//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleSingleNodePath()
public virtual void ShouldHandleSingleNodePath()
{
// Given
Node node;
using (Transaction tx = Db.beginTx())
{
node = Db.createNode();
tx.Success();
}
// When
Path mapped = _mapper.mapPath(path(AsNodeValues(node), AsRelationshipsValues()));
// Then
using (Transaction ignore = Db.beginTx())
{
assertThat(mapped.Length(), equalTo(0));
assertThat(mapped.StartNode(), equalTo(node));
assertThat(mapped.EndNode(), equalTo(node));
assertThat(Iterables.asList(mapped.Relationships()), hasSize(0));
assertThat(Iterables.asList(mapped.ReverseRelationships()), hasSize(0));
assertThat(Iterables.asList(mapped.Nodes()), equalTo(singletonList(node)));
assertThat(Iterables.asList(mapped.ReverseNodes()), equalTo(singletonList(node)));
assertThat(mapped.LastRelationship(), nullValue());
assertThat(Iterators.asList(mapped.GetEnumerator()), equalTo(singletonList(node)));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldTerminateOutdatedTransactions() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldTerminateOutdatedTransactions()
{
// given
long safeZone = 10;
int txCount = 3;
long firstCommitTimestamp = 10;
long commitTimestampInterval = 2;
TransactionBatchCommitter committer = NewBatchCommitter(safeZone);
TransactionChain chain = CreateTxChain(txCount, firstCommitTimestamp, commitTimestampInterval);
long timestampOutsideSafeZone = chain.Last.transactionRepresentation().LatestCommittedTxWhenStarted - safeZone - 1;
KernelTransaction txToTerminate = NewKernelTransaction(timestampOutsideSafeZone);
KernelTransaction tx = NewKernelTransaction(firstCommitTimestamp - 1);
when(_kernelTransactions.activeTransactions()).thenReturn(Iterators.asSet(NewHandle(txToTerminate), NewHandle(tx)));
// when
committer.Apply(chain.First, chain.Last);
// then
verify(txToTerminate).markForTermination(Org.Neo4j.Kernel.Api.Exceptions.Status_Transaction.Outdated);
verify(tx, never()).markForTermination(any());
_logProvider.formattedMessageMatcher().assertContains("Marking transaction for termination");
_logProvider.formattedMessageMatcher().assertContains("lastCommittedTxId:" + (BASE_TX_ID + txCount - 1));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleSingleRelationshipPath()
public virtual void ShouldHandleSingleRelationshipPath()
{
// Given
Node start, end;
Relationship relationship;
using (Transaction tx = Db.beginTx())
{
start = Db.createNode();
end = Db.createNode();
relationship = start.CreateRelationshipTo(end, RelationshipType.withName("R"));
tx.Success();
}
// When
Path mapped = _mapper.mapPath(path(AsNodeValues(start, end), AsRelationshipsValues(relationship)));
// Then
using (Transaction ignore = Db.beginTx())
{
assertThat(mapped.Length(), equalTo(1));
assertThat(mapped.StartNode(), equalTo(start));
assertThat(mapped.EndNode(), equalTo(end));
assertThat(Iterables.asList(mapped.Relationships()), equalTo(singletonList(relationship)));
assertThat(Iterables.asList(mapped.ReverseRelationships()), equalTo(singletonList(relationship)));
assertThat(Iterables.asList(mapped.Nodes()), equalTo(Arrays.asList(start, end)));
assertThat(Iterables.asList(mapped.ReverseNodes()), equalTo(Arrays.asList(end, start)));
assertThat(mapped.LastRelationship(), equalTo(relationship));
assertThat(Iterators.asList(mapped.GetEnumerator()), equalTo(Arrays.asList(start, relationship, end)));
}
}
private Path GetFirstPath(Traverser traverse)
{
using (ResourceIterator <Path> iterator = traverse.GetEnumerator())
{
return(Iterators.first(iterator));
}
}
private SchemaRead SchemaWithIndexes(params IndexReference[] indexes)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.internal.kernel.api.SchemaRead schemaRead = mock(org.neo4j.internal.kernel.api.SchemaRead.class);
SchemaRead schemaRead = mock(typeof(SchemaRead));
when(schemaRead.IndexesGetAll()).thenReturn(Iterators.iterator(indexes));
return(schemaRead);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test(expected = IllegalArgumentException.class) public void bothSidesMustHaveSameUniqueness()
public virtual void BothSidesMustHaveSameUniqueness()
{
CreateGraph("A TO B");
Traverser traverse = GraphDb.bidirectionalTraversalDescription().startSide(GraphDb.traversalDescription().uniqueness(Uniqueness.NODE_GLOBAL)).endSide(GraphDb.traversalDescription().uniqueness(Uniqueness.RELATIONSHIP_GLOBAL)).traverse(GetNodeWithName("A"), GetNodeWithName("B"));
using (ResourceIterator <Path> iterator = traverse.GetEnumerator())
{
Iterators.count(iterator);
}
}
private void VerifyContent()
{
GraphDatabaseAPI newDb = Db.GraphDatabaseAPI;
using (Transaction tx = newDb.BeginTx())
{
assertEquals(1L, Iterators.stream(newDb.Schema().getIndexes(_label).GetEnumerator()).count());
assertNotNull(newDb.FindNode(_label, _propKey, _numberValue));
assertNotNull(newDb.FindNode(_label, _propKey, _stringValue));
assertNotNull(newDb.FindNode(_label, _propKey, _spatialValue));
assertNotNull(newDb.FindNode(_label, _propKey, _temporalValue));
tx.Success();
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void flushStoreFilesWithCorrectCheckpointTriggerName() throws java.io.IOException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void FlushStoreFilesWithCorrectCheckpointTriggerName()
{
CheckPointer checkPointer = mock(typeof(CheckPointer));
StoreCopyCheckPointMutex mutex = new StoreCopyCheckPointMutex();
NeoStoreDataSource dataSource = mock(typeof(NeoStoreDataSource));
when(dataSource.StoreCopyCheckPointMutex).thenReturn(mutex);
when(dataSource.ListStoreFiles(anyBoolean())).thenReturn(Iterators.emptyResourceIterator());
DefaultMasterImplSPI master = new DefaultMasterImplSPI(mock(typeof(GraphDatabaseAPI), RETURNS_MOCKS), mock(typeof(FileSystemAbstraction)), new Monitors(), mockedTokenHolders(), mock(typeof(IdGeneratorFactory)), mock(typeof(TransactionCommitProcess)), checkPointer, mock(typeof(TransactionIdStore)), mock(typeof(LogicalTransactionStore)), dataSource, NullLogProvider.Instance);
master.FlushStoresAndStreamStoreFiles(mock(typeof(StoreWriter)));
TriggerInfo expectedTriggerInfo = new SimpleTriggerInfo(DefaultMasterImplSPI.STORE_COPY_CHECKPOINT_TRIGGER);
verify(checkPointer).tryCheckPoint(expectedTriggerInfo);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void shouldNotTimeoutSchemaTransactions()
internal virtual void ShouldNotTimeoutSchemaTransactions()
{
// given
KernelTransactions kernelTransactions = mock(typeof(KernelTransactions));
FakeClock clock = new FakeClock(100, MINUTES);
KernelTransactionMonitor monitor = new KernelTransactionMonitor(kernelTransactions, clock, NullLogService.Instance);
// a 2 minutes old schema transaction which has a timeout of 1 minute
KernelTransactionHandle oldSchemaTransaction = mock(typeof(KernelTransactionHandle));
when(oldSchemaTransaction.SchemaTransaction).thenReturn(true);
when(oldSchemaTransaction.StartTime()).thenReturn(clock.Millis() - MINUTES.toMillis(2));
when(oldSchemaTransaction.TimeoutMillis()).thenReturn(MINUTES.toMillis(1));
when(kernelTransactions.ActiveTransactions()).thenReturn(Iterators.asSet(oldSchemaTransaction));
// when
monitor.Run();
// then
verify(oldSchemaTransaction, times(1)).SchemaTransaction;
verify(oldSchemaTransaction, never()).markForTermination(any());
}
public override ResourceIterator <T> Iterator()
{
try
{
if (_cursor.next())
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final T first = cursor.get();
T first = _cursor.get();
return(new ResourceIteratorAnonymousInnerClass(this, first));
}
_cursor.close();
return(Iterators.asResourceIterator(Collections.emptyIterator()));
}
catch (IOException)
{
return(Iterators.asResourceIterator(Collections.emptyIterator()));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldHandleLongPath()
public virtual void ShouldHandleLongPath()
{
// Given
Node a, b, c, d, e;
Relationship r1, r2, r3, r4;
using (Transaction tx = Db.beginTx())
{
a = Db.createNode();
b = Db.createNode();
c = Db.createNode();
d = Db.createNode();
e = Db.createNode();
r1 = a.CreateRelationshipTo(b, RelationshipType.withName("R"));
r2 = b.CreateRelationshipTo(c, RelationshipType.withName("R"));
r3 = c.CreateRelationshipTo(d, RelationshipType.withName("R"));
r4 = d.CreateRelationshipTo(e, RelationshipType.withName("R"));
tx.Success();
}
// When
Path mapped = _mapper.mapPath(path(AsNodeValues(a, b, c, d, e), AsRelationshipsValues(r1, r2, r3, r4)));
// Then
using (Transaction ignore = Db.beginTx())
{
assertThat(mapped.Length(), equalTo(4));
assertThat(mapped.StartNode(), equalTo(a));
assertThat(mapped.EndNode(), equalTo(e));
assertThat(Iterables.asList(mapped.Relationships()), equalTo(Arrays.asList(r1, r2, r3, r4)));
assertThat(Iterables.asList(mapped.ReverseRelationships()), equalTo(Arrays.asList(r4, r3, r2, r1)));
assertThat(Iterables.asList(mapped.Nodes()), equalTo(Arrays.asList(a, b, c, d, e)));
assertThat(Iterables.asList(mapped.ReverseNodes()), equalTo(Arrays.asList(e, d, c, b, a)));
assertThat(mapped.LastRelationship(), equalTo(r4));
assertThat(Iterators.asList(mapped.GetEnumerator()), equalTo(Arrays.asList(a, r1, b, r2, c, r3, d, r4, e)));
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private Object[] single(org.neo4j.collection.RawIterator<Object[], org.neo4j.internal.kernel.api.exceptions.ProcedureException> result) throws org.neo4j.internal.kernel.api.exceptions.ProcedureException
private object[] Single(RawIterator <object[], ProcedureException> result)
{
return(Iterators.single(asList(result).GetEnumerator()));
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void shouldNotAllowConcurrentViolationOfConstraint() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void ShouldNotAllowConcurrentViolationOfConstraint()
{
// Given
GraphDatabaseAPI graphDb = Db.GraphDatabaseAPI;
System.Func <KernelTransaction> ktxSupplier = () => graphDb.DependencyResolver.resolveDependency(typeof(ThreadToStatementContextBridge)).getKernelTransactionBoundToThisThread(true);
Label label = label("Foo");
string propertyKey = "bar";
string conflictingValue = "baz";
// a constraint
using (Transaction tx = graphDb.BeginTx())
{
graphDb.Schema().constraintFor(label).assertPropertyIsUnique(propertyKey).create();
tx.Success();
}
// When
using (Transaction tx = graphDb.BeginTx())
{
KernelTransaction ktx = ktxSupplier();
int labelId = ktx.TokenRead().nodeLabel(label.Name());
int propertyKeyId = ktx.TokenRead().propertyKey(propertyKey);
IndexDescriptor index = TestIndexDescriptorFactory.uniqueForLabel(labelId, propertyKeyId);
Read read = ktx.DataRead();
using (NodeValueIndexCursor cursor = ktx.Cursors().allocateNodeValueIndexCursor())
{
read.NodeIndexSeek(ktx.SchemaRead().index(labelId, propertyKeyId), cursor, IndexOrder.NONE, false, IndexQuery.exact(index.Schema().PropertyId, "The value is irrelevant, we just want to perform some sort of lookup against this " + "index"));
}
// then let another thread come in and create a node
Threads.execute(Db =>
{
using (Transaction transaction = Db.beginTx())
{
Db.createNode(label).setProperty(propertyKey, conflictingValue);
transaction.success();
}
return(null);
}, graphDb).get();
// before we create a node with the same property ourselves - using the same statement that we have
// already used for lookup against that very same index
long node = ktx.DataWrite().nodeCreate();
ktx.DataWrite().nodeAddLabel(node, labelId);
try
{
ktx.DataWrite().nodeSetProperty(node, propertyKeyId, Values.of(conflictingValue));
fail("exception expected");
}
// Then
catch (UniquePropertyValueValidationException e)
{
assertEquals(ConstraintDescriptorFactory.uniqueForLabel(labelId, propertyKeyId), e.Constraint());
IndexEntryConflictException conflict = Iterators.single(e.Conflicts().GetEnumerator());
assertEquals(Values.stringValue(conflictingValue), conflict.SinglePropertyValue);
}
tx.Success();
}
}
protected internal override ResourceIterator <Relationship> ExpandRelationshipsWithoutChecks(PathExpander expander)
{
System.Collections.IEnumerable expandIterable = expander.expand(this, this);
return(Iterators.asResourceIterator(expandIterable.GetEnumerator()));
}
