def test_shouldTransitToNextStateWhenAllTheApprovalsAreApproved(self):
manager_permission = PermissionObjectFactory()
team_leader_permission = PermissionObjectFactory()
manager = UserObjectFactory(user_permissions=[manager_permission])
team_leader = UserObjectFactory(
user_permissions=[team_leader_permission])
state1 = RawState("state1")
state2 = RawState("state2")
authorization_policies = [
AuthorizationPolicyBuilder().with_priority(0).with_permission(
team_leader_permission).build(),
AuthorizationPolicyBuilder().with_priority(1).with_permission(
manager_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.build()
workflow_object = flow.objects[0]
assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
workflow_object.river.my_field.approve(team_leader)
assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
workflow_object.river.my_field.approve(manager)
assert_that(workflow_object.my_field, equal_to(flow.get_state(state2)))
def initialize_circular_scenario(self):
StateObjectFactory.reset_sequence(0)
TransitionApprovalMetaFactory.reset_sequence(0)
content_type = ContentType.objects.get_for_model(TestModel)
permissions = PermissionObjectFactory.create_batch(4)
self.user1 = UserObjectFactory(user_permissions=[permissions[0]])
self.user2 = UserObjectFactory(user_permissions=[permissions[1]])
self.user3 = UserObjectFactory(user_permissions=[permissions[2]])
self.user4 = UserObjectFactory(user_permissions=[permissions[3]])
self.open_state = StateObjectFactory(label='open')
self.in_progress_state = StateObjectFactory(label='in-progress')
self.resolved_state = StateObjectFactory(label='resolved')
self.re_opened_state = StateObjectFactory(label='re-opened')
self.closed_state = StateObjectFactory(label='closed')
t1 = TransitionApprovalMetaFactory.create(
field_name="my_field",
content_type=content_type,
source_state=self.open_state,
destination_state=self.in_progress_state,
)
t1.permissions.add(permissions[0])
t2 = TransitionApprovalMetaFactory.create(
field_name="my_field",
content_type=content_type,
source_state=self.in_progress_state,
destination_state=self.resolved_state,
)
t2.permissions.add(permissions[1])
t3 = TransitionApprovalMetaFactory.create(
field_name="my_field",
content_type=content_type,
source_state=self.resolved_state,
destination_state=self.re_opened_state,
)
t3.permissions.add(permissions[2])
t4 = TransitionApprovalMetaFactory.create(
field_name="my_field",
content_type=content_type,
source_state=self.resolved_state,
destination_state=self.closed_state,
)
t4.permissions.add(permissions[3])
t5 = TransitionApprovalMetaFactory.create(
field_name="my_field",
content_type=content_type,
source_state=self.re_opened_state,
destination_state=self.in_progress_state,
)
t5.permissions.add(permissions[0])
def initialize_circular_scenario(self):
from river.models.factories import \
TransitionObjectFactory, \
UserObjectFactory, \
PermissionObjectFactory, \
ProceedingMetaObjectFactory, \
StateObjectFactory
TransitionObjectFactory.reset_sequence(0)
ProceedingMetaObjectFactory.reset_sequence(0)
StateObjectFactory.reset_sequence(0)
TestModel.objects.all().delete()
self.content_type = ContentType.objects.get_for_model(TestModel)
self.permissions = PermissionObjectFactory.create_batch(4)
self.user1 = UserObjectFactory(user_permissions=[self.permissions[0]])
self.user2 = UserObjectFactory(user_permissions=[self.permissions[1]])
self.user3 = UserObjectFactory(user_permissions=[self.permissions[2]])
self.user4 = UserObjectFactory(user_permissions=[self.permissions[3]])
self.field = 'my_field'
self.open_state = StateObjectFactory(label='open')
self.in_progress_state = StateObjectFactory(label='in-progress')
self.resolved_state = StateObjectFactory(label='resolved')
self.re_opened_state = StateObjectFactory(label='re-opened')
self.closed_state = StateObjectFactory(label='closed')
self.transitions = [
TransitionObjectFactory(source_state=self.open_state,
destination_state=self.in_progress_state),
TransitionObjectFactory(source_state=self.in_progress_state,
destination_state=self.resolved_state),
TransitionObjectFactory(source_state=self.resolved_state,
destination_state=self.re_opened_state),
TransitionObjectFactory(source_state=self.resolved_state,
destination_state=self.closed_state),
TransitionObjectFactory(source_state=self.re_opened_state,
destination_state=self.in_progress_state)
]
self.proceeding_metas = ProceedingMetaObjectFactory.create_batch(
5,
content_type=self.content_type,
field=self.field,
transition=factory.Sequence(lambda n: self.transitions[n]),
order=0)
for n, proceeding_meta in enumerate(self.proceeding_metas):
proceeding_meta.permissions.add(self.permissions[n] if n < len(
self.permissions) else self.permissions[0])
self.objects = TestModelObjectFactory.create_batch(2)
def test_shouldReturnAnApprovalWhenUserIsAuthorizedWithAUserGroup(self):
authorized_user_group = GroupObjectFactory()
authorized_user = UserObjectFactory(groups=[authorized_user_group])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
authorization_policies = [
AuthorizationPolicyBuilder().with_group(
authorized_user_group).build()
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.build()
workflow_object = flow.objects[0]
available_approvals = BasicTestModel.river.my_field.get_available_approvals(
as_user=authorized_user)
assert_that(available_approvals, has_length(1))
assert_that(
list(available_approvals),
has_item(
all_of(
has_property("workflow_object", workflow_object),
has_property("workflow", flow.workflow),
has_property(
"transition",
flow.transitions_metas[0].transitions.first()))))
def test_shouldNotLetUserWhosePriorityComesLaterApproveProceed(self):
manager_permission = PermissionObjectFactory()
team_leader_permission = PermissionObjectFactory()
manager = UserObjectFactory(user_permissions=[manager_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
workflow = WorkflowFactory(initial_state=state1, content_type=self.content_type, field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=1,
permissions=[manager_permission]
)
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[team_leader_permission]
)
workflow_object = BasicTestModelObjectFactory()
assert_that(
calling(workflow_object.model.river.my_field.approve).with_args(as_user=manager),
raises(RiverException, "There is no available approval for the user")
)
def test_shouldTransitToTheGivenNextStateWhenThereAreMultipleNextStates(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(user_permissions=[authorized_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
state3 = StateObjectFactory(label="state3")
workflow = WorkflowFactory(initial_state=state1, content_type=self.content_type, field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[authorized_permission]
)
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state3,
priority=0,
permissions=[authorized_permission]
)
workflow_object = BasicTestModelObjectFactory()
assert_that(workflow_object.model.my_field, equal_to(state1))
workflow_object.model.river.my_field.approve(as_user=authorized_user, next_state=state3)
assert_that(workflow_object.model.my_field, equal_to(state3))
def test_shouldDictatePassingNextStateWhenThereAreMultiple(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(user_permissions=[authorized_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
state3 = StateObjectFactory(label="state3")
workflow = WorkflowFactory(initial_state=state1, content_type=self.content_type, field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[authorized_permission]
)
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state3,
priority=0,
permissions=[authorized_permission]
)
workflow_object = BasicTestModelObjectFactory()
assert_that(
calling(workflow_object.model.river.my_field.approve).with_args(as_user=authorized_user),
raises(RiverException, "State must be given when there are multiple states for destination")
)
def test_shouldNotReturnOtherObjectsApprovalsForTheAuthorizedUser(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(user_permissions=[authorized_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
workflow = WorkflowFactory(initial_state=state1, content_type=self.content_type, field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[authorized_permission]
)
workflow_object1 = BasicTestModelObjectFactory()
workflow_object2 = BasicTestModelObjectFactory()
available_approvals = workflow_object1.model.river.my_field.get_available_approvals(as_user=authorized_user)
assert_that(available_approvals, has_length(1))
assert_that(list(available_approvals), has_item(
has_property("workflow_object", workflow_object1.model)
))
assert_that(list(available_approvals), has_item(
is_not(has_property("workflow_object", workflow_object2.model))
))
def test_shouldNotCrashWhenAModelObjectWithStringPrimaryKeyIsApproved(
self):
content_type = ContentType.objects.get_for_model(
ModelWithStringPrimaryKey)
authorized_permission = PermissionObjectFactory(
content_type=content_type)
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state1")
state2 = RawState("state2")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("status", content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_object_factory(lambda: ModelWithStringPrimaryKey.objects.create()) \
.build()
workflow_object = flow.objects[0]
assert_that(workflow_object.status, equal_to(flow.get_state(state1)))
workflow_object.river.status.approve(as_user=authorized_user)
assert_that(workflow_object.status, equal_to(flow.get_state(state2)))
def test_shouldInvokeTheRegisteredViaClassApiCallBackWhenATransitionHappens(
self):
self.test_args = None
self.test_kwargs = None
def test_callback(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
content_type = ContentType.objects.get_for_model(BasicTestModel)
workflow = WorkflowFactory(initial_state=state1,
content_type=content_type,
field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[authorized_permission])
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=1,
permissions=[authorized_permission])
workflow_object = BasicTestModelObjectFactory()
BasicTestModel.river.my_field.hook_post_transition(test_callback)
assert_that(self.test_args, none())
assert_that(workflow_object.model.my_field, equal_to(state1))
workflow_object.model.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.model.my_field, equal_to(state1))
assert_that(self.test_args, none())
workflow_object.model.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.model.my_field, equal_to(state2))
assert_that(self.test_args,
equal_to((workflow_object.model, "my_field")))
last_approval = TransitionApproval.objects.get(
object_id=workflow_object.model.pk,
source_state=state1,
destination_state=state2,
priority=1)
assert_that(
self.test_kwargs,
has_entry(equal_to("transition_approval"),
equal_to(last_approval)))
def test_get_proceedings_object_waiting_for_approval_slow_test_from_fixture(self):
call_command('loaddata', 'river/fixtures/slow-case.json', verbosity=0)
user1 = UserObjectFactory(groups=[Group.objects.get(pk=3)])
objects1 = []
for i in range(66703, 66723):
objects1.append(TestModelSlowCase1.objects.create(pk=i))
objects2 = []
for i in range(8, 13):
objects2.append(TestModelSlowCase2.objects.create(pk=i))
for o in objects1:
before = datetime.now()
ProceedingService.get_available_proceedings(o, [o.status], user1)
after = datetime.now()
self.assertLess(after - before, timedelta(seconds=0.5))
for o in objects2:
before = datetime.now()
ProceedingService.get_available_proceedings(o, [o.status], user1)
after = datetime.now()
self.assertLess(after - before, timedelta(seconds=0.5))
def test_shouldTransitToTheGivenNextStateWhenThereAreMultipleNextStates(
self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state1")
state2 = RawState("state2")
state3 = RawState("state3")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_transition(state1, state3, authorization_policies) \
.build()
workflow_object = flow.objects[0]
assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
workflow_object.river.my_field.approve(
as_user=authorized_user, next_state=flow.get_state(state3))
assert_that(workflow_object.my_field, equal_to(flow.get_state(state3)))
def test_shouldReturnNoApprovalWhenUserIsUnAuthorized(self):
unauthorized_user = UserObjectFactory()
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
workflow = WorkflowFactory(initial_state=state1,
content_type=self.content_type,
field_name="my_field")
authorized_permission = PermissionObjectFactory()
transition_meta = TransitionMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
)
TransitionApprovalMetaFactory.create(
workflow=workflow,
transition_meta=transition_meta,
priority=0,
permissions=[authorized_permission])
BasicTestModelObjectFactory(workflow=workflow)
available_approvals = BasicTestModel.river.my_field.get_available_approvals(
as_user=unauthorized_user)
assert_that(available_approvals, has_length(0))
def test_shouldReturnAnApprovalWhenUserIsAuthorizedWithAUserGroup(self):
authorized_user_group = GroupObjectFactory()
authorized_user = UserObjectFactory(groups=[authorized_user_group])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
workflow = WorkflowFactory(initial_state=state1,
content_type=self.content_type,
field_name="my_field")
transition_meta = TransitionMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
)
approval_meta = TransitionApprovalMetaFactory.create(
workflow=workflow, transition_meta=transition_meta, priority=0)
approval_meta.groups.add(authorized_user_group)
workflow_object = BasicTestModelObjectFactory(workflow=workflow)
available_approvals = BasicTestModel.river.my_field.get_available_approvals(
as_user=authorized_user)
assert_that(available_approvals, has_length(1))
assert_that(
list(available_approvals),
has_item(
all_of(
has_property("workflow_object", workflow_object.model),
has_property("workflow", workflow),
has_property("transition",
transition_meta.transitions.first()))))
def test_shouldDictatePassingNextStateWhenThereAreMultiple(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state1")
state2 = RawState("state2")
state3 = RawState("state3")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_transition(state1, state3, authorization_policies) \
.build()
workflow_object = flow.objects[0]
assert_that(
calling(workflow_object.river.my_field.approve).with_args(
as_user=authorized_user),
raises(
RiverException,
"State must be given when there are multiple states for destination"
))
def test__shouldReturnApprovalsOnTimeWhenTooManyWorkflowObject(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
workflow = WorkflowFactory(initial_state=state1,
content_type=self.content_type,
field_name="my_field")
transition_meta = TransitionMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
)
TransitionApprovalMetaFactory.create(
workflow=workflow,
transition_meta=transition_meta,
priority=0,
permissions=[authorized_permission])
self.objects = BasicTestModelObjectFactory.create_batch(
250, workflow=workflow)
before = datetime.now()
BasicTestModel.river.my_field.get_on_approval_objects(
as_user=authorized_user)
after = datetime.now()
assert_that(after - before, less_than(timedelta(milliseconds=200)))
print("Time taken %s" % str(after - before))
def test_shouldNotJumpBackToAPreviousState(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state1")
state2 = RawState("state2")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.build()
workflow_object = flow.objects[0]
workflow_object.river.my_field.approve(
as_user=authorized_user, next_state=flow.get_state(state2))
assert_that(
calling(workflow_object.river.my_field.jump_to).with_args(
flow.get_state(state1)),
raises(
RiverException,
"This state is not available to be jumped in the future of this object"
))
def test_shouldNotCancelDescendantsThatCanBeTransitedInTheFuture(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state_1")
state2 = RawState("state_2")
state3 = RawState("state_3")
final_state = RawState("final_state")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_transition(state1, state3, authorization_policies) \
.with_transition(state2, state3, authorization_policies) \
.with_transition(state3, final_state, authorization_policies) \
.build()
workflow_object = flow.objects[0]
assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
workflow_object.river.my_field.approve(
as_user=authorized_user, next_state=flow.get_state(state2))
assert_that(workflow_object.my_field, equal_to(flow.get_state(state2)))
approvals = TransitionApproval.objects.filter(
workflow=flow.workflow, workflow_object=workflow_object)
assert_that(approvals, has_approval(state3, final_state, PENDING))
def test_shouldNotAcceptANextStateWhichIsNotAmongPossibleNextStates(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state1")
state2 = RawState("state2")
state3 = RawState("state3")
invalid_state = RawState("state4")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_transition(state1, state3, authorization_policies) \
.with_additional_state(invalid_state) \
.build()
workflow_object = flow.objects[0]
assert_that(
calling(workflow_object.river.my_field.approve).with_args(
as_user=authorized_user,
next_state=flow.get_state(invalid_state)),
raises(
RiverException,
"Invalid state is given\(%s\). Valid states is\(are\) (%s|%s)"
% (invalid_state.label, ",".join([state2.label, state3.label]),
",".join([state3.label, state2.label]))))
def test_shouldNotLetUserWhosePriorityComesLaterApproveProceed(self):
manager_permission = PermissionObjectFactory()
team_leader_permission = PermissionObjectFactory()
manager = UserObjectFactory(user_permissions=[manager_permission])
state1 = RawState("state1")
state2 = RawState("state2")
authorization_policies = [
AuthorizationPolicyBuilder().with_priority(0).with_permission(
team_leader_permission).build(),
AuthorizationPolicyBuilder().with_priority(1).with_permission(
manager_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.build()
workflow_object = flow.objects[0]
assert_that(
calling(workflow_object.river.my_field.approve).with_args(
as_user=manager),
raises(RiverException,
"There is no available approval for the user"))
def test_shouldNotTransitToNextStateWhenThereAreMultipleApprovalsToBeApproved(self):
manager_permission = PermissionObjectFactory()
team_leader_permission = PermissionObjectFactory()
team_leader = UserObjectFactory(user_permissions=[team_leader_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
workflow = WorkflowFactory(initial_state=state1, content_type=self.content_type, field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=1,
permissions=[manager_permission]
)
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[team_leader_permission]
)
workflow_object = BasicTestModelObjectFactory()
assert_that(workflow_object.model.my_field, equal_to(state1))
workflow_object.model.river.my_field.approve(team_leader)
assert_that(workflow_object.model.my_field, equal_to(state1))
def test_shouldNotReturnOtherObjectsApprovalsForTheAuthorizedUser(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state1")
state2 = RawState("state2")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build()
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_objects(2) \
.build()
workflow_object1 = flow.objects[0]
workflow_object2 = flow.objects[1]
available_approvals = workflow_object1.river.my_field.get_available_approvals(
as_user=authorized_user)
assert_that(available_approvals, has_length(1))
assert_that(
list(available_approvals),
has_item(has_property("workflow_object", workflow_object1)))
assert_that(
list(available_approvals),
has_item(is_not(has_property("workflow_object",
workflow_object2))))
def test_shouldReturnAnApprovalWhenUserIsAuthorizedWithAPermission(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
workflow = WorkflowFactory(initial_state=state1,
content_type=self.content_type,
field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[authorized_permission])
workflow_object = BasicTestModelObjectFactory()
available_approvals = BasicTestModel.river.my_field.get_available_approvals(
as_user=authorized_user)
assert_that(available_approvals, has_length(1))
assert_that(
list(available_approvals),
has_item(
all_of(has_property("workflow_object", workflow_object.model),
has_property("workflow", workflow),
has_property("source_state", state1),
has_property("destination_state", state2))))
def setUp(self):
from river.models.factories import \
TransitionObjectFactory, \
UserObjectFactory, \
PermissionObjectFactory, \
ApprovementMetaObjectFactory, \
StateObjectFactory
TransitionObjectFactory.reset_sequence(0)
ApprovementMetaObjectFactory.reset_sequence(0)
StateObjectFactory.reset_sequence(0)
TestModel.objects.all().delete()
self.content_type = ContentType.objects.get_for_model(TestModel)
self.permissions = PermissionObjectFactory.create_batch(4)
self.user1 = UserObjectFactory(user_permissions=[self.permissions[0]])
self.user2 = UserObjectFactory(user_permissions=[self.permissions[1]])
self.user3 = UserObjectFactory(user_permissions=[self.permissions[2]])
self.user4 = UserObjectFactory(user_permissions=[self.permissions[3]])
self.field = 'my_field'
self.states = StateObjectFactory.create_batch(
9,
label=factory.Sequence(lambda n: "s%s" % str(n + 1) if n <= 4 else
("s4.%s" % str(n - 4)
if n <= 6 else "s5.%s" % str(n - 6))))
self.transitions = TransitionObjectFactory.create_batch(
8,
content_type=self.content_type,
field=self.field,
source_state=factory.Sequence(lambda n: self.states[
n] if n <= 2 else (self.states[n - 1]) if n <= 4 else (
self.states[n - 2] if n <= 6 else self.states[4])),
destination_state=factory.Sequence(lambda n: self.states[n + 1]))
self.approvement_metas = ApprovementMetaObjectFactory.create_batch(
9,
transition=factory.Sequence(lambda n: self.transitions[n] if n <= 1
else self.transitions[n - 1]),
order=factory.Sequence(lambda n: 1 if n == 2 else 0))
for n, approvement_meta in enumerate(self.approvement_metas):
approvement_meta.permissions.add(
self.permissions[n] if n <= 3 else self.permissions[3])
self.objects = TestModelObjectFactory.create_batch(2)
def test_shouldInvokeCallbackThatIsRegisteredWithInstanceWhenTransitionHappens(
self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
content_type = ContentType.objects.get_for_model(BasicTestModel)
state1 = RawState("state1")
state2 = RawState("state2")
state3 = RawState("state3")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_transition(state2, state3, authorization_policies) \
.build()
workflow_object = flow.objects[0]
self.hook_post_transition(flow.workflow,
flow.transitions_metas[1],
workflow_object=workflow_object)
assert_that(self.get_output(), none())
assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
workflow_object.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.my_field, equal_to(flow.get_state(state2)))
assert_that(self.get_output(), none())
workflow_object.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.my_field, equal_to(flow.get_state(state3)))
last_approval = TransitionApproval.objects.get(
object_id=workflow_object.pk,
transition__source_state=flow.get_state(state2),
transition__destination_state=flow.get_state(state3))
output = self.get_output()
assert_that(output, has_length(1))
assert_that(output[0], has_key("hook"))
assert_that(output[0]["hook"], has_entry("type", "on-transit"))
assert_that(output[0]["hook"], has_entry("when", AFTER))
assert_that(
output[0]["hook"],
has_entry(
"payload",
all_of(
has_entry(equal_to("workflow_object"),
equal_to(workflow_object)),
has_entry(equal_to("transition_approval"),
equal_to(last_approval)))))
def test_shouldInvokeTheRegisteredViaInstanceApiCallBackWhenFlowIsCompleteForTheObject(
self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = StateObjectFactory(label="state1")
state2 = StateObjectFactory(label="state2")
state3 = StateObjectFactory(label="state3")
content_type = ContentType.objects.get_for_model(BasicTestModel)
workflow = WorkflowFactory(initial_state=state1,
content_type=content_type,
field_name="my_field")
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state1,
destination_state=state2,
priority=0,
permissions=[authorized_permission])
TransitionApprovalMetaFactory.create(
workflow=workflow,
source_state=state2,
destination_state=state3,
priority=0,
permissions=[authorized_permission])
workflow_object = BasicTestModelObjectFactory()
self.test_args = None
self.test_kwargs = None
def test_callback(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
workflow_object.model.river.my_field.hook_post_complete(test_callback)
assert_that(self.test_args, none())
assert_that(workflow_object.model.my_field, equal_to(state1))
workflow_object.model.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.model.my_field, equal_to(state2))
assert_that(self.test_args, none())
workflow_object.model.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.model.my_field, equal_to(state3))
assert_that(self.test_args,
equal_to((workflow_object.model, "my_field")))
def test_shouldInvokeCallbackForTheOnlyGivenTransition(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
content_type = ContentType.objects.get_for_model(BasicTestModel)
state1 = RawState("state1")
state2 = RawState("state2")
state3 = RawState("state3")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_transition(state2, state3, authorization_policies) \
.with_transition(state3, state1, authorization_policies) \
.build()
workflow_object = flow.objects[0]
workflow_object.river.my_field.approve(as_user=authorized_user)
workflow_object.river.my_field.approve(as_user=authorized_user)
workflow_object.river.my_field.approve(as_user=authorized_user)
assert_that(
TransitionApproval.objects.filter(
meta=flow.transitions_approval_metas[0]), has_length(2))
first_approval = TransitionApproval.objects.filter(
meta=flow.transitions_approval_metas[0],
transition__iteration=0).first()
assert_that(first_approval, is_not(none()))
self.hook_pre_transition(
flow.workflow,
flow.transitions_metas[0],
transition=flow.transitions_metas[0].transitions.first())
output = self.get_output()
assert_that(output, none())
workflow_object.river.my_field.approve(as_user=authorized_user)
output = self.get_output()
assert_that(output, none())
def test_shouldAllowMultipleCyclicTransitions(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
initial_state = RawState("initial_state")
cycle_state_1 = RawState("cycle_state_1")
cycle_state_2 = RawState("cycle_state_2")
off_the_cycle_state = RawState("off_the_cycle_state")
cycle_state_3 = RawState("cycle_state_3")
cycle_state_4 = RawState("cycle_state_4")
final_state = RawState("final_state")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(initial_state, cycle_state_1, authorization_policies) \
.with_transition(cycle_state_1, cycle_state_2, authorization_policies) \
.with_transition(cycle_state_2, cycle_state_1, authorization_policies) \
.with_transition(cycle_state_1, off_the_cycle_state, authorization_policies) \
.with_transition(off_the_cycle_state, cycle_state_3, authorization_policies) \
.with_transition(cycle_state_3, cycle_state_4, authorization_policies) \
.with_transition(cycle_state_4, cycle_state_3, authorization_policies) \
.with_transition(cycle_state_3, final_state, authorization_policies) \
.build()
workflow_object = flow.objects[0]
assert_that(workflow_object.my_field,
equal_to(flow.get_state(initial_state)))
workflow_object.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.my_field,
equal_to(flow.get_state(cycle_state_1)))
workflow_object.river.my_field.approve(
as_user=authorized_user, next_state=flow.get_state(cycle_state_2))
assert_that(workflow_object.my_field,
equal_to(flow.get_state(cycle_state_2)))
workflow_object.river.my_field.approve(as_user=authorized_user)
assert_that(workflow_object.my_field,
equal_to(flow.get_state(cycle_state_1)))
def test_shouldCancelAllOtherStateTransitionDescendants(self):
authorized_permission = PermissionObjectFactory()
authorized_user = UserObjectFactory(
user_permissions=[authorized_permission])
state1 = RawState("state1")
state2 = RawState("state2")
state3 = RawState("state3")
state4 = RawState("state4")
state5 = RawState("state5")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build(),
]
flow = FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.with_transition(state1, state3, authorization_policies) \
.with_transition(state1, state4, authorization_policies) \
.with_transition(state4, state5, authorization_policies) \
.build()
workflow_object = flow.objects[0]
assert_that(workflow_object.my_field, equal_to(flow.get_state(state1)))
workflow_object.river.my_field.approve(
as_user=authorized_user, next_state=flow.get_state(state3))
assert_that(workflow_object.my_field, equal_to(flow.get_state(state3)))
assert_that(
flow.transitions_approval_metas[0].transition_approvals.all(),
all_of(has_length(1), has_item(has_property("status", CANCELLED))))
assert_that(
flow.transitions_approval_metas[1].transition_approvals.all(),
all_of(has_length(1), has_item(has_property("status", APPROVED))))
assert_that(
flow.transitions_approval_metas[2].transition_approvals.all(),
all_of(has_length(1), has_item(has_property("status", CANCELLED))))
assert_that(
flow.transitions_approval_metas[3].transition_approvals.all(),
all_of(has_length(1), has_item(has_property("status", CANCELLED))))
def test_shouldReturnNoApprovalWhenUserIsUnAuthorized(self):
unauthorized_user = UserObjectFactory()
authorized_permission = PermissionObjectFactory()
state1 = RawState("state1")
state2 = RawState("state2")
authorization_policies = [
AuthorizationPolicyBuilder().with_permission(
authorized_permission).build()
]
FlowBuilder("my_field", self.content_type) \
.with_transition(state1, state2, authorization_policies) \
.build()
available_approvals = BasicTestModel.river.my_field.get_available_approvals(
as_user=unauthorized_user)
assert_that(available_approvals, has_length(0))
