From de8e92769986b927b8241a2933bc2e042dda81f7 Mon Sep 17 00:00:00 2001 From: mbatchelor Date: Wed, 25 May 2016 12:54:30 -0400 Subject: [PATCH] [TEST] - Additional load/save tests --- .../steps/multimerge/MultiMergeJoinMeta.java | 45 +++++-- .../PGPDecryptStreamMeta.java | 39 +++++- .../PGPEncryptStreamMeta.java | 35 ++++- .../textfileinput/TextFileInputField.java | 13 ++ .../multimerge/MultiMergeJoinMetaTest.java | 58 ++++++++- .../MySQLBulkLoaderMetaTest.java | 3 +- .../steps/normaliser/NormaliserMetaTest.java | 108 +++++++++++++++ .../di/trans/steps/nullif/NullIfMetaTest.java | 1 - .../numberrange/NumberRangeMetaTest.java | 33 +++-- .../steps/olapinput/OlapInputMetaTest.java | 3 +- .../orabulkloader/OraBulkLoaderMetaTest.java | 9 +- .../ParGzipCsvInputMetaTest.java | 123 +++++++++++++++--- ...entahoReportingOutputMetaLoadSaveTest.java | 89 +++++++++++++ .../pgbulkloader/PGBulkLoaderMetaTest.java | 9 +- .../PGPDecryptStreamMetaTest.java | 63 +++++++++ .../PGPEncryptStreamMetaTest.java | 64 +++++++++ .../PrioritizeStreamsMetaTest.java | 14 +- .../processfiles/ProcessFilesMetaTest.java | 74 +++++++++++ .../PropertyOutputMetaTest.java | 75 +++++++++++ .../ReservoirSamplingMetaTest.java | 5 +- 20 files changed, 773 insertions(+), 90 deletions(-) create mode 100644 engine/test-src/org/pentaho/di/trans/steps/normaliser/NormaliserMetaTest.java create mode 100644 engine/test-src/org/pentaho/di/trans/steps/pentahoreporting/PentahoReportingOutputMetaLoadSaveTest.java create mode 100644 engine/test-src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMetaTest.java create mode 100644 engine/test-src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMetaTest.java create mode 100644 engine/test-src/org/pentaho/di/trans/steps/processfiles/ProcessFilesMetaTest.java create mode 100644 engine/test-src/org/pentaho/di/trans/steps/propertyoutput/PropertyOutputMetaTest.java diff --git a/engine/src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMeta.java b/engine/src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMeta.java index 060e37c66d6f..19e18354813c 100644 --- a/engine/src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMeta.java +++ b/engine/src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMeta.java @@ -109,6 +109,7 @@ public void setKeyFields( String[] keyFields ) { this.keyFields = keyFields; } + @Override public boolean excludeFromRowLayoutVerification() { return true; } @@ -117,6 +118,7 @@ public MultiMergeJoinMeta() { super(); // allocate BaseStepMeta } + @Override public void loadXML( Node stepnode, List databases, IMetaStore metaStore ) throws KettleXMLException { readData( stepnode ); } @@ -125,6 +127,7 @@ public void allocateKeys( int nrKeys ) { keyFields = new String[nrKeys]; } + @Override public Object clone() { MultiMergeJoinMeta retval = (MultiMergeJoinMeta) super.clone(); int nrKeys = keyFields.length; @@ -136,6 +139,7 @@ public Object clone() { return retval; } + @Override public String getXML() { StringBuilder retval = new StringBuilder(); @@ -193,11 +197,13 @@ private void readData( Node stepnode ) throws KettleXMLException { } } + @Override public void setDefault() { joinType = join_types[0]; allocateKeys( 0 ); } + @Override public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, List databases ) throws KettleException { try { @@ -217,14 +223,18 @@ public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, Lis String stepName = rep.getStepAttributeString( id_step, "step" + i ); getStepIOMeta().addStream( new Stream( StreamType.INFO, null, BaseMessages.getString( PKG, "MultiMergeJoin.InfoStream.Description" ), - StreamIcon.INFO, null ) ); + StreamIcon.INFO, stepName ) ); inputSteps[i] = stepName; } - List infoStreams = getStepIOMeta().getInfoStreams(); - - for ( int i = 0; i < infoStreams.size(); i++ ) { - infoStreams.get( i ).setSubject( rep.getStepAttributeString( id_step, "step" + i ) ); - } + // This next bit is completely unnecessary if you just pass the step name into + // the constructor above. That sets the subject to the step name in one pass + // instead of a second one. + // MB - 5/2016 + // + // List infoStreams = getStepIOMeta().getInfoStreams(); + // for ( int i = 0; i < infoStreams.size(); i++ ) { + // infoStreams.get( i ).setSubject( rep.getStepAttributeString( id_step, "step" + i ) ); + // } joinType = rep.getStepAttributeString( id_step, "join_type" ); } catch ( Exception e ) { @@ -240,6 +250,7 @@ public void searchInfoAndTargetSteps( List steps ) { } } + @Override public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step ) throws KettleException { try { @@ -247,12 +258,19 @@ public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transform rep.saveStepAttribute( id_transformation, id_step, i, "keys", keyFields[i] ); } - List infoStreams = getStepIOMeta().getInfoStreams(); - - rep.saveStepAttribute( id_transformation, id_step, "number_input", infoStreams.size() ); - for ( int i = 0; i < infoStreams.size(); i++ ) { - rep.saveStepAttribute( id_transformation, id_step, "step" + i, infoStreams.get( i ).getStepname() ); + String[] inputStepsNames = inputSteps != null ? inputSteps : ArrayUtils.EMPTY_STRING_ARRAY; + rep.saveStepAttribute( id_transformation, id_step, "number_input", inputStepsNames.length ); + for ( int i = 0; i < inputStepsNames.length; i++ ) { + rep.saveStepAttribute( id_transformation, id_step, "step" + i, inputStepsNames[ i ] ); } +// The following was the old way of persisting this step to the repository. This was inconsistent with +// how getXML works, and also fails the load/save tester +// List infoStreams = getStepIOMeta().getInfoStreams(); +// rep.saveStepAttribute( id_transformation, id_step, "number_input", infoStreams.size() ); +// for ( int i = 0; i < infoStreams.size(); i++ ) { +// rep.saveStepAttribute( id_transformation, id_step, "step" + i, infoStreams.get( i ).getStepname() ); +// } + // inputSteps[i] rep.saveStepAttribute( id_transformation, id_step, "join_type", getJoinType() ); } catch ( Exception e ) { throw new KettleException( BaseMessages.getString( PKG, "MultiMergeJoinMeta.Exception.UnableToSaveStepInfo" ) @@ -260,6 +278,7 @@ public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transform } } + @Override public void check( List remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, VariableSpace space, Repository repository, IMetaStore metaStore ) { @@ -273,6 +292,7 @@ public void check( List remarks, TransMeta transMeta, Step remarks.add( cr ); } + @Override public void getFields( RowMetaInterface r, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException { // We don't have any input fields here in "r" as they are all info fields. @@ -292,15 +312,18 @@ public void getFields( RowMetaInterface r, String name, RowMetaInterface[] info, return; } + @Override public StepInterface getStep( StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta tr, Trans trans ) { return new MultiMergeJoin( stepMeta, stepDataInterface, cnr, tr, trans ); } + @Override public StepDataInterface getStepData() { return new MultiMergeJoinData(); } + @Override public void resetStepIoMeta() { // Don't reset! } diff --git a/engine/src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMeta.java b/engine/src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMeta.java index be61a44d7999..f05e0fe4af8f 100644 --- a/engine/src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMeta.java +++ b/engine/src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMeta.java @@ -2,7 +2,7 @@ * * Pentaho Data Integration * - * Copyright (C) 2002-2013 by Pentaho : http://www.pentaho.com + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com * ******************************************************************************* * @@ -81,7 +81,16 @@ public PGPDecryptStreamMeta() { super(); // allocate BaseStepMeta } - public void setGPGPLocation( String gpglocation ) { + /** + * @deprecated typo + * @param gpglocation + */ + @Deprecated + public void setGPGPLocation( String value ) { + this.setGPGLocation( value ); + } + + public void setGPGLocation( String gpglocation ) { this.gpglocation = gpglocation; } @@ -144,11 +153,22 @@ public String getResultFieldName() { /** * @param resultfieldname * The resultfieldname to set. + * @deprecated typo */ - public void setResultfieldname( String resultfieldname ) { - this.resultfieldname = resultfieldname; + @Deprecated + public void setResultfieldname( String value ) { + this.setResultFieldName( value ); } + /** + * + * @param resultfieldname + * The resultFieldName to set + * + */ + public void setResultFieldName( String resultfieldname ) { + this.resultfieldname = resultfieldname; + } /** * @return Returns the passhrase. */ @@ -164,16 +184,19 @@ public void setPassphrase( String passhrase ) { this.passhrase = passhrase; } + @Override public void loadXML( Node stepnode, List databases, IMetaStore metaStore ) throws KettleXMLException { readData( stepnode, databases ); } + @Override public Object clone() { PGPDecryptStreamMeta retval = (PGPDecryptStreamMeta) super.clone(); return retval; } + @Override public void setDefault() { resultfieldname = "result"; streamfield = null; @@ -181,6 +204,7 @@ public void setDefault() { gpglocation = null; } + @Override public void getFields( RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException { // Output fields (String) @@ -192,6 +216,7 @@ public void getFields( RowMetaInterface inputRowMeta, String name, RowMetaInterf } + @Override public String getXML() { StringBuilder retval = new StringBuilder(); retval.append( " " + XMLHandler.addTagValue( "gpglocation", gpglocation ) ); @@ -218,6 +243,7 @@ private void readData( Node stepnode, List data } } + @Override public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, List databases ) throws KettleException { try { gpglocation = rep.getStepAttributeString( id_step, "gpglocation" ); @@ -233,6 +259,7 @@ public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, Lis } } + @Override public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step ) throws KettleException { try { rep.saveStepAttribute( id_transformation, id_step, "gpglocation", gpglocation ); @@ -249,6 +276,7 @@ public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transform } } + @Override public void check( List remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, VariableSpace space, Repository repository, IMetaStore metaStore ) { @@ -307,15 +335,18 @@ public void check( List remarks, TransMeta transMeta, Step } + @Override public StepInterface getStep( StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta transMeta, Trans trans ) { return new PGPDecryptStream( stepMeta, stepDataInterface, cnr, transMeta, trans ); } + @Override public StepDataInterface getStepData() { return new PGPDecryptStreamData(); } + @Override public boolean supportsErrorHandling() { return true; } diff --git a/engine/src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMeta.java b/engine/src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMeta.java index ec2d4afde973..c50ffd02833c 100644 --- a/engine/src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMeta.java +++ b/engine/src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMeta.java @@ -80,8 +80,16 @@ public PGPEncryptStreamMeta() { super(); // allocate BaseStepMeta } - public void setGPGPLocation( String gpglocation ) { - this.gpglocation = gpglocation; + /** + * @deprecated - typo + */ + @Deprecated + public void setGPGPLocation( String value ) { + this.setGPGLocation( value ); + } + + public void setGPGLocation( String value ) { + this.gpglocation = value; } public String getGPGLocation() { @@ -140,12 +148,20 @@ public String getResultFieldName() { return resultfieldname; } + /** + * @deprecated - typo + */ + @Deprecated + public void setResultfieldname( String value ) { + this.setResultFieldName( value ); + } + /** * @param resultfieldname * The resultfieldname to set. */ - public void setResultfieldname( String resultfieldname ) { - this.resultfieldname = resultfieldname; + public void setResultFieldName( String value ) { + this.resultfieldname = value; } /** @@ -163,16 +179,19 @@ public void setKeyName( String keyname ) { this.keyname = keyname; } + @Override public void loadXML( Node stepnode, List databases, IMetaStore metaStore ) throws KettleXMLException { readData( stepnode, databases ); } + @Override public Object clone() { PGPEncryptStreamMeta retval = (PGPEncryptStreamMeta) super.clone(); return retval; } + @Override public void setDefault() { resultfieldname = "result"; streamfield = null; @@ -182,6 +201,7 @@ public void setDefault() { keynameFieldName = null; } + @Override public void getFields( RowMetaInterface inputRowMeta, String name, RowMetaInterface[] info, StepMeta nextStep, VariableSpace space, Repository repository, IMetaStore metaStore ) throws KettleStepException { // Output fields (String) @@ -193,6 +213,7 @@ public void getFields( RowMetaInterface inputRowMeta, String name, RowMetaInterf } + @Override public String getXML() { StringBuilder retval = new StringBuilder(); retval.append( " " + XMLHandler.addTagValue( "gpglocation", gpglocation ) ); @@ -219,6 +240,7 @@ private void readData( Node stepnode, List data } } + @Override public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, List databases ) throws KettleException { try { gpglocation = rep.getStepAttributeString( id_step, "gpglocation" ); @@ -233,6 +255,7 @@ public void readRep( Repository rep, IMetaStore metaStore, ObjectId id_step, Lis } } + @Override public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transformation, ObjectId id_step ) throws KettleException { try { rep.saveStepAttribute( id_transformation, id_step, "gpglocation", gpglocation ); @@ -248,6 +271,7 @@ public void saveRep( Repository rep, IMetaStore metaStore, ObjectId id_transform } } + @Override public void check( List remarks, TransMeta transMeta, StepMeta stepMeta, RowMetaInterface prev, String[] input, String[] output, RowMetaInterface info, VariableSpace space, Repository repository, IMetaStore metaStore ) { @@ -305,15 +329,18 @@ public void check( List remarks, TransMeta transMeta, Step } + @Override public StepInterface getStep( StepMeta stepMeta, StepDataInterface stepDataInterface, int cnr, TransMeta transMeta, Trans trans ) { return new PGPEncryptStream( stepMeta, stepDataInterface, cnr, transMeta, trans ); } + @Override public StepDataInterface getStepData() { return new PGPEncryptStreamData(); } + @Override public boolean supportsErrorHandling() { return true; } diff --git a/engine/src/org/pentaho/di/trans/steps/textfileinput/TextFileInputField.java b/engine/src/org/pentaho/di/trans/steps/textfileinput/TextFileInputField.java index 3ae389420c40..fc27b501ed61 100644 --- a/engine/src/org/pentaho/di/trans/steps/textfileinput/TextFileInputField.java +++ b/engine/src/org/pentaho/di/trans/steps/textfileinput/TextFileInputField.java @@ -44,6 +44,7 @@ * * @deprecated replaced by implementation in the ...steps.fileinput.text package */ +@Deprecated public class TextFileInputField implements Cloneable, TextFileInputFieldInterface { @Injection( name = "INPUT_NAME", group = "INPUT_FIELDS" ) @@ -134,6 +135,7 @@ public int compare( Object obj ) { return position - field.getPosition(); } + @Override public int compareTo( TextFileInputFieldInterface field ) { return position - field.getPosition(); } @@ -144,6 +146,7 @@ public boolean equal( Object obj ) { return ( position == field.getPosition() ); } + @Override public Object clone() { try { Object retval = super.clone(); @@ -153,6 +156,7 @@ public Object clone() { } } + @Override public int getPosition() { return position; } @@ -161,14 +165,17 @@ public void setPosition( int position ) { this.position = position; } + @Override public int getLength() { return length; } + @Override public void setLength( int length ) { this.length = length; } + @Override public String getName() { return name; } @@ -213,6 +220,10 @@ public void setSamples( String[] samples ) { this.samples = samples; } + public String[] getSamples( ) { + return this.samples; + } + public int getTrimType() { return trimtype; } @@ -289,6 +300,7 @@ public void setIfNullValue( String ifNullValue ) { this.ifNullValue = ifNullValue; } + @Override public String toString() { return name + "@" + position + ":" + length; } @@ -616,6 +628,7 @@ public void guessIgnore() { } } + @Override public TextFileInputFieldInterface createNewInstance( String newFieldname, int x, int newlength ) { return new TextFileInputField( newFieldname, x, newlength ); } diff --git a/engine/test-src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMetaTest.java index 61e4f565799e..dfae23b99c97 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/multimerge/MultiMergeJoinMetaTest.java @@ -24,23 +24,71 @@ import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertNull; +import java.util.ArrayList; import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.junit.Assert; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.step.StepMetaInterface; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.initializer.InitializerInterface; +import org.pentaho.di.trans.steps.loadsave.validator.ArrayLoadSaveValidator; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; +import org.pentaho.di.trans.steps.loadsave.validator.StringLoadSaveValidator; /** * @author Tatsiana_Kasiankova - * + * */ -public class MultiMergeJoinMetaTest { - +public class MultiMergeJoinMetaTest implements InitializerInterface { + LoadSaveTester loadSaveTester; + Class testMetaClass = MultiMergeJoinMeta.class; private MultiMergeJoinMeta multiMergeMeta; @Before - public void setup() throws Exception { + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); multiMergeMeta = new MultiMergeJoinMeta(); + List attributes = + Arrays.asList( "joinType", "keyFields", "inputSteps" ); + + Map getterMap = new HashMap(); + Map setterMap = new HashMap(); + FieldLoadSaveValidator stringArrayLoadSaveValidator = + new ArrayLoadSaveValidator( new StringLoadSaveValidator(), 5 ); + + + Map> attrValidatorMap = new HashMap>(); + attrValidatorMap.put( "keyFields", stringArrayLoadSaveValidator ); + attrValidatorMap.put( "inputSteps", stringArrayLoadSaveValidator ); + + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, new ArrayList(), new ArrayList(), + getterMap, setterMap, attrValidatorMap, typeValidatorMap, this ); + } + + // Call the allocate method on the LoadSaveTester meta class + @Override + public void modify( StepMetaInterface someMeta ) { + if ( someMeta instanceof MultiMergeJoinMeta ) { + ( (MultiMergeJoinMeta) someMeta ).allocateKeys( 5 ); + ( (MultiMergeJoinMeta) someMeta ).allocateInputSteps( 5 ); + } + } + + @Test + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); } @Test diff --git a/engine/test-src/org/pentaho/di/trans/steps/mysqlbulkloader/MySQLBulkLoaderMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/mysqlbulkloader/MySQLBulkLoaderMetaTest.java index f56557c98827..b83ddd9685bc 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/mysqlbulkloader/MySQLBulkLoaderMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/mysqlbulkloader/MySQLBulkLoaderMetaTest.java @@ -95,7 +95,6 @@ public void testRoundTrip() throws KettleException { new LoadSaveTester( MySQLBulkLoaderMeta.class, attributes, getterMap, setterMap, fieldLoadSaveValidatorAttributeMap, new HashMap>() ); - loadSaveTester.testXmlRoundTrip(); - loadSaveTester.testRepoRoundTrip(); + loadSaveTester.testSerialization(); } } diff --git a/engine/test-src/org/pentaho/di/trans/steps/normaliser/NormaliserMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/normaliser/NormaliserMetaTest.java new file mode 100644 index 000000000000..0db41d884898 --- /dev/null +++ b/engine/test-src/org/pentaho/di/trans/steps/normaliser/NormaliserMetaTest.java @@ -0,0 +1,108 @@ +/*! ****************************************************************************** + * + * Pentaho Data Integration + * + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com + * + ******************************************************************************* + * + * Licensed 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.pentaho.di.trans.steps.normaliser; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.UUID; + +import org.apache.commons.lang.builder.EqualsBuilder; +import org.junit.Before; +import org.junit.Test; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.step.StepMetaInterface; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.initializer.InitializerInterface; +import org.pentaho.di.trans.steps.loadsave.validator.ArrayLoadSaveValidator; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; + +public class NormaliserMetaTest implements InitializerInterface { + LoadSaveTester loadSaveTester; + Class testMetaClass = NormaliserMeta.class; + + @Before + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); + List attributes = + Arrays.asList( "typeField", "normaliserFields" ); + + Map getterMap = new HashMap(); + Map setterMap = new HashMap(); + + Map> attrValidatorMap = new HashMap>(); + attrValidatorMap.put( "normaliserFields", + new ArrayLoadSaveValidator( new NormaliserFieldLoadSaveValidator(), 5 ) ); + + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, new ArrayList(), new ArrayList(), + getterMap, setterMap, attrValidatorMap, typeValidatorMap, this ); + } + + // Call the allocate method on the LoadSaveTester meta class + @Override + public void modify( StepMetaInterface someMeta ) { + if ( someMeta instanceof NormaliserMeta ) { + ( (NormaliserMeta) someMeta ).allocate( 5 ); + } + } + + @Test + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); + } + + // NormaliserFieldLoadSaveValidator + public class NormaliserFieldLoadSaveValidator implements FieldLoadSaveValidator { + final Random rand = new Random(); + @Override + public NormaliserMeta.NormaliserField getTestObject() { + NormaliserMeta.NormaliserField rtn = new NormaliserMeta.NormaliserField(); + rtn.setName( UUID.randomUUID().toString() ); + rtn.setNorm( UUID.randomUUID().toString() ); + rtn.setValue( UUID.randomUUID().toString() ); + return rtn; + } + + @Override + public boolean validateTestObject( NormaliserMeta.NormaliserField testObject, Object actual ) { + if ( !( actual instanceof NormaliserMeta.NormaliserField ) ) { + return false; + } + NormaliserMeta.NormaliserField another = (NormaliserMeta.NormaliserField) actual; + return new EqualsBuilder() + .append( testObject.getName(), another.getName() ) + .append( testObject.getNorm(), another.getNorm() ) + .append( testObject.getValue(), another.getValue() ) + .isEquals(); + } + } + +} diff --git a/engine/test-src/org/pentaho/di/trans/steps/nullif/NullIfMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/nullif/NullIfMetaTest.java index e2b8144f53ec..10d2e47ba0ba 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/nullif/NullIfMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/nullif/NullIfMetaTest.java @@ -63,7 +63,6 @@ public void setUp() throws Exception { attrValidatorMap.put( "fieldValue", stringArrayLoadSaveValidator ); Map> typeValidatorMap = new HashMap>(); - // typeValidatorMap.put( int[].class.getCanonicalName(), new PrimitiveIntArrayLoadSaveValidator( new IntLoadSaveValidator(), 1 ) ); loadSaveTester = new LoadSaveTester( NullIfMeta.class, attributes, getterMap, setterMap, attrValidatorMap, typeValidatorMap ); diff --git a/engine/test-src/org/pentaho/di/trans/steps/numberrange/NumberRangeMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/numberrange/NumberRangeMetaTest.java index 2c4123a9842c..3152744a9fcb 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/numberrange/NumberRangeMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/numberrange/NumberRangeMetaTest.java @@ -37,21 +37,6 @@ public class NumberRangeMetaTest { - public class NumberRangeRuleFieldLoadSaveValidator implements FieldLoadSaveValidator { - @Override - public NumberRangeRule getTestObject() { - return new NumberRangeRule( - new Random().nextDouble(), - new Random().nextDouble(), - UUID.randomUUID().toString() ); - } - - @Override - public boolean validateTestObject( NumberRangeRule testObject, Object actual ) { - return testObject.equals( actual ); - } - } - @Test public void testStepMeta() throws KettleException { List attributes = Arrays.asList( "inputField", "outputField", "fallBackValue", "rules" ); @@ -76,7 +61,21 @@ public void testStepMeta() throws KettleException { LoadSaveTester loadSaveTester = new LoadSaveTester( NumberRangeMeta.class, attributes, getterMap, setterMap, fieldLoadSaveValidatorAttributeMap, new HashMap>() ); - loadSaveTester.testRepoRoundTrip(); - loadSaveTester.testXmlRoundTrip(); + loadSaveTester.testSerialization(); + } + + public class NumberRangeRuleFieldLoadSaveValidator implements FieldLoadSaveValidator { + @Override + public NumberRangeRule getTestObject() { + return new NumberRangeRule( + new Random().nextDouble(), + new Random().nextDouble(), + UUID.randomUUID().toString() ); + } + + @Override + public boolean validateTestObject( NumberRangeRule testObject, Object actual ) { + return testObject.equals( actual ); + } } } diff --git a/engine/test-src/org/pentaho/di/trans/steps/olapinput/OlapInputMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/olapinput/OlapInputMetaTest.java index 9cf43a99cf14..a6707bb86560 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/olapinput/OlapInputMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/olapinput/OlapInputMetaTest.java @@ -67,8 +67,7 @@ public void testRoundTrip() throws KettleException { LoadSaveTester loadSaveTester = new LoadSaveTester( OlapInputMeta.class, attributes, getterMap, setterMap ); - loadSaveTester.testRepoRoundTrip(); - loadSaveTester.testXmlRoundTrip(); + loadSaveTester.testSerialization(); } @Test diff --git a/engine/test-src/org/pentaho/di/trans/steps/orabulkloader/OraBulkLoaderMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/orabulkloader/OraBulkLoaderMetaTest.java index 2ad96035d68d..4ecdc755ab81 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/orabulkloader/OraBulkLoaderMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/orabulkloader/OraBulkLoaderMetaTest.java @@ -134,13 +134,8 @@ public void setUp() throws Exception { } @Test - public void testLoadSaveXML() throws KettleException { - loadSaveTester.testXmlRoundTrip(); - } - - @Test - public void testLoadSaveRepo() throws KettleException { - loadSaveTester.testRepoRoundTrip(); + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); } public class DateMaskLoadSaveValidator implements FieldLoadSaveValidator { diff --git a/engine/test-src/org/pentaho/di/trans/steps/parallelgzipcsv/ParGzipCsvInputMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/parallelgzipcsv/ParGzipCsvInputMetaTest.java index f3cb4515669e..6a9b1b95076e 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/parallelgzipcsv/ParGzipCsvInputMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/parallelgzipcsv/ParGzipCsvInputMetaTest.java @@ -21,28 +21,119 @@ ******************************************************************************/ package org.pentaho.di.trans.steps.parallelgzipcsv; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Random; +import java.util.UUID; + +import org.apache.commons.lang.builder.EqualsBuilder; +import org.junit.Before; import org.junit.Test; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.step.StepMetaInterface; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.initializer.InitializerInterface; +import org.pentaho.di.trans.steps.loadsave.validator.ArrayLoadSaveValidator; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; import org.pentaho.di.trans.steps.textfileinput.TextFileInputField; -import static org.junit.Assert.*; +public class ParGzipCsvInputMetaTest implements InitializerInterface { + LoadSaveTester loadSaveTester; + Class testMetaClass = ParGzipCsvInputMeta.class; + + @Before + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); + List attributes = + Arrays.asList( "filename", "filenameField", "includingFilename", "rowNumField", "headerPresent", "delimiter", + "enclosure", "bufferSize", "lazyConversionActive", "addResultFile", "runningInParallel", "encoding", + "inputFields" ); + + Map getterMap = new HashMap(); + Map setterMap = new HashMap(); + + Map> attrValidatorMap = new HashMap>(); + attrValidatorMap.put( "inputFields", new ArrayLoadSaveValidator( new TextFileInputFieldValidator(), 5 ) ); -public class ParGzipCsvInputMetaTest { + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, new ArrayList(), new ArrayList(), getterMap, + setterMap, attrValidatorMap, typeValidatorMap, this ); + } + + // Call the allocate method on the LoadSaveTester meta class + @Override + public void modify( StepMetaInterface someMeta ) { + if ( someMeta instanceof ParGzipCsvInputMeta ) { + ( (ParGzipCsvInputMeta) someMeta ).allocate( 5 ); + } + } @Test - public void cloneTest() throws Exception { - ParGzipCsvInputMeta meta = new ParGzipCsvInputMeta(); - meta.allocate( 2 ); - TextFileInputField tfi1 = new TextFileInputField( "fieldname1", 0, 10 ); - TextFileInputField tfi2 = new TextFileInputField( "fieldname2", 15, 30 ); - meta.setInputFields( new TextFileInputField[] { tfi1, tfi2 } ); - // scalars should be cloned using super.clone() - makes sure they're calling super.clone() - meta.setFilename( "aFileName" ); - ParGzipCsvInputMeta aClone = (ParGzipCsvInputMeta) meta.clone(); - assertFalse( aClone == meta ); - TextFileInputField[] ctfi = aClone.getInputFields(); - assertTrue( ctfi[0].getName().equals( tfi1.getName() ) ); - assertTrue( ctfi[1].getName().equals( tfi2.getName() ) ); - assertEquals( meta.getFilename(), aClone.getFilename() ); + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); } + // Note - cloneTest removed as clone is now covered by the load/save validator. + + private static class TextFileInputFieldValidator implements FieldLoadSaveValidator { + final Random rand = new Random(); + + @Override + public TextFileInputField getTestObject() { + TextFileInputField rtn = new TextFileInputField(); + rtn.setCurrencySymbol( UUID.randomUUID().toString() ); + rtn.setDecimalSymbol( UUID.randomUUID().toString() ); + rtn.setFormat( UUID.randomUUID().toString() ); + rtn.setGroupSymbol( UUID.randomUUID().toString() ); + rtn.setName( UUID.randomUUID().toString() ); + rtn.setTrimType( rand.nextInt( 4 ) ); + rtn.setPrecision( rand.nextInt( 9 ) ); + rtn.setLength( rand.nextInt( 50 ) ); + rtn.setType( rand.nextInt( 7 ) ); + // Note - these fields aren't serialized by the meta class ... cannot test for them + // rtn.setRepeated( rand.nextBoolean() ); + // rtn.setSamples( new String[] { UUID.randomUUID().toString(), UUID.randomUUID().toString(), + // UUID.randomUUID().toString() } ); + // rtn.setNullString( UUID.randomUUID().toString() ); + // rtn.setIfNullValue( UUID.randomUUID().toString() ); + // rtn.setIgnored( rand.nextBoolean() ); + // rtn.setPosition( rand.nextInt( 10 ) ); + return rtn; + } + + @Override + public boolean validateTestObject( TextFileInputField testObject, Object actual ) { + if ( !( actual instanceof TextFileInputField ) ) { + return false; + } + + TextFileInputField another = (TextFileInputField) actual; + return new EqualsBuilder() + .append( testObject.getCurrencySymbol(), another.getCurrencySymbol() ) + .append( testObject.getDecimalSymbol(), another.getDecimalSymbol() ) + .append( testObject.getFormat(), another.getFormat() ) + .append( testObject.getGroupSymbol(), another.getGroupSymbol() ) + .append( testObject.getName(), another.getName() ) + .append( testObject.getTrimType(), another.getTrimType() ) + .append( testObject.getPrecision(), another.getPrecision() ) + .append( testObject.getLength(), another.getLength() ) + .append( testObject.getType(), another.getType() ) + // Note - these fields aren't serialized by the meta class ... cannot test for them + // .append( testObject.isRepeated(), another.isRepeated() ) + // .append( testObject.getSamples(), another.getSamples() ) + // .append( testObject.getNullString(), another.getNullString() ) + // .append( testObject.getIfNullValue(), another.getIfNullValue() ) + // .append( testObject.isIgnored(), another.isIgnored() ) + // .append( testObject.getPosition(), another.getPosition() ) + .isEquals(); + } + } } diff --git a/engine/test-src/org/pentaho/di/trans/steps/pentahoreporting/PentahoReportingOutputMetaLoadSaveTest.java b/engine/test-src/org/pentaho/di/trans/steps/pentahoreporting/PentahoReportingOutputMetaLoadSaveTest.java new file mode 100644 index 000000000000..12d9b88adbc3 --- /dev/null +++ b/engine/test-src/org/pentaho/di/trans/steps/pentahoreporting/PentahoReportingOutputMetaLoadSaveTest.java @@ -0,0 +1,89 @@ +/*! ****************************************************************************** + * + * Pentaho Data Integration + * + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com + * + ******************************************************************************* + * + * Licensed 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.pentaho.di.trans.steps.pentahoreporting; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Random; + +import org.junit.Before; +import org.junit.Test; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; +import org.pentaho.di.trans.steps.loadsave.validator.MapLoadSaveValidator; +import org.pentaho.di.trans.steps.loadsave.validator.StringLoadSaveValidator; +import org.pentaho.di.trans.steps.pentahoreporting.PentahoReportingOutputMeta.ProcessorType; + +public class PentahoReportingOutputMetaLoadSaveTest { + LoadSaveTester loadSaveTester; + Class testMetaClass = PentahoReportingOutputMeta.class; + + @Before + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); + List attributes = + Arrays.asList( "inputFileField", "outputFileField", "parameterFieldMap", "outputProcessorType" ); + + Map getterMap = new HashMap(); + Map setterMap = new HashMap(); + + Map> attrValidatorMap = new HashMap>(); + attrValidatorMap.put( "parameterFieldMap", + new MapLoadSaveValidator( new StringLoadSaveValidator(), new StringLoadSaveValidator(), 5 ) ); + attrValidatorMap.put( "outputProcessorType", new ProcessorTypeLoadSaveValidator() ); + + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, getterMap, setterMap, attrValidatorMap, typeValidatorMap ); + } + + @Test + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); + } + + public class ProcessorTypeLoadSaveValidator implements FieldLoadSaveValidator { + final Random rand = new Random(); + @Override + public ProcessorType getTestObject() { + ProcessorType[] vals = ProcessorType.values(); + return vals[ rand.nextInt( vals.length ) ]; + } + + @Override + public boolean validateTestObject( ProcessorType testObject, Object actual ) { + if ( !( actual instanceof ProcessorType ) ) { + return false; + } + ProcessorType another = (ProcessorType) actual; + return testObject.equals( another ); + } + } + +} diff --git a/engine/test-src/org/pentaho/di/trans/steps/pgbulkloader/PGBulkLoaderMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/pgbulkloader/PGBulkLoaderMetaTest.java index 68e74daa017c..b674bdedd462 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/pgbulkloader/PGBulkLoaderMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/pgbulkloader/PGBulkLoaderMetaTest.java @@ -124,13 +124,8 @@ public void setUpLoadSave() throws Exception { } @Test - public void testLoadSaveXML() throws KettleException { - loadSaveTester.testXmlRoundTrip(); - } - - @Test - public void testLoadSaveRepo() throws KettleException { - loadSaveTester.testRepoRoundTrip(); + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); } @BeforeClass diff --git a/engine/test-src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMetaTest.java new file mode 100644 index 000000000000..be5315130985 --- /dev/null +++ b/engine/test-src/org/pentaho/di/trans/steps/pgpdecryptstream/PGPDecryptStreamMetaTest.java @@ -0,0 +1,63 @@ +/*! ****************************************************************************** + * + * Pentaho Data Integration + * + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com + * + ******************************************************************************* + * + * Licensed 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.pentaho.di.trans.steps.pgpdecryptstream; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Before; +import org.junit.Test; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; + +public class PGPDecryptStreamMetaTest { + + LoadSaveTester loadSaveTester; + Class testMetaClass = PGPDecryptStreamMeta.class; + + @Before + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); + List attributes = + Arrays.asList( "gPGLocation", "passphrase", "passphraseFieldName", "passphraseFieldName", "streamField", "resultFieldName" ); + + Map getterMap = new HashMap(); + Map setterMap = new HashMap(); + + Map> attrValidatorMap = new HashMap>(); + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, getterMap, setterMap, attrValidatorMap, typeValidatorMap ); + } + + @Test + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); + } +} diff --git a/engine/test-src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMetaTest.java new file mode 100644 index 000000000000..a143b2843c56 --- /dev/null +++ b/engine/test-src/org/pentaho/di/trans/steps/pgpencryptstream/PGPEncryptStreamMetaTest.java @@ -0,0 +1,64 @@ +/*! ****************************************************************************** + * + * Pentaho Data Integration + * + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com + * + ******************************************************************************* + * + * Licensed 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.pentaho.di.trans.steps.pgpencryptstream; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Before; +import org.junit.Test; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; + +public class PGPEncryptStreamMetaTest { + + LoadSaveTester loadSaveTester; + Class testMetaClass = PGPEncryptStreamMeta.class; + + @Before + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); + List attributes = + Arrays.asList( "gPGLocation", "keynameFieldName", "streamField", "resultFieldName", "keynameInField", "keynameFieldName" ); + + Map getterMap = new HashMap(); + Map setterMap = new HashMap(); + + Map> attrValidatorMap = new HashMap>(); + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, getterMap, setterMap, attrValidatorMap, typeValidatorMap ); + } + + @Test + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); + } + +} diff --git a/engine/test-src/org/pentaho/di/trans/steps/prioritizestreams/PrioritizeStreamsMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/prioritizestreams/PrioritizeStreamsMetaTest.java index 9380f72c8d42..06f9cf6fdc04 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/prioritizestreams/PrioritizeStreamsMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/prioritizestreams/PrioritizeStreamsMetaTest.java @@ -48,16 +48,9 @@ public void setUp() throws Exception { List attributes = Arrays.asList( "stepName" ); - Map getterMap = new HashMap() { - { - put( "stepName", "getStepName" ); - } - }; - Map setterMap = new HashMap() { - { - put( "stepName", "setStepName" ); - } - }; + Map getterMap = new HashMap(); + Map setterMap = new HashMap(); + FieldLoadSaveValidator stringArrayLoadSaveValidator = new ArrayLoadSaveValidator( new StringLoadSaveValidator(), 5 ); @@ -65,7 +58,6 @@ public void setUp() throws Exception { attrValidatorMap.put( "stepName", stringArrayLoadSaveValidator ); Map> typeValidatorMap = new HashMap>(); - // typeValidatorMap.put( int[].class.getCanonicalName(), new PrimitiveIntArrayLoadSaveValidator( new IntLoadSaveValidator(), 1 ) ); loadSaveTester = new LoadSaveTester( testMetaClass, attributes, getterMap, setterMap, attrValidatorMap, typeValidatorMap ); diff --git a/engine/test-src/org/pentaho/di/trans/steps/processfiles/ProcessFilesMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/processfiles/ProcessFilesMetaTest.java new file mode 100644 index 000000000000..2d1e916e3cfc --- /dev/null +++ b/engine/test-src/org/pentaho/di/trans/steps/processfiles/ProcessFilesMetaTest.java @@ -0,0 +1,74 @@ +/*! ****************************************************************************** + * + * Pentaho Data Integration + * + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com + * + ******************************************************************************* + * + * Licensed 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.pentaho.di.trans.steps.processfiles; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Before; +import org.junit.Test; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; +import org.pentaho.di.trans.steps.loadsave.validator.IntLoadSaveValidator; + +public class ProcessFilesMetaTest { + LoadSaveTester loadSaveTester; + Class testMetaClass = ProcessFilesMeta.class; + + @Before + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); + List attributes = + Arrays.asList( "addTargetFileNametoResult", "overwriteTargetFile", "createParentFolder", "dynamicSourceFileNameField", "dynamicTargetFileNameField", "operationType", "simulate" ); + + Map getterMap = new HashMap() { + { + put( "addTargetFileNametoResult", "isaddTargetFileNametoResult" ); + } + }; + Map setterMap = new HashMap() { + { + put( "addTargetFileNametoResult", "setaddTargetFileNametoResult" ); + } + }; + + Map> attrValidatorMap = new HashMap>(); + attrValidatorMap.put( "operationType", new IntLoadSaveValidator( ProcessFilesMeta.operationTypeDesc.length ) ); + + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, getterMap, setterMap, attrValidatorMap, typeValidatorMap ); + } + + @Test + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); + } + +} diff --git a/engine/test-src/org/pentaho/di/trans/steps/propertyoutput/PropertyOutputMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/propertyoutput/PropertyOutputMetaTest.java new file mode 100644 index 000000000000..56422adc897e --- /dev/null +++ b/engine/test-src/org/pentaho/di/trans/steps/propertyoutput/PropertyOutputMetaTest.java @@ -0,0 +1,75 @@ +/*! ****************************************************************************** + * + * Pentaho Data Integration + * + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com + * + ******************************************************************************* + * + * Licensed 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.pentaho.di.trans.steps.propertyoutput; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Before; +import org.junit.Test; +import org.pentaho.di.core.KettleEnvironment; +import org.pentaho.di.core.exception.KettleException; +import org.pentaho.di.core.plugins.PluginRegistry; +import org.pentaho.di.trans.steps.loadsave.LoadSaveTester; +import org.pentaho.di.trans.steps.loadsave.validator.FieldLoadSaveValidator; + +public class PropertyOutputMetaTest { + LoadSaveTester loadSaveTester; + Class testMetaClass = PropertyOutputMeta.class; + + @Before + public void setUpLoadSave() throws Exception { + KettleEnvironment.init(); + PluginRegistry.init( true ); + List attributes = + Arrays.asList( "keyField", "valueField", "addToResult", "fileName", "fileNameInField", "fileNameField", + "extension", "stepNrInFilename", "dateInFilename", "timeInFilename", + "createParentFolder", "comment", "append" ); + + // + // Note - "partNrInFilename" not included above because while it seems to be serialized/deserialized in the meta, + // there are no getters/setters and it's a private variable. Also, it's not included in the dialog. So it is + // always serialized/deserialized as "false" (N). + // MB - 5/2016 + + Map getterMap = new HashMap() { + { + put( "addToResult", "addToResult" ); + } + }; + Map setterMap = new HashMap(); + + Map> attrValidatorMap = new HashMap>(); + Map> typeValidatorMap = new HashMap>(); + + loadSaveTester = + new LoadSaveTester( testMetaClass, attributes, getterMap, setterMap, attrValidatorMap, typeValidatorMap ); + } + + @Test + public void testSerialization() throws KettleException { + loadSaveTester.testSerialization(); + } + +} diff --git a/engine/test-src/org/pentaho/di/trans/steps/reservoirsampling/ReservoirSamplingMetaTest.java b/engine/test-src/org/pentaho/di/trans/steps/reservoirsampling/ReservoirSamplingMetaTest.java index 1c97688b8eaa..b68ecf44a3a3 100644 --- a/engine/test-src/org/pentaho/di/trans/steps/reservoirsampling/ReservoirSamplingMetaTest.java +++ b/engine/test-src/org/pentaho/di/trans/steps/reservoirsampling/ReservoirSamplingMetaTest.java @@ -2,7 +2,7 @@ * * Pentaho Data Integration * - * Copyright (C) 2002-2015 by Pentaho : http://www.pentaho.com + * Copyright (C) 2002-2016 by Pentaho : http://www.pentaho.com * ******************************************************************************* * @@ -47,7 +47,6 @@ public void testLoadSaveMeta() throws KettleException { setterMap.put( "seed", "setSeed" ); LoadSaveTester tester = new LoadSaveTester( ReservoirSamplingMeta.class, attributes, getterMap, setterMap ); - tester.testXmlRoundTrip(); - tester.testRepoRoundTrip(); + tester.testSerialization(); } }