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_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_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)
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_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_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_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)
