//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);
}
private static TransactionStateMachineV1SPI CreateTxSpi(System.Func <TransactionIdStore> txIdStore, Duration txAwaitDuration, DatabaseAvailabilityGuard availabilityGuard, Clock clock)
{
QueryExecutionEngine queryExecutionEngine = mock(typeof(QueryExecutionEngine));
DependencyResolver dependencyResolver = mock(typeof(DependencyResolver));
ThreadToStatementContextBridge bridge = new ThreadToStatementContextBridge(availabilityGuard);
when(dependencyResolver.ResolveDependency(typeof(ThreadToStatementContextBridge))).thenReturn(bridge);
when(dependencyResolver.ResolveDependency(typeof(QueryExecutionEngine))).thenReturn(queryExecutionEngine);
when(dependencyResolver.ResolveDependency(typeof(DatabaseAvailabilityGuard))).thenReturn(availabilityGuard);
when(dependencyResolver.ProvideDependency(typeof(TransactionIdStore))).thenReturn(txIdStore);
GraphDatabaseAPI db = mock(typeof(GraphDatabaseAPI));
when(Db.DependencyResolver).thenReturn(dependencyResolver);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
when(queryService.DependencyResolver).thenReturn(dependencyResolver);
when(dependencyResolver.ResolveDependency(typeof(GraphDatabaseQueryService))).thenReturn(queryService);
BoltChannel boltChannel = new BoltChannel("bolt-42", "bolt", new EmbeddedChannel());
return(new TransactionStateMachineV1SPI(db, boltChannel, txAwaitDuration, clock));
}
//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);
}
private TransactionalContext CreateTransactionContext(GraphDatabaseQueryService graph, InternalTransaction tx, string query)
{
PropertyContainerLocker locker = new PropertyContainerLocker();
TransactionalContextFactory contextFactory = Neo4jTransactionalContextFactory.create(graph, locker);
return(contextFactory.NewContext(ClientConnectionInfo.EMBEDDED_CONNECTION, tx, query, EMPTY_MAP));
}
//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);
}
public virtual TransactionalContext Create(HttpServletRequest request, GraphDatabaseQueryService service, Transaction_Type type, LoginContext loginContext, string query, IDictionary <string, object> queryParameters)
{
TransactionalContextFactory contextFactory = Neo4jTransactionalContextFactory.create(service, _locker);
ClientConnectionInfo clientConnection = HttpConnectionInfoFactory.create(request);
InternalTransaction transaction = service.BeginTransaction(type, loginContext);
return(contextFactory.NewContext(clientConnection, transaction, query, ValueUtils.asMapValue(queryParameters)));
}
public static TransactionalContextFactory Create(GraphDatabaseQueryService queryService, PropertyContainerLocker locker)
{
DependencyResolver resolver = queryService.DependencyResolver;
ThreadToStatementContextBridge txBridge = resolver.ResolveDependency(typeof(ThreadToStatementContextBridge));
Kernel kernel = resolver.ResolveDependency(typeof(Kernel));
Neo4jTransactionalContext.Creator contextCreator = (tx, initialStatement, executingQuery) => new Neo4jTransactionalContext(queryService, txBridge, locker, tx, initialStatement, executingQuery, kernel);
return(new Neo4jTransactionalContextFactory(txBridge, contextCreator));
}
//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();
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private java.util.List<LockOperationRecord> traceQueryLocks(String query, LockOperationListener... listeners) throws org.neo4j.kernel.impl.query.QueryExecutionKernelException
private IList <LockOperationRecord> TraceQueryLocks(string query, params LockOperationListener[] listeners)
{
GraphDatabaseQueryService graph = DatabaseRule.resolveDependency(typeof(GraphDatabaseQueryService));
QueryExecutionEngine executionEngine = DatabaseRule.resolveDependency(typeof(QueryExecutionEngine));
using (InternalTransaction tx = graph.BeginTransaction(KernelTransaction.Type.@implicit, LoginContext.AUTH_DISABLED))
{
TransactionalContextWrapper context = new TransactionalContextWrapper(CreateTransactionContext(graph, tx, query), listeners);
executionEngine.ExecuteQuery(query, VirtualValues.emptyMap(), context);
return(new List <LockOperationRecord>(context.RecordingLocks.LockOperationRecords));
}
}
internal TransactionHandle(TransitionalPeriodTransactionMessContainer txManagerFacade, QueryExecutionEngine engine, GraphDatabaseQueryService queryService, TransactionRegistry registry, TransactionUriScheme uriScheme, bool implicitTransaction, LoginContext loginContext, long customTransactionTimeout, LogProvider logProvider)
{
this._txManagerFacade = txManagerFacade;
this._engine = engine;
this._queryService = queryService;
this._registry = registry;
this._uriScheme = uriScheme;
this._type = implicitTransaction ? Transaction_Type.@implicit : Transaction_Type.@explicit;
this._loginContext = loginContext;
this._customTransactionTimeout = customTransactionTimeout;
this._log = logProvider.getLog(this.GetType());
this._id = registry.Begin(this);
}
//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);
}
public Neo4jTransactionalContext(GraphDatabaseQueryService graph, ThreadToStatementContextBridge txBridge, PropertyContainerLocker locker, InternalTransaction initialTransaction, Statement initialStatement, ExecutingQuery executingQuery, Kernel kernel)
{
this._graph = graph;
this._txBridge = txBridge;
this._locker = locker;
this.TransactionType = initialTransaction.TransactionType();
this.SecurityContextConflict = initialTransaction.SecurityContext();
this._executingQuery = executingQuery;
this._transaction = initialTransaction;
this._kernelTransaction = txBridge.GetKernelTransactionBoundToThisThread(true);
this._statement = initialStatement;
this._kernel = kernel;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @BeforeEach void setUp()
internal virtual void SetUp()
{
_queryService = mock(typeof(GraphDatabaseQueryService));
DependencyResolver resolver = mock(typeof(DependencyResolver));
Statement statement = mock(typeof(Statement), RETURNS_DEEP_STUBS);
ThreadToStatementContextBridge contextBridge = mock(typeof(ThreadToStatementContextBridge));
when(_spi.queryService()).thenReturn(_queryService);
when(_spi.resolver()).thenReturn(resolver);
when(resolver.ResolveDependency(typeof(ThreadToStatementContextBridge))).thenReturn(contextBridge);
when(contextBridge.Get()).thenReturn(statement);
Config config = Config.defaults();
when(resolver.ResolveDependency(typeof(Config))).thenReturn(config);
_graphDatabaseFacade.init(_spi, contextBridge, config, mockedTokenHolders());
}
//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 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 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);
}
private void SetUpMocks()
{
_queryService = mock(typeof(GraphDatabaseQueryService));
DependencyResolver resolver = mock(typeof(DependencyResolver));
_txBridge = mock(typeof(ThreadToStatementContextBridge));
_initialStatement = mock(typeof(KernelStatement));
_statistics = new ConfiguredExecutionStatistics(this);
QueryRegistryOperations queryRegistryOperations = mock(typeof(QueryRegistryOperations));
InternalTransaction internalTransaction = mock(typeof(InternalTransaction));
when(internalTransaction.TerminationReason()).thenReturn(null);
when(_initialStatement.queryRegistration()).thenReturn(queryRegistryOperations);
when(_queryService.DependencyResolver).thenReturn(resolver);
when(resolver.ResolveDependency(typeof(ThreadToStatementContextBridge))).thenReturn(_txBridge);
when(_queryService.beginTransaction(any(), any())).thenReturn(internalTransaction);
KernelTransaction mockTransaction = mockTransaction(_initialStatement);
when(_txBridge.get()).thenReturn(_initialStatement);
when(_txBridge.getKernelTransactionBoundToThisThread(true)).thenReturn(mockTransaction);
}
private static TransactionalContextFactory NewTransactionalContextFactory(GraphDatabaseAPI db)
{
GraphDatabaseQueryService queryService = ResolveDependency(db, typeof(GraphDatabaseQueryService));
return(Neo4jTransactionalContextFactory.create(queryService, _locker));
}
private TransactionHandle GetTransactionHandle(TransitionalPeriodTransactionMessContainer kernel, QueryExecutionEngine executionEngine, TransactionRegistry registry)
{
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
return(new TransactionHandle(kernel, executionEngine, queryService, registry, uriScheme, true, AUTH_DISABLED, anyLong(), NullLogProvider.Instance));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("ConstantConditions") @Test public void rollsBackNewlyCreatedTransactionIfTerminationDetectedOnCloseDuringPeriodicCommit()
public virtual void RollsBackNewlyCreatedTransactionIfTerminationDetectedOnCloseDuringPeriodicCommit()
{
// Given
InternalTransaction initialTransaction = mock(typeof(InternalTransaction), new ReturnsDeepStubs());
KernelTransaction.Type transactionType = KernelTransaction.Type.@implicit;
SecurityContext securityContext = SecurityContext.AUTH_DISABLED;
when(initialTransaction.TransactionType()).thenReturn(transactionType);
when(initialTransaction.SecurityContext()).thenReturn(securityContext);
when(initialTransaction.TerminationReason()).thenReturn(null);
GraphDatabaseQueryService queryService = mock(typeof(GraphDatabaseQueryService));
Statement initialStatement = mock(typeof(Statement));
KernelTransaction initialKTX = MockTransaction(initialStatement);
QueryRegistryOperations initialQueryRegistry = mock(typeof(QueryRegistryOperations));
ExecutingQuery executingQuery = mock(typeof(ExecutingQuery));
PropertyContainerLocker locker = new PropertyContainerLocker();
ThreadToStatementContextBridge txBridge = mock(typeof(ThreadToStatementContextBridge));
Statement secondStatement = mock(typeof(Statement));
KernelTransaction secondKTX = MockTransaction(secondStatement);
InternalTransaction secondTransaction = mock(typeof(InternalTransaction));
when(secondTransaction.TerminationReason()).thenReturn(null);
QueryRegistryOperations secondQueryRegistry = mock(typeof(QueryRegistryOperations));
when(executingQuery.QueryText()).thenReturn("X");
when(executingQuery.QueryParameters()).thenReturn(EMPTY_MAP);
Mockito.doThrow(typeof(Exception)).when(initialTransaction).close();
when(initialStatement.QueryRegistration()).thenReturn(initialQueryRegistry);
when(queryService.BeginTransaction(transactionType, securityContext)).thenReturn(secondTransaction);
when(txBridge.GetKernelTransactionBoundToThisThread(true)).thenReturn(initialKTX, initialKTX, secondKTX);
when(txBridge.Get()).thenReturn(secondStatement);
when(secondStatement.QueryRegistration()).thenReturn(secondQueryRegistry);
Kernel kernel = mock(typeof(Kernel));
Neo4jTransactionalContext context = new Neo4jTransactionalContext(queryService, txBridge, locker, initialTransaction, initialStatement, executingQuery, kernel);
// When
try
{
context.CommitAndRestartTx();
throw new AssertionError("Expected RuntimeException to be thrown");
}
catch (Exception)
{
// Then
object[] mocks = new object[] { txBridge, initialTransaction, initialQueryRegistry, initialKTX, secondQueryRegistry, secondKTX, secondTransaction };
InOrder order = Mockito.inOrder(mocks);
// (0) Constructor
order.verify(initialTransaction).transactionType();
order.verify(initialTransaction).securityContext();
order.verify(txBridge).getKernelTransactionBoundToThisThread(true);
order.verify(initialTransaction).terminationReason(); // not terminated check
// (1) Collect statistics
order.verify(initialKTX).executionStatistics();
// (2) Unbind old
order.verify(txBridge).getKernelTransactionBoundToThisThread(true);
order.verify(txBridge).unbindTransactionFromCurrentThread();
// (3) Register and unbind new
order.verify(txBridge).getKernelTransactionBoundToThisThread(true);
order.verify(secondKTX).acquireStatement();
order.verify(secondQueryRegistry).registerExecutingQuery(executingQuery);
order.verify(txBridge).unbindTransactionFromCurrentThread();
// (4) Rebind, unregister, and close old
order.verify(txBridge).bindTransactionToCurrentThread(initialKTX);
order.verify(initialQueryRegistry).unregisterExecutingQuery(executingQuery);
order.verify(initialTransaction).success();
order.verify(initialTransaction).close();
order.verify(txBridge).bindTransactionToCurrentThread(secondKTX);
order.verify(secondTransaction).failure();
order.verify(secondTransaction).close();
order.verify(txBridge).unbindTransactionFromCurrentThread();
verifyNoMoreInteractions(mocks);
}
}
public virtual Neo4jTransactionalContext CopyFrom(GraphDatabaseQueryService graph, ThreadToStatementContextBridge txBridge, PropertyContainerLocker locker, InternalTransaction initialTransaction, Statement initialStatement, ExecutingQuery executingQuery)
{
return(new Neo4jTransactionalContext(graph, txBridge, locker, initialTransaction, initialStatement, executingQuery, _kernel));
}
