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 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):
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):
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_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)
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 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()
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)
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 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 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 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)
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 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_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 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 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),
])
def test_user_role_animator():
"""Users with 'animator_perimeter' filled are considered as local animators."""
# user
UserFactory(is_contributor=False)
# local animator
martinique = PerimeterFactory(name='Martinique',
scale=Perimeter.SCALES.region)
UserFactory(animator_perimeter=martinique)
assert User.objects.count() == 2
assert User.objects.animators().count() == 1
def setUp(self):
self.category = CategoryFactory()
self.user = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.user2 = UserFactory(email='*****@*****.**',
password='******',
category=self.category)
self.user3 = UserFactory(email='*****@*****.**',
password='******',
category=self.category)
def setUp(self):
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('priorities_review_document_list')
def test_user_role_api_token():
"""Users with a Token are considered as API users."""
# user
UserFactory(is_contributor=False)
# api user
api_user = UserFactory(is_contributor=False)
# There are different ways to generate an API Token (most simple one: in the Admin UI)
# https://django-rest-framework.readthedocs.io/en/3.4.7/api-guide/authentication.html?highlight=generate#generating-tokens # noqa
# call_command('drf_create_token', api_user.email)
Token.objects.get_or_create(user=api_user)
assert User.objects.count() == 2
assert User.objects.with_api_token().count() == 1
def setUp(self):
self.test_user = UserFactory()
self.test_user_2 = UserFactory()
self.private_guide = GuideFactory(
owner=self.test_user,
name='name',
private=True,
guide_file__data=b'guide'
)
self.public_guide = GuideFactory(
owner=self.test_user,
name='name',
private=False,
)
def test_new_reviews_statuses(self):
revision = self.create_reviewable_document()
revision.reviewers.add(UserFactory(), UserFactory())
revision.start_review()
reviewer_review = revision.get_review(self.user2)
self.assertEqual(reviewer_review.status, 'progress')
leader_review = revision.get_leader_review()
self.assertEqual(leader_review.status, 'pending')
approver_review = revision.get_approver_review()
self.assertEqual(approver_review.status, 'pending')
def setUpTestData(cls):
cls.company = CompanyFactory()
cls.ignored = CompanyFactory()
cls.employer = UserFactory(group=Group.objects.get(id=Groups.employer))
cls.employee = UserFactory(group=Group.objects.get(id=Groups.employee))
cls.managing = UserFactory(group=Group.objects.get(
id=Groups.management))
cls.employee_token = AuthFactory(user=cls.employee)
cls.employer_token = AuthFactory(user=cls.employer)
cls.managing_token = AuthFactory(user=cls.managing)
MemberFactory(account=cls.employer, company=cls.company)
MemberFactory(account=cls.employee, company=cls.company)
def setUp(self):
self.category = CategoryFactory()
self.user1 = UserFactory(email='*****@*****.**',
password='******',
is_superuser=True,
category=self.category)
self.client.login(email=self.user1.email, password='******')
self.user2 = UserFactory(email='*****@*****.**',
password='******',
category=self.category)
self.doc = DocumentFactory(revision={
'leader': self.user1,
})
self.revision = self.doc.latest_revision
self.revision.start_review()
def test_plan_seat_restrictions(self):
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, seats_total=8)
self.assertTrue(flight.check_plan_seat_restrictions(user_1, 1), 'no plan seat restrictions')
self.assertTrue(flight.check_plan_seat_restrictions(user_2, 1), 'no plan seat restrictions')
self.assertTrue(flight.check_plan_seat_restrictions(user_3, 1), 'no plan seat restrictions')
FlightPlanSeatRestrictionFactory(flight=flight, plan=plan_1, seats=1)
FlightPlanSeatRestrictionFactory(flight=flight, plan=plan_2, seats=2)
FlightPlanSeatRestrictionFactory(flight=flight, plan=plan_3, seats=3)
self.assertTrue(flight.check_plan_seat_restrictions(user_1, 1), 'seats still available for plan')
self.assertTrue(flight.check_plan_seat_restrictions(user_2, 1), 'seats still available for plan')
self.assertTrue(flight.check_plan_seat_restrictions(user_3, 1), 'seats still available for plan')
account_4 = AccountFactory(plan=plan_1)
account_5 = AccountFactory(plan=plan_2)
account_6 = AccountFactory(plan=plan_3)
reservation_4 = ReservationFactory(account=account_4)
FlightReservationFactory.create(reservation=reservation_4, flight=flight, passenger_count=1)
reservation_4.reserve()
self.assertFalse(flight.check_plan_seat_restrictions(user_1, 1), 'No seats still available for plan')
reservation_5 = ReservationFactory(account=account_5)
FlightReservationFactory.create(reservation=reservation_5, flight=flight, passenger_count=2)
reservation_5.reserve()
self.assertFalse(flight.check_plan_seat_restrictions(user_2, 1), 'No seats still available for plan')
reservation_6 = ReservationFactory(account=account_6)
FlightReservationFactory.create(reservation=reservation_6, flight=flight, passenger_count=3)
reservation_6.reserve()
self.assertFalse(flight.check_plan_seat_restrictions(user_3, 1), 'No seats still available for plan')
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")
