def test_edit_is_resettable(date_effective1, date_effective2, edit_status,
                            expected_outcome, create_user, ahj_obj):
    user = create_user()
    new_value = 'newname'
    old_value = 'oldname'
    if edit_status == 'A':  # The edit is applied
        set_obj_field(ahj_obj, 'AHJName', new_value)
    else:  # The edit is rejected or not yet applied
        set_obj_field(ahj_obj, 'AHJName', old_value)
        if edit_status == 'ANA':
            edit_status = 'A'
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': date_effective1,
        'DateEffective': date_effective1,
        'ReviewStatus': edit_status,
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit1 = Edit.objects.create(**edit_dict)
    edit_dict['DateRequested'], edit_dict[
        'DateEffective'] = date_effective2, date_effective2
    edit2 = Edit.objects.create(**edit_dict)
    assert expected_outcome == views_edits.edit_is_resettable(edit1)
def test_edit_is_applied__approved_and_date_effective_passed(
        date_effective, date_checked, edit_status, create_user, ahj_obj):
    def get_expected_value(date_effective, date_checked, edit_status):
        return date_effective is not None and date_effective <= date_checked and edit_status == 'A'

    user = create_user()
    date_requested = date_effective if date_effective is not None else timezone.now(
    )
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': 'oldname',
        'NewValue': 'newname',
        'DateRequested': date_requested,
        'DateEffective': date_effective,
        'ReviewStatus': edit_status,
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    assert views_edits.edit_is_applied(edit) == get_expected_value(
        date_effective, date_checked, edit_status)
Exemplo n.º 3
0
def test_apply_edits(ReviewStatus, DateEffective, create_user, ahj_obj):
    field_name = 'AHJName'
    old_value = 'oldname'
    new_value = 'newname'
    user = create_user()
    set_obj_field(ahj_obj, field_name, old_value)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user if DateEffective is not None else None,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': field_name,
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': timezone.now(),
        'DateEffective': DateEffective,
        'ReviewStatus': ReviewStatus,
        'IsApplied': False,
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    views_edits.apply_edits()
    ahj = AHJ.objects.get(AHJPK=ahj_obj.AHJPK)
    is_date_effective = (DateEffective.date() == datetime.date.today()
                         ) if DateEffective is not None else False
    edit_should_apply = is_date_effective and ReviewStatus == 'A'
    edit_is_applied = getattr(ahj, field_name) == new_value
    assert edit_is_applied == edit_should_apply
    edit = Edit.objects.get(EditID=edit.EditID)
    assert edit.IsApplied == edit_should_apply
Exemplo n.º 4
0
def test_edit_reset__edit_pending_do_nothing(create_user, ahj_obj):
    user = create_user()
    old_value = 'oldname'
    new_value = 'newname'
    set_obj_field(ahj_obj, 'AHJName', old_value)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': None,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': timezone.now(),
        'DateEffective': None,
        'ReviewStatus': 'P',
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    assert not views_edits.reset_edit(user, edit)
    edit_dict['OldValue'], edit_dict['NewValue'] = old_value, edit_dict[
        'OldValue']
    edit_dict['ReviewStatus'] = 'A'
    edit_dict['ApprovedBy'], edit_dict['DateEffective'] = user, timezone.now()
    assert not check_edit_exists(edit_dict)
    assert Edit.objects.all().count() == 1
Exemplo n.º 5
0
def test_edit_reset__edit_update(model_name, field_name, old_value, new_value,
                                 create_user, ahj_obj, create_minimal_obj,
                                 expected_value, add_enums):
    user = create_user()
    obj = create_minimal_obj(model_name)
    set_obj_field(obj, field_name, new_value)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': model_name,
        'SourceRow': obj.pk,
        'SourceColumn': field_name,
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'A',
        'IsApplied': True,
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    assert views_edits.reset_edit(user, edit)
    assert edit_is_pending(edit)
    if expected_value == 'old_value':
        expected_value = get_value_or_enum_row(field_name, old_value)
    assert get_obj_field(obj, field_name) == expected_value
Exemplo n.º 6
0
def test_edit_reset__edit_deletion(parent_model_name, model_name,
                                   review_status, create_user,
                                   create_minimal_obj, ahj_obj):
    user = create_user()
    parent_obj = create_minimal_obj(parent_model_name)
    obj = create_minimal_obj(model_name)
    relation = obj.create_relation_to(parent_obj)
    set_obj_field(relation, relation.get_relation_status_field(),
                  review_status != 'A')
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': relation.__class__.__name__,
        'SourceRow': relation.pk,
        'SourceColumn': relation.get_relation_status_field(),
        'OldValue': True,
        'NewValue': False,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': review_status,
        'IsApplied': review_status == 'A',
        'EditType': 'A',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    assert views_edits.reset_edit(user, edit)
    edit = Edit.objects.get(EditID=edit.EditID)
    assert edit_is_pending(edit)
    assert get_obj_field(
        relation,
        relation.get_relation_status_field()) == edit_dict['OldValue']
Exemplo n.º 7
0
def test_edit_revert__edit_addition(parent_model_name, model_name, create_user,
                                    create_minimal_obj, ahj_obj):
    user = create_user()
    parent_obj = create_minimal_obj(parent_model_name)
    obj = create_minimal_obj(model_name)
    relation = obj.create_relation_to(parent_obj)
    set_obj_field(relation, relation.get_relation_status_field(), True)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': relation.__class__.__name__,
        'SourceRow': relation.pk,
        'SourceColumn': relation.get_relation_status_field(),
        'OldValue': None,
        'NewValue': True,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'A',
        'EditType': 'A',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    assert views_edits.revert_edit(user, edit)
    edit_dict['OldValue'], edit_dict['NewValue'] = edit_dict['NewValue'], False
    assert check_edit_exists(edit_dict)
    assert get_obj_field(
        relation,
        relation.get_relation_status_field()) == edit_dict['NewValue']
Exemplo n.º 8
0
def test_edit_update_old_value_all_awaiting_apply_or_review(
        model_name, field_name, old_value, new_value, create_user, ahj_obj,
        create_minimal_obj, add_enums):
    user = create_user()
    obj = create_minimal_obj(model_name)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': model_name,
        'SourceRow': obj.pk,
        'SourceColumn': field_name,
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'A',
        'IsApplied': True,
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    edit_dict['IsApplied'] = False
    approved_edit = Edit.objects.create(**edit_dict)
    edit_dict['ReviewStatus'] = 'P'
    pending_edit = Edit.objects.create(**edit_dict)
    views_edits.apply_edits(ready_edits=[edit])
    views_edits.edit_update_old_value_all_awaiting_apply_or_review(edit)
    approved_edit = Edit.objects.get(EditID=approved_edit.EditID)
    pending_edit = Edit.objects.get(EditID=pending_edit.EditID)
    assert approved_edit.OldValue == str(new_value)
    assert pending_edit.OldValue == str(new_value)
Exemplo n.º 9
0
def test_edit_is_resettable(edit_status1, is_applied1, is_applied2,
                            expected_outcome, create_user, ahj_obj):
    user = create_user()
    new_value = 'newname'
    old_value = 'oldname'
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': edit_status1,
        'IsApplied': is_applied1,
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit_to_reset = Edit.objects.create(**edit_dict)
    tomorrow = timezone.now() + datetime.timedelta(days=1)
    edit_dict['DateRequested'], edit_dict['DateEffective'] = tomorrow, tomorrow
    edit_dict['ReviewStatus'], edit_dict['IsApplied'] = 'A', is_applied2
    later_edit = Edit.objects.create(**edit_dict)
    assert expected_outcome == views_edits.edit_is_resettable(edit_to_reset)
Exemplo n.º 10
0
def test_edit_revert__revert_edit_old_value_uses_current_row_value(
        create_user, ahj_obj):
    user = create_user()
    old_value = 'oldname'
    middle_value = 'newername'
    new_value = 'newestname'
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': old_value,
        'NewValue': middle_value,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'A',
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    edit_dict['OldValue'], edit_dict['NewValue'] = edit_dict[
        'NewValue'], new_value
    setattr(ahj_obj, 'AHJName', new_value)
    ahj_obj.save()
    newer_edit = Edit.objects.create(**edit_dict)
    assert views_edits.revert_edit(user, edit)
    edit_dict['OldValue'], edit_dict['NewValue'] = edit_dict[
        'NewValue'], old_value
    reverting_edit = filter_to_edit(edit_dict)
    assert reverting_edit.exists()
    assert reverting_edit.first().OldValue == new_value
    assert get_obj_field(ahj_obj, 'AHJName')
Exemplo n.º 11
0
 def test_tutorial_detail_superuser(self):
     user = create_user('bob', use_hash=False, with_profile=True)
     user.is_superuser = True
     user.is_staff = True
     user.save()
     tutorial = create_tutorial(status=Tutorial.HIDDEN)
     self.client.login(username='******', password='******')
     response = self.client.get(tutorial.get_absolute_url())
     eq_(response.status_code, 200)
     eq_(response.context['tutorial'], tutorial)
     self.client.logout()
Exemplo n.º 12
0
 def test_tutorial_detail_superuser(self):
     user = create_user('bob', use_hash=False, with_profile=True)
     user.is_superuser = True
     user.is_staff = True
     user.save()
     tutorial = create_tutorial(status=Tutorial.HIDDEN)
     self.client.login(username='******', password='******')
     response = self.client.get(tutorial.get_absolute_url())
     eq_(response.status_code, 200)
     eq_(response.context['tutorial'], tutorial)
     self.client.logout()
def test_edit_reset__edit_update(model_name, field_name, old_value, new_value,
                                 create_user, ahj_obj, make_later_edit,
                                 later_new_value, create_minimal_obj,
                                 expected_value, add_enums):
    user = create_user()
    obj = create_minimal_obj(model_name)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': model_name,
        'SourceRow': obj.pk,
        'SourceColumn': field_name,
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'A',
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    edits_to_apply = [edit]
    if make_later_edit:
        edit_dict['OldValue'], edit_dict[
            'NewValue'] = new_value, later_new_value
        edit_dict['DateRequested'], edit_dict['DateEffective'] = timezone.now(
        ), timezone.now()
        later_edit = Edit.objects.create(**edit_dict)
        edits_to_apply.append(later_edit)
    # NOTE: apply_edits is tested separately above
    views_edits.apply_edits(ready_edits=edits_to_apply)
    views_edits.reset_edit(user, edit)
    if make_later_edit:
        edit_dict['OldValue'], edit_dict[
            'NewValue'] = later_new_value, old_value
    else:
        edit_dict['ApprovedBy'], edit_dict['ReviewStatus'], edit_dict[
            'DateEffective'] = None, 'P', None
    assert check_edit_exists(edit_dict) is True
    if expected_value == 'old_value':
        expected_value = get_value_or_enum_row(field_name, old_value)
    assert get_obj_field(obj, field_name) == expected_value
Exemplo n.º 14
0
def test_edit_make_pending(create_user, ahj_obj):
    user = create_user()
    set_obj_field(ahj_obj, 'AHJName', 'newername')
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': 'oldname',
        'NewValue': 'newname',
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'R',
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    views_edits.edit_make_pending(edit)
    edit = Edit.objects.get(EditID=edit.EditID)
    assert edit_is_pending(edit)
def test_edit_reset__edit_rejected_always_make_pending_only(
        create_user, ahj_obj):
    user = create_user()
    old_value = 'oldname'
    middle_value = 'newername'
    new_value = 'newestname'
    set_obj_field(ahj_obj, 'AHJName', old_value)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': old_value,
        'NewValue': middle_value,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'R',
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    edit_dict['NewValue'] = new_value
    later_edit = Edit.objects.create(**edit_dict)
    views_edits.reset_edit(user, edit)
    views_edits.reset_edit(user, later_edit)
    edit_dict['ReviewStatus'] = 'A'
    edit_dict['OldValue'], edit_dict['NewValue'] = middle_value, old_value
    assert check_edit_exists(edit_dict) is False
    edit = Edit.objects.get(EditID=edit.EditID)
    assert edit.ReviewStatus == 'P'
    assert edit.ApprovedBy is None
    assert edit.DateEffective is None
    edit_dict['OldValue'], edit_dict['NewValue'] = new_value, old_value
    assert check_edit_exists(edit_dict) is False
    later_edit = Edit.objects.get(EditID=edit.EditID)
    assert later_edit.ReviewStatus == 'P'
    assert later_edit.ApprovedBy is None
    assert later_edit.DateEffective is None
    assert get_obj_field(ahj_obj, 'AHJName') == old_value
def test_edit_reset__kwargs(force_resettable, skip_undo, create_user, ahj_obj):
    user = create_user()
    old_value = 'oldname'
    new_value = 'newname'
    later_value = 'newname_later'
    set_obj_field(ahj_obj, 'AHJName', later_value)
    edit_dict = {
        'ChangedBy': user,
        'ApprovedBy': user,
        'SourceTable': 'AHJ',
        'SourceRow': ahj_obj.pk,
        'SourceColumn': 'AHJName',
        'OldValue': old_value,
        'NewValue': new_value,
        'DateRequested': timezone.now(),
        'DateEffective': timezone.now(),
        'ReviewStatus': 'A',
        'EditType': 'U',
        'AHJPK': ahj_obj
    }
    edit = Edit.objects.create(**edit_dict)
    edit_dict['OldValue'], edit_dict['NewValue'] = edit_dict[
        'NewValue'], later_value
    later_edit = Edit.objects.create(**edit_dict)
    views_edits.reset_edit(user,
                           edit,
                           force_resettable=force_resettable,
                           skip_undo=skip_undo)
    edit = Edit.objects.get(EditID=edit.EditID)
    if force_resettable and not skip_undo:
        assert get_obj_field(ahj_obj, 'AHJName') == old_value
    elif force_resettable and skip_undo:
        assert get_obj_field(ahj_obj, 'AHJName') == later_value
        assert edit.OldValue == later_value
    assert edit.NewValue == new_value
    assert edit.ReviewStatus == 'P'
    assert edit.ApprovedBy is None
    assert edit.DateEffective is None
Exemplo n.º 17
0
def user_obj(create_user):
    user = create_user(Username='******')
    return user
Exemplo n.º 18
0
def given_that_a_user_account_exists(step):
    world.username = '******'
    world.password = '******'
    world.user = create_user(world.username, world.password)