← Back to branch summary

~bjornt/pyjuju/stack-crack

« back to all changes in this revision

Viewing changes to ensemble/providers/ec2/tests/test_connect.py

  • Committer: William Reade
  • Date: 2011-08-17 09:17:06 UTC
  • mfrom: (306.1.24 hide-instances)
  • Revision ID: fwereade@gmail.com-20110817091706-2zg0we3co9xqrwfk
simplified instance-getting; ec2 no longer filters 'pending' instances, to better match orchestra behaviour; several error types/messages reworked

Show diffs side-by-side

added added

removed removed

Lines of Context:
ensemble/providers/ec2/tests/test_connect.py
5
5
 
6
6
from twisted.internet.defer import inlineCallbacks, succeed, fail
7
7
 
8
 
from txaws.ec2.model import Instance
9
 
 
10
8
import zookeeper
11
9
 
12
10
from txzookeeper import ZookeeperClient
30
28
 
31
29
class EC2ConnectTest(EC2TestMixin, TestCase):
32
30
 
 
31
    def mock_find_zookeepers(self, instance):
 
32
        self.s3.get_object(self.env_name, "provider-state")
 
33
        self.mocker.result(succeed(dump(
 
34
            {"zookeeper-instances": ["i-foobar"]})))
 
35
        self.ec2.describe_instances("i-foobar")
 
36
        self.mocker.result(succeed([instance]))
 
37
 
 
38
    def mock_connect(self, share, instance, result):
 
39
        self.mock_find_zookeepers(instance)
 
40
        client = self.mocker.patch(SSHClient)
 
41
        client.connect("foo.example.com:2181", timeout=30, share=share)
 
42
        self.mocker.result(result)
 
43
 
 
44
    def test_no_dns_name(self):
 
45
        instance = self.get_instance("i-foobar")
 
46
        self.mock_find_zookeepers(instance)
 
47
        self.mocker.replay()
 
48
 
 
49
        provider = self.get_provider()
 
50
        d = provider.connect()
 
51
 
 
52
        def check_error(error):
 
53
            self.assertEqual(
 
54
                str(error),
 
55
                "Ensemble environment is not accessible: Machine i-foobar has "
 
56
                "no address assigned yet")
 
57
 
 
58
        self.assertFailure(d, NoConnection)
 
59
        d.addCallback(check_error)
 
60
        return d
 
61
 
33
62
    def test_provider_connect_forwards_share_option(self):
34
63
        """Test connecting to a running ensemble zookeeper server within ec2.
35
64
        """
36
 
        server = Instance("i-foobar", "running", dns_name="x.example.com")
37
 
        self.s3.get_object(self.env_name, "provider-state")
38
 
        self.mocker.result(succeed(dump(
39
 
            {"zookeeper-instances": [server.instance_id]})))
40
 
 
41
 
        self.ec2.describe_instances(server.instance_id)
42
 
        self.mocker.result(succeed([server]))
43
 
        client = self.mocker.patch(SSHClient)
44
 
 
 
65
        instance = self.get_instance("i-foobar", dns_name="foo.example.com")
45
66
        connected_client = self.mocker.mock(type=SSHClient)
46
 
 
47
 
        client.connect(server.dns_name + ":2181", timeout=30, share=True)
48
 
        self.mocker.result(succeed(connected_client))
49
 
 
 
67
        self.mock_connect(True, instance, succeed(connected_client))
50
68
        # We'll test the wait on initialization separately.
51
69
        connected_client.exists_and_watch("/initialized")
52
70
        self.mocker.result((succeed(True), None))
53
 
 
54
71
        self.mocker.replay()
55
72
 
56
73
        provider = self.get_provider()
66
83
        """
67
84
        Test connecting to a running ensemble zookeeper server within ec2.
68
85
        """
69
 
        server = Instance("i-foobar", "running", dns_name="x1.example.com")
70
 
        self.s3.get_object(self.env_name, "provider-state")
71
 
        self.mocker.result(succeed(dump(
72
 
            {"zookeeper-instances": [server.instance_id]})))
73
 
        self.ec2.describe_instances(server.instance_id)
74
 
        self.mocker.result(succeed([server]))
75
 
 
76
86
        # Hand back a real connected client to test the wait on initialization.
 
87
        instance = self.get_instance("i-foobar", dns_name="foo.example.com")
77
88
        connected_client = ZookeeperClient()
 
89
        self.mock_connect(False, instance, succeed(connected_client))
78
90
 
79
 
        client = self.mocker.patch(SSHClient)
80
 
        client.connect(server.dns_name + ":2181", timeout=30, share=False)
81
 
        self.mocker.result(succeed(connected_client))
82
91
        self.mocker.replay()
83
92
 
84
93
        zookeeper.set_debug_level(0)
116
125
        we show an error indicating the machine might still be
117
126
        initializing.
118
127
        """
119
 
        server = Instance("i-foobaz", "running", dns_name="x2.example.com",
120
 
                          launch_time=_aws_minutes_ago(1))
121
 
        self.s3.get_object(self.env_name, "provider-state")
122
 
        self.mocker.result(succeed(dump(
123
 
            {"zookeeper-instances": [server.instance_id]})))
124
 
        self.ec2.describe_instances(server.instance_id)
125
 
        self.mocker.result(succeed([server]))
126
 
 
127
 
        client = self.mocker.patch(SSHClient)
128
 
        client.connect(server.dns_name + ":2181", timeout=30, share=False)
129
 
        self.mocker.result(fail(NoConnection("BADABOOM!")))
 
128
        instance = self.get_instance(
 
129
            "i-foobar", dns_name="foo.example.com",
 
130
            launch_time=_aws_minutes_ago(1))
 
131
        self.mock_connect(False, instance, fail(NoConnection("BADABOOM!")))
130
132
        self.mocker.replay()
131
133
 
132
134
        provider = self.get_provider()
145
147
        If the machine has started for a while, though, we won't
146
148
        tweak the error message in any way.
147
149
        """
148
 
        server = Instance("i-foobaz", "running", dns_name="x2.example.com",
149
 
                          launch_time=_aws_minutes_ago(5))
150
 
        self.s3.get_object(self.env_name, "provider-state")
151
 
        self.mocker.result(succeed(dump(
152
 
            {"zookeeper-instances": [server.instance_id]})))
153
 
        self.ec2.describe_instances(server.instance_id)
154
 
        self.mocker.result(succeed([server]))
155
 
 
156
 
        client = self.mocker.patch(SSHClient)
157
 
        client.connect(server.dns_name + ":2181", timeout=30, share=False)
158
 
        self.mocker.result(fail(NoConnection("BADABOOM!")))
 
150
        instance = self.get_instance(
 
151
            "i-foobar", dns_name="foo.example.com",
 
152
            launch_time=_aws_minutes_ago(5))
 
153
        self.mock_connect(False, instance, fail(NoConnection("BADABOOM!")))
159
154
        self.mocker.replay()
160
155
 
161
156
        provider = self.get_provider()
173
168
        If the error raised is not NoConnection, then it should not
174
169
        be tweaked even if it is a recent machine.
175
170
        """
176
 
        server = Instance("i-foobaz", "running", dns_name="x1.example.com",
177
 
                          launch_time=_aws_minutes_ago(1))
178
 
        self.s3.get_object(self.env_name, "provider-state")
179
 
        self.mocker.result(succeed(dump(
180
 
            {"zookeeper-instances": [server.instance_id]})))
181
 
        self.ec2.describe_instances(server.instance_id)
182
 
        self.mocker.result(succeed([server]))
183
 
 
184
 
        client = self.mocker.patch(SSHClient)
185
 
        client.connect(server.dns_name + ":2181", timeout=30, share=False)
186
 
        self.mocker.result(fail(ValueError("BADAPOFT!")))
 
171
        instance = self.get_instance(
 
172
            "i-foobar", dns_name="foo.example.com",
 
173
            launch_time=_aws_minutes_ago(1))
 
174
        self.mock_connect(False, instance, fail(ValueError("BADAPOFT!")))
187
175
        self.mocker.replay()
188
176
 
189
177
        provider = self.get_provider()