Plumb the subscription policy through the REST API.

2 files changed, 62 insertions, 17 deletions

diff --git a/src/mailman/app/tests/test_registrar.py b/src/mailman/app/tests/test_registrar.py
index 1431b5e6f..a2ab2c686 100644
--- a/src/mailman/app/tests/test_registrar.py
+++ b/src/mailman/app/tests/test_registrar.py
@@ -48,13 +48,14 @@ class TestRegistrar(unittest.TestCase):
         self._anne = getUtility(IUserManager).create_address(
             'anne@example.com')
 
-    def test_unique_token(self):
+    def test_initial_conditions(self):
         # Registering a subscription request provides a unique token associated
         # with a pendable, and the owner of the token.
         self.assertEqual(self._pendings.count, 0)
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, member = self._registrar.register(self._anne)
         self.assertIsNotNone(token)
         self.assertEqual(token_owner, TokenOwner.subscriber)
+        self.assertIsNone(member)
         self.assertEqual(self._pendings.count, 1)
         record = self._pendings.confirm(token, expunge=False)
         self.assertEqual(record['list_id'], self._mlist.list_id)
@@ -66,10 +67,11 @@ class TestRegistrar(unittest.TestCase):
         # there's nothing more to do.
         self._mlist.subscription_policy = SubscriptionPolicy.open
         self._anne.verified_on = now()
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, rmember = self._registrar.register(self._anne)
         self.assertIsNone(token)
         self.assertEqual(token_owner, TokenOwner.no_one)
         member = self._mlist.regular_members.get_member('anne@example.com')
+        self.assertEqual(rmember, member)
         self.assertEqual(member.address, self._anne)
         # There's nothing to confirm.
         record = self._pendings.confirm(token, expunge=False)
@@ -86,16 +88,18 @@ class TestRegistrar(unittest.TestCase):
         # to approve.  Running the workflow gives us a token.  Confirming the
         # token subscribes the user.
         self._mlist.subscription_policy = SubscriptionPolicy.open
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, rmember = self._registrar.register(self._anne)
         self.assertIsNotNone(token)
         self.assertEqual(token_owner, TokenOwner.subscriber)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # Now confirm the subscription.
-        token, token_owner = self._registrar.confirm(token)
+        token, token_owner, rmember = self._registrar.confirm(token)
         self.assertIsNone(token)
         self.assertEqual(token_owner, TokenOwner.no_one)
         member = self._mlist.regular_members.get_member('anne@example.com')
+        self.assertEqual(rmember, member)
         self.assertEqual(member.address, self._anne)
 
     def test_confirm_because_confirm(self):
@@ -105,16 +109,18 @@ class TestRegistrar(unittest.TestCase):
         # user.
         self._mlist.subscription_policy = SubscriptionPolicy.confirm
         self._anne.verified_on = now()
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, rmember = self._registrar.register(self._anne)
         self.assertIsNotNone(token)
         self.assertEqual(token_owner, TokenOwner.subscriber)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # Now confirm the subscription.
-        token, token_owner = self._registrar.confirm(token)
+        token, token_owner, rmember = self._registrar.confirm(token)
         self.assertIsNone(token)
         self.assertEqual(token_owner, TokenOwner.no_one)
         member = self._mlist.regular_members.get_member('anne@example.com')
+        self.assertEqual(rmember, member)
         self.assertEqual(member.address, self._anne)
 
     def test_confirm_because_moderation(self):
@@ -123,16 +129,18 @@ class TestRegistrar(unittest.TestCase):
         # token subscribes the user.
         self._mlist.subscription_policy = SubscriptionPolicy.moderate
         self._anne.verified_on = now()
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, rmember = self._registrar.register(self._anne)
         self.assertIsNotNone(token)
         self.assertEqual(token_owner, TokenOwner.moderator)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # Now confirm the subscription.
-        token, token_owner = self._registrar.confirm(token)
+        token, token_owner, rmember = self._registrar.confirm(token)
         self.assertIsNone(token)
         self.assertEqual(token_owner, TokenOwner.no_one)
         member = self._mlist.regular_members.get_member('anne@example.com')
+        self.assertEqual(rmember, member)
         self.assertEqual(member.address, self._anne)
 
     def test_confirm_because_confirm_then_moderation(self):
@@ -145,27 +153,30 @@ class TestRegistrar(unittest.TestCase):
           SubscriptionPolicy.confirm_then_moderate
         self._anne.verified_on = now()
         # Runs until subscription confirmation.
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, rmember = self._registrar.register(self._anne)
         self.assertIsNotNone(token)
         self.assertEqual(token_owner, TokenOwner.subscriber)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # Now confirm the subscription, and wait for the moderator to approve
         # the subscription.  She is still not subscribed.
-        new_token, token_owner = self._registrar.confirm(token)
+        new_token, token_owner, rmember = self._registrar.confirm(token)
         # The new token, used for the moderator to approve the message, is not
         # the same as the old token.
         self.assertNotEqual(new_token, token)
         self.assertIsNotNone(new_token)
         self.assertEqual(token_owner, TokenOwner.moderator)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # Confirm once more, this time as the moderator approving the
         # subscription.  Now she's a member.
-        token, token_owner = self._registrar.confirm(new_token)
+        token, token_owner, rmember = self._registrar.confirm(new_token)
         self.assertIsNone(token)
         self.assertEqual(token_owner, TokenOwner.no_one)
         member = self._mlist.regular_members.get_member('anne@example.com')
+        self.assertEqual(rmember, member)
         self.assertEqual(member.address, self._anne)
 
     def test_confirm_then_moderate_with_different_tokens(self):
@@ -177,18 +188,20 @@ class TestRegistrar(unittest.TestCase):
           SubscriptionPolicy.confirm_then_moderate
         self._anne.verified_on = now()
         # Runs until subscription confirmation.
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, rmember = self._registrar.register(self._anne)
         self.assertIsNotNone(token)
         self.assertEqual(token_owner, TokenOwner.subscriber)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # Now confirm the subscription, and wait for the moderator to approve
         # the subscription.  She is still not subscribed.
-        new_token, token_owner = self._registrar.confirm(token)
+        new_token, token_owner, rmember = self._registrar.confirm(token)
         # The status is not true because the user has not yet been subscribed
         # to the mailing list.
         self.assertIsNotNone(new_token)
         self.assertEqual(token_owner, TokenOwner.moderator)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # The new token is different than the old token.
@@ -197,11 +210,12 @@ class TestRegistrar(unittest.TestCase):
         self.assertRaises(LookupError, self._registrar.confirm, token)
         # Confirm once more, this time with the new token, as the moderator
         # approving the subscription.  Now she's a member.
-        done_token, token_owner = self._registrar.confirm(new_token)
+        done_token, token_owner, rmember = self._registrar.confirm(new_token)
         # The token is None, signifying that the member has been subscribed.
         self.assertIsNone(done_token)
         self.assertEqual(token_owner, TokenOwner.no_one)
         member = self._mlist.regular_members.get_member('anne@example.com')
+        self.assertEqual(rmember, member)
         self.assertEqual(member.address, self._anne)
 
     def test_discard_waiting_for_confirmation(self):
@@ -210,9 +224,10 @@ class TestRegistrar(unittest.TestCase):
         self._mlist.subscription_policy = SubscriptionPolicy.confirm
         self._anne.verified_on = now()
         # Runs until subscription confirmation.
-        token, token_owner = self._registrar.register(self._anne)
+        token, token_owner, rmember = self._registrar.register(self._anne)
         self.assertIsNotNone(token)
         self.assertEqual(token_owner, TokenOwner.subscriber)
+        self.assertIsNone(rmember)
         member = self._mlist.regular_members.get_member('anne@example.com')
         self.assertIsNone(member)
         # Now discard the subscription request.
diff --git a/src/mailman/app/tests/test_subscriptions.py b/src/mailman/app/tests/test_subscriptions.py
index fa4fec78f..42984c77c 100644
--- a/src/mailman/app/tests/test_subscriptions.py
+++ b/src/mailman/app/tests/test_subscriptions.py
@@ -203,13 +203,29 @@ class TestSubscriptionWorkflow(unittest.TestCase):
 
     def test_confirmation_checks_confirm_pre_confirmed(self):
         # The subscription policy requires user confirmation, but their
-        # subscription is pre-confirmed.
+        # subscription is pre-confirmed.  Since moderation is not required,
+        # the user will be immediately subscribed.
         self._mlist.subscription_policy = SubscriptionPolicy.confirm
         anne = self._user_manager.create_address(self._anne)
         workflow = SubscriptionWorkflow(self._mlist, anne,
                                         pre_verified=True,
                                         pre_confirmed=True)
         workflow.run_thru('confirmation_checks')
+        with patch.object(workflow, '_step_do_subscription') as step:
+            next(workflow)
+        step.assert_called_once_with()
+
+    def test_confirmation_checks_confirm_then_moderate_pre_confirmed(self):
+        # The subscription policy requires user confirmation, but their
+        # subscription is pre-confirmed.  Since moderation is required, that
+        # check will be performed.
+        self._mlist.subscription_policy = \
+          SubscriptionPolicy.confirm_then_moderate
+        anne = self._user_manager.create_address(self._anne)
+        workflow = SubscriptionWorkflow(self._mlist, anne,
+                                        pre_verified=True,
+                                        pre_confirmed=True)
+        workflow.run_thru('confirmation_checks')
         with patch.object(workflow, '_step_moderation_checks') as step:
             next(workflow)
         step.assert_called_once_with()
@@ -598,3 +614,17 @@ approval:
         # No further token is needed.
         self.assertIsNone(final_workflow.token)
         self.assertEqual(final_workflow.token_owner, TokenOwner.no_one)
+
+    def test_confirmation_needed_and_pre_confirmed(self):
+        # The subscription policy is 'confirm' but the subscription is
+        # pre-confirmed so the moderation checks can be skipped.
+        self._mlist.subscription_policy = SubscriptionPolicy.confirm
+        anne = self._user_manager.create_address(self._anne)
+        workflow = SubscriptionWorkflow(
+            self._mlist, anne,
+            pre_verified=True, pre_confirmed=True, pre_approved=True)
+        list(workflow)
+        # Anne was subscribed.
+        self.assertIsNone(workflow.token)
+        self.assertEqual(workflow.token_owner, TokenOwner.no_one)
+        self.assertEqual(workflow.member.address, anne)