Java tutorial
/*! ****************************************************************************** * * Pentaho Data Integration * * Copyright (C) 2016-2017 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.ui.spoon; import static org.mockito.Mockito.mock; import java.util.Collections; import java.util.UUID; import static org.hamcrest.CoreMatchers.*; import static org.junit.Assert.*; import org.apache.commons.vfs2.FileObject; import org.junit.After; import org.junit.Before; import org.junit.BeforeClass; import org.junit.Test; import static org.mockito.Mockito.*; import org.pentaho.di.base.AbstractMeta; import org.pentaho.di.cluster.ClusterSchema; import org.pentaho.di.cluster.SlaveServer; import org.pentaho.di.core.KettleEnvironment; import org.pentaho.di.core.database.DatabaseMeta; import org.pentaho.di.core.exception.KettleException; import org.pentaho.di.core.exception.KettleXMLException; import org.pentaho.di.core.vfs.KettleVFS; import org.pentaho.di.job.JobMeta; import org.pentaho.di.partition.PartitionSchema; import org.pentaho.di.repository.Repository; import org.pentaho.di.repository.RepositoryDirectory; import org.pentaho.di.repository.StringObjectId; import org.pentaho.di.shared.SharedObjectInterface; import org.pentaho.di.shared.SharedObjects; import org.pentaho.di.trans.TransMeta; import org.pentaho.di.trans.step.StepMeta; import org.pentaho.di.ui.spoon.delegates.SpoonClustersDelegate; import org.pentaho.di.ui.spoon.delegates.SpoonDBDelegate; import org.pentaho.di.ui.spoon.delegates.SpoonDelegates; import org.pentaho.di.ui.spoon.delegates.SpoonJobDelegate; import org.pentaho.di.ui.spoon.delegates.SpoonPartitionsDelegate; import org.pentaho.di.ui.spoon.delegates.SpoonSlaveDelegate; import org.pentaho.di.ui.spoon.delegates.SpoonTransformationDelegate; /** * SharedObjectSyncUtil tests. * */ public class SharedObjectSyncUtilTest { private static final String BEFORE_SYNC_VALUE = "BeforeSync"; private static final String AFTER_SYNC_VALUE = "AfterSync"; private static final String SHARED_OBJECTS_FILE = "ram:/shared.xml"; private SpoonDelegates spoonDelegates; private SharedObjectSyncUtil sharedUtil; private Spoon spoon; private Repository repository; @BeforeClass public static void setUpBeforeClass() throws Exception { KettleEnvironment.init(); } @Before public void setUp() { spoon = mock(Spoon.class); //when( spoon.getRepository() ).thenReturn( spoon.rep ); spoonDelegates = mock(SpoonDelegates.class); spoonDelegates.jobs = new SpoonJobDelegate(spoon); spoonDelegates.trans = new SpoonTransformationDelegate(spoon); spoonDelegates.db = new SpoonDBDelegate(spoon); spoonDelegates.slaves = new SpoonSlaveDelegate(spoon); spoonDelegates.partitions = new SpoonPartitionsDelegate(spoon); spoonDelegates.clusters = new SpoonClustersDelegate(spoon); spoon.delegates = spoonDelegates; sharedUtil = new SharedObjectSyncUtil(spoon); repository = mock(Repository.class); } @After public void tearDown() throws Exception { FileObject sharedObjectsFile = KettleVFS.getFileObject(SHARED_OBJECTS_FILE); if (sharedObjectsFile.exists()) { sharedObjectsFile.delete(); } } @Test public void synchronizeConnections() throws Exception { final String databaseName = "SharedDB"; DatabaseMeta sharedDB0 = createDatabaseMeta(databaseName, true); saveSharedObjects(SHARED_OBJECTS_FILE, sharedDB0); JobMeta job1 = createJobMeta(); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); spoonDelegates.jobs.addJob(job2); DatabaseMeta sharedDB2 = job2.getDatabase(0); assertEquals(databaseName, sharedDB2.getName()); DatabaseMeta sharedDB1 = job1.getDatabase(0); assertEquals(databaseName, sharedDB1.getName()); assertTrue(sharedDB1 != sharedDB2); assertThat(sharedDB1.getHostname(), equalTo(BEFORE_SYNC_VALUE)); sharedDB2.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeConnections(sharedDB2, sharedDB2.getName()); assertThat(sharedDB1.getHostname(), equalTo(AFTER_SYNC_VALUE)); } @Test public void synchronizeConnections_sync_shared_only() throws Exception { final String databaseName = "DB"; DatabaseMeta sharedDB0 = createDatabaseMeta(databaseName, true); saveSharedObjects(SHARED_OBJECTS_FILE, sharedDB0); JobMeta job1 = createJobMeta(); DatabaseMeta sharedDB1 = job1.getDatabase(0); spoonDelegates.jobs.addJob(job1); DatabaseMeta unsharedDB2 = createDatabaseMeta(databaseName, false); JobMeta job2 = createJobMeta(); spoonDelegates.jobs.addJob(job2); job2.removeDatabase(0); job2.addDatabase(unsharedDB2); JobMeta job3 = createJobMeta(); DatabaseMeta sharedDB3 = job3.getDatabase(0); spoonDelegates.jobs.addJob(job3); job3.addDatabase(sharedDB3); sharedDB3.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeConnections(sharedDB3, sharedDB3.getName()); assertThat(sharedDB1.getHostname(), equalTo(AFTER_SYNC_VALUE)); assertThat(unsharedDB2.getHostname(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeConnections_should_not_sync_unshared() throws Exception { final String databaseName = "DB"; JobMeta job1 = createJobMeta(); DatabaseMeta sharedDB1 = createDatabaseMeta(databaseName, true); job1.addDatabase(sharedDB1); spoonDelegates.jobs.addJob(job1); DatabaseMeta db2 = createDatabaseMeta(databaseName, false); JobMeta job2 = createJobMeta(); spoonDelegates.jobs.addJob(job2); job2.addDatabase(db2); db2.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeConnections(db2, db2.getName()); assertThat(sharedDB1.getHostname(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeConnections_use_case_sensitive_name() throws Exception { JobMeta job1 = createJobMeta(); DatabaseMeta sharedDB1 = createDatabaseMeta("DB", true); job1.addDatabase(sharedDB1); spoonDelegates.jobs.addJob(job1); DatabaseMeta sharedDB2 = createDatabaseMeta("Db", true); JobMeta job2 = createJobMeta(); spoonDelegates.jobs.addJob(job2); job2.addDatabase(sharedDB2); sharedDB2.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeConnections(sharedDB2, sharedDB2.getName()); assertThat(sharedDB1.getHostname(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeConnectionsRename() throws Exception { final String databaseName = BEFORE_SYNC_VALUE; DatabaseMeta sharedDB0 = createDatabaseMeta(databaseName, true); saveSharedObjects(SHARED_OBJECTS_FILE, sharedDB0); JobMeta job1 = createJobMeta(); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); spoonDelegates.jobs.addJob(job2); DatabaseMeta sharedDB2 = job2.getDatabase(0); assertEquals(databaseName, sharedDB2.getName()); DatabaseMeta sharedDB1 = job1.getDatabase(0); assertEquals(databaseName, sharedDB1.getName()); assertTrue(sharedDB1 != sharedDB2); assertThat(sharedDB1.getName(), equalTo(BEFORE_SYNC_VALUE)); sharedDB2.setName(AFTER_SYNC_VALUE); sharedUtil.synchronizeConnections(sharedDB2, BEFORE_SYNC_VALUE); assertThat(sharedDB1.getName(), equalTo(AFTER_SYNC_VALUE)); } @Test public void synchronizeConnectionsRenameBackAndForth() throws Exception { final String databaseName = "SharedDB"; DatabaseMeta sharedDB0 = createDatabaseMeta(databaseName, true); saveSharedObjects(SHARED_OBJECTS_FILE, sharedDB0); TransMeta t1 = createTransMeta(); spoonDelegates.trans.addTransformation(t1); TransMeta t2 = createTransMeta(); spoonDelegates.trans.addTransformation(t2); final String name2 = "NAME 2"; DatabaseMeta sharedDB1 = t1.getDatabase(0); sharedDB1.setName(name2); when(spoon.getActiveMeta()).thenReturn(t1); sharedUtil.synchronizeConnections(sharedDB1, databaseName); DatabaseMeta sharedDB2 = t2.getDatabase(0); assertTrue(sharedDB2.getName().equals(name2)); when(spoon.getActiveMeta()).thenReturn(t2); sharedDB2.setName("name3"); sharedUtil.synchronizeConnections(sharedDB2, name2); assertTrue(sharedDB1.getName().equals(sharedDB2.getName())); } @Test public void synchronizeSlaveServerRenameBackAndForth() throws Exception { final String serverName = "SharedServer"; SlaveServer server0 = createSlaveServer(serverName, true); saveSharedObjects(SHARED_OBJECTS_FILE, server0); JobMeta j1 = createJobMeta(); spoonDelegates.jobs.addJob(j1); JobMeta j2 = createJobMeta(); spoonDelegates.jobs.addJob(j2); final String name2 = "NAME 2"; when(spoon.getActiveMeta()).thenReturn(j1); SlaveServer server1 = j1.getSlaveServers().get(0); server1.setName(name2); sharedUtil.synchronizeSlaveServers(server1, serverName); SlaveServer server2 = j2.getSlaveServers().get(0); assertTrue(server2.getName().equals(name2)); when(spoon.getActiveMeta()).thenReturn(j2); server2.setName("name3"); sharedUtil.synchronizeSlaveServers(server2, name2); assertTrue(server1.getName().equals(server2.getName())); } @Test public void synchronizeSlaveServerRenameRepository() throws Exception { try { spoon.rep = repository; final String objectId = "object-id"; final String serverName = "SharedServer"; JobMeta job1 = createJobMeta(); job1.setRepository(repository); job1.setSharedObjects(createSharedObjects(SHARED_OBJECTS_FILE)); SlaveServer server1 = createSlaveServer(serverName, false); server1.setObjectId(new StringObjectId(objectId)); job1.addOrReplaceSlaveServer(server1); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); job2.setRepository(repository); job2.setSharedObjects(createSharedObjects(SHARED_OBJECTS_FILE)); SlaveServer server2 = createSlaveServer(serverName, false); server2.setObjectId(new StringObjectId(objectId)); spoonDelegates.jobs.addJob(job2); server2.setName(AFTER_SYNC_VALUE); sharedUtil.synchronizeSlaveServers(server2); job2.addOrReplaceSlaveServer(server2); assertEquals(AFTER_SYNC_VALUE, job1.getSlaveServers().get(0).getName()); } finally { spoon.rep = null; } } @Test public void synchronizeSlaveServerDeleteFromRepository() throws Exception { try { spoon.rep = repository; when(spoon.getRepository()).thenReturn(repository); final String objectId = "object-id"; final String serverName = "SharedServer"; TransMeta trans = createTransMeta(); trans.setRepository(repository); trans.setSharedObjects(createSharedObjects(SHARED_OBJECTS_FILE)); SlaveServer server1 = createSlaveServer(serverName, false); server1.setObjectId(new StringObjectId(objectId)); trans.addOrReplaceSlaveServer(server1); spoon.delegates.trans.addTransformation(trans); JobMeta job = createJobMeta(); job.setRepository(repository); job.setSharedObjects(createSharedObjects(SHARED_OBJECTS_FILE)); SlaveServer server3 = createSlaveServer(serverName, false); server3.setObjectId(new StringObjectId(objectId)); job.addOrReplaceSlaveServer(server3); spoon.delegates.jobs.addJob(job); TransMeta trans2 = createTransMeta(); trans2.setRepository(repository); trans2.setSharedObjects(createSharedObjects(SHARED_OBJECTS_FILE)); SlaveServer server2 = createSlaveServer(serverName, false); server2.setObjectId(new StringObjectId(objectId)); trans2.addOrReplaceSlaveServer(server2); spoon.delegates.trans.addTransformation(trans2); assertFalse(trans.getSlaveServers().isEmpty()); assertFalse(job.getSlaveServers().isEmpty()); spoon.delegates.slaves.delSlaveServer(trans2, server2); verify(repository).deleteSlave(server2.getObjectId()); assertTrue(trans.getSlaveServers().isEmpty()); assertTrue(job.getSlaveServers().isEmpty()); } finally { spoon.rep = null; when(spoon.getRepository()).thenReturn(null); } } @Test public void synchronizePartitionSchemasDeleteFromRepository() throws Exception { try { spoon.rep = repository; when(spoon.getRepository()).thenReturn(repository); final String objectId = "object-id"; final String partitionName = "partsch"; TransMeta trans1 = createTransMeta(); trans1.setRepository(repository); trans1.setSharedObjects(createSharedObjects(SHARED_OBJECTS_FILE)); PartitionSchema part1 = createPartitionSchema(partitionName, false); part1.setObjectId(new StringObjectId(objectId)); trans1.addOrReplacePartitionSchema(part1); spoon.delegates.trans.addTransformation(trans1); TransMeta trans2 = createTransMeta(); trans2.setRepository(repository); trans2.setSharedObjects(createSharedObjects(SHARED_OBJECTS_FILE)); PartitionSchema part2 = createPartitionSchema(partitionName, false); part2.setObjectId(new StringObjectId(objectId)); trans2.addOrReplacePartitionSchema(part2); spoon.delegates.trans.addTransformation(trans2); assertFalse(trans1.getPartitionSchemas().isEmpty()); spoon.delegates.partitions.delPartitionSchema(trans2, part2); verify(repository).deletePartitionSchema(part2.getObjectId()); assertTrue(trans1.getPartitionSchemas().isEmpty()); } finally { spoon.rep = null; when(spoon.getRepository()).thenReturn(null); } } @Test public void synchronizeConnectionsOpenNew() throws Exception { final String databaseName = "SharedDB"; DatabaseMeta sharedDB0 = createDatabaseMeta(databaseName, true); saveSharedObjects(SHARED_OBJECTS_FILE, sharedDB0); JobMeta job1 = createJobMeta(); spoonDelegates.jobs.addJob(job1); DatabaseMeta sharedDB1 = job1.getDatabase(0); JobMeta job2 = createJobMeta(); spoonDelegates.jobs.addJob(job2); DatabaseMeta sharedDB2 = job2.getDatabase(0); assertThat(sharedDB1.getHostname(), equalTo(BEFORE_SYNC_VALUE)); sharedDB2.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeConnections(sharedDB2, sharedDB2.getName()); assertThat(sharedDB1.getHostname(), equalTo(AFTER_SYNC_VALUE)); JobMeta job3 = createJobMeta(); spoonDelegates.jobs.addJob(job3); DatabaseMeta sharedDB3 = job3.getDatabase(0); assertThat(sharedDB3.getHostname(), equalTo(AFTER_SYNC_VALUE)); } @Test public void synchronizeSlaveServers() throws Exception { final String slaveServerName = "SharedSlaveServer"; JobMeta job1 = createJobMeta(); SlaveServer slaveServer1 = createSlaveServer(slaveServerName, true); job1.setSlaveServers(Collections.singletonList(slaveServer1)); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); SlaveServer slaveServer2 = createSlaveServer(slaveServerName, true); job2.setSlaveServers(Collections.singletonList(slaveServer2)); spoonDelegates.jobs.addJob(job2); slaveServer2.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeSlaveServers(slaveServer2); assertThat(slaveServer1.getHostname(), equalTo(AFTER_SYNC_VALUE)); } @Test public void synchronizeSlaveServers_sync_shared_only() throws Exception { final String slaveServerName = "SlaveServer"; JobMeta job1 = createJobMeta(); SlaveServer slaveServer1 = createSlaveServer(slaveServerName, true); job1.setSlaveServers(Collections.singletonList(slaveServer1)); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); SlaveServer unsharedSlaveServer2 = createSlaveServer(slaveServerName, false); job2.setSlaveServers(Collections.singletonList(unsharedSlaveServer2)); spoonDelegates.jobs.addJob(job2); JobMeta job3 = createJobMeta(); SlaveServer slaveServer3 = createSlaveServer(slaveServerName, true); job3.setSlaveServers(Collections.singletonList(slaveServer3)); spoonDelegates.jobs.addJob(job3); slaveServer3.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeSlaveServers(slaveServer3); assertThat(slaveServer1.getHostname(), equalTo(AFTER_SYNC_VALUE)); assertThat(unsharedSlaveServer2.getHostname(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeSlaveServers_should_not_sync_unshared() throws Exception { final String slaveServerName = "SlaveServer"; JobMeta job1 = createJobMeta(); SlaveServer slaveServer1 = createSlaveServer(slaveServerName, true); job1.setSlaveServers(Collections.singletonList(slaveServer1)); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); SlaveServer slaveServer2 = createSlaveServer(slaveServerName, false); job2.setSlaveServers(Collections.singletonList(slaveServer2)); spoonDelegates.jobs.addJob(job2); slaveServer2.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeSlaveServers(slaveServer2); assertThat(slaveServer1.getHostname(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeSlaveServers_use_case_sensitive_name() throws Exception { JobMeta job1 = createJobMeta(); SlaveServer slaveServer1 = createSlaveServer("SlaveServer", true); job1.setSlaveServers(Collections.singletonList(slaveServer1)); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); SlaveServer slaveServer2 = createSlaveServer("Slaveserver", true); job2.setSlaveServers(Collections.singletonList(slaveServer2)); spoonDelegates.jobs.addJob(job2); slaveServer2.setHostname(AFTER_SYNC_VALUE); sharedUtil.synchronizeSlaveServers(slaveServer2); assertThat(slaveServer1.getHostname(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeSlaveServersRename() throws Exception { final String originalName = "slave"; SlaveServer slaveServer = createSlaveServer(originalName, true); saveSharedObjects(SHARED_OBJECTS_FILE, slaveServer); JobMeta job1 = createJobMeta(); spoonDelegates.jobs.addJob(job1); JobMeta job2 = createJobMeta(); spoonDelegates.jobs.addJob(job2); SlaveServer server1 = job1.getSlaveServers().get(0); SlaveServer server2 = job2.getSlaveServers().get(0); assertTrue(server1 != server2); final String newName = "spartacus"; server1.setName(newName); sharedUtil.synchronizeSlaveServers(server1, originalName); assertEquals(1, job1.getSlaveServerNames().length); server2 = job2.getSlaveServers().get(0); assertEquals(newName, server2.getName()); } @Test public void synchronizeClusterSchemas() throws Exception { final String clusterSchemaName = "SharedClusterSchema"; TransMeta transformarion1 = createTransMeta(); ClusterSchema clusterSchema1 = createClusterSchema(clusterSchemaName, true); transformarion1.setClusterSchemas(Collections.singletonList(clusterSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); ClusterSchema clusterSchema2 = createClusterSchema(clusterSchemaName, true); transformarion2.setClusterSchemas(Collections.singletonList(clusterSchema2)); spoonDelegates.trans.addTransformation(transformarion2); clusterSchema2.setDynamic(true); sharedUtil.synchronizeClusterSchemas(clusterSchema2); assertThat(clusterSchema1.isDynamic(), equalTo(true)); } @Test public void synchronizeClusterSchemas_sync_shared_only() throws Exception { final String clusterSchemaName = "ClusterSchema"; TransMeta transformarion1 = createTransMeta(); ClusterSchema clusterSchema1 = createClusterSchema(clusterSchemaName, true); transformarion1.setClusterSchemas(Collections.singletonList(clusterSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); ClusterSchema unsharedClusterSchema2 = createClusterSchema(clusterSchemaName, false); transformarion2.setClusterSchemas(Collections.singletonList(unsharedClusterSchema2)); spoonDelegates.trans.addTransformation(transformarion2); TransMeta transformarion3 = createTransMeta(); ClusterSchema clusterSchema3 = createClusterSchema(clusterSchemaName, true); transformarion3.setClusterSchemas(Collections.singletonList(clusterSchema3)); spoonDelegates.trans.addTransformation(transformarion3); clusterSchema3.setDynamic(true); sharedUtil.synchronizeClusterSchemas(clusterSchema3); assertThat(clusterSchema1.isDynamic(), equalTo(true)); assertThat(unsharedClusterSchema2.isDynamic(), equalTo(false)); } @Test public void synchronizeClusterSchemas_should_not_sync_unshared() throws Exception { final String clusterSchemaName = "ClusterSchema"; TransMeta transformarion1 = createTransMeta(); ClusterSchema clusterSchema1 = createClusterSchema(clusterSchemaName, true); transformarion1.setClusterSchemas(Collections.singletonList(clusterSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); ClusterSchema clusterSchema2 = createClusterSchema(clusterSchemaName, false); transformarion2.setClusterSchemas(Collections.singletonList(clusterSchema2)); spoonDelegates.trans.addTransformation(transformarion2); clusterSchema2.setDynamic(true); sharedUtil.synchronizeClusterSchemas(clusterSchema2); assertThat(clusterSchema1.isDynamic(), equalTo(false)); } @Test public void synchronizeClusterSchemas_use_case_sensitive_name() throws Exception { TransMeta transformarion1 = createTransMeta(); ClusterSchema clusterSchema1 = createClusterSchema("ClusterSchema", true); transformarion1.setClusterSchemas(Collections.singletonList(clusterSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); ClusterSchema clusterSchema2 = createClusterSchema("Clusterschema", true); transformarion2.setClusterSchemas(Collections.singletonList(clusterSchema2)); spoonDelegates.trans.addTransformation(transformarion2); clusterSchema2.setDynamic(true); sharedUtil.synchronizeClusterSchemas(clusterSchema2); assertThat(clusterSchema1.isDynamic(), equalTo(false)); } @Test public void synchronizePartitionSchemas() throws Exception { final String partitionSchemaName = "SharedPartitionSchema"; TransMeta transformarion1 = createTransMeta(); PartitionSchema partitionSchema1 = createPartitionSchema(partitionSchemaName, true); transformarion1.setPartitionSchemas(Collections.singletonList(partitionSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); PartitionSchema partitionSchema2 = createPartitionSchema(partitionSchemaName, true); transformarion2.setPartitionSchemas(Collections.singletonList(partitionSchema2)); spoonDelegates.trans.addTransformation(transformarion2); partitionSchema2.setNumberOfPartitionsPerSlave(AFTER_SYNC_VALUE); sharedUtil.synchronizePartitionSchemas(partitionSchema2); assertThat(partitionSchema1.getNumberOfPartitionsPerSlave(), equalTo(AFTER_SYNC_VALUE)); } @Test public void synchronizePartitionSchemas_sync_shared_only() throws Exception { final String partitionSchemaName = "PartitionSchema"; TransMeta transformarion1 = createTransMeta(); PartitionSchema partitionSchema1 = createPartitionSchema(partitionSchemaName, true); transformarion1.setPartitionSchemas(Collections.singletonList(partitionSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); PartitionSchema unsharedPartitionSchema2 = createPartitionSchema(partitionSchemaName, false); transformarion2.setPartitionSchemas(Collections.singletonList(unsharedPartitionSchema2)); spoonDelegates.trans.addTransformation(transformarion2); TransMeta transformarion3 = createTransMeta(); PartitionSchema partitionSchema3 = createPartitionSchema(partitionSchemaName, true); transformarion3.setPartitionSchemas(Collections.singletonList(partitionSchema3)); spoonDelegates.trans.addTransformation(transformarion3); partitionSchema3.setNumberOfPartitionsPerSlave(AFTER_SYNC_VALUE); sharedUtil.synchronizePartitionSchemas(partitionSchema3); assertThat(partitionSchema1.getNumberOfPartitionsPerSlave(), equalTo(AFTER_SYNC_VALUE)); assertThat(unsharedPartitionSchema2.getNumberOfPartitionsPerSlave(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizePartitionSchemas_should_not_sync_unshared() throws Exception { final String partitionSchemaName = "PartitionSchema"; TransMeta transformarion1 = createTransMeta(); PartitionSchema partitionSchema1 = createPartitionSchema(partitionSchemaName, true); transformarion1.setPartitionSchemas(Collections.singletonList(partitionSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); PartitionSchema partitionSchema2 = createPartitionSchema(partitionSchemaName, false); transformarion2.setPartitionSchemas(Collections.singletonList(partitionSchema2)); spoonDelegates.trans.addTransformation(transformarion2); partitionSchema2.setNumberOfPartitionsPerSlave(AFTER_SYNC_VALUE); sharedUtil.synchronizePartitionSchemas(partitionSchema2); assertThat(partitionSchema1.getNumberOfPartitionsPerSlave(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizePartitionSchemas_use_case_sensitive_name() throws Exception { TransMeta transformarion1 = createTransMeta(); PartitionSchema partitionSchema1 = createPartitionSchema("PartitionSchema", true); transformarion1.setPartitionSchemas(Collections.singletonList(partitionSchema1)); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); PartitionSchema partitionSchema2 = createPartitionSchema("Partitionschema", true); transformarion2.setPartitionSchemas(Collections.singletonList(partitionSchema2)); spoonDelegates.trans.addTransformation(transformarion2); partitionSchema2.setNumberOfPartitionsPerSlave(AFTER_SYNC_VALUE); sharedUtil.synchronizePartitionSchemas(partitionSchema2); assertThat(partitionSchema1.getNumberOfPartitionsPerSlave(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeSteps() throws Exception { final String stepName = "SharedStep"; TransMeta transformarion1 = createTransMeta(); StepMeta step1 = createStepMeta(stepName, true); transformarion1.addStep(step1); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); StepMeta step2 = createStepMeta(stepName, true); transformarion2.addStep(step2); spoonDelegates.trans.addTransformation(transformarion2); step2.setDescription(AFTER_SYNC_VALUE); sharedUtil.synchronizeSteps(step2); assertThat(step1.getDescription(), equalTo(AFTER_SYNC_VALUE)); } @Test public void synchronizeSteps_sync_shared_only() throws Exception { final String stepName = "Step"; TransMeta transformarion1 = createTransMeta(); StepMeta step1 = createStepMeta(stepName, true); transformarion1.addStep(step1); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); StepMeta unsharedStep2 = createStepMeta(stepName, false); transformarion2.addStep(unsharedStep2); spoonDelegates.trans.addTransformation(transformarion2); TransMeta transformarion3 = createTransMeta(); StepMeta step3 = createStepMeta(stepName, true); transformarion3.addStep(step3); spoonDelegates.trans.addTransformation(transformarion3); step3.setDescription(AFTER_SYNC_VALUE); sharedUtil.synchronizeSteps(step3); assertThat(step1.getDescription(), equalTo(AFTER_SYNC_VALUE)); assertThat(unsharedStep2.getDescription(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeSteps_should_not_sync_unshared() throws Exception { final String stepName = "Step"; TransMeta transformarion1 = createTransMeta(); StepMeta step1 = createStepMeta(stepName, true); transformarion1.addStep(step1); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); StepMeta step2 = createStepMeta(stepName, false); transformarion2.addStep(step2); spoonDelegates.trans.addTransformation(transformarion2); step2.setDescription(AFTER_SYNC_VALUE); sharedUtil.synchronizeSteps(step2); assertThat(step1.getDescription(), equalTo(BEFORE_SYNC_VALUE)); } @Test public void synchronizeSteps_use_case_sensitive_name() throws Exception { TransMeta transformarion1 = createTransMeta(); StepMeta step1 = createStepMeta("STEP", true); transformarion1.addStep(step1); spoonDelegates.trans.addTransformation(transformarion1); TransMeta transformarion2 = createTransMeta(); StepMeta step2 = createStepMeta("Step", true); transformarion2.addStep(step2); spoonDelegates.trans.addTransformation(transformarion2); step2.setDescription(AFTER_SYNC_VALUE); sharedUtil.synchronizeSteps(step2); assertThat(step1.getDescription(), equalTo(BEFORE_SYNC_VALUE)); } private JobMeta createJobMeta() throws Exception { JobMeta jobMeta = new JobMeta(); jobMeta.setName(UUID.randomUUID().toString()); jobMeta.setFilename(UUID.randomUUID().toString()); jobMeta.setRepositoryDirectory(mock(RepositoryDirectory.class)); // jobMeta.setSharedObjectsFile( SHARED_OBJECTS_FILE ); initSharedObjects(jobMeta, SHARED_OBJECTS_FILE); when(spoon.getActiveMeta()).thenReturn(jobMeta); return jobMeta; } private TransMeta createTransMeta() throws KettleException { TransMeta transMeta = new TransMeta(); transMeta.setName(UUID.randomUUID().toString()); transMeta.setFilename(UUID.randomUUID().toString()); RepositoryDirectory repositoryDirectory = mock(RepositoryDirectory.class); doCallRealMethod().when(repositoryDirectory).setName(anyString()); doCallRealMethod().when(repositoryDirectory).getName(); transMeta.setRepositoryDirectory(repositoryDirectory); initSharedObjects(transMeta, SHARED_OBJECTS_FILE); when(spoon.getActiveMeta()).thenReturn(transMeta); return transMeta; } private static void initSharedObjects(AbstractMeta meta, String sharedObjectsFile) throws KettleException { meta.setSharedObjectsFile(sharedObjectsFile); meta.setSharedObjects(meta.readSharedObjects()); } private static StepMeta createStepMeta(String name, boolean shared) { StepMeta stepMeta = new StepMeta(); stepMeta.setName(name); stepMeta.setDescription(BEFORE_SYNC_VALUE); stepMeta.setShared(shared); return stepMeta; } private static PartitionSchema createPartitionSchema(String name, boolean shared) { PartitionSchema partitionSchema = new PartitionSchema(); partitionSchema.setName(name); partitionSchema.setNumberOfPartitionsPerSlave(BEFORE_SYNC_VALUE); partitionSchema.setShared(shared); return partitionSchema; } private static SlaveServer createSlaveServer(String name, boolean shared) { SlaveServer slaveServer = new SlaveServer(); slaveServer.setHostname(BEFORE_SYNC_VALUE); slaveServer.setName(name); slaveServer.setShared(shared); return slaveServer; } private static ClusterSchema createClusterSchema(String name, boolean shared) { ClusterSchema clusterSchema = new ClusterSchema(); clusterSchema.setName(name); clusterSchema.setDescription(BEFORE_SYNC_VALUE); clusterSchema.setDynamic(false); clusterSchema.setShared(shared); return clusterSchema; } private static DatabaseMeta createDatabaseMeta(String name, boolean shared) { DatabaseMeta database = new DatabaseMeta(); database.setName(name); database.setShared(shared); database.setHostname(BEFORE_SYNC_VALUE); return database; } private SharedObjects saveSharedObjects(String location, SharedObjectInterface... objects) throws Exception { SharedObjects sharedObjects = createSharedObjects(location, objects); sharedObjects.saveToFile(); return sharedObjects; } private static SharedObjects createSharedObjects(String location, SharedObjectInterface... objects) throws KettleXMLException { SharedObjects sharedObjects = new SharedObjects(location); for (SharedObjectInterface sharedObject : objects) { sharedObjects.storeObject(sharedObject); } return sharedObjects; } }