public static bool SupportsMultidatabase(this IConnection connection)
{
var serverVersion = ServerVersion.From(connection.Server.Version);
var protocol = connection.BoltProtocol;
return(serverVersion >= ServerVersion.V4_0_0 &&
protocol.Version() >= BoltProtocolFactory.ProtocolVersion.Version4);
}
public void ShouldHandleMajorMinorPatchVersion(string version)
{
var serverVersion = ServerVersion.From(version);
serverVersion.Major.Should().Be(3);
serverVersion.Minor.Should().Be(2);
serverVersion.Patch.Should().Be(1);
}
public static bool SupportsMultidatabase(this IConnection connection)
{
var serverVersion = ServerVersion.From(connection.Server.Version);
var protocol = connection.BoltProtocol;
return(serverVersion >= new ServerVersion(4, 0, 0) &&
protocol.GetVersion() >= BoltProtocolV4_0.Version);
}
public void ShouldHandleDevVersion()
{
var version = "Neo4j/dev";
var serverVersion = ServerVersion.From(version);
serverVersion.Major.Should().Be(Int32.MaxValue);
serverVersion.Minor.Should().Be(Int32.MaxValue);
serverVersion.Patch.Should().Be(Int32.MaxValue);
}
public RequireServerFactAttribute(string versionText = null,
VersionComparison versionCompare = VersionComparison.EqualTo)
{
var skipText = new StringBuilder();
if (!BoltkitHelper.IsBoltkitAvailable())
{
skipText.AppendLine(BoltkitHelper.TestRequireBoltkit);
}
if (!string.IsNullOrWhiteSpace(versionText))
{
var version = ServerVersion.From(versionText);
var availableVersion = ServerVersion.From(BoltkitHelper.ServerVersion());
var satisfy = false;
switch (versionCompare)
{
case VersionComparison.LessThan:
satisfy = availableVersion.CompareTo(version) < 0;
break;
case VersionComparison.LessThanOrEqualTo:
satisfy = availableVersion.CompareTo(version) <= 0;
break;
case VersionComparison.EqualTo:
satisfy = availableVersion.CompareTo(version) == 0;
break;
case VersionComparison.GreaterThanOrEqualTo:
satisfy = availableVersion.CompareTo(version) >= 0;
break;
case VersionComparison.GreaterThan:
satisfy = availableVersion.CompareTo(version) > 0;
break;
default:
throw new ArgumentOutOfRangeException(nameof(versionCompare));
}
if (!satisfy)
{
skipText.AppendLine(
$"Test requires available server version {availableVersion} to be {versionCompare.ToString()} {version}.");
}
}
Skip = skipText.ToString();
}
public static bool RequiredServerAvailable(string versionText, VersionComparison versionCompare, StringBuilder skipText)
{
var satisfy = true;
if (!string.IsNullOrWhiteSpace(versionText))
{
var version = ServerVersion.From(versionText);
var availableVersion = ServerVersion.From(BoltkitHelper.ServerVersion());
switch (versionCompare)
{
case VersionComparison.LessThan:
satisfy = availableVersion.CompareTo(version) < 0;
break;
case VersionComparison.LessThanOrEqualTo:
satisfy = availableVersion.CompareTo(version) <= 0;
break;
case VersionComparison.EqualTo:
satisfy = availableVersion.CompareTo(version) == 0;
break;
case VersionComparison.GreaterThanOrEqualTo:
satisfy = availableVersion.CompareTo(version) >= 0;
break;
case VersionComparison.GreaterThan:
satisfy = availableVersion.CompareTo(version) > 0;
break;
default:
throw new ArgumentOutOfRangeException(nameof(versionCompare));
}
if (!satisfy)
{
skipText.AppendLine(
$"Test requires available server version {availableVersion} to be {versionCompare.ToString()} {version}.");
}
}
return(satisfy);
}
public async Task GetSummary()
{
var session = Driver.AsyncSession();
try
{
var cursor = await session.RunAsync("CREATE (p:Person { Name: 'Test'})");
var summary = await cursor.SummaryAsync();
var peeked = await cursor.PeekAsync();
peeked.Should().BeNull();
summary.Statement.Text.Should().Be("CREATE (p:Person { Name: 'Test'})");
summary.Statement.Parameters.Count.Should().Be(0);
var stats = summary.Counters;
stats.ToString().Should()
.Be("Counters{NodesCreated=1, NodesDeleted=0, RelationshipsCreated=0, " +
"RelationshipsDeleted=0, PropertiesSet=1, LabelsAdded=1, LabelsRemoved=0, " +
"IndexesAdded=0, IndexesRemoved=0, ConstraintsAdded=0, ConstraintsRemoved=0, SystemUpdates=0}");
summary.StatementType.Should().Be(StatementType.WriteOnly);
var serverInfo = summary.Server;
serverInfo.Address.Should().Be("localhost:7687");
if (ServerVersion.From(serverInfo.Version) >= ServerVersion.V3_1_0)
{
summary.ResultAvailableAfter.Should().BeGreaterOrEqualTo(TimeSpan.Zero);
summary.ResultConsumedAfter.Should().BeGreaterOrEqualTo(TimeSpan.Zero);
}
else
{
summary.ResultAvailableAfter.Should().BeLessThan(TimeSpan.Zero);
summary.ResultConsumedAfter.Should().BeLessThan(TimeSpan.Zero);
}
}
finally
{
await session.CloseAsync();
}
}
public void ShouldThrowWhenVersionIsNullOrEmpty(string version)
{
var exc = Record.Exception(() => ServerVersion.From(version));
exc.Should().BeOfType <ArgumentNullException>();
}
public void ShouldThrowWhenVersionNotRecognized(string version)
{
var exc = Record.Exception(() => ServerVersion.From(version));
exc.Should().BeOfType <ArgumentOutOfRangeException>();
}
public MockedConnection(AccessMode mode, List <Tuple <IRequestMessage, IResponseMessage> > messages,
ServerInfo serverInfo = null)
{
foreach (var pair in messages)
{
if (pair.Item1 != null)
{
_requestMessages.Add(pair.Item1);
}
if (pair.Item2 != null)
{
_responseMessages.Add(pair.Item2);
}
}
_mockConn.Setup(x => x.EnqueueAsync(It.IsAny <IRequestMessage>(), It.IsAny <IResponseHandler>(),
It.IsAny <IRequestMessage>(), It.IsAny <IResponseHandler>()))
.Returns(Task.CompletedTask)
.Callback <IRequestMessage, IResponseHandler, IRequestMessage, IResponseHandler>(
(msg1, handler1, msg2, handler2) =>
{
msg1.ToString().Should().Be(_requestMessages[_requestCount].ToString());
_requestCount++;
_pipeline.Enqueue(msg1, handler1);
if (msg2 != null)
{
msg2.ToString().Should().Be(_requestMessages[_requestCount].ToString());
_requestCount++;
_pipeline.Enqueue(msg2, handler2);
}
});
_mockConn.Setup(x => x.ReceiveOneAsync())
.Returns(() =>
{
if (_responseCount < _responseMessages.Count)
{
_responseMessages[_responseCount].Dispatch(_pipeline);
_responseCount++;
_pipeline.AssertNoFailure();
return(Task.CompletedTask);
}
else
{
throw new InvalidOperationException("Not enough response message to provide");
}
});
_mockConn.Setup(x => x.IsOpen).Returns(() => _responseCount < _responseMessages.Count);
_mockConn.Setup(x => x.Mode).Returns(mode);
var protocol = BoltProtocolV3.BoltV3;
if (serverInfo != null)
{
if (ServerVersion.From(serverInfo.Version) >= ServerVersion.V4_0_0)
{
protocol = BoltProtocolV4.BoltV4;
}
_mockConn.Setup(x => x.Server).Returns(serverInfo);
}
else
{
_mockConn.Setup(x => x.Server)
.Returns(new ServerInfo(new Uri("bolt://123:456"))
{
Version = "Neo4j/3.5.0"
});
}
_mockConn.Setup(x => x.BoltProtocol).Returns(protocol);
}
public static bool SupportsMultidatabase(this IConnection connection)
{
return(ServerVersion.From(connection.Server.Version) >= ServerVersion.V4_0_0);
}
public async Task ShouldReturnDatabaseInfoForDefaultDatabaseWhenSpecifiedInTxFunc()
{
Console.WriteLine($"Version = {ServerVersion.From(BoltkitHelper.ServerVersion())}");
await VerifyDatabaseNameOnSummaryTxFunc("neo4j", "neo4j");
}
