def test_preprint_contributor_signal_not_sent_one_contributor(self):
     with capture_signals() as mock_signals:
         private_project_payload = build_preprint_create_payload(self.private_project._id, self.subject._id,
                                                                self.file_one_private_project._id)
         res = self.app.post_json_api(self.url, private_project_payload, auth=self.user.auth)
         assert_equal(res.status_code, 201)
         assert_not_equal(mock_signals.signals_sent(), set([project_signals.contributor_added]))

    def test_preprint_contributor_signal_not_sent_on_creation(self):
        with capture_signals() as mock_signals:
            public_project_payload = build_preprint_create_payload(self.public_project._id, self.provider._id,
                                                                   self.file_one_public_project._id)
            res = self.app.post_json_api(self.url, public_project_payload, auth=self.user.auth)

            assert_equal(res.status_code, 201)
            assert_not_in(project_signals.contributor_added, mock_signals.signals_sent())

 def test_edit_sends_mention_added_signal_if_mentions(self):
     with capture_signals() as mock_signals:
         self.comment.edit(
             auth=self.auth,
             content="This is a comment with a bad mention [@Mentioned User](http://localhost:5000/"
             + self.comment.user._id
             + "/).",
             save=True,
         )
     assert_equal(mock_signals.signals_sent(), set([mention_added]))

 def test_create_sends_comment_added_signal(self, node, user, auth):
     with capture_signals() as mock_signals:
         Comment.create(
             auth=auth,
             user=user,
             node=node,
             target=node.guids.all()[0],
             content='This is a comment.'
         )
     assert mock_signals.signals_sent() == ({comment_added})

 def test_create_sends_mention_added_signal_if_mentions(self, node, user, auth):
     with capture_signals() as mock_signals:
         Comment.create(
             auth=auth,
             user=user,
             node=node,
             target=node.guids.all()[0],
             content='This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/' + user._id + '/).'
         )
     assert mock_signals.signals_sent() == ({comment_added, mention_added})

 def test_edit_sends_mention_added_signal_if_mentions(self):
     comment = CommentFactory()
     auth = Auth(comment.user)
     with capture_signals() as mock_signals:
         comment.edit(
             auth=auth,
             content='This is a comment with a bad mention [@Mentioned User](http://localhost:5000/' + comment.user._id + '/).',
             save=True
         )
     assert mock_signals.signals_sent() == ({mention_added})

 def test_edit_does_not_send_mention_added_signal_if_nonuser_mentioned(self):
     with assert_raises(ValidationValueError) as error:
         with capture_signals() as mock_signals:
             self.comment.edit(
                 auth=self.auth,
                 content="This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).",
                 save=True,
             )
     assert_equal(mock_signals.signals_sent(), set([]))
     assert_equal(error.exception.message, "User does not exist or is not active.")

 def test_edit_does_not_send_mention_added_signal_if_already_mentioned(self):
     comment = CommentFactory()
     auth = Auth(comment.user)
     with capture_signals() as mock_signals:
         comment.ever_mentioned.add(comment.user)
         comment.edit(
             auth=auth,
             content='This is a comment with a bad mention [@Already Mentioned User](http://localhost:5000/' + comment.user._id + '/).',
             save=True
         )
     assert mock_signals.signals_sent() == set([])

 def test_create_sends_comment_added_signal(self):
     with capture_signals() as mock_signals:
         comment = Comment.create(
             auth=self.auth,
             user=self.comment.user,
             node=self.comment.node,
             target=self.comment.target,
             is_public=True,
             content='This is a comment.'
         )
     assert_equal(mock_signals.signals_sent(), set([comment_added]))

 def test_edit_does_not_send_mention_added_signal_if_already_mentioned(self):
     with capture_signals() as mock_signals:
         self.comment.ever_mentioned = [self.comment.user._id]
         self.comment.edit(
             auth=self.auth,
             content="This is a comment with a bad mention [@Already Mentioned User](http://localhost:5000/"
             + self.comment.user._id
             + "/).",
             save=True,
         )
     assert_equal(mock_signals.signals_sent(), set([]))

 def test_edit_does_not_send_mention_added_signal_if_nonuser_mentioned(self):
     comment = CommentFactory()
     auth = Auth(comment.user)
     with pytest.raises(ValidationError) as error:
         with capture_signals() as mock_signals:
             comment.edit(
                 auth=auth,
                 content='This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).',
                 save=True
             )
     assert mock_signals.signals_sent() == set([])
     assert error.value.message == 'User does not exist or is not active.'

 def test_create_does_not_send_mention_added_signal_if_nonuser_mentioned(self, node, user, auth):
     with pytest.raises(ValidationError) as error:
         with capture_signals() as mock_signals:
             Comment.create(
                 auth=auth,
                 user=user,
                 node=node,
                 target=node.guids.all()[0],
                 content='This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).'
             )
     assert mock_signals.signals_sent() == set([])
     assert error.value.message == 'User does not exist or is not active.'

 def test_create_does_not_send_mention_added_signal_if_noncontributor_mentioned(self, node, user, auth):
     with pytest.raises(ValidationError) as error:
         with capture_signals() as mock_signals:
             user = UserFactory()
             Comment.create(
                 auth=auth,
                 user=user,
                 node=node,
                 target=node.guids.all()[0],
                 content='This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/' + user._id + '/).'
             )
     assert mock_signals.signals_sent() == set([])
     assert error.value.message == 'Mentioned user is not a contributor.'

    def test_preprint_contributor_signal_sent_on_creation(self):
        # Signal sent but bails out early without sending email
        with capture_signals() as mock_signals:
            payload = build_preprint_create_payload(
                provider_id=self.provider._id)
            res = self.app.post_json_api(
                self.url, payload, auth=self.user.auth)

            assert_equal(res.status_code, 201)
            assert_true(len(mock_signals.signals_sent()) == 1)
            assert_in(
                project_signals.contributor_added,
                mock_signals.signals_sent())

 def test_create_sends_mention_added_signal_if_mentions(self):
     with capture_signals() as mock_signals:
         comment = Comment.create(
             auth=self.auth,
             user=self.comment.user,
             node=self.comment.node,
             target=self.comment.target,
             is_public=True,
             content="This is a comment with a bad mention [@Unconfirmed User](http://localhost:5000/"
             + self.comment.user._id
             + "/).",
         )
     assert_equal(mock_signals.signals_sent(), set([comment_added, mention_added]))

 def test_removed_contrib_files_checked_in(self, app, node, file):
     write_contrib = AuthUserFactory()
     node.add_contributor(write_contrib, permissions=['read', 'write'])
     node.save()
     assert node.can_edit(user=write_contrib)
     file.checkout = write_contrib
     file.save()
     assert file.is_checked_out
     with capture_signals() as mock_signals:
         node.remove_contributor(write_contrib, auth=Auth(write_contrib))
     assert mock_signals.signals_sent() == set([contributor_removed])
     file.reload()
     assert not file.is_checked_out

 def test_edit_does_not_send_mention_added_signal_if_noncontributor_mentioned(self):
     comment = CommentFactory()
     auth = Auth(comment.user)
     with pytest.raises(ValidationError) as error:
         with capture_signals() as mock_signals:
             user = UserFactory()
             comment.edit(
                 auth=auth,
                 content='This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/' + user._id + '/).',
                 save=True
             )
     assert mock_signals.signals_sent() == set([])
     assert error.value.message == 'Mentioned user is not a contributor.'

 def test_removed_contrib_files_checked_in(self):
     user = AuthUserFactory()
     self.node.add_contributor(user, permissions=['read', 'write'])
     self.node.save()
     assert_true(self.node.can_edit(user=user))
     self.file.checkout = user
     self.file.save()
     assert_true(self.file.is_checked_out)
     with capture_signals() as mock_signals:
         self.node.remove_contributor(user, auth=Auth(user))
     assert_equal(mock_signals.signals_sent(), set([contributor_removed]))
     self.file.reload()
     assert_false(self.file.is_checked_out)

 def test_create_does_not_send_mention_added_signal_if_nonuser_mentioned(self):
     with assert_raises(ValidationValueError) as error:
         with capture_signals() as mock_signals:
             comment = Comment.create(
                 auth=self.auth,
                 user=self.comment.user,
                 node=self.comment.node,
                 target=self.comment.target,
                 is_public=True,
                 content="This is a comment with a bad mention [@Not a User](http://localhost:5000/qwert/).",
             )
     assert_equal(mock_signals.signals_sent(), set([]))
     assert_equal(error.exception.message, "User does not exist or is not active.")

 def test_edit_does_not_send_mention_added_signal_if_noncontributor_mentioned(self):
     with assert_raises(ValidationValueError) as error:
         with capture_signals() as mock_signals:
             user = UserFactory()
             self.comment.edit(
                 auth=self.auth,
                 content="This is a comment with a bad mention [@Non-contributor User](http://localhost:5000/"
                 + user._id
                 + "/).",
                 save=True,
             )
     assert_equal(mock_signals.signals_sent(), set([]))
     assert_equal(error.exception.message, "Mentioned user is not a contributor.")