def setUpTestData(cls):
super().setUpTestData()
cls.superuser = UserFactory(username='******', is_staff=True, is_superuser=True)
cls.staffuser = UserFactory(username='******', is_staff=True, is_superuser=False)
cls.model = models.Room
cls.form = forms.RoomForm
cls.targets = ('name', 'description', 'assigned')
def setUp(self):
super().setUp()
self.user = UserFactory(username='******',
password=make_password(self.password))
self.staffuser = UserFactory(username='******',
password=make_password(self.password),
is_staff=True,
is_superuser=False)
self.superuser = UserFactory(username='******',
password=make_password(self.password),
is_staff=True,
is_superuser=True)
def setUpTestData(cls):
cls.password = '******'
cls.superuser = UserFactory(username='******',
is_staff=True,
is_superuser=True)
cls.staffuser = UserFactory(username='******',
is_staff=True,
is_superuser=False)
cls.users = UserFactory.create_batch(5)
u_pk = [_user.pk for _user in cls.users]
cls.rooms = [
(
RoomFactory.create(owner=cls.users[0]),
RoomFactory.create(owner=cls.users[0],
name='sample_a',
assigned=[u_pk[1], u_pk[2]]),
), # invalid: user[3], user[4]
(
RoomFactory.create(owner=cls.users[1]),
RoomFactory.create(owner=cls.users[1],
name='sample_b',
assigned=[u_pk[0], u_pk[2], u_pk[4]]),
), # invalid: user[3]
(
RoomFactory.create(owner=cls.users[2]),
RoomFactory.create(owner=cls.users[2],
name='sample_c',
assigned=[u_pk[3]]),
), # invalid: user[0], user[1], user[4]
(
RoomFactory.create(owner=cls.users[3], name='only_user3'),
RoomFactory.create(owner=cls.users[3], name='only_c'),
), # invalid: 0, 1, 2, 4
(
RoomFactory.create(owner=cls.users[3],
name='only_user3_part2'),
RoomFactory.create(owner=cls.users[3], name='only_c2'),
), # invalid: 0, 1, 2, 4
(
RoomFactory.create(owner=cls.users[3],
name='only_user3_part3'),
RoomFactory.create(owner=cls.users[3], name='only_c3'),
), # invalid: 0, 1, 2, 4
(
RoomFactory.create(owner=cls.users[3],
name='only_user3_part4'),
RoomFactory.create(owner=cls.users[3], name='only_c4'),
), # invalid: 0, 1, 2, 4
]
def setUpTestData(cls):
cls.password = '******'
cls.users = UserFactory.create_batch(5)
cls.room = RoomFactory.create(owner=cls.users[0],
name='chat_room',
assigned=[cls.users[1], cls.users[2]
]) # invalid: user[3], user[4]
def setUpTestData(cls):
cls.model = models.FileStorage
cls.password = '******'
cls.users = UserFactory.create_batch(6)
patterns = [
(cls.users[0], 'user0_file.txt', 'temp.md'),
(cls.users[1], 'user1_file.txt', 'file.pdf'),
(cls.users[2], 'user2_file.txt', ''),
(cls.users[3], '', 'user3.pdf'),
(cls.users[4], '', ''),
]
cls.files = []
for (user, filename, extname) in patterns:
tmp_files = [FileStorageFactory(user=user)]
if filename:
tmp_files.append(
FileStorageFactory(user=user, filename=filename))
if extname:
tmp_files.append(
FileStorageFactory(user=user,
filename=extname,
file__filename=extname))
cls.files.append(tuple(tmp_files))
def setUpTestData(cls):
cls.users = UserFactory.create_batch(5)
cls.not_active_user = UserFactory(username='******', is_active=False)
u_pk = [_user.pk for _user in cls.users]
cls.rooms = [
(RoomFactory.create(owner=cls.users[0]), RoomFactory.create(owner=cls.users[0], name='sample_a', assigned=[u_pk[1], u_pk[2]]), ), # invalid: user[3], user[4]
(RoomFactory.create(owner=cls.users[1]), RoomFactory.create(owner=cls.users[1], name='sample_b', assigned=[u_pk[0], u_pk[2], u_pk[4]]), ), # invalid: user[3]
(RoomFactory.create(owner=cls.users[2]), RoomFactory.create(owner=cls.users[2], name='sample_c', assigned=[u_pk[3]]), ), # invalid: user[0], user[1], user[4]
(RoomFactory.create(owner=cls.users[3], name='only_user3'), RoomFactory.create(owner=cls.users[3], name='only_c'), ), # invalid: 0, 1, 2, 4
]
_room = cls.rooms[0][-1]
messages = [
(cls.users[0], 'chat'), (cls.users[0], 'sample'), (cls.users[0], 'hello'), (cls.users[0], 'world'), (cls.users[0], 'hello world'), (cls.users[0], 'user0'),
(cls.users[1], 'sample'), (cls.users[1], 'hello world'), (cls.users[1], 'user1'),
]
cls.messages = [MessageFactory(user=_user, room=_room, content=_msg) for _user, _msg in messages]
def setUp(self):
super().setUp()
view_user = Permission.objects.get(codename='view_user')
view_perm = Permission.objects.get(codename='view_permission')
# owner
self.owner = UserFactory(username='******')
self.owner.user_permissions.add(view_user, view_perm)
# outsider
self.outsider = UserFactory(username='******')
self.outsider.user_permissions.add(view_user, view_perm)
# no permission user
self.no_permission_user = UserFactory(username='******')
# super user
self.superuser = UserFactory(username='******',
is_staff=True,
is_superuser=True)
def test_invalid_active_user_create_user_complete_view(self):
_active_user = UserFactory(username='******')
params = {'token': dumps(_active_user.pk)}
url = reverse('registration:create_user_complete', kwargs=params)
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
_active_user = UserModel.objects.get(pk=_active_user.pk)
self.assertTrue(_active_user.is_active)
def setUp(self):
super().setUp()
self.client.logout()
self.new_password = self.create_random_password_for_test()
self.not_active_user = UserFactory(username='******',
is_active=False)
self.uid = urlsafe_base64_encode(force_bytes(self.user.pk))
self.token = default_token_generator.make_token(self.user)
def setUp(self):
super().setUp()
self.client.login(username=self.superuser.username,
password=self.password)
self.test_user = UserFactory(username='******', is_active=False)
params = {
'pk': self.test_user.pk,
}
self.url = reverse('registration:delete_user_page', kwargs=params)
def test_invalid_user_pk_change_email_complete_view(self):
_active_user = UserFactory(username='******')
params = {
'param': dumps(_active_user.pk),
'token': dumps(self.new_email),
}
url = reverse('registration:change_email_complete', kwargs=params)
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
_user = UserModel.objects.get(pk=_active_user.pk)
self.assertEqual(_user.email, _active_user.email)
def setUpTestData(cls):
cls.users = UserFactory.create_batch(4)
codename = 'view_user'
cls.group_name = 'editors'
cls.permission_name = 'registration.{}'.format(codename)
group = Group.objects.create(name=cls.group_name)
view_user = Permission.objects.get(codename=codename)
# user0: have both no permission and no group
# user1: have only permission
# user2: have only group
# user3: have both permission and group
cls.users[1].user_permissions.add(view_user)
cls.users[2].groups.add(group)
cls.users[3].user_permissions.add(view_user)
cls.users[3].groups.add(group)
def setUp(self):
self.normal_user = UserFactory(username='******', viewname='_alice')
def setUpTestData(cls):
super().setUpTestData()
cls.users = UserFactory.create_batch(10)
def setUpTestData(cls):
cls.password = '******'
cls.user = UserFactory(username='******', password=make_password(cls.password))
cls.staffuser = UserFactory(username='******', password=make_password(cls.password), is_staff=True, is_superuser=False)
def setUp(self):
super().setUp()
self.new_email = 'new_{}'.format(self.user.email)
self.not_active_user = UserFactory(username='******',
is_active=False)
def setUpTestData(cls):
cls.password = '******'
cls.users = UserFactory.create_batch(7)
view_user = Permission.objects.get(codename='view_user')
view_perm = Permission.objects.get(codename='view_permission')
for user in cls.users:
user.user_permissions.add(view_user, view_perm)
cls.tags = [
(
TagFactory.create(user=cls.users[0]),
TagFactory.create(user=cls.users[0], name='sample_a'),
),
(
TagFactory.create(user=cls.users[1]),
TagFactory.create(user=cls.users[1], name='sample_b'),
),
(
TagFactory.create(user=cls.users[2]),
TagFactory.create(user=cls.users[2], name='sample_c'),
),
(
TagFactory.create(user=cls.users[3], name='info_d'),
TagFactory.create(user=cls.users[3], name='sample_d'),
TagFactory.create(user=cls.users[3], name='seed_d'),
),
(
TagFactory.create(user=cls.users[4], name='data_e'),
TagFactory.create(user=cls.users[4], name='sample_e'),
TagFactory.create(user=cls.users[4], name='type_e'),
),
]
posts = [
(
PostFactory(user=cls.users[0], title='post10'),
PostFactory(user=cls.users[0], title='title20'),
PostFactory(user=cls.users[0], title='case30'),
),
(
PostFactory(user=cls.users[1], title='post11'),
PostFactory(user=cls.users[1], title='title21'),
PostFactory(user=cls.users[1], title='case31'),
),
(
PostFactory(user=cls.users[2], title='post12'),
PostFactory(user=cls.users[2], title='title22'),
PostFactory(user=cls.users[2], title='case32'),
),
(PostFactory(user=cls.users[3], title='bot13'),
PostFactory(user=cls.users[3], title='bot23'),
PostFactory(user=cls.users[3], title='private', is_public=False)),
(
PostFactory(user=cls.users[5], title='shape15'),
PostFactory(user=cls.users[5], title='shape25'),
),
]
user_tag_post_combination = [
(cls.users[0], (cls.tags[0][0], ), (posts[0][0], posts[0][1])),
(cls.users[0], cls.tags[0], posts[0]),
(cls.users[1], (cls.tags[1][1], ), (posts[1][1], )),
(cls.users[1], cls.tags[1], posts[1]),
(cls.users[2], (cls.tags[2][0], ), (posts[2][0], posts[2][2])),
(cls.users[2], cls.tags[2], posts[2]),
(cls.users[3], cls.tags[3], posts[3]),
(cls.users[4], cls.tags[4], tuple()),
(cls.users[5], tuple(), posts[4]),
]
cls.posts = [
PostFactory.create(
user=_user,
tags=(_tag.pk for _tag in _tags),
relation_posts=(_post.pk for _post in _posts),
) for _user, _tags, _posts in user_tag_post_combination
]
def test_create_valid_user_blank_viewname(self):
blank_viewname_user = UserFactory(viewname='')
self.assertEqual(blank_viewname_user.viewname, '')
def setUp(self):
super().setUp()
self.user = UserFactory(username='******', is_active=False)
self.password = self.create_random_password_for_test()
class UserModelTests(TestCase):
@classmethod
def setUpClass(cls):
super().setUpClass()
def setUp(self):
self.normal_user = UserFactory(username='******', viewname='_alice')
def test_create_valid_user(self):
self.assertEqual(self.normal_user.username, 'alice')
self.assertEqual(self.normal_user.get_full_name(), 'alice')
self.assertEqual(self.normal_user.get_short_name(), 'alice')
self.assertEqual(self.normal_user.viewname, '_alice')
self.assertEqual(self.normal_user.email, '*****@*****.**')
self.assertFalse(self.normal_user.is_staff)
self.assertTrue(self.normal_user.is_active)
def test_create_valid_user_blank_viewname(self):
blank_viewname_user = UserFactory(viewname='')
self.assertEqual(blank_viewname_user.viewname, '')
def test_create_user(self):
_user = UserModel.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.assertTrue(isinstance(_user, UserModel))
def test_create_superuser(self):
_user = UserModel.objects.create_superuser(
username='******',
email='*****@*****.**',
password='******',
is_staff=True,
is_superuser=True)
self.assertTrue(isinstance(_user, UserModel))
self.assertTrue(_user.is_staff)
self.assertTrue(_user.is_superuser)
with self.assertRaises(ValueError):
_ = UserModel.objects.create_superuser(
username='******',
email='*****@*****.**',
password='******',
is_staff=True,
is_superuser=False)
with self.assertRaises(ValueError):
_ = UserModel.objects.create_superuser(
username='******',
email='*****@*****.**',
password='******',
is_staff=False,
is_superuser=True)
def test_aux_create_user(self):
with self.assertRaises(ValueError):
_ = UserModel.objects._create_user(username='',
email='*****@*****.**',
password='******')
with self.assertRaises(ValueError):
_ = UserModel.objects._create_user(username='******',
email='',
password='******')
def test_send_mail(self):
_subject = 'subject name'
_message = 'sample message'
self.normal_user.email_user(_subject, _message)
_outbox = mail.outbox[0]
self.assertEqual(_outbox.subject, _subject)
self.assertEqual(_outbox.body, _message)
@classmethod
def tearDownClass(cls):
super().tearDownClass()
def setUp(self):
super().setUp()
self.user = UserFactory(username='******',
password=make_password(self.password))
def setUpTestData(cls):
cls.owner = UserFactory()
cls.follower = UserFactory()
def setUp(self):
super().setUp()
self.user = UserFactory(username='******')
self.client.login(username=self.user.username, password=self.password)
def setUpTestData(cls):
cls.users = UserFactory.create_batch(6)
def setUpTestData(cls):
UserFactory.reset_sequence(0)
cls.users = UserFactory.create_batch(5)
cls.all_users = UserModel.objects.all()