def test_pending_request_queue():
missing_resource_1 = mr.MissingLinkCapacity(1)
supplied_resource_1 = sr.SuppliedLinkCapacity(1)
missing_resource_2 = mr.MissingFlowData([support.Range(1, 3, 1)])
supplied_resource_2_1 = sr.SuppliedFlowData(support.Range(3, 5, 1))
supplied_resource_2_2 = sr.SuppliedFlowData(support.Range(1, 3, 1))
pending_request_queue = pending_requests.PendingRequestQueue()
pending_request_queue.add_pending_request(
None, "req_msg1", [missing_resource_1, missing_resource_2])
pending_request_queue.add_pending_request(None, "req_msg2",
[missing_resource_1])
#Not empty
run_tests.compare_answer(
pending_request_queue.get_ready_to_be_handled_requests(), [],
"Check to see if no requests initially are ready")
run_tests.compare_answer(
len(pending_request_queue.pending_requests), 2,
"Check to see if both requests are still there initially")
#Supply 1
pending_request_queue.process_supplied_resource(supplied_resource_1)
requests = pending_request_queue.get_ready_to_be_handled_requests()
run_tests.compare_answer(
len(requests), 1,
"Check to see one request is ready after first supply")
run_tests.compare_answer(requests[0].request_message, "req_msg2",
"Check to see if correct message is ready req1")
run_tests.compare_answer(
len(pending_request_queue.pending_requests), 1,
"Check to see if last request is still there after first supply")
#Supply 2_1
pending_request_queue.process_supplied_resource(supplied_resource_2_1)
requests = pending_request_queue.get_ready_to_be_handled_requests()
run_tests.compare_answer(
len(requests), 0,
"Check to see if zero requests are ready after second supply")
run_tests.compare_answer(
len(pending_request_queue.pending_requests), 1,
"Check to see if last request is still there after second supply")
#Supply 2_2
pending_request_queue.process_supplied_resource(supplied_resource_2_2)
requests = pending_request_queue.get_ready_to_be_handled_requests()
run_tests.compare_answer(
len(requests), 1,
"Check to see one request is ready after third supply")
run_tests.compare_answer(requests[0].request_message, "req_msg1",
"Check to see if correct message is ready req2")
run_tests.compare_answer(
len(pending_request_queue.pending_requests), 0,
"Check to see if no request is still there after third supply")
def test_reduce_to_missing_ranges():
l1 = [1, 2, 10, 40, 41, 50]
answer1 = [support.Range(3, 9, 1), support.Range(11, 39, 1), support.Range(42, 49, 1)]
result1 = support.reduce_to_missing_ranges(l1, lambda x: x, 1, 1, 50)
run_tests.compare_answer(result1, answer1, "missing_support.Ranges 1")
#Difficult one because one value is outside of the (start value, end value) support.Range while the resolution allows it
l2 = [9, 11]
answer2 = [support.Range(1, 6, 3), support.Range(10, 10, 3)]
result2 = support.reduce_to_missing_ranges(l2, lambda x: x, 3, 1, 10)
run_tests.compare_answer(result2, answer2, "missing_ranges 2")
def from_maas_user_info_message_to_supplied_info(msg):
supplied_resource = None
if msg.time_span > 0:
start_date_time = datetime.datetime.combine(msg.start_date, msg.start_time)
end_date_time = start_date_time + datetime.timedelta(seconds=msg.time_span)
supplied_range = support.Range(start_date_time, end_date_time, support.Range.RESOLUTION_DATETIME_MINUTE)
supplied_resource = SuppliedUserInfo(supplied_range)
return supplied_resource
def test_pending_request():
missing_resource_1 = mr.MissingLinkCapacity(1)
supplied_resource_1 = sr.SuppliedLinkCapacity(1)
missing_resource_2 = mr.MissingFlowData([support.Range(1, 3, 1)])
supplied_resource_2_1 = sr.SuppliedFlowData(support.Range(3, 5, 1))
supplied_resource_2_2 = sr.SuppliedFlowData(support.Range(1, 3, 1))
pending_request = pending_requests.PendingRequest(
None, "req_msg", [missing_resource_1, missing_resource_2])
#Not empty
run_tests.compare_answer(pending_request.ready_to_be_handled(), False,
"Check if request not be handled after filled")
run_tests.compare_answer(len(pending_request.missing_resources.items()), 2,
"Check to see if both are added")
#Supply 1
pending_request.process_supplied_resource(supplied_resource_1)
run_tests.compare_answer(
pending_request.ready_to_be_handled(), False,
"Check if request not be handled after first supply")
run_tests.compare_answer(len(pending_request.missing_resources.items()), 1,
"Check to see if one still exists")
#Supply 2_1
pending_request.process_supplied_resource(supplied_resource_2_1)
run_tests.compare_answer(
pending_request.ready_to_be_handled(), False,
"Check if request not be handled after second supply")
run_tests.compare_answer(len(pending_request.missing_resources.items()), 1,
"Check to see if one still exists")
#Supply 2_2
pending_request.process_supplied_resource(supplied_resource_2_2)
run_tests.compare_answer(pending_request.ready_to_be_handled(), True,
"Check if request be handled after third supply")
run_tests.compare_answer(len(pending_request.missing_resources.items()), 0,
"Check to see if none still exist")
def test_missing_flow_data():
missing_ranges = [support.Range(1, 5, 1), support.Range(8, 10, 1)]
missing_resource = mr.MissingFlowData(missing_ranges)
supplied_range1 = support.Range(3, 5, 1)
supplied_range2 = support.Range(6, 9, 1)
supplied_resource1 = sr.SuppliedFlowData(supplied_range1)
supplied_resource2 = sr.SuppliedFlowData(supplied_range2)
#Not empty
run_tests.compare_answer(missing_resource.is_not_missing_anything(), False,
"Test empty after filled")
#Applied first
missing_resource.update_missing_from_supplied_info(supplied_resource1)
now_missing_ranges1 = missing_resource.missing
run_tests.compare_answer(now_missing_ranges1,
[support.Range(1, 2, 1),
support.Range(8, 10, 1)],
"Test missing after first supplied")
#Applied second
missing_resource.update_missing_from_supplied_info(supplied_resource2)
now_missing_ranges2 = missing_resource.missing
run_tests.compare_answer(
now_missing_ranges2,
[support.Range(1, 2, 1),
support.Range(10, 10, 1)], "Test missing after second supplied")
#Dismiss all and test empty
supplied_range_dismiss = support.Range(1, 10, 1)
supplied_resource_dismiss = sr.SuppliedFlowData(supplied_range_dismiss)
missing_resource.update_missing_from_supplied_info(
supplied_resource_dismiss)
now_missing_ranges_dismiss = missing_resource.missing
run_tests.compare_answer(now_missing_ranges_dismiss, [],
"Test if missing list is now empty")
run_tests.compare_answer(
missing_resource.is_not_missing_anything(), True,
"Test to see if missing resource is not missing anything")
def check_user_mobility_data_single_user_integrity(
grouped_by_date_grid_by_minute_of_day_mp_fetched, current_date):
missing_ranges_date_time_date_time = []
current_unix_days = support.date_to_unix_days_timestamp(current_date)
history_unix_days = current_unix_days - config.MP_USE_DATA_FROM_LAST_DAYS
current_unix_week = int(current_unix_days / common_config.DAYS_IN_A_WEEK)
history_unix_week = int(history_unix_days / common_config.DAYS_IN_A_WEEK)
#Find missing weeks
all_weeks = map(lambda x: support.date_to_unix_weeks_timestamp(x),
grouped_by_date_grid_by_minute_of_day_mp_fetched.keys())
missing_ranges_unix_weeks = support.reduce_to_missing_ranges(
all_weeks, lambda i: i, 1, history_unix_week, current_unix_week)
missing_ranges_date = map(
lambda x: support.Range(
support.unix_weeks_timestamp_to_date_range(x.min_range).min_range,
support.unix_weeks_timestamp_to_date_range(x.max_range).max_range,
support.Range.RESOLUTION_DATETIME_DAY), missing_ranges_unix_weeks)
#Add the missing days
begin_of_day_time = datetime.time(0, 0, 0)
end_of_day_time = datetime.time(23, 59, 59)
for missing_range_date in missing_ranges_date:
start_date_time = datetime.datetime.combine(
missing_range_date.min_range, begin_of_day_time)
end_date_time = datetime.datetime.combine(missing_range_date.max_range,
end_of_day_time)
missing_ranges_date_time_date_time.append(
support.Range(start_date_time, end_date_time,
support.Range.RESOLUTION_DATETIME_MINUTE))
#Calculate the missing time ranges in each day that already exists
for date, grid_by_minute_of_day_mp_fetched in grouped_by_date_grid_by_minute_of_day_mp_fetched.items(
):
missing_ranges_in_minutes = support.reduce_to_missing_ranges_already_grid(
grid_by_minute_of_day_mp_fetched, 1, 0,
common_config.MINUTES_IN_A_DAY - 1)
missing_ranges_in_time = map(
lambda missing_range: support.Range(
support.calc_time_from_minute_of_day(missing_range.min_range),
support.calc_time_from_minute_of_day(missing_range.max_range),
support.Range.RESOLUTION_DATETIME_SECOND),
missing_ranges_in_minutes)
#Add the missing times for a certain day
for missing_range_in_time in missing_ranges_in_time:
start_date_time = datetime.datetime.combine(
date, missing_range_in_time.min_range)
end_date_time = datetime.datetime.combine(
date, missing_range_in_time.max_range)
missing_ranges_date_time_date_time.append(
support.Range(start_date_time, end_date_time,
support.Range.RESOLUTION_DATETIME_MINUTE))
return missing_ranges_date_time_date_time
def from_bp_fetched_list_to_supplied_info(bp_fetched):
times = map(lambda x: x.time, bp_fetched)
min_time = min(*times)
max_time = max(*times)
return SuppliedFlowData(support.Range(min_time, max_time, 1))
def test_ranges_other_overlaps_right_border():
#Same range
run_tests.compare_answer(support.Range(1,3,1).other_overlaps_right_border(support.Range(1,3,1)), False, "Test ranges other overlaps right border (1,3) and (1,3)")
#Right border overlap
run_tests.compare_answer(support.Range(1,3,1).other_overlaps_right_border(support.Range(2,4,1)), True, "Test ranges other overlaps right border (1,3) and (2,4)")
#Left border overlap
run_tests.compare_answer(support.Range(3,5,1).other_overlaps_right_border(support.Range(1,4,1)), False, "Test ranges other overlaps right border (3,5) and (1,4)")
#No overlap
run_tests.compare_answer(support.Range(1,3,1).other_overlaps_right_border(support.Range(4,6,1)), False, "Test ranges other overlaps right border (1,3) and (4,6)")
#Falls in
run_tests.compare_answer(support.Range(2,6,1).other_overlaps_right_border(support.Range(3,4,1)), False, "Test ranges other overlaps right border (2,6) and (3,4)")
#Complete overlap
run_tests.compare_answer(support.Range(3,4,1).other_overlaps_right_border(support.Range(2,6,1)), False, "Test ranges other overlaps right border (2,6) and (3,4)")
def test_ranges_has_overlap():
#Same ranges
run_tests.compare_answer(support.Range(1,3,1).has_overlap(support.Range(1,3,1)), True, "Test ranges has overlap (1,3) and (1,3)")
#Right border overlap
run_tests.compare_answer(support.Range(1,3,1).has_overlap(support.Range(2,4,1)), True, "Test ranges has overlap (1,3) and (2,4)")
run_tests.compare_answer(support.Range(1,2,1).has_overlap(support.Range(2,4,1)), True, "Test ranges has overlap (1,2) and (2,4)")
#Left border overlap
run_tests.compare_answer(support.Range(3,5,1).has_overlap(support.Range(1,4,1)), True, "Test ranges has overlap (3,5) and (1,4)")
run_tests.compare_answer(support.Range(3,5,1).has_overlap(support.Range(1,3,1)), True, "Test ranges has overlap (3,5) and (1,3)")
#Complete overlap
run_tests.compare_answer(support.Range(3,5,1).has_overlap(support.Range(2,6,1)), True, "Test ranges has overlap (3,5) and (2,6)")
run_tests.compare_answer(support.Range(3,5,1).has_overlap(support.Range(3,5,1)), True, "Test ranges has overlap (3,5) and (3,5)")
#Falls in
run_tests.compare_answer(support.Range(2,6,1).has_overlap(support.Range(3,4,1)), True, "Test ranges has overlap (2,6) and (3,4)")
#No overlap
run_tests.compare_answer(support.Range(1,3,1).has_overlap(support.Range(4,6,1)), False, "Test ranges has overlap (1,3) and (4,6)")
run_tests.compare_answer(support.Range(4,6,1).has_overlap(support.Range(1,3,1)), False, "Test ranges has overlap (4,6) and (1,3)")
def test_ranges_sub():
#Same ranges
run_tests.compare_answer(support.Range(1,3,1) - support.Range(1,3,1), [], "Test ranges sub (1,3) - (1,3)")
#Right border overlap
run_tests.compare_answer(support.Range(1,3,1) - support.Range(2,4,1), [support.Range(1,1,1)], "Test ranges sub (1,3) - (2,4)")
run_tests.compare_answer(support.Range(1,2,1) - support.Range(2,4,1), [support.Range(1,1,1)], "Test ranges sub (1,2) - (2,4)")
#Left border overlap
run_tests.compare_answer(support.Range(3,5,1) - support.Range(1,4,1), [support.Range(5,5,1)], "Test ranges sub (3,5) - (1,4)")
run_tests.compare_answer(support.Range(3,5,1) - support.Range(1,3,1), [support.Range(4,5,1)], "Test ranges sub (3,5) - (1,3)")
#Complete overlap
run_tests.compare_answer(support.Range(3,5,1) - support.Range(2,6,1), [], "Test ranges sub (3,5) - (2,6)")
run_tests.compare_answer(support.Range(3,5,1) - support.Range(3,5,1), [], "Test ranges sub (3,5) - (3,5)")
#Falls in
run_tests.compare_answer(support.Range(2,6,1) - support.Range(3,4,1), [support.Range(2,2,1), support.Range(5,6,1)], "Test ranges sub (2,6) - (3,4)")
#Falls in but on a border so actually a border overlap
run_tests.compare_answer(support.Range(2,6,1) - support.Range(4,6,1), [support.Range(2,3,1)], "Test ranges sub (2,6) - (4,6)")
run_tests.compare_answer(support.Range(2,6,1) - support.Range(2,3,1), [support.Range(4,6,1)], "Test ranges sub (2,6) - (2,3)")
def test_ranges_add():
run_tests.compare_answer(support.Range(1,2,1) + support.Range(2,3,1), [support.Range(1,3,1)], "Testing ranges add (1,2) and (2,3)")
run_tests.compare_answer(support.Range(1,2,1) + support.Range(3,4,1), [support.Range(1,2,1), support.Range(3,4,1)], "Testing ranges add (1,2) and (3,4)")
run_tests.compare_answer(support.Range(2,3,1) + support.Range(1,2,1), [support.Range(1,3,1)], "Testing ranges add (2,3) and (1,2)")
run_tests.compare_answer(support.Range(1,2,1) + support.Range(1,2,1), [support.Range(1,2,1)], "Testing ranges add (1,2) and (1,2)")
