/*
* Copyright 2004-2015 the Seasar Foundation and the Others.
*
* 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.seasar.extension.tx.adapter;
import javax.transaction.UserTransaction;
import org.seasar.extension.tx.TransactionCallback;
import static javax.transaction.Status.*;
import static org.easymock.EasyMock.*;
/**
* {@link JTAUserTransactionAdapter}のテストクラスです。
* <p>
* メソッド名は次のようになっています。
* </p>
*
* <pre>
* test<TXATTR>_<CONTEXT>_<BEHAVIOR>()
* </pre>
*
* <dl>
* <dt><TXATTR></dt>
* <dd>テスト対象のトランザクション属性</dd>
* <dt><CONTEXT></dt>
* <dd>現在のスレッド上でトランザクションが開始されているか (<code>withTx</code>)いないか(<code>withoutTx()</code></dd>
* <dt><BEHAVIOR></dt>
* <dd>{@link TransactionCallback}の振る舞い。 リターンしてコミット (<code>returnCommit</code>)、
* リターンしてロールバック (<code>returnRollback)、
* 例外をスローしてコミット (<code>exceptionCommit</code>)、 例外をスローしてロールバック (<code>exceptionRollback)
* のいすれか</dd>
* </dl>
*
* @author koichik
*/
public class JTAUserTransactionAdapterTest extends
AbstTransactionManagerAdapterTest {
JTAUserTransactionAdapter target;
UserTransaction ut;
@Override
protected void setUp() throws Exception {
super.setUp();
ut = createStrictMock(UserTransaction.class);
target = new JTAUserTransactionAdapter(ut);
}
/**
* @throws Throwable
*/
public void testRequired_withoutTx_returnCommit() throws Throwable {
assertEquals("hoge", target.required(new ReturnCommitCallback()));
}
/**
* @throws Throwable
*/
public void recordRequired_withoutTx_returnCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
ut.begin();
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.commit();
}
/**
* @throws Throwable
*/
public void testRequired_withoutTx_returnRollback() throws Throwable {
assertEquals("hoge", target.required(new ReturnRollbackCallback()));
}
/**
* @throws Throwable
*/
public void recordRequired_withoutTx_returnRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
ut.begin();
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.setRollbackOnly();
expect(ut.getStatus()).andReturn(STATUS_MARKED_ROLLBACK);
ut.rollback();
}
/**
* @throws Throwable
*/
public void testRequired_withoutTx_exceptionCommit() throws Throwable {
try {
target.required(new ExceptionCommitCallback());
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequired_withoutTx_exceptionCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
ut.begin();
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.commit();
}
/**
* @throws Throwable
*/
public void testRequired_withoutTx_exceptionRollback() throws Throwable {
try {
target.required(new ExceptionRollbackCallback());
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequired_withoutTx_exceptionRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
ut.begin();
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.setRollbackOnly();
expect(ut.getStatus()).andReturn(STATUS_MARKED_ROLLBACK);
ut.rollback();
}
/**
* @throws Throwable
*/
public void testRequired_withTx_returnCommit() throws Throwable {
assertEquals("hoge", target.required(new ReturnCommitCallback()));
}
/**
* @throws Throwable
*/
public void recordRequired_withTx_returnCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testRequired_withTx_returnRollback() throws Throwable {
assertEquals("hoge", target.required(new ReturnRollbackCallback()));
}
/**
* @throws Throwable
*/
public void recordRequired_withTx_returnRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.setRollbackOnly();
}
/**
* @throws Throwable
*/
public void testRequired_withTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target.required(new ExceptionCommitCallback()));
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequired_withTx_exceptionCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testRequired_withTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target
.required(new ExceptionRollbackCallback()));
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequired_withTx_exceptionRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.setRollbackOnly();
}
/**
* @throws Throwable
*/
public void testRequiresNew_withoutTx_returnCommit() throws Throwable {
try {
assertEquals("hoge", target.requiresNew(new ReturnCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withoutTx_returnCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testRequiresNew_withoutTx_returnRollback() throws Throwable {
try {
assertEquals("hoge", target
.requiresNew(new ReturnRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withoutTx_returnRollback() throws Throwable {
}
/**
* @throws Throwable
*/
public void testRequiresNew_withoutTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target
.requiresNew(new ExceptionCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withoutTx_exceptionCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testRequiresNew_withoutTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target
.requiresNew(new ExceptionRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withoutTx_exceptionRollback()
throws Throwable {
}
/**
* @throws Throwable
*/
public void testRequiresNew_withTx_returnCommit() throws Throwable {
try {
assertEquals("hoge", target.requiresNew(new ReturnCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withTx_returnCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testRequiresNew_withTx_returnRollback() throws Throwable {
try {
assertEquals("hoge", target
.requiresNew(new ReturnRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withTx_returnRollback() throws Throwable {
}
/**
* @throws Throwable
*/
public void testRequiresNew_withTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target
.requiresNew(new ExceptionCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withTx_exceptionCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testRequiresNew_withTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target
.requiresNew(new ExceptionRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordRequiresNew_withTx_exceptionRollback() throws Throwable {
}
/**
* @throws Throwable
*/
public void testMandatory_withoutTx_returnCommit() throws Throwable {
try {
assertEquals("hoge", target.mandatory(new ReturnCommitCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordMandatory_withoutTx_returnCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testMandatory_withoutTx_returnRollback() throws Throwable {
try {
assertEquals("hoge", target.mandatory(new ReturnRollbackCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordMandatory_withoutTx_returnRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testMandatory_withoutTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target
.mandatory(new ExceptionCommitCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordMandatory_withoutTx_exceptionCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testMandatory_withoutTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target
.mandatory(new ExceptionRollbackCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordMandatory_withoutTx_exceptionRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testMandatory_withTx_returnCommit() throws Throwable {
assertEquals("hoge", target.mandatory(new ReturnCommitCallback()));
}
/**
* @throws Throwable
*/
public void recordMandatory_withTx_returnCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testMandatory_withTx_returnRollback() throws Throwable {
assertEquals("hoge", target.mandatory(new ReturnRollbackCallback()));
}
/**
* @throws Throwable
*/
public void recordMandatory_withTx_returnRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.setRollbackOnly();
}
/**
* @throws Throwable
*/
public void testMandatory_withTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target
.mandatory(new ExceptionCommitCallback()));
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordMandatory_withTx_exceptionCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testMandatory_withTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target
.mandatory(new ExceptionRollbackCallback()));
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordMandatory_withTx_exceptionRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.setRollbackOnly();
}
/**
* @throws Throwable
*/
public void testNotSupported_withoutTx_returnCommit() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ReturnCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withoutTx_returnCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testNotSupported_withoutTx_returnRollback() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ReturnRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withoutTx_returnRollback() throws Throwable {
}
/**
* @throws Throwable
*/
public void testNotSupported_withoutTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ExceptionCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withoutTx_exceptionCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testNotSupported_withoutTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ExceptionRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withoutTx_exceptionRollback()
throws Throwable {
}
/**
* @throws Throwable
*/
public void testNotSupported_withTx_returnCommit() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ReturnCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withTx_returnCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testNotSupported_withTx_returnRollback() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ReturnRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withTx_returnRollback() throws Throwable {
}
/**
* @throws Throwable
*/
public void testNotSupported_withTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ExceptionCommitCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withTx_exceptionCommit() throws Throwable {
}
/**
* @throws Throwable
*/
public void testNotSupported_withTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target
.notSupported(new ExceptionRollbackCallback()));
fail();
} catch (UnsupportedOperationException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNotSupported_withTx_exceptionRollback() throws Throwable {
}
/**
* @throws Throwable
*/
public void testNever_withoutTx_returnCommit() throws Throwable {
assertEquals("hoge", target.never(new ReturnCommitCallback()));
}
/**
* @throws Throwable
*/
public void recordNever_withoutTx_returnCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testNever_withoutTx_returnRollback() throws Throwable {
assertEquals("hoge", target.never(new ReturnRollbackCallback()));
}
/**
* @throws Throwable
*/
public void recordNever_withoutTx_returnRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testNever_withoutTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target.never(new ExceptionCommitCallback()));
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordNever_withoutTx_exceptionCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testNever_withoutTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target.never(new ExceptionRollbackCallback()));
fail();
} catch (Exception expected) {
}
}
/**
* @throws Throwable
*/
public void recordNever_withoutTx_exceptionRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
expect(ut.getStatus()).andReturn(STATUS_NO_TRANSACTION);
}
/**
* @throws Throwable
*/
public void testNever_withTx_returnCommit() throws Throwable {
try {
assertEquals("hoge", target.never(new ReturnCommitCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNever_withTx_returnCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testNever_withTx_returnRollback() throws Throwable {
try {
assertEquals("hoge", target.never(new ReturnRollbackCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNever_withTx_returnRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testNever_withTx_exceptionCommit() throws Throwable {
try {
assertEquals("hoge", target.never(new ExceptionCommitCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNever_withTx_exceptionCommit() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testNever_withTx_exceptionRollback() throws Throwable {
try {
assertEquals("hoge", target.never(new ExceptionRollbackCallback()));
fail();
} catch (IllegalStateException expected) {
}
}
/**
* @throws Throwable
*/
public void recordNever_withTx_exceptionRollback() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
}
/**
* @throws Throwable
*/
public void testSetRollbackOnly() throws Throwable {
target.setRollbackOnly();
target.setRollbackOnly();
}
/**
* @throws Throwable
*/
public void recordSetRollbackOnly() throws Throwable {
expect(ut.getStatus()).andReturn(STATUS_ACTIVE);
ut.setRollbackOnly();
expect(ut.getStatus()).andReturn(STATUS_MARKED_ROLLBACK);
}
}