org.openmrs.module.sync.api.db.hibernate.HibernateSyncInterceptorTransactionTest.java Source code

Introduction

Here is the source code for org.openmrs.module.sync.api.db.hibernate.HibernateSyncInterceptorTransactionTest.java

Source

/**
 * The contents of this file are subject to the OpenMRS Public License
 * Version 1.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://license.openmrs.org
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
 * License for the specific language governing rights and limitations
 * under the License.
 *
 * Copyright (C) OpenMRS, LLC.  All Rights Reserved.
 */
package org.openmrs.module.sync.api.db.hibernate;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dbunit.database.DatabaseConfig;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.ext.hsqldb.HsqldbDataTypeFactory;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.openmrs.EncounterType;
import org.openmrs.VisitType;
import org.openmrs.api.context.Context;
import org.openmrs.module.sync.TestUtil;
import org.openmrs.module.sync.test.ExampleTransactionalService;
import org.openmrs.test.BaseModuleContextSensitiveTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.NotTransactional;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.transaction.AfterTransaction;
import org.springframework.test.context.transaction.BeforeTransaction;
import org.springframework.transaction.annotation.Transactional;

import java.io.StringWriter;

/**
 * Tests transaction handling of the HibernateSyncInterceptor
 */
public class HibernateSyncInterceptorTransactionTest extends BaseModuleContextSensitiveTest {

    protected final Log log = LogFactory.getLog(getClass());

    private static final String ENCOUNTER_TYPE = "Test Encounter Type";
    private static final String VISIT_TYPE = "Visit Type";
    private static final String EXCEPTION_MESSAGE = "Test Exception";

    @Autowired
    ExampleTransactionalService testService;

    @Before
    @Override
    public void baseSetupWithStandardDataAndAuthentication() throws Exception {
    }

    @After
    @Override
    public void deleteAllData() throws Exception {
    }

    @BeforeTransaction
    public void beforeTx() throws Exception {
        Context.openSession();
        initializeInMemoryDatabase();
        executeDataSet(EXAMPLE_XML_DATASET_PACKAGE_PATH);
        executeDataSet(
                "org/openmrs/module/sync/include/" + new TestUtil().getTestDatasetFilename("syncCreateTest"));
        authenticate();
    }

    @AfterTransaction
    public void afterTx() throws Exception {
        if (log.isDebugEnabled()) {
            log.debug("====== ENCOUNTER_TYPE =========");
            log.debug(getTableContents("encounter_type"));
            log.debug("====== VISIT_TYPE =========");
            log.debug(getTableContents("visit_type"));
            log.debug("====== SYNC_RECORD =========");
            log.debug(getTableContents("sync_record"));
        }
        if (checkTableContains("encounter_type", ENCOUNTER_TYPE)) {
            Assert.assertTrue("Encounter Type saved, but Sync Record was not",
                    checkTableContains("sync_record", ENCOUNTER_TYPE));
        } else {
            Assert.assertFalse("Encounter Type not saved, but Sync Record was",
                    checkTableContains("sync_record", ENCOUNTER_TYPE));
        }
        if (checkTableContains("visit_type", VISIT_TYPE)) {
            Assert.assertTrue("Visit Type saved, but Sync Record was not",
                    checkTableContains("sync_record", VISIT_TYPE));
        } else {
            Assert.assertFalse("Visit Type not saved, but Sync Record was",
                    checkTableContains("sync_record", VISIT_TYPE));
        }
        super.deleteAllData();
    }

    @Test
    @Transactional
    @Rollback(false)
    public void shouldTestAllInSameTx() throws Exception {
        {
            EncounterType encounterType = new EncounterType();
            encounterType.setName(ENCOUNTER_TYPE);
            encounterType.setDescription("Encounter Type Description");
            testService.saveObjectInTransaction(encounterType);
        }
        {
            VisitType visitType = new VisitType();
            visitType.setName(VISIT_TYPE);
            visitType.setDescription("Visit Type Description");
            testService.saveObjectInTransaction(visitType);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void shouldTestFirstInNewTx() throws Exception {
        {
            EncounterType encounterType = new EncounterType();
            encounterType.setName(ENCOUNTER_TYPE);
            encounterType.setDescription("Encounter Type Description");
            testService.saveObjectInNewTransaction(encounterType);
        }
        {
            VisitType visitType = new VisitType();
            visitType.setName(VISIT_TYPE);
            visitType.setDescription("Visit Type Description");
            testService.saveObjectInTransaction(visitType);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void shouldTestSecondInNewTx() throws Exception {
        {
            EncounterType encounterType = new EncounterType();
            encounterType.setName(ENCOUNTER_TYPE);
            encounterType.setDescription("Encounter Type Description");
            testService.saveObjectInTransaction(encounterType);
        }
        {
            VisitType visitType = new VisitType();
            visitType.setName(VISIT_TYPE);
            visitType.setDescription("Visit Type Description");
            testService.saveObjectInNewTransaction(visitType);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void shouldTestBothInNewTx() throws Exception {
        {
            EncounterType encounterType = new EncounterType();
            encounterType.setName(ENCOUNTER_TYPE);
            encounterType.setDescription("Encounter Type Description");
            testService.saveObjectInNewTransaction(encounterType);
        }
        {
            VisitType visitType = new VisitType();
            visitType.setName(VISIT_TYPE);
            visitType.setDescription("Visit Type Description");
            testService.saveObjectInNewTransaction(visitType);
        }
    }

    @Test
    @Transactional
    @Rollback(false)
    public void shouldTestFirstInNoTransaction() throws Exception {
        {
            EncounterType encounterType = new EncounterType();
            encounterType.setName(ENCOUNTER_TYPE);
            encounterType.setDescription("Encounter Type Description");
            testService.saveObjectNoTransaction(encounterType);
        }
        {
            VisitType visitType = new VisitType();
            visitType.setName(VISIT_TYPE);
            visitType.setDescription("Visit Type Description");
            testService.saveObjectInTransaction(visitType);
        }
    }

    @Test
    @NotTransactional
    public void shouldTestFirstThrowsException() throws Exception {
        beforeTx();
        {
            EncounterType encounterType = new EncounterType();
            encounterType.setName(ENCOUNTER_TYPE);
            encounterType.setDescription("Encounter Type Description");
            String exceptionMessage = "";
            try {
                testService.saveObjectInTransactionWithException(encounterType);
            } catch (IllegalArgumentException e) {
                exceptionMessage = e.getMessage();
            }
            Assert.assertEquals(EXCEPTION_MESSAGE, exceptionMessage);
        }
        {
            VisitType visitType = new VisitType();
            visitType.setName(VISIT_TYPE);
            visitType.setDescription("Visit Type Description");
            testService.saveObjectInTransaction(visitType);
        }
        afterTx();
    }

    @Test
    @NotTransactional
    public void shouldTestSecondThrowsException() throws Exception {
        beforeTx();
        {
            EncounterType encounterType = new EncounterType();
            encounterType.setName(ENCOUNTER_TYPE);
            encounterType.setDescription("Encounter Type Description");
            testService.saveObjectInTransaction(encounterType);
        }
        {
            VisitType visitType = new VisitType();
            visitType.setName(VISIT_TYPE);
            visitType.setDescription("Visit Type Description");
            String exceptionMessage = "";
            try {
                testService.saveObjectInTransactionWithException(visitType);
            } catch (IllegalArgumentException e) {
                exceptionMessage = e.getMessage();
            }
            Assert.assertEquals(EXCEPTION_MESSAGE, exceptionMessage);
        }
        afterTx();
    }

    public String getTableContents(String tableName) throws Exception {
        StringWriter writer = new StringWriter();
        IDatabaseConnection connection = new DatabaseConnection(getConnection());
        DatabaseConfig config = connection.getConfig();
        config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new HsqldbDataTypeFactory());
        QueryDataSet outputSet = new QueryDataSet(connection);
        outputSet.addTable(tableName);
        FlatXmlDataSet.write(outputSet, writer);
        return writer.toString();
    }

    public boolean checkTableContains(String tableName, String testValue) throws Exception {
        return getTableContents(tableName).contains(testValue);
    }
}