class TestNodeFileLogDetail(ApiTestCase):
def setUp(self):
super(TestNodeFileLogDetail, self).setUp()
self.user_one = AuthUserFactory()
self.user_two = AuthUserFactory()
self.node = ProjectFactory(creator=self.user_one)
self.node.add_contributor(self.user_two)
self.component = NodeFactory(parent=self.node, creator=self.user_one)
self.file = api_utils.create_test_file(node=self.component, user=self.user_one)
self.node.add_log(
'osf_storage_file_moved',
auth=Auth(self.user_one),
params={
'node': self.node._id,
'project': self.node.parent_id,
'path': self.file.materialized_path,
'source': {
'materialized': self.file.materialized_path,
'addon': 'osfstorage',
'node': {
'_id': self.component._id,
'url': self.component.url,
'title': self.component.title,
}
},
'destination': {
'materialized': self.file.materialized_path,
'addon': 'osfstorage',
'node': {
'_id': self.node._id,
'url': self.node.url,
'title': self.node.title,
}
}
},
)
self.node.save()
self.node_logs_url = '/{}nodes/{}/logs/'.format(API_BASE, self.node._id)
self.component_logs_url = '/{}nodes/{}/logs/'.format(API_BASE, self.component._id)
def test_title_not_hidden_from_contributor_in_file_move(self):
res = self.app.get(self.node_logs_url, auth=self.user_two.auth)
assert_equal(res.status_code, 200)
assert_equal(res.json['data'][0]['attributes']['params']['destination']['node_title'], self.node.title)
def test_title_hidden_from_non_contributor_in_file_move(self):
res = self.app.get(self.node_logs_url, auth=self.user_two.auth)
assert_equal(res.status_code, 200)
assert_not_in(self.component.title, res.json['data'])
assert_equal(res.json['data'][0]['attributes']['params']['source']['node_title'], 'Private Component')
def _create_nodes_and_add_logs(self, first_activity_date, second_activity_date=None):
node_one = ProjectFactory(creator=self.user_1)
node_one.date_created = first_activity_date
node_one.add_log(
'log_added', params={'project': node_one._id}, auth=self.auth_1, log_date=first_activity_date, save=True
)
if second_activity_date:
node_two = ProjectFactory(creator=self.user_1)
node_two.date_created = second_activity_date
node_two.add_log(
'log_added', params={'project': node_two._id}, auth=self.auth_1, log_date=second_activity_date, save=True
)
def test_serializing_log_with_legacy_non_registered_contributor_data(
self, fake):
# Old logs store unregistered contributors in params as dictionaries of the form:
# {
# 'nr_email': <email>,
# 'nr_name': <name>,
# }
# This test ensures that the NodeLogSerializer can handle this legacy data.
project = ProjectFactory()
user = UserFactory()
request = make_drf_request_with_version()
nr_data = {'nr_email': fake.email(), 'nr_name': fake.name()}
log = project.add_log(action=NodeLog.CONTRIB_ADDED,
auth=Auth(project.creator),
params={
'project': project._id,
'node': project._id,
'contributors': [user._id, nr_data],
})
serialized = NodeLogSerializer(log, context={'request': request}).data
contributor_data = serialized['data']['attributes']['params'][
'contributors']
# contributor_data will have two dicts:
# the first will be the registered contrib, 2nd will be non-reg contrib
reg_contributor_data, unreg_contributor_data = contributor_data
assert reg_contributor_data['id'] == user._id
assert reg_contributor_data['full_name'] == user.fullname
assert unreg_contributor_data['id'] is None
assert unreg_contributor_data['full_name'] == nr_data['nr_name']
def test_serializing_log_with_legacy_non_registered_contributor_data(self, fake):
# Old logs store unregistered contributors in params as dictionaries of the form:
# {
# 'nr_email': <email>,
# 'nr_name': <name>,
# }
# This test ensures that the NodeLogSerializer can handle this legacy data.
project = ProjectFactory()
user = UserFactory()
request = make_drf_request_with_version()
nr_data = {'nr_email': fake.email(), 'nr_name': fake.name()}
log = project.add_log(
action=NodeLog.CONTRIB_ADDED,
auth=Auth(project.creator),
params={
'project': project._id,
'node': project._id,
'contributors': [user._id, nr_data],
}
)
serialized = NodeLogSerializer(log, context={'request': request}).data
contributor_data = serialized['data']['attributes']['params']['contributors']
# contributor_data will have two dicts:
# the first will be the registered contrib, 2nd will be non-reg contrib
reg_contributor_data, unreg_contributor_data = contributor_data
assert reg_contributor_data['id'] == user._id
assert reg_contributor_data['full_name'] == user.fullname
assert unreg_contributor_data['id'] is None
assert unreg_contributor_data['full_name'] == nr_data['nr_name']
def _create_nodes_and_add_logs(self,
first_activity_date,
second_activity_date=None):
node_one = ProjectFactory(creator=self.user_1)
node_one.date_created = first_activity_date
node_one.add_log('log_added',
params={'project': node_one._id},
auth=self.auth_1,
log_date=first_activity_date,
save=True)
if second_activity_date:
node_two = ProjectFactory(creator=self.user_1)
node_two.date_created = second_activity_date
node_two.add_log('log_added',
params={'project': node_two._id},
auth=self.auth_1,
log_date=second_activity_date,
save=True)
class TestUtilsTests(OsfTestCase):
def setUp(self):
super(TestUtilsTests, self).setUp()
self.node = ProjectFactory()
self.user = self.node.creator
self.auth = Auth(self.user)
def test_assert_logs(self):
def add_log(self):
self.node.add_log(NodeLog.UPDATED_FIELDS, {}, auth=self.auth)
wrapped = test_utils.assert_logs(NodeLog.UPDATED_FIELDS, 'node')(add_log)
wrapped(self)
def test_assert_logs_fail(self):
def dont_add_log(self):
pass
wrapped = test_utils.assert_logs(NodeLog.UPDATED_FIELDS, 'node')(dont_add_log)
assert_raises(AssertionError, lambda: wrapped(self))
def test_assert_logs_stacked(self):
def add_log(self):
self.node.add_log(NodeLog.UPDATED_FIELDS, {}, auth=self.auth)
def add_two_logs(self):
add_log(self)
self.node.add_log(NodeLog.CONTRIB_ADDED, {}, auth=self.auth)
wrapped = test_utils.assert_logs(NodeLog.UPDATED_FIELDS, 'node', -2)(
test_utils.assert_logs(NodeLog.CONTRIB_ADDED, 'node')(add_two_logs)
)
wrapped(self)
def test_assert_not_logs_pass(self):
def dont_add_log(self):
pass
wrapped = test_utils.assert_not_logs(NodeLog.UPDATED_FIELDS, 'node')(dont_add_log)
wrapped(self)
def test_assert_not_logs_fail(self):
def add_log(self):
self.node.add_log(NodeLog.UPDATED_FIELDS, {}, auth=self.auth)
wrapped = test_utils.assert_not_logs(NodeLog.UPDATED_FIELDS, 'node')(add_log)
assert_raises(AssertionError, lambda: wrapped(self))
class TestNodeFileLogDetail(ApiTestCase):
def setUp(self):
super(TestNodeFileLogDetail, self).setUp()
self.user_one = AuthUserFactory()
self.user_two = AuthUserFactory()
self.node = ProjectFactory(creator=self.user_one)
self.node.add_contributor(self.user_two)
self.component = NodeFactory(parent=self.node, creator=self.user_one)
self.file = api_utils.create_test_file(node=self.component,
user=self.user_one)
self.node.add_log(
'osf_storage_file_moved',
auth=Auth(self.user_one),
params={
'node': self.node._id,
'project': self.node.parent_id,
'path': self.file.materialized_path,
'source': {
'materialized': self.file.materialized_path,
'addon': 'osfstorage',
'node': {
'_id': self.component._id,
'url': self.component.url,
'title': self.component.title,
}
},
'destination': {
'materialized': self.file.materialized_path,
'addon': 'osfstorage',
'node': {
'_id': self.node._id,
'url': self.node.url,
'title': self.node.title,
}
}
},
)
self.node.save()
self.node_logs_url = '/{}nodes/{}/logs/'.format(
API_BASE, self.node._id)
self.component_logs_url = '/{}nodes/{}/logs/'.format(
API_BASE, self.component._id)
def test_title_not_hidden_from_contributor_in_file_move(self):
res = self.app.get(self.node_logs_url, auth=self.user_two.auth)
assert_equal(res.status_code, 200)
assert_equal(
res.json['data'][0]['attributes']['params']['destination']
['node_title'], self.node.title)
def test_title_hidden_from_non_contributor_in_file_move(self):
res = self.app.get(self.node_logs_url, auth=self.user_two.auth)
assert_equal(res.status_code, 200)
assert_not_in(self.component.title, res.json['data'])
assert_equal(
res.json['data'][0]['attributes']['params']['source']
['node_title'], 'Private Component')
class TestUserWorkshopFormView(AdminTestCase):
def setUp(self):
self.user = AuthUserFactory()
self.auth = Auth(self.user)
self.view = views.UserWorkshopFormView()
self.node = ProjectFactory(creator=self.user)
self.mock_data = mock.patch.object(
csv,
'reader',
# parse data into the proper format handling None values as csv reader would
side_effect=(lambda values: [[item or '' for item in value] for value in values])
)
self.mock_data.start()
def tearDown(self):
self.mock_data.stop()
def _setup_workshop(self, date):
self.workshop_date = date
self.data = [
['none', 'date', 'none', 'none', 'none', 'email', 'none'],
[None, self.workshop_date.strftime('%m/%d/%y'), None, None, None, self.user.username, None],
]
self.user_exists_by_name_data = [
['number', 'date', 'location', 'topic', 'name', 'email', 'other'],
[None, self.workshop_date.strftime('%m/%d/%y'), None, None, self.user.fullname, '*****@*****.**', None],
]
self.user_not_found_data = [
['none', 'date', 'none', 'none', 'none', 'email', 'none'],
[None, self.workshop_date.strftime('%m/%d/%y'), None, None, None, '*****@*****.**', None],
]
def _add_log(self, date):
self.node.add_log('log_added', params={'project': self.node._id}, auth=self.auth, log_date=date, save=True)
def test_correct_number_of_columns_added(self):
self._setup_workshop(self.node.created)
added_columns = ['OSF ID', 'Logs Since Workshop', 'Nodes Created Since Workshop', 'Last Log Data']
result_csv = self.view.parse(self.data)
nt.assert_equal(len(self.data[0]) + len(added_columns), len(result_csv[0]))
def test_user_activity_day_of_workshop_and_before(self):
self._setup_workshop(self.node.created)
# add logs 0 to 48 hours back
for time_mod in range(9):
self._add_log(self.node.created - timedelta(hours=(time_mod * 6)))
result_csv = self.view.parse(self.data)
user_logs_since_workshop = result_csv[1][-3]
user_nodes_created_since_workshop = result_csv[1][-2]
nt.assert_equal(user_logs_since_workshop, 0)
nt.assert_equal(user_nodes_created_since_workshop, 0)
def test_user_activity_after_workshop(self):
self._setup_workshop(self.node.created - timedelta(hours=25))
self._add_log(self.node.created)
result_csv = self.view.parse(self.data)
user_logs_since_workshop = result_csv[1][-3]
user_nodes_created_since_workshop = result_csv[1][-2]
# 1 node created, 1 bookmarks collection created (new user), 1 node log
nt.assert_equal(user_logs_since_workshop, 3)
nt.assert_equal(user_nodes_created_since_workshop, 1)
# Test workshop 30 days ago
self._setup_workshop(self.node.created - timedelta(days=30))
result_csv = self.view.parse(self.data)
user_logs_since_workshop = result_csv[1][-3]
user_nodes_created_since_workshop = result_csv[1][-2]
nt.assert_equal(user_logs_since_workshop, 3)
nt.assert_equal(user_nodes_created_since_workshop, 1)
# Test workshop a year ago
self._setup_workshop(self.node.created - timedelta(days=365))
result_csv = self.view.parse(self.data)
user_logs_since_workshop = result_csv[1][-3]
user_nodes_created_since_workshop = result_csv[1][-2]
nt.assert_equal(user_logs_since_workshop, 3)
nt.assert_equal(user_nodes_created_since_workshop, 1)
# Regression test for OSF-8089
def test_utc_new_day(self):
node_date = self.node.created
date = datetime(node_date.year, node_date.month, node_date.day, 0, tzinfo=pytz.utc) + timedelta(days=1)
self._setup_workshop(date)
self._add_log(self.workshop_date + timedelta(hours=25))
result_csv = self.view.parse(self.data)
user_logs_since_workshop = result_csv[1][-3]
nt.assert_equal(user_logs_since_workshop, 1)
# Regression test for OSF-8089
def test_utc_new_day_plus_hour(self):
node_date = self.node.created
date = datetime(node_date.year, node_date.month, node_date.day, 0, tzinfo=pytz.utc) + timedelta(days=1, hours=1)
self._setup_workshop(date)
self._add_log(self.workshop_date + timedelta(hours=25))
result_csv = self.view.parse(self.data)
user_logs_since_workshop = result_csv[1][-3]
nt.assert_equal(user_logs_since_workshop, 1)
# Regression test for OSF-8089
def test_utc_new_day_minus_hour(self):
node_date = self.node.created
date = datetime(node_date.year, node_date.month, node_date.day, 0, tzinfo=pytz.utc) + timedelta(days=1) - timedelta(hours=1)
self._setup_workshop(date)
self._add_log(self.workshop_date + timedelta(hours=25))
result_csv = self.view.parse(self.data)
user_logs_since_workshop = result_csv[1][-3]
nt.assert_equal(user_logs_since_workshop, 1)
def test_user_osf_account_not_found(self):
self._setup_workshop(self.node.created)
result_csv = self.view.parse(self.user_not_found_data)
user_id = result_csv[1][-4]
last_log_date = result_csv[1][-1]
user_logs_since_workshop = result_csv[1][-3]
user_nodes_created_since_workshop = result_csv[1][-2]
nt.assert_equal(user_id, '')
nt.assert_equal(last_log_date, '')
nt.assert_equal(user_logs_since_workshop, 0)
nt.assert_equal(user_nodes_created_since_workshop, 0)
def test_user_found_by_name(self):
self._setup_workshop(self.node.created)
result_csv = self.view.parse(self.user_exists_by_name_data)
user_id = result_csv[1][-4]
last_log_date = result_csv[1][-1]
user_logs_since_workshop = result_csv[1][-3]
user_nodes_created_since_workshop = result_csv[1][-2]
nt.assert_equal(user_id, self.user.id)
nt.assert_equal(last_log_date, '')
nt.assert_equal(user_logs_since_workshop, 0)
nt.assert_equal(user_nodes_created_since_workshop, 0)
def test_form_valid(self):
request = RequestFactory().post('/fake_path')
data = [
['none', 'date', 'none', 'none', 'none', 'email', 'none'],
[None, '9/1/16', None, None, None, self.user.username, None],
]
uploaded = SimpleUploadedFile('test_name', bytes(csv.reader(data)), content_type='text/csv')
form = WorkshopForm(data={'document': uploaded})
form.is_valid()
form.cleaned_data['document'] = uploaded
setup_form_view(self.view, request, form)
