def test_closed_clients_ordered_by_time_they_closed(self):
usr1 = UserFactory(
first_name='name1',
status=User.STATUS_CHOICES.closed,
status_changed=timezone.now() - timedelta(hours=48))
usr4 = UserFactory(
first_name='name4',
status=User.STATUS_CHOICES.closed,
status_changed=timezone.now() - timedelta(hours=12))
usr2 = UserFactory(
first_name='name2',
status=User.STATUS_CHOICES.closed,
status_changed=timezone.now() - timedelta(hours=36))
usr3 = UserFactory(
first_name='name3',
status=User.STATUS_CHOICES.closed,
status_changed=timezone.now() - timedelta(hours=24))
data = {'status': User.STATUS_CHOICES.closed}
url = reverse('accounts:users-list')
response = self.client.get(url, data=data, format='json')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data[0]['first_name'], usr1.first_name)
self.assertEqual(response.data[1]['first_name'], usr4.first_name)
self.assertEqual(response.data[2]['first_name'], usr2.first_name)
self.assertEqual(response.data[3]['first_name'], usr3.first_name)
def manager_get_all_users_and_filtered_users(self):
usr1 = UserFactory(status=User.STATUS_CHOICES.creating)
usr2 = UserFactory(status=User.STATUS_CHOICES.activated)
usr3 = UserFactory(status=User.STATUS_CHOICES.closing)
usr4 = UserFactory(status=User.STATUS_CHOICES.closed)
url = reverse('accounts:users-list')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 4)
self.assertContains(response, usr1.first_name)
self.assertContains(response, usr2.first_name)
self.assertContains(response, usr3.first_name)
self.assertContains(response, usr4.first_name)
data = {'status': User.STATUS_CHOICES.creating}
response = self.client.get(url, data=data, format='json')
self.assertEqual(response.status_code, 200)
self.assertContains(response, usr1.first_name)
data = {'status': User.STATUS_CHOICES.activated}
response = self.client.get(url, data=data, format='json')
self.assertEqual(response.status_code, 200)
self.assertContains(response, usr2.first_name)
data = {'status': User.STATUS_CHOICES.closing}
response = self.client.get(url, data=data, format='json')
self.assertEqual(response.status_code, 200)
self.assertContains(response, usr3.first_name)
data = {'status': User.STATUS_CHOICES.closed}
response = self.client.get(url, data=data, format='json')
self.assertEqual(response.status_code, 200)
self.assertContains(response, usr4.first_name)
def _test_should_not_allow_get_another_profile(self):
user = UserFactory()
auth_user = UserFactory()
url = reverse('user-detail', args=(user.id, ))
self.client.force_authenticate(user=auth_user)
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_should_not_allow_get_not_own_messages(self):
user = UserFactory()
auth_user = UserFactory()
msg = MessageFactory(sender=user)
self.client.force_authenticate(user=auth_user)
url = reverse('message-detail', args=(msg.id,))
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def setUp(self):
self.sender = UserFactory()
self.recipient1 = UserFactory()
self.recipient2 = UserFactory()
self.msg = MessageFactory(sender=self.sender)
self.fake_data = {
'message': self.msg.id,
'recipient': self.recipient1.id
}
def test_should_not_allow_update_another_profile(self):
user = UserFactory()
auth_user = UserFactory()
url = reverse('user-detail', args=(user.id, ))
data = {
'first_name': 'John',
}
self.client.force_authenticate(user=auth_user)
response = self.client.patch(url, data=data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def setUp(self):
self.user = UserFactory(email=fake.email())
self.admin = UserFactory(is_admin=True)
self.profile_one = UserFactory()
self.other_user = UserFactory(email=fake.email())
self.own_profile_url = reverse(f'{self.base_url_name}-own')
self.sign_in_as_user(self.user)
def setUp(self):
self.staff_user = UserFactory(is_staff=True)
self.common_user = UserFactory(is_staff=False)
self.staff_headers = self.get_jwt_header(self.staff_user.username,
'password123!')
self.common_headers = self.get_jwt_header(self.common_user.username,
'password123!')
self.tenant_one = TenantFactory(first_name='Bill', last_name='Murray')
self.tenant_two = TenantFactory(first_name='Nicole',
last_name='Kidman')
def setUp(self):
self.staff_user = UserFactory(is_staff=True)
self.common_user = UserFactory(is_staff=False)
self.staff_headers = self.get_jwt_header(self.staff_user.username,
'password123!')
self.common_headers = self.get_jwt_header(self.common_user.username,
'password123!')
self.landlord_one = LandlordFactory(first_name='George',
last_name='Foreman')
self.landlord_two = LandlordFactory(first_name='Ronda',
last_name='Rousey')
def test_should_allow_create_with_login(self):
user = UserFactory()
self.client.force_authenticate(user=user)
data = self.fake_data(sender=user.id)
url = reverse('message-list')
response = self.client.post(url, data)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_should_require_stripe_token(self):
user = UserFactory()
self.client.force_authenticate(user=user)
url = reverse('creditcard-list')
data = {}
response = self.client.post(url, data)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def handle(self, *args, **options):
users = []
posts = []
votes = []
with open(settings.BASE_DIR + '/bot-config.json') as config:
config = json.load(config)
for x in range(config['number_of_users']):
user = UserFactory(email=generate_random_email())
users.append(user)
for user in users:
random_posts = FuzzyInteger(0, config['max_posts_per_user']).fuzz()
print('Random posts for User ({}) -> {}'.format(
user.username, random_posts))
for _ in range(random_posts):
posts.append(PostFactory(author=user))
for user in users:
random_votes = FuzzyInteger(0, config['max_votes_per_user']).fuzz()
print('Random votes for User ({}) -> {}'.format(
user.username, random_votes))
for _ in range(random_votes):
votes.append(
VoteFactory(author=user, post=random.choice(posts)))
def test_payout_transaction(self):
milestone = MilestoneFactory()
milestone.save()
assigned = UserFactory()
task = TaskFactory(milestone=milestone,
amount=Decimal(1000),
assigned=assigned)
task.save()
user = milestone.project.user
customer = CustomerFactory(user=user)
credit_card = CreditCardFactory(customer=customer)
create_transaction(credit_card.id,
user,
Decimal(1500),
transaction_type=Transaction.ESCROW,
milestone_id=None)
assigned_balance = get_user_balance(assigned.id)
self.assertEqual(assigned_balance, 0)
create_transaction(credit_card.id,
user,
Decimal(1000),
transaction_type=Transaction.MILESTONE,
milestone_id=milestone.id)
expected_amount = task.amount - Decimal(
str(task.amount * config.BRETA_FEE / 100))
assigned_balance = get_user_balance(assigned.id)
self.assertEqual(assigned_balance, expected_amount)
def test_delete_listing_by_non_owner_auth_user_fails(self):
another_user = UserFactory()
self.sign_in_as_user(another_user)
response = self.client.delete(self.get_detail_url(self.listing_one.id))
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_should_not_return_not_own_project(self):
member = ProjectMemberFactory()
user = UserFactory()
self.client.force_authenticate(user=user)
url = reverse('projectmember-detail', args=(member.id, ))
response = self.client.get(url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def setUp(self):
super().setUp()
self.email = '*****@*****.**'
self.password = '******'
self.user = UserFactory(email=self.email)
self.user.set_password(self.password)
self.user.save()
def test_successful_login(self):
user = UserFactory(pin='PIN111', is_active=True)
data = {'pin': user.pin}
url = reverse('accounts:login')
response = self.client.post(url, data=data, format='json')
self.assertEqual(response.status_code, 200)
def test_font_delete_not_owner(self):
self.client.force_authenticate(user=UserFactory(username='******'))
self.assertEqual(Font.objects.all().count(), 1)
self.assertEqual(Symbol.objects.all().count(), 1)
response = self.client.delete(self.url)
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(Font.objects.all().count(), 1)
self.assertEqual(Symbol.objects.all().count(), 1)
def test_get_font_search_no_filter_one_no_moderated_if_admin(self):
self.client.force_authenticate(
user=UserFactory(is_superuser=True, username='******'))
self.admin_font_relation.moderated = False
self.admin_font_relation.save()
response = self.client.get(self.url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 2)
def test_message_create(self):
subject = 'Test'
body = 'Body'
sender = UserFactory()
msg = MessageFactory(subject=subject, body=body, sender=sender)
self.assertEqual(msg.subject, subject)
self.assertEqual(msg.body, body)
self.assertEqual(msg.sender, sender)
def setUp(self) -> None:
self.factory = APIRequestFactory()
self.vendor = VendorFactory()
self.vendor_item = VendorItemFactory(vendor=self.vendor)
self.user = UserFactory()
self.vendor.employees.add(self.user)
self.view = VendorItemModelViewSet.as_view({'get': 'list'})
self.auth_token = AuthTokenFactory(user=self.user)
def test_not_manager_fail_to_use_users_list_api(self):
usr = UserFactory()
self.client.force_authenticate(user=usr)
url = reverse('accounts:users-list')
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
def setUp(self):
self.template = 'customers/union_list.html'
self.url = reverse('customers:union-list')
self.user = UserFactory()
self.admin = AdminUserFactory()
self.management = ManagementUserFactory()
self.staff = StaffUserFactory()
self.guest = GuestUserFactory()
def test_client_deactivate_himself(self):
usr = UserFactory()
self.client.force_authenticate(user=usr)
url = reverse('accounts:users-deactivate')
response = self.client.patch(url)
self.assertEqual(response.status_code, 200)
def alt_child_user(db):
"""Creates alternate child website user."""
user = UserFactory(username='******',
name='Sophie',
email='*****@*****.**',
user_type=User.TYPE_CHILD,
profile_photo='')
return user
def parent_user(db):
"""Creates a parent website user."""
user = UserFactory(username='******',
name='Tom',
email='*****@*****.**',
user_type=User.TYPE_PARENT,
profile_photo='')
return user
def child_user(db):
"""Creates a child website user."""
user = UserFactory(username='******',
name='Natalie',
email='*****@*****.**',
user_type=User.TYPE_CHILD,
profile_photo='')
return user
def test_delete_listing_by_owner_auth_user_succeeds(self):
owner = UserFactory()
listing = ListingFactory(user=owner)
self.sign_in_as_user(owner)
response = self.client.delete(self.get_detail_url(listing.id))
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_create_listing_by_auth_user_with_invalid_data_fails(self):
user = UserFactory()
self.sign_in_as_user(user)
response = self.client.post(self.get_list_url(), {'title': 'Hello?'})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def admin_user(db):
"""Creates an administrator website user."""
user = UserFactory(username='******',
name='Mac',
email='*****@*****.**',
user_type=User.TYPE_ADMIN,
profile_photo='')
return user
