src/mailman/model/tests/test_domain.py

   1 # Copyright (C) 2011-2016 by the Free Software Foundation, Inc.
   2 #
   3 # This file is part of GNU Mailman.
   4 #
   5 # GNU Mailman is free software: you can redistribute it and/or modify it under
   6 # the terms of the GNU General Public License as published by the Free
   7 # Software Foundation, either version 3 of the License, or (at your option)
   8 # any later version.
   9 #
  10 # GNU Mailman is distributed in the hope that it will be useful, but WITHOUT
  11 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 # FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13 # more details.
  14 #
  15 # You should have received a copy of the GNU General Public License along with
  16 # GNU Mailman.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 """Test domains."""
  19
  20 import unittest
  21
  22 from mailman.app.lifecycle import create_list
  23 from mailman.interfaces.domain import (
  24     DomainCreatedEvent, DomainCreatingEvent, DomainDeletedEvent,
  25     DomainDeletingEvent, IDomainManager)
  26 from mailman.interfaces.listmanager import IListManager
  27 from mailman.interfaces.usermanager import IUserManager
  28 from mailman.testing.helpers import event_subscribers
  29 from mailman.testing.layers import ConfigLayer
  30 from zope.component import getUtility
  31
  32
  33 class TestDomainManager(unittest.TestCase):
  34     layer = ConfigLayer
  35
  36     def setUp(self):
  37         self._events = []
  38         self._manager = getUtility(IDomainManager)
  39
  40     def _record_event(self, event):
  41         self._events.append(event)
  42
  43     def test_create_domain_event(self):
  44         # Test that creating a domain in the domain manager propagates the
  45         # expected events.
  46         with event_subscribers(self._record_event):
  47             domain = self._manager.add('example.org')
  48         self.assertEqual(len(self._events), 2)
  49         self.assertIsInstance(self._events[0], DomainCreatingEvent)
  50         self.assertEqual(self._events[0].mail_host, 'example.org')
  51         self.assertIsInstance(self._events[1], DomainCreatedEvent)
  52         self.assertEqual(self._events[1].domain, domain)
  53
  54     def test_delete_domain_event(self):
  55         # Test that deleting a domain in the domain manager propagates the
  56         # expected event.
  57         domain = self._manager.add('example.org')
  58         with event_subscribers(self._record_event):
  59             self._manager.remove('example.org')
  60         self.assertEqual(len(self._events), 2)
  61         self.assertIsInstance(self._events[0], DomainDeletingEvent)
  62         self.assertEqual(self._events[0].domain, domain)
  63         self.assertIsInstance(self._events[1], DomainDeletedEvent)
  64         self.assertEqual(self._events[1].mail_host, 'example.org')
  65
  66     def test_lookup_missing_domain(self):
  67         # Like dictionaries, getitem syntax raises KeyError on missing domain.
  68         with self.assertRaises(KeyError):
  69             self._manager['doesnotexist.com']
  70
  71     def test_delete_missing_domain(self):
  72         # Trying to delete a missing domain gives you a KeyError.
  73         self.assertRaises(KeyError, self._manager.remove, 'doesnotexist.com')
  74
  75     def test_domain_creation_no_default_owners(self):
  76         # If a domain is created without owners, then it has none.
  77         domain = self._manager.add('example.org')
  78         self.assertEqual(len(domain.owners), 0)
  79
  80     def test_domain_creation_with_owner(self):
  81         # You can create a new domain with a single owner.
  82         domain = self._manager.add('example.org', owners=['anne@example.org'])
  83         self.assertEqual(len(domain.owners), 1)
  84         self.assertEqual(domain.owners[0].addresses[0].email,
  85                          'anne@example.org')
  86
  87     def test_domain_creation_with_owners(self):
  88         # You can create a new domain with multiple owners.
  89         domain = self._manager.add(
  90             'example.org', owners=['anne@example.org',
  91                                    'bart@example.net'])
  92         self.assertEqual(len(domain.owners), 2)
  93         self.assertEqual(
  94             sorted(owner.addresses[0].email for owner in domain.owners),
  95             ['anne@example.org', 'bart@example.net'])
  96
  97     def test_domain_creation_creates_new_users(self):
  98         # Domain creation with existing users does not create new users, but
  99         # any user which doesn't yet exist (and is linked to the given
 100         # address), gets created.
 101         user_manager = getUtility(IUserManager)
 102         user_manager.make_user('anne@example.com')
 103         user_manager.make_user('bart@example.com')
 104         domain = self._manager.add(
 105             'example.org', owners=['anne@example.com',
 106                                    'bart@example.com',
 107                                    'cris@example.com'])
 108         self.assertEqual(len(domain.owners), 3)
 109         self.assertEqual(
 110             sorted(owner.addresses[0].email for owner in domain.owners),
 111             ['anne@example.com', 'bart@example.com', 'cris@example.com'])
 112         # Now cris exists as a user.
 113         self.assertIsNotNone(user_manager.get_user('cris@example.com'))
 114
 115     def test_domain_creation_with_users(self):
 116         # Domains can be created with IUser objects.
 117         user_manager = getUtility(IUserManager)
 118         anne = user_manager.make_user('anne@example.com')
 119         bart = user_manager.make_user('bart@example.com')
 120         domain = self._manager.add('example.org', owners=[anne, bart])
 121         self.assertEqual(len(domain.owners), 2)
 122         self.assertEqual(
 123             sorted(owner.addresses[0].email for owner in domain.owners),
 124             ['anne@example.com', 'bart@example.com'])
 125         def sort_key(owner):                        # noqa
 126             return owner.addresses[0].email
 127         self.assertEqual(sorted(domain.owners, key=sort_key), [anne, bart])
 128
 129     def test_add_domain_owner(self):
 130         # Domain owners can be added after the domain is created.
 131         domain = self._manager.add('example.org')
 132         self.assertEqual(len(domain.owners), 0)
 133         domain.add_owner('anne@example.org')
 134         self.assertEqual(len(domain.owners), 1)
 135         self.assertEqual(domain.owners[0].addresses[0].email,
 136                          'anne@example.org')
 137
 138     def test_add_multiple_domain_owners(self):
 139         # Multiple domain owners can be added after the domain is created.
 140         domain = self._manager.add('example.org')
 141         self.assertEqual(len(domain.owners), 0)
 142         domain.add_owners(['anne@example.org', 'bart@example.net'])
 143         self.assertEqual(len(domain.owners), 2)
 144         self.assertEqual([owner.addresses[0].email for owner in domain.owners],
 145                          ['anne@example.org', 'bart@example.net'])
 146
 147     def test_remove_domain_owner(self):
 148         # Domain onwers can be removed.
 149         domain = self._manager.add(
 150             'example.org', owners=['anne@example.org',
 151                                    'bart@example.net'])
 152         domain.remove_owner('anne@example.org')
 153         self.assertEqual(len(domain.owners), 1)
 154         self.assertEqual([owner.addresses[0].email for owner in domain.owners],
 155                          ['bart@example.net'])
 156
 157     def test_remove_missing_owner(self):
 158         # Users which aren't owners can't be removed.
 159         domain = self._manager.add(
 160             'example.org', owners=['anne@example.org',
 161                                    'bart@example.net'])
 162         self.assertRaises(ValueError, domain.remove_owner, 'cris@example.org')
 163         self.assertEqual(len(domain.owners), 2)
 164         self.assertEqual([owner.addresses[0].email for owner in domain.owners],
 165                          ['anne@example.org', 'bart@example.net'])
 166
 167
 168 class TestDomainLifecycleEvents(unittest.TestCase):
 169     layer = ConfigLayer
 170
 171     def setUp(self):
 172         self._domainmanager = getUtility(IDomainManager)
 173         self._org = self._domainmanager.add('example.net')
 174         self._net = self._domainmanager.add('example.org')
 175
 176     def test_lists_are_deleted_when_domain_is_deleted(self):
 177         # When a domain is deleted, all the mailing lists in that domain are
 178         # also deleted.
 179         create_list('ant@example.net')
 180         create_list('bee@example.net')
 181         cat = create_list('cat@example.org')
 182         dog = create_list('dog@example.org')
 183         ewe = create_list('ewe@example.com')
 184         fly = create_list('fly@example.com')
 185         listmanager = getUtility(IListManager)
 186         self._domainmanager.remove('example.net')
 187         self.assertEqual(listmanager.get('ant@example.net'), None)
 188         self.assertEqual(listmanager.get('bee@example.net'), None)
 189         self.assertEqual(listmanager.get('cat@example.org'), cat)
 190         self.assertEqual(listmanager.get('dog@example.org'), dog)
 191         self.assertEqual(listmanager.get('ewe@example.com'), ewe)
 192         self.assertEqual(listmanager.get('fly@example.com'), fly)
 193         self._domainmanager.remove('example.org')
 194         self.assertEqual(listmanager.get('cat@example.org'), None)
 195         self.assertEqual(listmanager.get('dog@example.org'), None)
 196         self.assertEqual(listmanager.get('ewe@example.com'), ewe)
 197         self.assertEqual(listmanager.get('fly@example.com'), fly)