diff --git a/boltstub/parsing.py b/boltstub/parsing.py index e9c6bb22d..ccb0fe8bf 100644 --- a/boltstub/parsing.py +++ b/boltstub/parsing.py @@ -1050,7 +1050,6 @@ def can_be_skipped(self, channel): class ConditionalBlock(Block): - def __init__(self, conditions: List[str], blocks: List[Block], line_number: int): super().__init__(line_number) @@ -1120,7 +1119,7 @@ def can_consume_after_reset(self, channel) -> bool: block = self._probe_selection(channel, None) if not block: return False - return block.can_consume(channel) + return block.can_consume_after_reset(channel) pass def has_deterministic_end(self): diff --git a/tests/stub/routing/scripts/v3/router_adb_then_bdb.script b/tests/stub/routing/scripts/v3/router_adb_then_bdb.script new file mode 100644 index 000000000..4514bfb36 --- /dev/null +++ b/tests/stub/routing/scripts/v3/router_adb_then_bdb.script @@ -0,0 +1,21 @@ +!: BOLT #VERSION# +!: AUTO RESET +!: ALLOW RESTART +!: PY request = 0 + +C: HELLO {"scheme": "basic", "credentials": "c", "principal": "p", "user_agent": "007"#EXTR_HELLO_ROUTING_PROPS#} +S: SUCCESS {"server": "#SERVER_AGENT#", "connection_id": "bolt-123456789"} +*: RESET +{* + IF: request < 2 + {{ + C: RUN "CALL dbms.cluster.routing.getRoutingTable($context)" {"context": #ROUTINGCTX#} {"[mode]": "r"} + S: SUCCESS {"fields": ["ttl", "servers"]} + C: PULL_ALL + S: RECORD [1000, [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]] + SUCCESS {"type": "r"} + PY: request += 1 + *: RESET + }} +*} +?: GOODBYE diff --git a/tests/stub/routing/scripts/v3/writer_tx_yielding_failure_on_2nd_run.script b/tests/stub/routing/scripts/v3/writer_tx_yielding_failure_on_2nd_run.script new file mode 100644 index 000000000..d91373af7 --- /dev/null +++ b/tests/stub/routing/scripts/v3/writer_tx_yielding_failure_on_2nd_run.script @@ -0,0 +1,26 @@ +!: BOLT #VERSION# + +A: HELLO {"{}": "*"} +*: RESET + +C: RUN "RETURN 1 AS n" {} {} +S: SUCCESS {"fields": ["n"]} +C: PULL_ALL +S: RECORD [1] + SUCCESS {"type": "r"} + +*: RESET + +C: BEGIN {} +S: SUCCESS {} +C: RUN "RETURN 1 AS n" {} {} +S: FAILURE #FAILURE# +{? + C: PULL_ALL + S: IGNORED +?} +C: RESET +S: SUCCESS {} + +*: RESET +?: GOODBYE diff --git a/tests/stub/routing/scripts/v3/writer_yielding_failure_on_2nd_run.script b/tests/stub/routing/scripts/v3/writer_yielding_failure_on_2nd_run.script new file mode 100644 index 000000000..dd473748f --- /dev/null +++ b/tests/stub/routing/scripts/v3/writer_yielding_failure_on_2nd_run.script @@ -0,0 +1,24 @@ +!: BOLT #VERSION# + +A: HELLO {"{}": "*"} +*: RESET + +C: RUN "RETURN 1 AS n" {} {} +S: SUCCESS {"fields": ["n"]} +C: PULL_ALL +S: RECORD [1] + SUCCESS {"type": "r"} + +*: RESET + +C: RUN "RETURN 1 AS n" {} {} +S: FAILURE #FAILURE# +{? + C: PULL_ALL + S: IGNORED +?} +C: RESET +S: SUCCESS {} + +*: RESET +?: GOODBYE diff --git a/tests/stub/routing/scripts/v3/writer_yielding_failure_on_run.script b/tests/stub/routing/scripts/v3/writer_yielding_failure_on_run.script deleted file mode 100644 index d336d3feb..000000000 --- a/tests/stub/routing/scripts/v3/writer_yielding_failure_on_run.script +++ /dev/null @@ -1,14 +0,0 @@ -!: BOLT #VERSION# - -A: HELLO {"{}": "*"} -*: RESET -C: RUN "RETURN 1 as n" {} {} -S: FAILURE #FAILURE# -{? - C: PULL_ALL - S: IGNORED -?} -C: RESET -S: SUCCESS {} -*: RESET -?: GOODBYE diff --git a/tests/stub/routing/scripts/v4x1/router_adb_then_bdb.script b/tests/stub/routing/scripts/v4x1/router_adb_then_bdb.script new file mode 100644 index 000000000..9d67622b9 --- /dev/null +++ b/tests/stub/routing/scripts/v4x1/router_adb_then_bdb.script @@ -0,0 +1,38 @@ +!: BOLT #VERSION# +!: AUTO RESET +!: ALLOW RESTART +!: PY request = 0 + +C: HELLO {"scheme": "basic", "credentials": "c", "principal": "p", "user_agent": "007", "routing": #ROUTINGCTX#} +S: SUCCESS {"server": "#SERVER_AGENT#", "connection_id": "bolt-123456789"} +*: RESET +IF: request == 0 +{{ + C: RUN "CALL dbms.routing.getRoutingTable($context, $database)" {"context": #ROUTINGCTX#, "database": "adb"} {"[mode]": "r", "db": "system", "[bookmarks]": "*"} + S: SUCCESS {"fields": ["ttl", "servers"]} + C: PULL {"n": -1} + S: RECORD [1000, [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]] + SUCCESS {"type": "r"} + PY: request = 1 + *: RESET + {? + C: RUN "CALL dbms.routing.getRoutingTable($context, $database)" {"context": #ROUTINGCTX#, "database": "bdb"} {"[mode]": "r", "db": "system", "[bookmarks]": "*"} + S: SUCCESS {"fields": ["ttl", "servers"]} + C: PULL {"n": -1} + S: RECORD [1000, [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]] + SUCCESS {"type": "r"} + PY: request = 2 + *: RESET + ?} +}} +ELIF: request == 1 +{{ + C: RUN "CALL dbms.routing.getRoutingTable($context, $database)" {"context": #ROUTINGCTX#, "database": "bdb"} {"[mode]": "r", "db": "system", "[bookmarks]": "*"} + S: SUCCESS {"fields": ["ttl", "servers"]} + C: PULL {"n": -1} + S: RECORD [1000, [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]] + SUCCESS {"type": "r"} + PY: request = 2 + *: RESET +}} +?: GOODBYE diff --git a/tests/stub/routing/scripts/v4x3/router_adb_then_bdb.script b/tests/stub/routing/scripts/v4x3/router_adb_then_bdb.script new file mode 100644 index 000000000..35a8285ae --- /dev/null +++ b/tests/stub/routing/scripts/v4x3/router_adb_then_bdb.script @@ -0,0 +1,29 @@ +!: BOLT #VERSION# +!: AUTO RESET +!: ALLOW RESTART +!: PY request = 0 + +C: HELLO {"scheme": "basic", "credentials": "c", "principal": "p", "user_agent": "007", "routing": #ROUTINGCTX# , "[patch_bolt]": "*"} +S: SUCCESS {"server": "#SERVER_AGENT#", "connection_id": "bolt-123456789"} +*: RESET +IF: request == 0 +{{ + C: ROUTE #ROUTINGCTX# "*" "adb" + S: SUCCESS { "rt": { "ttl": 1000, "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 1 + *: RESET + {? + C: ROUTE #ROUTINGCTX# "*" "bdb" + S: SUCCESS { "rt": { "ttl": 1000, "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 2 + *: RESET + ?} +}} +ELIF: request == 1 +{{ + C: ROUTE #ROUTINGCTX# "*" "bdb" + S: SUCCESS { "rt": { "ttl": 1000, "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 2 + *: RESET +}} +?: GOODBYE diff --git a/tests/stub/routing/scripts/v4x4/router_adb_then_bdb.script b/tests/stub/routing/scripts/v4x4/router_adb_then_bdb.script new file mode 100644 index 000000000..ea26c4799 --- /dev/null +++ b/tests/stub/routing/scripts/v4x4/router_adb_then_bdb.script @@ -0,0 +1,29 @@ +!: BOLT #VERSION# +!: AUTO RESET +!: ALLOW RESTART +!: PY request = 0 + +C: HELLO {"scheme": "basic", "credentials": "c", "principal": "p", "user_agent": "007", "routing": #ROUTINGCTX#, "[patch_bolt]": "*"} +S: SUCCESS {"server": "#SERVER_AGENT#", "connection_id": "bolt-123456789"} +*: RESET +IF: request == 0 +{{ + C: ROUTE #ROUTINGCTX# "*" {"db": "adb"} + S: SUCCESS { "rt": { "ttl": 1000, "db": "adb", "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 1 + *: RESET + {? + C: ROUTE #ROUTINGCTX# "*" {"db": "bdb"} + S: SUCCESS { "rt": { "ttl": 1000, "db": "bdb", "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 2 + *: RESET + ?} +}} +ELIF: request == 1 +{{ + C: ROUTE #ROUTINGCTX# "*" {"db": "bdb"} + S: SUCCESS { "rt": { "ttl": 1000, "db": "bdb", "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 2 + *: RESET +}} +?: GOODBYE diff --git a/tests/stub/routing/scripts/v5x0/router_adb_then_bdb.script b/tests/stub/routing/scripts/v5x0/router_adb_then_bdb.script new file mode 100644 index 000000000..fcc3964d3 --- /dev/null +++ b/tests/stub/routing/scripts/v5x0/router_adb_then_bdb.script @@ -0,0 +1,29 @@ +!: BOLT #VERSION# +!: AUTO RESET +!: ALLOW RESTART +!: PY request = 0 + +C: HELLO {"scheme": "basic", "credentials": "c", "principal": "p", "user_agent": "007", "routing": #ROUTINGCTX#} +S: SUCCESS {"server": "#SERVER_AGENT#", "connection_id": "bolt-123456789"} +*: RESET +IF: request == 0 +{{ + C: ROUTE #ROUTINGCTX# "*" {"db": "adb"} + S: SUCCESS { "rt": { "ttl": 1000, "db": "adb", "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 1 + *: RESET + {? + C: ROUTE #ROUTINGCTX# "*" {"db": "bdb"} + S: SUCCESS { "rt": { "ttl": 1000, "db": "bdb", "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 2 + *: RESET + ?} +}} +ELIF: request == 1 +{{ + C: ROUTE #ROUTINGCTX# "*" {"db": "bdb"} + S: SUCCESS { "rt": { "ttl": 1000, "db": "bdb", "servers": [{"addresses": ["#HOST#:9000"], "role":"ROUTE"}, {"addresses": ["#HOST#:9010", "#HOST#:9011"], "role":"READ"}, {"addresses": ["#HOST#:9020", "#HOST#:9021"], "role":"WRITE"}]}} + PY: request = 2 + *: RESET +}} +?: GOODBYE diff --git a/tests/stub/routing/scripts/v5x0/writer_tx_yielding_failure_on_2nd_run.script b/tests/stub/routing/scripts/v5x0/writer_tx_yielding_failure_on_2nd_run.script new file mode 100644 index 000000000..713140bd5 --- /dev/null +++ b/tests/stub/routing/scripts/v5x0/writer_tx_yielding_failure_on_2nd_run.script @@ -0,0 +1,26 @@ +!: BOLT #VERSION# + +A: HELLO {"{}": "*"} +*: RESET + +C: RUN "RETURN 1 AS n" {} {"db": "adb"} +S: SUCCESS {"fields": ["n"]} +C: PULL {"n": 1000} +S: RECORD [1] + SUCCESS {"type": "r"} + +*: RESET + +C: BEGIN {"db": "bdb"} +S: SUCCESS {} +C: RUN "RETURN 1 AS n" {} {} +S: FAILURE #FAILURE# +{? + C: PULL {"n": 1000} + S: IGNORED +?} +C: RESET +S: SUCCESS {} + +*: RESET +?: GOODBYE diff --git a/tests/stub/routing/scripts/v5x0/writer_yielding_failure_on_2nd_run.script b/tests/stub/routing/scripts/v5x0/writer_yielding_failure_on_2nd_run.script new file mode 100644 index 000000000..0847b7b1f --- /dev/null +++ b/tests/stub/routing/scripts/v5x0/writer_yielding_failure_on_2nd_run.script @@ -0,0 +1,23 @@ +!: BOLT #VERSION# + +A: HELLO {"{}": "*"} +*: RESET + +C: RUN "RETURN 1 AS n" {} {"db": "adb"} +S: SUCCESS {"fields": ["n"]} +C: PULL {"n": 1000} +S: RECORD [1] + SUCCESS {"type": "r"} + +*: RESET + +C: RUN "RETURN 1 AS n" {} {"db": "bdb"} +S: FAILURE #FAILURE# +{? + # Drivers might pipeline RUN and PULL + C: PULL {"n": 1000} + S: IGNORED +?} + +*: RESET +?: GOODBYE diff --git a/tests/stub/routing/scripts/v5x0/writer_yielding_failure_on_run.script b/tests/stub/routing/scripts/v5x0/writer_yielding_failure_on_run.script deleted file mode 100644 index e3cecd3f2..000000000 --- a/tests/stub/routing/scripts/v5x0/writer_yielding_failure_on_run.script +++ /dev/null @@ -1,13 +0,0 @@ -!: BOLT #VERSION# - -A: HELLO {"{}": "*"} -*: RESET -C: RUN "RETURN 1 as n" {} {"db": "adb"} -S: FAILURE #FAILURE# -{? - # Drivers might pipeline RUN and PULL - C: PULL {"n": 1000} - S: IGNORED -?} -*: RESET -?: GOODBYE diff --git a/tests/stub/routing/test_routing_v3.py b/tests/stub/routing/test_routing_v3.py index fe6244705..06209c17d 100644 --- a/tests/stub/routing/test_routing_v3.py +++ b/tests/stub/routing/test_routing_v3.py @@ -35,6 +35,7 @@ def get_vars(self, host=None): return v adb = None + bdb = None def route_call_count(self, server): return server.count_requests( diff --git a/tests/stub/routing/test_routing_v5x0.py b/tests/stub/routing/test_routing_v5x0.py index d2260961f..3faca1a05 100644 --- a/tests/stub/routing/test_routing_v5x0.py +++ b/tests/stub/routing/test_routing_v5x0.py @@ -18,6 +18,7 @@ class RoutingV5x0(RoutingBase): bolt_version = "5.0" server_agent = "Neo4j/5.0.0" adb = "adb" + bdb = "bdb" def route_call_count(self, server): return server.count_requests("ROUTE") @@ -847,21 +848,24 @@ def test_should_fail_when_writing_on_writer_that_returns_not_a_leader_code( ): driver = Driver(self._backend, self._uri_with_context, self._auth, self._userAgent) - self.start_server(self._routingServer1, "router_adb.script") + self.start_server(self._routingServer1, "router_adb_then_bdb.script") self.start_server( self._writeServer1, - "writer_yielding_failure_on_run.script", + "writer_yielding_failure_on_2nd_run.script", vars_={ **self.get_vars(), "#FAILURE#": '{"code": "Neo.ClientError.Cluster.NotALeader", ' '"message": "blabla"}' } ) - session = driver.session("w", database=self.adb) + list(session.run("RETURN 1 AS n")) + session.close() + + session = driver.session("w", database=self.bdb) failed = False try: - session.run("RETURN 1 as n").consume() + session.run("RETURN 1 AS n").consume() except types.DriverError as e: driver_name = get_driver_name() if driver_name in ["java"]: @@ -893,7 +897,11 @@ def test_should_fail_when_writing_on_writer_that_returns_not_a_leader_code( session.close() self.assertNotIn(self._writeServer1.address, - driver.get_routing_table(self.adb).writers) + driver.get_routing_table(self.bdb).writers) + if self.adb != self.bdb: + # should not invalidate writer for other databases + self.assertIn(self._writeServer1.address, + driver.get_routing_table(self.adb).writers) driver.close() @@ -907,10 +915,10 @@ def test_should_fail_when_writing_on_writer_that_returns_forbidden_on_read_only_ ): driver = Driver(self._backend, self._uri_with_context, self._auth, self._userAgent) - self.start_server(self._routingServer1, "router_adb.script") + self.start_server(self._routingServer1, "router_adb_then_bdb.script") self.start_server( self._writeServer1, - "writer_yielding_failure_on_run.script", + "writer_yielding_failure_on_2nd_run.script", vars_={ **self.get_vars(), "#FAILURE#": @@ -919,11 +927,14 @@ def test_should_fail_when_writing_on_writer_that_returns_forbidden_on_read_only_ '"message": "Unable to write"}' } ) - session = driver.session("w", database=self.adb) + list(session.run("RETURN 1 AS n")) + session.close() + + session = driver.session("w", database=self.bdb) failed = False try: - session.run("RETURN 1 as n").consume() + session.run("RETURN 1 AS n").consume() except types.DriverError as e: self.assertEqual( "Neo.ClientError.General.ForbiddenOnReadOnlyDatabase", @@ -941,7 +952,11 @@ def test_should_fail_when_writing_on_writer_that_returns_forbidden_on_read_only_ session.close() self.assertNotIn(self._writeServer1.address, - driver.get_routing_table(self.adb).writers) + driver.get_routing_table(self.bdb).writers) + if self.adb != self.bdb: + # should not invalidate writer for other databases + self.assertIn(self._writeServer1.address, + driver.get_routing_table(self.adb).writers) driver.close() @@ -955,10 +970,10 @@ def test_should_fail_when_writing_on_writer_that_returns_database_unavailable( ): driver = Driver(self._backend, self._uri_with_context, self._auth, self._userAgent) - self.start_server(self._routingServer1, "router_adb.script") + self.start_server(self._routingServer1, "router_adb_then_bdb.script") self.start_server( self._writeServer1, - "writer_yielding_failure_on_run.script", + "writer_yielding_failure_on_2nd_run.script", vars_={ **self.get_vars(), "#FAILURE#": @@ -967,11 +982,14 @@ def test_should_fail_when_writing_on_writer_that_returns_database_unavailable( '"message": "Database is busy doing store copy"}' } ) - session = driver.session("w", database=self.adb) + list(session.run("RETURN 1 AS n")) + session.close() + + session = driver.session("w", database=self.bdb) failed = False try: - session.run("RETURN 1 as n").consume() + session.run("RETURN 1 AS n").consume() except types.DriverError as e: self.assertEqual( "Neo.ClientError.General.DatabaseUnavailable", @@ -988,6 +1006,9 @@ def test_should_fail_when_writing_on_writer_that_returns_database_unavailable( failed = True session.close() + self.assertIn(self._writeServer1.address, + driver.get_routing_table(self.bdb).writers) + # should not invalidate writer for other databases either self.assertIn(self._writeServer1.address, driver.get_routing_table(self.adb).writers) @@ -1003,23 +1024,26 @@ def test_should_fail_when_writing_without_explicit_consumption_on_writer_that_re ): driver = Driver(self._backend, self._uri_with_context, self._auth, self._userAgent) - self.start_server(self._routingServer1, "router_adb.script") + self.start_server(self._routingServer1, "router_adb_then_bdb.script") self.start_server( self._writeServer1, - "writer_yielding_failure_on_run.script", + "writer_yielding_failure_on_2nd_run.script", vars_={ **self.get_vars(), "#FAILURE#": '{"code": "Neo.ClientError.Cluster.NotALeader",' ' "message": "blabla"}' } ) - session = driver.session("w", database=self.adb) + list(session.run("RETURN 1 AS n")) + session.close() + + session = driver.session("w", database=self.bdb) failed = False try: # drivers doing eager loading will fail here - result = session.run("RETURN 1 as n") + result = session.run("RETURN 1 AS n") # drivers doing lazy loading should fail here result.next() except types.DriverError: @@ -1055,7 +1079,11 @@ def test_should_fail_when_writing_without_explicit_consumption_on_writer_that_re failed = True self.assertNotIn(self._writeServer1.address, - driver.get_routing_table(self.adb).writers) + driver.get_routing_table(self.bdb).writers) + if self.adb != self.bdb: + # should not invalidate writer for other databases + self.assertIn(self._writeServer1.address, + driver.get_routing_table(self.adb).writers) driver.close() @@ -1069,22 +1097,25 @@ def test_should_fail_when_writing_on_writer_that_returns_not_a_leader_code_using ): driver = Driver(self._backend, self._uri_with_context, self._auth, self._userAgent) - self.start_server(self._routingServer1, "router_adb.script") + self.start_server(self._routingServer1, "router_adb_then_bdb.script") self.start_server( self._writeServer1, - "writer_tx_yielding_failure_on_run.script", + "writer_tx_yielding_failure_on_2nd_run.script", vars_={ **self.get_vars(), "#FAILURE#": '{"code": "Neo.ClientError.Cluster.NotALeader", ' '"message": "blabla"}' } ) - session = driver.session("w", database=self.adb) + list(session.run("RETURN 1 AS n")) + session.close() + + session = driver.session("w", database=self.bdb) tx = session.begin_transaction() failed = False try: - tx.run("RETURN 1 as n").consume() + tx.run("RETURN 1 AS n").consume() except types.DriverError as e: driver_name = get_driver_name() if driver_name in ["java"]: @@ -1109,7 +1140,11 @@ def test_should_fail_when_writing_on_writer_that_returns_not_a_leader_code_using session.close() self.assertNotIn(self._writeServer1.address, - driver.get_routing_table(self.adb).writers) + driver.get_routing_table(self.bdb).writers) + if self.adb != self.bdb: + # should not invalidate writer for other databases + self.assertIn(self._writeServer1.address, + driver.get_routing_table(self.adb).writers) driver.close() @@ -1123,23 +1158,26 @@ def test_should_fail_when_writing_without_explicit_consumption_on_writer_that_re ): driver = Driver(self._backend, self._uri_with_context, self._auth, self._userAgent) - self.start_server(self._routingServer1, "router_adb.script") + self.start_server(self._routingServer1, "router_adb_then_bdb.script") self.start_server( self._writeServer1, - "writer_tx_yielding_failure_on_run.script", + "writer_tx_yielding_failure_on_2nd_run.script", vars_={ **self.get_vars(), "#FAILURE#": '{"code": "Neo.ClientError.Cluster.NotALeader", ' '"message": "blabla"}' } ) - session = driver.session("w", database=self.adb) + list(session.run("RETURN 1 AS n")) + session.close() + + session = driver.session("w", database=self.bdb) tx = session.begin_transaction() failed = False try: # drivers doing eager loading will fail here - tx.run("RETURN 1 as n") + tx.run("RETURN 1 AS n") # else they should fail here tx.commit() except types.DriverError as e: @@ -1166,7 +1204,11 @@ def test_should_fail_when_writing_without_explicit_consumption_on_writer_that_re session.close() self.assertNotIn(self._writeServer1.address, - driver.get_routing_table(self.adb).writers) + driver.get_routing_table(self.bdb).writers) + if self.adb != self.bdb: + # should not invalidate writer for other databases + self.assertIn(self._writeServer1.address, + driver.get_routing_table(self.adb).writers) driver.close()