class DocumentDetailTests(TestCase): """Test action menu items""" def setUp(self): self.category = CategoryFactory() self.user = UserFactory( name='User', password='******', is_superuser=True, category=self.category) self.client.login(username=self.user.email, password='******') self.doc = DocumentFactory( category=self.category, revision={ 'leader': self.user, } ) self.url = reverse("document_detail", args=[ self.category.organisation.slug, self.category.slug, self.doc.document_key ]) def test_admin_can_delete_document(self): res = self.client.get(self.url) self.assertContains(res, delete_button) def test_simple_user_cannot_delete_document(self): self.user.is_superuser = False self.user.save() res = self.client.get(self.url) self.assertNotContains(res, delete_button)
def create_admin(self): # Factory creates simple user, so ``is_staff`` is set later self.admin = UserFactory(username='******', password='******') self.admin.is_staff = True self.admin.is_superuser = True self.admin.save() print("admin user have been created successfully")
def setUp(self): Model = ContentType.objects.get_for_model(ContractorDeliverable) self.category = CategoryFactory(category_template__metadata_model=Model) self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.user2 = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.user3 = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.data = { 'docclass': 3, 'purpose_of_issue': 'FR', 'created_on': '2015-01-01', 'received_date': '2015-01-01' }
def test_buy_a_bet(self): """ Buy a bet """ event = EventFactory() user = UserFactory(total_cash=event.current_buy_for_price) old_price = event.current_buy_for_price bet_user, bet_event, bet = Bet.objects.buy_a_bet(user, event.id, Bet.YES, event.current_buy_for_price) self.assertEqual(user, bet_user) self.assertEqual(event, bet_event) self.assertEqual(event.current_buy_for_price, bet.bought_avg_price) self.assertEqual(1, bet.has) self.assertEqual(1, bet.bought) self.assertEqual(0, bet_user.total_cash) self.assertEqual(old_price, bet_user.portfolio_value) self.assertNotEqual(old_price, bet_event.current_buy_for_price) self.assertEqual(1, bet_event.turnover) with self.assertRaises(PriceMismatch): Bet.objects.buy_a_bet(user, event.id, Bet.YES, old_price) with self.assertRaises(InsufficientCash): Bet.objects.buy_a_bet(user, event.id, Bet.YES, bet_event.current_buy_for_price) user.total_cash = bet_event.current_buy_against_price user.save() # TODO should throw exception Bet.objects.buy_a_bet(user, event.id, Bet.NO, bet_event.current_buy_against_price)
def superuser(): """Generates a valid and active superuser.""" user = UserFactory() user.is_superuser = True user.save() return user
def test_matters_assistant_name_filter(snapshot, request): """ Test matters assistant name filter """ user_instance = UserFactory(first_name='first', last_name='last') MatterFactory.create_batch( size=5, assistant=user_instance, ) staff_member = UserFactory(id=1) request.user = staff_member client = Client(schema, context=request) query = client.execute(""" query getMatters($assistantName: String) { matters(first: 3, assistantName: $assistantName) { edges { node { id name client { id name } billableStatus } } } } """, variable_values={ 'assistantName': user_instance.full_name, }) snapshot.assert_match(query)
class BatchAckOfTransmittalsTests(TestCase): def setUp(self): self.trs = create_transmittal() self.category = self.trs.document.category self.user = UserFactory(email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.client.login(email=self.user.email, password='******') self.url = reverse('transmittal_batch_ack_of_receipt', args=[ self.category.organisation.slug, self.category.slug, ]) def test_internal_user_cannot_ack_transmittal(self): res = self.client.post(self.url, {'document_ids': [self.trs.document_id]}) self.assertEqual(res.status_code, 403) def test_acks_receipt(self): self.user.is_external = True self.user.save() res = self.client.post(self.url, {'document_ids': [self.trs.document_id]}, follow=True) self.assertEqual(res.status_code, 200) self.trs.refresh_from_db() self.assertIsNotNone(self.trs.ack_of_receipt_date) self.assertEqual(self.trs.ack_of_receipt_author, self.user)
def setUpTestData(cls): """ Initialize the class by populating the database. Some notes: - The 'ignored' company is to make a clear difference in the response for management and members of a company. """ cls.company = CompanyFactory() cls.ignored = CompanyFactory() cls.external = UserFactory(group=Group.objects.create(name="external")) cls.employer = UserFactory(group=Group.objects.get(id=Groups.employer)) cls.employee = UserFactory(group=Group.objects.get(id=Groups.employee)) cls.external_token = AuthFactory(user=cls.external) cls.employer_token = AuthFactory(user=cls.employer) cls.employee_token = AuthFactory(user=cls.employee) MemberFactory(account=cls.employer, company=cls.company) MemberFactory(account=cls.employee, company=cls.company) cls.management = UserFactory(group=Group.objects.get( id=Groups.management)) cls.administrator = UserFactory(group=Group.objects.get( id=Groups.admin)) cls.management_token = AuthFactory(user=cls.management) cls.administrator_token = AuthFactory(user=cls.administrator)
def setUp(self): self.category = CategoryFactory() user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.client.login(email=user.email, password='******') user2 = UserFactory(email='*****@*****.**', category=self.category) doc = DocumentFactory( document_key='hazop-report-1', category=self.category, revision={ 'leader': user, } ) doc.latest_revision.start_review() for _ in range(5): for u in (user, user2): NoteFactory( author=u, document=doc, revision=1) review_url = reverse('review_document', args=[doc.document_key]) self.url = '%s%s' % (self.live_server_url, review_url) self.test_file = os.path.join( os.path.dirname(__file__), 'casper_tests', 'tests.js' )
def setUpData(self): self.past_match = PastMatchFactory.create(home_team='Bordo', away_team='Chelsea') self.past_match2 = PastMatchFactory.create(home_team='Bordo', away_team='Ajax') self.past_match3 = PastMatchFactory.create(home_team='Chelsea', away_team='Ajax', home_score=None, away_score=None) self.future_match = FutureMatchFactory.create(home_team='Ajax', away_team='Barcelona', datetime="2047-01-09 05:04+00:00") self.user1 = UserFactory.create(username='******') self.user2 = UserFactory.create(username='******') self.bets = [ [ BetFactory.create(match=self.future_match, user=self.user1, home_score=2, away_score=1), BetFactory.create(match=self.future_match, user=self.user2, home_score=4, away_score=0), ], # future match [ None, BetFactory.create(match=self.past_match, user=self.user2, home_score=2, away_score=0), ], # past match [ BetFactory.create(match=self.past_match2, user=self.user1, home_score=1, away_score=3), BetFactory.create(match=self.past_match2, user=self.user2, home_score=0, away_score=0), ], [ None, BetFactory.create(match=self.past_match3, user=self.user2, home_score=0, away_score=0), ] ] self.past_match.set_score(home_score=2, away_score=0) self.past_match2.set_score(home_score=0, away_score=0)
def setUpTestData(cls): employer_group = Group.objects.get(id=Groups.employer) employee_group = Group.objects.get(id=Groups.employee) managing_group = Group.objects.get(id=Groups.management) cls.companyA = CompanyFactory() cls.companyB = CompanyFactory() cls.employerA = UserFactory(group=employer_group) cls.employeeA = UserFactory(group=employee_group) cls.employerB = UserFactory(group=employer_group) cls.employeeB = UserFactory(group=employee_group) cls.management = UserFactory(group=managing_group) cls.employee_a_token = AuthFactory(user=cls.employeeA) cls.employer_a_token = AuthFactory(user=cls.employerA) cls.employee_b_token = AuthFactory(user=cls.employeeB) cls.employer_b_token = AuthFactory(user=cls.employerB) cls.management_token = AuthFactory(user=cls.management) MemberFactory(account=cls.employerA, company=cls.companyA) MemberFactory(account=cls.employeeA, company=cls.companyA) MemberFactory(account=cls.employerB, company=cls.companyB) MemberFactory(account=cls.employeeB, company=cls.companyB)
class BatchAckOfTransmittalsTests(TestCase): def setUp(self): self.trs = create_transmittal() self.category = self.trs.document.category self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.client.login(email=self.user.email, password='******') self.url = reverse('transmittal_batch_ack_of_receipt', args=[ self.category.organisation.slug, self.category.slug, ]) def test_internal_user_cannot_ack_transmittal(self): res = self.client.post(self.url, {'document_ids': [self.trs.document_id]}) self.assertEqual(res.status_code, 403) def test_acks_receipt(self): self.user.is_external = True self.user.save() res = self.client.post( self.url, {'document_ids': [self.trs.document_id]}, follow=True) self.assertEqual(res.status_code, 200) self.trs.refresh_from_db() self.assertIsNotNone(self.trs.ack_of_receipt_date) self.assertEqual(self.trs.ack_of_receipt_author, self.user)
def test_matter_report_filter_with_value_error(snapshot, request): """ Test matter report filter with value error """ user_instance = UserFactory(first_name='name', last_name='name') MatterFactory.create_batch( size=5, assistant=user_instance, ) staff_member = UserFactory(id=1) request.user = staff_member client = Client(schema, context=request) query = client.execute(""" query getMatters($matterReport: String) { matters(first: 3, matterReport: $matterReport) { edges { node { id name client { id name } billableStatus } } } } """, variable_values={ 'matterReport': 'name', }) snapshot.assert_match(query)
def test_plan_restrictions(self): corp_account = CorporateAccountFactory.create() corp_user = UserFactory.create(account=corp_account) plan_1 = PlanFactory() plan_2 = PlanFactory() plan_3 = PlanFactory() account_1 = AccountFactory(plan=plan_1) account_2 = AccountFactory(plan=plan_2) account_3 = AccountFactory(plan=plan_3) user_1 = UserFactory(account=account_1) user_2 = UserFactory(account=account_2) user_3 = UserFactory(account=account_3) flight = FlightFactory(departure=arrow.now().replace(days=+12).datetime) self.assertTrue(flight.check_plan_restrictions(corp_user), 'always allow corp users') self.assertTrue(flight.check_plan_restrictions(user_1), 'no plan restrictions') self.assertTrue(flight.check_plan_restrictions(user_2), 'no plan restrictions') self.assertTrue(flight.check_plan_restrictions(user_3), 'no plan restrictions') FlightPlanRestrictionFactory(flight=flight, plan=plan_1, days=2) FlightPlanRestrictionFactory(flight=flight, plan=plan_2, days=12) FlightPlanRestrictionFactory(flight=flight, plan=plan_3, days=16) self.assertTrue(flight.check_plan_restrictions(corp_user), 'always allow corp users') self.assertFalse(flight.check_plan_restrictions(user_1), 'only 2 days out') self.assertTrue(flight.check_plan_restrictions(user_2), 'just now') self.assertTrue(flight.check_plan_restrictions(user_3), 'been good') flight.departure = arrow.now().replace(days=+13).datetime flight.save() self.assertTrue(flight.check_plan_restrictions(corp_user), 'always allow corp users') self.assertFalse(flight.check_plan_restrictions(user_1), 'only 2 days out') self.assertFalse(flight.check_plan_restrictions(user_2), 'just now') self.assertTrue(flight.check_plan_restrictions(user_3), 'been good') flight.departure = arrow.now().replace(days=+16).datetime flight.save() self.assertTrue(flight.check_plan_restrictions(corp_user), 'always allow corp users') self.assertFalse(flight.check_plan_restrictions(user_1), 'only 2 days out') self.assertFalse(flight.check_plan_restrictions(user_2), 'just now') self.assertTrue(flight.check_plan_restrictions(user_3), 'been good') flight.departure = arrow.now().replace(days=+17).datetime flight.save() self.assertTrue(flight.check_plan_restrictions(corp_user), 'always allow corp users') self.assertFalse(flight.check_plan_restrictions(user_1), 'only 2 days out') self.assertFalse(flight.check_plan_restrictions(user_2), 'just now') self.assertFalse(flight.check_plan_restrictions(user_3), 'been good')
def test_check_user_permissions(self): account = AccountFactory.create() user_1 = UserFactory.create(account=account) user_2 = UserFactory.create(account=account) flight = FlightFactory.create() self.assertFalse(flight.check_user_permissions(user_1), 'no fly permissions') self.assertFalse(flight.check_user_permissions(user_2), 'no fly permissions') user_1.user_permissions.add(Permission.objects.get(codename='can_fly')) delattr(user_1, '_perm_cache') self.assertTrue(flight.check_user_permissions(user_1), 'can fly permissions') self.assertFalse(flight.check_user_permissions(user_2), 'no fly permissions') user_2.user_permissions.add(Permission.objects.get(codename='can_fly')) delattr(user_2, '_perm_cache') user_1.user_permissions.add(Permission.objects.get(codename='can_book_promo_flights')) delattr(user_1, '_perm_cache') promo_flight = FlightFactory.create(flight_type=Flight.TYPE_PROMOTION) self.assertTrue(flight.check_user_permissions(user_1), 'regular flight') self.assertTrue(flight.check_user_permissions(user_2), 'regular flight') self.assertTrue(promo_flight.check_user_permissions(user_1), 'promo flight') self.assertFalse(promo_flight.check_user_permissions(user_2), 'promo flight nope')
def setUp(self): self.category = CategoryFactory() self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category ) self.other_user = UserFactory( email='*****@*****.**', password='******', ) self.client.login(email=self.user.email, password='******') doc = DocumentFactory( document_key='test_key', category=self.category, revision={ 'reviewers': [], 'leader': self.user, 'received_date': datetime.date.today(), } ) revision = doc.latest_revision revision.start_review() self.review = revision.get_review(self.user) self.url = self.review.get_comments_url() pdf_doc = 'sample_doc_pdf.pdf' self.sample_pdf = SimpleUploadedFile(pdf_doc, b'content')
def setUp(self): self.test_user = UserFactory(username='******') self.test_user_2 = UserFactory(username='******') self.public_guide_1 = GuideFactory(owner=self.test_user, private=False, name='Public Crane') self.public_guide_2 = GuideFactory(owner=self.test_user_2, private=False, name='Public Paper') self.private_guide_1 = GuideFactory(owner=self.test_user, private=True, name='Private') self.private_guide_2 = GuideFactory(owner=self.test_user_2, private=True, name='Private 2')
def setUp(self): super().setUp() Model = ContentType.objects.get_for_model(ContractorDeliverable) self.cat1 = CategoryFactory(category_template__metadata_model=Model) self.cat2 = CategoryFactory(category_template__metadata_model=Model) self.user1 = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.cat1, send_behind_schedule_alert_mails=True) self.user1.categories.add(self.cat2) self.user2 = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.cat2, send_behind_schedule_alert_mails=True) self.doc1 = DocumentFactory( category=self.cat1, metadata_factory_class=ContractorDeliverableFactory, revision_factory_class=ContractorDeliverableRevisionFactory) self.doc2 = DocumentFactory( category=self.cat2, metadata_factory_class=ContractorDeliverableFactory, revision_factory_class=ContractorDeliverableRevisionFactory) populate_values_list_cache()
class UserApiAclTests(APITestCase): def setUp(self): self.category = CategoryFactory() self.user = UserFactory(name='user', password='******', category=self.category) self.dc_perms = Permission.objects.filter(codename__endswith='_document') self.dc = UserFactory(name='dc', password='******', category=self.category) self.dc.user_permissions = self.dc_perms self.dc.save() self.url = reverse('user-list', args=[ self.category.organisation.slug, self.category.category_template.slug, ]) def test_anonymous_access_forbidden(self): """Anonymous cannot access the user api.""" res = self.client.get(self.url) self.assertEqual(res.status_code, 403) def test_simple_user_access_forbidden(self): """Simple users don't have access to the user api.""" self.client.login(username=self.user.email, password='******') res = self.client.get(self.url) self.assertEqual(res.status_code, 403) def test_dc_can_access_user_api(self): """Document controllers can access the user api.""" self.client.login(username=self.dc.email, password='******') res = self.client.get(self.url) self.assertEqual(res.status_code, 200) def test_dc_can_only_access_users_from_his_category(self): other_category = CategoryFactory() user = UserFactory(name='dc2', password='******', category=other_category) user.user_permissions = self.dc_perms user.save() self.client.login(username=user.email, password='******') res = self.client.get(self.url) self.assertEqual(res.status_code, 403) def test_dc_cannot_see_users_from_other_categories(self): other_category = CategoryFactory() user1 = UserFactory(name='toto', password='******', category=other_category) user1.save() user2 = UserFactory(name='tata', password='******', category=self.category) user2.save() self.client.login(username=self.dc.email, password='******') res = self.client.get(self.url) self.assertEqual(res.status_code, 200) self.assertTrue('tata' in res.content) self.assertTrue('toto' not in res.content)
def setUp(self): self.trs = create_transmittal() self.trs.recipient.users.add(UserFactory(email='*****@*****.**')) self.trs.recipient.users.add(UserFactory(email='*****@*****.**')) self.trs.recipient.users.add(UserFactory(email='*****@*****.**')) self.trs.recipient.users.add( UserFactory(email='*****@*****.**', send_trs_reminders_mails=False))
def test_match_update_bets_calls_set_result_for_every_bet( self, mock_set_result): user1 = UserFactory.create() user2 = UserFactory.create() match = PastMatchFactory(home_score=1, away_score=2) bet1 = BetFactory(match=match, user=user1) BetFactory(match=match, user=user2) match.update_bets() self.assertEqual(mock_set_result.call_count, 2)
class AdminTest(FunctionalTest): def setUp(self): super().setUp() # Create a superuser self.password = '******' self.admin_user = UserFactory(password=self.password) self.admin_user.is_admin = True self.admin_user.save() # Create packages and doctypes for the new audit PackageFactory(name='TestPackage') DoctypeFactory(name='TestDoctype') def test_can_create_new_audit_via_admin_site(self): # Gertrude opens her web browser, and goes to the admin page self.browser.get(self.server_url + '/admin/') # She sees the familiar 'Django administration' heading body = self.browser.find_element_by_tag_name('body') self.assertIn('Django administration', body.text) # She inserts her email and password email_input = self.browser.find_element_by_id('id_username') email_input.send_keys(self.admin_user.email) password_input = self.browser.find_element_by_id('id_password') password_input.send_keys(self.password + '\n') # Aftwer beign logged in, she visits the audit creation page audit_section = self.browser.find_element_by_css_selector('.model-audit') audit_section.find_element_by_css_selector('.addlink').click() # She inserts all the required information in order to create a new audit self.browser.find_element_by_id('id_name').send_keys('A new test audit') self.browser.find_element_by_id('id_description').send_keys('A text description for our new audit') package_dropdown = Select(self.browser.find_element_by_id('id_package')) package_dropdown.select_by_visible_text('TestPackage') doctype_selection = Select(self.browser.find_element_by_id('id_required_doctypes')) doctype_selection.select_by_visible_text('TestDoctype') runner_dropdown = Select(self.browser.find_element_by_id('id_runner')) runner_dropdown.select_by_visible_text('DummyAudit') # She then saves her new audit by clicking on the Save button self.browser.find_element_by_css_selector('.default').click() # A list page is displayed, and she can see her newly created audit is in there self.assertTrue(self.browser.find_element_by_link_text('A new test audit')) # Finally, she visits to the home page to check if her new audit is displayed self.browser.find_element_by_link_text('VIEW SITE').click() page_text = self.browser.find_element_by_tag_name('body').text self.assertIn('A new test audit', page_text)
class PasswordResetTestCase(APITestCase): User = get_user_model() def setUp(self): self.user = UserFactory() def send_reset_password_request(self, data): """ Send request to reset password """ response = self.client.post( reverse('password_reset:reset-password-request'), data=data) return response def test_successful_generate_token(self): """ Test successful generating token for provided email """ data = {'email': self.user.email} response = self.send_reset_password_request(data) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_invalid_email(self): """ Test failure generating token for invalid email """ data = {'email': '*****@*****.**'} response = self.send_reset_password_request(data) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) def test_successful_validate_token(self): """ Test successful validating token """ data = {'email': self.user.email} self.send_reset_password_request(data) token = ResetPasswordToken.objects.first().key response = self.client.post( reverse('password_reset:reset-password-validate'), data={'token': token}) self.assertEqual(response.status_code, status.HTTP_200_OK) def test_fail_validating_token(self): """ Test unsuccessful validating wrong token """ response = self.client.post( reverse('password_reset:reset-password-validate'), data={'token': 'wrong_token'}) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) def test_successful_change_password(self): """ Test successful changing password with provided token and password """ self.send_reset_password_request({'email': self.user.email}) token = ResetPasswordToken.objects.first().key data = {'token': token, 'password': '******'} response = self.client.post( reverse('password_reset:reset-password-confirm'), data=data) self.user.refresh_from_db() self.assertTrue(self.user.check_password('exampleNewPassword')) def test_fail_change_password(self): """ Test fail changing password with provided wrong token """ data = {'token': 'wrong_token', 'password': '******'} self.client.post(reverse('password_reset:reset-password-confirm'), data=data) self.assertFalse(self.user.check_password('exampleNewPassword'))
def test_dc_can_only_access_users_from_his_category(self): other_category = CategoryFactory() user = UserFactory(name='dc2', password='******', category=other_category) user.user_permissions = self.dc_perms user.save() self.client.login(username=user.email, password='******') res = self.client.get(self.url) self.assertEqual(res.status_code, 403)
def test_user_role_contributor(): """Users with 'is_contributor' as True are considered as contributors.""" # user UserFactory(is_contributor=False) # contributor UserFactory(is_contributor=True) assert User.objects.count() == 2 assert User.objects.contributors().count() == 1
def test_notification_list(self): trs = create_transmittal() rev = trs.latest_revision trs.recipient.users.add(UserFactory(email='*****@*****.**')) trs.recipient.users.add(UserFactory(email='*****@*****.**')) trs.recipient.users.add(UserFactory(email='*****@*****.**')) send_transmittal_creation_notifications(trs, rev) self.assertEqual(len(mail.outbox), 3)
def setUp(self): self.category = CategoryFactory() self.user = UserFactory(email='*****@*****.**', password='******', category=self.category) self.client.login(email=self.user.email, password='******') self.user2 = UserFactory(email='*****@*****.**', password='******', category=self.category)
class PendingReviewsReminderTests(TestCase): def setUp(self): self.category = CategoryFactory() self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category ) self.client.login(email=self.user.email, password='******') self.doc1 = DocumentFactory( category=self.category, revision={ 'leader': self.user, 'received_date': datetime.date.today(), } ) self.doc2 = DocumentFactory( category=self.category, revision={ 'leader': self.user, 'received_date': datetime.date.today(), } ) def test_empty_reminder_list(self): call_command('send_review_reminders') self.assertEqual(len(mail.outbox), 0) def test_send_reminders(self): self.doc1.get_latest_revision().start_review() self.assertEqual(Review.objects.all().count(), 1) call_command('send_review_reminders') self.assertEqual(len(mail.outbox), 1) def test_finished_reviews(self): rev = self.doc1.get_latest_revision() rev.start_review() rev.end_review() self.assertEqual(Review.objects.all().count(), 1) call_command('send_review_reminders') self.assertEqual(len(mail.outbox), 0) def test_do_not_send_reminder(self): """Reminders are not send to users if their mail config says so.""" self.doc1.get_latest_revision().start_review() self.assertEqual(Review.objects.all().count(), 1) self.user.send_pending_reviews_mails = False self.user.save() call_command('send_review_reminders') self.assertEqual(len(mail.outbox), 0)
def setUp(self): cache.clear() self.category = CategoryFactory() self.user = UserFactory(email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.other_user = UserFactory(email='*****@*****.**', category=self.category) self.client.login(email=self.user.email, password='******') self.url = reverse('category_list')
def test_user_role_search_page_admin(): """Users with linked Search Pages are considered as Search Page administrators.""" # user UserFactory(is_contributor=False) # search page administrator search_page_administrator = UserFactory(is_contributor=False) SearchPageFactory(administrator=search_page_administrator) assert User.objects.count() == 2 assert User.objects.search_page_admins().count() == 1
def test_attendance_data(self): user1 = UserFactory(email='*****@*****.**') user2 = UserFactory(email='*****@*****.**') AttendanceFactory(user=user1, event=self.event) AttendanceFactory(user=user2, event=self.event) url = reverse('event:detail', kwargs={"pk": self.event.pk}) self.client.login(email='*****@*****.**', password='******') response = self.client.get(url) self.assertContains(response, "user1") self.assertContains(response, "user2")
def test_can_get_images_uploaded_by_a_user(self): """ Tests that the manager can get images specifically uploaded by a user. """ user_1 = UserFactory.create() user_2 = UserFactory.create() image_1a = ImageFactory.create(uploaded_by=user_1) image_1b = ImageFactory.create(uploaded_by=user_1) image_2a = ImageFactory.create(uploaded_by=user_2) self.assertEquals([image_1b, image_1a], list(Image.objects.filter_uploaded_by(user_1))) self.assertEquals([image_2a], list(Image.objects.filter_uploaded_by(user_2)))
def setUp(self): self.category = CategoryFactory() self.user1 = UserFactory(username='******', category=self.category) self.user2 = UserFactory(username='******', category=self.category) self.user3 = UserFactory(username='******', category=self.category) self.doc = DocumentFactory(revision={ 'leader': self.user1, }) self.revision = self.doc.latest_revision self.revision.start_review()
def test_reviewers_not_in_categories(self): form = DistributionListForm({ 'name': 'test', 'categories': [self.category.id], 'leader': self.users[0].id, 'reviewers': [UserFactory().id, UserFactory().id] }) self.assertFalse(form.is_valid()) self.assertTrue('reviewers' in form.errors)
def setUp(self): super(ClosedReviewsEmailTests, self).setUp() self.today = timezone.now() self.yesterday = timezone.now() - datetime.timedelta(days=1) self.originator = EntityFactory( type='originator', users=[ UserFactory(), UserFactory(), UserFactory(), UserFactory(send_closed_reviews_mails=False), ])
class FileTransmittedDownloadTests(TestCase): def setUp(self): self.trs = create_transmittal() self.rev = self.trs.latest_revision self.category = self.trs.document.category self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, is_external=True, category=self.category) self.trs.recipient.users.add(self.user) self.client.login(email=self.user.email, password='******') self.linked_rev = self.trs.get_revisions()[0] self.url = reverse('file_transmitted_download', args=[ self.category.organisation.slug, self.category.slug, self.trs.document_number, self.linked_rev.metadata.document_key, self.linked_rev.revision, ]) pdf_doc = 'sample_doc_pdf.pdf' sample_pdf = SimpleUploadedFile(pdf_doc, b'content') self.linked_rev.file_transmitted = sample_pdf self.linked_rev.save() def test_url_is_accessible_to_externals(self): u"""This download url is for contractors only.""" res = self.client.get(self.url) self.assertEqual(res.status_code, 200) self.user.is_external = False self.user.save() res = self.client.get(self.url) self.assertEqual(res.status_code, 404) def test_that_revision_is_linked_to_transmittal(self): u"""The file must have been transmitted.""" self.linked_rev.transmittals.clear() self.linked_rev.save() res = self.client.get(self.url) self.assertEqual(res.status_code, 404) def test_that_contractor_is_in_recipients(self): u"""The contractor must be allowed to access the transmittal.""" self.trs.recipient.users.clear() self.trs.recipient.save() res = self.client.get(self.url) self.assertEqual(res.status_code, 404)
def test_get_bet_social(self): """ Get bet social """ event = EventFactory() users_yes = UserFactory.create_batch(10) users_no = UserFactory.create_batch(10) bets_yes = [BetFactory(user=u, event=event) for u in users_yes] bets_no = [BetFactory(user=u, event=event, outcome=Bet.NO) for u in users_no] self.maxDiff = None social = event.get_bet_social() self.assertEqual(10, social['yes_count']) self.assertEqual(bets_yes[:6], list(social['yes_bets'])) self.assertEqual(10, social['no_count']) self.assertEqual(bets_no[:6], list(social['no_bets']))
def create_admin(self): # Factory creates simple user, so ``is_staff`` is set later self.admin = UserFactory(username="******", password="******") self.admin.is_staff = True self.admin.is_superuser = True self.admin.save() print("admin user have been created successfully")
def setUp(self): self.moderator = ModeratorFactory() self.standard_user = UserFactory( first_name='Firsto', last_name='Namo', ) self.invited_pending = InvitedPendingFactory() self.requested_pending = RequestedPendingFactory()
def test_can_logout(self): """ Tests the logout view. """ user = UserFactory.create() self.client.login(**{'username': user.username, 'password': '******'}) response = self.client.get(reverse('accounts:logout'), follow=True) self.assertRedirects(response, '{0}?next={1}'.format(reverse('accounts:login'), reverse('images:upload'))) self.assertFalse(response.context['user'].is_authenticated())
class AckReceiptOfTransmittalTests(TestCase): def setUp(self): self.trs = create_transmittal() self.category = self.trs.document.category self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.client.login(email=self.user.email, password='******') self.url = reverse('transmittal_ack_of_receipt', args=[ self.category.organisation.slug, self.category.slug, self.trs.document.document_key ]) def test_non_contractor_acks_receipt(self): """Non contractor cannot ack receipt of transmittals.""" res = self.client.post(self.url) self.assertEqual(res.status_code, 403) def test_acks_receipt(self): self.assertIsNone(self.trs.ack_of_receipt_date) self.assertIsNone(self.trs.ack_of_receipt_author) self.user.is_external = True self.user.save() res = self.client.post(self.url, follow=True) self.assertEqual(res.status_code, 200) self.trs.refresh_from_db() self.assertIsNotNone(self.trs.ack_of_receipt_date) self.assertEqual(self.trs.ack_of_receipt_author, self.user) def test_acks_receipt_twice_fails(self): self.user.is_external = True self.user.save() self.trs.ack_receipt(self.user) res = self.client.post(self.url, follow=True) self.assertEqual(res.status_code, 403)
class AclTests(TestCase): def setUp(self): category = CategoryFactory() self.user = UserFactory(name='User', password='******', category=category) self.home_url = reverse('category_document_list', args=[ category.organisation.slug, category.slug ]) self.create_url = reverse('document_create', args=[ category.organisation.slug, category.slug ]) self.login_url = '/accounts/login/' self.dc_perms = Permission.objects.filter(codename__endswith='_document') def test_anonymous_access(self): res = self.client.get(self.home_url) self.assertRedirects(res, '%s?next=%s' % (self.login_url, self.home_url)) res = self.client.get(self.create_url) self.assertRedirects(res, '%s?next=%s' % (self.login_url, self.create_url)) def test_authenticated_user_access(self): self.client.login(username=self.user.email, password='******') res = self.client.get(self.home_url) self.assertEqual(res.status_code, 200) res = self.client.get(self.create_url) self.assertRedirects(res, '%s?next=%s' % (self.login_url, self.create_url)) def test_document_controller_access(self): self.user.user_permissions = self.dc_perms self.user.save() self.client.login(username=self.user.email, password='******') res = self.client.get(self.home_url) self.assertEqual(res.status_code, 200) res = self.client.get(self.create_url) self.assertEqual(res.status_code, 200)
def setUp(self): HospitalFactory.create_batch(5) Hospital.objects.filter(id=1).update(is_kamc=True) SpecialtyFactory.create_batch(5) Department.objects.create( hospital=Hospital.objects.first(), specialty=Specialty.objects.first(), contact_name="", contact_position="", email="", phone="", extension="", ) UserFactory.create_batch(10) super(ProtractorTests, self).setUp()
def setUp(self): self.site = get_current_site(self.client.request) self.site.config = SiteConfigFactory(site=self.site) self.reporting_user = UserFactory() self.accused_user = UserFactory() self.moderator = ModeratorFactory() factory.create_batch( ModeratorFactory, 10, moderator=self.moderator, )
def setUp(self): category = CategoryFactory() self.user = UserFactory(name='User', password='******', category=category) self.url = reverse('category_document_list', args=[ category.organisation.slug, category.slug ]) self.dc_perms = Permission.objects.filter(codename__endswith='_document') self.create_url = reverse('document_create', args=[ category.organisation.slug, category.slug ])
def test_can_login_and_redirect(self): """ Tests a user can login and be redirected back to the homepage. """ user = UserFactory.create() response = self.client.post( reverse('accounts:login'), data={'username': user.username, 'password': '******'}, follow=True, ) self.assertRedirects(response, reverse('images:upload')) self.assertTrue(response.context['user'].is_authenticated())
def test_current_event_price(self): """ Current event price """ event = EventFactory() users = UserFactory.create_batch(2) bet1 = BetFactory(event=event, user=users[0], outcome=Bet.YES) bet2 = BetFactory(event=event, user=users[1], outcome=Bet.NO) event.current_buy_for_price = 55 event.current_buy_against_price = 45 self.assertEqual(55, bet1.current_event_price()) self.assertEqual(45, bet2.current_event_price())
def setUp(self): super().setUp() # Create a superuser self.password = '******' self.admin_user = UserFactory(password=self.password) self.admin_user.is_admin = True self.admin_user.save() # Create packages and doctypes for the new audit PackageFactory(name='TestPackage') DoctypeFactory(name='TestDoctype')
class TransmittalActionTests(TestCase): def setUp(self): self.trs = create_transmittal() self.doc = self.trs.document self.category = self.doc.category self.url = reverse("document_detail", args=[ self.category.organisation.slug, self.category.slug, self.doc.document_key ]) self.user = UserFactory( name='User', password='******', is_superuser=True, category=self.category) self.client.login(username=self.user.email, password='******') def test_internal_user_cannot_ack_transmittal(self): self.assertIsNone(self.trs.ack_of_receipt_date) self.assertFalse(self.user.is_external) res = self.client.get(self.url) self.assertNotContains(res, ack_button) def test_external_user_can_ack_transmittal(self): self.user.is_external = True self.user.save() res = self.client.get(self.url) self.assertContains(res, ack_button) def test_transmittal_cannot_be_acked_twice(self): self.user.is_external = True self.trs.ack_receipt(self.user) self.assertIsNotNone(self.trs.ack_of_receipt_date) res = self.client.get(self.url) self.assertNotContains(res, ack_button)
def setUp(self): self.category = CategoryFactory() self.user = UserFactory(name='user', password='******', category=self.category) self.dc_perms = Permission.objects.filter(codename__endswith='_document') self.dc = UserFactory(name='dc', password='******', category=self.category) self.dc.user_permissions = self.dc_perms self.dc.save() self.url = reverse('user-list', args=[ self.category.organisation.slug, self.category.category_template.slug, ])
def setUp(self): self.trs = create_transmittal() self.category = self.trs.document.category self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category) self.client.login(email=self.user.email, password='******') self.url = reverse('transmittal_batch_ack_of_receipt', args=[ self.category.organisation.slug, self.category.slug, ])
def setUp(self): self.trs = create_transmittal() self.doc = self.trs.document self.category = self.doc.category self.url = reverse("document_detail", args=[ self.category.organisation.slug, self.category.slug, self.doc.document_key ]) self.user = UserFactory( name='User', password='******', is_superuser=True, category=self.category) self.client.login(username=self.user.email, password='******')
def setUp(self): self.category = CategoryFactory() self.user = UserFactory( email='*****@*****.**', password='******', is_superuser=True, category=self.category ) self.url = reverse('feed_new_documents', args=[ self.category.organisation.slug, self.category.slug, ]) DocumentFactory( title='document 1', category=self.category, )
def setUp(self): self.site = get_current_site(self.client.request) self.site.config = SiteConfigFactory(site=self.site) self.standard_user = UserFactory() self.reporting_user = UserFactory() self.accused_user = UserFactory() self.moderator = ModeratorFactory() self.abuse_report = AbuseReportFactory( logged_against=self.accused_user, logged_by=self.reporting_user ) self.abuse_warning = AbuseWarningFactory( logged_against=self.accused_user )
def setUp(self): self.category = CategoryFactory() self.user = UserFactory( name='User', password='******', is_superuser=True, category=self.category) self.client.login(username=self.user.email, password='******') self.doc = DocumentFactory( category=self.category, revision={ 'leader': self.user, } ) self.url = reverse("document_detail", args=[ self.category.organisation.slug, self.category.slug, self.doc.document_key ])
def test_finish_yes(self): """ Finish event with outcome yes """ users = UserFactory.create_batch(3) for u in users: u.portfolio_value = 1000 u.total_cash = 2000 event = EventFactory() bets = [BetFactory(event=event, user=user, has=3) for user in users[:2]] bets[1].outcome = Bet.NO bets[1].save() event.finish_yes() self.assertIsNotNone(event.end_date) self.assertEqual(Event.FINISHED_YES, event.outcome) event2 = EventFactory(outcome=Event.FINISHED_NO) with self.assertRaises(EventNotInProgress): event2.finish_yes()
def test_dc_cannot_see_users_from_other_categories(self): other_category = CategoryFactory() user1 = UserFactory(name='toto', password='******', category=other_category) user1.save() user2 = UserFactory(name='tata', password='******', category=self.category) user2.save() self.client.login(username=self.dc.email, password='******') res = self.client.get(self.url) self.assertEqual(res.status_code, 200) self.assertTrue('tata' in res.content) self.assertTrue('toto' not in res.content)