test/org/apache/pig/parser/TestErrorHandling.java - pig - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package org.apache.pig.parser;

 import java.io.IOException;
 import java.util.Properties;

 import org.junit.Assert;

 import org.apache.pig.ExecType;
 import org.apache.pig.PigServer;
 import org.apache.pig.impl.logicalLayer.FrontendException;
 import org.apache.pig.impl.logicalLayer.validators.TypeCheckerException;
 import org.junit.Before;
 import org.junit.Test;

 public class TestErrorHandling {
     private PigServer pig = null;

     @Before
     public void setUp() throws Exception{
         pig = new PigServer(ExecType.LOCAL, new Properties());
         pig.setValidateEachStatement(true);
     }

     @Test // Error from SchemaAliasVisitor
     public void tesNegative1() {
         String query = "A = load 'x' as ( u:int, v:long, u:chararray, w:bytearray );";
         try {
             pig.registerQuery( query );
         } catch(Exception ex) {
             System.out.println( ex.getMessage() );
             Assert.assertTrue( ex.getMessage().contains( "line 1, column 33" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // Error from ColumnAliasConversionVisitor
     public void tesNegative2() {
         String query = "A = load 'x' as ( u:int, v:long, w );\n" +
                        "B = foreach A generate $5;";
         try {
             pig.registerQuery( query );
         } catch(Exception ex) {
             System.out.println( ex.getMessage() );
             Assert.assertTrue( ex.getMessage().contains( "line 2, column 23" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // Error from ASTValidator
     public void tesNegative3() throws IOException {
         String query = "A = load 'x';\n" +
                        "C = limit B 100;";
         try {
             pig.registerQuery( query );
         } catch(Exception ex) {
             System.out.println( ex.getMessage() );
             Assert.assertTrue( ex.getMessage().contains( "line 2, column 10" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // Type checking error
     public void tesNegative4() throws IOException {
         String query = "A = load 'x' as ( u:int, v:chararray );\n" +
                        "C = foreach A generate u + v;";
         try {
             pig.registerQuery( query );
         } catch(TypeCheckerException ex) {
             System.out.println( ex.getCause().getMessage() );
             Assert.assertTrue( ex.getCause().getMessage().contains( "line 2, column 25" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // Type checking lineage error message
     public void tesNegative5() throws IOException {
         String query = "a = load 'a' using PigStorage('a') as (field1, field2: float, field3: chararray );\n" +
                        "b = load 'b' using PigStorage('b') as (field4, field5, field6: chararray );\n" +
                        "c = cogroup a by *, b by * ;\n" +
                        "d = foreach c generate group, flatten($1), flatten($2);\n" +
                        "e = foreach d generate group + 1, field1 + 1, field4 + 2.0;";
         try {
             pig.registerQuery( query );
         } catch(TypeCheckerException ex) {
             System.out.println( ex.getCause().getMessage() );
             Assert.assertTrue( ex.getCause().getMessage().contains( "line 5, column 29" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // Error from ScalarAliasVisitor
     public void tesNegative6() {
         String query = "A = load 'x';\n" +
                        "B = load 'y' as ( u : int, v : chararray );\n" +
                        "C = foreach A generate B.w, $0;\n" +
                        "D = store C into 'output';\n";
         try {
             pig.registerQuery( query );
         } catch(Exception ex) {
             System.out.println( ex.getMessage() );
             Assert.assertTrue( ex.getMessage().contains( "line 3, column 23" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // Error from InputOutputFileVisitor
     public void tesNegative7() throws IOException {
         String query = "A = load 'x';\n" +
                        "store A into 'fs2you://output';\n";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
             System.out.println( ex.getCause().getMessage() );
             Assert.assertTrue( ex.getCause().getMessage().contains( "line 2, column 0" ) );
             Assert.assertTrue( ex.getCause().getMessage().contains( "No FileSystem for scheme: fs2you" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // Error from InputOutputFileVisitor
     public void tesNegative8() throws IOException {
         String query = "A = load 'x' as ( a : bag{ T:tuple(u, v) }, c : int, d : long );\n" +
                        "B = foreach A { S = c * 2; T = limit S 100; generate T; };\n" +
                        "store B into 'y';";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
             System.out.println( ex.getMessage() );
             Assert.assertTrue( ex.getMessage().contains( "line 2, column 37" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // PIG-1956, 1957
     public void tesNegative9() throws IOException {
 		pig.registerQuery("a = load 'temp' as (a0:int, a1:int);\n");
 		pig.registerQuery("b = group a by a0;\n");
 		try {
 			pig.registerQuery("c = foreach b { " +
 					" c1 = foreach a { " +
 					" c11 = filter a by a1 > 0; " +
 					" generate c11; " +
 					" } " +
 					" generate c1; " +
 			" }\n");
 		} catch (FrontendException ex) {
 			String msg = ex.getMessage();
 			Assert.assertTrue( msg.contains( "line 5, column 32" ) );
 			Assert.assertTrue( msg.contains( "mismatched input '{' expecting GENERATE"));
 			return;
 		}
         Assert.fail( "Testcase should fail" );
     }

     @Test
     public void tesNegative10() throws IOException {
         String query = "A = load 'x' as (u :int, v: chararray);\n" +
                        "B = load 'y';\n" +
                        "C = union onschema A, B;";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
             System.out.println( ex.getMessage() );
             Assert.assertTrue( ex.getMessage().contains( "line 3, column 4" ) );
             Assert.assertTrue( ex.getMessage().contains(
             		"UNION ONSCHEMA cannot be used with relations that have null schema" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // PIG-1961
     public void tesNegative11() throws IOException {
         String query = "A = load ^ 'x' as (name, age, gpa);\n";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
         	String msg = ex.getMessage();
             System.out.println( msg );
             Assert.assertFalse( msg.contains( "file null" ) );
             Assert.assertTrue( msg.contains( "Unexpected character" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // PIG-1961
     public void tesNegative12() throws IOException {
         String query = "A = loadd 'x' as (name, age, gpa);\n";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
         	String msg = ex.getMessage();
             System.out.println( msg );
             Assert.assertFalse( msg.contains( "file null" ) );
             Assert.assertTrue( msg.contains( "Syntax error, unexpected symbol at or near 'A'" ) );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test // PIG-1921
     public void tesNegative13() throws IOException {
         String query = "A = load 'x' as (u:int, v);\n" +
                        "B = load 'y';\n" +
                        "C = join A by u, B by w;";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
         	String msg = ex.getMessage();
             System.out.println( msg );
             Assert.assertTrue( !msg.contains( "null") );
             Assert.assertTrue( msg.contains( "Projected field [w] does not exist.") );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }


     @Test //pig-2606
     public void testNegative14() throws IOException {
         String query = "A = load 'x'; \n" +
                        "B = union A, A;";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
             String msg = ex.getMessage();
             System.out.println( msg );
             Assert.assertTrue( msg.contains( "Pig does not accept same alias as input for") );
             Assert.assertTrue( msg.contains( "UNION") );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test //pig-2606
     public void testNegative15() throws IOException {
         String query = "A = load 'x' as (a0, a1); \n" +
                        "B = join A by a0, A by a1;";
         try {
             pig.registerQuery( query );
         } catch(FrontendException ex) {
             String msg = ex.getMessage();
             System.out.println( msg );
             Assert.assertTrue( msg.contains( "Pig does not accept same alias as input for") );
             Assert.assertTrue( msg.contains( "JOIN") );
             return;
         }
         Assert.fail( "Testcase should fail" );
     }

     @Test //pig-2267
     public void testAutomaticallyGivenSchemaName1() throws IOException{
         String query = "a = load 'x' as (int,val_0);";
         String failMsg = "Duplicated alias in schema";
         shouldFailWithMessage(query,failMsg);
     }

     @Test //pig-2267
     public void testAutomaticallyGivenSchemaName2() throws IOException{
         String query = "a = load 'x' as ((int,int),tuple_0:tuple(int,int));";
         String failMsg = "Duplicated alias in schema";
         shouldFailWithMessage(query,failMsg);
     }

     @Test //pig-2267
     public void testAutomaticallyGivenSchemaName3() throws IOException{
         String query = "a = load 'x' as (tuple_0:tuple(int,int),(int,int));";
         String failMsg = "Duplicated alias in schema";
         shouldFailWithMessage(query,failMsg);
     }

     @Test //pig-2267
     public void testAutomaticallyGivenSchemaName4() throws IOException{
         String query = "a = load 'x' as (bag_0:bag{},{});";
         String failMsg = "Duplicated alias in schema";
         shouldFailWithMessage(query,failMsg);
     }

     @Test //pig-2267
     public void testAutomaticallyGivenSchemaName5() throws IOException{
         String query = "a = load 'x' as ([],map_0:map[]);";
         String failMsg = "Duplicated alias in schema";
         shouldFailWithMessage(query,failMsg);
     }

     @Test //pig-2267
     public void testAutomaticallyGivenSchemaName6() throws IOException{
         String query = "a = load 'x' as (int,int,int,val_3,val_2);";
         String failMsg = "Duplicated alias in schema";
         shouldFailWithMessage(query,failMsg);
     }

     public void shouldFailWithMessage(String query, String... messages) throws IOException {
         try {
             pig.registerQuery(query);
         } catch (Exception e) {
             String msg = e.getMessage();
             System.out.println(msg);
             for (String message : messages) {
                 Assert.assertTrue(msg.contains(message));
             }
             return;
         }
         Assert.fail("Testcase should fail");
     }

 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package org.apache.pig.parser;

	import java.io.IOException;
	import java.util.Properties;

	import org.junit.Assert;

	import org.apache.pig.ExecType;
	import org.apache.pig.PigServer;
	import org.apache.pig.impl.logicalLayer.FrontendException;
	import org.apache.pig.impl.logicalLayer.validators.TypeCheckerException;
	import org.junit.Before;
	import org.junit.Test;

	public class TestErrorHandling {
	private PigServer pig = null;

	@Before
	public void setUp() throws Exception{
	pig = new PigServer(ExecType.LOCAL, new Properties());
	pig.setValidateEachStatement(true);
	}

	@Test // Error from SchemaAliasVisitor
	public void tesNegative1() {
	String query = "A = load 'x' as ( u:int, v:long, u:chararray, w:bytearray );";
	try {
	pig.registerQuery( query );
	} catch(Exception ex) {
	System.out.println( ex.getMessage() );
	Assert.assertTrue( ex.getMessage().contains( "line 1, column 33" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // Error from ColumnAliasConversionVisitor
	public void tesNegative2() {
	String query = "A = load 'x' as ( u:int, v:long, w );\n" +
	"B = foreach A generate $5;";
	try {
	pig.registerQuery( query );
	} catch(Exception ex) {
	System.out.println( ex.getMessage() );
	Assert.assertTrue( ex.getMessage().contains( "line 2, column 23" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // Error from ASTValidator
	public void tesNegative3() throws IOException {
	String query = "A = load 'x';\n" +
	"C = limit B 100;";
	try {
	pig.registerQuery( query );
	} catch(Exception ex) {
	System.out.println( ex.getMessage() );
	Assert.assertTrue( ex.getMessage().contains( "line 2, column 10" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // Type checking error
	public void tesNegative4() throws IOException {
	String query = "A = load 'x' as ( u:int, v:chararray );\n" +
	"C = foreach A generate u + v;";
	try {
	pig.registerQuery( query );
	} catch(TypeCheckerException ex) {
	System.out.println( ex.getCause().getMessage() );
	Assert.assertTrue( ex.getCause().getMessage().contains( "line 2, column 25" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // Type checking lineage error message
	public void tesNegative5() throws IOException {
	String query = "a = load 'a' using PigStorage('a') as (field1, field2: float, field3: chararray );\n" +
	"b = load 'b' using PigStorage('b') as (field4, field5, field6: chararray );\n" +
	"c = cogroup a by , b by ;\n" +
	"d = foreach c generate group, flatten($1), flatten($2);\n" +
	"e = foreach d generate group + 1, field1 + 1, field4 + 2.0;";
	try {
	pig.registerQuery( query );
	} catch(TypeCheckerException ex) {
	System.out.println( ex.getCause().getMessage() );
	Assert.assertTrue( ex.getCause().getMessage().contains( "line 5, column 29" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // Error from ScalarAliasVisitor
	public void tesNegative6() {
	String query = "A = load 'x';\n" +
	"B = load 'y' as ( u : int, v : chararray );\n" +
	"C = foreach A generate B.w, $0;\n" +
	"D = store C into 'output';\n";
	try {
	pig.registerQuery( query );
	} catch(Exception ex) {
	System.out.println( ex.getMessage() );
	Assert.assertTrue( ex.getMessage().contains( "line 3, column 23" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // Error from InputOutputFileVisitor
	public void tesNegative7() throws IOException {
	String query = "A = load 'x';\n" +
	"store A into 'fs2you://output';\n";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	System.out.println( ex.getCause().getMessage() );
	Assert.assertTrue( ex.getCause().getMessage().contains( "line 2, column 0" ) );
	Assert.assertTrue( ex.getCause().getMessage().contains( "No FileSystem for scheme: fs2you" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // Error from InputOutputFileVisitor
	public void tesNegative8() throws IOException {
	String query = "A = load 'x' as ( a : bag{ T:tuple(u, v) }, c : int, d : long );\n" +
	"B = foreach A { S = c * 2; T = limit S 100; generate T; };\n" +
	"store B into 'y';";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	System.out.println( ex.getMessage() );
	Assert.assertTrue( ex.getMessage().contains( "line 2, column 37" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // PIG-1956, 1957
	public void tesNegative9() throws IOException {
	pig.registerQuery("a = load 'temp' as (a0:int, a1:int);\n");
	pig.registerQuery("b = group a by a0;\n");
	try {
	pig.registerQuery("c = foreach b { " +
	" c1 = foreach a { " +
	" c11 = filter a by a1 > 0; " +
	" generate c11; " +
	" } " +
	" generate c1; " +
	" }\n");
	} catch (FrontendException ex) {
	String msg = ex.getMessage();
	Assert.assertTrue( msg.contains( "line 5, column 32" ) );
	Assert.assertTrue( msg.contains( "mismatched input '{' expecting GENERATE"));
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test
	public void tesNegative10() throws IOException {
	String query = "A = load 'x' as (u :int, v: chararray);\n" +
	"B = load 'y';\n" +
	"C = union onschema A, B;";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	System.out.println( ex.getMessage() );
	Assert.assertTrue( ex.getMessage().contains( "line 3, column 4" ) );
	Assert.assertTrue( ex.getMessage().contains(
	"UNION ONSCHEMA cannot be used with relations that have null schema" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // PIG-1961
	public void tesNegative11() throws IOException {
	String query = "A = load ^ 'x' as (name, age, gpa);\n";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	String msg = ex.getMessage();
	System.out.println( msg );
	Assert.assertFalse( msg.contains( "file null" ) );
	Assert.assertTrue( msg.contains( "Unexpected character" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // PIG-1961
	public void tesNegative12() throws IOException {
	String query = "A = loadd 'x' as (name, age, gpa);\n";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	String msg = ex.getMessage();
	System.out.println( msg );
	Assert.assertFalse( msg.contains( "file null" ) );
	Assert.assertTrue( msg.contains( "Syntax error, unexpected symbol at or near 'A'" ) );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test // PIG-1921
	public void tesNegative13() throws IOException {
	String query = "A = load 'x' as (u:int, v);\n" +
	"B = load 'y';\n" +
	"C = join A by u, B by w;";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	String msg = ex.getMessage();
	System.out.println( msg );
	Assert.assertTrue( !msg.contains( "null") );
	Assert.assertTrue( msg.contains( "Projected field [w] does not exist.") );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}


	@Test //pig-2606
	public void testNegative14() throws IOException {
	String query = "A = load 'x'; \n" +
	"B = union A, A;";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	String msg = ex.getMessage();
	System.out.println( msg );
	Assert.assertTrue( msg.contains( "Pig does not accept same alias as input for") );
	Assert.assertTrue( msg.contains( "UNION") );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test //pig-2606
	public void testNegative15() throws IOException {
	String query = "A = load 'x' as (a0, a1); \n" +
	"B = join A by a0, A by a1;";
	try {
	pig.registerQuery( query );
	} catch(FrontendException ex) {
	String msg = ex.getMessage();
	System.out.println( msg );
	Assert.assertTrue( msg.contains( "Pig does not accept same alias as input for") );
	Assert.assertTrue( msg.contains( "JOIN") );
	return;
	}
	Assert.fail( "Testcase should fail" );
	}

	@Test //pig-2267
	public void testAutomaticallyGivenSchemaName1() throws IOException{
	String query = "a = load 'x' as (int,val_0);";
	String failMsg = "Duplicated alias in schema";
	shouldFailWithMessage(query,failMsg);
	}

	@Test //pig-2267
	public void testAutomaticallyGivenSchemaName2() throws IOException{
	String query = "a = load 'x' as ((int,int),tuple_0:tuple(int,int));";
	String failMsg = "Duplicated alias in schema";
	shouldFailWithMessage(query,failMsg);
	}

	@Test //pig-2267
	public void testAutomaticallyGivenSchemaName3() throws IOException{
	String query = "a = load 'x' as (tuple_0:tuple(int,int),(int,int));";
	String failMsg = "Duplicated alias in schema";
	shouldFailWithMessage(query,failMsg);
	}

	@Test //pig-2267
	public void testAutomaticallyGivenSchemaName4() throws IOException{
	String query = "a = load 'x' as (bag_0:bag{},{});";
	String failMsg = "Duplicated alias in schema";
	shouldFailWithMessage(query,failMsg);
	}

	@Test //pig-2267
	public void testAutomaticallyGivenSchemaName5() throws IOException{
	String query = "a = load 'x' as ([],map_0:map[]);";
	String failMsg = "Duplicated alias in schema";
	shouldFailWithMessage(query,failMsg);
	}

	@Test //pig-2267
	public void testAutomaticallyGivenSchemaName6() throws IOException{
	String query = "a = load 'x' as (int,int,int,val_3,val_2);";
	String failMsg = "Duplicated alias in schema";
	shouldFailWithMessage(query,failMsg);
	}

	public void shouldFailWithMessage(String query, String... messages) throws IOException {
	try {
	pig.registerQuery(query);
	} catch (Exception e) {
	String msg = e.getMessage();
	System.out.println(msg);
	for (String message : messages) {
	Assert.assertTrue(msg.contains(message));
	}
	return;
	}
	Assert.fail("Testcase should fail");
	}

	}