def test_register_for_an_object(self):
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostCompletedHandler.register(test_handler, self.objects[0],
'my_field')
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field,
self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
# Approved but no transition
TransitionService.approve_transition(self.objects[0], self.field,
self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field,
self.user3)
self.assertEqual((self.objects[0], 'my_field'), self.test_args)
def test_register_for_all(self):
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostCompletedHandler.register(test_handler)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
# Proceeded but no transition
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.assertEqual((), self.test_args)
self.assertDictEqual({
'field': 'my_field',
'object': self.objects[0]
}, self.test_kwargs)
def test_get_next_proceedings(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
proceedings = ProceedingService.get_next_proceedings(self.objects[0], self.field)
self.assertEqual(9, proceedings.count())
self.objects[0].proceed(self.user1)
proceedings = ProceedingService.get_next_proceedings(self.objects[0], self.field)
self.assertEqual(8, proceedings.count())
self.objects[0].proceed(self.user2)
# Two proceedings exist on same level
proceedings = ProceedingService.get_next_proceedings(self.objects[0], self.field)
self.assertEqual(7, proceedings.count())
self.objects[0].proceed(self.user3)
proceedings = ProceedingService.get_next_proceedings(self.objects[0], self.field)
self.assertEqual(6, proceedings.count())
self.objects[0].proceed(self.user4, next_state=State.objects.get(label='s4'))
proceedings = ProceedingService.get_next_proceedings(self.objects[0], self.field)
self.assertEqual(2, proceedings.count())
self.objects[0].proceed(self.user4, next_state=State.objects.get(label='s4.1'))
proceedings = ProceedingService.get_next_proceedings(self.objects[0], self.field)
self.assertEqual(0, proceedings.count())
def test_get_available_states(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user2, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0],
self.field,
self.user2,
include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user2)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user3, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0],
self.field,
self.user3,
include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user3)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user4, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0],
self.field,
self.user4,
include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user4)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user1, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0],
self.field,
self.user1,
include_user=True)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(
self.objects[0], self.field, self.user1)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
def test_get_proceedings_object_waiting_for_approval_without_skip(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
proceedings = ProceedingService.get_available_proceedings(
self.objects[0],
self.field, [self.objects[0].my_field],
user=self.user1)
self.assertEqual(1, proceedings.count())
proceedings = ProceedingService.get_available_proceedings(
self.objects[0],
self.field, [self.objects[0].my_field],
user=self.user2)
self.assertEqual(0, proceedings.count())
proceedings = ProceedingService.get_available_proceedings(
self.objects[0],
self.field, [self.objects[0].my_field],
user=self.user3)
self.assertEqual(0, proceedings.count())
proceedings = ProceedingService.get_available_proceedings(
self.objects[0],
self.field, [self.objects[0].my_field],
user=self.user4)
self.assertEqual(0, proceedings.count())
def test_register_for_a_transition(self):
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostTransitionHandler.register(test_handler, self.objects[0], 'my_field', source_state=State.objects.get(label='s2'), destination_state=State.objects.get(label='s3'))
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field, self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field, self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field, self.user3)
self.assertEqual((self.objects[0], 'my_field'), self.test_args)
self.assertDictEqual(
{
'approvement': Approvement.objects.filter(meta__transition__source_state=State.objects.get(label='s2'), meta__transition__destination_state=State.objects.get(label='s3'))[2],
'source_state': State.objects.get(label='s2'),
'destination_state': State.objects.get(label='s3')
}, self.test_kwargs)
def test_register_for_all(self):
self.initialize_normal_scenario()
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0])
ObjectService.register_object(self.objects[1])
PostCompletedHandler.register(test_handler)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
# Proceeded but no transition
TransitionService.proceed(self.objects[0], self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.user3)
self.assertEqual((), self.test_args)
self.assertDictEqual({'object': self.objects[0]}, self.test_kwargs)
def setUp(self):
super(test_MemoryHandlerBackend, self).setUp()
app_config.HANDLER_BACKEND_CLASS = 'river.handlers.backends.memory.MemoryHandlerBackend'
self.handler_backend = load_handler_backend()
self.handler_backend.handlers = {}
ObjectService.register_object(self.objects[0], self.field)
def test_register_for_all(self):
self.initialize_normal_scenario()
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0])
ObjectService.register_object(self.objects[1])
PostCompletedHandler.register(test_handler)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
# Proceeded but no transition
TransitionService.proceed(self.objects[0], self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.user3)
self.assertEqual((), self.test_args)
self.assertDictEqual({"object": self.objects[0]}, self.test_kwargs)
def test_register_for_an_object(self):
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostCompletedHandler.register(test_handler, self.objects[0], 'my_field')
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
# Proceeded but no transition
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.assertEqual((self.objects[0], 'my_field'), self.test_args)
def test_get_next_approvements(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
approvements = ApprovementService.get_next_approvements(self.objects[0], self.field)
self.assertEqual(9, approvements.count())
self.objects[0].approve(self.user1)
approvements = ApprovementService.get_next_approvements(self.objects[0], self.field)
self.assertEqual(8, approvements.count())
self.objects[0].approve(self.user2)
# Two approvements exist on same level
approvements = ApprovementService.get_next_approvements(self.objects[0], self.field)
self.assertEqual(8, approvements.count())
self.objects[0].approve(self.user3)
approvements = ApprovementService.get_next_approvements(self.objects[0], self.field)
self.assertEqual(6, approvements.count())
self.objects[0].approve(self.user4, next_state=State.objects.get(label='s4'))
approvements = ApprovementService.get_next_approvements(self.objects[0], self.field)
self.assertEqual(2, approvements.count())
self.objects[0].approve(self.user4, next_state=State.objects.get(label='s4.1'))
approvements = ApprovementService.get_next_approvements(self.objects[0], self.field)
self.assertEqual(0, approvements.count())
def test_register_for_all(self):
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostCompletedHandler.register(test_handler)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field, self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
# Approved but no transition
TransitionService.approve_transition(self.objects[0], self.field, self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field, self.user3)
self.assertEqual((), self.test_args)
self.assertDictEqual(
{
'field': 'my_field',
'object': self.objects[0]
}, self.test_kwargs)
def setUp(self):
super(test_MemoryHandlerBackend, self).setUp()
app_config.HANDLER_BACKEND_CLASS = 'river.handlers.backends.memory.MemoryHandlerBackend'
self.handler_backend = load_handler_backend()
self.handler_backend.handlers = {}
ObjectService.register_object(self.objects[0], self.field)
def test_get_next_proceedings(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0])
ObjectService.register_object(self.objects[1])
proceedings = ProceedingService.get_next_proceedings(self.objects[0])
self.assertEqual(9, proceedings.count())
self.objects[0].proceed(self.user1)
proceedings = ProceedingService.get_next_proceedings(self.objects[0])
self.assertEqual(8, proceedings.count())
self.objects[0].proceed(self.user2)
# Two proceedings exist on same level
proceedings = ProceedingService.get_next_proceedings(self.objects[0])
self.assertEqual(7, proceedings.count())
self.objects[0].proceed(self.user3)
proceedings = ProceedingService.get_next_proceedings(self.objects[0])
self.assertEqual(6, proceedings.count())
self.objects[0].proceed(self.user4, next_state=State.objects.get(label='s4'))
proceedings = ProceedingService.get_next_proceedings(self.objects[0])
self.assertEqual(2, proceedings.count())
self.objects[0].proceed(self.user4, next_state=State.objects.get(label='s4.1'))
proceedings = ProceedingService.get_next_proceedings(self.objects[0])
self.assertEqual(0, proceedings.count())
def test_init(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
initial_state = StateService.get_initial_state(self.content_type, self.field)
self.assertEqual(initial_state, getattr(self.objects[0], self.field))
self.assertEqual(18, Approvement.objects.count())
def setUp(self):
super(test_DatabaseHandlerBackend, self).setUp()
self.initialize_normal_scenario()
app_config.HANDLER_BACKEND_CLASS = 'river.handlers.backends.database.DatabaseHandlerBackend'
self.handler_backend = load_handler_backend()
self.handler_backend.handlers = {}
ObjectService.register_object(self.objects[0])
def setUp(self):
super(test_DatabaseHandlerBackend, self).setUp()
RiverConfig.HANDLER_BACKEND_CLASS = 'river.handlers.backends.database.DatabaseHandlerBackend'
self.handler_backend = load_handler_backend()
self.handler_backend.handlers = {}
ObjectService.register_object(self.objects[0], self.field)
def setUp(self):
super(test_DatabaseHandlerBackend, self).setUp()
self.initialize_normal_scenario()
app_config.HANDLER_BACKEND_CLASS = 'river.handlers.backends.database.DatabaseHandlerBackend'
self.handler_backend = load_handler_backend()
self.handler_backend.handlers = {}
ObjectService.register_object(self.objects[0])
def test_get_field(self):
field = ObjectService.get_field(TestModel)
self.assertEqual('my_field', field.name)
try:
ObjectService.get_field(TestModelWithoutStateField)
self.assertFalse(True, "Trying getting field from a model does not contains state field should have thrown the error with code '8'")
except RiverException as re:
self.assertEqual(ErrorCode.NO_STATE_FIELD, re.code)
def test_init(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
initial_state = StateService.get_initial_state(self.content_type,
self.field)
self.assertEqual(initial_state, getattr(self.objects[0], self.field))
self.assertEqual(18, Approvement.objects.count())
def test_get_proceedings_object_waiting_for_approval_slow_test(self):
self.initialize_normal_scenario()
self.objects = TestModelObjectFactory.create_batch(100)
for o in self.objects:
ObjectService.register_object(o)
before = datetime.now()
for o in self.objects:
ProceedingService.get_available_proceedings(o, [o.my_field], user=self.user1)
after = datetime.now()
self.assertLess(after - before, timedelta(seconds=2))
def test_init(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0])
ObjectService.register_object(self.objects[1])
initial_state = StateService.get_initial_state(self.content_type)
self.assertEqual(initial_state, self.objects[0].get_state())
self.assertEqual(18, Proceeding.objects.count())
def test_init(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
initial_state = StateService.get_initial_state(self.content_type, self.field)
self.assertEqual(initial_state, getattr(self.objects[0], self.field))
self.assertEqual(18, Proceeding.objects.count())
def test_register_for_all(self):
self.initialize_normal_scenario()
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostTransitionHandler.register(test_handler)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.assertEqual((), self.test_args)
self.assertDictEqual(
{
'field': 'my_field',
'object': self.objects[0],
'proceeding': Proceeding.objects.filter(meta__transition__source_state=State.objects.get(label='s1'), meta__transition__destination_state=State.objects.get(label='s2'))[0],
'source_state': State.objects.get(label='s1'),
'destination_state': State.objects.get(label='s2')
}, self.test_kwargs)
# Proceeded but no transition
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.assertEqual((), self.test_args)
self.assertDictEqual(
{
'field': 'my_field',
'object': self.objects[0],
'proceeding': Proceeding.objects.filter(meta__transition__source_state=State.objects.get(label='s1'), meta__transition__destination_state=State.objects.get(label='s2'))[0],
'source_state': State.objects.get(label='s1'),
'destination_state': State.objects.get(label='s2')
}, self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.assertEqual((), self.test_args)
self.assertDictEqual(
{
'field': 'my_field',
'object': self.objects[0],
'proceeding': Proceeding.objects.filter(meta__transition__source_state=State.objects.get(label='s2'), meta__transition__destination_state=State.objects.get(label='s3'))[2],
'source_state': State.objects.get(label='s2'),
'destination_state': State.objects.get(label='s3')
}, self.test_kwargs)
def _post_save(sender, instance, created, *args, **kwargs): # signal, sender, instance):
"""
Desc: Generate TransitionApprovements according to TransitionApproverDefinition of the content type at the beginning.
:param kwargs:
:return:
"""
if created:
for f in instance._meta.fields:
if isinstance(f, StateField):
ObjectService.register_object(instance, f.name)
def test_register_for_all(self):
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostTransitionHandler.register(test_handler)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.assertEqual((), self.test_args)
self.assertDictEqual(
{
'field': 'my_field',
'object': self.objects[0],
'proceeding': Proceeding.objects.filter(meta__transition__source_state=State.objects.get(label='s1'), meta__transition__destination_state=State.objects.get(label='s2'))[0],
'source_state': State.objects.get(label='s1'),
'destination_state': State.objects.get(label='s2')
}, self.test_kwargs)
# Proceeded but no transition
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.assertEqual((), self.test_args)
self.assertDictEqual(
{
'field': 'my_field',
'object': self.objects[0],
'proceeding': Proceeding.objects.filter(meta__transition__source_state=State.objects.get(label='s1'), meta__transition__destination_state=State.objects.get(label='s2'))[0],
'source_state': State.objects.get(label='s1'),
'destination_state': State.objects.get(label='s2')
}, self.test_kwargs)
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.assertEqual((), self.test_args)
self.assertDictEqual(
{
'field': 'my_field',
'object': self.objects[0],
'proceeding': Proceeding.objects.filter(meta__transition__source_state=State.objects.get(label='s2'), meta__transition__destination_state=State.objects.get(label='s3'))[2],
'source_state': State.objects.get(label='s2'),
'destination_state': State.objects.get(label='s3')
}, self.test_kwargs)
def test_get_field(self):
field = ObjectService.get_field(TestModel)
self.assertEqual('my_field', field.name)
try:
ObjectService.get_field(TestModelWithoutStateField)
self.assertFalse(
True,
"Trying getting field from a model does not contains state field should have thrown the error with code '8'"
)
except RiverException as re:
self.assertEqual(ErrorCode.NO_STATE_FIELD, re.code)
def test_get_objects_waiting_for_approval_for_user(self):
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.field, self.user1)
self.assertEqual(2, on_approval_objects.count())
self.assertEqual(self.objects[0], on_approval_objects[0])
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.field, self.user2)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.field, self.user3)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.field, self.user4)
self.assertEqual(0, on_approval_objects.count())
def _post_save(sender, instance, created, *args, **kwargs): # signal, sender, instance):
"""
Desc: Generate TransitionProceedings according to ProceedingMeta of the content type at the beginning.
:param kwargs:
:return:
"""
from river.services.state import StateService
if created:
ObjectService.register_object(instance)
if not instance.get_state():
init_state = StateService.get_initial_state(ContentType.objects.get_for_model(instance))
instance.set_state(init_state)
instance.save()
def test_register_for_a_transition(self):
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
PostTransitionHandler.register(
test_handler,
self.objects[0],
'my_field',
source_state=State.objects.get(label='s2'),
destination_state=State.objects.get(label='s3'))
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field,
self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field,
self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.approve_transition(self.objects[0], self.field,
self.user3)
self.assertEqual((self.objects[0], 'my_field'), self.test_args)
self.assertDictEqual(
{
'approvement':
Approvement.objects.filter(
meta__transition__source_state=State.objects.get(
label='s2'),
meta__transition__destination_state=State.objects.get(
label='s3'))[2],
'source_state':
State.objects.get(label='s2'),
'destination_state':
State.objects.get(label='s3')
}, self.test_kwargs)
def _post_save(sender, instance, created, *args, **kwargs): # signal, sender, instance):
"""
Desc: Generate TransitionProceedings according to ProceedingMeta of the content type at the beginning.
:param kwargs:
:return:
"""
from river.services.state import StateService
if created:
ObjectService.register_object(instance)
if not instance.get_state():
init_state = StateService.get_initial_state(ContentType.objects.get_for_model(instance))
instance.set_state(init_state)
instance.save()
def test_get_proceedings_object_waiting_for_approval_without_skip(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
proceedings = ProceedingService.get_available_proceedings(self.objects[0], self.field, [self.objects[0].my_field], user=self.user1)
self.assertEqual(1, proceedings.count())
proceedings = ProceedingService.get_available_proceedings(self.objects[0], self.field, [self.objects[0].my_field], user=self.user2)
self.assertEqual(0, proceedings.count())
proceedings = ProceedingService.get_available_proceedings(self.objects[0], self.field, [self.objects[0].my_field], user=self.user3)
self.assertEqual(0, proceedings.count())
proceedings = ProceedingService.get_available_proceedings(self.objects[0], self.field, [self.objects[0].my_field], user=self.user4)
self.assertEqual(0, proceedings.count())
def test_get_approvements_object_waiting_for_approval_without_skip(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[0], self.field, [self.objects[0].my_field], user=self.user1)
self.assertEqual(1, approvements.count())
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[0], self.field, [self.objects[0].my_field], user=self.user2)
self.assertEqual(0, approvements.count())
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[0], self.field, [self.objects[0].my_field], user=self.user3)
self.assertEqual(0, approvements.count())
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[0], self.field, [self.objects[0].my_field], user=self.user4)
self.assertEqual(0, approvements.count())
def test_get_objects_waiting_for_approval_for_user(self):
self.initialize_normal_scenario()
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.user1)
self.assertEqual(2, on_approval_objects.count())
self.assertEqual(self.objects[0], on_approval_objects[0])
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.user2)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.user3)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(self.content_type, self.user4)
self.assertEqual(0, on_approval_objects.count())
def test_register_for_a_transition(self):
self.initialize_normal_scenario()
self.test_args = None
self.test_kwargs = None
def test_handler(*args, **kwargs):
self.test_args = args
self.test_kwargs = kwargs
ObjectService.register_object(self.objects[0])
ObjectService.register_object(self.objects[1])
PostTransitionHandler.register(
test_handler,
self.objects[0],
source_state=State.objects.get(label="s2"),
destination_state=State.objects.get(label="s3"),
)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.user1)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.user2)
self.assertIsNone(self.test_args)
self.assertIsNone(self.test_kwargs)
TransitionService.proceed(self.objects[0], self.user3)
self.assertEqual((self.objects[0],), self.test_args)
self.assertDictEqual(
{
"proceeding": Proceeding.objects.filter(
meta__transition__source_state=State.objects.get(label="s2"),
meta__transition__destination_state=State.objects.get(label="s3"),
)[2],
"source_state": State.objects.get(label="s2"),
"destination_state": State.objects.get(label="s3"),
},
self.test_kwargs,
)
def test_get_objects_waiting_for_approval_for_user(self):
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.field, self.user1)
self.assertEqual(2, on_approval_objects.count())
self.assertEqual(self.objects[0], on_approval_objects[0])
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.field, self.user2)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.field, self.user3)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.field, self.user4)
self.assertEqual(0, on_approval_objects.count())
def test_approve_transition(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
# ####################
# STATE 1 - STATE 2
# Only User1(2001) can approve and after his approve state must be changed to STATE 2
# ###################
# Approved by user has no required permission for this transition
try:
TransitionService.approve_transition(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException, e:
self.assertEqual(e.message, 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
def test_get_objects_waiting_for_approval_for_user(self):
self.initialize_normal_scenario()
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.user1)
self.assertEqual(2, on_approval_objects.count())
self.assertEqual(self.objects[0], on_approval_objects[0])
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.user2)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.user3)
self.assertEqual(0, on_approval_objects.count())
on_approval_objects = ObjectService.get_objects_waiting_for_approval(
self.content_type, self.user4)
self.assertEqual(0, on_approval_objects.count())
def test_get_available_states(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0])
ObjectService.register_object(self.objects[1])
available_states = StateService.get_available_states(self.objects[0], self.user2, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.user2, include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.user2)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.user3, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.user3, include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.user3)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.user4, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.user4, include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.user4)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.user1, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.user1, include_user=True)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.user1)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
def test_get_available_states(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
available_states = StateService.get_available_states(self.objects[0], self.field, self.user2, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.field, self.user2, include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.field, self.user2)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.field, self.user3, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.field, self.user3, include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.field, self.user3)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.field, self.user4, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.field, self.user4, include_user=True)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.field, self.user4)
self.assertEqual(0, available_states.count())
available_states = StateService.get_available_states(self.objects[0], self.field, self.user1, include_user=False)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.field, self.user1, include_user=True)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
available_states = StateService.get_available_states(self.objects[0], self.field, self.user1)
self.assertEqual(1, available_states.count())
self.assertEqual(State.objects.get(label='s2'), available_states[0])
def save(self, *args, **kwargs):
content_type = self.cleaned_data['content_type']
field = ObjectService.get_only_field(content_type.model_class())
instance = super(ProceedingMetaForm, self).save(commit=False)
instance.field = field.name
return super(ProceedingMetaForm, self).save(*args, **kwargs)
def is_workflow_completed(workflow_object):
return ObjectService.is_workflow_completed(workflow_object, name)
def save(self, *args, **kwargs):
content_type = self.cleaned_data['content_type']
field = ObjectService.get_field(content_type.model_class())
instance = super(ProceedingMetaForm, self).save(commit=False)
instance.field = field.name
return super(ProceedingMetaForm, self).save(*args, **kwargs)
def test_get_only_fields(self):
field = ObjectService.get_only_field(TestModel)
self.assertEqual('my_field', field.name)
def test_get_approvements_object_waiting_for_approval_with_skip(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
approvements = self.objects[1].get_available_approvements(self.user1)
self.assertEqual(1, approvements.count())
self.assertEqual(State.objects.get(label='s2'), approvements[0].meta.transition.destination_state)
Approvement.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s2')
).update(skip=True)
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[1], self.field, [self.objects[1].my_field], user=self.user2)
self.assertEqual(1, approvements.count())
self.assertEqual(State.objects.get(label='s3'), approvements[0].meta.transition.destination_state)
Approvement.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s3')
).update(skip=True)
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[1], self.field, [self.objects[1].my_field], user=self.user4)
self.assertEqual(2, approvements.count())
self.assertEqual(State.objects.get(label='s4'), approvements[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5'), approvements[1].meta.transition.destination_state)
Approvement.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s4')
).update(skip=True)
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[1], self.field, [self.objects[1].my_field], user=self.user4)
self.assertEqual(3, approvements.count())
self.assertEqual(State.objects.get(label='s5'), approvements[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.1'), approvements[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.2'), approvements[2].meta.transition.destination_state)
Approvement.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s4')
).update(skip=False)
Approvement.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s5')
).update(skip=True)
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[1], self.field, [self.objects[1].my_field], user=self.user4)
self.assertEqual(3, approvements.count())
self.assertEqual(State.objects.get(label='s4'), approvements[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.1'), approvements[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'), approvements[2].meta.transition.destination_state)
Approvement.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state__in=State.objects.filter(label__in=['s4', 's5'])
).update(skip=True)
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[1], self.field, [self.objects[1].my_field], user=self.user4)
self.assertEqual(4, approvements.count())
self.assertEqual(State.objects.get(label='s4.1'), approvements[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.2'), approvements[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.1'), approvements[2].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'), approvements[3].meta.transition.destination_state)
Approvement.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state__in=State.objects.filter(label__in=['s4.1', 's5.1'])
).update(skip=True)
approvements = ApprovementService.get_approvements_object_waiting_for_approval(self.objects[1], self.field, [self.objects[1].my_field], user=self.user4)
self.assertEqual(2, approvements.count())
self.assertEqual(State.objects.get(label='s4.2'), approvements[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'), approvements[1].meta.transition.destination_state)
def test_get_proceedings_object_waiting_for_approval_with_skip(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
proceedings = self.objects[1].get_available_proceedings(self.user1)
self.assertEqual(1, proceedings.count())
self.assertEqual(State.objects.get(label='s2'), proceedings[0].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s2')
).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(self.objects[1], self.field,
[self.objects[1].my_field], user=self.user2)
self.assertEqual(1, proceedings.count())
self.assertEqual(State.objects.get(label='s3'), proceedings[0].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s3')
).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(self.objects[1], self.field,
[self.objects[1].my_field], user=self.user4)
self.assertEqual(2, proceedings.count())
self.assertEqual(State.objects.get(label='s4'), proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5'), proceedings[1].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s4')
).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(self.objects[1], self.field,
[self.objects[1].my_field], user=self.user4)
self.assertEqual(3, proceedings.count())
self.assertEqual(State.objects.get(label='s5'), proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.1'), proceedings[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.2'), proceedings[2].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s4')
).update(skip=False)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(label='s5')
).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(self.objects[1], self.field,
[self.objects[1].my_field], user=self.user4)
self.assertEqual(3, proceedings.count())
self.assertEqual(State.objects.get(label='s4'), proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.1'), proceedings[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'), proceedings[2].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state__in=State.objects.filter(label__in=['s4', 's5'])
).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(self.objects[1], self.field,
[self.objects[1].my_field], user=self.user4)
self.assertEqual(4, proceedings.count())
self.assertEqual(State.objects.get(label='s4.1'), proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.2'), proceedings[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.1'), proceedings[2].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'), proceedings[3].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state__in=State.objects.filter(label__in=['s4.1', 's5.1'])
).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(self.objects[1], self.field,
[self.objects[1].my_field], user=self.user4)
self.assertEqual(2, proceedings.count())
self.assertEqual(State.objects.get(label='s4.2'), proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'), proceedings[1].meta.transition.destination_state)
def test_get_the_fields(self):
fields = ObjectService.get_the_fields(TestModel)
self.assertEqual(1, len(fields))
self.assertEqual('my_field', fields[0].name)
def test_cycle_proceedings(self):
self.initialize_circular_scenario()
ObjectService.register_object(self.objects[0], self.field)
# No Cycle
self.assertFalse(ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user1, next_state=self.in_progress_state, god_mod=True)
self.assertEqual(5, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
# No Cycle
self.assertFalse(ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user2, next_state=self.resolved_state, god_mod=True)
self.assertEqual(5, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
# State is re-opened and cycle is detected. Transition in-progress to resolved proceeding is cloned
self.assertFalse(ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user3, next_state=self.re_opened_state, god_mod=True)
self.assertEqual(6, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(ProceedingMeta.objects.get(transition__source_state=self.in_progress_state,
transition__destination_state=self.resolved_state),
Proceeding.objects.filter(object_id=self.objects[0].pk).latest('date_created').meta)
# There will be no cycling even if the method is invoked. Because cycling is done in proceeding.
self.assertFalse(ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.assertEqual(6, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
# State is in-progress and cycle is detected. Transition resolved to re-opened proceeding is cloned
self.objects[0].proceed(user=self.user3, next_state=self.in_progress_state, god_mod=True)
self.assertEqual(7, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(ProceedingMeta.objects.get(transition__source_state=self.resolved_state,
transition__destination_state=self.re_opened_state),
Proceeding.objects.filter(object_id=self.objects[0].pk).latest('date_created').meta)
# State is resolved and cycle is detected. Transition re-opened to in-progress proceeding is cloned
self.objects[0].proceed(user=self.user3, next_state=self.resolved_state, god_mod=True)
self.assertEqual(8, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(ProceedingMeta.objects.get(transition__source_state=self.re_opened_state,
transition__destination_state=self.in_progress_state),
Proceeding.objects.filter(object_id=self.objects[0].pk).latest('date_created').meta)
# State is re-opened and cycle is detected. Transition in-progress to resolved proceeding is cloned
self.assertFalse(ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user3, next_state=self.re_opened_state, god_mod=True)
self.assertEqual(9, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(ProceedingMeta.objects.get(transition__source_state=self.in_progress_state,
transition__destination_state=self.resolved_state),
Proceeding.objects.filter(object_id=self.objects[0].pk).latest('date_created').meta)
# State is in-progress and cycle is detected. Transition resolved to re-opened proceeding is cloned
self.objects[0].proceed(user=self.user3, next_state=self.in_progress_state, god_mod=True)
self.assertEqual(10, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(ProceedingMeta.objects.get(transition__source_state=self.resolved_state,
transition__destination_state=self.re_opened_state),
Proceeding.objects.filter(object_id=self.objects[0].pk).latest('date_created').meta)
# State is resolved and cycle is detected. Transition re-opened to in-progress proceeding is cloned
self.objects[0].proceed(user=self.user3, next_state=self.resolved_state, god_mod=True)
self.assertEqual(11, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(ProceedingMeta.objects.get(transition__source_state=self.re_opened_state,
transition__destination_state=self.in_progress_state),
Proceeding.objects.filter(object_id=self.objects[0].pk).latest('date_created').meta)
# No Cycle for closed state.
self.objects[0].proceed(user=self.user4, next_state=self.closed_state, god_mod=True)
self.assertEqual(11, Proceeding.objects.filter(object_id=self.objects[0].pk).count())
def test_get_only_fields(self):
field = ObjectService.get_only_field(TestModel)
self.assertEqual('my_field', field.name)
def test_proceed(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
# ####################
# STATE 1 - STATE 2
# Only User1(2001) can proceed and after his proceed state must be changed to STATE 2
# ###################
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Proceeded by user has required permission for this transition
self.assertEqual(State.objects.get(label='s1'), getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.assertEqual(State.objects.get(label='s2'), getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s1',
meta__transition__destination_state__label='s2'
)
self.assertEqual(1, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertEqual(self.user1, proceedings[0].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
try:
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# ####################
# STATE 2 - STATE 3
# User2(2002) is first proceeder and User3(2003) is second proceeder. This must be done with turn. After proceeding is done, state is gonna be changed to STATE 3
# ####################
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Turn is User2(2002)s, not User3(2003)s. After User2(2002) proceeded, User3(2003) can proceed.
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Proceeded by two user has required permission for this transition to get next state (order is user2(2002),user3(2003)).
self.assertEqual(State.objects.get(label='s2'), getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.assertEqual(State.objects.get(label='s2'), getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s2',
meta__transition__destination_state__label='s3'
)
self.assertEqual(1, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertEqual(self.user2, proceedings[0].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
self.assertEqual(State.objects.get(label='s2'), getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.assertEqual(State.objects.get(label='s3'), getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s2',
meta__transition__destination_state__label='s3'
)
self.assertEqual(2, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertIsNotNone(proceedings[1].transactioner)
self.assertEqual(self.user2, proceedings[0].transactioner)
self.assertEqual(self.user3, proceedings[1].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
self.assertIsNotNone(proceedings[1].transaction_date)
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# ####################
# STATE 3 - STATE 4 or STATE 5
# Only User4(2004) can proceed by giving the exact next state and after his proceed with his state must be changed to STATE 4 or STATE 5
# ###################
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER, e.code)
# There are STATE 4 and STATE 5 as next. State must be given to switch
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e), 'State must be given when there are multiple states for destination')
self.assertEqual(ErrorCode.NEXT_STATE_IS_REQUIRED, e.code)
# There are STATE 4 and STATE 5 as next. State among STATE 4 and STATE 5 must be given to switch, not other state
try:
TransitionService.proceed(self.objects[0], self.field, self.user4, next_state=State.objects.get(label='s3'))
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(str(e),
"Invalid state is given(%s). Valid states is(are) %s" % (
State.objects.get(label='s3').__unicode__(), ','.join([ast.__unicode__() for ast in State.objects.filter(label__in=['s4', 's5'])])))
self.assertEqual(ErrorCode.INVALID_NEXT_STATE_FOR_USER, e.code)
# There are STATE 4 and STATE 5 as next. After one of them is given to proceeding, the state must be switch to it immediately.
self.assertEqual(State.objects.get(label='s3'), getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0], self.field, self.user4, next_state=State.objects.get(label='s5'))
self.assertEqual(State.objects.get(label='s5'), getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s3',
meta__transition__destination_state__label='s5'
)
self.assertEqual(1, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertEqual(self.user4, proceedings[0].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
def test_proceed(self):
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
# ####################
# STATE 1 - STATE 2
# Only User1(2001) can proceed and after his proceed state must be changed to STATE 2
# ###################
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Proceeded by user has required permission for this transition
self.assertEqual(State.objects.get(label='s1'),
getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.assertEqual(State.objects.get(label='s2'),
getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s1',
meta__transition__destination_state__label='s2')
self.assertEqual(1, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertEqual(self.user1, proceedings[0].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
try:
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# ####################
# STATE 2 - STATE 3
# User2(2002) is first proceeder and User3(2003) is second proceeder. This must be done with turn. After proceeding is done, state is gonna be changed to STATE 3
# ####################
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Turn is User2(2002)s, not User3(2003)s. After User2(2002) proceeded, User3(2003) can proceed.
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Proceeded by two user has required permission for this transition to get next state (order is user2(2002),user3(2003)).
self.assertEqual(State.objects.get(label='s2'),
getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.assertEqual(State.objects.get(label='s2'),
getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s2',
meta__transition__destination_state__label='s3')
self.assertEqual(1, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertEqual(self.user2, proceedings[0].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
self.assertEqual(State.objects.get(label='s2'),
getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.assertEqual(State.objects.get(label='s3'),
getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s2',
meta__transition__destination_state__label='s3')
self.assertEqual(2, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertIsNotNone(proceedings[1].transactioner)
self.assertEqual(self.user2, proceedings[0].transactioner)
self.assertEqual(self.user3, proceedings[1].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
self.assertIsNotNone(proceedings[1].transaction_date)
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# ####################
# STATE 3 - STATE 4 or STATE 5
# Only User4(2004) can proceed by giving the exact next state and after his proceed with his state must be changed to STATE 4 or STATE 5
# ###################
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user1)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user2)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# Proceeded by user has no required permission for this transition
try:
TransitionService.proceed(self.objects[0], self.field, self.user3)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'There is no available state for destination for the user.')
self.assertEqual(ErrorCode.NO_AVAILABLE_NEXT_STATE_FOR_USER,
e.code)
# There are STATE 4 and STATE 5 as next. State must be given to switch
try:
TransitionService.proceed(self.objects[0], self.field, self.user4)
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e),
'State must be given when there are multiple states for destination'
)
self.assertEqual(ErrorCode.NEXT_STATE_IS_REQUIRED, e.code)
# There are STATE 4 and STATE 5 as next. State among STATE 4 and STATE 5 must be given to switch, not other state
try:
TransitionService.proceed(self.objects[0],
self.field,
self.user4,
next_state=State.objects.get(label='s3'))
self.fail('Exception was expected')
except RiverException as e:
self.assertEqual(
str(e), "Invalid state is given(%s). Valid states is(are) %s" %
(State.objects.get(label='s3').__unicode__(), ','.join([
ast.__unicode__()
for ast in State.objects.filter(label__in=['s4', 's5'])
])))
self.assertEqual(ErrorCode.INVALID_NEXT_STATE_FOR_USER, e.code)
# There are STATE 4 and STATE 5 as next. After one of them is given to proceeding, the state must be switch to it immediately.
self.assertEqual(State.objects.get(label='s3'),
getattr(self.objects[0], self.field))
TransitionService.proceed(self.objects[0],
self.field,
self.user4,
next_state=State.objects.get(label='s5'))
self.assertEqual(State.objects.get(label='s5'),
getattr(self.objects[0], self.field))
proceedings = Proceeding.objects.filter(
workflow_object=self.objects[0],
field=self.field,
status=APPROVED,
meta__transition__source_state__label='s3',
meta__transition__destination_state__label='s5')
self.assertEqual(1, proceedings.count())
self.assertIsNotNone(proceedings[0].transactioner)
self.assertEqual(self.user4, proceedings[0].transactioner)
self.assertIsNotNone(proceedings[0].transaction_date)
def get_object_count_waiting_for_approval(self, user):
return ObjectService.get_object_count_waiting_for_approval(ContentType.objects.get_for_model(self.model), user)
def is_workflow_completed(workflow_object):
return ObjectService.is_workflow_completed(workflow_object, name)
def get_object_count_waiting_for_approval(self, user):
return ObjectService.get_object_count_waiting_for_approval(
ContentType.objects.get_for_model(self.model), user)
def test_get_proceedings_object_waiting_for_approval_with_skip(self):
self.initialize_normal_scenario()
ObjectService.register_object(self.objects[0], self.field)
ObjectService.register_object(self.objects[1], self.field)
proceedings = self.objects[1].get_available_proceedings(self.user1)
self.assertEqual(1, proceedings.count())
self.assertEqual(State.objects.get(label='s2'),
proceedings[0].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(
label='s2')).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(
self.objects[1],
self.field, [self.objects[1].my_field],
user=self.user2)
self.assertEqual(1, proceedings.count())
self.assertEqual(State.objects.get(label='s3'),
proceedings[0].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(
label='s3')).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(
self.objects[1],
self.field, [self.objects[1].my_field],
user=self.user4)
self.assertEqual(2, proceedings.count())
self.assertEqual(State.objects.get(label='s4'),
proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5'),
proceedings[1].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(
label='s4')).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(
self.objects[1],
self.field, [self.objects[1].my_field],
user=self.user4)
self.assertEqual(3, proceedings.count())
self.assertEqual(State.objects.get(label='s5'),
proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.1'),
proceedings[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.2'),
proceedings[2].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(
label='s4')).update(skip=False)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state=State.objects.get(
label='s5')).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(
self.objects[1],
self.field, [self.objects[1].my_field],
user=self.user4)
self.assertEqual(3, proceedings.count())
self.assertEqual(State.objects.get(label='s4'),
proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.1'),
proceedings[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'),
proceedings[2].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state__in=State.objects.filter(
label__in=['s4', 's5'])).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(
self.objects[1],
self.field, [self.objects[1].my_field],
user=self.user4)
self.assertEqual(4, proceedings.count())
self.assertEqual(State.objects.get(label='s4.1'),
proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s4.2'),
proceedings[1].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.1'),
proceedings[2].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'),
proceedings[3].meta.transition.destination_state)
Proceeding.objects.filter(
field=self.field,
workflow_object=self.objects[1],
meta__transition__destination_state__in=State.objects.filter(
label__in=['s4.1', 's5.1'])).update(skip=True)
proceedings = ProceedingService.get_available_proceedings(
self.objects[1],
self.field, [self.objects[1].my_field],
user=self.user4)
self.assertEqual(2, proceedings.count())
self.assertEqual(State.objects.get(label='s4.2'),
proceedings[0].meta.transition.destination_state)
self.assertEqual(State.objects.get(label='s5.2'),
proceedings[1].meta.transition.destination_state)
def test_cycle_proceedings(self):
self.initialize_circular_scenario()
ObjectService.register_object(self.objects[0], self.field)
# No Cycle
self.assertFalse(
ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user1,
next_state=self.in_progress_state,
god_mod=True)
self.assertEqual(
5,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
# No Cycle
self.assertFalse(
ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user2,
next_state=self.resolved_state,
god_mod=True)
self.assertEqual(
5,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
# State is re-opened and cycle is detected. Transition in-progress to resolved proceeding is cloned
self.assertFalse(
ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user3,
next_state=self.re_opened_state,
god_mod=True)
self.assertEqual(
6,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(
ProceedingMeta.objects.get(
transition__source_state=self.in_progress_state,
transition__destination_state=self.resolved_state),
Proceeding.objects.filter(
object_id=self.objects[0].pk).latest('date_created').meta)
# There will be no cycling even if the method is invoked. Because cycling is done in proceeding.
self.assertFalse(
ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.assertEqual(
6,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
# State is in-progress and cycle is detected. Transition resolved to re-opened proceeding is cloned
self.objects[0].proceed(user=self.user3,
next_state=self.in_progress_state,
god_mod=True)
self.assertEqual(
7,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(
ProceedingMeta.objects.get(
transition__source_state=self.resolved_state,
transition__destination_state=self.re_opened_state),
Proceeding.objects.filter(
object_id=self.objects[0].pk).latest('date_created').meta)
# State is resolved and cycle is detected. Transition re-opened to in-progress proceeding is cloned
self.objects[0].proceed(user=self.user3,
next_state=self.resolved_state,
god_mod=True)
self.assertEqual(
8,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(
ProceedingMeta.objects.get(
transition__source_state=self.re_opened_state,
transition__destination_state=self.in_progress_state),
Proceeding.objects.filter(
object_id=self.objects[0].pk).latest('date_created').meta)
# State is re-opened and cycle is detected. Transition in-progress to resolved proceeding is cloned
self.assertFalse(
ProceedingService.cycle_proceedings(self.objects[0], self.field))
self.objects[0].proceed(user=self.user3,
next_state=self.re_opened_state,
god_mod=True)
self.assertEqual(
9,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(
ProceedingMeta.objects.get(
transition__source_state=self.in_progress_state,
transition__destination_state=self.resolved_state),
Proceeding.objects.filter(
object_id=self.objects[0].pk).latest('date_created').meta)
# State is in-progress and cycle is detected. Transition resolved to re-opened proceeding is cloned
self.objects[0].proceed(user=self.user3,
next_state=self.in_progress_state,
god_mod=True)
self.assertEqual(
10,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(
ProceedingMeta.objects.get(
transition__source_state=self.resolved_state,
transition__destination_state=self.re_opened_state),
Proceeding.objects.filter(
object_id=self.objects[0].pk).latest('date_created').meta)
# State is resolved and cycle is detected. Transition re-opened to in-progress proceeding is cloned
self.objects[0].proceed(user=self.user3,
next_state=self.resolved_state,
god_mod=True)
self.assertEqual(
11,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())
self.assertEqual(
ProceedingMeta.objects.get(
transition__source_state=self.re_opened_state,
transition__destination_state=self.in_progress_state),
Proceeding.objects.filter(
object_id=self.objects[0].pk).latest('date_created').meta)
# No Cycle for closed state.
self.objects[0].proceed(user=self.user4,
next_state=self.closed_state,
god_mod=True)
self.assertEqual(
11,
Proceeding.objects.filter(object_id=self.objects[0].pk).count())