def test_log_create_on_private_project(self): res = self.app.get(self.private_url, auth=self.user.auth) assert_equal(res.status_code, 200) assert_equal(len(res.json['data']), len(self.public_project.logs)) assert_datetime_equal(parse_date(res.json['data'][API_FIRST]['attributes']['date']), self.private_project.logs[OSF_FIRST].date) assert_equal(res.json['data'][API_FIRST]['attributes']['action'], self.private_project.logs[OSF_FIRST].action)
def test_project_creation(self, app, user, public_project, private_project, public_url, private_url): # test_project_created res = app.get(public_url) assert res.status_code == 200 assert len(res.json['data']) == public_project.logs.count() assert public_project.logs.first().action == 'project_created' assert public_project.logs.first( ).action == res.json['data'][API_LATEST]['attributes']['action'] # test_log_create_on_public_project res = app.get(public_url) assert res.status_code == 200 assert len(res.json['data']) == public_project.logs.count() assert_datetime_equal( parse_date(res.json['data'][API_FIRST]['attributes']['date']), public_project.logs.first().date) assert res.json['data'][API_FIRST]['attributes'][ 'action'] == public_project.logs.first().action # test_log_create_on_private_project res = app.get(private_url, auth=user.auth) assert res.status_code == 200 assert len(res.json['data']) == public_project.logs.count() assert_datetime_equal( parse_date(res.json['data'][API_FIRST]['attributes']['date']), private_project.logs.first().date) assert res.json['data'][API_FIRST]['attributes'][ 'action'] == private_project.logs.first().action
def test_log_create_on_private_project(self): res = self.app.get(self.private_url, auth=self.user.auth) assert_equal(res.status_code, 200) assert_equal(len(res.json['data']), len(self.public_project.logs)) assert_datetime_equal(datetime.datetime.strptime(res.json['data'][API_FIRST]['attributes']['date'], "%Y-%m-%dT%H:%M:%S.%f"), self.private_project.logs[OSF_FIRST].date) assert_equal(res.json['data'][API_FIRST]['attributes']['action'], self.private_project.logs[OSF_FIRST].action)
def test_serialization(self): user = UserFactory() req = make_drf_request() reg = RegistrationFactory(creator=user) result = RegistrationSerializer(reg, context={'request': req}).data data = result['data'] assert_equal(data['id'], reg._id) assert_equal(data['type'], 'registrations') # Attributes attributes = data['attributes'] assert_datetime_equal( parse_date(attributes['date_registered']), reg.registered_date ) assert_equal(attributes['retracted'], reg.is_retracted) # Relationships relationships = data['relationships'] assert_in('registered_by', relationships) registered_by = relationships['registered_by']['links']['related']['href'] assert_equal( urlparse(registered_by).path, '/{}users/{}/'.format(API_BASE, user._id) ) assert_in('registered_from', relationships) registered_from = relationships['registered_from']['links']['related']['href'] assert_equal( urlparse(registered_from).path, '/{}nodes/{}/'.format(API_BASE, reg.registered_from._id) )
def test_serialization(self): user = UserFactory() req = make_drf_request() reg = RegistrationFactory(creator=user) result = RegistrationSerializer(reg, context={"request": req}).data data = result["data"] assert_equal(data["id"], reg._id) assert_equal(data["type"], "registrations") should_not_relate_to_registrations = ["registered_from", "registered_by", "registration_schema"] # Attributes attributes = data["attributes"] assert_datetime_equal(parse_date(attributes["date_registered"]), reg.registered_date) assert_equal(attributes["withdrawn"], reg.is_retracted) # Relationships relationships = data["relationships"] relationship_urls = {} for relationship in relationships: relationship_urls[relationship] = relationships[relationship]["links"]["related"]["href"] assert_in("registered_by", relationships) registered_by = relationships["registered_by"]["links"]["related"]["href"] assert_equal(urlparse(registered_by).path, "/{}users/{}/".format(API_BASE, user._id)) assert_in("registered_from", relationships) registered_from = relationships["registered_from"]["links"]["related"]["href"] assert_equal(urlparse(registered_from).path, "/{}nodes/{}/".format(API_BASE, reg.registered_from._id)) for relationship in relationship_urls: if relationship in should_not_relate_to_registrations: assert_not_in("/{}registrations/".format(API_BASE), relationship_urls[relationship]) else: assert_in( "/{}registrations/".format(API_BASE), relationship_urls[relationship], "For key {}".format(relationship), )
def test_serialization(self): user = UserFactory() req = make_drf_request() reg = RegistrationFactory(creator=user) result = RegistrationSerializer(reg, context={'request': req}).data data = result['data'] assert_equal(data['id'], reg._id) assert_equal(data['type'], 'registrations') # Attributes attributes = data['attributes'] assert_datetime_equal(parse_date(attributes['date_registered']), reg.registered_date) assert_equal(attributes['retracted'], reg.is_retracted) # Relationships relationships = data['relationships'] assert_in('registered_by', relationships) registered_by = relationships['registered_by']['links']['related'][ 'href'] assert_equal( urlparse(registered_by).path, '/{}users/{}/'.format(API_BASE, user._id)) assert_in('registered_from', relationships) registered_from = relationships['registered_from']['links']['related'][ 'href'] assert_equal( urlparse(registered_from).path, '/{}nodes/{}/'.format(API_BASE, reg.registered_from._id))
def test_project_creation( self, app, user, public_project, private_project, public_url, private_url): # test_project_created res = app.get(public_url) assert res.status_code == 200 assert len(res.json['data']) == public_project.logs.count() assert public_project.logs.first().action == 'project_created' assert public_project.logs.first( ).action == res.json['data'][API_LATEST]['attributes']['action'] # test_log_create_on_public_project res = app.get(public_url) assert res.status_code == 200 assert len(res.json['data']) == public_project.logs.count() assert_datetime_equal( parse_date( res.json['data'][API_FIRST]['attributes']['date']), public_project.logs.first().date) assert res.json['data'][API_FIRST]['attributes']['action'] == public_project.logs.first( ).action # test_log_create_on_private_project res = app.get(private_url, auth=user.auth) assert res.status_code == 200 assert len(res.json['data']) == public_project.logs.count() assert_datetime_equal( parse_date( res.json['data'][API_FIRST]['attributes']['date']), private_project.logs.first().date) assert res.json['data'][API_FIRST]['attributes']['action'] == private_project.logs.first( ).action
def test_log_create_on_public_project(self): res = self.app.get(self.public_url) assert_equal(res.status_code, 200) assert_equal(len(res.json['data']), len(self.public_project.logs)) assert_datetime_equal(parse_date(res.json['data'][API_FIRST]['attributes']['date']), self.public_project.logs[OSF_FIRST].date) assert_equal(res.json['data'][API_FIRST]['attributes']['action'], self.public_project.logs[OSF_FIRST].action)
def test_view_comments_updates_user_comments_view_timestamp_files(self): osfstorage = self.project.get_addon('osfstorage') root_node = osfstorage.get_root() test_file = root_node.append_file('test_file') test_file.create_version( self.user, { 'object': '06d80e', 'service': 'cloud', osfstorage_settings.WATERBUTLER_RESOURCE: 'osf', }, { 'size': 1337, 'contentType': 'img/png' }).save() url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'files', 'rootId': test_file._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[ self.project._id]['files'][test_file._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
def test_from_iso_with_tz(): d = central.localize(dt.datetime.now()) formatted = d.isoformat() result = utils.from_iso(formatted) assert_datetime_equal(result, d) if utils.dateutil_available: # Note a naive datetime assert result.tzinfo is not None
def test_from_iso_with_tz(): d = central.localize(dt.datetime.now()) formatted = d.isoformat() result = utils.from_iso_datetime(formatted) assert_datetime_equal(result, d) if utils.dateutil_available: # Note a naive datetime assert result.tzinfo is not None
def test_view_project_comments_updates_user_comments_view_timestamp(self): url = self.project.api_url_for("update_comments_timestamp") res = self.app.put_json(url, {"page": "node", "rootId": self.project._id}, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[self.project._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
def test_localdatetime_field_deserialization(self): dtime = dt.datetime.now() localized_dtime = central.localize(dtime) field = fields.DateTime(format='iso') result = field.deserialize(localized_dtime.isoformat()) assert_datetime_equal(result, dtime) # If dateutil is used, the datetime will not be naive if utils.dateutil_available: assert result.tzinfo is not None
def test_log_create_on_public_project(self): res = self.app.get(self.public_url) assert_equal(res.status_code, 200) assert_equal(len(res.json['data']), self.public_project.logs.count()) assert_datetime_equal( parse_date(res.json['data'][API_FIRST]['attributes']['date']), self.public_project.logs.first().date) assert_equal(res.json['data'][API_FIRST]['attributes']['action'], self.public_project.logs.first().action)
def test_serialization(self): user = UserFactory() versioned_request = make_drf_request_with_version(version='2.2') registration = RegistrationFactory(creator=user) result = RegistrationSerializer(registration, context={ 'request': versioned_request }).data data = result['data'] assert data['id'] == registration._id assert data['type'] == 'registrations' should_not_relate_to_registrations = [ 'registered_from', 'registered_by', 'registration_schema', 'region', 'provider', 'storage', 'groups', 'original_response', 'latest_response', ] # Attributes attributes = data['attributes'] assert_datetime_equal(parse_date(attributes['date_registered']), registration.registered_date) assert attributes['withdrawn'] == registration.is_retracted # Relationships relationships = data['relationships'] # Relationships with data relationship_urls = { k: v['links']['related']['href'] for k, v in relationships.items() } assert 'registered_by' in relationships registered_by = relationships['registered_by']['links']['related'][ 'href'] assert urlparse(registered_by).path == '/{}users/{}/'.format( API_BASE, user._id) assert 'registered_from' in relationships registered_from = relationships['registered_from']['links']['related'][ 'href'] assert urlparse(registered_from).path == '/{}nodes/{}/'.format( API_BASE, registration.registered_from._id) api_registrations_url = '/{}registrations/'.format(API_BASE) for relationship in relationship_urls: if relationship in should_not_relate_to_registrations: assert api_registrations_url not in relationship_urls[ relationship] else: assert api_registrations_url in relationship_urls[ relationship], 'For key {}'.format(relationship)
def test_log_create_on_public_project(self): res = self.app.get(self.public_url) assert_equal(res.status_code, 200) assert_equal(len(res.json['data']), len(self.public_project.logs)) assert_datetime_equal( datetime.datetime.strptime( res.json['data'][API_FIRST]['attributes']['date'], "%Y-%m-%dT%H:%M:%S.%f"), self.public_project.logs[OSF_FIRST].date) assert_equal(res.json['data'][API_FIRST]['attributes']['action'], self.public_project.logs[OSF_FIRST].action)
def test_view_project_comments_updates_user_comments_view_timestamp(self): url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'node', 'rootId': self.project._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[self.project._id]['node'] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
def test_view_project_comments_updates_user_comments_view_timestamp(self): url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'node', 'rootId': self.project._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[self.project._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
def test_serialization(self): user = UserFactory() versioned_request = make_drf_request_with_version(version='2.2') registration = RegistrationFactory(creator=user) result = RegistrationSerializer( registration, context={ 'request': versioned_request}).data data = result['data'] assert data['id'] == registration._id assert data['type'] == 'registrations' should_not_relate_to_registrations = [ 'registered_from', 'registered_by', 'registration_schema', 'region', 'provider', ] # Attributes attributes = data['attributes'] assert_datetime_equal( parse_date(attributes['date_registered']), registration.registered_date ) assert attributes['withdrawn'] == registration.is_retracted # Relationships relationships = data['relationships'] # Relationships with data relationship_urls = { k: v['links']['related']['href'] for k, v in relationships.items()} assert 'registered_by' in relationships registered_by = relationships['registered_by']['links']['related']['href'] assert urlparse( registered_by).path == '/{}users/{}/'.format(API_BASE, user._id) assert 'registered_from' in relationships registered_from = relationships['registered_from']['links']['related']['href'] assert urlparse(registered_from).path == '/{}nodes/{}/'.format( API_BASE, registration.registered_from._id) api_registrations_url = '/{}registrations/'.format(API_BASE) for relationship in relationship_urls: if relationship in should_not_relate_to_registrations: assert api_registrations_url not in relationship_urls[relationship] else: assert api_registrations_url in relationship_urls[relationship], 'For key {}'.format( relationship)
def test_from_iso_datetime(timezone): d = dt.datetime.now(tz=timezone) formatted = d.isoformat() result = utils.from_iso_datetime(formatted) assert type(result) == dt.datetime assert_datetime_equal(result, d) # Test with 3-digit only microseconds # Regression test for https://github.com/marshmallow-code/marshmallow/issues/1251 d = dt.datetime.now(tz=timezone).replace(microsecond=123000) formatted = d.isoformat() formatted = formatted[:23] + formatted[26:] result = utils.from_iso_datetime(formatted) assert type(result) == dt.datetime assert_datetime_equal(result, d)
def test_custom_date_format_datetime_field_deserialization(self): dtime = dt.datetime.now() datestring = dtime.strftime('%H:%M:%S %Y-%m-%d') field = fields.DateTime(format='%d-%m-%Y %H:%M:%S') #deserialization should fail when datestring is not of same format with pytest.raises(ValidationError) as excinfo: field.deserialize(datestring) msg = 'Not a valid datetime.'.format(datestring) assert msg in str(excinfo) field = fields.DateTime(format='%H:%M:%S %Y-%m-%d') assert_datetime_equal(field.deserialize(datestring), dtime) field = fields.DateTime() assert msg in str(excinfo)
def test_view_comments_updates_user_comments_view_timestamp_files(self): osfstorage = self.project.get_addon("osfstorage") root_node = osfstorage.get_root() test_file = root_node.append_file("test_file") test_file.create_version( self.user, {"object": "06d80e", "service": "cloud", osfstorage_settings.WATERBUTLER_RESOURCE: "osf"}, {"size": 1337, "contentType": "img/png"}, ).save() url = self.project.api_url_for("update_comments_timestamp") res = self.app.put_json(url, {"page": "files", "rootId": test_file._id}, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[test_file._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
def test_serialization(self): user = UserFactory() req = make_drf_request_with_version(version='2.0') reg = RegistrationFactory(creator=user) result = RegistrationSerializer(reg, context={'request': req}).data data = result['data'] assert_equal(data['id'], reg._id) assert_equal(data['type'], 'registrations') should_not_relate_to_registrations = [ 'registered_from', 'registered_by', 'registration_schema' ] # Attributes attributes = data['attributes'] assert_datetime_equal( parse_date(attributes['date_registered']), reg.registered_date ) assert_equal(attributes['withdrawn'], reg.is_retracted) # Relationships relationships = data['relationships'] relationship_urls = {} for relationship in relationships: relationship_urls[relationship]=relationships[relationship]['links']['related']['href'] assert_in('registered_by', relationships) registered_by = relationships['registered_by']['links']['related']['href'] assert_equal( urlparse(registered_by).path, '/{}users/{}/'.format(API_BASE, user._id) ) assert_in('registered_from', relationships) registered_from = relationships['registered_from']['links']['related']['href'] assert_equal( urlparse(registered_from).path, '/{}nodes/{}/'.format(API_BASE, reg.registered_from._id) ) for relationship in relationship_urls: if relationship in should_not_relate_to_registrations: assert_not_in('/{}registrations/'.format(API_BASE), relationship_urls[relationship]) else: assert_in('/{}registrations/'.format(API_BASE), relationship_urls[relationship], 'For key {}'.format(relationship))
def test_serialization(self): user = UserFactory() req = make_drf_request() reg = RegistrationFactory(creator=user) result = RegistrationSerializer(reg, context={'request': req}).data data = result['data'] assert_equal(data['id'], reg._id) assert_equal(data['type'], 'registrations') should_not_relate_to_registrations = [ 'registered_from', 'registered_by', 'registration_schema' ] # Attributes attributes = data['attributes'] assert_datetime_equal( parse_date(attributes['date_registered']), reg.registered_date ) assert_equal(attributes['withdrawn'], reg.is_retracted) # Relationships relationships = data['relationships'] relationship_urls = {} for relationship in relationships: relationship_urls[relationship]=relationships[relationship]['links']['related']['href'] assert_in('registered_by', relationships) registered_by = relationships['registered_by']['links']['related']['href'] assert_equal( urlparse(registered_by).path, '/{}users/{}/'.format(API_BASE, user._id) ) assert_in('registered_from', relationships) registered_from = relationships['registered_from']['links']['related']['href'] assert_equal( urlparse(registered_from).path, '/{}nodes/{}/'.format(API_BASE, reg.registered_from._id) ) for relationship in relationship_urls: if relationship in should_not_relate_to_registrations: assert_not_in('/{}registrations/'.format(API_BASE), relationship_urls[relationship]) else: assert_in('/{}registrations/'.format(API_BASE), relationship_urls[relationship], 'For key {}'.format(relationship))
def test_serialization(self): user = UserFactory() req = make_drf_request() reg = RegistrationFactory(creator=user) result = RegistrationSerializer(reg, context={"request": req}).data data = result["data"] assert_equal(data["id"], reg._id) assert_equal(data["type"], "registrations") # Attributes attributes = data["attributes"] assert_datetime_equal(parse_date(attributes["date_registered"]), reg.registered_date) assert_equal(attributes["retracted"], reg.is_retracted) # Relationships relationships = data["relationships"] assert_in("registered_by", relationships) registered_by = relationships["registered_by"]["links"]["related"]["href"] assert_equal(urlparse(registered_by).path, "/{}users/{}/".format(API_BASE, user._id)) assert_in("registered_from", relationships) registered_from = relationships["registered_from"]["links"]["related"]["href"] assert_equal(urlparse(registered_from).path, "/{}nodes/{}/".format(API_BASE, reg.registered_from._id))
def test_view_comments_updates_user_comments_view_timestamp_files(self): osfstorage = self.project.get_addon('osfstorage') root_node = osfstorage.get_root() test_file = root_node.append_file('test_file') test_file.create_version(self.user, { 'object': '06d80e', 'service': 'cloud', osfstorage_settings.WATERBUTLER_RESOURCE: 'osf', }, { 'size': 1337, 'contentType': 'img/png' }).save() url = self.project.api_url_for('update_comments_timestamp') res = self.app.put_json(url, { 'page': 'files', 'rootId': test_file._id }, auth=self.user.auth) self.user.reload() user_timestamp = self.user.comments_viewed_timestamp[self.project._id]['files'][test_file._id] view_timestamp = dt.datetime.utcnow() assert_datetime_equal(user_timestamp, view_timestamp)
def test_list_field_deserialize_single_value(self): field = fields.List(fields.DateTime) dtime = dt.datetime.utcnow() result = field.deserialize(dtime.isoformat()) assert type(result) == list assert_datetime_equal(result[0], dtime)
def test_from_iso_datetime(use_dateutil): d = dt.datetime.now() formatted = d.isoformat() result = utils.from_iso_datetime(formatted, use_dateutil=use_dateutil) assert type(result) == dt.datetime assert_datetime_equal(result, d)
def test_from_rfc(use_dateutil): d = dt.datetime.now() rfc = utils.rfcformat(d) result = utils.from_rfc(rfc, use_dateutil=use_dateutil) assert type(result) == dt.datetime assert_datetime_equal(result, d)
def test_rfc_datetime_field_deserialization(self, fmt): dtime = dt.datetime.now() datestring = utils.rfcformat(dtime) field = fields.DateTime(format=fmt) assert_datetime_equal(field.deserialize(datestring), dtime)
def test_from_rfc(): d = dt.datetime.now() rfc = utils.rfcformat(d) result = utils.from_rfc(rfc) assert isinstance(result, dt.datetime) assert_datetime_equal(result, d)
def test_from_rfc(): d = dt.datetime.now().replace(microsecond=0) rfc = utils.rfcformat(d) result = utils.from_rfc(rfc) assert type(result) == dt.datetime assert_datetime_equal(result, d)
def test_iso_datetime_field_deserialization(self, fmt): dtime = dt.datetime.now() datestring = dtime.isoformat() field = fields.DateTime(format=fmt) assert_datetime_equal(field.deserialize(datestring), dtime)
def test_from_iso(use_dateutil): d = dt.datetime.now() formatted = d.isoformat() result = utils.from_iso(formatted, use_dateutil=use_dateutil) assert type(result) == dt.datetime assert_datetime_equal(result, d)
def test_from_iso(use_dateutil): d = dt.datetime.now() formatted = d.isoformat() result = utils.from_iso(formatted, use_dateutil=use_dateutil) assert isinstance(result, dt.datetime) assert_datetime_equal(result, d)
def test_from_iso(): d = dt.datetime.now() formatted = d.isoformat() result = utils.from_iso(formatted) assert isinstance(result, dt.datetime) assert_datetime_equal(result, d)