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)