← Back to branch summary

~free.ekanayaka/landscape-client/lucid-1.5.4-0ubuntu0.10.04.0

« back to all changes in this revision

Viewing changes to landscape/monitor/tests/test_hardwareinventory.py

  • Committer: Bazaar Package Importer
  • Author(s): Free Ekanayaka
  • Date: 2010-06-28 18:07:18 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20100628180718-vytyqgbtkiirv5sb
Tags: 1.5.2.1-0ubuntu0.10.04.0
https://launchpad.net/bugs/597000
Filter duplicate network interfaces in get_active_interfaces (LP: #597000)

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/monitor/tests/test_hardwareinventory.py
1
1
from twisted.internet.defer import fail, succeed
2
2
 
3
 
from landscape.lib import bpickle_dbus
4
3
from landscape.monitor.hardwareinventory import HardwareInventory
5
4
from landscape.tests.test_hal import MockHALManager, MockRealHALDevice
6
5
from landscape.tests.helpers import LandscapeTest, MonitorHelper
16
15
        super(HardwareInventoryTest, self).setUp()
17
16
        self.mstore.set_accepted_types(["hardware-inventory"])
18
17
        devices = [MockRealHALDevice({u"info.udi": u"wubble",
19
 
                                      u"info.product": u"Wubble",}),
 
18
                                      u"info.product": u"Wubble"}),
20
19
                   MockRealHALDevice({u"info.udi": u"ooga",
21
 
                                      u"info.product": u"Ooga",})]
 
20
                                      u"info.product": u"Ooga"})]
22
21
        self.hal_manager = MockHALManager(devices)
23
22
        self.plugin = HardwareInventory(hal_manager=self.hal_manager)
24
23
        self.monitor.add(self.plugin)
25
24
 
26
25
    def assertSchema(self, devices):
27
26
        full_message = {"type": "hardware-inventory", "devices": devices}
28
 
        self.assertEquals(HARDWARE_INVENTORY.coerce(full_message), full_message)
 
27
        self.assertEquals(HARDWARE_INVENTORY.coerce(full_message),
 
28
                          full_message)
29
29
 
30
30
    def test_hal_devices(self):
31
31
        """
71
71
        """
72
72
        self.hal_manager.devices = [
73
73
            MockRealHALDevice({u"info.udi": u"wubble",
74
 
                               u"info.product": u"Wubble",}),]
 
74
                               u"info.product": u"Wubble"})]
75
75
        registry_mocker = self.mocker.replace(self.plugin.registry)
76
76
        registry_mocker.flush()
77
77
        self.mocker.count(2)
80
80
        message = self.plugin.create_message()
81
81
        self.plugin.persist_data(None)
82
82
        self.assertEquals(message, [("create", {u"info.udi": u"wubble",
83
 
                                                u"info.product": u"Wubble"}),])
 
83
                                                u"info.product": u"Wubble"})])
84
84
 
85
85
        self.hal_manager.devices[0] = MockRealHALDevice(
86
 
            {u"info.udi": u"wubble", u"info.product": u"Ooga",})
 
86
            {u"info.udi": u"wubble", u"info.product": u"Ooga"})
87
87
        message = self.plugin.create_message()
88
88
        self.plugin.persist_data(None)
89
89
        self.assertEquals(message, [("update", u"wubble",
90
 
                                     {}, {u"info.product": u"Ooga"}, {}),])
 
90
                                     {}, {u"info.product": u"Ooga"}, {})])
91
91
        self.assertSchema(message)
92
92
        self.assertEquals(self.plugin.create_message(), [])
93
93
 
100
100
        self.hal_manager.devices = [
101
101
            MockRealHALDevice({u"info.udi": u"wubble",
102
102
                               u"info.product": u"Wubble",
103
 
                               u"info.capabilities": [u"foo", u"bar"]}),]
 
103
                               u"info.capabilities": [u"foo", u"bar"]})]
104
104
 
105
105
        message = self.plugin.create_message()
106
106
        self.plugin.persist_data(None)
132
132
        self.hal_manager.devices = [
133
133
            MockRealHALDevice({u"info.udi": u"wubble",
134
134
                               u"info.product": u"Wubble",
135
 
                               u"linux.acpi_type": 11}),]
 
135
                               u"linux.acpi_type": 11})]
136
136
 
137
137
        message = self.plugin.create_message()
138
138
        self.plugin.persist_data(None)
139
139
        self.assertEquals(message, [("create", {u"info.udi": u"wubble",
140
140
                                                u"info.product": u"Wubble",
141
 
                                                u"linux.acpi_type": 11}),])
 
141
                                                u"linux.acpi_type": 11})])
142
142
 
143
143
        self.hal_manager.devices[0] = MockRealHALDevice(
144
144
            {u"info.udi": u"wubble", u"info.product": u"Ooga",
148
148
        self.assertEquals(message, [("update", u"wubble",
149
149
                                     {u"info.category": u"unittest"},
150
150
                                     {u"info.product": u"Ooga"},
151
 
                                     {u"linux.acpi_type": 11}),])
 
151
                                     {u"linux.acpi_type": 11})])
152
152
        self.assertSchema(message)
153
153
 
154
154
        self.assertEquals(self.plugin.create_message(), [])
161
161
        """
162
162
        self.hal_manager.devices = [
163
163
            MockRealHALDevice({u"info.udi": u"wubble",
164
 
                               u"info.product": u"Wubble",}),
 
164
                               u"info.product": u"Wubble"}),
165
165
            MockRealHALDevice({u"info.udi": u"ooga",
166
 
                               u"info.product": u"Ooga",})]
 
166
                               u"info.product": u"Ooga"})]
167
167
 
168
168
        message = self.plugin.create_message()
169
169
        self.plugin.persist_data(None)
170
170
        self.assertEquals(message, [("create", {u"info.udi": u"wubble",
171
171
                                                u"info.product": u"Wubble"}),
172
172
                                    ("create", {u"info.udi": u"ooga",
173
 
                                                u"info.product": u"Ooga"}),])
 
173
                                                u"info.product": u"Ooga"})])
174
174
        self.assertSchema(message)
175
175
 
176
176
        self.hal_manager.devices.pop(1)
177
177
        message = self.plugin.create_message()
178
178
        self.plugin.persist_data(None)
179
 
        self.assertEquals(message, [("delete", u"ooga"),])
 
179
        self.assertEquals(message, [("delete", u"ooga")])
180
180
        self.assertSchema(message)
181
181
        self.assertEquals(self.plugin.create_message(), [])
182
182
 
196
196
                               u"info.parent": u"wubble0"}),
197
197
            MockRealHALDevice({u"info.udi": u"wubble3",
198
198
                               u"block.device": u"/dev/scd1",
199
 
                               u"info.parent": u"wubble2"}),]
 
199
                               u"info.parent": u"wubble2"})]
200
200
 
201
201
        message = self.plugin.create_message()
202
202
        self.plugin.persist_data(None)
206
206
        message = self.plugin.create_message()
207
207
        self.plugin.persist_data(None)
208
208
 
209
 
        self.assertEquals(message, [("delete", u"wubble"),])
 
209
        self.assertEquals(message, [("delete", u"wubble")])
210
210
        self.assertEquals(self.plugin.create_message(), [])
211
211
 
212
212
    def test_resynchronize(self):
252
252
        only persist data when the broker confirms that the message
253
253
        sent by the plugin has been sent.
254
254
        """
255
 
        class MyException(Exception): pass
 
255
 
 
256
        class MyException(Exception):
 
257
            pass
 
258
 
256
259
        self.log_helper.ignore_errors(MyException)
257
260
 
258
261
        broker_mock = self.mocker.replace(self.monitor.broker)