← Back to branch summary

~rvb/maas/transaction-1.7-bug-1409852

« back to all changes in this revision

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

merged upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/maasserver/tests/test_auth.py
34
34
 
35
35
    def make_user(self, name='test', password='test'):
36
36
        """Create a user with a password."""
37
 
        return factory.make_user(username=name, password=password)
 
37
        return factory.make_User(username=name, password=password)
38
38
 
39
39
    def test_login(self):
40
40
        name = factory.make_string()
59
59
    def test_logout(self):
60
60
        name = factory.make_string()
61
61
        password = factory.make_string()
62
 
        factory.make_user(name, password)
 
62
        factory.make_User(name, password)
63
63
        self.client.login(username=name, password=password)
64
64
        self.client.post(reverse('logout'))
65
65
 
68
68
 
69
69
def make_unallocated_node():
70
70
    """Return a node that is not allocated to anyone."""
71
 
    return factory.make_node()
 
71
    return factory.make_Node()
72
72
 
73
73
 
74
74
def make_allocated_node(owner=None):
75
75
    """Create a node, owned by `owner` (or create owner if not given)."""
76
76
    if owner is None:
77
 
        owner = factory.make_user()
78
 
    return factory.make_node(owner=owner, status=NODE_STATUS.ALLOCATED)
 
77
        owner = factory.make_User()
 
78
    return factory.make_Node(owner=owner, status=NODE_STATUS.ALLOCATED)
79
79
 
80
80
 
81
81
class TestMAASAuthorizationBackend(MAASServerTestCase):
102
102
    def test_user_can_view_unowned_node(self):
103
103
        backend = MAASAuthorizationBackend()
104
104
        self.assertTrue(backend.has_perm(
105
 
            factory.make_user(), NODE_PERMISSION.VIEW,
 
105
            factory.make_User(), NODE_PERMISSION.VIEW,
106
106
            make_unallocated_node()))
107
107
 
108
108
    def test_user_can_view_nodes_owned_by_others(self):
109
109
        backend = MAASAuthorizationBackend()
110
110
        self.assertTrue(backend.has_perm(
111
 
            factory.make_user(), NODE_PERMISSION.VIEW, make_allocated_node()))
 
111
            factory.make_User(), NODE_PERMISSION.VIEW, make_allocated_node()))
112
112
 
113
113
    def test_owned_status(self):
114
114
        # A non-admin user can access nodes he owns.
121
121
    def test_user_cannot_edit_nodes_owned_by_others(self):
122
122
        backend = MAASAuthorizationBackend()
123
123
        self.assertFalse(backend.has_perm(
124
 
            factory.make_user(), NODE_PERMISSION.EDIT, make_allocated_node()))
 
124
            factory.make_User(), NODE_PERMISSION.EDIT, make_allocated_node()))
125
125
 
126
126
    def test_user_cannot_edit_unowned_node(self):
127
127
        backend = MAASAuthorizationBackend()
128
128
        self.assertFalse(backend.has_perm(
129
 
            factory.make_user(), NODE_PERMISSION.EDIT,
 
129
            factory.make_User(), NODE_PERMISSION.EDIT,
130
130
            make_unallocated_node()))
131
131
 
132
132
    def test_user_can_edit_his_own_nodes(self):
133
133
        backend = MAASAuthorizationBackend()
134
 
        user = factory.make_user()
 
134
        user = factory.make_User()
135
135
        self.assertTrue(backend.has_perm(
136
136
            user, NODE_PERMISSION.EDIT, make_allocated_node(owner=user)))
137
137
 
139
139
        # NODE_PERMISSION.ADMIN permission on nodes is granted to super users
140
140
        # only.
141
141
        backend = MAASAuthorizationBackend()
142
 
        user = factory.make_user()
 
142
        user = factory.make_User()
143
143
        self.assertFalse(
144
144
            backend.has_perm(
145
 
                user, NODE_PERMISSION.ADMIN, factory.make_node()))
 
145
                user, NODE_PERMISSION.ADMIN, factory.make_Node()))
146
146
 
147
147
 
148
148
class TestNodeVisibility(MAASServerTestCase):
158
158
                factory.make_admin(), NODE_PERMISSION.VIEW))
159
159
 
160
160
    def test_user_sees_own_nodes_and_unowned_nodes(self):
161
 
        user = factory.make_user()
 
161
        user = factory.make_User()
162
162
        make_allocated_node()
163
163
        own_node = make_allocated_node(owner=user)
164
164
        unowned_node = make_unallocated_node()