KettleDatabaseRepository_GetObjectInformation_Test.java

/*! ******************************************************************************
 *
 * Pentaho Data Integration
 *
 * Copyright (C) 2002-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.repository.kdr;

import static org.junit.Assert.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;

import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;

import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.pentaho.di.core.KettleEnvironment;
import org.pentaho.di.core.RowMetaAndData;
import org.pentaho.di.core.row.RowMeta;
import org.pentaho.di.core.row.ValueMetaInterface;
import org.pentaho.di.core.row.value.ValueMetaFactory;
import org.pentaho.di.repository.ObjectId;
import org.pentaho.di.repository.RepositoryDirectoryInterface;
import org.pentaho.di.repository.RepositoryObject;
import org.pentaho.di.repository.RepositoryObjectType;
import org.pentaho.di.repository.StringObjectId;
import org.pentaho.di.repository.kdr.delegates.KettleDatabaseRepositoryDatabaseDelegate;
import org.pentaho.di.repository.kdr.delegates.KettleDatabaseRepositoryJobDelegate;
import org.pentaho.di.repository.kdr.delegates.KettleDatabaseRepositoryTransDelegate;

/**
 * @author Andrey Khayrutdinov
 */
public class KettleDatabaseRepository_GetObjectInformation_Test {
  private static final String ABSENT_ID = "non-existing object";
  private static final String EXISTING_ID = "existing object";

  @BeforeClass
  public static void initKettle() throws Exception {
    KettleEnvironment.init();
  }


  private KettleDatabaseRepository repository;
  private RepositoryDirectoryInterface directoryInterface;

  @Before
  public void setUp() throws Exception {
    directoryInterface = mock( RepositoryDirectoryInterface.class );

    repository = spy( new KettleDatabaseRepository() );
    doReturn( directoryInterface ).when( repository ).loadRepositoryDirectoryTree();
    doReturn( directoryInterface )
      .when( repository )
      .loadRepositoryDirectoryTree( any( RepositoryDirectoryInterface.class ) );
  }


  @Test
  public void getObjectInformation_AbsentJob_IsDeletedFlagSet() throws Exception {
    KettleDatabaseRepositoryJobDelegate jobDelegate =
      spy( new KettleDatabaseRepositoryJobDelegate( repository ) );

    RowMeta meta = createMetaForJob();
    doReturn( new RowMetaAndData( meta, new Object[ meta.size() ] ) )
      .when( jobDelegate )
      .getJob( new StringObjectId( ABSENT_ID ) );

    assertIsDeletedSet_ForAbsentObject( null, jobDelegate, RepositoryObjectType.JOB );
  }

  @Test
  public void getObjectInformation_AbsentTrans_IsDeletedFlagSet() throws Exception {
    KettleDatabaseRepositoryTransDelegate transDelegate =
      spy( new KettleDatabaseRepositoryTransDelegate( repository ) );

    RowMeta meta = createMetaForTrans();
    doReturn( new RowMetaAndData( meta, new Object[ meta.size() ] ) )
      .when( transDelegate )
      .getTransformation( new StringObjectId( ABSENT_ID ) );

    assertIsDeletedSet_ForAbsentObject( transDelegate, null, RepositoryObjectType.TRANSFORMATION );
  }

  private void assertIsDeletedSet_ForAbsentObject( KettleDatabaseRepositoryTransDelegate transDelegate,
                                                   KettleDatabaseRepositoryJobDelegate jobDelegate,
                                                   RepositoryObjectType objectType )
    throws Exception {
    repository.transDelegate = transDelegate;
    repository.jobDelegate = jobDelegate;

    when( directoryInterface.findDirectory( any( ObjectId.class ) ) ).thenReturn( null );

    RepositoryObject object = repository.getObjectInformation( new StringObjectId( ABSENT_ID ), objectType );
    assertTrue( object.isDeleted() );
  }


  @Test
  public void getObjectInformation_ExistingJob_IsDeletedFlagNotSet() throws Exception {
    KettleDatabaseRepositoryJobDelegate jobDelegate =
      spy( new KettleDatabaseRepositoryJobDelegate( repository ) );

    RowMeta meta = createMetaForJob();
    Object[] values = new Object[ meta.size() ];
    values[ Arrays.asList( meta.getFieldNames() ).indexOf( KettleDatabaseRepositoryBase.FIELD_JOB_NAME ) ] = EXISTING_ID;
    doReturn( new RowMetaAndData( meta, values ) )
      .when( jobDelegate )
      .getJob( new StringObjectId( EXISTING_ID ) );

    assertIsDeletedNotSet_ForExistingObject( null, jobDelegate, RepositoryObjectType.JOB );
  }

  @Test
  public void getObjectInformation_ExistingTrans_IsDeletedFlagNotSet() throws Exception {
    KettleDatabaseRepositoryTransDelegate transDelegate =
      spy( new KettleDatabaseRepositoryTransDelegate( repository ) );

    RowMeta meta = createMetaForJob();
    Object[] values = new Object[ meta.size() ];
    values[ Arrays.asList( meta.getFieldNames() ).indexOf( KettleDatabaseRepositoryBase.FIELD_TRANSFORMATION_NAME ) ] = EXISTING_ID;
    doReturn( new RowMetaAndData( meta, values ) )
      .when( transDelegate )
      .getTransformation( new StringObjectId( EXISTING_ID ) );

    assertIsDeletedNotSet_ForExistingObject( transDelegate, null, RepositoryObjectType.TRANSFORMATION );
  }

  @Test
  public void getObjectInformation_GetDatabaseInformation() throws Exception {
    KettleDatabaseRepositoryDatabaseDelegate databaseDelegate =
        spy( new KettleDatabaseRepositoryDatabaseDelegate( repository ) );
    repository.databaseDelegate = databaseDelegate;
    RowMeta meta = createMetaForDatabase();
    Object[] values = new Object[ meta.size() ];
    values[ Arrays.asList( meta.getFieldNames() ).indexOf( KettleDatabaseRepositoryBase.FIELD_DATABASE_NAME ) ] = EXISTING_ID;
    doReturn( new RowMetaAndData( meta, values ) )
      .when( databaseDelegate )
      .getDatabase( new StringObjectId( EXISTING_ID ) );
    RepositoryObject actual = repository.getObjectInformation( new StringObjectId( EXISTING_ID ), RepositoryObjectType.DATABASE );

    assertEquals( new StringObjectId( EXISTING_ID ), actual.getObjectId() );
    assertEquals( EXISTING_ID, actual.getName() );
    assertEquals( RepositoryObjectType.DATABASE, actual.getObjectType() );
  }

  private void assertIsDeletedNotSet_ForExistingObject( KettleDatabaseRepositoryTransDelegate transDelegate,
                                                        KettleDatabaseRepositoryJobDelegate jobDelegate,
                                                        RepositoryObjectType objectType )
    throws Exception {
    repository.transDelegate = transDelegate;
    repository.jobDelegate = jobDelegate;

    when( directoryInterface.findDirectory( any( ObjectId.class ) ) ).thenReturn( null );

    RepositoryObject object = repository.getObjectInformation( new StringObjectId( EXISTING_ID ), objectType );
    assertFalse( object.isDeleted() );
  }


  private static RowMeta createMetaForJob() throws Exception {
    LinkedHashMap<String, Integer> fields = new LinkedHashMap<String, Integer>();
    fields.put( KettleDatabaseRepositoryBase.FIELD_JOB_NAME, ValueMetaInterface.TYPE_STRING );
    fields.put( KettleDatabaseRepositoryBase.FIELD_JOB_DESCRIPTION, ValueMetaInterface.TYPE_STRING );
    fields.put( KettleDatabaseRepositoryBase.FIELD_JOB_MODIFIED_USER, ValueMetaInterface.TYPE_STRING );
    fields.put( KettleDatabaseRepositoryBase.FIELD_JOB_MODIFIED_DATE, ValueMetaInterface.TYPE_DATE );
    fields.put( KettleDatabaseRepositoryBase.FIELD_JOB_ID_DIRECTORY, ValueMetaInterface.TYPE_INTEGER );
    return createMeta( fields );
  }

  private static RowMeta createMetaForTrans() throws Exception {
    LinkedHashMap<String, Integer> fields = new LinkedHashMap<String, Integer>();
    fields.put( KettleDatabaseRepositoryBase.FIELD_TRANSFORMATION_NAME, ValueMetaInterface.TYPE_STRING );
    fields.put( KettleDatabaseRepositoryBase.FIELD_TRANSFORMATION_DESCRIPTION, ValueMetaInterface.TYPE_STRING );
    fields.put( KettleDatabaseRepositoryBase.FIELD_TRANSFORMATION_MODIFIED_USER, ValueMetaInterface.TYPE_STRING );
    fields.put( KettleDatabaseRepositoryBase.FIELD_TRANSFORMATION_MODIFIED_DATE, ValueMetaInterface.TYPE_DATE );
    fields.put( KettleDatabaseRepositoryBase.FIELD_TRANSFORMATION_ID_DIRECTORY, ValueMetaInterface.TYPE_INTEGER );
    return createMeta( fields );
  }

  private static RowMeta createMetaForDatabase() throws Exception {
    LinkedHashMap<String, Integer> fields = new LinkedHashMap<String, Integer>();
    fields.put( KettleDatabaseRepositoryBase.FIELD_DATABASE_NAME, ValueMetaInterface.TYPE_STRING );
    return createMeta( fields );
  }

  private static RowMeta createMeta( LinkedHashMap<String, Integer> fields ) throws Exception {
    RowMeta meta = new RowMeta();
    for ( Map.Entry<String, Integer> entry : fields.entrySet() ) {
      meta.addValueMeta( ValueMetaFactory.createValueMeta( entry.getKey(), entry.getValue() ) );
    }
    return meta;
  }
}