def test_unsubscribe_from_creator(self):
        self.assertEqual(self._get_all_subscribers_of_creator(self.owner_id),
                         [])

        # Add subscribers to a creator.
        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        subscription_services.subscribe_to_creator(USER_ID_2, self.owner_id)
        self.assertEqual(self._get_all_subscribers_of_creator(self.owner_id),
                         [USER_ID, USER_ID_2])
        self.assertEqual(self._get_all_creators_subscribed_to(USER_ID),
                         [self.owner_id])
        self.assertEqual(self._get_all_creators_subscribed_to(USER_ID_2),
                         [self.owner_id])

        # Unsubscribing a user from a creator.
        subscription_services.unsubscribe_from_creator(USER_ID, self.owner_id)
        self.assertEqual(self._get_all_subscribers_of_creator(self.owner_id),
                         [USER_ID_2])
        self.assertEqual(self._get_all_creators_subscribed_to(USER_ID), [])

        # Unsubscribing the same user again has no effect.
        subscription_services.unsubscribe_from_creator(USER_ID, self.owner_id)
        self.assertEqual(self._get_all_subscribers_of_creator(self.owner_id),
                         [USER_ID_2])
        self.assertEqual(self._get_all_creators_subscribed_to(USER_ID), [])

        # Unsubscribing the second user.
        subscription_services.unsubscribe_from_creator(USER_ID_2,
                                                       self.owner_id)
        self.assertEqual(self._get_all_subscribers_of_creator(self.owner_id),
                         [])
        self.assertEqual(self._get_all_creators_subscribed_to(USER_ID_2), [])
    def test_get_all_creators_subscribed_to(self):
        self.assertEqual(
            subscription_services.get_all_creators_subscribed_to(USER_ID), [])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            subscription_services.get_all_creators_subscribed_to(USER_ID),
            [self.owner_id])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_2_id)
        self.assertEqual(
            subscription_services.get_all_creators_subscribed_to(USER_ID),
            [self.owner_id, self.owner_2_id])
Beispiel #3
0
    def test_can_see_subscription(self):
        self.login(self.VIEWER_EMAIL)

        response = self.get_json(feconf.LEARNER_DASHBOARD_DATA_URL)
        self.assertEqual(len(response['subscription_list']), 0)

        subscription_services.subscribe_to_creator(self.viewer_id,
                                                   self.owner_id)
        response = self.get_json(feconf.LEARNER_DASHBOARD_DATA_URL)
        self.assertEqual(len(response['subscription_list']), 1)
        self.assertEqual(response['subscription_list'][0]['creator_username'],
                         self.OWNER_USERNAME)
        self.logout()
Beispiel #4
0
    def test_get_all_subscribers_of_creator(self):
        self.assertEqual(
            subscription_services.get_all_subscribers_of_creator(
                self.owner_id), [])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            subscription_services.get_all_subscribers_of_creator(self.owner_id),
            [USER_ID])

        subscription_services.subscribe_to_creator(USER_ID_2, self.owner_id)
        self.assertEqual(
            subscription_services.get_all_subscribers_of_creator(self.owner_id),
            [USER_ID, USER_ID_2])
    def test_get_all_subscribers_of_creators(self):
        self.assertEqual(
            subscription_services.get_all_subscribers_of_creator(
                self.owner_id), [])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            subscription_services.get_all_subscribers_of_creator(self.owner_id),
            [USER_ID])

        subscription_services.subscribe_to_creator(USER_ID_2, self.owner_id)
        self.assertEqual(
            subscription_services.get_all_subscribers_of_creator(self.owner_id),
            [USER_ID, USER_ID_2])
    def test_get_all_creators_subscribed_to(self):
        self.assertEqual(
            subscription_services.get_all_creators_subscribed_to(
                USER_ID), [])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            subscription_services.get_all_creators_subscribed_to(
                USER_ID), [self.owner_id])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_2_id)
        self.assertEqual(
            subscription_services.get_all_creators_subscribed_to(
                USER_ID), [self.owner_id, self.owner_2_id])
Beispiel #7
0
    def setUp(self):
        super(UserSubscriptionsModelValidatorTests, self).setUp()

        self.signup(self.OWNER_EMAIL, self.OWNER_USERNAME)
        self.signup(USER_EMAIL, USER_NAME)

        self.owner_id = self.get_user_id_from_email(self.OWNER_EMAIL)
        self.user_id = self.get_user_id_from_email(USER_EMAIL)
        self.owner = user_services.UserActionsInfo(self.owner_id)

        explorations = [exp_domain.Exploration.create_default_exploration(
            '%s' % i,
            title='title %d' % i,
            category='category%d' % i
        ) for i in xrange(3)]

        for exp in explorations:
            exp_services.save_new_exploration(self.owner_id, exp)
            rights_manager.publish_exploration(self.owner, exp.id)

        collections = [collection_domain.Collection.create_default_collection(
            '%s' % i,
            title='title %d' % i,
            category='category%d' % i
        ) for i in xrange(3, 6)]

        for collection in collections:
            collection_services.save_new_collection(self.owner_id, collection)
            rights_manager.publish_collection(self.owner, collection.id)

        thread_id = feedback_services.create_thread(
            'exploration', 'exp_id', None, 'a subject', 'some text')

        subscription_services.subscribe_to_thread(
            self.user_id, thread_id)
        subscription_services.subscribe_to_creator(self.user_id, self.owner_id)
        for exp in explorations:
            subscription_services.subscribe_to_exploration(
                self.user_id, exp.id)
        for collection in collections:
            subscription_services.subscribe_to_collection(
                self.user_id, collection.id)
        self.process_and_flush_pending_tasks()

        prod_validation_jobs_one_off.MODEL_TO_VALIDATOR_MAPPING = {
            user_models.UserSubscriptionsModel:
                prod_validation_jobs_one_off.UserSubscriptionsModelValidator,
        }
Beispiel #8
0
    def test_can_see_subscriptions(self):
        self.login(self.VIEWER_EMAIL)

        response = self.get_json(feconf.PREFERENCES_DATA_URL)
        self.assertEqual(len(response['subscription_list']), 0)

        # Subscribe to user.
        subscription_services.subscribe_to_creator(self.viewer_id,
                                                   self.owner_id)
        response = self.get_json(feconf.PREFERENCES_DATA_URL)
        self.assertEqual(len(response['subscription_list']), 1)
        self.assertEqual(response['subscription_list'][0]['creator_username'],
                         self.OWNER_USERNAME)

        # Unsubscribe from user.
        subscription_services.unsubscribe_from_creator(self.viewer_id,
                                                       self.owner_id)
        response = self.get_json(feconf.PREFERENCES_DATA_URL)
        self.assertEqual(len(response['subscription_list']), 0)
Beispiel #9
0
    def test_can_see_subscribers(self):
        self.login(self.OWNER_EMAIL)

        response = self.get_json(feconf.DASHBOARD_DATA_URL)
        self.assertEqual(len(response['subscribers_list']), 0)

        # Subscribe to creator.
        subscription_services.subscribe_to_creator(
            self.viewer_id, self.owner_id)
        response = self.get_json(feconf.DASHBOARD_DATA_URL)
        self.assertEqual(len(response['subscribers_list']), 1)
        self.assertEqual(
            response['subscribers_list'][0]['subscriber_username'],
            self.VIEWER_USERNAME)

        # Unsubscribe from creator.
        subscription_services.unsubscribe_from_creator(
            self.viewer_id, self.owner_id)
        response = self.get_json(feconf.DASHBOARD_DATA_URL)
        self.assertEqual(len(response['subscribers_list']), 0)
Beispiel #10
0
    def test_get_all_creators_to_which_learner_has_subscribed(self):
        self.assertEqual(
            subscription_services.
            get_all_creators_to_which_learner_has_subscribed(  # pylint: disable=line-too-long
                USER_ID),
            [])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            subscription_services.
            get_all_creators_to_which_learner_has_subscribed(  # pylint: disable=line-too-long
                USER_ID),
            [self.owner_id])

        subscription_services.subscribe_to_creator(USER_ID, self.owner_2_id)
        self.assertEqual(
            subscription_services.
            get_all_creators_to_which_learner_has_subscribed(  # pylint: disable=line-too-long
                USER_ID),
            [self.owner_id, self.owner_2_id])
Beispiel #11
0
    def test_subscribe_to_creator(self):
        self.assertEqual(self._get_all_subscribers_of_creator(
            self.owner_id), [])

        # Subscribe a user to a creator.
        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creator(self.owner_id), [USER_ID])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID),
            [self.owner_id])

        # Repeated subscriptions to the same creator has no effect.
        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creator(self.owner_id), [USER_ID])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID),
            [self.owner_id])

        # Subscribe another creator.
        subscription_services.subscribe_to_creator(
            USER_ID_2, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creator(self.owner_id),
            [USER_ID, USER_ID_2])
        self.assertEqual(
            self._get_all_creators_subscribed_to(
                USER_ID_2), [self.owner_id])
    def test_subscribe_to_creator(self):
        self.assertEqual(self._get_all_subscribers_of_creators(
            self.owner_id), [])

        # Subscribe a user to a creator.
        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creators(self.owner_id), [USER_ID])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID),
            [self.owner_id])

        # Repeated subscriptions to the same creator has no effect.
        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creators(self.owner_id), [USER_ID])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID),
            [self.owner_id])

        # Subscribe another creator.
        subscription_services.subscribe_to_creator(USER_ID_2,
                                                   self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creators(self.owner_id),
            [USER_ID, USER_ID_2])
        self.assertEqual(
            self._get_all_creators_subscribed_to(
                USER_ID_2), [self.owner_id])
    def test_unsubscribe_from_creator(self):
        self.assertEqual(self._get_all_subscribers_of_creators(
            self.owner_id), [])

        # Add subscribers to a creator.
        subscription_services.subscribe_to_creator(USER_ID, self.owner_id)
        subscription_services.subscribe_to_creator(USER_ID_2, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creators(self.owner_id), [
                USER_ID, USER_ID_2])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID),
            [self.owner_id])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID_2),
            [self.owner_id])

        # Unsubscribing a user from a creator.
        subscription_services.unsubscribe_from_creator(USER_ID, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creators(self.owner_id), [USER_ID_2])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID), [])

        # Unsubscribing the same user again has no effect.
        subscription_services.unsubscribe_from_creator(USER_ID, self.owner_id)
        self.assertEqual(
            self._get_all_subscribers_of_creators(self.owner_id), [USER_ID_2])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID), [])

        # Unsubscribing the second user.
        subscription_services.unsubscribe_from_creator(
            USER_ID_2, self.owner_id)
        self.assertEqual(self._get_all_subscribers_of_creators(
            self.owner_id), [])
        self.assertEqual(
            self._get_all_creators_subscribed_to(USER_ID_2),
            [])
    def test_inform_subscribers(self) -> None:
        subscription_services.subscribe_to_creator(  # type: ignore[no-untyped-call]
            self.user_id_2, self.editor_id)
        subscription_services.subscribe_to_creator(  # type: ignore[no-untyped-call]
            self.new_user_id, self.editor_id)
        subscription_services.subscribe_to_creator(  # type: ignore[no-untyped-call]
            self.user_id, self.editor_id)

        email_preferences_model = user_models.UserEmailPreferencesModel.get(
            self.user_id_2, strict=False)
        if email_preferences_model is None:
            email_preferences_model = user_models.UserEmailPreferencesModel(
                id=self.user_id_2)

        email_preferences_model.subscription_notifications = False
        email_preferences_model.update_timestamps()
        email_preferences_model.put()

        with self.can_send_emails_ctx, self.can_send_subscription_email_ctx:
            email_subscription_services.inform_subscribers(
                self.editor_id, 'A', 'Title')

            # Make sure correct number of emails is sent and no email is sent
            # to the person who has unsubscribed from subscription emails.
            messages = (self._get_sent_email_messages(self.NEW_USER_EMAIL))
            self.assertEqual(len(messages), 1)
            messages = (self._get_sent_email_messages(self.NEW_USER_EMAIL))
            self.assertEqual(len(messages), 1)
            messages = (self._get_sent_email_messages(self.USER_EMAIL_2))
            self.assertEqual(len(messages), 0)

            # Make sure correct email models are stored.
            all_models: Sequence[email_models.SentEmailModel] = (
                email_models.SentEmailModel.get_all().fetch())
            self.assertEqual(
                True,
                any(model.recipient_id == self.user_id
                    for model in all_models))
            self.assertEqual(True, any(
                model.recipient_email == self.USER_EMAIL for model in all_models))  # pylint: disable=line-too-long

            self.assertEqual(True, any(
                model.recipient_id == self.new_user_id for model in all_models))  # pylint: disable=line-too-long
            self.assertEqual(True, any(
                model.recipient_email == self.NEW_USER_EMAIL for model in all_models))  # pylint: disable=line-too-long

            # No email model is stored for the user who has unsubscribed from
            # subscription emails.
            self.assertEqual(
                False,
                any(model.recipient_id == self.user_id_2
                    for model in all_models))
            self.assertEqual(False, any(
                model.recipient_email == self.USER_EMAIL_2 for model in all_models))  # pylint: disable=line-too-long
    def test_inform_subscribers(self):
        subscription_services.subscribe_to_creator(
            self.user_id_2, self.editor_id)
        subscription_services.subscribe_to_creator(
            self.new_user_id, self.editor_id)
        subscription_services.subscribe_to_creator(
            self.user_id, self.editor_id)

        email_preferences_model = user_models.UserEmailPreferencesModel.get(
            self.user_id_2, strict=False)
        if email_preferences_model is None:
            email_preferences_model = user_models.UserEmailPreferencesModel(
                id=self.user_id_2)

        email_preferences_model.subscription_notifications = False
        email_preferences_model.put()

        with self.can_send_emails_ctx, self.can_send_subscription_email_ctx:
            email_subscription_services.inform_subscribers(
                self.editor_id, 'A', 'Title')

            # make sure correct number of emails is sent and no email is sent
            # to the person who has unsubscribed from subscription emails.
            messages = self.mail_stub.get_sent_messages(to=self.NEW_USER_EMAIL)
            self.assertEqual(len(messages), 1)
            messages = self.mail_stub.get_sent_messages(to=self.USER_EMAIL)
            self.assertEqual(len(messages), 1)
            messages = self.mail_stub.get_sent_messages(to=self.USER_EMAIL_2)
            self.assertEqual(len(messages), 0)

            # Make sure correct email models are stored.
            all_models = email_models.SentEmailModel.get_all().fetch()
            self.assertEqual(True, any(
                model.recipient_id == self.user_id for model in all_models))
            self.assertEqual(True, any(
                model.recipient_email == self.USER_EMAIL for model in all_models)) # pylint: disable=line-too-long

            self.assertEqual(True, any(
                model.recipient_id == self.new_user_id for model in all_models)) # pylint: disable=line-too-long
            self.assertEqual(True, any(
                model.recipient_email == self.NEW_USER_EMAIL for model in all_models)) # pylint: disable=line-too-long

            # No email model is stored for the user who has unsubscribed from
            # subscription emails.
            self.assertEqual(False, any(
                model.recipient_id == self.user_id_2 for model in all_models))
            self.assertEqual(False, any(
                model.recipient_email == self.USER_EMAIL_2 for model in all_models)) # pylint: disable=line-too-long
Beispiel #16
0
 def post(self):
     creator_id = user_services.get_user_id_from_username(
         self.payload.get('creator_username'))
     subscription_services.subscribe_to_creator(self.user_id, creator_id)
     self.render_json(self.values)
 def test_exception_is_raised_when_user_self_subscribes(self):
     with self.assertRaisesRegexp(
             Exception,
             'User %s is not allowed to self subscribe.' % USER_ID):
         subscription_services.subscribe_to_creator(USER_ID, USER_ID)
 def test_exception_is_raised_when_user_self_subscribes(self) -> None:
     with self.assertRaisesRegex(  # type: ignore[no-untyped-call]
             Exception,
             'User %s is not allowed to self subscribe.' % USER_ID):
         subscription_services.subscribe_to_creator(USER_ID, USER_ID)
 def post(self):
     creator_id = user_services.get_user_id_from_username(
         self.payload.get('creator_username'))
     subscription_services.subscribe_to_creator(self.user_id, creator_id)
     self.render_json(self.values)