Exemple #1
0
 def setUp(self):
     super(RegistrationEmbargoModelsTestCase, self).setUp()
     self.user = UserFactory()
     self.project = ProjectFactory(creator=self.user)
     self.registration = RegistrationFactory(project=self.project)
     self.embargo = EmbargoFactory(user=self.user)
     self.valid_embargo_end_date = datetime.datetime.utcnow(
     ) + datetime.timedelta(days=3)
 def setUp(self):
     super(RegistrationEmbargoModelsTestCase, self).setUp()
     self.user = UserFactory()
     self.project = ProjectFactory(creator=self.user)
     self.registration = RegistrationFactory(project=self.project)
     self.embargo = EmbargoFactory(user=self.user)
     self.valid_embargo_end_date = datetime.datetime.utcnow() + datetime.timedelta(days=3)
Exemple #3
0
 def test_state_can_be_set_to_complete(self):
     embargo = EmbargoFactory()
     embargo.state = Embargo.COMPLETED
     embargo.save()  # should pass validation
     assert_equal(embargo.state, Embargo.COMPLETED)
Exemple #4
0
 def test_state_can_be_set_to_complete(self):
     embargo = EmbargoFactory()
     embargo.state = Embargo.COMPLETED
     embargo.save()  # should pass validation
     assert_equal(embargo.state, Embargo.COMPLETED)
class RegistrationEmbargoModelsTestCase(OsfTestCase):
    def setUp(self):
        super(RegistrationEmbargoModelsTestCase, self).setUp()
        self.user = UserFactory()
        self.project = ProjectFactory(creator=self.user)
        self.registration = RegistrationFactory(project=self.project)
        self.embargo = EmbargoFactory(user=self.user)
        self.valid_embargo_end_date = datetime.datetime.utcnow() + datetime.timedelta(days=3)

    # Validator tests
    def test_invalid_state_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.embargo.state = 'not a valid state'
            self.embargo.save()

    # Node#_initiate_embargo tests
    def test__initiate_embargo_does_not_save_embargo(self):
        initial_count = Embargo.find().count()
        self.registration._initiate_embargo(
            self.user,
            self.valid_embargo_end_date,
            for_existing_registration=True
        )
        self.assertEqual(Embargo.find().count(), initial_count)

    def test__initiate_embargo_does_not_create_tokens_for_unregistered_admin(self):
        unconfirmed_user = UnconfirmedUserFactory()
        self.registration.contributors.append(unconfirmed_user)
        self.registration.add_permission(unconfirmed_user, 'admin', save=True)
        assert_true(self.registration.has_permission(unconfirmed_user, 'admin'))

        embargo = self.registration._initiate_embargo(
            self.user,
            self.valid_embargo_end_date,
            for_existing_registration=True
        )
        assert_true(self.user._id in embargo.approval_state)
        assert_false(unconfirmed_user._id in embargo.approval_state)

    def test__initiate_embargo_with_save_does_save_embargo(self):
        initial_count = Embargo.find().count()
        self.registration._initiate_embargo(
            self.user,
            self.valid_embargo_end_date,
            for_existing_registration=True,
            save=True
        )
        self.assertEqual(Embargo.find().count(), initial_count + 1)

    # Backref tests
    def test_embargo_initiator_has_backref(self):
        self.registration.embargo_registration(
            self.user,
            self.valid_embargo_end_date
        )
        self.registration.save()
        self.registration.reload()
        assert_equal(len(self.user.embargo__embargoed), 1)

    # Node#embargo_registration tests
    def test_embargo_from_non_admin_raises_PermissionsError(self):
        self.registration.remove_permission(self.user, 'admin')
        self.registration.save()
        self.registration.reload()
        with assert_raises(PermissionsError):
            self.registration.embargo_registration(self.user, self.valid_embargo_end_date)

    def test_embargo_end_date_in_past_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.registration.embargo_registration(
                self.user,
                datetime.datetime(1999, 1, 1)
            )

    def test_embargo_end_date_today_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.registration.embargo_registration(
                self.user,
                datetime.datetime.utcnow()
            )

    def test_embargo_end_date_in_far_future_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.registration.embargo_registration(
                self.user,
                datetime.datetime(2099, 1, 1)
            )

    def test_embargo_with_valid_end_date_starts_pending_embargo(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)

    def test_embargo_public_project_makes_private_pending_embargo(self):
        self.registration.is_public = True
        assert_true(self.registration.is_public)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)
        assert_false(self.registration.is_public)

    def test_embargo_non_registration_raises_NodeStateError(self):
        self.registration.is_registration = False
        self.registration.save()
        with assert_raises(NodeStateError):
            self.registration.embargo_registration(
                self.user,
                datetime.datetime.utcnow() + datetime.timedelta(days=10)
            )
        assert_false(self.registration.pending_embargo)

    # Embargo#approve_embargo tests
    def test_invalid_approval_token_raises_InvalidEmbargoApprovalToken(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        invalid_approval_token = 'not a real token'
        with assert_raises(InvalidEmbargoApprovalToken):
            self.registration.embargo.approve_embargo(self.user, invalid_approval_token)
        assert_true(self.registration.pending_embargo)
        assert_false(self.registration.embargo_end_date)

    def test_non_admin_approval_token_raises_PermissionsError(self):
        non_admin = UserFactory()
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        approval_token = self.registration.embargo.approval_state[self.user._id]['approval_token']
        with assert_raises(PermissionsError):
            self.registration.embargo.approve_embargo(non_admin, approval_token)
        assert_true(self.registration.pending_embargo)

    def test_one_approval_with_one_admin_embargoes(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        approval_token = self.registration.embargo.approval_state[self.user._id]['approval_token']
        self.registration.embargo.approve_embargo(self.user, approval_token)
        assert_true(self.registration.embargo_end_date)
        assert_false(self.registration.pending_embargo)

    def test_approval_adds_to_parent_projects_log(self):
        initial_project_logs = len(self.registration.registered_from.logs)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()

        approval_token = self.registration.embargo.approval_state[self.user._id]['approval_token']
        self.registration.embargo.approve_embargo(self.user, approval_token)
        # Logs: Created, registered, embargo initiated, embargo approved
        assert_equal(len(self.registration.registered_from.logs), initial_project_logs + 2)

    def test_one_approval_with_two_admins_stays_pending(self):
        admin2 = UserFactory()
        self.registration.contributors.append(admin2)
        self.registration.add_permission(admin2, 'admin', save=True)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()

        # First admin approves
        approval_token = self.registration.embargo.approval_state[self.user._id]['approval_token']
        self.registration.embargo.approve_embargo(self.user, approval_token)
        assert_true(self.registration.pending_embargo)
        num_of_approvals = sum([val['has_approved'] for val in self.registration.embargo.approval_state.values()])
        assert_equal(num_of_approvals, 1)

        # Second admin approves
        approval_token = self.registration.embargo.approval_state[admin2._id]['approval_token']
        self.registration.embargo.approve_embargo(admin2, approval_token)
        assert_true(self.registration.embargo_end_date)
        assert_false(self.registration.pending_embargo)
        num_of_approvals = sum([val['has_approved'] for val in self.registration.embargo.approval_state.values()])
        assert_equal(num_of_approvals, 2)

    # Embargo#disapprove_embargo tests
    def test_invalid_disapproval_token_raises_InvalidEmbargoDisapprovalToken(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)
        with assert_raises(InvalidEmbargoDisapprovalToken):
            self.registration.embargo.disapprove_embargo(self.user, fake.sentence())
        assert_true(self.registration.pending_embargo)
        assert_false(self.registration.embargo_end_date)

    def test_non_admin_disapproval_token_raises_PermissionsError(self):
        non_admin = UserFactory()
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        disapproval_token = self.registration.embargo.approval_state[self.user._id]['disapproval_token']
        with assert_raises(PermissionsError):
            self.registration.embargo.disapprove_embargo(non_admin, disapproval_token)
        assert_true(self.registration.pending_embargo)

    def test_one_disapproval_cancels_embargo(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        disapproval_token = self.registration.embargo.approval_state[self.user._id]['disapproval_token']
        self.registration.embargo.disapprove_embargo(self.user, disapproval_token)
        assert_equal(self.registration.embargo.state, Embargo.CANCELLED)
        assert_false(self.registration.pending_embargo)
        assert_false(self.registration.embargo_end_date)

    def test_disapproval_adds_to_parent_projects_log(self):
        initial_project_logs = len(self.registration.registered_from.logs)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()

        disapproval_token = self.registration.embargo.approval_state[self.user._id]['disapproval_token']
        registered_from = self.registration.registered_from
        self.registration.embargo.disapprove_embargo(self.user, disapproval_token)
        # Logs: Created, registered, embargo initiated, embargo cancelled
        assert_equal(len(registered_from.logs), initial_project_logs + 2)

    def test_cancelling_embargo_deletes_parent_registration(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()

        disapproval_token = self.registration.embargo.approval_state[self.user._id]['disapproval_token']
        self.registration.embargo.disapprove_embargo(self.user, disapproval_token)
        assert_equal(self.registration.embargo.state, Embargo.CANCELLED)
        assert_true(self.registration.is_deleted)

    def test_cancelling_embargo_for_existing_registration_does_not_delete_registration(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10),
            for_existing_registration=True
        )
        self.registration.save()

        disapproval_token = self.registration.embargo.approval_state[self.user._id]['disapproval_token']
        self.registration.embargo.disapprove_embargo(self.user, disapproval_token)
        assert_equal(self.registration.embargo.state, Embargo.CANCELLED)
        assert_false(self.registration.is_deleted)

    # Embargo property tests
    def test_new_registration_is_pending_registration(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10)
        )
        self.registration.save()
        assert_true(self.registration.pending_registration)

    def test_existing_registration_is_not_pending_registration(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10),
            for_existing_registration=True
        )
        self.registration.save()
        assert_false(self.registration.pending_registration)
Exemple #6
0
class RegistrationEmbargoModelsTestCase(OsfTestCase):
    def setUp(self):
        super(RegistrationEmbargoModelsTestCase, self).setUp()
        self.user = UserFactory()
        self.project = ProjectFactory(creator=self.user)
        self.registration = RegistrationFactory(project=self.project)
        self.embargo = EmbargoFactory(user=self.user)
        self.valid_embargo_end_date = datetime.datetime.utcnow(
        ) + datetime.timedelta(days=3)

    # Validator tests
    def test_invalid_state_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.embargo.state = 'not a valid state'
            self.embargo.save()

    # Node#_initiate_embargo tests
    def test__initiate_embargo_does_not_save_embargo(self):
        initial_count = Embargo.find().count()
        self.registration._initiate_embargo(self.user,
                                            self.valid_embargo_end_date,
                                            for_existing_registration=True)
        self.assertEqual(Embargo.find().count(), initial_count)

    def test__initiate_embargo_does_not_create_tokens_for_unregistered_admin(
            self):
        unconfirmed_user = UnconfirmedUserFactory()
        self.registration.contributors.append(unconfirmed_user)
        self.registration.add_permission(unconfirmed_user, 'admin', save=True)
        assert_true(self.registration.has_permission(unconfirmed_user,
                                                     'admin'))

        embargo = self.registration._initiate_embargo(
            self.user,
            self.valid_embargo_end_date,
            for_existing_registration=True)
        assert_true(self.user._id in embargo.approval_state)
        assert_false(unconfirmed_user._id in embargo.approval_state)

    def test__initiate_embargo_with_save_does_save_embargo(self):
        initial_count = Embargo.find().count()
        self.registration._initiate_embargo(self.user,
                                            self.valid_embargo_end_date,
                                            for_existing_registration=True,
                                            save=True)
        self.assertEqual(Embargo.find().count(), initial_count + 1)

    # Backref tests
    def test_embargo_initiator_has_backref(self):
        self.registration.embargo_registration(self.user,
                                               self.valid_embargo_end_date)
        self.registration.save()
        self.registration.reload()
        assert_equal(len(self.user.embargo__embargoed), 1)

    # Node#embargo_registration tests
    def test_embargo_from_non_admin_raises_PermissionsError(self):
        self.registration.remove_permission(self.user, 'admin')
        self.registration.save()
        self.registration.reload()
        with assert_raises(PermissionsError):
            self.registration.embargo_registration(self.user,
                                                   self.valid_embargo_end_date)

    def test_embargo_end_date_in_past_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.registration.embargo_registration(
                self.user, datetime.datetime(1999, 1, 1))

    def test_embargo_end_date_today_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.registration.embargo_registration(self.user,
                                                   datetime.datetime.utcnow())

    def test_embargo_end_date_in_far_future_raises_ValidationValueError(self):
        with assert_raises(ValidationValueError):
            self.registration.embargo_registration(
                self.user, datetime.datetime(2099, 1, 1))

    def test_embargo_with_valid_end_date_starts_pending_embargo(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)

    def test_embargo_public_project_makes_private_pending_embargo(self):
        self.registration.is_public = True
        assert_true(self.registration.is_public)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)
        assert_false(self.registration.is_public)

    def test_embargo_non_registration_raises_NodeStateError(self):
        self.registration.is_registration = False
        self.registration.save()
        with assert_raises(NodeStateError):
            self.registration.embargo_registration(
                self.user,
                datetime.datetime.utcnow() + datetime.timedelta(days=10))
        assert_false(self.registration.pending_embargo)

    # Embargo#approve_embargo tests
    def test_invalid_approval_token_raises_InvalidEmbargoApprovalToken(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        invalid_approval_token = 'not a real token'
        with assert_raises(InvalidEmbargoApprovalToken):
            self.registration.embargo.approve_embargo(self.user,
                                                      invalid_approval_token)
        assert_true(self.registration.pending_embargo)
        assert_false(self.registration.embargo_end_date)

    def test_non_admin_approval_token_raises_PermissionsError(self):
        non_admin = UserFactory()
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        approval_token = self.registration.embargo.approval_state[
            self.user._id]['approval_token']
        with assert_raises(PermissionsError):
            self.registration.embargo.approve_embargo(non_admin,
                                                      approval_token)
        assert_true(self.registration.pending_embargo)

    def test_one_approval_with_one_admin_embargoes(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        approval_token = self.registration.embargo.approval_state[
            self.user._id]['approval_token']
        self.registration.embargo.approve_embargo(self.user, approval_token)
        assert_true(self.registration.embargo_end_date)
        assert_false(self.registration.pending_embargo)

    def test_approval_adds_to_parent_projects_log(self):
        initial_project_logs = len(self.registration.registered_from.logs)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()

        approval_token = self.registration.embargo.approval_state[
            self.user._id]['approval_token']
        self.registration.embargo.approve_embargo(self.user, approval_token)
        # Logs: Created, registered, embargo initiated, embargo approved
        assert_equal(len(self.registration.registered_from.logs),
                     initial_project_logs + 2)

    def test_one_approval_with_two_admins_stays_pending(self):
        admin2 = UserFactory()
        self.registration.contributors.append(admin2)
        self.registration.add_permission(admin2, 'admin', save=True)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()

        # First admin approves
        approval_token = self.registration.embargo.approval_state[
            self.user._id]['approval_token']
        self.registration.embargo.approve_embargo(self.user, approval_token)
        assert_true(self.registration.pending_embargo)
        num_of_approvals = sum([
            val['has_approved']
            for val in self.registration.embargo.approval_state.values()
        ])
        assert_equal(num_of_approvals, 1)

        # Second admin approves
        approval_token = self.registration.embargo.approval_state[
            admin2._id]['approval_token']
        self.registration.embargo.approve_embargo(admin2, approval_token)
        assert_true(self.registration.embargo_end_date)
        assert_false(self.registration.pending_embargo)
        num_of_approvals = sum([
            val['has_approved']
            for val in self.registration.embargo.approval_state.values()
        ])
        assert_equal(num_of_approvals, 2)

    # Embargo#disapprove_embargo tests
    def test_invalid_disapproval_token_raises_InvalidEmbargoDisapprovalToken(
            self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)
        with assert_raises(InvalidEmbargoDisapprovalToken):
            self.registration.embargo.disapprove_embargo(
                self.user, fake.sentence())
        assert_true(self.registration.pending_embargo)
        assert_false(self.registration.embargo_end_date)

    def test_non_admin_disapproval_token_raises_PermissionsError(self):
        non_admin = UserFactory()
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        disapproval_token = self.registration.embargo.approval_state[
            self.user._id]['disapproval_token']
        with assert_raises(PermissionsError):
            self.registration.embargo.disapprove_embargo(
                non_admin, disapproval_token)
        assert_true(self.registration.pending_embargo)

    def test_one_disapproval_cancels_embargo(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_embargo)

        disapproval_token = self.registration.embargo.approval_state[
            self.user._id]['disapproval_token']
        self.registration.embargo.disapprove_embargo(self.user,
                                                     disapproval_token)
        assert_equal(self.registration.embargo.state, Embargo.CANCELLED)
        assert_false(self.registration.pending_embargo)
        assert_false(self.registration.embargo_end_date)

    def test_disapproval_adds_to_parent_projects_log(self):
        initial_project_logs = len(self.registration.registered_from.logs)
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()

        disapproval_token = self.registration.embargo.approval_state[
            self.user._id]['disapproval_token']
        registered_from = self.registration.registered_from
        self.registration.embargo.disapprove_embargo(self.user,
                                                     disapproval_token)
        # Logs: Created, registered, embargo initiated, embargo cancelled
        assert_equal(len(registered_from.logs), initial_project_logs + 2)

    def test_cancelling_embargo_deletes_parent_registration(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()

        disapproval_token = self.registration.embargo.approval_state[
            self.user._id]['disapproval_token']
        self.registration.embargo.disapprove_embargo(self.user,
                                                     disapproval_token)
        assert_equal(self.registration.embargo.state, Embargo.CANCELLED)
        assert_true(self.registration.is_deleted)

    def test_cancelling_embargo_for_existing_registration_does_not_delete_registration(
            self):
        self.registration.embargo_registration(self.user,
                                               datetime.datetime.utcnow() +
                                               datetime.timedelta(days=10),
                                               for_existing_registration=True)
        self.registration.save()

        disapproval_token = self.registration.embargo.approval_state[
            self.user._id]['disapproval_token']
        self.registration.embargo.disapprove_embargo(self.user,
                                                     disapproval_token)
        assert_equal(self.registration.embargo.state, Embargo.CANCELLED)
        assert_false(self.registration.is_deleted)

    # Embargo property tests
    def test_new_registration_is_pending_registration(self):
        self.registration.embargo_registration(
            self.user,
            datetime.datetime.utcnow() + datetime.timedelta(days=10))
        self.registration.save()
        assert_true(self.registration.pending_registration)

    def test_existing_registration_is_not_pending_registration(self):
        self.registration.embargo_registration(self.user,
                                               datetime.datetime.utcnow() +
                                               datetime.timedelta(days=10),
                                               for_existing_registration=True)
        self.registration.save()
        assert_false(self.registration.pending_registration)