//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleNodeDetachDeleteConcurrentlyWithIndexDrop() throws Throwable
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldHandleNodeDetachDeleteConcurrentlyWithIndexDrop()
{
ShouldHandleIndexDropConcurrentlyWithOperation(nodeId =>
{
ThreadToStatementContextBridge txBridge = Db.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge));
txBridge.getKernelTransactionBoundToThisThread(true).dataWrite().nodeDetachDelete(nodeId);
});
}
private static long GetLabelId(HighlyAvailableGraphDatabase db, Label label)
{
using (Transaction ignore = Db.beginTx())
{
ThreadToStatementContextBridge bridge = ThreadToStatementContextBridgeFrom(db);
return(bridge.GetKernelTransactionBoundToThisThread(true).tokenRead().nodeLabel(label.Name()));
}
}
public ClassicCoreSPI(PlatformModule platform, DataSourceModule dataSource, Logger msgLog, CoreAPIAvailabilityGuard availability, ThreadToStatementContextBridge threadToTransactionBridge)
{
this._platform = platform;
this._dataSource = dataSource;
this._msgLog = msgLog;
this._availability = availability;
this._threadToTransactionBridge = threadToTransactionBridge;
}
internal ProcedureGDSFactory(PlatformModule platform, DataSourceModule dataSource, CoreAPIAvailabilityGuard coreAPIAvailabilityGuard, TokenHolders tokenHolders, ThreadToStatementContextBridge bridge)
{
this._platform = platform;
this._dataSource = dataSource;
this._availability = coreAPIAvailabilityGuard;
this._urlValidator = url => platform.UrlAccessRule.validate(platform.Config, url);
this._tokenHolders = tokenHolders;
this._bridge = bridge;
}
private int LabelId(Label alien)
{
ThreadToStatementContextBridge contextBridge = (( GraphDatabaseAPI )_db).DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge));
using (Transaction tx = _db.beginTx())
{
return(contextBridge.GetKernelTransactionBoundToThisThread(true).tokenRead().nodeLabel(alien.Name()));
}
}
public ProcedureGDBFacadeSPI(DataSourceModule sourceModule, DependencyResolver resolver, CoreAPIAvailabilityGuard availability, ThrowingFunction <URL, URL, URLAccessValidationError> urlValidator, SecurityContext securityContext, ThreadToStatementContextBridge threadToTransactionBridge)
{
this._databaseLayout = sourceModule.NeoStoreDataSource.DatabaseLayout;
this._sourceModule = sourceModule;
this._resolver = resolver;
this._availability = availability;
this._urlValidator = urlValidator;
this._securityContext = securityContext;
this._threadToTransactionBridge = threadToTransactionBridge;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setUp()
public virtual void SetUp()
{
GraphDatabaseAPI api = DbRule.GraphDatabaseAPI;
_graph = api;
DependencyResolver dependencyResolver = api.DependencyResolver;
this._bridge = dependencyResolver.ResolveDependency(typeof(ThreadToStatementContextBridge));
this._tx = _graph.beginTx();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void before()
public virtual void Before()
{
ThreadToStatementContextBridge bridge = mock(typeof(ThreadToStatementContextBridge));
Statement statement = mock(typeof(Statement));
when(bridge.Get()).thenReturn(statement);
_kernelTransaction = spy(typeof(KernelTransaction));
_locks = mock(typeof(Locks));
when(_kernelTransaction.locks()).thenReturn(_locks);
_placeboTx = new PlaceboTransaction(_kernelTransaction);
_resource = mock(typeof(Node));
when(_resource.Id).thenReturn(1L);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private static void lockNodeUsingUniqueIndexSeek(org.neo4j.kernel.internal.GraphDatabaseAPI database, org.neo4j.graphdb.Label label, String nameProperty) throws org.neo4j.internal.kernel.api.exceptions.KernelException
private static void LockNodeUsingUniqueIndexSeek(GraphDatabaseAPI database, Label label, string nameProperty)
{
using (Transaction transaction = database.BeginTx())
{
ThreadToStatementContextBridge contextBridge = database.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge));
KernelTransaction kernelTransaction = contextBridge.GetKernelTransactionBoundToThisThread(true);
TokenRead tokenRead = kernelTransaction.TokenRead();
Read dataRead = kernelTransaction.DataRead();
int labelId = tokenRead.NodeLabel(label.Name());
int propertyId = tokenRead.PropertyKey(nameProperty);
IndexReference indexReference = kernelTransaction.SchemaRead().index(labelId, propertyId);
dataRead.LockingNodeUniqueIndexSeek(indexReference, IndexQuery.ExactPredicate.exact(propertyId, "value"));
transaction.Success();
}
}
private void SetUpMocks()
{
_database = mock(typeof(Database));
_databaseFacade = mock(typeof(GraphDatabaseFacade));
_resolver = mock(typeof(DependencyResolver));
_executionEngine = mock(typeof(ExecutionEngine));
_statementBridge = mock(typeof(ThreadToStatementContextBridge));
_databaseQueryService = mock(typeof(GraphDatabaseQueryService));
_kernelTransaction = mock(typeof(KernelTransaction));
_statement = mock(typeof(Statement));
_request = mock(typeof(HttpServletRequest));
InternalTransaction transaction = new TopLevelTransaction(_kernelTransaction);
LoginContext loginContext = AUTH_DISABLED;
KernelTransaction.Type type = KernelTransaction.Type.@implicit;
QueryRegistryOperations registryOperations = mock(typeof(QueryRegistryOperations));
when(_statement.queryRegistration()).thenReturn(registryOperations);
when(_statementBridge.get()).thenReturn(_statement);
when(_kernelTransaction.securityContext()).thenReturn(loginContext.Authorize(s => - 1, GraphDatabaseSettings.DEFAULT_DATABASE_NAME));
when(_kernelTransaction.transactionType()).thenReturn(type);
when(_database.Graph).thenReturn(_databaseFacade);
when(_databaseFacade.DependencyResolver).thenReturn(_resolver);
when(_resolver.resolveDependency(typeof(QueryExecutionEngine))).thenReturn(_executionEngine);
when(_resolver.resolveDependency(typeof(ThreadToStatementContextBridge))).thenReturn(_statementBridge);
when(_resolver.resolveDependency(typeof(GraphDatabaseQueryService))).thenReturn(_databaseQueryService);
when(_databaseQueryService.beginTransaction(type, loginContext)).thenReturn(transaction);
when(_databaseQueryService.beginTransaction(type, loginContext, CUSTOM_TRANSACTION_TIMEOUT, TimeUnit.MILLISECONDS)).thenReturn(transaction);
when(_databaseQueryService.DependencyResolver).thenReturn(_resolver);
when(_request.Scheme).thenReturn("http");
when(_request.RemoteAddr).thenReturn("127.0.0.1");
when(_request.RemotePort).thenReturn(5678);
when(_request.ServerName).thenReturn("127.0.0.1");
when(_request.ServerPort).thenReturn(7474);
when(_request.RequestURI).thenReturn("/");
}
internal TransactionContinuation(HighlyAvailableGraphDatabase db)
{
this.Db = db;
this.Bridge = ThreadToStatementContextBridgeFrom(db);
}
