public async Task ShouldFailWithAuthenticationError()
{
Exception exception = null;
using (var driver = GraphDatabase.Driver(RoutingServer, AuthTokens.Basic("fake", "fake")))
{
var session = driver.AsyncSession();
try
{
exception = await Record.ExceptionAsync(() => session.RunAsync("RETURN 1"));
}
finally
{
await session.CloseAsync();
}
}
exception.Should().BeOfType <AuthenticationException>();
exception.Message.Should().Be("The client is unauthorized due to authentication failure.");
}
public virtual IDriver GetDriver()
{
if (Instance == null)
{
Instance = new DriverDecorator(GraphDatabase.Driver(Uri, AuthToken, Config), Manager);
}
else
{
try
{
Instance.Session().Dispose();
}
catch
{
Instance = new DriverDecorator(GraphDatabase.Driver(Uri, AuthToken, Config), Manager);
}
}
return(Instance);
}
public void ShouldNotPackBytes()
{
// Given
byte[] byteArray = PackStreamBitConverter.GetBytes("hello, world");
// When
using (var driver = GraphDatabase.Driver("bolt://127.0.0.1:7687", AuthToken))
using (var session = driver.Session())
{
var exception = Record.Exception(() =>
session.Run("CREATE (a {value:{value}})",
new Dictionary <string, object> {
{ "value", byteArray }
}));
// Then
exception.Should().BeOfType <ProtocolException>();
exception.Message.Should().Be("Cannot understand values with type System.Byte[]");
}
}
private (IDriver, ConcurrentQueue <IPooledConnection>) SetupMonitoredDriver()
{
var configBuilder = Config.Builder
.WithMetricsEnabled(true)
.WithConnectionAcquisitionTimeout(TimeSpan.FromMinutes(5))
.WithConnectionTimeout(Config.InfiniteInterval)
.WithMaxConnectionPoolSize(100)
.WithLogger(new StressTestLogger(_output, LoggingEnabled));
_configure?.Invoke(configBuilder);
var config = configBuilder.Build();
var connectionSettings = new ConnectionSettings(_databaseUri, _authToken, config);
var bufferSettings = new BufferSettings(config);
var connectionFactory = new MonitoredPooledConnectionFactory(
new PooledConnectionFactory(connectionSettings, bufferSettings, config.Logger));
return((Internal.Driver)GraphDatabase.CreateDriver(_databaseUri, config, connectionFactory),
connectionFactory.Connections);
}
public async Task ShouldThrowServiceUnavailableExceptionIfNoServer()
{
using (var driver = GraphDatabase.Driver(WrongServer, AuthTokens.Basic("fake", "fake")))
{
var session = driver.AsyncSession();
try
{
var exc = await Record.ExceptionAsync(() => session.RunAsync("RETURN 1"));
exc.Should().BeOfType <ServiceUnavailableException>().Which
.Message.Should()
.Be(
"Failed to connect to any routing server. Please make sure that the cluster is up and can be accessed by the driver and retry.");
}
finally
{
await session.CloseAsync();
}
}
}
protected async Task AssertRestoredDatabase(string boltEndpoint)
{
using (var driver = GraphDatabase.Driver(boltEndpoint))
{
var session = driver.AsyncSession();
try
{
var result = await session.RunAsync("MATCH (p:Person) RETURN p.FirstName as FirstName, p.LastName AS LastName");
var record = await result.SingleAsync();
Assert.AreEqual("Foo", record["FirstName"].As <string>());
Assert.AreEqual("Bar", record["LastName"].As <string>());
}
finally
{
await session.CloseAsync();
}
}
}
public void ShouldAllowMoreTxAfterSessionReset()
{
using (var driver = GraphDatabase.Driver(_serverEndPoint, _authToken))
{
using (var session = driver.Session())
{
using (var tx = session.BeginTransaction())
{
tx.Run("Return 1");
tx.Success();
}
session.Reset();
using (var tx = session.BeginTransaction())
{
tx.Run("RETURN 2");
tx.Success();
}
}
}
}
public void ShouldFailIfCommitFailsDueToBrokenConnection(string boltVersion)
{
using (BoltStubServer.Start($"{boltVersion}/connection_error_on_commit", 9001))
{
using (var driver =
GraphDatabase.Driver("bolt://127.0.0.1:9001", AuthTokens.None, NoEncryptionAndShortRetry))
{
using (var session = driver.Session(o => o.WithDefaultAccessMode(AccessMode.Write)))
{
var txc = session.BeginTransaction();
var result = txc.Run("CREATE (n {name: 'Bob'})");
var exc = Record.Exception(() => txc.Commit());
exc.Should().BeOfType <ServiceUnavailableException>().Which
.HasCause <IOException>().Should().BeTrue();
}
}
}
}
public void ShouldLoadBalanceBetweenServers()
{
using (var driver = GraphDatabase.Driver(RoutingServer, AuthToken))
{
string addr1, addr2;
for (int i = 0; i < 10; i++)
{
using (var session = driver.Session(AccessMode.Read))
{
var result = session.Run("RETURN 1");
addr1 = result.Summary.Server.Address;
}
using (var session = driver.Session(AccessMode.Read))
{
addr2 = session.Run("RETURN 2").Summary.Server.Address;
}
addr1.Should().NotBe(addr2);
}
}
}
public void ResultsHaveReceivedButNotBeenReadGetBufferedAfterSessionClosed()
{
using (var driver = GraphDatabase.Driver(_serverEndPoint, _authToken))
{
IStatementResult result;
using (var session = driver.Session())
{
result = session.Run("unwind range(1,3) as n RETURN n");
}
var resultAll = result.ToList();
// Records that has not been read inside session still saved
resultAll.Count.Should().Be(3);
resultAll.Select(r => r.Values["n"].ValueAs <int>()).Should().ContainInOrder(1, 2, 3);
// Summary is still saved
result.Summary.Statement.Text.Should().Be("unwind range(1,3) as n RETURN n");
result.Summary.StatementType.Should().Be(StatementType.ReadOnly);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton(s => GraphDatabase.Driver(Configuration.GetConnectionString("DefaultConnection"), AuthTokens.Basic("neo4j", "neo4j")));
services.AddScoped(s => s.GetService <IDriver>().AsyncSession());
services.AddIdentity <ApplicationUser, Neo4jIdentityRole>()
.AddNeo4jDataStores()
.AddDefaultTokenProviders();
services.AddMvc()
.AddRazorPagesOptions(options =>
{
options.Conventions.AuthorizeFolder("/Account/Manage");
options.Conventions.AuthorizePage("/Account/Logout");
});
// Register no-op EmailSender used by account confirmation and password reset during development
// For more information on how to enable account confirmation and password reset please visit https://go.microsoft.com/fwlink/?LinkID=532713
services.AddSingleton <IEmailSender, EmailSender>();
}
static void Main(string[] args)
{
using (var _driver = GraphDatabase.Driver("bolt://localhost:7687",
AuthTokens.Basic("neo4j", "Neo4j")))
{
using (var session = _driver.Session())
{
var response = session.ReadTransaction(tx =>
tx.Run("match (a:Actor) return a limit 100"));
foreach (var result in response)
{
var firstValue = result.Values.First().Value;
Console.WriteLine(((INode)firstValue)
.Properties["name"].As <string>());
}
}
}
Console.ReadKey();
}
public async Task ShouldNotBeAbleToAccessRecordsAfterSessionClose()
{
using (var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken))
{
var session = driver.AsyncSession();
IStatementResultCursor cursor;
try
{
cursor = await session.RunAsync("RETURN 1 As X");
}
finally
{
await session.CloseAsync();
}
var records = await cursor.ToListAsync();
records.Count.Should().Be(0);
}
}
private IDriver GetDriver(IServiceProvider provider)
{
//We're creating a logger here that the IDriver can use, that also hooks into the ASPNET logger
var logger = new Neo4jAspNetCoreLogger(provider.GetService <ILogger <IDriver> >())
{
//LogLevel is pulled from the ASP NET default logging level
Level = Enum.Parse <LogLevel>(Configuration["Logging:LogLevel:Default"])
};
//Setup our IDriver instance to be injected
var driver = GraphDatabase.Driver(
Configuration["Neo4j:Host"],
AuthTokens.Basic(
Configuration["Neo4j:User"],
Configuration["Neo4j:Pass"]),
config => config.WithLogger(logger)
);
return(driver);
}
public void ShouldCreateCustomAuthToken()
{
var oldAuthToken = _authToken.AsDictionary();
var newAuthToken = AuthTokens.Custom(
oldAuthToken["principal"].ValueAs <string>(),
oldAuthToken["credentials"].ValueAs <string>(),
"native",
"basic");
using (var driver = GraphDatabase.Driver(_serverEndPoint, newAuthToken))
{
using (var session = driver.Session())
{
var result = session.Run("RETURN 2 as Number");
result.Consume();
result.Keys.Should().Contain("Number");
result.Keys.Count.Should().Be(1);
}
}
}
public async void KeysShouldBeAvailableJustAfterConsecutiveRunAsyncWithConsumptionInBetween()
{
using (var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken))
{
using (var session = driver.Session())
{
var cursor1 = await session.RunAsync("RETURN 1 As X");
var cursor2 = await session.RunAsync("RETURN 1 As Y");
await cursor1.ConsumeAsync();
cursor1.Keys.Should().HaveCount(1);
cursor1.Keys.Should().Contain("X");
cursor2.Keys.Should().HaveCount(1);
cursor2.Keys.Should().Contain("Y");
}
}
}
public async Task KeysShouldBeAvailableAfterConsecutiveRunNoOrder()
{
using var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken);
var session = driver.AsyncSession();
await using (session.ConfigureAwait(false))
{
var cursor1 = await session.RunAsync("RETURN 1 As X");
var cursor2 = await session.RunAsync("RETURN 1 As Y");
var keys2 = await cursor2.KeysAsync();
keys2.Should().BeEquivalentTo("Y");
var keys1 = await cursor1.KeysAsync();
keys1.Should().BeEquivalentTo("X");
}
}
private void SetupMonitoredDriver()
{
var config = new Config
{
MetricsFactory = new DefaultMetricsFactory(),
ConnectionAcquisitionTimeout = TimeSpan.FromMinutes(5),
ConnectionTimeout = Config.InfiniteInterval,
MaxConnectionPoolSize = 100,
DriverLogger = new TestDriverLogger(Output)
};
var connectionSettings = new ConnectionSettings(AuthToken, config);
var bufferSettings = new BufferSettings(config);
var connectionFactory = new MonitoredPooledConnectionFactory(
new PooledConnectionFactory(connectionSettings, bufferSettings, config.DriverLogger));
_driver = (Internal.Driver)GraphDatabase.CreateDriver(new Uri(RoutingServer), config, connectionFactory);
_connections = connectionFactory.Connections;
_metrics = _driver.GetMetrics();
}
public async Task ShouldConnectIPv6AddressIfEnabled()
{
using (var driver = GraphDatabase.Driver("bolt://[::1]:7687", AuthToken,
o => o.WithIpv6Enabled(true)))
{
var session = driver.AsyncSession();
try
{
var cursor = await session.RunAsync("RETURN 1");
var result = await cursor.SingleAsync(r => r[0].As <int>());
result.Should().Be(1);
}
finally
{
await session.CloseAsync();
}
}
}
public async Task ShouldNotBeAbleToAccessRecordsAfterSessionClose()
{
using (var driver = GraphDatabase.Driver(ServerEndPoint, AuthToken))
{
var session = driver.AsyncSession();
IResultCursor cursor;
try
{
cursor = await session.RunAsync("RETURN 1 As X");
}
finally
{
await session.CloseAsync();
}
var error = await Record.ExceptionAsync(async() => await cursor.ToListAsync());
error.Should().BeOfType <ResultConsumedException>();
}
}
public void csvtographdbfunction(int ID, string word)
{
Console.WriteLine("word without synonym {0}", word);
string id = ID.ToString();
using (var driver = GraphDatabase.Driver("bolt://*****:*****@"merge(p:doc" + id + "{name:{WORD},detect:{DETECT}}) with p match(m:doc" + id + "),(n:doc" + id + ") merge (m)-[:next]-(n)",
new Dictionary <string, object> {
{ "WORD", "" + word + "" }, { "DETECT", "" + id + "" }
});
Console.WriteLine("yoyoyoy");
session.Run(@"match(a) match(b) where a.name=b.name merge (a)<-[r:same]->(b) with a,b match(a) match(b) where a=b match (a)<-[r]->(b) delete r");
Console.WriteLine("reached the end of elsegraph");
}
}
public static void Register(HttpConfiguration config)
{
// Web API configuration and services
// Web API routes
config.MapHttpAttributeRoutes();
config.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
config.Formatters.JsonFormatter.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
var appXmlType = config.Formatters.XmlFormatter.SupportedMediaTypes.FirstOrDefault(t => t.MediaType == "application/xml");
config.Formatters.XmlFormatter.SupportedMediaTypes.Remove(appXmlType);
//Use an IoC container and register as a Singleton
var url = ConfigurationManager.AppSettings["GraphDBUrl"];
var driver = GraphDatabase.Driver(url);
Neo4jDriver = driver;
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mixingPeriodicCommitAndLoadCSVShouldWorkWithLists() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void MixingPeriodicCommitAndLoadCSVShouldWorkWithLists()
{
using (Driver driver = GraphDatabase.driver(GraphDb.boltURI(), Configuration()), Session session = driver.session())
{
StatementResult result = session.run("USING PERIODIC COMMIT " + (_lineCountInCSV - 1) + "\n" + "LOAD CSV FROM \"" + _url + "\" as row fieldterminator \" \"\n" + "MERGE (currentnode:Label2 {uuid:row[0]})\n" + "RETURN [currentnode];");
int countOfNodes = 0;
while (result.hasNext())
{
IEnumerator <object> iterator = result.next().get(0).asList().GetEnumerator();
while (iterator.MoveNext())
{
Node node = ( Node )iterator.Current;
assertTrue(node.hasLabel("Label2"));
assertEquals(countOfNodes.ToString(), node.get("uuid").asString());
countOfNodes++;
}
}
assertEquals(_lineCountInCSV, countOfNodes);
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void mixingPeriodicCommitAndLoadCSVShouldWork()
public virtual void MixingPeriodicCommitAndLoadCSVShouldWork()
{
for (int i = _lineCountInCSV - 1; i < _lineCountInCSV + 1; i++) // test with different periodic commit sizes
{
using (Driver driver = GraphDatabase.driver(GraphDb.boltURI(), Configuration()), Session session = driver.session())
{
StatementResult result = session.run("USING PERIODIC COMMIT " + i + "\n" + "LOAD CSV FROM \"" + _url + "\" as row fieldterminator \" \"\n" + "MERGE (currentnode:Label1 {uuid:row[0]})\n" + "RETURN currentnode;");
int countOfNodes = 0;
while (result.hasNext())
{
Node node = result.next().get(0).asNode();
assertTrue(node.hasLabel("Label1"));
assertEquals(countOfNodes.ToString(), node.get("uuid").asString());
countOfNodes++;
}
assertEquals(_lineCountInCSV, countOfNodes);
session.reset();
}
}
}
public static IDriver ConnectToNeo(NeoConfiguration config, Config neo4jconfig)
{
try
{
if (string.IsNullOrWhiteSpace(config.DB_Password) || string.IsNullOrWhiteSpace(config.DB_Username))
{
return(GraphDatabase.Driver(config.DB_URI, neo4jconfig));
}
else
{
return(GraphDatabase.Driver(config.DB_URI, AuthTokens.Basic(config.DB_Username, config.DB_Password), neo4jconfig));
}
}
catch (Exception e)
{
Console.WriteLine("Error connecting to Neo4j: " + e.Message);
Environment.Exit(1002);
}
return(null);
}
private static async Task VerifyConnectivity(Uri address, IAuthToken token)
{
using (var driver = GraphDatabase.Driver(address, token))
{
var session = driver.AsyncSession();
try
{
var cursor = await session.RunAsync("RETURN 2 as Number");
var records = await cursor.ToListAsync(r => r["Number"].As <int>());
records.Should().BeEquivalentTo(2);
}
finally
{
await session.CloseAsync();
}
}
}
public void ShouldNotThrowExceptionWhenDisposeSessionAfterDriver()
{
var driver = GraphDatabase.Driver(_serverEndPoint, _authToken);
var session = driver.Session();
using (var tx = session.BeginTransaction())
{
var ex = Record.Exception(() => tx.Run("Invalid Cypher").Consume());
ex.Should().BeOfType <ClientException>();
ex.Message.Should().StartWith("Invalid input 'I'");
}
var result = session.Run("RETURN 1");
result.Single()[0].ValueAs <int>().Should().Be(1);
driver.Dispose();
session.Dispose();
}
static void Main(string[] args)
{
WczytajBazeNeo4j();
var Start = WybierzStacjeStartowa();
var Stop = WybierzStacjeDocelowa();
Console.WriteLine();
using (var driver = GraphDatabase.Driver("bolt://localhost", AuthTokens.Basic(_login, _pass)))
{
using (var session = driver.Session())
{
string st = $@"MATCH (start:Loc{{name:'{Start}'}}), (end:Loc{{name:'{Stop}'}}) CALL algo.shortestPath(start, end, 'cost',{{write:true,writeProperty:'sssp'}}) YIELD writeMillis,loadMillis,nodeCount, totalCost RETURN writeMillis,loadMillis,nodeCount,totalCost";
var result = session.Run(st);
foreach (var record in result)
{
Console.WriteLine($"{record["nodeCount"].As<string>()} przystankow i {record["totalCost"].As<string>()} jednostek czasowych do pokonania trasy z {Start} do {Stop}");
}
}
}
using (var driver = GraphDatabase.Driver("bolt://localhost", AuthTokens.Basic(_login, _pass)))
{
using (var session = driver.Session())
{
string st = $@"MATCH(n: Loc {{ name: '{Start}'}}) CALL algo.shortestPath.deltaStepping.stream(n, 'cost', 3.0) YIELD nodeId, distance RETURN algo.asNode(nodeId).name AS destination, distance ORDER BY distance ASC";
var result = session.Run(st);
Console.WriteLine();
foreach (var record in result)
{
Console.WriteLine($"{record["destination"].As<string>()} {record["distance"].As<string>()}");
}
}
}
Console.ReadKey();
}
public async Task CanSendMultipleBookmarks()
{
var bookmarks = new[]
{
"neo4j:bookmark:v1:tx5", "neo4j:bookmark:v1:tx29",
"neo4j:bookmark:v1:tx94", "neo4j:bookmark:v1:tx56",
"neo4j:bookmark:v1:tx16", "neo4j:bookmark:v1:tx68"
};
using (BoltStubServer.Start("V4/multiple_bookmarks", 9001))
{
var uri = new Uri("bolt://127.0.0.1:9001");
using (var driver = GraphDatabase.Driver(uri, SetupConfig))
{
var session = driver.AsyncSession(o => o.WithBookmarks(Bookmark.From(bookmarks)));
try
{
var txc = await session.BeginTransactionAsync();
try
{
await txc.RunAsync("CREATE (n {name:'Bob'})");
await txc.CommitAsync();
}
catch
{
await txc.RollbackAsync();
throw;
}
}
finally
{
await session.CloseAsync();
}
session.LastBookmark.Should().Be(Bookmark.From("neo4j:bookmark:v1:tx95"));
}
}
}
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
services.AddHttpContextAccessor();
// configure strongly typed settings objects
var appSettingsSection = Configuration.GetSection("AppSettings");
services.Configure <AppSettings>(appSettingsSection);
services.AddSingleton(GraphDatabase.Driver("bolt://localhost:7687", AuthTokens.Basic("neo4j", "password"))); //7474
services.AddDbContext <AppDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
// configure jwt authentication
var appSettings = appSettingsSection.Get <AppSettings>();
var key = Encoding.ASCII.GetBytes(appSettings.Secret);
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
});
// configure DI for application services
services.AddScoped <IUserService, UserService>();
}
