class TranslatedUserObjectPermissionsFormTestCase(TestCase):
def setUp(self):
self.obj = UserFactory()
self.user = UserFactory()
def test_delete_all_permissions(self):
assign_perm('users.change_user', self.user, self.obj)
self.assertTrue(self.user.has_perm('users.change_user', self.obj))
form = TranslatedUserObjectPermissionsForm(data={'permissions': ''},
user=self.user,
obj=self.obj)
self.assertTrue(form.is_valid())
form.save_obj_perms()
self.assertFalse(self.user.has_perm('users.change_user', self.obj))
self.assertEqual(get_perms(self.user, self.obj), [])
class UserDetailViewTestCase(TestCase):
def setUp(self):
self.object = UserFactory(is_staff=False)
def login(self, user=None):
self.client.login(username=(user or self.object).username, password='******')
def get(self):
return self.client.get(self.object.get_absolute_url())
def own_resp(self):
self.login()
return self.get()
def test_contains_username(self):
self.assertContains(self.own_resp(), self.object.username)
def test_contains_assigned_cases(self):
url = reverse_lazy('cases:list') + '?permission=' + str(self.object.pk)
self.login()
self.assertNotContains(self.own_resp(), url)
user = UserFactory()
assign_perm('users.can_view_other', user)
assign_perm('cases.can_assign', user)
self.login(user=user)
self.assertContains(self.get(), url)
def test_get_context_data_is_staff(self):
self.client.login(username=UserFactory(is_staff=True,
is_superuser=True).username,
password='******')
resp = self.client.get(self.url, data={'is_staff': 1})
context_data = resp.context_data
self.assertIn('is_staff', context_data)
self.assertEqual(context_data['is_staff']['selected'], 1)
self.assertIn('choices', context_data['is_staff'])
def test_register__user_already_logged_in(self):
logged_in_user = UserFactory() # Create, don't build
new_user = UserFactory.build() # Build, don't create
data = {
"username": new_user.username,
"email": new_user.email,
"password": "******",
}
request = self.factory.post("/api/user/", data)
force_authenticate(request, logged_in_user)
with mock.patch("users.api.views.send_welcome_email"
) as mock_send_welcome_email:
response = UserCreateAPIView.as_view()(request)
response.render()
self.assertEqual(response.status_code, 400)
self.assertEqual(response.data, ["You have already signed up"])
self.assertEqual(mock_send_welcome_email.call_count, 0)
def setUp(self):
self.url = self.reverse('api:product-create-subproducts')
self.member_organisation = MemberOrganisationFactory()
self.profile = ProfileFactory()
self.user = UserFactory(profile=self.profile)
# string token
self.token = AuthTokenFactory(user=self.user)
self.api_client = APIClient()
self.api_client.credentials(HTTP_AUTHORIZATION=f'Token {self.token}')
def test_website_collaborator_serializer():
""" WebsiteCollaboratorSerializer should serialize a User object with correct fields """
collaborator = (User.objects.filter(id=UserFactory.create().id).annotate(
role=Value(ROLE_EDITOR, CharField())).first())
serialized_data = WebsiteCollaboratorSerializer(instance=collaborator).data
assert serialized_data["user_id"] == collaborator.id
assert serialized_data["name"] == collaborator.name
assert serialized_data["email"] == collaborator.email
assert serialized_data["role"] == ROLE_EDITOR
def create_user(self, user_type: str, number_of_users_to_create: int = 1) -> None:
factory_parameters = self._set_user_factory_parameters(user_type)
for user_number in range(number_of_users_to_create):
user_email = f"user.{user_type}{user_number + 1}@codepoets.it".lower()
if not CustomUser.objects.filter(email=user_email).exists():
logging.info(f"{number_of_users_to_create - user_number} {user_type}(s) left to create")
UserFactory(**factory_parameters, email=user_email)
def test_delete_user_device_wrong_user(user_api_client):
other_user = UserFactory()
user_device = UserDeviceFactory(user=other_user)
url = get_user_device_detail_url(user_device)
response = user_api_client.delete(url)
assert response.status_code == 403
assert UserDevice.objects.count() == 1
def handle(self, *args, **kwargs):
UserFactory.create(email="*****@*****.**",
is_staff=True,
is_superuser=True)
dealers = []
for dealer in [("Parts Express", "https://www.parts-express.com")]:
dealers.append(
DealerFactory.create(name=dealer[0], website=dealer[1]))
self.stdout.write("Created {0} Dealer(s)".format(len(dealers)))
dealer_scrapers = []
for dealer in dealers:
dealer_scrapers.append(
DealerScraperFactory.create(class_name="PartsExpressScraper",
dealer=dealer))
self.stdout.write("Created {0} DealerScraper(s)".format(
len(dealer_scrapers)))
def test_put_fail_missing_fields(self):
user = UserFactory(email="*****@*****.**")
self.assertIsInstance(user, User)
self.set_user(user)
self.assertEqual(user.email, "*****@*****.**")
data = {}
path = self.get_path(id_detail=user.id)
response = self.client.put(path, data, HTTP_AUTHORIZATION=self.auth)
self.assertEqual(
response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.data
)
self.assertEqual(User.objects.count(), 1)
user.refresh_from_db()
self.assertEqual(user.email, "*****@*****.**")
def test_fetch_users(prop, values, db_values):
"""
fetch_users should return a set of Users that match some provided values which represent
ids, emails, or usernames
"""
users = UserFactory.create_batch(
len(values), **{prop: factory.Iterator(db_values or values)}
)
found_users = fetch_users(values)
assert set(users) == set(found_users)
def test_websites_endpoint_list_forbidden_methods(drf_client, method):
"""No put, patch, or delete requests allowed at this endpoint"""
drf_client.force_login(UserFactory.create(is_superuser=True))
client_func = getattr(drf_client, method)
resp = client_func(reverse("websites_api-list"),
data={
"name": "fakename",
"title": "Fake Title"
})
assert resp.status_code == 405
def test_authenticated__can_post_message(self):
user = UserFactory() # Create, don't build
message = MessageFactory(user=user) # Create, don't build
data = {"message": message.message}
request = self.factory.post("/api/wall/", data)
force_authenticate(request, user)
response = MessageListCreateAPIView.as_view()(request, data)
self.assertEqual(response.status_code, 201, response.data)
self.assertEqual(response.data["message"], data["message"])
def setUp(self):
self.user = UserFactory(
password=PostGenerationMethodCall('set_password', 'codebuddies'))
url = '/auth/obtain_token/'
data = {"username": self.user.username, "password": "******"}
token_response = self.client.post(url, data, format='json')
self.client.credentials(HTTP_AUTHORIZATION='Bearer ' +
token_response.data['token'])
def test_multiple_success_blocking_user(self):
"""test block_users command blocking emails success with more than one user"""
test_usernames = ["*****@*****.**", "*****@*****.**", "*****@*****.**"]
for username in test_usernames:
user = UserFactory.create(username=username, is_active=True)
assert BlockList.objects.all().count() == 0
COMMAND.handle("block_users", users=test_usernames, block_users=True)
assert BlockList.objects.all().count() == 3
def setUp(self):
self.path = "/user/login/"
self.anonymous_client = self.get_anonymous_client()
self.password = "******"
self.user = UserFactory(password=self.password)
self.example_data = {
"username": self.user.username,
"password": self.password,
}
def test_get_is_staff_choice(self):
self.client.login(username=UserFactory(is_staff=True).username,
password='******')
self.assertEqual(self.get_view().get_is_staff_choice(), 0) # Default
self.assertEqual(self.get_view(is_staff='a').get_is_staff_choice(),
0) # Non-num
self.assertEqual(self.get_view(is_staff='5').get_is_staff_choice(),
0) # Too large
self.assertEqual(self.get_view(is_staff=1).get_is_staff_choice(),
1) # Correct
def test_for_user(self):
self.assertFalse(
Advice.objects.for_user(
UserFactory()).filter(pk=AdviceFactory().pk).exists())
# has perm
user = UserFactory()
assign_perm('advicer.can_view_all_advices', user)
self.assertTrue(
Advice.objects.for_user(user).filter(
pk=AdviceFactory().pk).exists())
# advicer
user = UserFactory()
self.assertTrue(
Advice.objects.for_user(user).filter(pk=AdviceFactory(
advicer=user).pk).exists())
# created_by
self.assertTrue(
Advice.objects.for_user(user).filter(pk=AdviceFactory(
created_by=user).pk).exists())
def test_forgot_password_availability(client):
user = UserFactory(
reset_password_token=User.generate_token(),
reset_password_request_date=timezone.now(),
)
payload = dict(email=user.email)
response = client.post(reverse('users:forgot_password'), payload)
assert response.status_code == 400
def test_contains_assigned_cases(self):
url = reverse_lazy('cases:list') + '?permission=' + str(self.object.pk)
self.login()
self.assertNotContains(self.own_resp(), url)
user = UserFactory()
assign_perm('users.can_view_other', user)
assign_perm('cases.can_assign', user)
self.login(user=user)
self.assertContains(self.get(), url)
def test_patch_picture(self):
user = UserFactory(email="*****@*****.**")
self.assertIsInstance(user, User)
self.set_user(user)
self.assertEqual(user.email, "*****@*****.**")
data = {"picture": open(self._image_path, "rb")}
path = self.get_path(id_detail=user.id)
response = self.client.patch(
path, data, HTTP_AUTHORIZATION=self.auth, format="multipart"
)
self.assertEqual(response.status_code, status.HTTP_200_OK, msg=response.data)
self.assertEqual(User.objects.count(), 1)
user.refresh_from_db()
self.assertEqual(user.picture.name, f"users/{user.id}/picture.jpg")
def test_projects_list_view_for_manager_should_show_only_projects_in_which_he_is_manager(
self):
manager_user = UserFactory(user_type=CustomUser.UserType.MANAGER.name)
manager_project = ProjectFactory()
manager_project.managers.add(manager_user)
self.client.force_login(manager_user)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertContains(response, manager_project.name)
self.assertNotContains(response, self.project.name)
def test_unauthorized_user_cannot_create_product(self):
user = UserFactory(is_admin=False, is_active=True)
self.client.force_login(user)
response = self.client.post(reverse('products:product-list'),
data=self.data)
self.assertEqual(response.status_code, 403)
self.assertDictEqual(
response.json(),
{'detail': 'You do not have permission to perform this action.'})
def test_list(self):
users = UserFactory.create_batch(3)
self.assertEqual(User.objects.count(), 3)
self.set_user(users[0])
path = self.get_path()
response = self.client.get(path, HTTP_AUTHORIZATION=self.auth)
self.assertEqual(response.status_code, status.HTTP_200_OK, msg=response.data)
self.assertEqual(len(response.data.get("results")), 1, msg=response.data)
def test_closed_to_assigned(self):
staff = UserFactory(is_staff=True)
case = CaseFactory(pk=639, status=Case.STATUS.closed)
assign_perm('cases.can_send_to_client', staff, case)
msg = self.get_message('cc_message.eml')
mail_process(sender=self.mailbox, message=msg)
case.refresh_from_db()
self.assertEqual(case.status, Case.STATUS.assigned)
def test_get(self):
user = UserFactory(email="*****@*****.**")
self.assertEqual(User.objects.count(), 1)
self.set_user(user)
path = self.get_path(id_detail=user.id)
response = self.client.get(path, HTTP_AUTHORIZATION=self.auth)
self.assertEqual(response.status_code, status.HTTP_200_OK, msg=response.data)
self.assertEqual(response.data.get("email"), "*****@*****.**")
def setUp(self):
cache.clear()
self.api_basename = "categories:admin-category"
# user
self.user = UserFactory.create()
self.user.set_password("test1234")
self.user.save()
refresh = RefreshToken.for_user(self.user)
self.client.credentials(
HTTP_AUTHORIZATION=f"Bearer {refresh.access_token}")
def test_cannot_see_others_consents(user_api_client):
another_user = UserFactory()
another_user_consent = UserConsentFactory(user=another_user)
response = user_api_client.get(LIST_URL)
assert response.status_code == 200
assert len(response.data['results']) == 0
response = user_api_client.get(get_detail_url(another_user_consent))
assert response.status_code == 404
def tagged_users(self, create, extracted, **kwargs):
if create:
if isinstance(extracted, list):
for user in extracted:
self.tagged_users.add(user)
else:
rand_int = random.randint(0, 2)
for i in range(rand_int):
self.tagged_users.add(
UserFactory(connected_users=[], blocked_users=[]))
def test_sync_contact_with_hubspot(mock_hubspot_request):
"""Test that send_hubspot_request is called properly for a CONTACT sync"""
user = UserFactory.create()
sync_contact_with_hubspot(user.id)
body = make_contact_sync_message(user.id)
body[0]["changeOccurredTimestamp"] = ANY
mock_hubspot_request.assert_called_once_with("CONTACT",
HUBSPOT_SYNC_URL,
"PUT",
body=body)
def test_project_update_view_should_not_update_managers_if_user_is_manager(
self):
assert self.project.managers.count() == 0
user_manager = UserFactory(user_type=CustomUser.UserType.MANAGER.name)
self.client.force_login(user=user_manager)
self.data["managers"] = [self.user.pk, user_manager.pk]
response = self.client.post(self.url, self.data)
self.assertEqual(response.status_code, 404)
self.project.refresh_from_db()
self.assertEqual(self.project.managers.count(), 0)
def setUp(self):
self.user = UserFactory(password='******')
self.staff = UserFactory(
password='******',
is_staff=True,
groups=[JobsBoardAdminGroupFactory()],
)
self.job_category = JobCategoryFactory(
name='Game Production',
slug='game-production'
)
self.job_type = JobTypeFactory(
name='FrontEnd Developer',
slug='frontend-developer'
)
self.job = ApprovedJobFactory(
description='Lorem ipsum dolor sit amet',
category=self.job_category,
city='Memphis',
region='TN',
country='USA',
email='*****@*****.**',
is_featured=True,
telecommuting=True,
)
self.job.job_types.add(self.job_type)
self.job_draft = DraftJobFactory(
description='Lorem ipsum dolor sit amet',
category=self.job_category,
city='Memphis',
region='TN',
country='USA',
email='*****@*****.**',
is_featured=True,
creator=self.user,
)
self.job_draft.job_types.add(self.job_type)
def setUpClass(cls):
super().setUpClass()
cls.user = UserFactory.create()
cls.user.save()
# needed to get names of HVCs, have to do again because factory
# remembers other tests, even if flushed from DB
for i in range(255):
HVCFactory.create(
campaign_id='E%03d' % (i + 1),
financial_year=16,
)
def test_admin_new_password(self):
self._make_staff()
self._login()
UserFactory.create(email='*****@*****.**')
response = self.alice_client.post(
reverse('admin-new-password'),
{'email': '*****@*****.**'},
)
self.assertEqual(response.status_code, 201)
self.assertEquals(len(mail.outbox), 1)
self.assertEquals(
mail.outbox[0].subject,
'Export Wins Login Credentials',
)
self.assertIn(
'This email contains your login credentials',
mail.outbox[0].body,
)
self.assertEqual(
mail.outbox[0].to[0],
'*****@*****.**',
)
def get_data(self):
self.email = UserFactory.build().email
return {u'attachment_set-0-DELETE': '',
u'attachment_set-0-attachment': '',
u'attachment_set-0-id': '',
u'attachment_set-0-letter': '',
u'attachment_set-1-DELETE': '',
u'attachment_set-1-attachment': '',
u'attachment_set-1-id': '',
u'attachment_set-1-letter': '',
u'attachment_set-2-DELETE': '',
u'attachment_set-2-attachment': '',
u'attachment_set-2-id': '',
u'attachment_set-2-letter': '',
u'attachment_set-INITIAL_FORMS': '0',
u'attachment_set-MAX_NUM_FORMS': '1000',
u'attachment_set-MIN_NUM_FORMS': '0',
u'attachment_set-TOTAL_FORMS': '3',
u'client-autocomplete': '',
u'email': self.email,
u'giodo': 'on',
u'name': 'Lorem ipsum subject example',
u'text': 'Lorem ipsum example text'}
def setUp(self):
self.object = UserFactory(is_staff=False)
def setUp(self):
self.client = Client()
self.alice_client = AliceClient()
self.user = UserFactory.create()
self.user.set_password('asdf')
self.user.save()
self.superuser = UserFactory.create(is_superuser=True, email="[email protected]")
self.wins_schema = reverse("drf:win-schema")
self.wins_list = reverse("drf:win-list")
self.wins_detail = reverse("drf:win-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.customerresponses_schema = reverse("drf:customerresponse-schema")
self.customerresponses_list = reverse("drf:customerresponse-list")
self.customerresponses_detail = reverse("drf:customerresponse-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.breakdowns_schema = reverse("drf:breakdown-schema")
self.breakdowns_list = reverse("drf:breakdown-list")
self.breakdowns_detail = reverse("drf:breakdown-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.advisors_schema = reverse("drf:advisor-schema")
self.advisors_list = reverse("drf:advisor-list")
self.advisors_detail = reverse("drf:advisor-detail", kwargs={
"pk": "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
})
self.win = WinFactory.create()
self.WINS_POST_SAMPLE = {
"user": self.user.id,
"cdms_reference": "cdms reference",
"company_name": "company name",
"country": "AF",
"created": "2016-05-17T12:44:48.021705Z",
"customer_email_address": "*****@*****.**",
"customer_job_title": "customer job title",
"customer_location": 3,
"customer_name": "customer name",
"date": "1979-06-01",
"description": "asdlkjskdlfkjlsdjkl",
"goods_vs_services": 1,
"has_hvo_specialist_involvement": True,
"hq_team": "other:1",
"hvo_programme": "BSC-01",
"is_e_exported": True,
"is_line_manager_confirmed": True,
"is_personally_confirmed": True,
"is_prosperity_fund_related": True,
"lead_officer_name": "lead officer name",
"line_manager_name": "line manager name",
"location": "Edinburgh, UK",
"sector": 1,
"team_type": "investment",
"total_expected_export_value": 5,
"total_expected_non_export_value": 5,
"total_expected_odi_value": 5,
"type": 1,
"type_of_support_1": 1,
"business_type": 1,
"name_of_export": "name",
"name_of_customer": "name",
}
self.CUSTOMER_RESPONSES_POST_SAMPLE = {
"win": str(self.win.pk),
"name": "bob",
"improved_profile": "1",
"gained_confidence": "1",
"access_to_information": "1",
"expected_portion_without_help": "1",
"last_export": "1",
"overcame_problem": "1",
"developed_relationships": "1",
"access_to_contacts": "1",
"our_support": "1",
"marketing_source": "1",
"other_marketing_source": ""
}
self.BREAKDOWNS_POST_SAMPLE = {
"win": str(self.win.pk),
"type": Breakdown.TYPE_EXPORT,
"year": "1999",
"value": "1",
}
self.ADVISORS_POST_SAMPLE = {
"win": str(self.win.pk),
"name": "bob",
"team_type": "other",
"hq_team": "team:1",
"location": "france"
}
def setUp(self):
self.user_list = UserFactory.create_batch(size=1, is_staff=False)
self.staff_list = UserFactory.create_batch(size=1, is_staff=True)
self.object_list = self.user_list + self.staff_list
def setUp(self):
self.obj = UserFactory()
self.user = UserFactory()
