def setUp(self):
TestCase.setUp(self)
self.generator = Generator()
self.api = Api()
self.object_generator = ObjectGenerator()
self.init_users()
self.init_assignable()
def setUp(self):
"""Prepare data needed to run the tests"""
self.api = Api()
self.setup_roles()
self.setup_users()
self.setup_audits()
self.setup_snapshots_and_issue()
def setUp(self):
super(TestPermissionsOnAssessmentTemplate, self).setUp()
self.api = Api()
editor = all_models.AccessControlRole.query.filter(
all_models.AccessControlRole.name == "Program Editors").one()
self.generator = ObjectGenerator()
_, self.editor = self.generator.generate_person(user_role="Creator")
_, program = self.generator.generate_object(
all_models.Program, {
"access_control_list":
[acl_helper.get_acl_json(editor.id, self.editor.id)]
})
program_id = program.id
_, audit = self.generator.generate_object(
all_models.Audit,
{
"title": "Assessment Template test Audit",
"program": {
"id": program_id
},
"status": "Planned"
},
)
audit_id = audit.id
generated_at = self.generator.generate_object(
all_models.AssessmentTemplate,
self._get_assessment_template_base("Template", audit))
self.assessment_template_resp, assessment_template = generated_at
assessment_template_id = assessment_template.id
self.api.set_user(self.editor)
self.perms_data = self.api.client.get("/permissions").json
self.audit = all_models.Audit.query.get(audit_id)
self.assessment_template = all_models.AssessmentTemplate.query.get(
assessment_template_id)
def setUp(self):
super(TestWorkflowsApiPost, self).setUp()
self.api = Api()
self.generator = wf_generator.WorkflowsGenerator()
self.wf_admin_id = all_models.Person.query.first().id
with factories.single_commit():
self.people_ids = [factories.PersonFactory().id for _ in xrange(6)]
def setUp(self):
super(TestReader, self).setUp()
self.generator = Generator()
self.api = Api()
self.object_generator = ObjectGenerator()
self.init_users()
self.init_assignable()
def setUp(self):
"""Set up."""
super(TestWfNotifsGenerator, self).setUp()
self.api = Api()
self.wf_generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
Notification.query.delete()
with freeze_time("2015-05-01 14:29:00"):
wf_slug = "wf1"
with factories.single_commit():
wf = wf_factories.WorkflowFactory(slug=wf_slug)
task_group = wf_factories.TaskGroupFactory(workflow=wf)
wf_factories.TaskGroupTaskFactory(
task_group=task_group,
title='task1',
start_date=datetime.now(),
end_date=datetime.now() + timedelta(7)
)
data = workflow_api.get_cycle_post_dict(wf)
self.api.post(all_models.Cycle, data)
wf = all_models.Workflow.query.filter_by(slug=wf_slug).one()
self.cycle = all_models.Cycle.query.filter_by(workflow_id=wf.id).one()
self.ctask = all_models.CycleTaskGroupObjectTask.query.filter_by(
cycle_id=self.cycle.id).first()
def setUp(self):
"""Imports test_csvs/audit_rbac.csv needed by the tests"""
self._check_csv_response(self.response, {})
self.api = Api()
self.client.get("/login")
db.engine.execute("""
UPDATE audits
SET archived = 0,
description = ""
WHERE title = '2016: Program Manager Audit RBAC Test - Audit 1'
""")
db.engine.execute("""
UPDATE audits
SET archived = 1,
description = ""
WHERE title = '2016: Program Manager Audit RBAC Test - Audit 2'
""")
db.engine.execute("""
UPDATE issues
SET title = slug
""")
db.engine.execute("""
UPDATE assessments
SET title = slug
""")
db.engine.execute("""
UPDATE assessment_templates
SET title = slug
""")
db.engine.execute("""
UPDATE snapshots
SET revision_id = {}
""".format(self.rev_id))
def setUp(self):
super(TestOneTimeWorkflowNotification, self).setUp()
self.api = Api()
self.wf_generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.random_objects = self.object_generator.generate_random_objects()
self.random_people = [
self.object_generator.generate_person(user_role="Administrator")[1]
for _ in range(5)
]
self.create_test_cases()
self.create_users()
db.session.query(Notification).delete()
def init_decorator(init):
def new_init(self, *args, **kwargs):
init(self, *args, **kwargs)
if hasattr(self, "created_at"):
self.created_at = datetime.now()
return new_init
Notification.__init__ = init_decorator(Notification.__init__)
def setUp(self):
super(WorkflowTestCase, self).setUp()
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.random_objects = self.object_generator.generate_random_objects()
def setUp(self):
super(TestWorkflowCycleStatePropagation, self).setUp()
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.weekly_wf = {
"title":
"weekly thingy",
"description":
"start this many a time",
"unit":
"week",
"repeat_every":
1,
"task_groups": [
{
"title":
"weekly task group",
"task_group_tasks": [{
"title": "weekly task 1",
"start_date": dtm.date(2016, 6, 10),
"end_date": dtm.date(2016, 6, 13),
}, {
"title": "weekly task 1",
"start_date": dtm.date(2016, 6, 10),
"end_date": dtm.date(2016, 6, 13),
}]
},
]
}
def setUp(self):
super(TestWorkflowCycleStatePropagantion, self).setUp()
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.weekly_wf = {
"title":
"weekly thingy",
"description":
"start this many a time",
"frequency":
"weekly",
"task_groups": [
{
"title":
"weekly task group",
"task_group_tasks": [{
"title": "weekly task 1",
"relative_end_day": 1,
"relative_end_month": None,
"relative_start_day": 5,
"relative_start_month": None,
}, {
"title": "weekly task 1",
"relative_end_day": 1,
"relative_end_month": None,
"relative_start_day": 1,
"relative_start_month": None,
}]
},
]
}
def setUp(self): # noqa
super(TestBacklogWorkflow, self).setUp()
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.random_objects = self.object_generator.generate_random_objects()
self.create_backlog_workflow()
def setUp(self):
TestCase.setUp(self)
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.random_objects = self.object_generator.generate_random_objects()
self.create_test_cases()
def setUp(self): # noqa
TestCase.setUp(self)
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.random_objects = self.object_generator.generate_random_objects()
self.create_backlog_workflow()
def setUp(self):
# old-style class
TestCase.setUp(self)
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.random_objects = self.object_generator.generate_random_objects()
def setUp(self):
super(TestBasicWorkflowActions, self).setUp()
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
self.random_objects = self.object_generator.generate_random_objects()
self.create_test_cases()
def setUp(self):
super(TestCreatorAudit, self).setUp()
self.generator = Generator()
self.api = Api()
self.object_generator = ObjectGenerator()
self.init_users()
self.init_test_cases()
self.objects = {}
def setUp(self):
super(TestReader, self).setUp()
self.audit_id = factories.AuditFactory().id
self.generator = Generator()
self.api = Api()
self.object_generator = ObjectGenerator()
self.init_users()
self.init_assignable()
def setUp(self):
super(TestRevisionHistory, self).setUp()
self.api = Api()
roles = {r.name: r for r in all_models.Role.query.all()}
ac_roles = {
r.name: r
for r in all_models.AccessControlRole.query.all()
}
with factories.single_commit():
self.control = factories.ControlFactory()
acrs = {
"ACL_Reader":
factories.AccessControlRoleFactory(name="ACL_Reader",
object_type="Control",
update=0),
"ACL_Editor":
factories.AccessControlRoleFactory(name="ACL_Editor",
object_type="Control"),
}
self.program = factories.ProgramFactory()
self.program.context.related_object = self.program
self.relationship = factories.RelationshipFactory(
source=self.program,
destination=self.control,
context=self.program.context,
)
self.people = {
"Creator": factories.PersonFactory(),
"Reader": factories.PersonFactory(),
"Editor": factories.PersonFactory(),
"Administrator": factories.PersonFactory(),
"ACL_Reader": factories.PersonFactory(),
"ACL_Editor": factories.PersonFactory(),
"Program Editors": factories.PersonFactory(),
"Program Managers": factories.PersonFactory(),
"Program Readers": factories.PersonFactory(),
}
for role_name in ["Creator", "Reader", "Editor", "Administrator"]:
rbac_factories.UserRoleFactory(role=roles[role_name],
person=self.people[role_name])
for role_name in [
"Program Editors", "Program Managers", "Program Readers"
]:
person = self.people[role_name]
rbac_factories.UserRoleFactory(role=roles["Creator"],
person=person)
factories.AccessControlListFactory(
ac_role=ac_roles[role_name],
object=self.program,
person=self.people[role_name])
with factories.single_commit():
for role_name in ["ACL_Reader", "ACL_Editor"]:
rbac_factories.UserRoleFactory(role=roles["Creator"],
person=self.people[role_name])
factories.AccessControlListFactory(
ac_role=acrs[role_name],
object=self.control,
person=self.people[role_name])
def setUp(self):
TestCase.setUp(self)
self.generator = Generator()
self.api = Api()
self.object_generator = ObjectGenerator()
self.init_users()
self.init_roles()
self.init_test_cases()
self.objects = {}
def setUp(self):
super(TestAccessControlRole, self).setUp()
self.api = Api()
self.object_generator = ObjectGenerator()
self.people = {}
for name in ["Creator", "Reader", "Editor"]:
_, user = self.object_generator.generate_person(
data={"name": name}, user_role=name)
self.people[name] = user
def setUp(self):
super(TestPermissionsLoading, self).setUp()
self.api = Api()
self.generator = generator.ObjectGenerator()
self.control_id = factories.ControlFactory().id
_, user = self.generator.generate_person(user_role="Creator")
self.api.set_user(user)
def setUp(self):
super(TestRecurringCycleNotifications, self).setUp()
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
_, self.assignee = self.object_generator.generate_person(
user_role="Administrator")
self.create_test_cases()
def setUp(self):
TestCase.setUp(self)
self.api = Api()
self.generator = WorkflowsGenerator()
self.object_generator = ObjectGenerator()
_, self.assignee = self.object_generator.generate_person(
user_role="Administrator")
self.create_test_cases()
def setUp(self):
super(TestAssigneeRBAC, self).setUp()
self.api = Api()
self.set_up_people()
self.assignee_roles = {
role_name: role_id
for role_id, role_name in get_custom_roles_for(
"Assessment").items()
if role_name in ["Assignees", "Creators", "Verifiers"]
}
def setUp(self):
super(TestPermissionsLoading, self).setUp()
self.api = Api()
self.generator = generator.ObjectGenerator()
_, self.user = self.generator.generate_person(user_role="Creator")
_, self.user1 = self.generator.generate_person(user_role="Creator")
self.api.set_user(self.user)
self.user_id = self.user.id
self.user1_id = self.user1.id
def send_import_request(data, dry_run=False, person=None):
"""Sending import post request."""
headers = {
"X-test-only": "true" if dry_run else "false",
"X-requested-by": "GGRC",
}
api = Api()
api.set_user(person) # Ok if person is None
response = api.client.post("/_service/import_csv",
data=data, headers=headers)
return json.loads(response.data)
def setUp(self):
super(TestStatusApiPost, self).setUp()
self.api = Api()
with factories.single_commit():
self.workflow = wf_factories.WorkflowFactory()
self.cycle = wf_factories.CycleFactory(workflow=self.workflow)
self.group = wf_factories.CycleTaskGroupFactory(
cycle=self.cycle, context=self.cycle.workflow.context)
self.task = wf_factories.CycleTaskFactory(
cycle=self.cycle,
cycle_task_group=self.group,
context=self.cycle.workflow.context)
def setUp(self):
super(TestAccessControlList, self).setUp()
self.api = Api()
self.person = factories.PersonFactory(name="My Person")
self.control = factories.ControlFactory()
self.acr = factories.AccessControlRoleFactory(object_type="Control",
read=True)
self.second_acr = factories.AccessControlRoleFactory(
object_type="Control", read=True)
self.acl = factories.AccessControlListFactory(object=self.control,
ac_role_id=self.acr.id,
person=self.person)
def setUp(self):
super(TestFilterByAuditor, self).setUp()
self.api = Api()
self.generator = ObjectGenerator()
_, self.auditor = self.generator.generate_person(user_role="Creator")
with factories.single_commit():
self.audit = factories.AuditFactory(status="In Progress")
self.audit_id = self.audit.id
audit_context = factories.ContextFactory()
self.audit.context = audit_context
self.audit.add_person_with_role_name(self.auditor, "Auditors")
self.api.set_user(self.auditor)
