@Test public void testBaseStepGetLogLevelWontThrowNPEWithNullLog() { when( mockHelper.logChannelInterfaceFactory.create( any(), any( LoggingObjectInterface.class ) ) ).thenAnswer( new Answer<LogChannelInterface>() { @Override public LogChannelInterface answer( InvocationOnMock invocation ) throws Throwable { ( (BaseStep) invocation.getArguments()[ 0 ] ).getLogLevel(); return mockHelper.logChannelInterface; } } ); new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ) .getLogLevel(); }
@Test public void testCleanup() throws IOException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); ServerSocket serverSocketMock = mock( ServerSocket.class ); doReturn( 0 ).when( serverSocketMock ).getLocalPort(); baseStep.setServerSockets( Collections.singletonList( serverSocketMock ) ); SocketRepository socketRepositoryMock = mock( SocketRepository.class ); baseStep.setSocketRepository( socketRepositoryMock ); baseStep.cleanup(); verify( socketRepositoryMock ).releaseSocket( 0 ); }
@Test public void putRowWithRowHandler() throws KettleException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandler ); RowMetaInterface rowMetaInterface = mock( RowMetaInterface.class ); Object[] objects = new Object[] { "foo", "bar" }; baseStep.putRow( rowMetaInterface, objects ); verify( rowHandler, times( 1 ) ).putRow( rowMetaInterface, objects ); }
@Test public void resultFilesMapIsSafeForConcurrentModification() throws Exception { final BaseStep step = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans );
@Test public void putErrorWithRowHandler() throws KettleException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandler ); RowMetaInterface rowMetaInterface = mock( RowMetaInterface.class ); Object[] objects = new Object[] { "foo", "bar" }; baseStep.putError( rowMetaInterface, objects, 3l, "desc", "field1,field2", "errorCode" ); verify( rowHandler, times( 1 ) ).putError( rowMetaInterface, objects, 3l, "desc", "field1,field2", "errorCode" ); }
@Test public void testCleanupWithInexistentRemoteSteps() throws IOException { BaseStep baseStep = spy( new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ) ); ServerSocket serverSocketMock = mock( ServerSocket.class ); doReturn( 0 ).when( serverSocketMock ).getLocalPort(); baseStep.setServerSockets( Collections.singletonList( serverSocketMock ) ); SocketRepository socketRepositoryMock = mock( SocketRepository.class ); baseStep.setSocketRepository( socketRepositoryMock ); RemoteStep inputStep = mock( RemoteStep.class ); doReturn( Collections.singletonList( inputStep ) ).when( baseStep ).getRemoteInputSteps(); RemoteStep outputStep = mock( RemoteStep.class ); doReturn( Collections.singletonList( outputStep ) ).when( baseStep ).getRemoteOutputSteps(); baseStep.cleanup(); verify( inputStep ).cleanup(); verify( outputStep ).cleanup(); verify( socketRepositoryMock ).releaseSocket( 0 ); }
@Test public void getRowWithRowHandler() throws KettleException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandler ); baseStep.getRow(); verify( rowHandler, times( 1 ) ).getRow(); }
/** * Row listeners collection modifiers are exposed out of BaseStep class, * whereas the collection traversal is happening on every row being processed. * * We should be sure that modification of the collection will not throw a concurrent modification exception. */ @Test public void testRowListeners() throws Exception { int modifiersAmount = 100; int traversersAmount = 100; StepMeta stepMeta = mock( StepMeta.class); TransMeta transMeta = mock( TransMeta.class); when( stepMeta.getName() ).thenReturn( STEP_META ); when( transMeta.findStep( STEP_META ) ).thenReturn( stepMeta ); when( stepMeta.getTargetStepPartitioningMeta() ).thenReturn( mock( StepPartitioningMeta.class ) ); baseStep = new BaseStep( stepMeta, null, 0, transMeta, mock( Trans.class ) ); AtomicBoolean condition = new AtomicBoolean( true ); List<RowListenersModifier> rowListenersModifiers = new ArrayList<>(); for ( int i = 0; i < modifiersAmount; i++ ) { rowListenersModifiers.add( new RowListenersModifier( condition ) ); } List<RowListenersTraverser> rowListenersTraversers = new ArrayList<>(); for ( int i = 0; i < traversersAmount; i++ ) { rowListenersTraversers.add( new RowListenersTraverser( condition ) ); } ConcurrencyTestRunner<?, ?> runner = new ConcurrencyTestRunner<Object, Object>(rowListenersModifiers, rowListenersTraversers, condition ); runner.runConcurrentTest(); runner.checkNoExceptionRaised(); }
/** * Row sets collection modifiers are exposed out of BaseStep class, * whereas the collection traversal is happening on every row being processed. * * We should be sure that modification of the collection will not throw a concurrent modification exception. */ @Test public void testInputOutputRowSets() throws Exception { int modifiersAmount = 100; int traversersAmount = 100; StepMeta stepMeta = mock( StepMeta.class); TransMeta transMeta = mock( TransMeta.class); when( stepMeta.getName() ).thenReturn( STEP_META ); when( transMeta.findStep( STEP_META ) ).thenReturn( stepMeta ); when( stepMeta.getTargetStepPartitioningMeta() ).thenReturn( mock( StepPartitioningMeta.class ) ); baseStep = new BaseStep( stepMeta, null, 0, transMeta, mock( Trans.class ) ); AtomicBoolean condition = new AtomicBoolean( true ); List<RowSetsModifier> rowSetsModifiers = new ArrayList<>(); for ( int i = 0; i < modifiersAmount; i++ ) { rowSetsModifiers.add( new RowSetsModifier( condition ) ); } List<RowSetsTraverser> rowSetsTraversers = new ArrayList<>(); for ( int i = 0; i < traversersAmount; i++ ) { rowSetsTraversers.add( new RowSetsTraverser( condition ) ); } ConcurrencyTestRunner<?, ?> runner = new ConcurrencyTestRunner<Object, Object>(rowSetsModifiers, rowSetsTraversers, condition ); runner.runConcurrentTest(); runner.checkNoExceptionRaised(); }
new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans );
@Test public void putGetFromPutToDefaultRowHandlerMethods() throws KettleException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandlerWithDefaultMethods() ); RowMetaInterface rowMetaInterface = mock( RowMetaInterface.class ); Object[] objects = new Object[] { "foo", "bar" }; try { baseStep.putRowTo( rowMetaInterface, objects, new QueueRowSet() ); fail( "Expected default exception for putRowTo" ); } catch ( UnsupportedOperationException uoe ) { assertThat( uoe.getMessage(), containsString( this.getClass().getName() ) ); } try { baseStep.getRowFrom( new QueueRowSet() ); fail( "Expected default exception for getRowFrom" ); } catch ( UnsupportedOperationException uoe ) { assertThat( uoe.getMessage(), containsString( this.getClass().getName() ) ); } }
@Test public void testGetRowSafeModeEnabled() throws KettleException { Trans transMock = mock( Trans.class ); when( transMock.isSafeModeEnabled() ).thenReturn( true ); BaseStep baseStepSpy = spy( new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, transMock ) ); doNothing().when( baseStepSpy ).waitUntilTransformationIsStarted(); doNothing().when( baseStepSpy ).openRemoteInputStepSocketsOnce(); BlockingRowSet rowSet = new BlockingRowSet( 1 ); List<ValueMetaInterface> valueMetaList = Arrays.asList( new ValueMetaInteger( "x" ), new ValueMetaString( "a" ) ); RowMeta rowMeta = new RowMeta(); rowMeta.setValueMetaList( valueMetaList ); final Object[] row = new Object[] {}; rowSet.putRow( rowMeta, row ); baseStepSpy.setInputRowSets( Arrays.asList( rowSet ) ); doReturn( rowSet ).when( baseStepSpy ).currentInputStream(); baseStepSpy.getRow(); verify( mockHelper.transMeta, times( 1 ) ).checkRowMixingStatically( any( StepMeta.class ), anyObject() ); } }
@Test public void notEmptyFieldName() throws KettleStepException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandler ); RowMetaInterface rowMeta = new RowMeta(); rowMeta.addValueMeta( new ValueMetaBase( "name", ValueMetaInterface.TYPE_INTEGER ) ); baseStep.putRow( rowMeta, new Object[] { 0 } ); }
new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setStopped( false ); baseStep.setRepartitioning( StepPartitioningMeta.PARTITIONING_METHOD_SPECIAL );
@Test( expected = KettleStepException.class ) public void nullFieldName() throws KettleStepException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandler ); RowMetaInterface rowMeta = new RowMeta(); rowMeta.addValueMeta( new ValueMetaBase( null, ValueMetaInterface.TYPE_INTEGER ) ); baseStep.putRow( rowMeta, new Object[] { 0 } ); }
@Test( expected = KettleStepException.class ) public void emptyFieldName() throws KettleStepException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandler ); RowMetaInterface rowMeta = new RowMeta(); rowMeta.addValueMeta( new ValueMetaBase( "", ValueMetaInterface.TYPE_INTEGER ) ); baseStep.putRow( rowMeta, new Object[] { 0 } ); }
@Test( expected = KettleStepException.class ) public void blankFieldName() throws KettleStepException { BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setRowHandler( rowHandler ); RowMetaInterface rowMeta = new RowMeta(); rowMeta.addValueMeta( new ValueMetaBase( " ", ValueMetaInterface.TYPE_INTEGER ) ); baseStep.putRow( rowMeta, new Object[] { 0 } ); }
@Test public void testBuildLog() throws KettleValueException { BaseStep testObject = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); Date startDate = new Date( (long) 123 ); Date endDate = new Date( (long) 125 ); RowMetaAndData result = testObject.buildLog( "myStepName", 13, 123, 234, 345, 456, 567, startDate, endDate ); assertNotNull( result ); assertEquals( 9, result.size() ); assertEquals( ValueMetaInterface.TYPE_STRING, result.getValueMeta( 0 ).getType() ); assertEquals( "myStepName", result.getString( 0, "default" ) ); assertEquals( ValueMetaInterface.TYPE_NUMBER, result.getValueMeta( 1 ).getType() ); assertEquals( new Double( 13.0 ), Double.valueOf( result.getNumber( 1, 0.1 ) ) ); assertEquals( ValueMetaInterface.TYPE_NUMBER, result.getValueMeta( 2 ).getType() ); assertEquals( new Double( 123 ), Double.valueOf( result.getNumber( 2, 0.1 ) ) ); assertEquals( ValueMetaInterface.TYPE_NUMBER, result.getValueMeta( 3 ).getType() ); assertEquals( new Double( 234 ), Double.valueOf( result.getNumber( 3, 0.1 ) ) ); assertEquals( ValueMetaInterface.TYPE_NUMBER, result.getValueMeta( 4 ).getType() ); assertEquals( new Double( 345 ), Double.valueOf( result.getNumber( 4, 0.1 ) ) ); assertEquals( ValueMetaInterface.TYPE_NUMBER, result.getValueMeta( 5 ).getType() ); assertEquals( new Double( 456 ), Double.valueOf( result.getNumber( 5, 0.1 ) ) ); assertEquals( ValueMetaInterface.TYPE_NUMBER, result.getValueMeta( 6 ).getType() ); assertEquals( new Double( 567 ), Double.valueOf( result.getNumber( 6, 0.1 ) ) ); assertEquals( ValueMetaInterface.TYPE_DATE, result.getValueMeta( 7 ).getType() ); assertEquals( startDate, result.getDate( 7, Calendar.getInstance().getTime() ) ); assertEquals( ValueMetaInterface.TYPE_DATE, result.getValueMeta( 8 ).getType() ); assertEquals( endDate, result.getDate( 8, Calendar.getInstance().getTime() ) ); }
@Test public void outputRowMetasAreNotSharedAmongSeveralStreams() throws Exception { RowSet rs1 = new SingleRowRowSet(); RowSet rs2 = new SingleRowRowSet(); when( mockHelper.trans.isRunning() ).thenReturn( true ); BaseStep baseStep = new BaseStep( mockHelper.stepMeta, mockHelper.stepDataInterface, 0, mockHelper.transMeta, mockHelper.trans ); baseStep.setStopped( false ); baseStep.setRepartitioning( StepPartitioningMeta.PARTITIONING_METHOD_NONE ); baseStep.setOutputRowSets( Arrays.asList( rs1, rs2 ) ); for ( RowSet rowSet : baseStep.getOutputRowSets() ) { assertNull( "RowMeta should be null, since no calls were done", rowSet.getRowMeta() ); } RowMetaInterface rowMeta = new RowMeta(); rowMeta.addValueMeta( new ValueMetaString( "string" ) ); rowMeta.addValueMeta( new ValueMetaInteger( "integer" ) ); baseStep.putRow( rowMeta, new Object[] { "a", 1 } ); RowMetaInterface meta1 = rs1.getRowMeta(); RowMetaInterface meta2 = rs2.getRowMeta(); assertNotNull( meta1 ); assertNotNull( meta2 ); // content is same for ( ValueMetaInterface meta : meta1.getValueMetaList() ) { assertTrue( meta.getName(), meta2.exists( meta ) ); } // whereas instances differ assertFalse( meta1 == meta2 ); }