public async Task ShouldPropagateInvalidBookmarkException()
            {
                var error        = new InvalidBookmarkException("Invalid bookmark");
                var uri          = new Uri("neo4j://123:456");
                var routingTable = new RoutingTable(null, new List <Uri> {
                    uri
                });
                var poolManagerMock = new Mock <IClusterConnectionPoolManager>();

                poolManagerMock.Setup(x => x.CreateClusterConnectionAsync(uri))
                .ReturnsAsync(new Mock <IConnection>().Object);

                var discovery = new Mock <IDiscovery>();

                discovery.Setup(x => x.DiscoverAsync(It.IsAny <IConnection>(), "", null, Bookmark.From("Invalid bookmark"))).Throws(error);

                var logger = new Mock <ILogger>();

                logger.Setup(x => x.Error(It.IsAny <Exception>(), It.IsAny <string>(), It.IsAny <object[]>()));

                var manager = NewRoutingTableManager(routingTable, poolManagerMock.Object, discovery.Object,
                                                     logger: logger.Object);

                var exc = await Record.ExceptionAsync(() =>
                                                      manager.UpdateRoutingTableAsync(routingTable, AccessMode.Read, "", null, Bookmark.From("Invalid bookmark")));

                exc.Should().Be(error);
                logger.Verify(x => x.Error(error, It.IsAny <string>(), It.IsAny <object[]>()));
            }
Ejemplo n.º 2
0
        public static Neo4jException ParseServerException(string code, string message)
        {
            Neo4jException error;
            var            parts          = code.Split('.');
            var            classification = parts[1].ToLowerInvariant();

            switch (classification)
            {
            case "clienterror":
                if (AuthenticationException.IsAuthenticationError(code))
                {
                    error = new AuthenticationException(message);
                }
                else if (AuthorizationException.IsAuthorizationError(code))
                {
                    error = new AuthorizationException(message);
                }
                else if (ProtocolException.IsProtocolError(code))
                {
                    error = new ProtocolException(code, message);
                }
                else if (FatalDiscoveryException.IsFatalDiscoveryError(code))
                {
                    error = new FatalDiscoveryException(message);
                }
                else if (TokenExpiredException.IsTokenExpiredError(code))
                {
                    error = new TokenExpiredException(message);
                }
                else if (InvalidBookmarkException.IsInvalidBookmarkException(code))
                {
                    error = new InvalidBookmarkException(message);
                }
                else
                {
                    error = new ClientException(code, message);
                }

                break;

            case "transienterror":
                error = new TransientException(code, message);
                break;

            default:
                error = new DatabaseException(code, message);
                break;
            }

            return(error);
        }