def test_retractions_display_limited_fields(self):
        registration = RegistrationFactory(creator=self.user,
                                           project=self.public_project,
                                           public=True)
        url = '/{}registrations/{}/'.format(API_BASE, registration._id)
        retraction = RetractedRegistrationFactory(registration=registration,
                                                  user=registration.creator)
        retraction.justification = 'We made a major error.'
        retraction.save()
        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.status_code, 200)

        assert_items_equal(
            res.json['data']['attributes'], {
                'title': registration.title,
                'description': registration.description,
                'date_created': registration.date_created,
                'date_registered': registration.registered_date,
                'retraction_justification':
                registration.retraction.justification,
                'public': None,
                'category': None,
                'date_modified': None,
                "registration": True,
                'fork': None,
                'collection': None,
                'dashboard': None,
                'tags': None,
                'retracted': True,
                'pending_retraction': None,
                'pending_registration_approval': None,
                "pending_embargo": None,
                "registered_meta": None,
                "registration_supplement":
                registration.registered_meta.keys()[0]
            })

        contributors = urlparse(
            res.json['data']['relationships']['contributors']['links']
            ['related']['href']).path
        assert_equal(
            contributors,
            '/{}registrations/{}/contributors/'.format(API_BASE,
                                                       registration._id))

        assert_not_in('children', res.json['data']['relationships'])
        assert_not_in('comments', res.json['data']['relationships'])
        assert_not_in('node_links', res.json['data']['relationships'])
        assert_not_in('registrations', res.json['data']['relationships'])
        assert_not_in('parent', res.json['data']['relationships'])
        assert_not_in('forked_from', res.json['data']['relationships'])
        assert_not_in('files', res.json['data']['relationships'])
        assert_not_in('logs', res.json['data']['relationships'])
Example #2
0
 def test_cannot_access_retracted_files_list(self):
     registration = RegistrationFactory(creator=self.user,
                                        project=self.public_project)
     url = '/{}nodes/{}/files/'.format(API_BASE, registration._id)
     retraction = RetractedRegistrationFactory(registration=registration,
                                               user=registration.creator)
     res = self.app.get(url, auth=self.user.auth, expect_errors=True)
     assert_equal(res.status_code, 404)
    def test_retractions_display_limited_fields(self):
        registration = RegistrationFactory(creator=self.user, project=self.public_project, public=True)
        url = "/{}registrations/{}/".format(API_BASE, registration._id)
        retraction = RetractedRegistrationFactory(registration=registration, user=registration.creator)
        retraction.justification = "We made a major error."
        retraction.save()
        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.status_code, 200)

        assert_items_equal(
            res.json["data"]["attributes"],
            {
                "title": registration.title,
                "description": registration.description,
                "date_created": registration.date_created,
                "date_registered": registration.registered_date,
                "retraction_justification": registration.retraction.justification,
                "public": None,
                "category": None,
                "date_modified": None,
                "registration": True,
                "fork": None,
                "collection": None,
                "dashboard": None,
                "tags": None,
                "retracted": True,
                "pending_retraction": None,
                "pending_registration_approval": None,
                "pending_embargo": None,
                "registered_meta": None,
                "registration_supplement": registration.registered_meta.keys()[0],
            },
        )

        contributors = urlparse(res.json["data"]["relationships"]["contributors"]["links"]["related"]["href"]).path
        assert_equal(contributors, "/{}registrations/{}/contributors/".format(API_BASE, registration._id))

        assert_not_in("children", res.json["data"]["relationships"])
        assert_not_in("comments", res.json["data"]["relationships"])
        assert_not_in("node_links", res.json["data"]["relationships"])
        assert_not_in("registrations", res.json["data"]["relationships"])
        assert_not_in("parent", res.json["data"]["relationships"])
        assert_not_in("forked_from", res.json["data"]["relationships"])
        assert_not_in("files", res.json["data"]["relationships"])
        assert_not_in("logs", res.json["data"]["relationships"])
Example #4
0
 def test_cannot_delete_a_retraction(self):
     registration = RegistrationFactory(creator=self.user, project=self.public_project)
     url = '/{}nodes/{}/'.format(API_BASE, registration._id)
     retraction = RetractedRegistrationFactory(registration=registration, user=registration.creator)
     res = self.app.delete_json_api(url, auth=self.user.auth, expect_errors=True)
     registration.reload()
     assert_equal(res.status_code, 404)
     assert_equal(registration.title, registration.title)
     assert_equal(registration.description, registration.description)
    def test_retractions_display_limited_fields(self):
        registration = RegistrationFactory(creator=self.user, project=self.public_project, public=True)
        url = '/{}registrations/{}/'.format(API_BASE, registration._id)
        retraction = RetractedRegistrationFactory(registration=registration, user=registration.creator)
        retraction.justification = 'We made a major error.'
        retraction.save()
        res = self.app.get(url, auth=self.user.auth)
        assert_equal(res.status_code, 200)

        assert_items_equal(res.json['data']['attributes'], {
            'title': registration.title,
            'description': registration.description,
            'date_created': registration.date_created,
            'date_registered': registration.registered_date,
            'retraction_justification': registration.retraction.justification,
            'public': None,
            'category': None,
            'date_modified': None,
            "registration": True,
            'fork': None,
            'collection': None,
            'dashboard': None,
            'tags': None,
            'retracted': True,
            'pending_retraction': None,
            'pending_registration_approval': None,
            'pending_embargo_approval': None,
            "embargo_end_date": None,
            "registered_meta": None,
            'current_user_permissions': None,
            "registration_supplement": registration.registered_meta.keys()[0]
        })

        contributors = urlparse(res.json['data']['relationships']['contributors']['links']['related']['href']).path
        assert_equal(contributors, '/{}registrations/{}/contributors/'.format(API_BASE, registration._id))

        assert_not_in('children', res.json['data']['relationships'])
        assert_not_in('comments', res.json['data']['relationships'])
        assert_not_in('node_links', res.json['data']['relationships'])
        assert_not_in('registrations', res.json['data']['relationships'])
        assert_not_in('parent', res.json['data']['relationships'])
        assert_not_in('forked_from', res.json['data']['relationships'])
        assert_not_in('files', res.json['data']['relationships'])
        assert_not_in('logs', res.json['data']['relationships'])
    def setUp(self):
        self.maxDiff = None
        super(TestRegistrationDetail, self).setUp()
        self.user = AuthUserFactory()

        self.user_two = AuthUserFactory()

        self.public_project = ProjectFactory(title="Project One", is_public=True, creator=self.user)
        self.private_project = ProjectFactory(title="Project Two", is_public=False, creator=self.user)
        self.public_registration = RegistrationFactory(project=self.public_project, creator=self.user, is_public=True)
        self.private_registration = RegistrationFactory(project=self.private_project, creator=self.user)
        self.public_url = '/{}registrations/{}/'.format(API_BASE, self.public_registration._id)
        self.private_url = '/{}registrations/{}/'.format(API_BASE, self.private_registration._id)

        self.retraction_registration = RegistrationFactory(creator=self.user, project=self.public_project, public=True)
        self.retraction_url = '/{}registrations/{}/'.format(API_BASE, self.retraction_registration._id)
        retraction = RetractedRegistrationFactory(registration=self.retraction_registration, user=self.retraction_registration.creator)
        retraction.justification = 'We made a major error.'
        retraction.save()
 def test_cannot_access_retracted_comments(self):
     self.public_project = ProjectFactory(is_public=True, creator=self.user)
     self.public_comment = CommentFactory(node=self.public_project,
                                          user=self.user)
     registration = RegistrationFactory(creator=self.user,
                                        project=self.public_project)
     url = '/{}nodes/{}/comments/'.format(API_BASE, registration._id)
     retraction = RetractedRegistrationFactory(registration=registration,
                                               user=self.user)
     res = self.app.get(url, auth=self.user.auth, expect_errors=True)
     assert_equal(res.status_code, 404)
    def test_doesnt_return_retractions_with_auth(self):
        retraction = RetractedRegistrationFactory(
            registration=self.registration2, user=self.user1)

        assert_true(self.registration2.is_retracted)

        res = self.app.get(self.institution_node_url, auth=self.user1.auth)

        assert_equal(res.status_code, 200)
        ids = [each['id'] for each in res.json['data']]

        assert_not_in(self.registration2._id, ids)
Example #9
0
 def test_cannot_update_a_retraction(self):
     registration = RegistrationFactory(creator=self.user, project=self.public_project)
     url = '/{}nodes/{}/'.format(API_BASE, registration._id)
     retraction = RetractedRegistrationFactory(registration=registration, user=registration.creator)
     res = self.app.put_json_api(url, {
         'data': {
             'id': registration._id,
             'type': 'nodes',
             'attributes': {
                 'title': fake.catch_phrase(),
                 'description': fake.bs(),
                 'category': 'hypothesis',
                 'public': True
             }
         }
     }, auth=self.user.auth, expect_errors=True)
     registration.reload()
     assert_equal(res.status_code, 404)
     assert_equal(registration.title, registration.title)
     assert_equal(registration.description, registration.description)