← Back to branch summary

~ubuntu-branches/ubuntu/utopic/maas/utopic-updates

« back to all changes in this revision

Viewing changes to src/maasserver/tests/test_rabbit.py

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez, Jeroen Vermeulen, Andres Rodriguez, Jason Hobbs, Raphaël Badin, Louis Bouchard, Gavin Panella
  • Date: 2014-08-21 19:36:30 UTC
  • mfrom: (1.3.1)
  • Revision ID: package-import@ubuntu.com-20140821193630-kertpu5hd8yyss8h
Tags: 1.7.0~beta7+bzr3266-0ubuntu1
https://launchpad.net/bugs/1365130
https://launchpad.net/bugs/1346703
* New Upstream Snapshot, Beta 7 bzr3266

[ Jeroen Vermeulen ]
* debian/extras/99-maas-sudoers
  debian/maas-dhcp.postinst
  debian/rules
  - Add second DHCP server instance for IPv6.
* debian/maas-region-controller-min.install
  debian/maas-region-controller-min.lintian-overrides
  - Install deployment user-data: maas_configure_interfaces.py script.
* debian/maas-cluster-controller.links
  debian/maas-cluster-controller.install
  debian/maas-cluster-controller.postinst
  - Reflect Celery removal changes made in trunk r3067.
  - Don't install celeryconfig_cluster.py any longer. 
  - Don't install maas_local_celeryconfig_cluster.py any longer.
  - Don't symlink maas_local_celeryconfig_cluster.py from /etc to /usr.
  - Don't insert UUID into maas_local_celeryconfig_cluster.py.

[ Andres Rodriguez ]
* debian/maas-region-controller-min.postrm: Cleanup lefover files.
* debian/maas-dhcp.postrm: Clean leftover configs.
* Provide new maas-proxy package that replaces the usage of
  squid-deb-proxy:
  - debian/control: New maas-proxy package that replaces the usage
    of squid-deb-proxy; Drop depends on squid-deb-proxy.
  - Add upstrart job.
  - Ensure squid3 is stopped as maas-proxy uses a caching proxy.
* Remove Celery references to cluster controller:
  - Rename upstart job from maas-pserv to maas-cluster; rename
    maas-cluster-celery to maas-cluster-register. Ensure services
    are stopped on upgrade.
  - debian/maintscript: Cleanup config files.
  - Remove all references to the MAAS celery daemon and config
    files as we don't use it like that anymore
* Move some entries in debian/maintscript to
  debian/maas-cluster-controller.maintscript
* Remove usage of txlongpoll and rabbitmq-server. Handle upgrades
  to ensure these are removed correctly.

[ Jason Hobbs ]
* debian/maas-region-controller-min.install: Install
  maas-generate-winrm-cert script.

[ Raphaël Badin ]
* debian/extras/maas-region-admin: Bypass django-admin as it prints
  spurious messages to stdout (LP: #1365130).

[Louis Bouchard]
* debian/maas-cluster-controller.postinst:
  - Exclude /var/log/maas/rsyslog when changing ownership
    (LP: #1346703)

[Gavin Panella]
* debian/maas-cluster-controller.maas-clusterd.upstart:
  - Don't start-up the cluster controller unless a shared-secret has
    been installed.
* debian/maas-cluster-controller.maas-cluster-register.upstart: Drop.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/tests/test_rabbit.py
1
 
# Copyright 2012-2014 Canonical Ltd.  This software is licensed under the
2
 
# GNU Affero General Public License version 3 (see the file LICENSE).
3
 
 
4
 
"""Rabbit messaging tests."""
5
 
 
6
 
from __future__ import (
7
 
    absolute_import,
8
 
    print_function,
9
 
    unicode_literals,
10
 
    )
11
 
 
12
 
str = None
13
 
 
14
 
__metaclass__ = type
15
 
__all__ = []
16
 
 
17
 
 
18
 
import socket
19
 
import time
20
 
 
21
 
from amqplib import client_0_8 as amqp
22
 
from django.conf import settings
23
 
from maasserver.exceptions import NoRabbit
24
 
from maasserver.rabbit import (
25
 
    RabbitBase,
26
 
    RabbitExchange,
27
 
    RabbitMessaging,
28
 
    RabbitQueue,
29
 
    RabbitSession,
30
 
    )
31
 
from maasserver.testing.factory import factory
32
 
from maasserver.testing.rabbit import uses_rabbit_fixture
33
 
from maastesting.testcase import MAASTestCase
34
 
from testtools.testcase import ExpectedException
35
 
 
36
 
 
37
 
def run_rabbit_command(rabbit, command):
38
 
    """Run a Rabbit command through rabbitctl, and return its output."""
39
 
    if isinstance(command, unicode):
40
 
        command = command.encode('ascii')
41
 
    rabbit_env = rabbit.runner.environment
42
 
    return rabbit_env.rabbitctl(command)[0]
43
 
 
44
 
 
45
 
class TestRabbitSession(MAASTestCase):
46
 
 
47
 
    @uses_rabbit_fixture
48
 
    def test_connection_gets_connection(self):
49
 
        session = RabbitSession()
50
 
        self.addCleanup(session.disconnect)
51
 
        # Referencing the connection property causes a connection to be
52
 
        # created.
53
 
        connection = session.connection
54
 
        self.assertIsNotNone(session._connection)
55
 
        # The same connection is returned every time.
56
 
        self.assertIs(connection, session.connection)
57
 
 
58
 
    def test_connection_raises_NoRabbit_if_cannot_connect(self):
59
 
        # Attempt to connect to a RabbitMQ on the local "discard"
60
 
        # service.  The connection will be refused.
61
 
        self.patch(settings, 'RABBITMQ_HOST', 'localhost:9')
62
 
        session = RabbitSession()
63
 
        with ExpectedException(NoRabbit):
64
 
            session.connection
65
 
 
66
 
    def test_connection_propagates_exceptions(self):
67
 
 
68
 
        def fail(*args, **kwargs):
69
 
            raise socket.error("Connection not refused, but failed anyway.")
70
 
 
71
 
        self.patch(amqp, 'Connection', fail)
72
 
        session = RabbitSession()
73
 
        with ExpectedException(socket.error):
74
 
            session.connection
75
 
 
76
 
    def test_disconnect(self):
77
 
        session = RabbitSession()
78
 
        session.disconnect()
79
 
        self.assertIsNone(session._connection)
80
 
 
81
 
 
82
 
class TestRabbitMessaging(MAASTestCase):
83
 
 
84
 
    @uses_rabbit_fixture
85
 
    def test_messaging_getExchange(self):
86
 
        exchange_name = factory.make_string()
87
 
        messaging = RabbitMessaging(exchange_name)
88
 
        self.addCleanup(messaging._session.disconnect)
89
 
        exchange = messaging.getExchange()
90
 
        self.assertIsInstance(exchange, RabbitExchange)
91
 
        self.assertEqual(messaging._session, exchange._session)
92
 
        self.assertEqual(exchange_name, exchange.exchange_name)
93
 
 
94
 
    @uses_rabbit_fixture
95
 
    def test_messaging_getQueue(self):
96
 
        exchange_name = factory.make_string()
97
 
        messaging = RabbitMessaging(exchange_name)
98
 
        self.addCleanup(messaging._session.disconnect)
99
 
        queue = messaging.getQueue()
100
 
        self.assertIsInstance(queue, RabbitQueue)
101
 
        self.assertEqual(messaging._session, queue._session)
102
 
        self.assertEqual(exchange_name, queue.exchange_name)
103
 
 
104
 
 
105
 
class TestRabbitBase(MAASTestCase):
106
 
 
107
 
    def test_rabbitbase_contains_session(self):
108
 
        exchange_name = factory.make_string()
109
 
        rabbitbase = RabbitBase(RabbitSession(), exchange_name)
110
 
        self.assertIsInstance(rabbitbase._session, RabbitSession)
111
 
 
112
 
    def test_base_has_exchange_name(self):
113
 
        exchange_name = factory.make_string()
114
 
        rabbitbase = RabbitBase(RabbitSession(), exchange_name)
115
 
        self.assertEqual(exchange_name, rabbitbase.exchange_name)
116
 
 
117
 
    @uses_rabbit_fixture
118
 
    def test_base_channel(self):
119
 
        rabbitbase = RabbitBase(RabbitSession(), factory.make_string())
120
 
        self.addCleanup(rabbitbase._session.disconnect)
121
 
        # Referencing the channel property causes an open channel to be
122
 
        # created.
123
 
        channel = rabbitbase.channel
124
 
        self.assertTrue(channel.is_open)
125
 
        self.assertIsNotNone(rabbitbase._session._connection)
126
 
        # The same channel is returned every time.
127
 
        self.assertIs(channel, rabbitbase.channel)
128
 
 
129
 
    @uses_rabbit_fixture
130
 
    def test_base_channel_creates_exchange(self):
131
 
        exchange_name = factory.make_string()
132
 
        rabbitbase = RabbitBase(RabbitSession(), exchange_name)
133
 
        self.addCleanup(rabbitbase._session.disconnect)
134
 
        rabbitbase.channel
135
 
        self.assertIn(
136
 
            exchange_name,
137
 
            run_rabbit_command(self.rabbit, 'list_exchanges'))
138
 
 
139
 
 
140
 
class TestRabbitExchange(MAASTestCase):
141
 
 
142
 
    def basic_get(self, channel, queue_name, timeout):
143
 
        endtime = time.time() + timeout
144
 
        while True:
145
 
            message = channel.basic_get(queue_name)
146
 
            if message is None:
147
 
                if time.time() > endtime:
148
 
                    self.fail('Cannot get message.')
149
 
                time.sleep(0.1)
150
 
            else:
151
 
                return message
152
 
 
153
 
    @uses_rabbit_fixture
154
 
    def test_exchange_publish(self):
155
 
        exchange_name = factory.make_string()
156
 
        message_content = factory.make_string()
157
 
        exchange = RabbitExchange(RabbitSession(), exchange_name)
158
 
        self.addCleanup(exchange._session.disconnect)
159
 
 
160
 
        rabbitbase = RabbitBase(RabbitSession(), exchange_name)
161
 
        self.addCleanup(rabbitbase._session.disconnect)
162
 
        channel = rabbitbase.channel
163
 
        queue_name = channel.queue_declare(auto_delete=True)[0]
164
 
        channel.queue_bind(exchange=exchange_name, queue=queue_name)
165
 
        exchange.publish(message_content)
166
 
        message = self.basic_get(channel, queue_name, timeout=2)
167
 
        self.assertEqual(message_content, message.body)
168
 
 
169
 
 
170
 
class TestRabbitQueue(MAASTestCase):
171
 
 
172
 
    @uses_rabbit_fixture
173
 
    def test_rabbit_queue_binds_queue(self):
174
 
        exchange_name = factory.make_string()
175
 
        message_content = factory.make_string()
176
 
        queue = RabbitQueue(RabbitSession(), exchange_name)
177
 
        self.addCleanup(queue._session.disconnect)
178
 
 
179
 
        # Publish to queue.name.
180
 
        base = RabbitBase(RabbitSession(), exchange_name)
181
 
        self.addCleanup(base._session.disconnect)
182
 
        channel = base.channel
183
 
        msg = amqp.Message(message_content)
184
 
        channel.basic_publish(
185
 
            exchange=exchange_name, routing_key='', msg=msg)
186
 
        message = channel.basic_get(queue.name)
187
 
        self.assertEqual(message_content, message.body)