← Back to branch summary

~smoser/ubuntu/wily/maas/lp1474417

« back to all changes in this revision

Viewing changes to src/metadataserver/tests/test_models.py

  • Committer: Package Import Robot
  • Author(s): Andres Rodriguez, Dave Walker, Andres Rodriguez
  • Date: 2012-03-07 12:46:17 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20120307124617-319lac0nc230srs9
Tags: 0.1+bzr232+dfsg-0ubuntu1
https://launchpad.net/bugs/937982
* New upstream snapshot.

[ Dave Walker ]
* debian/control:
  - Changed depends from psycopg2 to python-psycopg2 and dropped versioning.
    - LP: #937982 

[ Andres Rodriguez ]
* debian/maas.install: Install maas-import-isos and related files.
* Integrate squid3 as proxy solution:
  - debian/extras/squid.conf: Added
  - debian/control: Depend on squid3.
  - debian/maas.{postinst,postrm}: Handle installation/removal of custom
    squid config file.
* Split into different binary packages (maas,python-django-maas).
  - debian/maas.postinst: Handle the apache2 configuration.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/metadataserver/tests/test_models.py
13
13
 
14
14
from maasserver.testing.factory import factory
15
15
from maastesting import TestCase
16
 
from metadataserver.models import NodeKey
 
16
from metadataserver.models import (
 
17
    NodeKey,
 
18
    NodeUserData,
 
19
    )
17
20
 
18
21
 
19
22
class TestNodeKeyManager(TestCase):
20
23
    """Test NodeKeyManager."""
21
24
 
22
 
    def test_create_key_registers_node_key(self):
 
25
    def test_get_token_for_node_registers_node_key(self):
23
26
        node = factory.make_node()
24
 
        token = NodeKey.objects.create_token(node)
 
27
        token = NodeKey.objects.get_token_for_node(node)
25
28
        nodekey = NodeKey.objects.get(node=node, key=token.key)
26
29
        self.assertNotEqual(None, nodekey)
 
30
        self.assertEqual(token, nodekey.token)
27
31
 
28
32
    def test_get_node_for_key_finds_node(self):
29
33
        node = factory.make_node()
30
 
        token = NodeKey.objects.create_token(node)
 
34
        token = NodeKey.objects.get_token_for_node(node)
31
35
        self.assertEqual(node, NodeKey.objects.get_node_for_key(token.key))
32
36
 
33
37
    def test_get_node_for_key_raises_DoesNotExist_if_key_not_found(self):
34
38
        non_key = factory.getRandomString()
35
39
        self.assertRaises(
36
40
            NodeKey.DoesNotExist, NodeKey.objects.get_node_for_key, non_key)
 
41
 
 
42
    def test_get_token_for_node_creates_token(self):
 
43
        node = factory.make_node()
 
44
        token = NodeKey.objects.get_token_for_node(node)
 
45
        self.assertEqual(node, NodeKey.objects.get_node_for_key(token.key))
 
46
 
 
47
    def test_get_token_for_node_returns_existing_token(self):
 
48
        node = factory.make_node()
 
49
        original_token = NodeKey.objects.get_token_for_node(node)
 
50
        repeated_token = NodeKey.objects.get_token_for_node(node)
 
51
        self.assertEqual(original_token, repeated_token)
 
52
 
 
53
    def test_get_token_for_node_inverts_get_node_for_key(self):
 
54
        node = factory.make_node()
 
55
        self.assertEqual(
 
56
            node,
 
57
            NodeKey.objects.get_node_for_key(
 
58
                NodeKey.objects.get_token_for_node(node).key))
 
59
 
 
60
    def test_get_node_for_key_inverts_get_token_for_node(self):
 
61
        key = NodeKey.objects.get_token_for_node(factory.make_node()).key
 
62
        self.assertEqual(
 
63
            key,
 
64
            NodeKey.objects.get_token_for_node(
 
65
                NodeKey.objects.get_node_for_key(key)).key)
 
66
 
 
67
 
 
68
class TestNodeUserDataManager(TestCase):
 
69
    """Test NodeUserDataManager."""
 
70
 
 
71
    def test_set_user_data_creates_new_nodeuserdata_if_needed(self):
 
72
        node = factory.make_node()
 
73
        data = b'foo'
 
74
        NodeUserData.objects.set_user_data(node, data)
 
75
        self.assertEqual(data, NodeUserData.objects.get(node=node).data)
 
76
 
 
77
    def test_set_user_data_overwrites_existing_userdata(self):
 
78
        node = factory.make_node()
 
79
        data = b'bar'
 
80
        NodeUserData.objects.set_user_data(node, b'old data')
 
81
        NodeUserData.objects.set_user_data(node, data)
 
82
        self.assertEqual(data, NodeUserData.objects.get(node=node).data)
 
83
 
 
84
    def test_set_user_data_leaves_data_for_other_nodes_alone(self):
 
85
        node = factory.make_node()
 
86
        NodeUserData.objects.set_user_data(node, b'intact')
 
87
        NodeUserData.objects.set_user_data(factory.make_node(), b'unrelated')
 
88
        self.assertEqual(b'intact', NodeUserData.objects.get(node=node).data)
 
89
 
 
90
    def test_get_user_data_retrieves_data(self):
 
91
        node = factory.make_node()
 
92
        data = b'splat'
 
93
        NodeUserData.objects.set_user_data(node, data)
 
94
        self.assertEqual(data, NodeUserData.objects.get_user_data(node))
 
95
 
 
96
    def test_get_user_data_raises_DoesNotExist_if_not_found(self):
 
97
        node = factory.make_node()
 
98
        self.assertRaises(
 
99
            NodeUserData.DoesNotExist,
 
100
            NodeUserData.objects.get_user_data, node)
 
101
 
 
102
    def test_get_user_data_ignores_other_nodes(self):
 
103
        node = factory.make_node()
 
104
        data = b'bzzz'
 
105
        NodeUserData.objects.set_user_data(node, data)
 
106
        NodeUserData.objects.set_user_data(factory.make_node(), b'unrelated')
 
107
        self.assertEqual(data, NodeUserData.objects.get_user_data(node))
 
108
 
 
109
    def test_has_user_data_returns_False_if_node_has_no_user_data(self):
 
110
        self.assertFalse(
 
111
            NodeUserData.objects.has_user_data(factory.make_node()))
 
112
 
 
113
    def test_has_user_data_returns_True_if_node_has_user_data(self):
 
114
        node = factory.make_node()
 
115
        NodeUserData.objects.set_user_data(node, b"This node has user data.")
 
116
        self.assertTrue(NodeUserData.objects.has_user_data(node))