catalog-be/src/test/java/org/openecomp/sdc/common/transaction/mngr/SdncTransactionTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * SDC
   4  * ================================================================================
   5  * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 package org.openecomp.sdc.common.transaction.mngr;
  22
  23 import fj.data.Either;
  24 import org.junit.Before;
  25 import org.junit.BeforeClass;
  26 import org.junit.Test;
  27 import org.mockito.Mockito;
  28 import org.openecomp.sdc.be.config.ConfigurationManager;
  29 import org.openecomp.sdc.be.dao.api.ResourceUploadStatus;
  30 import org.openecomp.sdc.be.dao.impl.ESCatalogDAO;
  31 import org.openecomp.sdc.be.dao.titan.TitanGenericDao;
  32 import org.openecomp.sdc.be.dao.titan.TitanOperationStatus;
  33 import org.openecomp.sdc.be.resources.data.ESArtifactData;
  34 import org.openecomp.sdc.common.api.ConfigurationSource;
  35 import org.openecomp.sdc.common.impl.ExternalConfiguration;
  36 import org.openecomp.sdc.common.impl.FSConfigurationSource;
  37 import org.openecomp.sdc.common.transaction.api.IDBAction;
  38 import org.openecomp.sdc.common.transaction.api.RollbackHandler;
  39 import org.openecomp.sdc.common.transaction.api.TransactionUtils;
  40 import org.openecomp.sdc.common.transaction.api.TransactionUtils.ActionTypeEnum;
  41 import org.openecomp.sdc.common.transaction.api.TransactionUtils.DBActionCodeEnum;
  42 import org.openecomp.sdc.common.transaction.api.TransactionUtils.DBTypeEnum;
  43 import org.openecomp.sdc.common.transaction.api.TransactionUtils.ESActionTypeEnum;
  44 import org.openecomp.sdc.common.transaction.api.TransactionUtils.LogMessages;
  45 import org.openecomp.sdc.common.transaction.api.TransactionUtils.TransactionCodeEnum;
  46 import org.openecomp.sdc.common.transaction.api.TransactionUtils.TransactionStatusEnum;
  47 import org.slf4j.Logger;
  48
  49 import static org.junit.Assert.assertTrue;
  50 import static org.mockito.Mockito.reset;
  51 import static org.mockito.Mockito.times;
  52 import static org.mockito.Mockito.verify;
  53 import static org.mockito.Mockito.when;
  54
  55 public class SdncTransactionTest {
  56     private static ESCatalogDAO esCatalogDao = Mockito.mock(ESCatalogDAO.class);
  57     private static TitanGenericDao titanGenericDao = Mockito.mock(TitanGenericDao.class);
  58     private static final Logger log = Mockito.spy(Logger.class);
  59     private static int transactionId = 0;
  60     private static ConfigurationManager configurationManager;
  61
  62     public enum TestAction {
  63         TitanAction, Rollback, GeneralAction
  64     }
  65
  66     public enum TestResponse {
  67         TitanResponseSuccess, GeneralSuccess
  68     }
  69
  70     @BeforeClass
  71     public static void beforeClass() {
  72         TransactionSdncImpl.setLog(log);
  73         CommitManager.setLog(log);
  74         RollbackHandler.setLog(log);
  75         String appConfigDir = "src/test/resources/config/catalog-be";
  76         ConfigurationSource configurationSource = new FSConfigurationSource(ExternalConfiguration.getChangeListener(), appConfigDir);
  77         configurationManager = new ConfigurationManager(configurationSource);
  78     }
  79
  80     @Before
  81     public void beforeTest() {
  82         reset(log);
  83         reset(esCatalogDao);
  84         reset(titanGenericDao);
  85     }
  86
  87     @Test
  88     public void testInvokeTitanAction() {
  89         int transactionId = getNextTransactionId();
  90         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
  91
  92         doBasicTitanAction(transactionId, tx, false, true);
  93         assertTrue(tx.getStatus() == TransactionStatusEnum.OPEN);
  94     }
  95
  96     @Test
  97     public void testInvokeESAction() {
  98         int transactionId = getNextTransactionId();
  99         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 100
 101         doESAddArtifactAction(transactionId, tx, true, true);
 102         assertTrue(tx.getStatus() == TransactionStatusEnum.OPEN);
 103     }
 104
 105     @Test
 106     public void testfinishTransaction() {
 107         int transactionId = getNextTransactionId();
 108         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 109         doFinishTransaction(transactionId, tx, true);
 110         assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
 111     }
 112
 113     @Test
 114     public void testFinishOnClosedTransaction() {
 115         int transactionId = getNextTransactionId();
 116         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 117         doFinishTransaction(transactionId, tx, true);
 118
 119         TransactionCodeEnum finishTransaction = tx.finishTransaction();
 120         assertTrue(finishTransaction == TransactionCodeEnum.TRANSACTION_CLOSED);
 121         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.COMMIT_ON_CLOSED_TRANSACTION, transactionId, TransactionStatusEnum.CLOSED.name(), TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 122         assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
 123
 124     }
 125
 126     @Test
 127     public void testCallingLastActionTwice() {
 128         int transactionId = getNextTransactionId();
 129         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 130         doBasicTitanAction(transactionId, tx, true, true);
 131         Either<TestResponse, TransactionCodeEnum> doBasicTitanAction = doBasicTitanAction(transactionId, tx, true, false);
 132         assertTrue(doBasicTitanAction.isRight());
 133         assertTrue(tx.getStatus() != TransactionStatusEnum.OPEN);
 134         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DOUBLE_FINISH_FLAG_ACTION, transactionId, DBTypeEnum.TITAN.name(), TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 135     }
 136
 137     @Test
 138     public void testActionOnClosedTransaction() {
 139         int transactionId = getNextTransactionId();
 140         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 141         doFinishTransaction(transactionId, tx, true);
 142
 143         Either<DBActionCodeEnum, TransactionCodeEnum> eitherESResult = tx.invokeESAction(false, ESActionTypeEnum.ADD_ARTIFACT, createDummyArtifactData());
 144         assertTrue(eitherESResult.isRight());
 145         assertTrue(eitherESResult.right().value() == TransactionCodeEnum.TRANSACTION_CLOSED);
 146
 147         Either<Object, TransactionCodeEnum> eitherTitanResult = tx.invokeTitanAction(false, createBasicAction(TestAction.TitanAction, TestResponse.TitanResponseSuccess));
 148         assertTrue(eitherTitanResult.isRight());
 149         assertTrue(eitherTitanResult.right().value() == TransactionCodeEnum.TRANSACTION_CLOSED);
 150
 151         Either<Object, TransactionCodeEnum> eitherGeneralDBAction = tx.invokeGeneralDBAction(true, DBTypeEnum.TITAN, createBasicAction(TestAction.TitanAction, TestResponse.TitanResponseSuccess),
 152                 createBasicAction(TestAction.Rollback, TestResponse.TitanResponseSuccess));
 153         assertTrue(eitherGeneralDBAction.isRight());
 154         assertTrue(eitherGeneralDBAction.right().value() == TransactionCodeEnum.TRANSACTION_CLOSED);
 155
 156         assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
 157         verify(log, times(3)).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.ACTION_ON_CLOSED_TRANSACTION, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 158
 159     }
 160
 161     @Test
 162     public void testBasicHappyScenario() {
 163         int transactionId = getNextTransactionId();
 164         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 165
 166         doBasicTitanAction(transactionId, tx, false, true);
 167         assertTrue(tx.getStatus() == TransactionStatusEnum.OPEN);
 168
 169         doESAddArtifactAction(transactionId, tx, true, true);
 170         assertTrue(tx.getStatus() == TransactionStatusEnum.OPEN);
 171
 172         doFinishTransaction(transactionId, tx, true);
 173
 174         assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
 175
 176     }
 177
 178     @Test
 179     public void testRollbackSucceededOnAction() {
 180         int transactionId = getNextTransactionId();
 181         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 182         doESAddArtifactAction(transactionId, tx, false, true);
 183
 184         when(titanGenericDao.rollback()).thenReturn(TitanOperationStatus.OK);
 185         String crushMessage = "DB Crush Simulation";
 186         Either<TestResponse, TransactionCodeEnum> eitherTransactionResult = tx.invokeTitanAction(false, createCrushingAction(TestAction.TitanAction, crushMessage));
 187
 188         assertTrue(eitherTransactionResult.isRight());
 189         assertTrue(eitherTransactionResult.right().value() == TransactionCodeEnum.ROLLBACK_SUCCESS);
 190         assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
 191         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION, DBTypeEnum.TITAN.name(), transactionId, crushMessage, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 192
 193         verify(log, times(1)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 194         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 195
 196         verify(log, times(1)).debug(LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 197         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 198
 199         verify(log).info(LogMessages.ROLLBACK_SUCCEEDED_GENERAL, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 200         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_SUCCEEDED_GENERAL, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 201     }
 202
 203     @Test
 204     public void testRollbackFailedOnAction() {
 205         int transactionId = getNextTransactionId();
 206         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 207
 208         doESAddArtifactAction(transactionId, tx, false, true);
 209
 210         when(titanGenericDao.rollback()).thenReturn(TitanOperationStatus.NOT_CONNECTED);
 211         String crushMessage = "DB Crush Simulation";
 212         Either<TestResponse, TransactionCodeEnum> eitherTransactionResult = tx.invokeTitanAction(false, createCrushingAction(TestAction.TitanAction, crushMessage));
 213
 214         assertTrue(eitherTransactionResult.isRight());
 215         assertTrue(tx.getStatus() == TransactionStatusEnum.FAILED_ROLLBACK);
 216         assertTrue(eitherTransactionResult.right().value() == TransactionCodeEnum.ROLLBACK_FAILED);
 217         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION, DBTypeEnum.TITAN.name(), transactionId, crushMessage, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 218
 219         verify(log, times(1)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 220         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 221
 222         verify(log, times(1)).debug(LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 223         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 224     }
 225
 226     @Test
 227     public void testRollbackSucceededOnCommit() {
 228         int transactionId = getNextTransactionId();
 229         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 230         doESAddArtifactAction(transactionId, tx, false, true);
 231         doBasicTitanAction(transactionId, tx, true, true);
 232
 233         when(titanGenericDao.commit()).thenReturn(TitanOperationStatus.GENERAL_ERROR);
 234         when(titanGenericDao.rollback()).thenReturn(TitanOperationStatus.OK);
 235         // finishTransaction
 236         TransactionCodeEnum transactionCode = tx.finishTransaction();
 237         assertTrue(transactionCode == TransactionCodeEnum.ROLLBACK_SUCCESS);
 238         assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
 239
 240         verify(log, times(1)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 241         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 242
 243         verify(log, times(1)).debug(LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 244         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 245
 246         verify(log).info(LogMessages.ROLLBACK_SUCCEEDED_GENERAL, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 247         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_SUCCEEDED_GENERAL, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 248     }
 249
 250     @Test
 251     public void testRollbackFailedOnCommit() {
 252         int transactionId = getNextTransactionId();
 253         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 254         doESAddArtifactAction(transactionId, tx, false, true);
 255         doBasicTitanAction(transactionId, tx, true, true);
 256
 257         when(titanGenericDao.commit()).thenReturn(TitanOperationStatus.GENERAL_ERROR);
 258         when(titanGenericDao.rollback()).thenReturn(TitanOperationStatus.OK);
 259         String esError = "No Connection to Es";
 260         Mockito.doThrow(new RuntimeException(esError)).when(esCatalogDao).deleteArtifact(Mockito.anyString());
 261         // finishTransaction
 262         TransactionCodeEnum transactionCode = tx.finishTransaction();
 263         assertTrue(transactionCode == TransactionCodeEnum.ROLLBACK_FAILED);
 264         assertTrue(tx.getStatus() == TransactionStatusEnum.FAILED_ROLLBACK);
 265
 266         verify(log, times(1)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 267         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.ELASTIC_SEARCH.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 268
 269         verify(log, times(1)).debug(LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 270         verify(log, times(1)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_NON_PERSISTENT_ACTION, DBTypeEnum.TITAN.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 271     }
 272
 273     @Test
 274     public void testInvokeGeneralAction() {
 275         when(titanGenericDao.rollback()).thenReturn(TitanOperationStatus.OK);
 276         int transactionId = getNextTransactionId();
 277         TransactionSdncImpl tx = new TransactionSdncImpl(transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT, esCatalogDao, titanGenericDao);
 278         IDBAction generalAction = createBasicAction(TestAction.GeneralAction, TestResponse.GeneralSuccess);
 279         IDBAction rollbackAction = createBasicAction(TestAction.Rollback, TestResponse.GeneralSuccess);
 280         String crushMessage = "No DB Connection";
 281         IDBAction crushingAction = createCrushingAction(TestAction.GeneralAction, crushMessage);
 282
 283         Either<TestResponse, TransactionCodeEnum> eitherResult = tx.invokeGeneralDBAction(false, DBTypeEnum.MYSTERY, generalAction, rollbackAction);
 284         assertTrue(eitherResult.isLeft());
 285         assertTrue(eitherResult.left().value() == TestResponse.GeneralSuccess);
 286         assertTrue(tx.getStatus() == TransactionStatusEnum.OPEN);
 287         eitherResult = tx.invokeGeneralDBAction(false, DBTypeEnum.MYSTERY, crushingAction, rollbackAction);
 288
 289         assertTrue(eitherResult.isRight());
 290         assertTrue(eitherResult.right().value() == TransactionCodeEnum.ROLLBACK_SUCCESS);
 291         assertTrue(tx.getStatus() == TransactionStatusEnum.CLOSED);
 292
 293         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.DB_ACTION_FAILED_WITH_EXCEPTION, DBTypeEnum.MYSTERY.name(), transactionId, crushMessage, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 294
 295         verify(log, times(2)).debug(LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.MYSTERY.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 296         verify(log, times(2)).debug(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_PERSISTENT_ACTION, DBTypeEnum.MYSTERY.name(), transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 297
 298         verify(log).info(LogMessages.ROLLBACK_SUCCEEDED_GENERAL, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 299         verify(log).info(TransactionUtils.TRANSACTION_MARKER, LogMessages.ROLLBACK_SUCCEEDED_GENERAL, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 300
 301     }
 302
 303     private Either<TestResponse, TransactionCodeEnum> doBasicTitanAction(int transactionId, TransactionSdncImpl tx, boolean isLastAction, boolean isVerifyAction) {
 304         // Add Titan Action
 305         Either<TestResponse, TransactionCodeEnum> eitherTitanResult = tx.invokeTitanAction(isLastAction, createBasicAction(TestAction.TitanAction, TestResponse.TitanResponseSuccess));
 306         if (isVerifyAction) {
 307             // Check Titan Action
 308             assertTrue(eitherTitanResult.isLeft());
 309             assertTrue(eitherTitanResult.left().value() == TestResponse.TitanResponseSuccess);
 310             verify(log).debug(TestAction.TitanAction.name());
 311             verify(log).debug(LogMessages.INVOKE_ACTION, transactionId, DBTypeEnum.TITAN.name(), TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 312             verifyNoErrorsInLog();
 313             verifyNoInfoInLog();
 314         }
 315         return eitherTitanResult;
 316     }
 317
 318     private TransactionCodeEnum doFinishTransaction(int transactionId, TransactionSdncImpl tx, boolean isVerifyAction) {
 319         // Prerequisite finishTransaction
 320         when(titanGenericDao.commit()).thenReturn(TitanOperationStatus.OK);
 321         // finishTransaction
 322         TransactionCodeEnum transactionCode = tx.finishTransaction();
 323         if (isVerifyAction) {
 324             // Check finishTransaction
 325             verify(log).debug(LogMessages.COMMIT_ACTION_ALL_DB, transactionId, TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 326             verify(log).debug(LogMessages.COMMIT_ACTION_SPECIFIC_DB, transactionId, DBTypeEnum.TITAN.name(), TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 327             assertTrue(transactionCode == TransactionCodeEnum.SUCCESS);
 328         }
 329         return transactionCode;
 330     }
 331
 332     private void doESAddArtifactAction(int transactionId, TransactionSdncImpl tx, boolean isLastAction, boolean isVerifyAction) {
 333         // Prerequisite ES Action
 334         Either<ESArtifactData, ResourceUploadStatus> eitherBeforeAddArtifact = Either.right(ResourceUploadStatus.NOT_EXIST);
 335         when(esCatalogDao.getArtifact(Mockito.anyString())).thenReturn(eitherBeforeAddArtifact);
 336
 337         // Add ES Action
 338         Either<DBActionCodeEnum, TransactionCodeEnum> eitherEsAction = tx.invokeESAction(isLastAction, ESActionTypeEnum.ADD_ARTIFACT, createDummyArtifactData());
 339
 340         if (isVerifyAction) {
 341             // Check Titan Action
 342             assertTrue(eitherEsAction.isLeft());
 343             assertTrue(eitherEsAction.left().value() == DBActionCodeEnum.SUCCESS);
 344             verify(log).debug(LogMessages.INVOKE_ACTION, transactionId, DBTypeEnum.ELASTIC_SEARCH.name(), TransactionUtils.DUMMY_USER, ActionTypeEnum.ADD_ARTIFACT.name());
 345             verifyNoErrorsInLog();
 346             verifyNoInfoInLog();
 347         }
 348     }
 349
 350     private ESArtifactData createDummyArtifactData() {
 351         String strData = "qweqwqweqw34e4wrwer";
 352         ESArtifactData arData = new ESArtifactData("artifactNewMarina11", strData.getBytes());
 353         return arData;
 354     }
 355
 356     private void verifyNoErrorsInLog() {
 357         verify(log, Mockito.times(0)).error(Mockito.anyString(), Mockito.any(Object[].class));
 358         verify(log, Mockito.times(0)).error(Mockito.anyString());
 359     }
 360
 361     private void verifyNoInfoInLog() {
 362         verify(log, Mockito.times(0)).info(Mockito.anyString(), Mockito.any(Object[].class));
 363         verify(log, Mockito.times(0)).info(Mockito.anyString());
 364     }
 365
 366     private IDBAction createBasicAction(TestAction action, TestResponse resp) {
 367         final TestAction finalAction = action;
 368         final TestResponse finalResp = resp;
 369         return new IDBAction() {
 370             @Override
 371             public TestResponse doAction() {
 372                 log.debug(finalAction.name());
 373                 return finalResp;
 374             }
 375         };
 376     }
 377
 378     private IDBAction createCrushingAction(TestAction action, final String crushMessage) {
 379         final TestAction finalAction = action;
 380         return new IDBAction() {
 381             @Override
 382             public TestResponse doAction() {
 383                 log.debug(finalAction.name());
 384                 throw new RuntimeException(crushMessage);
 385             }
 386         };
 387     }
 388
 389     public int getNextTransactionId() {
 390         transactionId++;
 391         return transactionId;
 392     }
 393 }