← Back to branch summary

~ubuntu-branches/ubuntu/trusty/txzookeeper/trusty

« back to all changes in this revision

Viewing changes to txzookeeper/tests/test_client.py

  • Committer: Package Import Robot
  • Author(s): Clint Byrum, Jakub Wilk, Clint Byrum
  • Date: 2013-05-15 09:58:18 UTC
  • mfrom: (3.2.1) (4.1.1 experimental)
  • Revision ID: package-import@ubuntu.com-20130515095818-oragqc8jfsc3205x
Tags: 0.9.8-1
[ Jakub Wilk ]
* Use canonical URIs for Vcs-* fields.

[ Clint Byrum ]
* New upstream release.
* Updated standards to 3.9.4, no changes necessary.

Show diffs side-by-side

added added

removed removed

Lines of Context:
txzookeeper/tests/test_client.py
24
24
import base64
25
25
import hashlib
26
26
 
27
 
from twisted.internet.defer import Deferred
 
27
from twisted.internet.defer import Deferred, maybeDeferred
28
28
from twisted.internet.base import DelayedCall
29
29
from twisted.python.failure import Failure
30
30
 
31
31
import zookeeper
32
32
 
33
 
from mocker import ANY, MATCH
 
33
from mocker import ANY, MATCH, ARGS
34
34
from txzookeeper.tests import ZookeeperTestCase, utils
35
35
from txzookeeper.client import (
36
36
    ZookeeperClient, ZOO_OPEN_ACL_UNSAFE, ConnectionTimeoutException,
122
122
        d.addCallback(check_connected)
123
123
        return d
124
124
 
 
125
    def test_close(self):
 
126
        """
 
127
        Test that the connection is closed, also for the first
 
128
        connection when the zookeeper handle is 0.
 
129
        """
 
130
 
 
131
        def _fake_init(*_):
 
132
            return 0
 
133
 
 
134
        mock_init = self.mocker.replace("zookeeper.init")
 
135
        mock_init(ARGS)
 
136
        self.mocker.call(_fake_init)
 
137
 
 
138
        def _fake_close(handle):
 
139
            return zookeeper.OK
 
140
 
 
141
        mock_close = self.mocker.replace("zookeeper.close")
 
142
        mock_close(0)
 
143
        self.mocker.call(_fake_close)
 
144
 
 
145
        self.mocker.replay()
 
146
 
 
147
        # Avoid unclean reactor by letting the callLater go through,
 
148
        # but we do not care about the timeout.
 
149
        def _silence_timeout(failure):
 
150
            failure.trap(ConnectionTimeoutException)
 
151
        self.client.connect(timeout=0).addErrback(_silence_timeout)
 
152
 
 
153
        d = maybeDeferred(self.client.close)
 
154
 
 
155
        def _verify(result):
 
156
            self.mocker.verify()
 
157
        d.addCallback(_verify)
 
158
        return d
 
159
 
125
160
    def test_client_event_repr(self):
126
161
        event = ClientEvent(zookeeper.SESSION_EVENT,
127
 
                            zookeeper.EXPIRED_SESSION_STATE, '')
128
 
        self.assertEqual(repr(event),
129
 
                         "<ClientEvent session at '' state: expired>")
 
162
                            zookeeper.EXPIRED_SESSION_STATE, '', 0)
 
163
        self.assertEqual(
 
164
            repr(event),
 
165
            "<ClientEvent session at '' state: expired handle:0>")
130
166
 
131
167
    def test_client_event_attributes(self):
132
 
        event = ClientEvent(4, 'state', 'path')
 
168
        event = ClientEvent(4, 'state', 'path', 0)
133
169
        self.assertEqual(event.type, 4)
134
170
        self.assertEqual(event.connection_state, 'state')
135
171
        self.assertEqual(event.path, 'path')
136
 
        self.assertEqual(event, (4, 'state', 'path'))
 
172
        self.assertEqual(event.handle, 0)
 
173
        self.assertEqual(event, (4, 'state', 'path', 0))
137
174
 
138
175
    def test_client_use_while_disconnected_returns_failure(self):
139
176
        return self.assertFailure(
404
441
        """
405
442
        d = self.client.connect()
406
443
 
407
 
        def inject_error(result_code, d, extra_codes=None):
 
444
        def inject_error(result_code, d, extra_codes=None, path=None):
408
445
            error = SyntaxError()
409
446
            d.errback(error)
410
447
            return error
412
449
        def check_exists(client):
413
450
            mock_client = self.mocker.patch(client)
414
451
            mock_client._check_result(
415
 
                ANY, DEFERRED_MATCH, extra_codes=(zookeeper.NONODE,))
 
452
                ANY, DEFERRED_MATCH, extra_codes=(zookeeper.NONODE,),
 
453
                path="/zebra-moon")
416
454
            self.mocker.call(inject_error)
417
455
            self.mocker.replay()
418
456
            return client.exists("/zebra-moon")
604
642
 
605
643
        def verify_succeeds(failure):
606
644
            self.assertTrue(failure)
607
 
            self.assertEqual(failure.value.args, ("no node",))
 
645
            self.assertEqual(
 
646
                failure.value.args, ("no node /abcd",))
608
647
 
609
648
        d.addCallback(delete_node)
610
649
        d.addCallback(verify_fails)
647
686
 
648
687
        def verify_succeeds(failure):
649
688
            self.assertTrue(failure)
650
 
            self.assertEqual(failure.value.args, ("no node",))
 
689
            self.assertTrue(
 
690
                failure.value.args, ("no node /xy1"))
651
691
 
652
692
        d.addCallback(set_node)
653
693
        d.addCallback(verify_fails)
837
877
            return self.client.set("/orchard", "bar")
838
878
 
839
879
        def node_access_failed(failure):
840
 
            self.assertEqual(failure.value.args, ("not authenticated",))
 
880
            self.assertEqual(failure.value.args, ("not authenticated /orchard",))
841
881
            failed.append(True)
842
882
            return
843
883
 
1133
1173
        connected before then, then an errback is invoked with a timeout
1134
1174
        exception.
1135
1175
        """
1136
 
        mock_init = self.mocker.replace("zookeeper.init")
1137
 
        mock_init(ANY, ANY, ANY)
1138
 
        self.mocker.result(0)
1139
 
        self.mocker.replay()
1140
 
 
1141
 
        d = self.client.connect(timeout=0.1)
 
1176
        # Connect to a non standard port with nothing at the remote side.
 
1177
        d = self.client.connect("127.0.0.1:2182", timeout=0.2)
1142
1178
 
1143
1179
        def verify_timeout(failure):
1144
1180
            self.assertTrue(