//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)); }