← Back to branch summary

~gz/pyjuju/0.5_unicode_token_backport

« back to all changes in this revision

Viewing changes to juju/providers/openstack/tests/test_launch.py

  • Committer: Clint Byrum
  • Author(s): Martin Packman
  • Date: 2012-09-10 08:32:41 UTC
  • Revision ID: clint@ubuntu.com-20120910083241-xueuh0bt5jl44w2b
https://launchpad.net/bugs/1048533
OpenStack Provider

Show diffs side-by-side

added added

removed removed

Lines of Context:
juju/providers/openstack/tests/test_launch.py
 
1
"""Tests for launching a new server customised for juju using Nova"""
 
2
 
 
3
import logging
 
4
 
 
5
from twisted.internet import (
 
6
    defer,
 
7
    )
 
8
 
 
9
from juju import errors
 
10
from juju.lib import (
 
11
    mocker,
 
12
    testing,
 
13
    )
 
14
from juju.machine import (
 
15
    constraints,
 
16
    )
 
17
 
 
18
from juju.providers.openstack import (
 
19
    launch,
 
20
    tests,
 
21
    )
 
22
 
 
23
class MockedLaunchProvider(tests.MockedProvider):
 
24
 
 
25
    def launch(self, machine_id, master=False):
 
26
        constraint_set = constraints.ConstraintSet(self.provider_type)
 
27
        details = {
 
28
            'machine-id': machine_id,
 
29
            'constraints': constraint_set.load({}),
 
30
            }
 
31
        return launch.NovaLaunchMachine.launch(self, details, master)
 
32
 
 
33
    def expect_launch_setup(self, machine_id):
 
34
        self.port_manager.ensure_groups(machine_id)
 
35
        self.mocker.result(defer.succeed(["juju-x", "juju-y"]))
 
36
        self.nova.list_flavors()
 
37
        self.mocker.result(defer.succeed([
 
38
                {'id': 1, 'name': "standard.xsmall"},
 
39
            ]))
 
40
 
 
41
    def expect_run_server(self, machine_id, response):
 
42
        self.nova.run_server(
 
43
            name="juju testing instance " + machine_id,
 
44
            image_id=42,
 
45
            flavor_id=1,
 
46
            security_group_names=["juju-x", "juju-y"],
 
47
            user_data=mocker.ANY,
 
48
            )
 
49
        self.mocker.result(defer.succeed(response))
 
50
 
 
51
    def expect_available_floating_ip(self, server_id):
 
52
        self.nova.list_floating_ips()
 
53
        self.mocker.result(defer.succeed([
 
54
            {'instance_id': None, 'ip': "198.162.1.0"},
 
55
            ]))
 
56
        self.nova.add_floating_ip(server_id, "198.162.1.0")
 
57
        self.mocker.result(defer.succeed(None))
 
58
 
 
59
 
 
60
class NovaLaunchMachineTests(testing.TestCase):
 
61
 
 
62
    def test_launch_requires_default_image_id(self):
 
63
        config = dict(MockedLaunchProvider.default_config)
 
64
        del config['default-image-id']
 
65
        provider = MockedLaunchProvider(self.mocker, config)
 
66
        provider.expect_zookeeper_machines(1000)
 
67
        self.mocker.replay()
 
68
        deferred = provider.launch("1")
 
69
        return self.assertFailure(deferred, errors.ProviderError)
 
70
 
 
71
    def test_start_machine(self):
 
72
        provider = MockedLaunchProvider(self.mocker)
 
73
        provider.expect_zookeeper_machines(1000)
 
74
        provider.expect_launch_setup("1")
 
75
        provider.expect_run_server("1", response={
 
76
            'id': 1001,
 
77
            'addresses': {'public': []},
 
78
            })
 
79
        self.mocker.replay()
 
80
        return provider.launch("1")
 
81
 
 
82
    def test_start_machine_delay(self):
 
83
        provider = MockedLaunchProvider(self.mocker)
 
84
        provider.config["use-floating-ip"] = True
 
85
        provider.expect_zookeeper_machines(1000)
 
86
        provider.expect_launch_setup("1")
 
87
        provider.expect_run_server("1", response={
 
88
            'id': 1001,
 
89
            })
 
90
        provider.nova.get_server(1001)
 
91
        self.mocker.result(defer.succeed({
 
92
            'id': 1001,
 
93
            'addresses': {'public': []},
 
94
            }))
 
95
        provider.expect_available_floating_ip(1001)
 
96
        self.mocker.result(defer.succeed(None))
 
97
        self.mocker.replay()
 
98
        self.patch(launch.NovaLaunchMachine, "_DELAY_FOR_ADDRESSES", 0)
 
99
        return provider.launch("1")
 
100
 
 
101
    def test_start_machine_master(self):
 
102
        provider = MockedLaunchProvider(self.mocker)
 
103
        provider.expect_swift_public_object_url("juju_master_id")
 
104
        provider.expect_launch_setup("0")
 
105
        provider.expect_run_server("0", response={
 
106
            'id': 1000,
 
107
            'addresses': {'public': []},
 
108
            })
 
109
        provider.expect_swift_put("juju_master_id", "1000")
 
110
        provider.provider_actions.save_state({'zookeeper-instances': [1000]})
 
111
        self.mocker.result(defer.succeed(None))
 
112
        self.mocker.replay()
 
113
        return provider.launch("0", master=True)