#80 more tests

Author: aburmeis

src/test/java/com/arangodb/springframework/transaction/ArangoTransactionManagerRepositoryTest.java

@@ -4,14 +4,14 @@
 import com.arangodb.springframework.ArangoTransactionalTestConfiguration;
 import com.arangodb.springframework.repository.HumanBeingRepository;
 import com.arangodb.springframework.testdata.HumanBeing;
+import org.junit.Before;
 import org.junit.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.transaction.TestTransaction;
 import org.springframework.transaction.annotation.Transactional;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 
 @ContextConfiguration(classes = { ArangoTransactionalTestConfiguration.class })
 public class ArangoTransactionManagerRepositoryTest extends AbstractArangoTest {
@@ -21,16 +21,37 @@ public class ArangoTransactionManagerRepositoryTest extends AbstractArangoTest {
 	@Autowired
 	private HumanBeingRepository humanBeingRepository;
 
+	@Before
+	public void setUp() {
+		humanBeingRepository.deleteAll();
+	}
+
 	@Test
 	public void shouldWorkWithoutTransaction() {
-		assertDoesNotThrow(() -> humanBeingRepository.save(anakin));
+		humanBeingRepository.save(anakin);
+
+		assertThat(humanBeingRepository.findByNameAndSurname(anakin.getName(), anakin.getSurname())).isPresent();
 	}
 
 	@Test
 	@Transactional
 	public void shouldWorkWithinTransaction() {
+		humanBeingRepository.save(anakin);
+
+		assertThat(humanBeingRepository.findByNameAndSurname(anakin.getName(), anakin.getSurname())).isPresent();
+	}
+
+	@Test
+	@Transactional
+	public void shouldWorkAfterTransaction() {
 		TestTransaction.flagForCommit();
-		assertDoesNotThrow(() -> humanBeingRepository.save(anakin));
+
+		humanBeingRepository.save(anakin);
+
+		assertThat(TestTransaction.isFlaggedForRollback()).isFalse();
+		TestTransaction.end();
+
+		assertThat(humanBeingRepository.findByNameAndSurname(anakin.getName(), anakin.getSurname())).isPresent();
 	}
 
 	@Test

src/test/java/com/arangodb/springframework/transaction/ArangoTransactionManagerTest.java

@@ -5,6 +5,7 @@
 import com.arangodb.DbName;
 import com.arangodb.entity.StreamTransactionEntity;
 import com.arangodb.model.StreamTransactionOptions;
+import com.arangodb.model.TransactionCollectionOptions;
 import com.arangodb.springframework.core.ArangoOperations;
 import com.arangodb.springframework.repository.query.QueryTransactionBridge;
 import org.junit.Before;
@@ -15,6 +16,7 @@
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
+import org.springframework.transaction.IllegalTransactionStateException;
 import org.springframework.transaction.InvalidIsolationLevelException;
 import org.springframework.transaction.TransactionDefinition;
 import org.springframework.transaction.TransactionStatus;
@@ -26,9 +28,10 @@
 import java.util.function.Function;
 
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.*;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.*;
+import static org.springframework.beans.PropertyAccessorFactory.forDirectFieldAccess;
 
 @RunWith(MockitoJUnitRunner.class)
 public class ArangoTransactionManagerTest {
@@ -72,7 +75,7 @@ public void getTransactionReturnsNewTransactionWithoutStreamTransaction() {
     }
 
     @Test
-    public void getTransactionReturnsTransactionCreatesStreamTransactionOnBridgeBeginCall() {
+    public void getTransactionReturnsTransactionCreatesStreamTransactionWithAllCollectionsOnBridgeBeginCall() {
         DefaultTransactionAttribute definition = new DefaultTransactionAttribute();
         definition.setLabels(Collections.singleton("baz"));
         definition.setTimeout(20);
@@ -83,9 +86,47 @@ public void getTransactionReturnsTransactionCreatesStreamTransactionOnBridgeBegi
                 .thenReturn(streamTransaction);
         verify(bridge).setCurrentTransaction(beginPassed.capture());
         beginPassed.getValue().apply(Arrays.asList("foo", "bar"));
+        assertThat(transaction.isCompleted(), is(false));
         verify(database).beginStreamTransaction(optionsPassed.capture());
         assertThat(optionsPassed.getValue().getAllowImplicit(), is(true));
         assertThat(optionsPassed.getValue().getLockTimeout(), is(20));
+        TransactionCollectionOptions collections = getCollections(optionsPassed.getValue());
+        assertThat(collections.getRead(), nullValue());
+        assertThat(collections.getExclusive(), nullValue());
+        assertThat(collections.getWrite(), hasItems("baz", "foo", "bar"));
+    }
+
+    @Test
+    public void getTransactionWithMultipleBridgeCallsWorksForKnownCollections() {
+        DefaultTransactionAttribute definition = new DefaultTransactionAttribute();
+        definition.setLabels(Collections.singleton("baz"));
+        definition.setTimeout(20);
+        underTest.getTransaction(definition);
+        when(streamTransaction.getId())
+                .thenReturn("123");
+        when(database.beginStreamTransaction(any()))
+                .thenReturn(streamTransaction);
+        verify(bridge).setCurrentTransaction(beginPassed.capture());
+        beginPassed.getValue().apply(Collections.singletonList("foo"));
+        beginPassed.getValue().apply(Arrays.asList("foo", "baz"));
+        verify(database).beginStreamTransaction(optionsPassed.capture());
+        TransactionCollectionOptions collections = getCollections(optionsPassed.getValue());
+        assertThat(collections.getWrite(), hasItems("baz", "foo"));
+    }
+
+    @Test(expected = IllegalTransactionStateException.class)
+    public void getTransactionWithMultipleBridgeCallsFailsForAdditionalCollection() {
+        DefaultTransactionAttribute definition = new DefaultTransactionAttribute();
+        definition.setLabels(Collections.singleton("baz"));
+        definition.setTimeout(20);
+        underTest.getTransaction(definition);
+        when(streamTransaction.getId())
+                .thenReturn("123");
+        when(database.beginStreamTransaction(any()))
+                .thenReturn(streamTransaction);
+        verify(bridge).setCurrentTransaction(beginPassed.capture());
+        beginPassed.getValue().apply(Collections.singletonList("foo"));
+        beginPassed.getValue().apply(Collections.singletonList("bar"));
     }
 
     @Test(expected = InvalidIsolationLevelException.class)
@@ -94,4 +135,8 @@ public void getTransactionThrowsInvalidIsolationLevelExceptionForIsolationSerial
         definition.setIsolationLevel(TransactionDefinition.ISOLATION_SERIALIZABLE);
         underTest.getTransaction(definition);
     }
+
+    private TransactionCollectionOptions getCollections(StreamTransactionOptions options) {
+        return (TransactionCollectionOptions) forDirectFieldAccess(options).getPropertyValue("collections");
+    }
 }