def test_periodlist_only_periods_in_subject(self):
testsubject = mommy.make('core.Subject')
othersubject = mommy.make('core.Subject')
testperiod1 = mommy.make_recipe('devilry.apps.core.period_active',
parentnode=testsubject,
long_name='Testsubject Period 1')
testperiod2 = mommy.make_recipe('devilry.apps.core.period_active',
parentnode=othersubject,
long_name='Othersubject Period 1')
testuser = mommy.make(settings.AUTH_USER_MODEL)
periodpermissiongroup = mommy.make('devilry_account.PeriodPermissionGroup',
period=testperiod1)
mommy.make('devilry_account.PermissionGroupUser',
user=testuser, permissiongroup=periodpermissiongroup.permissiongroup)
periodpermissiongroup2 = mommy.make('devilry_account.PeriodPermissionGroup',
period=testperiod2)
mommy.make('devilry_account.PermissionGroupUser',
user=testuser, permissiongroup=periodpermissiongroup2.permissiongroup)
mockresponse = self.mock_http200_getrequest_htmls(cradmin_role=testsubject, requestuser=testuser)
self.assertEqual(
1,
mockresponse.selector.count('.django-cradmin-listbuilder-itemvalue-titledescription-title')
)
self.assertEqual(
'Testsubject Period 1',
mockresponse.selector.one(
'.django-cradmin-listbuilder-itemvalue-titledescription-title').alltext_normalized
)
def upload_timetable_specified_sessions_only(self):
start_date = datetime(2016, 3, 22, tzinfo=timezone.utc) # tues
end_date = datetime(2016, 3, 23, tzinfo=timezone.utc) # wed
self.assertEquals(Event.objects.all().count(), 0)
# create some timetabled sessions for mondays, tuesdays and Wednesdays
tues_sessions = mommy.make_recipe('booking.tue_session', _quantity=3)
mommy.make_recipe('booking.wed_session', _quantity=3)
session_ids = [
session.id for session in Session.objects.all() if
session in tues_sessions
]
# choose tues-wed as date range, but specify the tues sessions only
upload_timetable(start_date, end_date, session_ids)
# check that there are now classes on the dates specified
tue_classes = Event.objects.filter(
date__gte=self._start_of_day(start_date),
date__lte=self._end_of_day(start_date)
)
wed_classes = Event.objects.filter(
date__gte=self._start_of_day(end_date),
date__lte=self._end_of_day(end_date)
)
# total number of classes created is 3, as no wed classes created
self.assertEquals(tue_classes.count(), 3)
self.assertEquals(wed_classes.count(), 0)
self.assertEquals(Event.objects.count(), 3)
def test_bookable_blocks_past(self):
"""
blocks appear in the choice dropdown in an empty form if they are:
- open
- have events
- not past (i.e. all events in the past)
- no event on the block is full
- block hasn't started yet
:return:
"""
block = mommy.make_recipe(
'flex_bookings.block', booking_open=True
)
event = mommy.make_recipe(
'flex_bookings.future_EV', booking_open=True,
date=timezone.now() - timedelta(5)
)
block.events.add(event)
self.assertTrue(block.booking_open)
self.assertTrue(block.events.exists())
self.assertTrue(block.is_past)
self.assertFalse(block.has_full_class)
self.assertTrue(block.has_started)
formset = UserBlockFormSet(
# data=self.formset_data({'form-TOTAL-FORMS': 2}),
initial=[{'user': self.user.id, 'block': self.block.id}]
)
form = formset.forms[1] # get the second (empty) form
block_qset = form.fields['block'].queryset
# block dropdown only has self.block
self.assertEqual(block_qset.count(), 1)
self.assertEqual(block_qset[0].id, self.block.id)
def test_create_block_redirects_if_no_blocktypes_available(self):
"""
Test that create block form redirects if trying to create a
block with an event type that the user already has
"""
event_type = mommy.make_recipe('booking.event_type_PC')
block_type_pc5 = mommy.make_recipe(
'booking.blocktype5', event_type=event_type
)
block_type_pc10 = mommy.make_recipe(
'booking.blocktype5', event_type=event_type
)
mommy.make_recipe(
'booking.block', user=self.user, block_type=block_type_pc5,
paid=True
)
# create form with a different blocktype, but one with the same event
# type as the user's booked block
form_data = {'block_type': block_type_pc10}
url = reverse('booking:add_block')
request = self.factory.post(url, form_data)
self._set_session(self.user, request)
form_data = {'block_type': block_type_pc10.id}
form = BlockCreateForm(data=form_data)
form.full_clean()
view = setup_view(BlockCreateView, request)
resp = view.form_valid(view, form)
self.assertEqual(resp.status_code, 302)
def test_not_assignments_where_not_student(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
mockresponse = self.mock_http200_getrequest_htmls(requestuser=testuser)
self.assertEqual(
0,
self.__get_assignment_count(selector=mockresponse.selector))
def test_querycount(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testperiod = mommy.make_recipe('devilry.apps.core.period_active')
testassignment1 = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
parentnode=testperiod)
testassignment2 = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
parentnode=testperiod)
loops = overview.PeriodOverviewView.paginate_by / 2
for number in range(int(round(loops))):
group1 = mommy.make('core.AssignmentGroup', parentnode=testassignment1)
mommy.make('core.Examiner', assignmentgroup=group1)
mommy.make('core.Candidate', relatedstudent__user=testuser, assignment_group=group1)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=group1, grading_points=1)
group2 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Examiner', assignmentgroup=group2)
mommy.make('core.Candidate', relatedstudent__user=testuser, assignment_group=group2)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=group2, grading_points=1)
with self.assertNumQueries(4):
mockresponse = self.mock_http200_getrequest_htmls(requestuser=testuser, cradmin_role=testperiod)
self.assertEqual(
loops * 2,
self.__get_assignment_count(selector=mockresponse.selector))
def test_image_operations_as_authorised_users(self):
# create a campaign & deployment that ONLY bill can see
bills_campaign = mommy.make_one("catamidb.Campaign", id=3, short_name="cp__1")
bills_deployment = mommy.make_recipe("catamidb.Deployment3", id=3, campaign=bills_campaign)
bills_image = mommy.make_recipe("catamidb.Image3", id=3, deployment=bills_deployment)
assign("view_campaign", self.user_bill, bills_campaign)
# check that bill can see via the API
response = self.bill_api_client.get(self.image_url, format="json")
self.assertValidJSONResponse(response)
self.assertEqual(len(self.deserialize(response)["objects"]), 3)
# check that bill can get to the object itself
response = self.bill_api_client.get(self.image_url + "3/", format="json")
self.assertValidJSONResponse(response)
# check that bob can not see - now we know tastypie API has correct
# permission validation
response = self.bob_api_client.get(self.image_url, format="json")
self.assertValidJSONResponse(response)
self.assertEqual(len(self.deserialize(response)["objects"]), 2)
# check bob can NOT get to the hidden object
response = self.bob_api_client.get(self.image_url + "3/", format="json")
self.assertHttpUnauthorized(response)
# check that anonymous can see public ones as well
response = self.anon_api_client.get(self.image_url, format="json")
self.assertValidJSONResponse(response)
self.assertEqual(len(self.deserialize(response)["objects"]), 2)
# check anonymous can NOT get to the hidden object
response = self.anon_api_client.get(self.image_url + "3/", format="json")
self.assertHttpUnauthorized(response)
def test_grouplist_orderby(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testperiod = mommy.make_recipe('devilry.apps.core.period_active')
mommy.make('core.Candidate',
relatedstudent__user=testuser,
assignment_group__parentnode=mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 1',
first_deadline=ACTIVE_PERIOD_START + timedelta(days=1),
parentnode=testperiod))
mommy.make('core.Candidate',
relatedstudent__user=testuser,
assignment_group__parentnode=mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 3',
first_deadline=ACTIVE_PERIOD_START + timedelta(days=3),
parentnode=testperiod))
mommy.make('core.Candidate',
relatedstudent__user=testuser,
assignment_group__parentnode=mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
long_name='Assignment 2',
first_deadline=ACTIVE_PERIOD_START + timedelta(days=2),
parentnode=testperiod))
mockresponse = self.mock_http200_getrequest_htmls(
requestuser=testuser, cradmin_role=testperiod)
self.assertEqual(
[
'Assignment 3',
'Assignment 2',
'Assignment 1',
],
self.__get_assignment_titles(mockresponse.selector))
def test_grouplist_status_waiting_for_feedback_sanity(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
testperiod = mommy.make_recipe('devilry.apps.core.period_active')
testgroup = mommy.make('core.AssignmentGroup',
parentnode=mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start',
parentnode=testperiod))
mommy.make('core.Candidate',
relatedstudent__user=testuser,
assignment_group=testgroup)
devilry_group_mommy_factories.feedbackset_first_attempt_published(
group=testgroup, grading_points=3)
devilry_group_mommy_factories.feedbackset_new_attempt_unpublished(
group=testgroup,
deadline_datetime=timezone.now() - timedelta(days=2))
mockresponse = self.mock_http200_getrequest_htmls(
requestuser=testuser, cradmin_role=testperiod)
self.assertFalse(
mockresponse.selector.exists(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-grade'))
self.assertEqual(
'Status: waiting for feedback',
mockresponse.selector.one(
'.devilry-cradmin-groupitemvalue '
'.devilry-cradmin-groupitemvalue-status').alltext_normalized)
def test_increment_for_strings(self):
person = mommy.make_recipe('test.generic.serial_person')
self.assertEqual(person.name, 'joe1')
person = mommy.prepare_recipe('test.generic.serial_person')
self.assertEqual(person.name, 'joe2')
person = mommy.make_recipe('test.generic.serial_person')
self.assertEqual(person.name, 'joe3')
def testContent(self):
mommy.make_recipe('apps.front.user')
mommy.make_recipe('apps.lecturers.lecturer')
login(self)
response = self.client.get('/dozenten/')
self.assertContains(response, '<h1>Unsere Dozenten</h1>')
self.assertContains(response, 'David<br />Krakaduku')
def test_submitting_form_for_classes_redirects_to_class_register(self):
event = mommy.make_recipe('booking.future_PC')
bookings = mommy.make_recipe(
'booking.booking', event=event, status='OPEN', _quantity=2
)
form_data = self.formset_data({
'bookings-0-id': bookings[0].id,
'bookings-0-user': bookings[0].user.id,
'bookings-0-paid': bookings[0].paid,
'bookings-0-attended': bookings[0].attended,
'bookings-1-id': bookings[1].id,
'bookings-1-user': bookings[1].user.id,
'bookings-1-paid': bookings[1].paid,
'bookings-1-attended': bookings[1].attended,
})
resp = self._post_response(
self.staff_user, event.slug,
form_data=form_data,
print_view=False,
ev_type='class',
status_choice='OPEN'
)
self.assertEquals(resp.status_code, 302)
self.assertEquals(
resp.url,
reverse(
'studioadmin:class_register',
args=[event.slug, 'OPEN']
)
)
def test_events_excluded_from_form_for_instructors(
self, mock_tz, mock_date
):
mock_tz.now.return_value = datetime(
year=2015, month=9, day=7, hour=10, tzinfo=timezone.utc
)
mock_date.today.return_value = date(year=2015, month=9, day=7)
mommy.make_recipe(
'booking.future_EV',
date=datetime(
year=2015, month=9, day=7,
hour=18, minute=0, tzinfo=timezone.utc
),
_quantity=3
)
pole_classes = mommy.make_recipe(
'booking.future_PC',
date=datetime(
year=2015, month=9, day=7,
hour=18, minute=0, tzinfo=timezone.utc
),
_quantity=3
)
resp = self._get_response(self.instructor_user)
form = resp.context_data['form']
self.assertEqual(len(form.events), 3)
self.assertEqual(
sorted([ev.id for ev in form.events]),
sorted([ev.id for ev in pole_classes])
)
def test_block_format_paid_no_block_available(self):
# paid (user has available block not used)
event = mommy.make_recipe('booking.future_EV', max_participants=1)
# block used
block_type = mommy.make(
BlockType, event_type=event.event_type, size=3
)
# paid (user has no available block)
user1 = mommy.make_recipe('booking.user')
mommy.make_recipe(
'booking.booking', event=event, user=user1, paid=True,
payment_confirmed=True
)
resp = self._get_response(self.staff_user, event.slug)
# block is hidden as booking is paid
self.assertIn(
'<span class="hide"><select class="hide" id="id_bookings-0-block" '
'name="bookings-0-block">',
resp.rendered_content
)
# block info is displayed
self.assertIn(
'No active block', resp.rendered_content
)
def test_status_choice_filter(self):
open_bookings = mommy.make_recipe(
'booking.booking', event=self.event, status='OPEN', _quantity=5
)
cancelled_bookings = mommy.make_recipe(
'booking.booking',
event=self.event,
status='CANCELLED',
_quantity=5
)
resp = self._get_response(
self.staff_user, self.event.slug, status_choice='ALL'
)
# bookings: open - 5 plus 2 created in setup, cancelled = 5 (12)
# also shows forms for available spaces (16 max, 9 spaces)
self.assertEquals(len(resp.context_data['formset'].forms), 21)
resp = self._get_response(
self.staff_user, self.event.slug, status_choice='OPEN'
)
# 5 open plus 2 created in setup, plus empty forms for available
# spaces to max participants 16
forms = resp.context_data['formset'].forms
self.assertEquals(len(forms), 16)
self.assertEquals(
set([form.instance.status for form in forms]), {'OPEN'}
)
resp = self._get_response(
self.staff_user, self.event.slug, status_choice='CANCELLED'
)
forms = resp.context_data['formset'].forms
# 5 cancelled plus empty forms for 9 available spaces
self.assertEquals(len(forms), 14)
def test_block_format_block_used(self):
event = mommy.make_recipe(
'booking.future_EV', max_participants=1, event_type__subtype='Event'
)
# block used
block_type = mommy.make(
BlockType, event_type=event.event_type, size=3
)
block = mommy.make_recipe(
'booking.block', block_type=block_type, user=self.user, paid=True
)
mommy.make_recipe(
'booking.booking', user=self.user, event=event,
block=block, paid=True, payment_confirmed=True
)
resp = self._get_response(self.staff_user, event.slug)
# block is hidden as booking is paid
self.assertIn(
'<select class="hide" id="id_bookings-0-block" '
'name="bookings-0-block">',
resp.rendered_content
)
# block info is displayed
self.assertIn(
'Event (2/3 left); expires {}'.format(
block.expiry_date.strftime('%d %b %y')
),
resp.rendered_content
)
def test_block_format_block_available_not_used(self):
# paid (user has available block not used)
event = mommy.make_recipe(
'booking.future_EV', max_participants=1, event_type__subtype='Event'
)
# block used
block_type = mommy.make(
BlockType, event_type=event.event_type, size=3
)
block = mommy.make_recipe(
'booking.block', block_type=block_type, user=self.user, paid=True
)
mommy.make_recipe(
'booking.booking', event=event, user=self.user, paid=True,
payment_confirmed=True
)
resp = self._get_response(self.staff_user, event.slug)
# block is hidden as booking is paid
self.assertIn(
'<span class="hide"><select class="form-control input-xs '
'studioadmin-list" id="id_bookings-0-block" '
'name="bookings-0-block">',
resp.rendered_content
)
# block info is displayed
self.assertIn(
'Active block not used', resp.rendered_content
)
def test_print_with_invalid_date_format(self):
mommy.make_recipe(
'booking.future_EV',
date=datetime(
year=2015, month=9, day=7,
hour=18, minute=0, tzinfo=timezone.utc
),
)
url = reverse('studioadmin:register-day')
self.client.login(username=self.staff_user.username, password='******')
resp = self.client.post(
url,
{
'register_date': 'Mon 33 Sep 2015',
'exclude_ext_instructor': True,
'register_format': 'full',
'print': 'print'
},
follow=True
)
content = format_content(resp.rendered_content)
self.assertIn(
'Please correct the following errors: register_date',
content
)
def setUp(self):
super(EventRegisterViewTests, self).setUp()
self.event = mommy.make_recipe(
'booking.future_EV', max_participants=16
)
self.booking1 = mommy.make_recipe('booking.booking', event=self.event)
self.booking2 = mommy.make_recipe('booking.booking', event=self.event)
def test_paypal_notify_url_with_block(self, mock_postback):
mock_postback.return_value = b"VERIFIED"
user = mommy.make_recipe('flex_bookings.user')
events = mommy.make_recipe('flex_bookings.future_EV', _quantity=5)
block = mommy.make_recipe('flex_bookings.block')
for event in events:
block.events.add(event)
booking = mommy.make_recipe(
'flex_bookings.booking', user=user, event=event
)
block.bookings.add(booking)
invoice_id = helpers.create_block_paypal_transaction(
user, block
).invoice_id
self.assertFalse(PayPalIPN.objects.exists())
params = dict(IPN_POST_PARAMS)
params.update(
{
'custom': b('block {}'.format(block.id)),
'invoice': b(invoice_id)
}
)
resp = self.paypal_post(params)
self.assertEqual(resp.status_code, 200)
self.assertEqual(PayPalIPN.objects.count(), 1)
ppipn = PayPalIPN.objects.first()
self.assertFalse(ppipn.flag)
self.assertEqual(ppipn.flag_info, '')
block.refresh_from_db()
# 2 emails sent, to user and studio
self.assertEqual(len(mail.outbox), 2)
def test_paypal_notify_only_updates_relevant_booking(self, mock_postback):
mock_postback.return_value = b"VERIFIED"
user = mommy.make_recipe('flex_bookings.user')
booking = mommy.make_recipe('flex_bookings.booking', paid=False)
mommy.make_recipe('flex_bookings.booking', paid=False, _quantity=5)
invoice_id = helpers.create_booking_paypal_transaction(
booking.user, booking
).invoice_id
self.assertFalse(PayPalIPN.objects.exists())
params = dict(IPN_POST_PARAMS)
params.update(
{
'custom': b('booking {}'.format(booking.id)),
'invoice': b(invoice_id)
}
)
resp = self.paypal_post(params)
self.assertEqual(resp.status_code, 200)
self.assertEqual(PayPalIPN.objects.count(), 1)
ppipn = PayPalIPN.objects.first()
self.assertFalse(ppipn.flag)
self.assertEqual(ppipn.flag_info, '')
booking.refresh_from_db()
self.assertTrue(booking.paid)
# 2 emails sent, to user and studio
self.assertEqual(len(mail.outbox), 2)
for bkg in Booking.objects.all():
if bkg.id == booking.id:
self.assertTrue(bkg.paid)
else:
self.assertFalse(bkg.paid)
def test_create_existing_block_transaction_with_txn_id(self):
user = mommy.make_recipe('flex_bookings.user', username="******")
events = mommy.make_recipe('flex_bookings.future_EV', _quantity=5)
block = mommy.make_recipe(
'flex_bookings.block', name="test block"
)
for event in events:
block.events.add(event)
block_txn = helpers.create_block_paypal_transaction(user, block)
block_txn.transaction_id = "test transaction id"
block_txn.save()
self.assertEqual(block_txn.block, block)
self.assertEqual(
block_txn.invoice_id,
'testuser-tb-inv#001'
)
self.assertEqual(PaypalBlockTransaction.objects.count(), 1)
second_block_txn = helpers.create_block_paypal_transaction(user, block)
self.assertEqual(PaypalBlockTransaction.objects.count(), 2)
self.assertNotEqual(block_txn, second_block_txn)
self.assertEqual(
second_block_txn.invoice_id,
'testuser-tb-inv#002'
)
def test_create_existing_booking_txn_with_txn_id(self):
"""
if the existing transaction is already associated with a paypal
transaction_id, we do need to create a new transaction, with new
invoice number with incremented counter
"""
user = mommy.make_recipe('flex_bookings.user', username="******")
booking = mommy.make_recipe(
'flex_bookings.booking', user=user, event__name='test event'
)
booking_txn = helpers.create_booking_paypal_transaction(user, booking)
self.assertEqual(booking_txn.booking, booking)
self.assertEqual(
booking_txn.invoice_id,
'testuser-te-{}-inv#001'.format(
booking.event.date.strftime("%d%m%y%H%M")
)
)
self.assertEqual(PaypalBookingTransaction.objects.count(), 1)
booking_txn.transaction_id = "123"
booking_txn.save()
new_booking_txn = helpers.create_booking_paypal_transaction(user, booking)
self.assertEqual(PaypalBookingTransaction.objects.count(), 2)
self.assertEqual(
new_booking_txn.invoice_id,
'testuser-te-{}-inv#002'.format(
booking.event.date.strftime("%d%m%y%H%M")
)
)
def test_paypal_booking_admin_display(self):
user = mommy.make_recipe(
'flex_bookings.user', first_name='Test', last_name='User')
booking = mommy.make_recipe('flex_bookings.booking', user=user)
pptrans = helpers.create_booking_paypal_transaction(
booking.user, booking
)
ppbooking_admin = PaypalBookingTransactionAdmin(
PaypalBookingTransaction, AdminSite()
)
ppbooking_query = ppbooking_admin.get_queryset(None)[0]
self.assertEqual(
ppbooking_admin.get_booking_id(ppbooking_query), booking.id
)
self.assertEqual(
ppbooking_admin.get_user(ppbooking_query), 'Test User'
)
self.assertEqual(
ppbooking_admin.get_event(ppbooking_query), booking.event
)
self.assertEqual(
ppbooking_admin.cost(ppbooking_query),
u"\u00A3{}.00".format(booking.event.cost)
)
def test_paypal_block_admin_display(self):
user = mommy.make_recipe(
'flex_bookings.user', first_name='Test', last_name='User'
)
events = mommy.make_recipe('flex_bookings.future_EV', _quantity=5)
block = mommy.make_recipe('flex_bookings.block')
for event in events:
block.events.add(event)
booking = mommy.make_recipe(
'flex_bookings.booking', user=user, event=event
)
block.bookings.add(booking)
pptrans = helpers.create_block_paypal_transaction(
user, block
)
ppblock_admin = PaypalBlockTransactionAdmin(
PaypalBlockTransaction, AdminSite()
)
ppblock_query = ppblock_admin.get_queryset(None)[0]
self.assertEqual(
ppblock_admin.get_block_id(ppblock_query), block.id
)
self.assertEqual(
ppblock_admin.get_user(ppblock_query), 'Test User'
)
self.assertEqual(
ppblock_admin.cost(ppblock_query),
u"\u00A3{:.2f}".format(
block.item_cost * block.bookings.count()
)
)
def test_upcoming_assignments_header(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start')
mockresponse = self.mock_http200_getrequest_htmls(requestuser=testuser)
self.assertEqual(
mockresponse.selector.one('.devilry-student-dashboard-upcoming-assignments-header').alltext_normalized,
'Upcoming assignments')
def test_categories_with_published_articles(self):
c1 = mommy.make_recipe('kb.tests.category_with_articles')
c2 = mommy.make_recipe('kb.tests.category_without_articles')
mommy.make_recipe('kb.tests.draft_article', category=c2)
self.assertSeqEqual(Category.objects.all(), [c1, c2])
self.assertSeqEqual(Category.objects.categories(), [c1])
def test_create_booking_with_duplicate_invoice_number(self):
user = mommy.make_recipe('flex_bookings.user', username="******")
booking = mommy.make_recipe(
'flex_bookings.booking', user=user, event__name='test event',
event__date=datetime(2015, 2, 1, 10, 0, tzinfo=timezone.utc)
)
booking1 = mommy.make_recipe(
'flex_bookings.booking', user=user, event__name='test event1',
event__date=datetime(2015, 2, 1, 10, 0, tzinfo=timezone.utc)
)
booking_txn = helpers.create_booking_paypal_transaction(user, booking)
self.assertEqual(booking_txn.booking, booking)
self.assertEqual(
booking_txn.invoice_id,
'testuser-te-{}-inv#001'.format(
booking.event.date.strftime("%d%m%y%H%M")
)
)
booking1_txn = helpers.create_booking_paypal_transaction(user, booking1)
self.assertEqual(booking1_txn.booking, booking1)
self.assertNotEqual(
booking1_txn.invoice_id,
'testuser-te-{}-inv#001'.format(
booking1.event.date.strftime("%d%m%y%H%M")
)
)
# to avoid duplication, the counter is set to 6 digits, the first 3
# random between 100 and 999
self.assertEqual(len(booking1_txn.invoice_id.split('#')[-1]), 6)
def test_cannot_post_delete_block_page_if_block_has_bookings(self):
mommy.make_recipe('booking.booking', block=self.block)
resp = self._post_response(self.user, self.block.id)
self.assertEqual(resp.status_code, 302)
self.assertIn(resp.url, reverse('booking:permission_denied'))
self.assertEqual(Block.objects.first(), self.block)
def test_create_block_transaction_with_duplicate_invoice_number(self):
user = mommy.make_recipe('flex_bookings.user', username="******")
events = mommy.make_recipe('flex_bookings.future_EV', _quantity=5)
block = mommy.make_recipe(
'flex_bookings.block', name="test block"
)
for event in events:
block.events.add(event)
events1 = mommy.make_recipe('flex_bookings.future_EV', _quantity=5)
block1 = mommy.make_recipe(
'flex_bookings.block', name="test block"
)
for event in events1:
block1.events.add(event)
block_txn = helpers.create_block_paypal_transaction(user, block)
self.assertEqual(block_txn.block, block)
self.assertEqual(
block_txn.invoice_id,
'testuser-tb-inv#001'
)
self.assertEqual(PaypalBlockTransaction.objects.count(), 1)
second_block_txn = helpers.create_block_paypal_transaction(user, block1)
self.assertEqual(PaypalBlockTransaction.objects.count(), 2)
self.assertNotEqual(block_txn, second_block_txn)
# to avoid duplication, the counter is set to 6 digits, the first 3
# random between 100 and 999
self.assertEqual(len(second_block_txn.invoice_id.split('#')[-1]), 6)
def setUp(self):
mommy.make_recipe('apps.front.user')
login(self)
def test_success_multiple(self):
testassignment1 = mommy.make_recipe(
'devilry.apps.core.assignment_oldperiod_start',
short_name='cool',
passing_grade_min_points=1,
max_points=1,
)
group1 = mommy.make('core.AssignmentGroup', parentnode=testassignment1)
candidate1 = core_mommy.candidate(group=group1, shortname='april', fullname='April Duck')
group_mommy.feedbackset_first_attempt_published(group=group1, grading_points=1)
group2 = mommy.make('core.AssignmentGroup', parentnode=testassignment1)
candidate2 = core_mommy.candidate(group=group2, shortname='donald', fullname='Donald Duck')
group_mommy.feedbackset_first_attempt_published(group=group2, grading_points=1)
testassignment0 = mommy.make_recipe(
'devilry.apps.core.assignment_oldperiod_middle',
short_name='cool',
parentnode__parentnode=testassignment1.parentnode.parentnode,
passing_grade_min_points=1,
max_points=1,
)
group3 = mommy.make('core.AssignmentGroup', parentnode=testassignment0)
candidate3 = core_mommy.candidate(group=group3, shortname='dewey', fullname='Dewey Duck')
group_mommy.feedbackset_first_attempt_published(group=group3, grading_points=1)
testassignment2 = mommy.make_recipe(
'devilry.apps.core.assignment_activeperiod_start',
short_name='cool',
parentnode__parentnode=testassignment1.parentnode.parentnode,
passing_grade_min_points=2,
max_points=3,
)
new_group1 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Candidate', assignment_group=new_group1, relatedstudent__user=candidate1.relatedstudent.user)
new_group2 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Candidate', assignment_group=new_group2, relatedstudent__user=candidate2.relatedstudent.user)
new_group3 = mommy.make('core.AssignmentGroup', parentnode=testassignment2)
mommy.make('core.Candidate', assignment_group=new_group3, relatedstudent__user=candidate3.relatedstudent.user)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testassignment2,
viewkwargs={'period_id': testassignment1.parentnode.id},
messagesmock=messagesmock,
requestkwargs={
'data': {
'candidates': '[{}, {}, {}]'.format(candidate1.id, candidate2.id, candidate3.id)
}
},
cradmin_instance=self.__mockinstance_with_devilryrole('departmentadmin')
)
messagesmock.add.assert_called_once_with(
messages.SUCCESS,
'Success: {}, {}, {} got approved for this assignment.'
''.format(candidate1.relatedstudent.user.get_displayname(),
candidate2.relatedstudent.user.get_displayname(),
candidate3.relatedstudent.user.get_displayname()),
''
)
def setUp(self):
self.tour = mommy.make_recipe('core.city_tour_bh')
self.tour_rondonia = mommy.make_recipe('core.tour_rondonia')
self.destino = self.tour.destino
self.resp = self.client.get(
r("core:destino", args=[self.destino.slug]))
def setUp(self):
self.tour = mommy.make_recipe('core.city_tour_bh')
self.detail_page = self.client.get(
r("core:detalhes", args=[self.tour.slug]))
def setUp(self):
self.tour = mommy.make_recipe('core.city_tour_bh')
self.resp = self.client.get(r('core:typejson'))
def setUp(self):
# setUpClass
mommy.make_recipe('apps.front.user')
mommy.make_recipe('apps.documents.document_summary')
mommy.make_recipe('apps.documents.document_summary')
mommy.make_recipe('apps.documents.document_exam')
mommy.make_recipe('apps.documents.document_software')
mommy.make_recipe('apps.documents.document_learning_aid')
# setUp
self.response = self.client.get(
reverse('documents:documentcategory_list'))
def setUp(self):
# setUpClass
mommy.make_recipe('apps.front.user')
def test_get_suggested_deadlines_not_first_assignment(self):
period = mommy.make_recipe('devilry.apps.core.assignment_activeperiod_start').period
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=period)
self.assertTrue(mockresponse.selector.exists(
'#devilry_admin_createassignment_suggested_deadlines'))
def test_post_future_period_sanity(self):
self.assertEqual(Assignment.objects.count(), 0)
period = mommy.make_recipe('devilry.apps.core.period_future')
self.__valid_post_request(period=period, first_deadline=ASSIGNMENT_FUTUREPERIOD_START_FIRST_DEADLINE)
self.assertEqual(Assignment.objects.count(), 1)
def setUp(self):
django_apps.app_configs['edc_device'].device_id = '99'
self.survey_schedule_object = site_surveys.get_survey_schedules()[0]
self.household_structure = self.member_helper.make_household_ready_for_enumeration(
make_hoh=False, report_datetime=self.survey_schedule_object.start)
household_status = ELIGIBLE_REPRESENTATIVE_PRESENT
mommy.make_recipe('household.householdlogentry',
report_datetime=get_utcnow(),
household_log=self.household_structure.householdlog,
household_status=household_status)
# add another member, OK!
household_member = self.member_helper.add_household_member(
self.household_structure, relation='Mother')
enrollment_checklist = mommy.make_recipe(
'member.enrollmentchecklist',
household_member=household_member,
report_datetime=self.household_structure.report_datetime,
dob=(self.household_structure.report_datetime -
relativedelta(years=household_member.age_in_years)).date(),
gender=household_member.gender,
initials=household_member.initials,
)
# fake values
fake_identity = fake.credit_card_number()
last_name = fake.last_name().upper()
initials = enrollment_checklist.initials
last_name = initials[1] + last_name
options = {
'identity': '317115159',
'confirm_identity': '317115159',
}
try:
registered_subject = RegisteredSubject.objects.get(
registration_identifier=household_member.internal_identifier)
except RegisteredSubject.DoesNotExist:
identity = options.get('identity', fake_identity)
confirm_identity = options.get('confirm_identity', fake_identity)
dob = options.get('dob', enrollment_checklist.dob)
else:
identity = options.get('identity', registered_subject.identity)
confirm_identity = options.get('confirm_identity',
registered_subject.identity)
dob = registered_subject.dob
self.report_datetime = self.get_utcnow()
consent_object = site_consents.get_consent(
report_datetime=self.report_datetime,
consent_model='bcpp_subject.subjectconsent')
consent_options = dict(
first_name=household_member.first_name,
last_name=last_name,
consent_datetime=self.report_datetime,
version=consent_object.version,
dob=dob,
gender=options.get('gender', enrollment_checklist.gender),
initials=initials,
is_literate=options.get('is_literate',
enrollment_checklist.literacy),
witness_name=options.get(
'witness_name',
fake.last_name()
if enrollment_checklist.literacy == NO else None),
legal_marriage=options.get('legal_marriage',
enrollment_checklist.legal_marriage),
marriage_certificate=options.get(
'marriage_certificate',
enrollment_checklist.marriage_certificate),
guardian_name=options.get(
'guardian_name',
fake.name() if enrollment_checklist.guardian == YES else None),
identity=identity,
confirm_identity=confirm_identity)
# add subject consent
self.subject_consent = SubjectConsent.objects.create(
household_member=household_member,
survey_schedule=household_member.survey_schedule_object.
field_value,
**consent_options)
SubjectLocator.objects.create(
subject_identifier=self.subject_consent.subject_identifier,
report_datetime=self.report_datetime,
alt_contact_cell_number='72200111',
has_alt_contact=NO,
alt_contact_name=None,
alt_contact_rel=None,
alt_contact_cell=None,
other_alt_contact_cell='760000111',
alt_contact_tel=None)
def test_get_select_options_import_no_students_exists(self):
period = mommy.make_recipe('devilry.apps.core.period_active')
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=period)
option_list = mockresponse.selector.list('option')
self.assertEqual(option_list[2].get('value'), 'none')
def test_post_add_all_relatedstudents_on_period_no_students_on_period(self):
period = mommy.make_recipe('devilry.apps.core.period_active')
created_assignment, mockresponse = self.__valid_post_request(period=period)
self.assertEqual(0, created_assignment.assignmentgroups.count())
self.assertEqual(Candidate.objects.filter(assignment_group__parentnode=created_assignment).count(), 0)
def test_hiv_rapid_test_not_required(self):
self.maternal_dataset_options = {
'delivdt': get_utcnow() - relativedelta(years=8),
'mom_enrolldate': get_utcnow(),
'mom_hivstatus': 'HIV-uninfected',
'study_maternal_identifier': '11123',
'protocol': 'Mpepu',
'preg_pi': 0
}
self.child_dataset_options = {
'infant_hiv_exposed': '',
'infant_enrolldate': get_utcnow(),
'study_maternal_identifier': '11123',
'study_child_identifier': '1234',
'dob': get_utcnow() - relativedelta(years=8)
}
mommy.make_recipe('flourish_child.childdataset',
**self.child_dataset_options)
maternal_dataset_obj = mommy.make_recipe(
'flourish_caregiver.maternaldataset',
**self.maternal_dataset_options)
sh = SubjectHelperMixin()
subject_identifier = sh.enroll_prior_participant_assent(
maternal_dataset_obj.screening_identifier,
self.child_dataset_options.get('study_child_identifier'),
hiv_status=POS)
history_model = 'edc_visit_schedule.subjectschedulehistory'
history_obj = django_apps.get_model(history_model).objects.get(
subject_identifier=subject_identifier)
history_obj.offschedule_datetime = get_utcnow().date() + relativedelta(
days=100)
history_obj.save()
visit = mommy.make_recipe('flourish_caregiver.maternalvisit',
report_datetime=get_utcnow(),
appointment=Appointment.objects.get(
visit_code='2000M',
subject_identifier=subject_identifier),
reason=SCHEDULED)
mommy.make_recipe('flourish_caregiver.hivrapidtestcounseling',
maternal_visit=visit,
rapid_test_done=YES,
result_date=get_utcnow().date(),
result=NEG)
visit2 = mommy.make_recipe('flourish_caregiver.maternalvisit',
appointment=Appointment.objects.get(
visit_code='2001M',
subject_identifier=subject_identifier),
report_datetime=get_utcnow() +
relativedelta(days=91),
reason=SCHEDULED)
self.assertEqual(
CrfMetadata.objects.get(
model='flourish_caregiver.hivrapidtestcounseling',
subject_identifier=subject_identifier,
visit_code='2001M').entry_status, REQUIRED)
mommy.make_recipe('flourish_caregiver.hivrapidtestcounseling',
maternal_visit=visit2,
rapid_test_done=YES,
result_date=get_utcnow().date() +
relativedelta(days=91),
result=NEG)
visit2 = mommy.make_recipe('flourish_caregiver.maternalvisit',
appointment=Appointment.objects.get(
visit_code='2002M',
subject_identifier=subject_identifier),
report_datetime=get_utcnow(),
reason=SCHEDULED)
self.assertEqual(
CrfMetadata.objects.get(
model='flourish_caregiver.hivrapidtestcounseling',
subject_identifier=subject_identifier,
visit_code='2002M').entry_status, NOT_REQUIRED)
def test_get_suggested_name_first_assignment(self):
period = mommy.make_recipe('devilry.apps.core.period_active')
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=period)
self.assertEqual(mockresponse.selector.one('input[name=long_name]').get('value', ''), '')
self.assertEqual(mockresponse.selector.one('input[name=short_name]').get('value', ''), '')
def test_validate_long_and_lat_within_ward_invalid(self):
"""Kenya High (-1.275611, 36.780612) - is just outside Kilimani ward"""
with self.assertRaises(ValidationError):
mommy.make_recipe('mfl_gis.tests.facility_coordinates_recipe',
coordinates=Point(36.780612, -1.275611))
def test_get_default_select_options_count(self):
period = mommy.make_recipe('devilry.apps.core.period_active')
mockresponse = self.mock_http200_getrequest_htmls(
cradmin_role=period)
option_list = mockresponse.selector.list('option')
self.assertEqual(len(option_list), 3)
def test_validate_long_and_lat_within_county_invalid(self):
"""Thomson Falls - 0.044444, 36.370416 - is in Kenya but not Nairobi"""
with self.assertRaises(ValidationError):
mommy.make_recipe('mfl_gis.tests.facility_coordinates_recipe',
coordinates=Point(36.370416, 0.044444))
def setUp(self):
super(FormTest, self).setUp()
self.seed = mommy.make_recipe('grunt.seed')
test_audio_path = Path(settings.APP_DIR,
'grunt/tests/media/test-audio.wav')
self.audio = File(open(test_audio_path, 'rb'))
def test_features_json(self):
facility_gps = mommy.make_recipe(
'mfl_gis.tests.facility_coordinates_recipe')
self.assertEquals(1, FacilityCoordinates.objects.count())
self.assertIsInstance(facility_gps.json_features, dict)
def test_validate_long_and_lat_within_constituency_invalid(self):
"""Taj Mall (-1.323139, 36.898769) is in Nrb but not Dagoretti North"""
with self.assertRaises(ValidationError):
mommy.make_recipe('mfl_gis.tests.facility_coordinates_recipe',
coordinates=Point(36.898769, -1.323139))
def test_model_allocates_identifier(self):
obj = mommy.make_recipe("ambition_screening.subjectscreening")
self.assertIsNotNone(obj.screening_identifier)
self.assertTrue(obj.screening_identifier.startswith("S"))
def test_validate_long_and_lat_within_kenya_invalid(self):
"""The Kampala Serena - 0.319590, 32.586484; definitely not in Kenya"""
with self.assertRaises(ValidationError):
mommy.make_recipe('mfl_gis.tests.facility_coordinates_recipe',
coordinates=Point(32.586484, 0.319590))
def make_question(self, **mommy_kwargs):
recording = mommy.make_recipe('ratings.recording')
return mommy.make_recipe('ratings.question',
given=recording,
**mommy_kwargs)
def test_save(self):
facility_gps = mommy.make_recipe(
'mfl_gis.tests.facility_coordinates_recipe')
self.assertEquals(1, FacilityCoordinates.objects.count())
self.assertEquals(facility_gps, facility_gps.facility.coordinates)
def test_creates_unique_field_recipe_using_for_iterator(self):
for i in range(1, 4):
dummy = mommy.make_recipe('test.generic.dummy_unique_field')
self.assertEqual(dummy.value, 10 + i)
def test_add_choices_to_question(self):
num_choices = 3
question = mommy.make(Question)
messages = mommy.make_recipe('ratings.seed', _quantity=num_choices)
question.choices.add(*messages)
self.assertEquals(question.choices.count(), num_choices)
def test_make_recipe_with_quantity_parameter(self):
people = mommy.make_recipe('test.generic.person', _quantity=3)
self.assertEqual(len(people), 3)
for person in people:
self.assertIsInstance(person, Person)
self.assertNotEqual(person.id, None)
def test_creates_unique_field_recipe_using_quantity_argument(self):
dummies = mommy.make_recipe('test.generic.dummy_unique_field',
_quantity=3)
self.assertEqual(11, dummies[0].value)
self.assertEqual(12, dummies[1].value)
self.assertEqual(13, dummies[2].value)
def test_make_recipe(self):
person = mommy.make_recipe('test.generic.person')
self.assertIsInstance(person, Person)
self.assertNotEqual(person.id, None)
def test_make_recipe_with_args(self):
person = mommy.make_recipe('test.generic.person',
name='Dennis Ritchie',
age=70)
self.assertEqual(person.name, 'Dennis Ritchie')
self.assertEqual(person.age, 70)