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