/** Test case for injector step... also a show case on how to use injector. */ public void testInjector() throws Exception { KettleEnvironment.init(); // // Create a new transformation... // TransMeta transMeta = new TransMeta(); transMeta.setName("injectortest"); PluginRegistry registry = PluginRegistry.getInstance(); // // create an injector step... // String injectorStepname = "injector step"; InjectorMeta im = new InjectorMeta(); // Set the information of the injector. String injectorPid = registry.getPluginId(StepPluginType.class, im); StepMeta injectorStep = new StepMeta(injectorPid, injectorStepname, (StepMetaInterface) im); transMeta.addStep(injectorStep); // // Create a dummy step // String dummyStepname = "dummy step"; DummyTransMeta dm = new DummyTransMeta(); String dummyPid = registry.getPluginId(StepPluginType.class, dm); StepMeta dummyStep = new StepMeta(dummyPid, dummyStepname, (StepMetaInterface) dm); transMeta.addStep(dummyStep); TransHopMeta hi = new TransHopMeta(injectorStep, dummyStep); transMeta.addTransHop(hi); // Now execute the transformation... Trans trans = new Trans(transMeta); trans.prepareExecution(null); StepInterface si = trans.getStepInterface(dummyStepname, 0); RowStepCollector rc = new RowStepCollector(); si.addRowListener(rc); RowProducer rp = trans.addRowProducer(injectorStepname, 0); trans.startThreads(); // add rows List<RowMetaAndData> inputList = createData(); for (RowMetaAndData rm : inputList) { rp.putRow(rm.getRowMeta(), rm.getData()); } rp.finished(); trans.waitUntilFinished(); List<RowMetaAndData> resultRows = rc.getRowsWritten(); checkRows(resultRows, inputList); }
/** Test case for Constant step. Row generator attached to a constant step. */ public void testConstant1() throws Exception { KettleEnvironment.init(); // // Create a new transformation... // TransMeta transMeta = new TransMeta(); transMeta.setName("constanttest1"); PluginRegistry registry = PluginRegistry.getInstance(); // // create a row generator step... // String rowGeneratorStepname = "row generator step"; RowGeneratorMeta rm = new RowGeneratorMeta(); // Set the information of the row generator. String rowGeneratorPid = registry.getPluginId(StepPluginType.class, rm); StepMeta rowGeneratorStep = new StepMeta(rowGeneratorPid, rowGeneratorStepname, (StepMetaInterface) rm); transMeta.addStep(rowGeneratorStep); // // Generate 1 empty row // String fieldName[] = {}; String type[] = {}; String value[] = {}; String fieldFormat[] = {}; String group[] = {}; String decimal[] = {}; int intDummies[] = {}; rm.setDefault(); rm.setFieldName(fieldName); rm.setFieldType(type); rm.setValue(value); rm.setFieldLength(intDummies); rm.setFieldPrecision(intDummies); rm.setRowLimit("1"); rm.setFieldFormat(fieldFormat); rm.setGroup(group); rm.setDecimal(decimal); // // Add constant step. // String constStepname1 = "constant 1"; ConstantMeta cnst1 = new ConstantMeta(); String fieldName1[] = { "boolean1", "boolean2", "boolean3", "boolean4", "boolean5", "boolean6", "boolean7", "string1", "string2", "string3", "integer1", "integer2", "integer3", "integer4", "number1", "number2", "number3", "number4", }; String type1[] = { "boolean", "Boolean", "bOOLEAN", "BOOLEAN", "boolean", "boolean", "boolean", "string", "string", "String", "integer", "integer", "integer", "integer", "number", "number", "number", "number" }; String value1[] = { "Y", "T", "a", "TRUE", "0", "9", "", "AAAAAAAAAAAAAA", " ", "", "-100", "0", "212", "", "-100.2", "0.0", "212.23", "" }; String fieldFormat1[] = { "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "" }; String group1[] = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", ",", ",", ",", ","}; String decimal1[] = { "", "", "", "", "", "", "", "", "", "", "", "", "", "", ".", ".", ".", "." }; String currency[] = {"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""}; int intDummies1[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; cnst1.setFieldName(fieldName1); cnst1.setFieldType(type1); cnst1.setValue(value1); cnst1.setFieldLength(intDummies1); cnst1.setFieldPrecision(intDummies1); cnst1.setFieldFormat(fieldFormat1); cnst1.setGroup(group1); cnst1.setDecimal(decimal1); cnst1.setCurrency(currency); String addSeqPid1 = registry.getPluginId(StepPluginType.class, cnst1); StepMeta addSeqStep1 = new StepMeta(addSeqPid1, constStepname1, (StepMetaInterface) cnst1); transMeta.addStep(addSeqStep1); TransHopMeta hi1 = new TransHopMeta(rowGeneratorStep, addSeqStep1); transMeta.addTransHop(hi1); // Now execute the transformation... Trans trans = new Trans(transMeta); trans.prepareExecution(null); StepInterface si = trans.getStepInterface(constStepname1, 0); RowStepCollector endRc = new RowStepCollector(); si.addRowListener(endRc); trans.startThreads(); trans.waitUntilFinished(); // Now check whether the output is still as we expect. List<RowMetaAndData> goldenImageRows = createResultData1(); List<RowMetaAndData> resultRows1 = endRc.getRowsWritten(); checkRows(resultRows1, goldenImageRows); }
public void testCalculator1() throws Exception { KettleEnvironment.init(); PluginRegistry registry = PluginRegistry.getInstance(); // // Create a new transformation... // TransMeta transMeta = new TransMeta(); transMeta.setName("calculatortest1"); // // create a row generator step... // String rowGeneratorStepname = "row generator step"; RowGeneratorMeta rm = new RowGeneratorMeta(); // Set the information of the row generator. String rowGeneratorPid = registry.getPluginId(StepPluginType.class, rm); StepMeta rowGeneratorStep = new StepMeta(rowGeneratorPid, rowGeneratorStepname, rm); transMeta.addStep(rowGeneratorStep); // // Generate 1 empty row // String[] strDummies = {}; int[] intDummies = {}; rm.setDefault(); rm.setFieldName(strDummies); rm.setFieldType(strDummies); rm.setValue(strDummies); rm.setFieldLength(intDummies); rm.setFieldPrecision(intDummies); rm.setRowLimit("1"); rm.setFieldFormat(strDummies); rm.setGroup(strDummies); rm.setDecimal(strDummies); // // Add calculator step. // String calculatorStepname1 = "calculator 1"; CalculatorMeta calc1 = new CalculatorMeta(); CalculatorMetaFunction[] calculations = new CalculatorMetaFunction[] { new CalculatorMetaFunction( "timestamp1", // fieldName CalculatorMetaFunction.CALC_CONSTANT, // calctype "1970-01-01 00:00:00.100100", // fieldA "", // String fieldB "", // String fieldC ValueMetaInterface.TYPE_TIMESTAMP, // valueType, 0, // int valueLength, 0, // int valuePrecision, false, // boolean removedFromResult, "", // String conversionMask, "", // String decimalSymbol, "", // String groupingSymbol, "" // String currencySymbol ), new CalculatorMetaFunction( "int1", // fieldName CalculatorMetaFunction.CALC_CONSTANT, // calctype "1", // fieldA "", // String fieldB "", // String fieldC ValueMetaInterface.TYPE_INTEGER, // valueType, 0, // int valueLength, 0, // int valuePrecision, false, // boolean removedFromResult, "", // String conversionMask, "", // String decimalSymbol, "", // String groupingSymbol, "" // String currencySymbol ), new CalculatorMetaFunction( "timestamp plus 1 day", // fieldName CalculatorMetaFunction.CALC_ADD_DAYS, // calctype "timestamp1", // fieldA "int1", // String fieldB "", // String fieldC ValueMetaInterface.TYPE_DATE, // valueType, 0, // int valueLength, 0, // int valuePrecision, false, // boolean removedFromResult, "", // String conversionMask, "", // String decimalSymbol, "", // String groupingSymbol, "" // String currencySymbol ) }; calc1.setCalculation(calculations); // String calculatorPid1 = registry.getPluginId(StepPluginType.class, calc1); StepMeta calcualtorStep1 = new StepMeta(calculatorPid1, calculatorStepname1, calc1); transMeta.addStep(calcualtorStep1); // TransHopMeta hi1 = new TransHopMeta(rowGeneratorStep, calcualtorStep1); transMeta.addTransHop(hi1); // Now execute the transformation... Trans trans = new Trans(transMeta); trans.prepareExecution(null); StepInterface si = trans.getStepInterface(calculatorStepname1, 0); RowStepCollector endRc = new RowStepCollector(); si.addRowListener(endRc); trans.startThreads(); trans.waitUntilFinished(); // Now check whether the output is still as we expect. List<RowMetaAndData> goldenImageRows = createResultData1(); List<RowMetaAndData> resultRows1 = endRc.getRowsWritten(); checkRows(resultRows1, goldenImageRows); }
/** Test case for janino step. */ public void testJaninoStep() throws Exception { KettleEnvironment.init(); // // Create a new transformation... // TransMeta transMeta = new TransMeta(); transMeta.setName("janino test"); PluginRegistry registry = PluginRegistry.getInstance(); // create an injector step... String injectorStepName = "injector step"; InjectorMeta im = new InjectorMeta(); // Set the information of the injector. String injectorPid = registry.getPluginId(StepPluginType.class, im); StepMeta injectorStep = new StepMeta(injectorPid, injectorStepName, im); transMeta.addStep(injectorStep); // // create a janino step... // String stepname = "janino"; JaninoMeta jm = new JaninoMeta(); // Set the information of the step String janinoPid = registry.getPluginId(StepPluginType.class, jm); StepMeta janinoStep = new StepMeta(janinoPid, stepname, jm); transMeta.addStep(janinoStep); jm.setDefault(); JaninoMetaFunction[] formulas = { new JaninoMetaFunction( "string", "(string==null)?null:\"string-value\"", ValueMeta.TYPE_STRING, -1, -1, "string"), new JaninoMetaFunction( "integer", "(integer==null)?null:new Long(42L)", ValueMeta.TYPE_INTEGER, -1, -1, "integer"), new JaninoMetaFunction( "number", "(number==null)?null:new Double(23.0)", ValueMeta.TYPE_NUMBER, -1, -1, "number"), new JaninoMetaFunction( "bigdecimal", "(bigdecimal==null)?null:new java.math.BigDecimal(11.0)", ValueMeta.TYPE_BIGNUMBER, -1, -1, "bigdecimal"), new JaninoMetaFunction( "date", "(date==null)?null:new java.util.Date(10000000)", ValueMeta.TYPE_DATE, -1, -1, "date"), new JaninoMetaFunction( "binary", "(binary==null)?null:new byte[]{1,2,3,4,5}", ValueMeta.TYPE_BINARY, -1, -1, "binary"), new JaninoMetaFunction( "bool", "(bool==null)?null:Boolean.TRUE", ValueMeta.TYPE_BOOLEAN, -1, -1, "bool"), }; jm.setFormula(formulas); transMeta.addTransHop(new TransHopMeta(injectorStep, janinoStep)); // // Create a dummy step // String dummyStepname = "dummy step"; DummyTransMeta dm = new DummyTransMeta(); String dummyPid = registry.getPluginId(StepPluginType.class, dm); StepMeta dummyStep = new StepMeta(dummyPid, dummyStepname, dm); transMeta.addStep(dummyStep); TransHopMeta hi = new TransHopMeta(janinoStep, dummyStep); transMeta.addTransHop(hi); // Now execute the transformation... Trans trans = new Trans(transMeta); trans.prepareExecution(null); StepInterface si = trans.getStepInterface(dummyStepname, 0); RowStepCollector rc = new RowStepCollector(); si.addRowListener(rc); RowProducer rp = trans.addRowProducer(injectorStepName, 0); trans.startThreads(); for (RowMetaAndData rm : createInputList()) { rp.putRow(rm.getRowMeta(), rm.getData()); } rp.finished(); trans.waitUntilFinished(); List<RowMetaAndData> checkList = createExpectedList(); List<RowMetaAndData> resultRows = rc.getRowsWritten(); checkRows(resultRows, checkList); }