← Back to branch summary

~juju/ubuntu/quantal/juju/0.6

« back to all changes in this revision

Viewing changes to juju/providers/ec2/tests/test_bootstrap.py

  • Committer: Package Import Robot
  • Author(s): Clint Byrum
  • Date: 2011-09-28 09:42:32 UTC
  • Revision ID: package-import@ubuntu.com-20110928094232-o1yozyv3nw3ejymz
Tags: upstream-0.5+bzr361
Import upstream version 0.5+bzr361

Show diffs side-by-side

added added

removed removed

Lines of Context:
juju/providers/ec2/tests/test_bootstrap.py
 
1
import logging
 
2
import os
 
3
 
 
4
import yaml
 
5
 
 
6
from twisted.internet.defer import succeed
 
7
 
 
8
from txaws.ec2.model import SecurityGroup
 
9
 
 
10
from juju.lib.mocker import MATCH
 
11
from juju.lib.testing import TestCase
 
12
from juju.providers.ec2.machine import EC2ProviderMachine
 
13
 
 
14
from .common import EC2TestMixin, EC2MachineLaunchMixin
 
15
 
 
16
DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data")
 
17
 
 
18
 
 
19
class EC2BootstrapTest(EC2TestMixin, EC2MachineLaunchMixin, TestCase):
 
20
 
 
21
    def _mock_verify(self):
 
22
        self.s3.put_object(
 
23
            self.env_name, "bootstrap-verify", "storage is writable")
 
24
        self.mocker.result(succeed(True))
 
25
 
 
26
    def _mock_save(self):
 
27
        """Mock saving bootstrap instances to S3."""
 
28
 
 
29
        def match_string(data):
 
30
            return isinstance(data, str)
 
31
 
 
32
        self.s3.put_object(
 
33
            self.env_name, "provider-state",
 
34
            MATCH(match_string))
 
35
        self.mocker.result(succeed(True))
 
36
 
 
37
    def _mock_launch(self):
 
38
        """Mock launching a bootstrap machine on ec2."""
 
39
        def verify_user_data(data):
 
40
            expect_path = os.path.join(DATA_DIR, "bootstrap_cloud_init")
 
41
            with open(expect_path) as f:
 
42
                expect_cloud_init = yaml.load(f.read())
 
43
            self.assertEquals(yaml.load(data), expect_cloud_init)
 
44
            return True
 
45
 
 
46
        self.ec2.run_instances(
 
47
            image_id="ami-default",
 
48
            instance_type="m1.small",
 
49
            max_count=1,
 
50
            min_count=1,
 
51
            security_groups=["juju-moon", "juju-moon-0"],
 
52
            user_data=MATCH(verify_user_data))
 
53
 
 
54
    def test_launch_bootstrap(self):
 
55
        """The provider bootstrap can launch a bootstrap/zookeeper machine."""
 
56
 
 
57
        log = self.capture_logging("juju.common", level=logging.DEBUG)
 
58
 
 
59
        self.s3.get_object(self.env_name, "provider-state")
 
60
        self.mocker.result(succeed(""))
 
61
        self._mock_verify()
 
62
        self.ec2.describe_security_groups()
 
63
        self.mocker.result(succeed([]))
 
64
        self._mock_create_group()
 
65
        self._mock_create_machine_group(0)
 
66
        self._mock_launch_utils(region="us-east-1")
 
67
        self._mock_launch()
 
68
        self.mocker.result(succeed([]))
 
69
        self._mock_save()
 
70
        self.mocker.replay()
 
71
 
 
72
        provider = self.get_provider()
 
73
        deferred = provider.bootstrap()
 
74
 
 
75
        def check_log(result):
 
76
            log_text = log.getvalue()
 
77
            self.assertIn("Launching juju bootstrap instance", log_text)
 
78
            self.assertNotIn("previously bootstrapped", log_text)
 
79
 
 
80
        deferred.addCallback(check_log)
 
81
        return deferred
 
82
 
 
83
    def test_launch_bootstrap_existing_provider_group(self):
 
84
        """
 
85
        When launching a bootstrap instance the provider will use an existing
 
86
        provider instance group.
 
87
        """
 
88
        self.capture_logging("juju.ec2")
 
89
        self.s3.get_object(self.env_name, "provider-state")
 
90
        self.mocker.result(succeed(""))
 
91
        self._mock_verify()
 
92
        self.ec2.describe_security_groups()
 
93
        self.mocker.result(succeed([
 
94
            SecurityGroup("juju-%s" % self.env_name, "")]))
 
95
        self._mock_create_machine_group(0)
 
96
        self._mock_launch_utils(region="us-east-1")
 
97
        self._mock_launch()
 
98
        self.mocker.result(succeed([]))
 
99
        self._mock_save()
 
100
        self.mocker.replay()
 
101
 
 
102
        provider = self.get_provider()
 
103
        return provider.bootstrap()
 
104
 
 
105
    def test_run_with_loaded_state(self):
 
106
        """
 
107
        If the provider bootstrap is run when there is already a running
 
108
        bootstrap instance, it will just return the existing machine.
 
109
        """
 
110
        state = yaml.dump({"zookeeper-instances": ["i-foobar"]})
 
111
        self.s3.get_object(self.env_name, "provider-state")
 
112
        self.mocker.result(succeed(state))
 
113
        self.ec2.describe_instances("i-foobar")
 
114
        self.mocker.result(succeed([self.get_instance("i-foobar")]))
 
115
        self.mocker.replay()
 
116
 
 
117
        log = self.capture_logging("juju.common")
 
118
 
 
119
        def validate_result(result):
 
120
            self.assertTrue(result)
 
121
            machine = result.pop()
 
122
            self.assertTrue(isinstance(machine, EC2ProviderMachine))
 
123
            self.assertEqual(machine.instance_id, "i-foobar")
 
124
            self.assertEquals(
 
125
                log.getvalue(),
 
126
                "juju environment previously bootstrapped.\n")
 
127
 
 
128
        provider = self.get_provider()
 
129
        d = provider.bootstrap()
 
130
        d.addCallback(validate_result)
 
131
        return d
 
132
 
 
133
    def test_run_with_launch(self):
 
134
        """
 
135
        The provider bootstrap will launch an instance when run if there
 
136
        is no existing instance.
 
137
        """
 
138
        self.s3.get_object(self.env_name, "provider-state")
 
139
        self.mocker.result(succeed(""))
 
140
        self._mock_verify()
 
141
        self.ec2.describe_security_groups()
 
142
        self.mocker.result(succeed([
 
143
            SecurityGroup("juju-%s" % self.env_name, "")]))
 
144
        self._mock_create_machine_group(0)
 
145
        self._mock_launch_utils(region="us-east-1")
 
146
        self._mock_launch()
 
147
        self.mocker.result(succeed([self.get_instance("i-foobar")]))
 
148
        self._mock_save()
 
149
        self.mocker.replay()
 
150
 
 
151
        def validate_result(result):
 
152
            (machine,) = result
 
153
            self.assert_machine(machine, "i-foobar", "")
 
154
        provider = self.get_provider()
 
155
        d = provider.bootstrap()
 
156
        d.addCallback(validate_result)
 
157
        return d