//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldExecuteStatements() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldExecuteStatements()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
Result executionResult = mock(typeof(Result));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(executionEngine.ExecuteQuery("query", NoParams, transactionalContext)).thenReturn(executionResult);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
TransactionHandle handle = GetTransactionHandle(kernel, executionEngine, registry);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
handle.Execute(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
// then
verify(executionEngine).executeQuery("query", NoParams, transactionalContext);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).transactionCommitUri(uriScheme.txCommitUri(1337));
outputOrder.verify(output).statementResult(executionResult, false, ( ResultDataContent[] )null);
outputOrder.verify(output).notifications(anyCollection());
outputOrder.verify(output).transactionStatus(anyLong());
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRollbackTransactionIfExecutionErrorOccurs() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldRollbackTransactionIfExecutionErrorOccurs()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction transactionContext = kernel.NewTransaction(@explicit, AUTH_DISABLED, -1);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(executionEngine.ExecuteQuery("query", NoParams, transactionalContext)).thenThrow(new System.NullReferenceException());
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
TransactionHandle handle = GetTransactionHandle(kernel, executionEngine, registry);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
handle.Execute(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
// then
verify(transactionContext).rollback();
verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).transactionCommitUri(uriScheme.txCommitUri(1337));
outputOrder.verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.ExecutionFailed)));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLogMessageIfCypherSyntaxErrorOccurs() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldLogMessageIfCypherSyntaxErrorOccurs()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(executionEngine.ExecuteQuery("matsch (n) return n", NoParams, transactionalContext)).thenThrow(new QueryExecutionKernelException(new SyntaxException("did you mean MATCH?")));
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(kernel, executionEngine, queryService, registry, uriScheme, false, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
Statement statement = new Statement("matsch (n) return n", map(), false, (ResultDataContent[])null);
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.SyntaxError)));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void acquiringATransactionThatHasAlreadyBeenAcquiredShouldThrowInvalidConcurrentTransactionAccess() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void AcquiringATransactionThatHasAlreadyBeenAcquiredShouldThrowInvalidConcurrentTransactionAccess()
{
// Given
AssertableLogProvider logProvider = new AssertableLogProvider();
TransactionHandleRegistry registry = new TransactionHandleRegistry(Clocks.fakeClock(), 0, logProvider);
TransactionHandle handle = mock(typeof(TransactionHandle));
long id = registry.Begin(handle);
registry.Release(id, handle);
registry.Acquire(id);
// When
try
{
registry.Acquire(id);
fail("Should have thrown exception");
}
catch (InvalidConcurrentTransactionAccess)
{
// expected
}
// then
logProvider.AssertNoLoggingOccurred();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleExecutionEngineThrowingUndeclaredCheckedExceptions() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldHandleExecutionEngineThrowingUndeclaredCheckedExceptions()
{
// given
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
when(executionEngine.ExecuteQuery(eq("match (n) return n"), eq(NoParams), any(typeof(TransactionalContext)))).thenAnswer(invocationOnMock =>
{
throw new Exception("BOO");
});
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(MockKernel(), executionEngine, queryService, registry, uriScheme, false, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
Statement statement = new Statement("match (n) return n", map(), false, (ResultDataContent[])null);
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).statementResult(Null, eq(false), Null);
outputOrder.verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Statement.ExecutionFailed)));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
internal SuspendedTransaction(TransactionHandleRegistry outerInstance, ActiveTransaction activeMarker, TransactionHandle transactionHandle)
{
this._outerInstance = outerInstance;
this.ActiveMarker = activeMarker;
this.TransactionHandle = transactionHandle;
this.LastActiveTimestampConflict = outerInstance.clock.millis();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void expiryTimeShouldBeSetToCurrentTimePlusTimeout() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ExpiryTimeShouldBeSetToCurrentTimePlusTimeout()
{
// Given
AssertableLogProvider logProvider = new AssertableLogProvider();
FakeClock clock = Clocks.fakeClock();
int timeoutLength = 123;
TransactionHandleRegistry registry = new TransactionHandleRegistry(clock, timeoutLength, logProvider);
TransactionHandle handle = mock(typeof(TransactionHandle));
long id = registry.Begin(handle);
// When
long timesOutAt = registry.Release(id, handle);
// Then
assertThat(timesOutAt, equalTo(clock.Millis() + timeoutLength));
// And when
clock.Forward(1337, TimeUnit.MILLISECONDS);
registry.Acquire(id);
timesOutAt = registry.Release(id, handle);
// Then
assertThat(timesOutAt, equalTo(clock.Millis() + timeoutLength));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCommitSinglePeriodicCommitStatement() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCommitSinglePeriodicCommitStatement()
{
// given
string queryText = "USING PERIODIC COMMIT CREATE()";
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
Result executionResult = mock(typeof(Result));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(executionEngine.IsPeriodicCommit(queryText)).thenReturn(true);
when(executionEngine.ExecuteQuery(eq(queryText), eq(NoParams), eq(transactionalContext))).thenReturn(executionResult);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
TransactionHandle handle = GetTransactionHandle(kernel, executionEngine, registry);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
Statement statement = new Statement(queryText, map(), false, (ResultDataContent[])null);
// when
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
verify(executionEngine).executeQuery(queryText, NoParams, transactionalContext);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).statementResult(executionResult, false, ( ResultDataContent[] )null);
outputOrder.verify(output).notifications(anyCollectionOf(typeof(Notification)));
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldRollbackTransactionAndTellRegistryToForgetItsHandle()
public virtual void ShouldRollbackTransactionAndTellRegistryToForgetItsHandle()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction transactionContext = kernel.NewTransaction(@explicit, AUTH_DISABLED, -1);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(kernel, mock(typeof(QueryExecutionEngine)), queryService, registry, uriScheme, true, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
handle.Rollback(output);
// then
InOrder transactionOrder = inOrder(transactionContext, registry);
transactionOrder.verify(transactionContext).rollback();
transactionOrder.verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldThrowSpecificExceptionOnConcurrentTransactionAccess() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldThrowSpecificExceptionOnConcurrentTransactionAccess()
{
// given
TransactionRegistry registry = new TransactionHandleRegistry(mock(typeof(Clock)), 0, NullLogProvider.Instance);
TransitionalPeriodTransactionMessContainer kernel = mock(typeof(TransitionalPeriodTransactionMessContainer));
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransitionalTxManagementKernelTransaction kernelTransaction = mock(typeof(TransitionalTxManagementKernelTransaction));
when(kernel.NewTransaction(any(typeof(KernelTransaction.Type)), any(typeof(LoginContext)), anyLong())).thenReturn(kernelTransaction);
TransactionFacade actions = new TransactionFacade(kernel, null, queryService, registry, NullLogProvider.Instance);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final TransactionHandle transactionHandle = actions.newTransactionHandle(new DisgustingUriScheme(), true, org.neo4j.internal.kernel.api.security.LoginContext.AUTH_DISABLED, -1);
TransactionHandle transactionHandle = actions.NewTransactionHandle(new DisgustingUriScheme(), true, LoginContext.AUTH_DISABLED, -1);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.test.DoubleLatch latch = new org.neo4j.test.DoubleLatch();
DoubleLatch latch = new DoubleLatch();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final StatementDeserializer statements = mock(StatementDeserializer.class);
StatementDeserializer statements = mock(typeof(StatementDeserializer));
//JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops:
when(statements.HasNext()).thenAnswer(invocation =>
{
latch.StartAndWaitForAllToStartAndFinish();
return(false);
});
(new Thread(() =>
{
// start and block until finish
transactionHandle.Execute(statements, mock(typeof(ExecutionResultSerializer)), mock(typeof(HttpServletRequest)));
})).Start();
latch.WaitForAllToStart();
try
{
// when
actions.FindTransactionHandle(DisgustingUriScheme.ParseTxId(transactionHandle.Uri()));
fail("should have thrown exception");
}
catch (InvalidConcurrentTransactionAccess)
{
// then we get here
}
finally
{
latch.Finish();
}
}
public override long Begin(TransactionHandle handle)
{
long id = _idGenerator.incrementAndGet();
if (null == _registry.GetOrAdd(id, new ActiveTransaction(handle)))
{
return(id);
}
else
{
throw new System.InvalidOperationException("Attempt to begin transaction for id that was already registered");
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void startTransactionWithRequestedTimeout()
public virtual void StartTransactionWithRequestedTimeout()
{
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
TransitionalPeriodTransactionMessContainer txManagerFacade = MockKernel();
TransactionHandle handle = new TransactionHandle(txManagerFacade, executionEngine, queryService, mock(typeof(TransactionRegistry)), uriScheme, true, AUTH_DISABLED, 100, NullLogProvider.Instance);
handle.Commit(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
verify(txManagerFacade).newTransaction(Transaction_Type.@implicit, AUTH_DISABLED, 100);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldGenerateTransactionId()
public virtual void ShouldGenerateTransactionId()
{
// given
AssertableLogProvider logProvider = new AssertableLogProvider();
TransactionHandleRegistry registry = new TransactionHandleRegistry(Clocks.fakeClock(), 0, logProvider);
TransactionHandle handle = mock(typeof(TransactionHandle));
// when
long id1 = registry.Begin(handle);
long id2 = registry.Begin(handle);
// then
assertNotEquals(id1, id2);
logProvider.AssertNoLoggingOccurred();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldStoreSuspendedTransaction() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldStoreSuspendedTransaction()
{
// Given
AssertableLogProvider logProvider = new AssertableLogProvider();
TransactionHandleRegistry registry = new TransactionHandleRegistry(Clocks.fakeClock(), 0, logProvider);
TransactionHandle handle = mock(typeof(TransactionHandle));
long id = registry.Begin(handle);
// When
registry.Release(id, handle);
TransactionHandle acquiredHandle = registry.Acquire(id);
// Then
assertSame(handle, acquiredHandle);
logProvider.AssertNoLoggingOccurred();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test @SuppressWarnings("unchecked") public void deadlockExceptionHasCorrectStatus() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void DeadlockExceptionHasCorrectStatus()
{
// given
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
when(executionEngine.ExecuteQuery(anyString(), any(typeof(MapValue)), Null)).thenThrow(new DeadlockDetectedException("deadlock"));
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(MockKernel(), executionEngine, queryService, mock(typeof(TransactionRegistry)), uriScheme, true, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
handle.Execute(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
// then
verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Transaction.DeadlockDetected)));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldLogMessageIfCommitErrorOccurs() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldLogMessageIfCommitErrorOccurs()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction transactionContext = kernel.NewTransaction(@explicit, AUTH_DISABLED, -1);
doThrow(new System.NullReferenceException()).when(transactionContext).commit();
LogProvider logProvider = mock(typeof(LogProvider));
Log log = mock(typeof(Log));
when(logProvider.GetLog(typeof(TransactionHandle))).thenReturn(log);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
QueryExecutionEngine engine = mock(typeof(QueryExecutionEngine));
Result executionResult = mock(typeof(Result));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(engine.ExecuteQuery("query", NoParams, transactionalContext)).thenReturn(executionResult);
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(kernel, engine, queryService, registry, uriScheme, false, AUTH_DISABLED, anyLong(), logProvider);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
Statement statement = new Statement("query", map(), false, (ResultDataContent[])null);
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
verify(log).error(eq("Failed to commit transaction."), any(typeof(System.NullReferenceException)));
verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).statementResult(executionResult, false, ( ResultDataContent[] )null);
outputOrder.verify(output).notifications(anyCollectionOf(typeof(Notification)));
outputOrder.verify(output).errors(argThat(HasErrors(Org.Neo4j.Kernel.Api.Exceptions.Status_Transaction.TransactionCommitFailed)));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldProvideInterruptHandlerForActiveTransaction() throws org.neo4j.server.rest.transactional.error.TransactionLifecycleException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldProvideInterruptHandlerForActiveTransaction()
{
// Given
AssertableLogProvider logProvider = new AssertableLogProvider();
FakeClock clock = Clocks.fakeClock();
int timeoutLength = 123;
TransactionHandleRegistry registry = new TransactionHandleRegistry(clock, timeoutLength, logProvider);
TransactionHandle handle = mock(typeof(TransactionHandle));
// Active Tx in Registry
long id = registry.Begin(handle);
// When
registry.Terminate(id);
// Then
verify(handle, times(1)).terminate();
verifyNoMoreInteractions(handle);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldResumeTransactionWhenExecutingStatementsOnSecondRequest() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldResumeTransactionWhenExecutingStatementsOnSecondRequest()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction transactionContext = kernel.NewTransaction(@explicit, AUTH_DISABLED, -1);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
TransactionHandle handle = GetTransactionHandle(kernel, executionEngine, registry);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
handle.Execute(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
reset(transactionContext, registry, executionEngine, output);
Result executionResult = mock(typeof(Result));
when(executionEngine.ExecuteQuery("query", NoParams, transactionalContext)).thenReturn(executionResult);
// when
handle.Execute(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
// then
InOrder order = inOrder(transactionContext, registry, executionEngine);
order.verify(transactionContext).resumeSinceTransactionsAreStillThreadBound();
order.verify(executionEngine).executeQuery("query", NoParams, transactionalContext);
order.verify(transactionContext).suspendSinceTransactionsAreStillThreadBound();
order.verify(registry).release(1337L, handle);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).transactionCommitUri(uriScheme.txCommitUri(1337));
outputOrder.verify(output).statementResult(executionResult, false, ( ResultDataContent[] )null);
outputOrder.verify(output).notifications(anyCollectionOf(typeof(Notification)));
outputOrder.verify(output).transactionStatus(anyLong());
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
public override long Release(long id, TransactionHandle transactionHandle)
{
TransactionMarker marker = _registry[id];
if (null == marker)
{
throw new System.InvalidOperationException("Trying to suspend unregistered transaction");
}
if (marker.Suspended)
{
throw new System.InvalidOperationException("Trying to suspend transaction that was already suspended");
}
SuspendedTransaction suspendedTx = new SuspendedTransaction(this, marker.ActiveTransaction, transactionHandle);
if (!_registry.replace(id, marker, suspendedTx))
{
throw new System.InvalidOperationException("Trying to suspend transaction that has been concurrently suspended");
}
return(ComputeNewExpiryTime(suspendedTx.LastActiveTimestamp));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void transactionsShouldBeEvictedWhenUnusedLongerThanTimeout() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void TransactionsShouldBeEvictedWhenUnusedLongerThanTimeout()
{
// Given
FakeClock clock = Clocks.fakeClock();
AssertableLogProvider logProvider = new AssertableLogProvider();
TransactionHandleRegistry registry = new TransactionHandleRegistry(clock, 0, logProvider);
TransactionHandle oldTx = mock(typeof(TransactionHandle));
TransactionHandle newTx = mock(typeof(TransactionHandle));
TransactionHandle handle = mock(typeof(TransactionHandle));
long txId1 = registry.Begin(handle);
long txId2 = registry.Begin(handle);
// And given one transaction was stored one minute ago, and another was stored just now
registry.Release(txId1, oldTx);
clock.Forward(1, TimeUnit.MINUTES);
registry.Release(txId2, newTx);
// When
registry.RollbackSuspendedTransactionsIdleSince(clock.Millis() - 1000);
// Then
assertThat(registry.Acquire(txId2), equalTo(newTx));
// And then the other should have been evicted
try
{
registry.Acquire(txId1);
fail("Should have thrown exception");
}
catch (InvalidTransactionId)
{
// ok
}
logProvider.AssertExactly(inLog(typeof(TransactionHandleRegistry)).info("Transaction with id 1 has been automatically rolled " + "back due to transaction timeout."));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCommitTransactionAndTellRegistryToForgetItsHandle() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCommitTransactionAndTellRegistryToForgetItsHandle()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction transactionContext = kernel.NewTransaction(@explicit, AUTH_DISABLED, -1);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
QueryExecutionEngine engine = mock(typeof(QueryExecutionEngine));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
Result result = mock(typeof(Result));
when(engine.ExecuteQuery("query", NoParams, transactionalContext)).thenReturn(result);
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(kernel, engine, queryService, registry, uriScheme, false, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
// when
Statement statement = new Statement("query", map(), false, (ResultDataContent[])null);
handle.Commit(statements(statement), output, mock(typeof(HttpServletRequest)));
// then
InOrder transactionOrder = inOrder(transactionContext, registry);
transactionOrder.verify(transactionContext).commit();
transactionOrder.verify(registry).forget(1337L);
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).statementResult(result, false, ( ResultDataContent[] )null);
outputOrder.verify(output).notifications(anyCollectionOf(typeof(Notification)));
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldInterruptTransaction()
public virtual void ShouldInterruptTransaction()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
TransitionalTxManagementKernelTransaction tx = mock(typeof(TransitionalTxManagementKernelTransaction));
when(kernel.NewTransaction(any(typeof(Transaction_Type)), any(typeof(LoginContext)), anyLong())).thenReturn(tx);
TransactionRegistry registry = mock(typeof(TransactionRegistry));
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
QueryExecutionEngine executionEngine = mock(typeof(QueryExecutionEngine));
TransactionHandle handle = GetTransactionHandle(kernel, executionEngine, registry);
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
Statement statement = new Statement("MATCH (n) RETURN n", map(), false, (ResultDataContent[])null);
handle.Execute(statements(statement), output, mock(typeof(HttpServletRequest)));
// when
handle.Terminate();
// then
verify(tx, times(1)).terminate();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldCreateTransactionContextOnlyWhenFirstNeeded() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldCreateTransactionContextOnlyWhenFirstNeeded()
{
// given
TransitionalPeriodTransactionMessContainer kernel = MockKernel();
ExecutionResultSerializer output = mock(typeof(ExecutionResultSerializer));
TransactionRegistry registry = mock(typeof(TransactionRegistry));
// when
QueryExecutionEngine engine = mock(typeof(QueryExecutionEngine));
Result executionResult = mock(typeof(Result));
TransactionalContext transactionalContext = PrepareKernelWithQuerySession(kernel);
when(engine.ExecuteQuery("query", NoParams, transactionalContext)).thenReturn(executionResult);
when(registry.Begin(any(typeof(TransactionHandle)))).thenReturn(1337L);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
TransactionHandle handle = new TransactionHandle(kernel, engine, queryService, registry, uriScheme, true, AUTH_DISABLED, anyLong(), NullLogProvider.Instance);
// then
verifyZeroInteractions(kernel);
// when
handle.Execute(statements(new Statement("query", map(), false, (ResultDataContent[])null)), output, mock(typeof(HttpServletRequest)));
// then
verify(kernel).newTransaction(any(typeof(Transaction_Type)), any(typeof(LoginContext)), anyLong());
InOrder outputOrder = inOrder(output);
outputOrder.verify(output).transactionCommitUri(uriScheme.txCommitUri(1337));
outputOrder.verify(output).statementResult(executionResult, false, ( ResultDataContent[] )null);
outputOrder.verify(output).notifications(anyCollectionOf(typeof(Notification)));
outputOrder.verify(output).transactionStatus(anyLong());
outputOrder.verify(output).errors(argThat(HasNoErrors()));
outputOrder.verify(output).finish();
verifyNoMoreInteractions(output);
}
