def test_rule_match_success_dest_ctc_assign_same(pg_conn, loc_a1, loc_b1,
ctc_a1, ctc_b1):
create_location_assign_type(pg_conn, 'keeper', 'Keeper')
create_location_assign_type(pg_conn, 'dweller', 'Dweller')
assign_contact_to_location(pg_conn, loc_a1, ctc_a1, 'dweller')
assign_contact_to_location(pg_conn, loc_a1, ctc_b1, 'keeper')
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
rule_3 = _create_auth_rule(pg_conn, 3, 'sys/none')
patch_auth_rule(pg_conn, rule_1, loc_ass='dweller')
patch_auth_rule(pg_conn, rule_2, loc_ass='keeper')
proc_1 = create_process(pg_conn)
proc_2 = create_process(pg_conn)
proc_3 = create_process(pg_conn)
update_process(pg_conn, proc_1, ctc_a1, None, loc_a1, None,
None) # assignee aiming correct loc
update_process(pg_conn, proc_2, ctc_b1, None, loc_a1, None,
None) # assignee aiming correct loc
update_process(pg_conn, proc_3, ctc_b1, None, loc_b1, None,
None) # assignee aiming incorrect loc
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1, rule_3]
assert _proc_matches(grouped, proc_2) == [rule_2, rule_3]
assert _proc_matches(grouped, proc_3) == [rule_3]
def test_rule_match_success_ckp_null(pg_conn, ckp_a1, ckp_b1):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
proc_1 = create_process(pg_conn)
proc_2 = create_process(pg_conn)
update_process(pg_conn, proc_1, None, None, None, ckp_a1, None)
update_process(pg_conn, proc_2, None, None, None, ckp_b1, None)
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1, rule_2]
assert _proc_matches(grouped, proc_2) == [rule_1, rule_2]
def test_rule_match_success_daytime_range_max(pg_conn):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
patch_auth_rule(pg_conn, rule_1, hour1=0, minute1=0)
patch_auth_rule(pg_conn, rule_2, hour1=23, minute1=59)
proc_1 = create_process(pg_conn, started_at=dt(2018, 7, 15, 0, 0))
proc_2 = create_process(pg_conn, started_at=dt(2018, 7, 15, 23, 59))
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1, rule_2]
assert _proc_matches(grouped, proc_2) == [rule_2]
def test_rule_match_success_weekday_range_max(pg_conn):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
patch_auth_rule(pg_conn, rule_1, wday1=0)
patch_auth_rule(pg_conn, rule_2, wday1=6)
proc_1 = create_process(pg_conn, started_at=dt(2018, 7, 15)) # 0, monday
proc_2 = create_process(pg_conn, started_at=dt(2018, 7, 14)) # 6, sunday
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1, rule_2]
assert _proc_matches(grouped, proc_2) == [rule_2]
def test_rule_match_success_monthday_range_max(pg_conn):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
patch_auth_rule(pg_conn, rule_1, mday1=1)
patch_auth_rule(pg_conn, rule_2, mday1=31)
proc_1 = create_process(pg_conn, started_at=dt(2010, 1, 1))
proc_2 = create_process(pg_conn, started_at=dt(2010, 1, 31))
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1, rule_2]
assert _proc_matches(grouped, proc_2) == [rule_2]
def test_rule_match_success_year_range_min(pg_conn):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
patch_auth_rule(pg_conn, rule_1, year0=2018)
patch_auth_rule(pg_conn, rule_2, year0=2010)
proc_1 = create_process(pg_conn, started_at=dt(2018, 1, 1))
proc_2 = create_process(pg_conn, started_at=dt(2010, 1, 1))
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1, rule_2]
assert _proc_matches(grouped, proc_2) == [rule_2]
def test_processes_rule_matches_multiple_processes_match_single_rule(
pg_conn, ctc_a1, ctc_b1):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
patch_auth_rule(pg_conn, rule_1, ctc=ctc_a1)
proc_1 = create_process(pg_conn)
proc_2 = create_process(pg_conn)
update_process(pg_conn, proc_1, ctc_a1, None, None, None, None)
update_process(pg_conn, proc_2, ctc_a1, None, None, None, None)
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1]
assert _proc_matches(grouped, proc_2) == [rule_1]
def test_create_process_auth_event(pg_conn):
proc_id = create_process(pg_conn)
create_process_auth_event(pg_conn, proc_id, 0, 'sys/none')
create_process_auth_event(pg_conn, proc_id, 0, 'sys/none')
create_process_auth_event(pg_conn, proc_id, 0, 'sys/none')
assert fetch_scalar(pg_conn,
'select count(*) from ac_process_auth_events;') == 3
def test_retrieve_process_histories_by_ids(pg_conn):
pk = create_process(pg_conn)
create_process_auth_event(pg_conn, pk, 0, 'sys/none')
create_process_auth_event(pg_conn, pk, 0, 'sys/none')
create_process_auth_event(pg_conn, pk, 0, 'sys/none')
rs = retrieve_process_histories_by_ids(pg_conn, (pk,))
assert len(rs) == 3
def test_processes_rule_selections_highest_order_rule_selected_from_multiple_matches(
pg_conn, ctc_a1, ctc_b1, vhc_a1):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
rule_3 = _create_auth_rule(pg_conn, 3, 'sys/none')
patch_auth_rule(pg_conn, rule_1, ctc=ctc_b1)
patch_auth_rule(pg_conn, rule_2, ctc=ctc_a1)
patch_auth_rule(pg_conn, rule_3, ctc=ctc_b1, vhc=vhc_a1)
proc_1 = create_process(pg_conn)
proc_2 = create_process(pg_conn)
update_process(pg_conn, proc_1, ctc_a1, None, None, None, None)
update_process(pg_conn, proc_2, ctc_b1, None, None, None, vhc_a1)
processes_matches = retrieve_processes_rule_selections(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_2]
assert _proc_matches(grouped, proc_2) == [rule_1]
def test_processes_rule_matches_single_process_matches_no_rule(
pg_conn, ctc_a1, ctc_b1):
proc_1 = create_process(pg_conn)
update_process(pg_conn, proc_1, ctc_a1, None, None, None, None)
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == []
def test_rule_match_failure_daytime_above_max_hour_below_max_minute(pg_conn):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
patch_auth_rule(pg_conn, rule_1, hour0=0, minute0=0, hour1=3, minute1=20)
proc_1 = create_process(pg_conn, started_at=dt(2018, 7, 15, 4, 1))
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == []
def test_create_process_should_use_auth_flow_setting(pg_conn):
pk = create_process(pg_conn)
rs = retrieve_processes_by_ids(pg_conn, (pk,))
active_flow = retrieve_current_active_auth_flow(pg_conn)
assert rs[0]['auth_flow'] == active_flow['auth_flow_id']
auth_flow_1 = create_auth_flow(pg_conn, 'Flow 1')
update_current_active_auth_flow(pg_conn, auth_flow_1)
pk = create_process(pg_conn)
rs = retrieve_processes_by_ids(pg_conn, (pk,))
assert rs[0]['auth_flow'] == auth_flow_1
auth_flow_2 = create_auth_flow(pg_conn, 'Flow 2')
update_current_active_auth_flow(pg_conn, auth_flow_2)
pk = create_process(pg_conn)
rs = retrieve_processes_by_ids(pg_conn, (pk,))
assert rs[0]['auth_flow'] == auth_flow_2
def test_rule_match_success_daytime_below_min_minute_within_daytime_range(
pg_conn):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
patch_auth_rule(pg_conn, rule_1, hour0=0, minute0=10, hour1=3, minute1=20)
proc_1 = create_process(pg_conn, started_at=dt(2018, 7, 15, 2, 5))
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1]
def test_rule_match_success_dest_group_same(pg_conn, loc_a1, loc_b1, loc_nogrp,
locgrp_a, locgrp_b):
rule_1 = _create_auth_rule(pg_conn, 1, 'sys/none')
rule_2 = _create_auth_rule(pg_conn, 2, 'sys/none')
rule_3 = _create_auth_rule(pg_conn, 3, 'sys/none')
patch_auth_rule(pg_conn, rule_1, loc_grp=locgrp_a)
patch_auth_rule(pg_conn, rule_2, loc_grp=locgrp_b)
proc_1 = create_process(pg_conn)
proc_2 = create_process(pg_conn)
proc_3 = create_process(pg_conn)
update_process(pg_conn, proc_1, None, None, loc_a1, None, None)
update_process(pg_conn, proc_2, None, None, loc_b1, None, None)
update_process(pg_conn, proc_3, None, None, loc_nogrp, None, None)
processes_matches = retrieve_processes_rule_matches(pg_conn)
grouped = toolz.groupby('proc_id', processes_matches)
assert _proc_matches(grouped, proc_1) == [rule_1, rule_3]
assert _proc_matches(grouped, proc_2) == [rule_2, rule_3]
assert _proc_matches(grouped, proc_3) == [rule_3]
def test_terminate_process_no_orig(pg_conn):
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
ckp = create_checkpoint(pg_conn, 'Gate 1')
vhc = create_vehicle(pg_conn, 'UUU0000')
pk = create_process(pg_conn)
time.sleep(0.01)
update_process(pg_conn, pk, ctc, None, dest, ckp, vhc)
with pytest.raises(Exception):
terminate_process(pg_conn, pk)
def test_terminate_process_no_ckp(pg_conn):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
vhc = create_vehicle(pg_conn, 'UUU0000')
pk = create_process(pg_conn)
time.sleep(0.01)
update_process(pg_conn, pk, ctc, orig, dest, None, vhc)
with pytest.raises(Exception):
terminate_process(pg_conn, pk)
def test_terminate_process_no_ctc(pg_conn):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ckp = create_checkpoint(pg_conn, 'Gate 1')
vhc = create_vehicle(pg_conn, 'UUU0000')
pk = create_process(pg_conn)
time.sleep(0.01)
update_process(pg_conn, pk, None, orig, dest, ckp, vhc)
with pytest.raises(Exception):
terminate_process(pg_conn, pk)
def test_terminate_process_no_vhc(pg_conn):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
ckp = create_checkpoint(pg_conn, 'Gate 1')
pk = create_process(pg_conn)
time.sleep(0.01)
update_process(pg_conn, pk, ctc, orig, dest, ckp, None)
terminate_process(pg_conn, pk)
rs = retrieve_processes_by_ids(pg_conn, (pk,))
assert rs[0]['finished_at']
def test_create_process_auth_events_on_finished_process_err(pg_conn):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
ckp = create_checkpoint(pg_conn, 'Gate 1')
vhc = create_vehicle(pg_conn, 'UUU0000')
proc_id = create_process(pg_conn)
time.sleep(0.1)
update_process(pg_conn, proc_id, ctc, orig, dest, ckp, vhc)
terminate_process(pg_conn, proc_id)
with pytest.raises(Exception):
create_process_auth_event(pg_conn, proc_id, 0, 'sys/none')
def test_update_process_finished_err(pg_conn):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
ckp = create_checkpoint(pg_conn, 'Gate 1')
vhc = create_vehicle(pg_conn, 'UUU0000')
pk = create_process(pg_conn)
time.sleep(0.01)
update_process(pg_conn, pk, ctc, orig, dest, ckp, vhc)
terminate_process(pg_conn, pk)
with pytest.raises(Exception):
update_process(pg_conn, pk, ctc, orig, dest, ckp, vhc)
def test_process_archive_with_unresolved_terminated_process_should_archive_none(
pg_conn):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
ckp = create_checkpoint(pg_conn, 'Gate 1')
vhc = create_vehicle(pg_conn, 'UUU0000')
pk = create_process(pg_conn)
time.sleep(0.1)
update_process(pg_conn, pk, ctc, orig, dest, ckp, vhc)
terminate_process(pg_conn, pk)
results = archive_finished_processes(pg_conn)
assert results == []
def test_terminate_process(pg_conn):
created_proc_id = dql_binds.create_process(pg_conn)
created_ctc_id = dql_binds.create_contact(pg_conn, 'Joe')
created_orig_id = dql_binds.create_location(pg_conn, 'Addr 1')
created_dest_id = dql_binds.create_location(pg_conn, 'Addr 2')
created_ckp_id = dql_binds.create_checkpoint(pg_conn, 'Gate 1')
result = dql_binds.update_process(pg_conn,
created_proc_id,
ctc=created_ctc_id,
loc_orig=created_orig_id,
loc_dest=created_dest_id,
ckp=created_ckp_id)
result = dql_binds.terminate_process(pg_conn, created_proc_id)
assert isinstance(result, datetime.datetime)
def test_process_archive_with_resolved_terminated_process_should_archive_two(
pg_conn, basic_flow):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
ckp = create_checkpoint(pg_conn, 'Gate 1')
vhc = create_vehicle(pg_conn, 'UUU0000')
pk0 = create_process(pg_conn)
time.sleep(0.1)
update_process(pg_conn, pk0, ctc, orig, dest, ckp, vhc)
create_process_auth_event(pg_conn, pk0, ctc, 'sys/acc')
terminate_process(pg_conn, pk0)
pk1 = create_process(pg_conn)
time.sleep(0.1)
update_process(pg_conn, pk1, ctc, orig, dest, ckp, vhc)
create_process_auth_event(pg_conn, pk1, ctc, 'sys/acc')
terminate_process(pg_conn, pk1)
results = archive_finished_processes(pg_conn)
assert results[0]['archived_proc_id'] == pk0
assert results[1]['archived_proc_id'] == pk1
def test_retrieve_process_histories_by_ids_flow(pg_conn, basic_flow):
pk = create_process(pg_conn)
update_process_auth_flow(pg_conn, pk, basic_flow)
create_process_auth_event(pg_conn, pk, 0, 'sys/0001')
rs = retrieve_process_histories_by_ids(pg_conn, (pk,))
assert [r['curr_auth_flow_st'] for r in rs] == ['sys/0001']
create_process_auth_event(pg_conn, pk, 0, 'sys/0002')
rs = retrieve_process_histories_by_ids(pg_conn, (pk,))
assert [r['curr_auth_flow_st'] for r in rs] == ['sys/0001', 'sys/0002']
create_process_auth_event(pg_conn, pk, 0, 'sys/0003')
rs = retrieve_process_histories_by_ids(pg_conn, (pk,))
assert [r['curr_auth_flow_st'] for r in rs] == ['sys/0001', 'sys/0002', 'sys/0003']
def test_update_process(pg_conn):
orig = create_location(pg_conn, 'Origin')
dest = create_location(pg_conn, 'Dest')
ctc = create_contact(pg_conn, 'Subject')
ckp = create_checkpoint(pg_conn, 'Gate 1')
vhc = create_vehicle(pg_conn, 'UUU0000')
pk = create_process(pg_conn)
update_process(pg_conn, pk, ctc, orig, dest, ckp, vhc)
rs = retrieve_processes_by_ids(pg_conn, (pk,))
assert len(rs) == 1
assert rs[0]['proc_id'] == pk
assert rs[0]['ctc'] == ctc
assert rs[0]['vhc'] == vhc
assert rs[0]['ckp'] == ckp
assert rs[0]['loc_orig'] == orig
assert rs[0]['loc_dest'] == dest
def test_retrieve_process_histories_by_ids(pg_conn):
dql_binds.create_auth_level(pg_conn, 'sys/acc', auth_grant=True)
dql_binds.create_auth_flow_st(pg_conn, 0, 'sys/acc', st_term=True)
dql_binds.create_auth_flow_tr(pg_conn, 0, 'sys/acc', 'sys/none', 'sys/acc')
created_proc_id = dql_binds.create_process(pg_conn)
ctc = dql_binds.create_contact(pg_conn, 'Joe')
loc_orig = dql_binds.create_location(pg_conn, 'Addr 1')
loc_dest = dql_binds.create_location(pg_conn, 'Addr 2')
ckp = dql_binds.create_checkpoint(pg_conn, 'Gate 1')
dql_binds.update_process(pg_conn,
created_proc_id,
ctc=ctc,
loc_orig=loc_orig,
loc_dest=loc_dest,
ckp=ckp)
dql_binds.create_process_auth_event(pg_conn, created_proc_id, ctc,
'sys/acc')
result = dql_binds.retrieve_process_histories_by_ids(
pg_conn, (created_proc_id, ))
assert result
def test_archive_finished_processes(pg_conn):
dql_binds.create_auth_level(pg_conn, 'sys/acc', auth_grant=True)
dql_binds.create_auth_flow_st(pg_conn, 0, 'sys/acc', st_term=True)
dql_binds.create_auth_flow_tr(pg_conn, 0, 'sys/acc', 'sys/none', 'sys/acc')
created_proc_id = dql_binds.create_process(pg_conn)
ctc = dql_binds.create_contact(pg_conn, 'Joe')
loc_orig = dql_binds.create_location(pg_conn, 'Addr 1')
loc_dest = dql_binds.create_location(pg_conn, 'Addr 2')
ckp = dql_binds.create_checkpoint(pg_conn, 'Gate 1')
dql_binds.update_process(pg_conn,
created_proc_id,
ctc=ctc,
loc_orig=loc_orig,
loc_dest=loc_dest,
ckp=ckp)
dql_binds.create_process_auth_event(pg_conn, created_proc_id, ctc,
'sys/acc')
time.sleep(0.1)
dql_binds.terminate_process(pg_conn, created_proc_id)
result = dql_binds.archive_finished_processes(pg_conn)
assert result
def test_retrieve_processes_by_ids(pg_conn):
pks = [create_process(pg_conn), create_process(pg_conn), create_process(pg_conn), create_process(pg_conn)]
rs = retrieve_processes_by_ids(pg_conn, tuple(pks))
assert len(rs) == 4
assert [r['proc_id'] for r in rs] == pks
def test_create_process(pg_conn):
pk = create_process(pg_conn)
rs = retrieve_processes_by_ids(pg_conn, (pk,))
assert len(rs) == 1
assert rs[0]['proc_id'] == pk
