private void assertRowSetMatches( String msg, Object[] expectedRow, RowSet outputRowSet ) { Object[] actualRow = outputRowSet.getRow(); Assert.assertEquals( msg + ". Output row is of an unexpected length", expectedRow.length, outputRowSet.getRowMeta() .size() ); for ( int i = 0; i < expectedRow.length; i++ ) { Assert.assertEquals( msg + ". Unexpected output value at index " + i, expectedRow[i], actualRow[i] ); } } }
private boolean isRowSetContainsValue( RowSet rowSet, Object[] allowed, Object[] illegal ) { boolean ok = true; Set<Object> yes = new HashSet<Object>(); yes.addAll( Arrays.asList( allowed ) ); Set<Object> no = new HashSet<Object>(); no.addAll( Arrays.asList( illegal ) ); for ( int i = 0; i < rowSet.size(); i++ ) { Object[] row = rowSet.getRow(); Object val = row[0]; ok = yes.contains( val ) && !no.contains( val ); if ( !ok ) { // this is not ok now return false; } } return ok; }
public RowSet getMockInputRowSet( final List<Object[]> rows ) { final AtomicInteger index = new AtomicInteger( 0 ); RowSet rowSet = mock( RowSet.class, Mockito.RETURNS_MOCKS ); Answer<Object[]> answer = new Answer<Object[]>() { @Override public Object[] answer( InvocationOnMock invocation ) throws Throwable { int i = index.getAndIncrement(); return i < rows.size() ? rows.get( i ) : null; } }; when( rowSet.getRowWait( anyLong(), any( TimeUnit.class ) ) ).thenAnswer( answer ); when( rowSet.getRow() ).thenAnswer( answer ); when( rowSet.isDone() ).thenAnswer( new Answer<Boolean>() { @Override public Boolean answer( InvocationOnMock invocation ) throws Throwable { return index.get() >= rows.size(); } } ); return rowSet; }
private boolean verifyOutput( Object[][] expectedRows, RowSet outputRowSet ) throws KettleValueException { if ( expectedRows.length == outputRowSet.size() ) { for ( Object[] expectedRow : expectedRows ) { Object[] row = outputRowSet.getRow(); if ( expectedRow.length == outputRowSet.getRowMeta().size() ) { for ( int j = 0; j < expectedRow.length; j++ ) { if ( !expectedRow[j].equals( outputRowSet.getRowMeta().getString( row, j ) ) ) { return false; } } return true; } } } return false; }
while ( ( rawReaderRow = data.readerRowSet.getRow() ) == null ) { if ( data.inputs.hasNext() && data.readerRowSet.isDone() ) { try ( InputStream nextIn = data.inputs.next() ) {
@Test public void testOutputDoneIfInputEmpty() throws Exception { Script step = new Script( helper.stepMeta, helper.stepDataInterface, 1, helper.transMeta, helper.trans ); step.init( helper.initStepMetaInterface, helper.initStepDataInterface ); RowSet rs = helper.getMockInputRowSet( new Object[ 0 ][ 0 ] ); List<RowSet> in = new ArrayList<RowSet>(); in.add( rs ); step.setInputRowSets( in ); TransTestingUtil.execute( step, helper.processRowsStepMetaInterface, helper.processRowsStepDataInterface, 0, true ); rs.getRow(); }
Object[] actualRow = outputRowSet.getRow(); Object[] expectedRow = new Object[] { null, null, d3, d4 };
baseStep.putRow( rowMeta1, objects1 ); assertEquals( object0, baseStep.getOutputRowSets().get( 0 ).getRow()[ 0 ] ); assertEquals( object1, baseStep.getOutputRowSets().get( 1 ).getRow()[ 0 ] ); assertEquals( object0, baseStep.getOutputRowSets().get( 2 ).getRow()[ 0 ] ); assertEquals( object1, baseStep.getOutputRowSets().get( 3 ).getRow()[ 0 ] );
Mockito.when( rowSet.getOriginStepCopy() ).thenReturn( 0 ); Mockito.when( rowSet.getDestinationStepCopy() ).thenReturn( 0 ); Mockito.when( rowSet.getRow() ).thenReturn( new String[] { values } ).thenReturn( null ); Mockito.when( rowSet.isDone() ).thenReturn( true ); RowMetaInterface allowedRowMeta = Mockito.mock( RowMetaInterface.class );
@Test public void testCacheAllTable() throws KettleException { DatabaseLookup stepSpy = spy( new DatabaseLookup( smh.stepMeta, smh.stepDataInterface, 0, smh.transMeta, smh.trans ) ); Database database = mockDatabase(); doReturn( database ).when( stepSpy ).getDatabase( any( DatabaseMeta.class ) ); stepSpy.addRowSetToInputRowSets( mockInputRowSet() ); stepSpy.setInputRowMeta( mockInputRowMeta() ); RowSet outputRowSet = new QueueRowSet(); stepSpy.addRowSetToOutputRowSets( outputRowSet ); StepMetaInterface meta = mockStepMeta(); StepDataInterface data = smh.initStepDataInterface; Assert.assertTrue( "Step init failed", stepSpy.init( meta, data ) ); Assert.assertTrue( "Error processing row", stepSpy.processRow( meta, data ) ); Assert.assertEquals( "Cache lookup failed", "value", outputRowSet.getRow()[2] ); } }
@Test public void test() throws KettleException { KettleEnvironment.init(); NullIf step = new NullIf( smh.stepMeta, smh.stepDataInterface, 0, smh.transMeta, smh.trans ); step.init( smh.initStepMetaInterface, smh.stepDataInterface ); step.setInputRowMeta( getInputRowMeta() ); step.addRowSetToInputRowSets( mockInputRowSet() ); step.addRowSetToOutputRowSets( new QueueRowSet() ); boolean hasMoreRows; do { hasMoreRows = step.processRow( mockProcessRowMeta(), smh.processRowsStepDataInterface ); } while ( hasMoreRows ); RowSet outputRowSet = step.getOutputRowSets().get( 0 ); Object[] actualRow = outputRowSet.getRow(); Object[] expectedRow = new Object[] { "value1", null, "value3" }; Assert.assertEquals( "Output row is of an unexpected length", expectedRow.length, outputRowSet.getRowMeta().size() ); for ( int i = 0; i < expectedRow.length; i++ ) { Assert.assertEquals( "Unexpected output value at index " + i, expectedRow[i], actualRow[i] ); } }
@Test public void processRow_NullsArePutIntoDefaultWhenNotSpecified() throws Exception { SwitchCaseCustom step = new SwitchCaseCustom( mockHelper ); step.meta.loadXML( loadStepXmlMetadata( "SwitchCaseTest_PDI-12671.xml" ), Collections.<DatabaseMeta>emptyList(), mock( IMetaStore.class ) ); List<RowSet> outputRowSets = new LinkedList<RowSet>(); for ( SwitchCaseTarget item : step.meta.getCaseTargets() ) { StepMetaInterface smInt = new DummyTransMeta(); item.caseTargetStep = new StepMeta( item.caseTargetStepname, smInt ); RowSet rw = new QueueRowSet(); step.map.put( item.caseTargetStepname, rw ); outputRowSets.add( rw ); } // create a default step StepMetaInterface smInt = new DummyTransMeta(); StepMeta stepMeta = new StepMeta( step.meta.getDefaultTargetStepname(), smInt ); step.meta.setDefaultTargetStep( stepMeta ); RowSet defaultRowSet = new QueueRowSet(); step.map.put( step.meta.getDefaultTargetStepname(), defaultRowSet ); step.input.add( new Object[] { null } ); step.processRow(); assertEquals( 1, defaultRowSet.size() ); for ( RowSet rowSet : outputRowSets ) { assertEquals( 0, rowSet.size() ); } assertNull( defaultRowSet.getRow()[0] ); }
private void doTest( boolean memoryPreservationActive, boolean binaryLookupStream, boolean binaryDataStream ) throws KettleException { StreamLookup step = new StreamLookup( smh.stepMeta, smh.stepDataInterface, 0, smh.transMeta, smh.trans ); step.init( smh.initStepMetaInterface, smh.initStepDataInterface ); step.addRowSetToInputRowSets( mockLookupRowSet( binaryLookupStream ) ); step.addRowSetToInputRowSets( mockDataRowSet( binaryDataStream ) ); step.addRowSetToOutputRowSets( new QueueRowSet() ); StreamLookupMeta meta = mockProcessRowMeta( memoryPreservationActive ); StreamLookupData data = new StreamLookupData(); data.readLookupValues = true; RowSet outputRowSet = step.getOutputRowSets().get( 0 ); // Process rows and collect output int rowNumber = 0; String[] expectedOutput = { "Name", "", "Value" }; while ( step.processRow( meta, data ) ) { Object[] rowData = outputRowSet.getRow(); if ( rowData != null ) { RowMetaInterface rowMeta = outputRowSet.getRowMeta(); Assert.assertEquals( "Output row is of wrong size", 3, rowMeta.size() ); rowNumber++; // Verify output for ( int valueIndex = 0; valueIndex < rowMeta.size(); valueIndex++ ) { String expectedValue = expectedOutput[valueIndex] + rowNumber; Object actualValue = rowMeta.getValueMeta( valueIndex ).convertToNormalStorageType( rowData[valueIndex] ); Assert.assertEquals( "Unexpected value at row " + rowNumber + " position " + valueIndex, expectedValue, actualValue ); } } } Assert.assertEquals( "Incorrect output row number", 2, rowNumber ); }
@Test public void testSplitFields() throws KettleException { FieldSplitter step = new FieldSplitter( smh.stepMeta, smh.stepDataInterface, 0, smh.transMeta, smh.trans ); step.init( smh.initStepMetaInterface, smh.stepDataInterface ); step.setInputRowMeta( getInputRowMeta() ); step.addRowSetToInputRowSets( mockInputRowSet() ); step.addRowSetToOutputRowSets( new QueueRowSet() ); boolean hasMoreRows; do { hasMoreRows = step.processRow( mockProcessRowMeta(), smh.processRowsStepDataInterface ); } while ( hasMoreRows ); RowSet outputRowSet = step.getOutputRowSets().get( 0 ); Object[] actualRow = outputRowSet.getRow(); Object[] expectedRow = new Object[] { "before", null, "b=b", "after" }; assertEquals( "Output row is of an unexpected length", expectedRow.length, outputRowSet.getRowMeta().size() ); for ( int i = 0; i < expectedRow.length; i++ ) { assertEquals( "Unexpected output value at index " + i, expectedRow[i], actualRow[i] ); } }
Object[] row = rs.getRow(); RowMetaInterface rm = rs.getRowMeta();
public IRubyObject read() throws KettleException { Object r[] = rs.getRow(); // signal that there's no more rows coming if (r == null) { return data.runtime.getNil(); } step.incrementLinesRead(); IRubyObject rubyRow = model.createRubyInputRow(rs.getRowMeta(), r); return rubyRow; }