def test_nearby_going_query(self): # Creates the available journeys with driver... user1 = UserFactory() residence1 = ResidenceFactory(user=user1, position=Point(883877.34, 547084.05, srid=DEFAULT_PROJECTED_SRID)) user2 = UserFactory() residence2 = ResidenceFactory(user=user2, position=Point(882823.07, 545542.48, srid=DEFAULT_PROJECTED_SRID)) campus = CampusFactory() user3 = UserFactory() residence3 = ResidenceFactory(user=user3, position=Point(865621.24, 545274.90, srid=DEFAULT_PROJECTED_SRID)) template = JourneyTemplateFactory(user=user1, driver=user1, residence=residence1, campus=campus) JourneyFactory(template=template) template = JourneyTemplateFactory(user=user2, driver=user2, residence=residence2, campus=campus) JourneyFactory(template=template) template = JourneyTemplateFactory(user=user3, driver=user3, residence=residence3, campus=campus) JourneyFactory(template=template) point = Point(882532.74, 545437.43, srid=DEFAULT_PROJECTED_SRID) self.assertEquals(Journey.objects.nearby( geometry=point, distance=D(m=2500), kind=GOING ).count(), 2)
def test_smart_create_no_transport(self): """Test smart create of a journey without transport.""" user = UserFactory() origin = ResidenceFactory(user=user) destination = CampusFactory() journey = Journey.objects.smart_create(user=user, origin=origin, destination=destination, departure=timezone.now() + datetime.timedelta(days=1)) self.assertEquals(Journey.objects.count(), 1) self.assertEquals(Journey.objects.first(), journey)
def setUp(self): self.user_student = UserFactory(name="user_student") self.user_student2 = UserFactory(name="user_student2") self.user_teacher = UserFactory( name="teacher_user", user_type=User.USER_TYPE_TEACHER ) self.user_teacher2 = UserFactory( name="teacher_user2", user_type=User.USER_TYPE_TEACHER ) self.school_user = UserFactory( name="school_user", user_type=User.USER_TYPE_SCHOOL ) self.school_user2 = UserFactory( name="school_user2", user_type=User.USER_TYPE_SCHOOL ) self.school = SchoolFactory(user=self.school_user) self.student = StudentFactory(user=self.user_student, school=self.school) self.teacher = TeacherFactory(user=self.user_teacher, school=self.school) self.class_instance = ClassFactory(school=self.school, teacher=self.teacher) self.class_instance.students.add(self.student) self.school2 = SchoolFactory(user=self.school_user2) self.student2 = StudentFactory(user=self.user_student2, school=self.school2) self.teacher2 = TeacherFactory(user=self.user_teacher2, school=self.school2) self.class_instance2 = ClassFactory(school=self.school2, teacher=self.teacher2) self.class_instance2.students.add(self.student2) self.token = Token.objects.create(user=self.user_student) self.client.credentials(HTTP_AUTHORIZATION=f"Token {self.token.key}")
def test_it_can_send_an_explicit_file_as_input(db, settings, fake_soap_call, django_file_storage): settings.HP_ACTION_CUSTOMER_KEY = "blarg" out = StringIO() user = UserFactory() fake_soap_call.simulate_success(user) call_command("hpsend", user.username, "--xml-input-file", __file__, *EXTRACT_BASENAME_ARGS, stdout=out) assert ".py as input for document assembly" in out.getvalue()
def test_author_update_returns_200_given_valid_input(self): user = UserFactory(is_staff=True) token = TokenFactory(user=user) self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key) body = { 'name': 'Steven King', } response = self.client.patch(self.url, json.dumps(body), content_type='application/json') self.assertEqual(200, response.status_code)
def test_author_update_updates_a_author_given_valid_input(self): user = UserFactory(is_staff=True) token = TokenFactory(user=user) self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key) body = { 'name': 'Steven King', } self.client.patch(self.url, json.dumps(body), content_type='application/json') self.assertTrue(Author.objects.filter(name='Steven King').exists())
def test_forbidden_superuser_creation(self): self.user = UserFactory(name='super', email='*****@*****.**') self.client.force_authenticate(self.user) response = self.client.post(reverse('superuser_create'), { 'name': 'test', 'email': '*****@*****.**', 'password': '******' }, format='json') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(User.objects.count(), 1)
def test_it_works(self, settings): UserFactory(phone_number="5551234567", username="******") UserFactory(phone_number="5551230000", username="******") lookup = PhoneNumberLookup(phone_number="5551234567", is_valid=True, carrier={"type": "mobile"}) lookup.save() settings.TWILIO_ACCOUNT_SID = "blarg" with self.mock_twilio(is_valid=False): assert self.run_command() == [ "Looking up phone number for blarg.", "Done syncing phone number lookups.", ] self.is_phone_number_valid.assert_called_once_with("5551230000") self.is_phone_number_valid.reset_mock() assert self.run_command() == ["Done syncing phone number lookups."] self.is_phone_number_valid.assert_not_called() assert PhoneNumberLookup.objects.get( phone_number="5551230000").is_valid is False
def test_it_works(self, settings): UserFactory(phone_number='5551234567', username='******') UserFactory(phone_number='5551230000', username='******') lookup = PhoneNumberLookup(phone_number='5551234567', is_valid=True, carrier={'type': 'mobile'}) lookup.save() settings.TWILIO_ACCOUNT_SID = 'blarg' with self.mock_twilio(is_valid=False): assert self.run_command() == [ 'Looking up phone number for blarg.', 'Done syncing phone number lookups.' ] self.is_phone_number_valid.assert_called_once_with('5551230000') self.is_phone_number_valid.reset_mock() assert self.run_command() == ['Done syncing phone number lookups.'] self.is_phone_number_valid.assert_not_called() assert PhoneNumberLookup.objects.get( phone_number='5551230000').is_valid is False
def setUpTestData(cls): cls.unicef_staff = UserFactory(is_staff=True) cls.partner = PartnerFactory( partner_type=PartnerType.CIVIL_SOCIETY_ORGANIZATION, cso_type="International", hidden=False, vendor_number="DDD", short_name="Short name", ) cls.url = reverse( 'partners_api:partner-delete', args=[cls.partner.pk] )
def setUpTestData(cls): cls.unicef_staff = UserFactory(is_staff=True) cls.intervention = InterventionFactory() cls.result_link = InterventionResultLinkFactory() cls.lower_result = LowerResultFactory( name="LL Name", result_link=cls.result_link, ) cls.indicator = IndicatorBlueprintFactory() cls.applied = AppliedIndicatorFactory(context_code="CC321", indicator=cls.indicator, lower_result=cls.lower_result) cls.url = reverse("applied-indicator")
def test_get_notifications(self): user = UserFactory() [ NotificationFactory(user=user, verb=random.choice([JOIN, LEAVE]), actor=UserFactory(), target=self._make_journey(user)) for _ in range(5) ] [ NotificationFactory(user=UserFactory(), verb=random.choice([JOIN, LEAVE]), actor=UserFactory(), target=self._make_journey(user)) for _ in range(5) ] url = "/api/v1/notifications/" self.client.force_authenticate(user=user) response = self.client.get(url) self.assertEqual(response.status_code, status.HTTP_200_OK) response_data = json.loads(response.content.decode('utf-8')) self.assertEquals(5, len(response_data['results']))
def create_user(*, email, password, first_name='', last_name='', is_active=True): user = UserFactory(email=email, first_name=first_name, last_name=last_name, is_active=is_active) user.set_password(password) user.save() return user
def test_user_delete_order_invalid(self): """Users can not delete other user's orders.""" non_order_owner = UserFactory() self.client.credentials( HTTP_AUTHORIZATION="Token " + non_order_owner.auth_token.key ) response = self.client.delete( reverse("v1:orders-detail", args=[self.order_1.pk]) ) # Returns HTTP 404 as other user's orders are not visible to non admin self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) self.assertTrue(Order.objects.filter(pk=self.order_1.pk).exists())
def test_get_messages_journey(self): user = UserFactory() origin = ResidenceFactory(user=user) destination = CampusFactory() journey = JourneyFactory(user=user, residence=origin, campus=destination) [ MessageFactory(user=UserFactory(), journey=JourneyFactory(user=UserFactory(), residence=origin, campus=destination)) for _ in range(2) ] [MessageFactory(user=user, journey=journey) for _ in range(5)] [MessageFactory(user=UserFactory(), journey=journey) for _ in range(5)] url = "/api/v1/journeys/{}/messages/".format(journey.pk) self.client.force_authenticate(user=user) response = self.client.get(url) self.assertEqual(response.status_code, status.HTTP_200_OK) response_data = json.loads(response.content.decode('utf-8')) self.assertEquals(10, len(response_data['results']))
def test_user_partial_update_invalid(self): """Users can not patch user data.""" user = UserFactory() self.client.credentials(HTTP_AUTHORIZATION="Token " + user.auth_token.key) data = {"first_name": "New Name"} response = self.client.patch( reverse("v1:users-detail", args=[self.user.pk]), data) self.user.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(self.user.first_name, "Name")
def test_description_can_have_html_entities(self): material = MaterialFactory(description="→") self.client.force_login(UserFactory()) response = self.client.get(reverse("catalog:catalog")) self.assertTemplateUsed(response, "catalog/material_list.html") self.assertNotContains( response, "→", msg_prefix="the material description was escaped") self.assertContains( response, "→", msg_prefix="the material description does not match")
def test_clean_activate(self): """If staff member made active, ensure user not already associated with another partner """ UserFactory(email="*****@*****.**") partner = PartnerFactory() staff = PartnerStaffFactory( partner=partner, email="*****@*****.**", active=False ) form = forms.PartnerStaffMemberForm(self.data, instance=staff) self.assertTrue(form.is_valid())
def test_partial_update_exchanges_invalid(self): """Users can not partially update exchanges.""" user = UserFactory() self.client.credentials(HTTP_AUTHORIZATION="Token " + user.auth_token.key) data = {"name": "New Exchange Name"} response = self.client.patch( reverse("v1:exchanges-detail", args=[self.exchange.pk]), data) self.exchange.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(self.exchange.name, "Exchange")
def setUp(self): self.factory = APIRequestFactory() self.user = User.objects.create_user(username='******', email='*****@*****.**', password='******') self.user.is_superuser = True self.user.save() self.token = Token.objects.create(user=self.user) self.token.save() self.client.credentials(HTTP_AUTHORIZATION='Token ' + self.token.key) for i in range(10): UserFactory()
def setUp(self): self.admin = AdminFactory() self.client.credentials(HTTP_AUTHORIZATION="Token " + self.admin.auth_token.key) self.user = UserFactory(first_name="Name") self.data = { "first_name": "Test", "last_name": "User", "email": "*****@*****.**", "is_active": True, "is_staff": False, "is_superuser": False, }
def test_it_creates_reminder_when_sms_failed_and_should_not_be_retried( self, db): user = UserFactory() result = Reminder.objects.try_to_create_from_send_sms_result( SendSmsResult(err_code=TWILIO_BLOCKED_NUMBER_ERR), kind=REMINDERS.LOC, user=user) assert result and result.pk assert result.sid == "" assert result.err_code == TWILIO_BLOCKED_NUMBER_ERR assert result.kind == REMINDERS.LOC assert result.user == user
def test_asset_partial_update_invalid(self): """Assets can not be partially updated by users.""" user = UserFactory() self.client.credentials(HTTP_AUTHORIZATION="Token " + user.auth_token.key) data = {"name": "New Name"} response = self.client.patch( reverse("v1:assets-detail", args=[self.asset.pk]), data) self.asset.refresh_from_db() self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(self.asset.name, "Asset")
def test_get_no_profile(self): """Ensure profile is created for user, if it does not exist""" user = UserFactory() UserProfile.objects.get(user=user).delete() self.assertFalse(UserProfile.objects.filter(user=user).exists()) response = self.forced_auth_req( "get", self.url, user=self.unicef_staff, ) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(response.data["name"], user.get_full_name()) self.assertFalse(UserProfile.objects.filter(user=user).exists())
def setUpTestData(cls): cls.unicef_staff = UserFactory(is_staff=True) cls.intervention = InterventionFactory() cls.intervention.old_instance = cls.intervention cls.validator = InterventionValid( cls.intervention, user=cls.unicef_staff, disable_rigid_check=True, ) cls.validator.permissions = cls.validator.get_permissions( cls.intervention ) cls.future_date = datetime.date.today() + datetime.timedelta(days=2)
def setUp(self): self.super = UserFactory(email='*****@*****.**', is_superuser=True) self.user_one = UserFactory(id=98, email='*****@*****.**') self.user_two = UserFactory(id=99, email='*****@*****.**') self.wallet_one = WalletFactory(user=self.user_one, id=1) self.wallet_two = WalletFactory(user=self.user_two, id=2) self.credit_card_one = CreditCardFactory(wallet=self.wallet_one, id=1, number='1234567891011121', limit='300.00', expires_at=date(2018, 10, 10)) self.credit_card_two = CreditCardFactory(wallet=self.wallet_one, id=2, number='1234567891011120', limit='500.00', expires_at=date(2018, 10, 20)) self.credit_card_three = CreditCardFactory(wallet=self.wallet_one, id=3, number='1234567891011122', limit='600.00', expires_at=date( 2018, 10, 30))
def setUp(self): super().setUp() self.user_school = UserFactory( name="user_school", user_type=User.USER_TYPE_SCHOOL ) self.user_school2 = UserFactory( name="user_school", user_type=User.USER_TYPE_SCHOOL ) self.user_teacher = UserFactory( name="user_teacher", user_type=User.USER_TYPE_TEACHER ) self.user_teacher2 = UserFactory( name="user_teacher2", user_type=User.USER_TYPE_TEACHER ) self.school = SchoolFactory(user=self.user_school) self.teacher = TeacherFactory(school=self.school, user=self.user_teacher) self.class_instance = ClassFactory(school=self.school, teacher=self.teacher) self.class_video = ClassVideoFactory( author=self.user_teacher, uploaded_class=self.class_instance ) self.class_video_comment = ClassVideoCommentFactory( video=self.class_video, author=self.user_teacher ) self.school2 = SchoolFactory(user=self.user_school2) self.teacher2 = TeacherFactory(school=self.school2, user=self.user_teacher2) self.class_instance2 = ClassFactory(school=self.school2, teacher=self.teacher2) self.class_video2 = ClassVideoFactory( author=self.user_teacher2, uploaded_class=self.class_instance2 ) self.class_video_comment2 = ClassVideoCommentFactory( video=self.class_video2, author=self.user_teacher2 ) self.token = Token.objects.create(user=self.user_teacher) self.client.credentials(HTTP_AUTHORIZATION=f"Token {self.token.key}")
def test_author_detail_returns_valid_response_given_valid_input(self): user = UserFactory(is_staff=True) token = TokenFactory(user=user) self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key) expected_response = { 'id': 999, 'name': 'Steven King', } response = self.client.get(self.url) self.assertEqual(expected_response, response.json())
def setUpTestData(cls): cls.user = UserFactory() cls.partner = PartnerFactory(partner_type=PartnerType.CIVIL_SOCIETY_ORGANIZATION) cls.today = datetime.date.today() # The serializer examines context['request'].user during the course of its operation. If that's not set, the # serializer will fail. It doesn't need a real request object, just something with a .user attribute, so # that's what I create here. class Stub(object): pass cls.fake_request = Stub() cls.fake_request.user = cls.user
def test_category_detail_returns_valid_response_given_valid_input(self): user = UserFactory(is_staff=True) token = TokenFactory(user=user) self.client.credentials(HTTP_AUTHORIZATION='Token ' + token.key) expected_response = { 'id': 999, 'name': 'Drama', 'description': 'Titanic stuff' } response = self.client.get(self.url) self.assertEqual(expected_response, response.json())