From d4949c7503ebc02d27d0939cf079709d9020f297 Mon Sep 17 00:00:00 2001 From: Trevi Awater Date: Mon, 30 Mar 2026 21:31:01 +0200 Subject: [PATCH] integration tests --- .github/workflows/integration-tests.yml | 34 ++++ .serena/.gitignore | 2 + .serena/project.yml | 152 ++++++++++++++++++ Xamarin.Neo4j/Xamarin.Neo4j.sln | 18 +++ .../Fixtures/MemgraphFixture.cs | 71 ++++++++ .../Fixtures/Neo4jFixture.cs | 64 ++++++++ .../MemgraphConnectivityTests.cs | 78 +++++++++ .../Neo4jConnectivityTests.cs | 126 +++++++++++++++ .../Xamarin.Neo4j.IntegrationTests.csproj | 19 +++ 9 files changed, 564 insertions(+) create mode 100644 .github/workflows/integration-tests.yml create mode 100644 .serena/.gitignore create mode 100644 .serena/project.yml create mode 100644 Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/MemgraphFixture.cs create mode 100644 Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/Neo4jFixture.cs create mode 100644 Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/MemgraphConnectivityTests.cs create mode 100644 Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Neo4jConnectivityTests.cs create mode 100644 Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Xamarin.Neo4j.IntegrationTests.csproj diff --git a/.github/workflows/integration-tests.yml b/.github/workflows/integration-tests.yml new file mode 100644 index 0000000..ed83206 --- /dev/null +++ b/.github/workflows/integration-tests.yml @@ -0,0 +1,34 @@ +name: Integration Tests + +on: + push: + branches: ["main"] + paths: + - "Xamarin.Neo4j/**" + - ".github/workflows/integration-tests.yml" + pull_request: + branches: ["main"] + paths: + - "Xamarin.Neo4j/**" + workflow_dispatch: + +jobs: + test: + runs-on: ubuntu-latest + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup .NET + uses: actions/setup-dotnet@v4 + with: + dotnet-version: "10.0.x" + + - name: Unit Tests + working-directory: Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.Tests + run: dotnet test --verbosity normal + + - name: Integration Tests + working-directory: Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests + run: dotnet test --verbosity normal diff --git a/.serena/.gitignore b/.serena/.gitignore new file mode 100644 index 0000000..2e510af --- /dev/null +++ b/.serena/.gitignore @@ -0,0 +1,2 @@ +/cache +/project.local.yml diff --git a/.serena/project.yml b/.serena/project.yml new file mode 100644 index 0000000..1c2fce5 --- /dev/null +++ b/.serena/project.yml @@ -0,0 +1,152 @@ +# the name by which the project can be referenced within Serena +project_name: "xamarin-neo4j" + + +# list of languages for which language servers are started; choose from: +# al bash clojure cpp csharp +# csharp_omnisharp dart elixir elm erlang +# fortran fsharp go groovy haskell +# java julia kotlin lua markdown +# matlab nix pascal perl php +# php_phpactor powershell python python_jedi r +# rego ruby ruby_solargraph rust scala +# swift terraform toml typescript typescript_vts +# vue yaml zig +# (This list may be outdated. For the current list, see values of Language enum here: +# https://github.com/oraios/serena/blob/main/src/solidlsp/ls_config.py +# For some languages, there are alternative language servers, e.g. csharp_omnisharp, ruby_solargraph.) +# Note: +# - For C, use cpp +# - For JavaScript, use typescript +# - For Free Pascal/Lazarus, use pascal +# Special requirements: +# Some languages require additional setup/installations. +# See here for details: https://oraios.github.io/serena/01-about/020_programming-languages.html#language-servers +# When using multiple languages, the first language server that supports a given file will be used for that file. +# The first language is the default language and the respective language server will be used as a fallback. +# Note that when using the JetBrains backend, language servers are not used and this list is correspondingly ignored. +languages: +- csharp + +# the encoding used by text files in the project +# For a list of possible encodings, see https://docs.python.org/3.11/library/codecs.html#standard-encodings +encoding: "utf-8" + +# line ending convention to use when writing source files. +# Possible values: unset (use global setting), "lf", "crlf", or "native" (platform default) +# This does not affect Serena's own files (e.g. memories and configuration files), which always use native line endings. +line_ending: + +# The language backend to use for this project. +# If not set, the global setting from serena_config.yml is used. +# Valid values: LSP, JetBrains +# Note: the backend is fixed at startup. If a project with a different backend +# is activated post-init, an error will be returned. +language_backend: + +# whether to use project's .gitignore files to ignore files +ignore_all_files_in_gitignore: true + +# advanced configuration option allowing to configure language server-specific options. +# Maps the language key to the options. +# Have a look at the docstring of the constructors of the LS implementations within solidlsp (e.g., for C# or PHP) to see which options are available. +# No documentation on options means no options are available. +ls_specific_settings: {} + +# list of additional paths to ignore in this project. +# Same syntax as gitignore, so you can use * and **. +# Note: global ignored_paths from serena_config.yml are also applied additively. +ignored_paths: [] + +# whether the project is in read-only mode +# If set to true, all editing tools will be disabled and attempts to use them will result in an error +# Added on 2025-04-18 +read_only: false + +# list of tool names to exclude. +# This extends the existing exclusions (e.g. from the global configuration) +# +# Below is the complete list of tools for convenience. +# To make sure you have the latest list of tools, and to view their descriptions, +# execute `uv run scripts/print_tool_overview.py`. +# +# * `activate_project`: Activates a project by name. +# * `check_onboarding_performed`: Checks whether project onboarding was already performed. +# * `create_text_file`: Creates/overwrites a file in the project directory. +# * `delete_lines`: Deletes a range of lines within a file. +# * `delete_memory`: Deletes a memory from Serena's project-specific memory store. +# * `execute_shell_command`: Executes a shell command. +# * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced. +# * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type). +# * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type). +# * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes. +# * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file. +# * `initial_instructions`: Gets the initial instructions for the current project. +# Should only be used in settings where the system prompt cannot be set, +# e.g. in clients you have no control over, like Claude Desktop. +# * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol. +# * `insert_at_line`: Inserts content at a given line in a file. +# * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol. +# * `list_dir`: Lists files and directories in the given directory (optionally with recursion). +# * `list_memories`: Lists memories in Serena's project-specific memory store. +# * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building). +# * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context). +# * `read_file`: Reads a file within the project directory. +# * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store. +# * `remove_project`: Removes a project from the Serena configuration. +# * `replace_lines`: Replaces a range of lines within a file with new content. +# * `replace_symbol_body`: Replaces the full definition of a symbol. +# * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen. +# * `search_for_pattern`: Performs a search for a pattern in the project. +# * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase. +# * `switch_modes`: Activates modes by providing a list of their names +# * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information. +# * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task. +# * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed. +# * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store. +excluded_tools: [] + +# list of tools to include that would otherwise be disabled (particularly optional tools that are disabled by default). +# This extends the existing inclusions (e.g. from the global configuration). +included_optional_tools: [] + +# fixed set of tools to use as the base tool set (if non-empty), replacing Serena's default set of tools. +# This cannot be combined with non-empty excluded_tools or included_optional_tools. +fixed_tools: [] + +# list of mode names to that are always to be included in the set of active modes +# The full set of modes to be activated is base_modes + default_modes. +# If the setting is undefined, the base_modes from the global configuration (serena_config.yml) apply. +# Otherwise, this setting overrides the global configuration. +# Set this to [] to disable base modes for this project. +# Set this to a list of mode names to always include the respective modes for this project. +base_modes: + +# list of mode names that are to be activated by default. +# The full set of modes to be activated is base_modes + default_modes. +# If the setting is undefined, the default_modes from the global configuration (serena_config.yml) apply. +# Otherwise, this overrides the setting from the global configuration (serena_config.yml). +# This setting can, in turn, be overridden by CLI parameters (--mode). +default_modes: + +# initial prompt for the project. It will always be given to the LLM upon activating the project +# (contrary to the memories, which are loaded on demand). +initial_prompt: "" + +# time budget (seconds) per tool call for the retrieval of additional symbol information +# such as docstrings or parameter information. +# This overrides the corresponding setting in the global configuration; see the documentation there. +# If null or missing, use the setting from the global configuration. +symbol_info_budget: + +# list of regex patterns which, when matched, mark a memory entry as read‑only. +# Extends the list from the global configuration, merging the two lists. +read_only_memory_patterns: [] + +# list of regex patterns for memories to completely ignore. +# Matching memories will not appear in list_memories or activate_project output +# and cannot be accessed via read_memory or write_memory. +# To access ignored memory files, use the read_file tool on the raw file path. +# Extends the list from the global configuration, merging the two lists. +# Example: ["_archive/.*", "_episodes/.*"] +ignored_memory_patterns: [] diff --git a/Xamarin.Neo4j/Xamarin.Neo4j.sln b/Xamarin.Neo4j/Xamarin.Neo4j.sln index 9b4b68b..0e6f9bc 100644 --- a/Xamarin.Neo4j/Xamarin.Neo4j.sln +++ b/Xamarin.Neo4j/Xamarin.Neo4j.sln @@ -8,6 +8,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xamarin.Neo4j.iOS", "Xamari EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xamarin.Neo4j.Tests", "Xamarin.Neo4j\Xamarin.Neo4j.Tests\Xamarin.Neo4j.Tests.csproj", "{A9874913-14B2-4BED-A838-89697258405A}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xamarin.Neo4j.IntegrationTests", "Xamarin.Neo4j\Xamarin.Neo4j.IntegrationTests\Xamarin.Neo4j.IntegrationTests.csproj", "{B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Ad-Hoc|iPhone = Ad-Hoc|iPhone @@ -100,5 +102,21 @@ Global {A9874913-14B2-4BED-A838-89697258405A}.Release|iPhone.Build.0 = Release|Any CPU {A9874913-14B2-4BED-A838-89697258405A}.Release|iPhoneSimulator.ActiveCfg = Release|Any CPU {A9874913-14B2-4BED-A838-89697258405A}.Release|iPhoneSimulator.Build.0 = Release|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Ad-Hoc|iPhone.ActiveCfg = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Ad-Hoc|iPhone.Build.0 = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.AppStore|iPhone.ActiveCfg = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.AppStore|iPhone.Build.0 = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Debug|iPhone.ActiveCfg = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Debug|iPhone.Build.0 = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Debug|iPhoneSimulator.ActiveCfg = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Debug|iPhoneSimulator.Build.0 = Debug|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Release|Any CPU.Build.0 = Release|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Release|iPhone.ActiveCfg = Release|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Release|iPhone.Build.0 = Release|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Release|iPhoneSimulator.ActiveCfg = Release|Any CPU + {B3E7D2A1-5C4F-4A8B-9D6E-1F2A3B4C5D6E}.Release|iPhoneSimulator.Build.0 = Release|Any CPU EndGlobalSection EndGlobal diff --git a/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/MemgraphFixture.cs b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/MemgraphFixture.cs new file mode 100644 index 0000000..757d138 --- /dev/null +++ b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/MemgraphFixture.cs @@ -0,0 +1,71 @@ +using System; +using System.Threading.Tasks; +using DotNet.Testcontainers.Builders; +using DotNet.Testcontainers.Containers; +using Neo4j.Driver; + +namespace Xamarin.Neo4j.IntegrationTests.Fixtures +{ + public class MemgraphFixture : IAsyncDisposable + { + private IContainer _container; + + public string BoltUri { get; private set; } + + public async Task StartAsync() + { + _container = new ContainerBuilder() + .WithImage("memgraph/memgraph:latest") + .WithPortBinding(7687, true) + .WithCommand("--bolt-server-name-for-init=Neo4j/5.0.0", "--also-log-to-stderr") + .WithWaitStrategy(Wait.ForUnixContainer() + .UntilPortIsAvailable(7687)) + .Build(); + + await _container.StartAsync(); + + var boltPort = _container.GetMappedPublicPort(7687); + BoltUri = $"bolt://localhost:{boltPort}"; + + Console.Error.WriteLine($"[MemgraphFixture] Container started, BoltUri={BoltUri}"); + + await WaitForReady(); + + Console.Error.WriteLine("[MemgraphFixture] Ready!"); + } + + private async Task WaitForReady() + { + for (var i = 0; i < 30; i++) + { + IDriver driver = null; + try + { + driver = GraphDatabase.Driver(BoltUri); + await using var session = driver.AsyncSession(); + var cursor = await session.RunAsync("RETURN 1 AS n"); + await cursor.ConsumeAsync(); + return; + } + catch (Exception ex) + { + var inner = ex.InnerException != null ? $" -> {ex.InnerException.GetType().Name}: {ex.InnerException.Message}" : ""; + Console.Error.WriteLine($"[Memgraph] Attempt {i}: {ex.GetType().Name}: {ex.Message}{inner}"); + await Task.Delay(2000); + } + finally + { + if (driver != null) await driver.DisposeAsync(); + } + } + + throw new TimeoutException("Memgraph container did not become ready in time."); + } + + public async ValueTask DisposeAsync() + { + if (_container != null) + await _container.DisposeAsync(); + } + } +} diff --git a/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/Neo4jFixture.cs b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/Neo4jFixture.cs new file mode 100644 index 0000000..86d8741 --- /dev/null +++ b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Fixtures/Neo4jFixture.cs @@ -0,0 +1,64 @@ +using System; +using System.Threading.Tasks; +using DotNet.Testcontainers.Builders; +using DotNet.Testcontainers.Containers; +using Neo4j.Driver; + +namespace Xamarin.Neo4j.IntegrationTests.Fixtures +{ + public class Neo4jFixture : IAsyncDisposable + { + private IContainer _container; + + public string BoltUri { get; private set; } + public string Username => "neo4j"; + public string Password => "testpassword"; + + public async Task StartAsync() + { + _container = new ContainerBuilder() + .WithImage("neo4j:latest") + .WithPortBinding(7474, true) + .WithPortBinding(7687, true) + .WithEnvironment("NEO4J_AUTH", $"{Username}/{Password}") + .WithWaitStrategy(Wait.ForUnixContainer() + .UntilPortIsAvailable(7687)) + .Build(); + + await _container.StartAsync(); + + var boltPort = _container.GetMappedPublicPort(7687); + BoltUri = $"bolt://localhost:{boltPort}"; + + await WaitForReady(); + } + + private async Task WaitForReady() + { + var driver = GraphDatabase.Driver(BoltUri, AuthTokens.Basic(Username, Password)); + + for (var i = 0; i < 30; i++) + { + try + { + await driver.VerifyConnectivityAsync(); + await driver.DisposeAsync(); + return; + } + catch + { + await Task.Delay(1000); + } + } + + await driver.DisposeAsync(); + throw new TimeoutException("Neo4j container did not become ready in time."); + } + + public async ValueTask DisposeAsync() + { + if (_container != null) + await _container.DisposeAsync(); + } + } +} diff --git a/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/MemgraphConnectivityTests.cs b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/MemgraphConnectivityTests.cs new file mode 100644 index 0000000..bfaac3e --- /dev/null +++ b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/MemgraphConnectivityTests.cs @@ -0,0 +1,78 @@ +using System.Threading.Tasks; +using Neo4j.Driver; +using NUnit.Framework; +using Xamarin.Neo4j.IntegrationTests.Fixtures; + +namespace Xamarin.Neo4j.IntegrationTests +{ + [TestFixture] + public class MemgraphConnectivityTests + { + private static MemgraphFixture _fixture; + private IDriver _driver; + + [OneTimeSetUp] + public async Task OneTimeSetUp() + { + _fixture = new MemgraphFixture(); + await _fixture.StartAsync(); + } + + [OneTimeTearDown] + public async Task OneTimeTearDown() + { + if (_fixture != null) + await _fixture.DisposeAsync(); + } + + [SetUp] + public void SetUp() + { + _driver = GraphDatabase.Driver(_fixture.BoltUri); + } + + [TearDown] + public async Task TearDown() + { + if (_driver != null) + await _driver.DisposeAsync(); + } + + [Test] + public async Task CanEstablishConnection() + { + await using var session = _driver.AsyncSession(); + var result = await session.RunAsync("RETURN 1 AS n"); + var record = await result.SingleAsync(); + Assert.AreEqual(1L, record["n"].As()); + } + + [Test] + public async Task CanExecuteCypherQuery() + { + await using var session = _driver.AsyncSession(); + + var result = await session.RunAsync("CREATE (n:Test {name: 'hello'}) RETURN n.name AS name"); + var record = await result.SingleAsync(); + + Assert.AreEqual("hello", record["name"].As()); + } + + [Test] + public async Task CanQueryNodesAndRelationships() + { + await using var session = _driver.AsyncSession(); + + await session.RunAsync( + "CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})"); + + var cursor = await session.RunAsync( + "MATCH (a:Person)-[r:KNOWS]->(b:Person) RETURN a.name AS from, b.name AS to, type(r) AS rel"); + var record = await cursor.SingleAsync(); + + Assert.AreEqual("Alice", record["from"].As()); + Assert.AreEqual("Bob", record["to"].As()); + Assert.AreEqual("KNOWS", record["rel"].As()); + } + } +} diff --git a/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Neo4jConnectivityTests.cs b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Neo4jConnectivityTests.cs new file mode 100644 index 0000000..e3042a1 --- /dev/null +++ b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Neo4jConnectivityTests.cs @@ -0,0 +1,126 @@ +using System.Threading.Tasks; +using Neo4j.Driver; +using NUnit.Framework; +using Xamarin.Neo4j.IntegrationTests.Fixtures; + +namespace Xamarin.Neo4j.IntegrationTests +{ + [TestFixture] + public class Neo4jConnectivityTests + { + private static Neo4jFixture _fixture; + private IDriver _driver; + + [OneTimeSetUp] + public async Task OneTimeSetUp() + { + _fixture = new Neo4jFixture(); + await _fixture.StartAsync(); + } + + [OneTimeTearDown] + public async Task OneTimeTearDown() + { + if (_fixture != null) + await _fixture.DisposeAsync(); + } + + [SetUp] + public void SetUp() + { + _driver = GraphDatabase.Driver( + _fixture.BoltUri, + AuthTokens.Basic(_fixture.Username, _fixture.Password)); + } + + [TearDown] + public async Task TearDown() + { + if (_driver != null) + await _driver.DisposeAsync(); + } + + [Test] + public async Task CanEstablishConnection() + { + await _driver.VerifyConnectivityAsync(); + } + + [Test] + public async Task CanExecuteCypherQuery() + { + await using var session = _driver.AsyncSession(); + + var result = await session.RunAsync("CREATE (n:Test {name: 'hello'}) RETURN n.name AS name"); + var record = await result.SingleAsync(); + + Assert.AreEqual("hello", record["name"].As()); + } + + [Test] + public async Task CanQueryNodesAndRelationships() + { + await using var session = _driver.AsyncSession(); + + await session.RunAsync( + "CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})"); + + var cursor = await session.RunAsync( + "MATCH (a:Person)-[r:KNOWS]->(b:Person) RETURN a.name AS from, b.name AS to, type(r) AS rel"); + var record = await cursor.SingleAsync(); + + Assert.AreEqual("Alice", record["from"].As()); + Assert.AreEqual("Bob", record["to"].As()); + Assert.AreEqual("KNOWS", record["rel"].As()); + } + + [Test] + public async Task CanExpandNode() + { + await using var session = _driver.AsyncSession(); + + var setupResult = await session.RunAsync( + "CREATE (c:Hub {name: 'Center'})" + + "CREATE (c)-[:LINK]->(a:Leaf {name: 'A'})" + + "CREATE (c)-[:LINK]->(b:Leaf {name: 'B'})" + + "CREATE (c)-[:LINK]->(d:Leaf {name: 'C'})" + + "RETURN id(c) AS centerId"); + var setupRecord = await setupResult.SingleAsync(); + var centerId = setupRecord["centerId"].As(); + + var cursor = await session.RunAsync( + "MATCH (n)-[r]-(m) WHERE id(n) = $nodeId RETURN n, r, m", + new { nodeId = centerId }); + + var records = await cursor.ToListAsync(); + + Assert.AreEqual(3, records.Count); + + foreach (var record in records) + { + Assert.IsInstanceOf(record["n"]); + Assert.IsInstanceOf(record["r"]); + Assert.IsInstanceOf(record["m"]); + } + } + + [Test] + public void CanParseConnectionString() + { + var connectionString = new Models.Neo4jConnectionString + { + Scheme = "bolt://", + Host = "localhost:7687", + Username = _fixture.Username, + Password = _fixture.Password, + Database = "neo4j" + }; + + var result = connectionString.ParseHost(); + + Assert.AreEqual("bolt://localhost:7687", result.Item1); + Assert.IsFalse(result.Item2); + Assert.IsFalse(result.Item3); + } + } +} diff --git a/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Xamarin.Neo4j.IntegrationTests.csproj b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Xamarin.Neo4j.IntegrationTests.csproj new file mode 100644 index 0000000..a81cf3c --- /dev/null +++ b/Xamarin.Neo4j/Xamarin.Neo4j/Xamarin.Neo4j.IntegrationTests/Xamarin.Neo4j.IntegrationTests.csproj @@ -0,0 +1,19 @@ + + + + net10.0 + + + + + + + + + + + + + + +