Update bookmark manager API (#659)

* Update bookmark manager API
* Move all bookmark manager references to experimental namespace.

Author: thelonelyvulpes

Neo4j.Driver/Neo4j.Driver.Tests.TestBackend/Protocol/BookmarkManager/BookmarkManagerClose.cs

@@ -1,6 +1,4 @@
-using System.Threading.Tasks;
-
-namespace Neo4j.Driver.Tests.TestBackend
+namespace Neo4j.Driver.Tests.TestBackend
 {
     internal class BookmarkManagerClose : IProtocolObject
     {
@@ -11,12 +9,6 @@ public class BookmarkManagerCloseDto
             public string id { get; set; }
         }
 
-        public override Task Process()
-        {
-            var bookmarkManager = ObjManager.GetObject<NewBookmarkManager>(data.id).BookmarkManager;
-            return bookmarkManager.ForgetAsync();
-        }
-
         public override string Respond()
         {
             return new ProtocolResponse("BookmarkManager", new {data.id}).Encode();

Neo4j.Driver/Neo4j.Driver.Tests.TestBackend/Protocol/BookmarkManager/NewBookmarkManager.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Neo4j.Driver.Experimental;
 using Newtonsoft.Json;
 
 namespace Neo4j.Driver.Tests.TestBackend
@@ -15,38 +16,38 @@ internal class NewBookmarkManager : IProtocolObject
 
         public class NewBookmarkManagerDto
         {
-            public Dictionary<string, string[]> initialBookmarks { get; set; }
+            public string[] initialBookmarks { get; set; }
             public bool bookmarksSupplierRegistered { get; set; }
             public bool bookmarksConsumerRegistered { get; set; }
         }
 
         public override Task Process(Controller controller)
         {
             var initialBookmarks =
-                data.initialBookmarks?.ToDictionary(x => x.Key, x => x.Value as IEnumerable<string>)
-                ?? new Dictionary<string, IEnumerable<string>>();
+                data.initialBookmarks
+                ?? Array.Empty<string>();
 
-            async Task<string[]> BookmarkSupplier(string database, CancellationToken _)
+            async Task<string[]> BookmarkSupplier(CancellationToken _)
             {
                 if (!data.bookmarksSupplierRegistered)
                     return Array.Empty<string>();
 
                 var request = new BookmarkManagerSupplierRequest(ObjManager);
 
-                await controller.SendResponse(GetSupplyRequest(database, request));
+                await controller.SendResponse(GetSupplyRequest(request));
                 var result = await controller.TryConsumeStreamObjectOfType<BookmarksSupplierCompleted>();
 
                 return result.data.bookmarks;
             }
 
-            async Task NotifyBookmarks(string database, string[] bookmarks, CancellationToken _)
+            async Task NotifyBookmarks(string[] bookmarks, CancellationToken _)
             {
                 if (!data.bookmarksConsumerRegistered)
                     return;
 
                 var request = new BookmarkManagerConsumerRequest(ObjManager);
 
-                await controller.SendResponse(GetConsumeRequest(database, bookmarks, request));
+                await controller.SendResponse(GetConsumeRequest(bookmarks, request));
                 await controller.TryConsumeStreamObjectOfType<BookmarksConsumerCompleted>();
             }
 
@@ -57,16 +58,16 @@ async Task NotifyBookmarks(string database, string[] bookmarks, CancellationToke
             return Task.CompletedTask;
         }
 
-        private string GetConsumeRequest(string database, string[] bookmarks, BookmarkManagerConsumerRequest request)
+        private string GetConsumeRequest(string[] bookmarks, BookmarkManagerConsumerRequest request)
         {
             return new ProtocolResponse("BookmarksConsumerRequest",
-                new {database, bookmarks, bookmarkManagerId = uniqueId, id = request.uniqueId}).Encode();
+                new {bookmarks, bookmarkManagerId = uniqueId, id = request.uniqueId}).Encode();
         }
 
-        private string GetSupplyRequest(string database, BookmarkManagerSupplierRequest request)
+        private string GetSupplyRequest(BookmarkManagerSupplierRequest request)
         {
             return new ProtocolResponse("BookmarksSupplierRequest",
-                new {database, bookmarkManagerId = uniqueId, id = request.uniqueId}).Encode();
+                new {bookmarkManagerId = uniqueId, id = request.uniqueId}).Encode();
         }
 
         public override string Respond()

Neo4j.Driver/Neo4j.Driver.Tests/AsyncSessionTests.cs

@@ -23,6 +23,7 @@
 using System.Threading.Tasks;
 using FluentAssertions;
 using Moq;
+using Neo4j.Driver.Experimental;
 using Neo4j.Driver.Internal;
 using Neo4j.Driver.Internal.Connector;
 using Neo4j.Driver.Internal.Messaging;
@@ -419,13 +420,13 @@ public void ShouldSyncBookmarksOnUpdateBookmarks()
                 using (var session = new AsyncSession(null, null, null, 0, cfg, false))
                 {
                     session.UpdateBookmarks(new InternalBookmarks("a"));
-                    bookmarkManager.Verify(x => x.UpdateBookmarksAsync("test", Array.Empty<string>(), new[] { "a" }, It.IsAny<CancellationToken>()), Times.Once);
+                    bookmarkManager.Verify(x => x.UpdateBookmarksAsync(Array.Empty<string>(), new[] { "a" }, It.IsAny<CancellationToken>()), Times.Once);
                     session.UpdateBookmarks(new InternalBookmarks("b"));
-                    bookmarkManager.Verify(x => x.UpdateBookmarksAsync("test", new[] { "a" }, new[] { "b" }, It.IsAny<CancellationToken>()), Times.Once);
+                    bookmarkManager.Verify(x => x.UpdateBookmarksAsync(new[] { "a" }, new[] { "b" }, It.IsAny<CancellationToken>()), Times.Once);
                 }   
 
-                bookmarkManager.Verify(x => x.UpdateBookmarksAsync("test", It.IsAny<string[]>(), It.IsAny<string[]>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
-                bookmarkManager.Verify(x => x.UpdateBookmarksAsync("test", new[] { "a" }, new[] { "b" }, It.IsAny<CancellationToken>()), Times.Once);
+                bookmarkManager.Verify(x => x.UpdateBookmarksAsync(It.IsAny<string[]>(), It.IsAny<string[]>(), It.IsAny<CancellationToken>()), Times.Exactly(2));
+                bookmarkManager.Verify(x => x.UpdateBookmarksAsync( new[] { "a" }, new[] { "b" }, It.IsAny<CancellationToken>()), Times.Once);
             }
         }
     }

Neo4j.Driver/Neo4j.Driver.Tests/Internal/BookmarkManager/BookmarkManagerFactoryTests.cs

@@ -20,6 +20,7 @@
 using System.Threading.Tasks;
 using Xunit;
 using FluentAssertions;
+using Neo4j.Driver.Experimental;
 
 namespace Neo4j.Driver.Internal.BookmarkManager;
 
@@ -31,9 +32,9 @@ public void ShouldReturnNewBookmarkManager()
         var factory = new BookmarkManagerFactory();
 
         var config = new BookmarkManagerConfig(
-            new Dictionary<string, IEnumerable<string>>(),
-            (_, _) => Task.FromResult(Array.Empty<string>()),
-            (_, _, _) => Task.CompletedTask);
+            Array.Empty<string>(),
+            (_) => Task.FromResult(Array.Empty<string>()),
+            (_, _) => Task.CompletedTask);
 
         var bookmarkManager = factory.NewBookmarkManager(config);