def setUpTestData(cls):
cls.current_user = factories.UserFactory()
cls.workspace = factories.WorkspaceFactory(creator=cls.current_user)
cls.workspace.grant_membership(cls.current_user,
models.Membership.OWNER)
cls.user = factories.UserFactory()
cls.membership, _ = cls.workspace.grant_membership(
cls.user, models.Membership.READONLY)
cls.request = collections.namedtuple('Request',
['user'])(user=cls.current_user)
def test_vote(self):
"""It should cast a vote successfully.
"""
voter = factories.UserFactory()
resource = self.factory()
vote = resource.vote(voter, models.Vote.UP)
self.assertEqual(type(vote), models.Vote)
def setUpTestData(cls):
cls.commentable = factories.TableFactory()
cls.workspace = cls.commentable.workspace
cls.user = factories.UserFactory()
cls.comment = cls.commentable.comments.create(
author=cls.user,
html='This is a test',
)
def test_get_vote_when_not_exists(self):
"""It should return the vote if exists.
"""
voter = factories.UserFactory()
resource = self.factory()
self.assertEqual(
None,
resource.get_vote(voter),
)
def test_delete_vote(self):
"""It should delete the vote and update the counters.
"""
voter = factories.UserFactory()
resource = self.factory()
resource.vote(voter, models.Vote.UP)
resource.delete_vote(voter)
self.assertEqual(resource.votes.count(), 0)
def test_get_vote_when_exists(self):
"""It should return the vote if exists.
"""
voter = factories.UserFactory()
resource = self.factory()
vote = resource.vote(voter, models.Vote.UP)
self.assertEqual(
vote,
resource.get_vote(voter),
)
def test_pin(self):
"""It should mark the `pinned_at` timestamp.
"""
user = factories.UserFactory()
comment = self.factory()
comment.pin(user)
pinned_at = comment.pinned_at
self.assertTrue(pinned_at is not None)
self.assertTrue(comment.pinned)
comment.pin(user)
self.assertTrue(pinned_at, comment.pinned_at)
def test_valid_update(self):
"""It should create the group membership.
"""
user = factories.UserFactory()
self.workspace.grant_membership(user, models.Membership.MEMBER)
serializer = self.serializer_class(
instance=self.instance,
data={'user': user.pk},
partial=True,
)
self.assertTrue(serializer.is_valid())
self.assertTrue(serializer.save())
self.assertTrue(user.groups.filter(name=self.instance.name).exists())
def test_vote_when_exists(self):
"""It should update the vote (and counters) accordingly.
"""
voter = factories.UserFactory()
resource = self.factory()
resource.vote(voter, models.Vote.UP)
self.assertEqual(resource.num_vote_up, 1)
self.assertEqual(resource.num_vote_down, 0)
resource.vote(voter, models.Vote.DOWN)
self.assertEqual(resource.num_vote_up, 0)
self.assertEqual(resource.num_vote_down, 1)
self.assertEqual(resource.votes.count(), 1)
def test_remove_revoked_user_from_groups(self):
"""It should remove a User from all workspace groups when membership is revoked.
"""
user = factories.UserFactory()
workspace = factories.WorkspaceFactory(name='Metameta')
workspace.grant_membership(user, models.Membership.READONLY)
group = factories.GroupFactory(workspace_id=workspace.id)
group.user_set.add(user)
self.assertTrue(user.groups.filter(name=group.name).exists())
workspace.revoke_membership(user)
self.assertFalse(user.groups.filter(name=group.name).exists())
def test_when_not_team_member(self):
"""It should return an error.
"""
user = factories.UserFactory()
serializer = self.serializer_class(
instance=self.instance,
data={'user': user.pk},
partial=True,
)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors, [{
'code': 'no_membership',
'field': 'user',
'resource': 'User',
}])
def test_get_custom_properties(self):
"""It should return NULL for non-existent fields.
"""
user = factories.UserFactory()
workspace = factories.WorkspaceFactory()
workspace.grant_membership(user, 'OWNER')
attributes = {
'content_type': self.model_class.get_content_type(),
'workspace': workspace,
}
customfields = [
factories.CustomFieldFactory(field_name='Steward',
field_type=models.CustomField.USER,
**attributes),
factories.CustomFieldFactory(field_name='Product Area',
field_type=models.CustomField.TEXT,
**attributes),
factories.CustomFieldFactory(field_name='Team',
field_type=models.CustomField.TEXT,
**attributes),
]
resource = self.factory(
workspace=workspace,
custom_properties={
customfields[0].pk: user.pk,
customfields[2].pk: 'Data Engineering',
},
)
custom_properties = resource.get_custom_properties()
for customfield in customfields:
self.assertTrue(customfield.pk in custom_properties)
self.assertEqual(custom_properties[customfields[0].pk], {
'label': 'Steward',
'value': user
})
self.assertEqual(custom_properties[customfields[2].pk], {
'label': 'Team',
'value': 'Data Engineering'
})
def test_saves_with_workspace_id(self):
"""It should automatically add the workspace of the ContentObject.
"""
user = factories.UserFactory()
voteable = factories.CommentFactory()
properties = {
'content_object': voteable,
'action': self.model_class.UP,
'user': user,
}
vote = self.model_class.objects.create(**properties)
self.assertEqual(
vote.workspace_id,
voteable.workspace_id,
)
def test_saves_with_workspace_id(self):
"""It should automatically add the workspace of the ContentObject.
"""
user = factories.UserFactory()
commentable = factories.TableFactory()
properties = {
'content_object': commentable,
'author': user,
'html': helpers.faker.sentence(),
}
comment = self.model_class.objects.create(**properties)
self.assertEqual(
comment.workspace_id,
commentable.workspace_id,
)
def test_membership_granted_when_exists(self, mock_deliver):
"""It should call the Mailer.deliver method with the proper template.
"""
user = factories.UserFactory()
workspace = factories.WorkspaceFactory(name='Metameta')
emails.membership_granted(user.email, workspace,
models.Membership.READONLY)
mock_deliver.assert_called_with(
user.email,
'You have granted the Readonly role to the Metameta workspace',
{
'to_address': user.email,
'workspace_name': workspace.name,
'user_exists': True,
'permissions': 'Readonly',
},
)
def setUpTestData(cls):
cls.current_user = factories.UserFactory()
cls.workspace = factories.WorkspaceFactory(creator=cls.current_user)
cls.workspace.grant_membership(cls.current_user, auth.Membership.OWNER)
cls.group = factories.GroupFactory(workspace_id=cls.workspace.id)
cls.datastore = factories.DatastoreFactory(workspace=cls.workspace)
cls.attributes = {
'content_type': cls.datastore.content_type,
'workspace': cls.workspace,
}
cls.customfields = [
factories.CustomFieldFactory(
field_name='Steward',
field_type=models.CustomField.USER,
validators={},
**cls.attributes,
),
factories.CustomFieldFactory(
field_name='Product Area',
field_type=models.CustomField.TEXT,
validators={},
**cls.attributes,
),
factories.CustomFieldFactory(
field_name='Department',
field_type=models.CustomField.ENUM,
validators={
'choices': ['Data Engineering', 'Product', 'Design']
},
**cls.attributes,
),
factories.CustomFieldFactory(
field_name='Team',
field_type=models.CustomField.GROUP,
**cls.attributes,
),
]
cls.request = collections.namedtuple(
'Request',
['user', 'workspace'],
)(user=cls.current_user, workspace=cls.workspace)
def test_get_custom_properties_deleted_user(self):
"""It should return NULL for a deleted choice.
"""
user = factories.UserFactory()
workspace = factories.WorkspaceFactory()
workspace.grant_membership(user, 'OWNER')
attributes = {
'content_type': self.model_class.get_content_type(),
'workspace': workspace,
}
customfield = factories.CustomFieldFactory(
field_name='Steward',
field_type=models.CustomField.USER,
**attributes,
)
resource = self.factory(
workspace=workspace,
custom_properties={
customfield.pk: user.pk,
},
)
self.assertEqual(resource.get_custom_properties()[customfield.pk], {
'label': 'Steward',
'value': user
})
workspace.revoke_membership(user)
resource.refresh_from_db()
self.assertEqual(resource.get_custom_properties()[customfield.pk], {
'label': 'Steward',
'value': None
})
def setUpTestData(cls):
cls.creator = factories.UserFactory()
cls.resource = cls.factory()
cls.workspace = cls.factory()
def setUp(self):
self.client = Client(HTTP_HOST='example.com')
self.user = factories.UserFactory()
self.workspace = factories.WorkspaceFactory()
self.workspace.grant_membership(self.user, 'READONLY')
def setUpTestData(cls):
cls.commentable = factories.TableFactory()
cls.workspace = cls.commentable.workspace
cls.user = factories.UserFactory()
