Java 类org.springframework.test.context.transaction.TestTransaction 实例源码

@Test
public void commitTxAndStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Commit
    TestTransaction.flagForCommit();
    assertFalse(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertInTransaction(false);
    assertFalse(TestTransaction.isActive());
    assertUsers();

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dogbert");

    TestTransaction.start();
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
}

@Test
public void commitTxButDoNotStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Commit
    TestTransaction.flagForCommit();
    assertFalse(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers();

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dogbert");
}

@Test
public void rollbackTxAndStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Rollback (automatically)
    assertTrue(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers("Dilbert");

    // Start new transaction with default rollback semantics
    TestTransaction.start();
    assertInTransaction(true);
    assertTrue(TestTransaction.isFlaggedForRollback());
    assertTrue(TestTransaction.isActive());

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dilbert", "Dogbert");
}

@Test
@Commit
public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Rollback
    TestTransaction.flagForRollback();
    assertTrue(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers("Dilbert");

    // Start new transaction with default commit semantics
    TestTransaction.start();
    assertInTransaction(true);
    assertFalse(TestTransaction.isFlaggedForRollback());
    assertTrue(TestTransaction.isActive());

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dilbert", "Dogbert");
}

@Test
public void commitTxAndStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Commit
    TestTransaction.flagForCommit();
    assertFalse(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertInTransaction(false);
    assertFalse(TestTransaction.isActive());
    assertUsers();

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dogbert");

    TestTransaction.start();
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
}

@Test
public void commitTxButDoNotStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Commit
    TestTransaction.flagForCommit();
    assertFalse(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers();

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dogbert");
}

@Test
public void rollbackTxAndStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Rollback (automatically)
    assertTrue(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers("Dilbert");

    // Start new transaction with default rollback semantics
    TestTransaction.start();
    assertInTransaction(true);
    assertTrue(TestTransaction.isFlaggedForRollback());
    assertTrue(TestTransaction.isActive());

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dilbert", "Dogbert");
}

@Test
@Commit
public void rollbackTxAndStartNewTxWithDefaultCommitSemantics() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Rollback
    TestTransaction.flagForRollback();
    assertTrue(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers("Dilbert");

    // Start new transaction with default commit semantics
    TestTransaction.start();
    assertInTransaction(true);
    assertFalse(TestTransaction.isFlaggedForRollback());
    assertTrue(TestTransaction.isActive());

    executeSqlScript("classpath:/org/springframework/test/context/jdbc/data-add-dogbert.sql", false);
    assertUsers("Dilbert", "Dogbert");
}

@Test
public void testTransactional() throws Exception {
    User user = newUser().address("address").firstName("firstname").lastName("lastname").build();
    user = userRepository.save(user);

    TestTransaction.end();
    Assert.assertEquals(0 , userRepository.findAll().size());


    TestTransaction.start();
    TestTransaction.flagForCommit();
    user = newUser().address("address").firstName("firstname").lastName("lastname").build();
    user = userRepository.save(user);
    TestTransaction.end();

    Assert.assertEquals(user, userRepository.findAll().get(0));
}

@Test
public void rollbackTxButDoNotStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Rollback (automatically)
    assertTrue(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers("Dilbert");
}

@Test
public void rollbackTxButDoNotStartNewTx() {
    assertInTransaction(true);
    assertTrue(TestTransaction.isActive());
    assertUsers("Dilbert");
    deleteFromTables("user");
    assertUsers();

    // Rollback (automatically)
    assertTrue(TestTransaction.isFlaggedForRollback());
    TestTransaction.end();
    assertFalse(TestTransaction.isActive());
    assertInTransaction(false);
    assertUsers("Dilbert");
}

@Test
@Transactional
@Commit
public void testTransactionalEvent() throws Exception {
    publisher.publishEvent(new TransactionalEvent(1));

    Assert.assertEquals(0 , transactionEventListener.getAllEvents().size());

    TestTransaction.end();

    Assert.assertEquals(2 , transactionEventListener.getAllEvents().size());
}

@Test
@Rollback
public void testRollback() throws Exception {
    User user = newUser().address("address").firstName("firstname").lastName("lastname").build();
    user = userRepository.save(user);

    TestTransaction.end();
    Assert.assertEquals(0 , userRepository.findAll().size());
}

@Test
@Commit
public void testCommit() throws Exception {
    User user = newUser().address("address").firstName("firstname").lastName("lastname").build();
    user = userRepository.save(user);

    TestTransaction.end();
    Assert.assertEquals(1 , userRepository.findAll().size());
}

@Test
@Transactional
@Sql("/sql/create-user.sql")
public void userTest() {
    Assert.assertNotNull(userRepository.findOne(1234l));
    TestTransaction.end();

    Assert.assertNull(userRepository.findOne(1234l));
}

@Test
@Transactional
@Sql(statements = "INSERT INTO USER (ID, FIRSTNAME,LASTNAME,ADDRESS) VALUES (1234,'Bilbo' , 'Baggins', 'Fondcombe')")
public void userStatementTest() {
    Assert.assertNotNull(userRepository.findOne(1234l));
    TestTransaction.end();
    Assert.assertNull(userRepository.findOne(1234l));
}

@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void isActiveWithNonExistentTransactionContext() {
    assertFalse(TestTransaction.isActive());
}

@Test(expected = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void flagForRollbackWithNonExistentTransactionContext() {
    TestTransaction.flagForRollback();
}

@Test(expected = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void flagForCommitWithNonExistentTransactionContext() {
    TestTransaction.flagForCommit();
}

@Test(expected = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void isFlaggedForRollbackWithNonExistentTransactionContext() {
    TestTransaction.isFlaggedForRollback();
}

@Test(expected = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void startTxWithNonExistentTransactionContext() {
    TestTransaction.start();
}

@Test(expected = IllegalStateException.class)
public void startTxWithExistingTransaction() {
    TestTransaction.start();
}

@Test(expected = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void endTxWithNonExistentTransactionContext() {
    TestTransaction.end();
}

@Test
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void isActiveWithNonExistentTransactionContext() {
    assertFalse(TestTransaction.isActive());
}

@Test(expectedExceptions = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void flagForRollbackWithNonExistentTransactionContext() {
    TestTransaction.flagForRollback();
}

@Test(expectedExceptions = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void flagForCommitWithNonExistentTransactionContext() {
    TestTransaction.flagForCommit();
}

@Test(expectedExceptions = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void isFlaggedForRollbackWithNonExistentTransactionContext() {
    TestTransaction.isFlaggedForRollback();
}

@Test(expectedExceptions = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void startTxWithNonExistentTransactionContext() {
    TestTransaction.start();
}

@Test(expectedExceptions = IllegalStateException.class)
public void startTxWithExistingTransaction() {
    TestTransaction.start();
}

@Test(expectedExceptions = IllegalStateException.class)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void endTxWithNonExistentTransactionContext() {
    TestTransaction.end();
}