def test_ephemeral_sequential(self): z = pookeeper.allocate(self.hosts) z.create('/root', CREATOR_ALL_ACL, Persistent()) random_data = _random_data() result = z.create('/root/pookie', CREATOR_ALL_ACL, EphemeralSequential(), data=random_data) result = z.create('/root/pookie', CREATOR_ALL_ACL, EphemeralSequential(), data=random_data) result = z.create('/root/pookie', CREATOR_ALL_ACL, EphemeralSequential(), data=random_data) children, _ = z.get_children('/root') children = sorted(children) assert len(children) == 3 assert int(children[0][len('/root/pookie'):]) == 0 assert int(children[1][len('/root/pookie'):]) == 1 assert int(children[2][len('/root/pookie'):]) == 2 z.close() z = pookeeper.allocate(self.hosts) children, _ = z.get_children('/root') assert len(children) == 0 pookeeper.delete(z, '/root') assert not z.exists('/root') z.close()
def test_ephemeral(self): z = pookeeper.allocate(self.hosts) random_data = _random_data() z.create('/pookie', CREATOR_ALL_ACL, Ephemeral(), data=random_data) z.close() z = pookeeper.allocate(self.hosts) assert not z.exists('/pookie') z.close()
def test_get_children_default_watcher(self): watcher = mock() z = pookeeper.allocate(self.hosts, watcher=watcher) z.create('/pookie', CREATOR_ALL_ACL, Persistent(), data=_random_data()) z.get_children('/pookie', watch=True) z.create('/pookie/bear', CREATOR_ALL_ACL, Persistent(), data=_random_data()) z.get_children('/pookie', watch=True) z.set_data('/pookie', _random_data()) z.set_data('/pookie/bear', _random_data()) # One is for when we do and the other is for when we don't chroot z.get_children('/pookie', watch=True) z.get_children('/pookie/bear', watch=True) z.delete('/pookie/bear') z.delete('/pookie') z.close() mockito.verify(watcher).session_connected(matchers.any(long), matchers.any(str), False) mockito.verify(watcher, times=2).children_changed('/pookie') mockito.verify(watcher).node_deleted('/pookie/bear') mockito.verify(watcher).connection_closed() verifyNoMoreInteractions(watcher)
def test_session_resumption(self): """ Test session reconnect disconnect the client by killing the socket, not sending the session disconnect to the server as usual. This allows the test to verify disconnect handling """ client = DropableClient34(self.hosts) client.create('/e', CREATOR_ALL_ACL, Ephemeral()) client.drop() try: client.exists('/e') assert False, 'Connection dropped for test' except ConnectionDroppedForTest: pass resumed_client = pookeeper.allocate(self.hosts, session_timeout=client.session_timeout, session_id=client.session_id, session_passwd=client.session_passwd) stat = resumed_client.exists('/e') assert stat is not None resumed_client.close() try: resumed_client.exists('/e') assert False, 'Should have raised SessionExpiredError' except SessionExpiredError: pass new_client = self._get_client(session_timeout=resumed_client.session_timeout, session_id=resumed_client.session_id, session_passwd=resumed_client.session_passwd) stat = new_client.exists('/e') assert stat is None new_client.close()
def test_persistent(self): z = pookeeper.allocate(self.hosts) random_data = _random_data() z.create('/pookie', CREATOR_ALL_ACL, Persistent(), data=random_data) z.close() z = pookeeper.allocate(self.hosts) data, stat = z.get_data('/pookie') assert data == random_data z.delete('/pookie', stat.version) assert not z.exists('/pookie') z.close()
def test_close(self): watcher = WatcherCounter() client = pookeeper.allocate(self.hosts, session_timeout=3.0, watcher=watcher) client.sync('/') client.close() assert watcher._session_connected == 1 assert not watcher._session_expired assert not watcher._auth_failed assert not watcher._connection_dropped assert watcher._connection_closed == 1
def test_ping(self): """ Make sure client connection is kept alive by behind the scenes pinging """ client = pookeeper.allocate(self.hosts, session_timeout=0.8) client.sync('/') time.sleep(5) client.get_children('/') client.close()
def test_negotiated_session_timeout(self): """ Verify access to the negotiated session timeout """ TICK_TIME = 2.0 # validate typical case - requested == negotiated client = pookeeper.allocate(self.hosts, session_timeout=TICK_TIME * 4) client.sync('/') assert TICK_TIME * 4 == client.negotiated_session_timeout client.close() # validate lower limit client = pookeeper.allocate(self.hosts, session_timeout=TICK_TIME) client.sync('/') assert TICK_TIME * 2 == client.negotiated_session_timeout client.close() # validate upper limit client = pookeeper.allocate(self.hosts, session_timeout=TICK_TIME * 30) client.sync('/') assert TICK_TIME * 20 == client.negotiated_session_timeout client.close()
def test_acls(self): z = pookeeper.allocate(self.hosts) z.create('/pookie', CREATOR_ALL_ACL + READ_ACL_UNSAFE, Persistent()) acls, stat = z.get_acls('/pookie') assert len(acls) == 2 for acl in acls: assert acl in set(CREATOR_ALL_ACL + READ_ACL_UNSAFE) z.delete('/pookie', stat.version) assert not z.exists('/pookie') z.close()
def test_bugus_auth(self): z = pookeeper.allocate(self.hosts, auth_data=set([('bogus', 'authdata')])) try: z.exists('/zookeeper') assert False, 'Allocation should have thrown an AuthFailedError' except AuthFailedError: pass try: z.exists('/zookeeper') assert False, 'Allocation should have thrown an AuthFailedError' except AuthFailedError: pass z.close()
def test_set_data_watcher(self): watcher = mock() z = pookeeper.allocate(self.hosts) z.create('/pookie', CREATOR_ALL_ACL, Ephemeral(), data=_random_data()) stat = z.exists('/pookie') stat = z.set_data('/pookie', _random_data(), stat.version) z.get_data('/pookie', watcher=watcher) stat = z.set_data('/pookie', _random_data(), stat.version) z.get_data('/pookie', watcher=watcher) z.delete('/pookie', stat.version) z.close() inorder.verify(watcher).data_changed('/pookie') inorder.verify(watcher).node_deleted('/pookie') verifyNoMoreInteractions(watcher)
def test_set_data_default_watcher(self): watcher = mock() z = pookeeper.allocate(self.hosts, watcher=watcher) z.create('/pookie', CREATOR_ALL_ACL, Ephemeral(), data=_random_data()) stat = z.exists('/pookie') stat = z.set_data('/pookie', _random_data(), stat.version) z.get_data('/pookie', watch=True) stat = z.set_data('/pookie', _random_data(), stat.version) z.get_data('/pookie', watch=True) z.delete('/pookie', stat.version) z.close() inorder.verify(watcher).session_connected(matchers.any(long), matchers.any(str), False) inorder.verify(watcher).data_changed('/pookie') inorder.verify(watcher).node_deleted('/pookie') inorder.verify(watcher).connection_closed() verifyNoMoreInteractions(watcher)
def test_exists_watcher(self): watcher = mock() z = pookeeper.allocate(self.hosts) assert not z.exists('/pookie', watcher=watcher) z.create('/pookie', CREATOR_ALL_ACL, Ephemeral(), data=_random_data()) stat = z.exists('/pookie', watcher=watcher) stat = z.set_data('/pookie', _random_data(), stat.version) # This data change will be ignored since the watch has been reset z.set_data('/pookie', _random_data(), stat.version) stat = z.exists('/pookie', watcher=watcher) z.delete('/pookie', stat.version) z.close() inorder.verify(watcher).node_created('/pookie') inorder.verify(watcher).data_changed('/pookie') inorder.verify(watcher).node_deleted('/pookie') verifyNoMoreInteractions(watcher)
def test_state_no_dupuplicate_reporting(self): """ Verify state change notifications are not duplicated This test makes sure that duplicate state changes are not communicated to the client watcher. For example we should not notify state as "disconnected" if the watch has already been disconnected. In general we don't consider a dup state notification if the event type is not "None" (ie non-None communicates an event). """ watcher = WatcherCounter() client = pookeeper.allocate(self.hosts, session_timeout=3.0, watcher=watcher) client.sync('/') self.cluster.stop() time.sleep(5) assert watcher._session_connected == 1 assert not watcher._session_expired assert not watcher._auth_failed assert watcher._connection_dropped == 1 assert not watcher._connection_closed
def test_transaction(self): z = pookeeper.allocate(self.hosts) # this should fail because /bar does not exist z.create('/foo', CREATOR_ALL_ACL, Persistent()) stat = z.exists('/foo') transaction = z.allocate_transaction() transaction.create('/pookie', CREATOR_ALL_ACL, Persistent()) transaction.check('/foo', stat.version) transaction.check('/bar', stat.version) transaction.delete('/foo', stat.version) transaction.commit() assert not z.exists('/pookie') assert z.exists('/foo') # this should succeed transaction = z.allocate_transaction() transaction.create('/pookie', CREATOR_ALL_ACL, Persistent()) transaction.check('/foo', stat.version) transaction.delete('/foo', stat.version) transaction.commit() try: transaction.create('/pookie', CREATOR_ALL_ACL, Persistent()) assert False, 'Transaction already committed - create should have failed' except ValueError: pass try: transaction.check('/foo', stat.version) assert False, 'Transaction already committed - check should have failed' except ValueError: pass try: transaction.delete('/foo', stat.version) assert False, 'Transaction already committed - delete should have failed' except ValueError: pass try: transaction.commit() assert False, 'Transaction already committed - commit should have failed' except ValueError: pass stat = z.exists('/pookie') z.delete('/pookie', stat.version) assert not z.exists('/foo') # test with z.create('/foo', CREATOR_ALL_ACL, Persistent()) with z.allocate_transaction() as t: t.create('/pookie', CREATOR_ALL_ACL, Persistent()) t.check('/foo', stat.version) t.delete('/foo', stat.version) stat = z.exists('/pookie') z.delete('/pookie', stat.version) assert not z.exists('/foo') z.close()