← Back to branch summary

~allenap/maas/xxx-a-thon

« back to all changes in this revision

Viewing changes to src/maasserver/models/signals/tests/test_dns.py

  • Committer: Gavin Panella
  • Date: 2016-03-22 21:14:34 UTC
  • mfrom: (4657.1.157 maas)
  • Revision ID: gavin.panella@canonical.com-20160322211434-xzuovio86zvzo2js
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/models/signals/tests/test_dns.py
15
15
from maasserver.testing.testcase import MAASServerTestCase
16
16
from maastesting.matchers import (
17
17
    MockCalledOnceWith,
 
18
    MockCallsMatch,
18
19
    MockNotCalled,
19
20
)
 
21
from mock import call
 
22
from netaddr import IPNetwork
20
23
 
21
24
 
22
25
class TestDNSSignals(MAASServerTestCase):
29
32
        dns_update_all_zones = self.patch_autospec(
30
33
            dns_config_module, "dns_update_all_zones")
31
34
        domain = factory.make_Domain()
32
 
        self.assertThat(dns_add_domains, MockCalledOnceWith(domains=[domain]))
 
35
        self.assertThat(dns_add_domains, MockCalledOnceWith(domains={domain}))
33
36
        self.assertThat(dns_update_all_zones, MockNotCalled())
34
37
        domain.name = factory.make_name("domain")
35
38
        domain.save()
45
48
        dns_update_all_zones = self.patch_autospec(
46
49
            dns_config_module, "dns_update_all_zones")
47
50
        dnsrr = factory.make_DNSResource(domain=domain)
48
 
        self.assertThat(
49
 
            dns_update_domains, MockCalledOnceWith(domains=[domain]))
50
 
        self.assertThat(dns_update_subnets, MockNotCalled())
51
 
        self.assertThat(dns_update_all_zones, MockCalledOnceWith())
 
51
        # Once from saving the DNSResource, and once from adding the
 
52
        # StaticIPAddress.
 
53
        self.expectThat(
 
54
            dns_update_domains, MockCallsMatch(
 
55
                call({domain}), call({domain})))
 
56
        subnet = dnsrr.ip_addresses.first().subnet
 
57
        self.assertThat(dns_update_subnets, MockCalledOnceWith({subnet}))
 
58
        self.assertEqual(2, dns_update_all_zones.call_count)
52
59
        dnsrr.name = factory.make_name("dnsresource")
53
60
        dnsrr.save()
54
 
        self.assertEqual(2, dns_update_all_zones.call_count)
 
61
        self.assertEqual(3, dns_update_all_zones.call_count)
55
62
 
56
63
    def test_saving_dnsresource_without_ip_triggers_update(self):
57
64
        domain = factory.make_Domain()
64
71
            dns_config_module, "dns_update_all_zones")
65
72
        dnsrr = factory.make_DNSResource(domain=domain, no_ip_addresses=True)
66
73
        self.assertThat(
67
 
            dns_update_domains, MockCalledOnceWith(domains=[domain]))
 
74
            dns_update_domains, MockCalledOnceWith(domains={domain}))
68
75
        self.assertThat(dns_update_subnets, MockNotCalled())
69
76
        self.assertThat(dns_update_all_zones, MockNotCalled())
70
77
        dnsrr.name = factory.make_name("dnsresource")
82
89
            dns_config_module, "dns_update_all_zones")
83
90
        dnsdata = factory.make_DNSData(dnsresource=dnsrr)
84
91
        self.assertThat(
85
 
            dns_update_domains, MockCalledOnceWith(domains=[dnsrr.domain]))
 
92
            dns_update_domains, MockCalledOnceWith(domains={dnsrr.domain}))
86
93
        self.assertThat(dns_update_subnets, MockNotCalled())
87
94
        dnsdata.ttl = random.randint(0, 10000000)
88
95
        dnsdata.save()
95
102
        dns_update_all_zones = self.patch_autospec(
96
103
            dns_config_module, "dns_update_all_zones")
97
104
        subnet = factory.make_Subnet()
98
 
        self.assertThat(dns_add_subnets, MockCalledOnceWith(subnets=[subnet]))
 
105
        self.assertThat(dns_add_subnets, MockCalledOnceWith(subnets={subnet}))
 
106
        subnet.name = factory.make_name("subnet")
 
107
        subnet.save()
 
108
        self.assertThat(dns_update_all_zones, MockCalledOnceWith())
 
109
 
 
110
    def test_saving_subnet_with_parent_triggers_update(self):
 
111
        self.patch(settings, "DNS_CONNECT", False)
 
112
        dns_add_subnets = self.patch_autospec(
 
113
            dns_config_module, "dns_add_subnets")
 
114
        dns_update_subnets = self.patch_autospec(
 
115
            dns_config_module, "dns_update_subnets")
 
116
        dns_update_all_zones = self.patch_autospec(
 
117
            dns_config_module, "dns_update_all_zones")
 
118
        net = factory.make_ip4_or_6_network(host_bits=random.randint(2, 3))
 
119
        if net.version == 6:
 
120
            prefixlen = random.randint(121, 124)
 
121
        else:
 
122
            prefixlen = random.randint(20, 24)
 
123
        parent = IPNetwork("%s/%d" % (net.network, prefixlen))
 
124
        parent = IPNetwork("%s/%d" % (parent.network, prefixlen))
 
125
        parent_subnet = factory.make_Subnet(cidr=parent.cidr)
 
126
        self.assertThat(dns_add_subnets, MockCalledOnceWith(
 
127
            subnets={parent_subnet}))
 
128
        subnet = factory.make_Subnet(cidr=net.cidr)
 
129
        self.assertEqual(2, dns_add_subnets.call_count)
 
130
        self.assertThat(dns_update_subnets, MockCalledOnceWith(
 
131
            {parent_subnet}))
99
132
        subnet.name = factory.make_name("subnet")
100
133
        subnet.save()
101
134
        self.assertThat(dns_update_all_zones, MockCalledOnceWith())
150
183
            domain_module, "dns_kms_setting_changed")
151
184
        Config.objects.set_config('windows_kms_host', '8.8.8.8')
152
185
        self.assertThat(dns_kms_setting_changed, MockCalledOnceWith())
 
186
 
 
187
    def test_adding_and_removing_ip_on_dnsrr_triggers_update(self):
 
188
        self.patch(settings, "DNS_CONNECT", False)
 
189
        dns_update_all_zones = self.patch_autospec(
 
190
            dns_config_module, "dns_update_all_zones")
 
191
        dns_update_domains = self.patch_autospec(
 
192
            dns_config_module, "dns_update_domains")
 
193
        dns_update_subnets = self.patch_autospec(
 
194
            dns_config_module, "dns_update_subnets")
 
195
        domain = factory.make_Domain()
 
196
        dnsrr = factory.make_DNSResource(domain=domain, no_ip_addresses=True)
 
197
        sip = factory.make_StaticIPAddress()
 
198
        self.assertThat(dns_update_subnets, MockNotCalled())
 
199
        self.assertThat(dns_update_domains, MockCalledOnceWith({domain}))
 
200
        dnsrr.ip_addresses.add(sip)
 
201
        self.assertThat(dns_update_all_zones, MockNotCalled())
 
202
        # One call from creating the DNSResource, and one from adding the
 
203
        # StaticIPAddress.
 
204
        self.assertThat(
 
205
            dns_update_domains,
 
206
            MockCallsMatch(call({domain}), call({domain})))
 
207
        # Once from adding the StaticIPAddress.
 
208
        self.assertThat(
 
209
            dns_update_subnets,
 
210
            MockCallsMatch(call({sip.subnet})))
 
211
        # Now remove it.
 
212
        dnsrr.ip_addresses.remove(sip)
 
213
        # Calls update_all_zones, does not generate new calls to the others.
 
214
        self.assertThat(dns_update_all_zones, MockCalledOnceWith())
 
215
        self.assertEqual(2, dns_update_domains.call_count)
 
216
        self.assertEqual(1, dns_update_subnets.call_count)
 
217
 
 
218
    def test_adding_and_removing_ip_on_interface_triggers_update(self):
 
219
        self.patch(settings, "DNS_CONNECT", False)
 
220
        dns_update_all_zones = self.patch_autospec(
 
221
            dns_config_module, "dns_update_all_zones")
 
222
        dns_update_domains = self.patch_autospec(
 
223
            dns_config_module, "dns_update_domains")
 
224
        dns_update_subnets = self.patch_autospec(
 
225
            dns_config_module, "dns_update_subnets")
 
226
        subnet = factory.make_Subnet()
 
227
        node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet)
 
228
        self.assertThat(dns_update_all_zones, MockNotCalled())
 
229
        self.assertThat(
 
230
            dns_update_subnets, MockCallsMatch(
 
231
                call({subnet}), call({subnet})))
 
232
        self.assertThat(
 
233
            dns_update_domains, MockCallsMatch(
 
234
                call({node.domain}), call({node.domain})))
 
235
        # Now add an extra StaticIPAddress
 
236
        sip = factory.make_StaticIPAddress(subnet=subnet)
 
237
        node.get_boot_interface().ip_addresses.add(sip)
 
238
        # This calls dns_update_{domains,subnets}
 
239
        self.assertThat(dns_update_all_zones, MockNotCalled())
 
240
        self.assertThat(
 
241
            dns_update_subnets, MockCallsMatch(
 
242
                call({subnet}), call({subnet}), call({subnet})))
 
243
        self.assertThat(
 
244
            dns_update_domains, MockCallsMatch(
 
245
                call({node.domain}), call({node.domain}),
 
246
                call({node.domain})))
 
247
        # And then remove it
 
248
        node.get_boot_interface().ip_addresses.remove(sip)
 
249
        # This calls update_all_zones
 
250
        self.assertThat(dns_update_all_zones, MockCalledOnceWith())
 
251
        self.assertEqual(3, dns_update_subnets.call_count)
 
252
        self.assertEqual(3, dns_update_domains.call_count)
 
253
 
 
254
    def test_adding_and_removing_dnsrr_on_ip_triggers_update(self):
 
255
        self.patch(settings, "DNS_CONNECT", False)
 
256
        dns_update_all_zones = self.patch_autospec(
 
257
            dns_config_module, "dns_update_all_zones")
 
258
        dns_update_domains = self.patch_autospec(
 
259
            dns_config_module, "dns_update_domains")
 
260
        dns_update_subnets = self.patch_autospec(
 
261
            dns_config_module, "dns_update_subnets")
 
262
        domain = factory.make_Domain()
 
263
        dnsrr = factory.make_DNSResource(domain=domain, no_ip_addresses=True)
 
264
        sip = factory.make_StaticIPAddress()
 
265
        self.assertThat(dns_update_subnets, MockNotCalled())
 
266
        self.assertThat(dns_update_domains, MockCalledOnceWith({domain}))
 
267
        sip.dnsresource_set.add(dnsrr)
 
268
        self.assertThat(dns_update_all_zones, MockNotCalled())
 
269
        # One call from creating the DNSResource, and one from adding the
 
270
        # StaticIPAddress.
 
271
        self.assertThat(
 
272
            dns_update_domains,
 
273
            MockCallsMatch(call({domain}), call({domain})))
 
274
        # Once from adding the StaticIPAddress.
 
275
        self.assertThat(
 
276
            dns_update_subnets,
 
277
            MockCallsMatch(call({sip.subnet})))
 
278
        # Now remove it.
 
279
        sip.dnsresource_set.remove(dnsrr)
 
280
        # Calls update_all_zones, does not generate new calls to the others.
 
281
        self.assertThat(dns_update_all_zones, MockCalledOnceWith())
 
282
        self.assertEqual(2, dns_update_domains.call_count)
 
283
        self.assertEqual(1, dns_update_subnets.call_count)
 
284
 
 
285
    def test_adding_and_removing_interface_on_ip_triggers_update(self):
 
286
        self.patch(settings, "DNS_CONNECT", False)
 
287
        dns_update_all_zones = self.patch_autospec(
 
288
            dns_config_module, "dns_update_all_zones")
 
289
        dns_update_domains = self.patch_autospec(
 
290
            dns_config_module, "dns_update_domains")
 
291
        dns_update_subnets = self.patch_autospec(
 
292
            dns_config_module, "dns_update_subnets")
 
293
        subnet = factory.make_Subnet()
 
294
        node = factory.make_Node_with_Interface_on_Subnet(subnet=subnet)
 
295
        self.assertThat(dns_update_all_zones, MockNotCalled())
 
296
        self.assertThat(
 
297
            dns_update_subnets, MockCallsMatch(
 
298
                call({subnet}), call({subnet})))
 
299
        self.assertThat(
 
300
            dns_update_domains, MockCallsMatch(
 
301
                call({node.domain}), call({node.domain})))
 
302
        # Now add an extra StaticIPAddress
 
303
        sip = factory.make_StaticIPAddress(subnet=subnet)
 
304
        sip.interface_set.add(node.get_boot_interface())
 
305
        # This calls dns_update_{domains,subnets}
 
306
        self.assertThat(dns_update_all_zones, MockNotCalled())
 
307
        self.assertThat(
 
308
            dns_update_subnets, MockCallsMatch(
 
309
                call({subnet}), call({subnet}), call({subnet})))
 
310
        self.assertThat(
 
311
            dns_update_domains, MockCallsMatch(
 
312
                call({node.domain}), call({node.domain}),
 
313
                call({node.domain})))
 
314
        # And then remove it
 
315
        sip.interface_set.remove(node.get_boot_interface())
 
316
        # This calls update_all_zones
 
317
        self.assertThat(dns_update_all_zones, MockCalledOnceWith())
 
318
        self.assertEqual(3, dns_update_subnets.call_count)
 
319
        self.assertEqual(3, dns_update_domains.call_count)