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())
