def test_confine_to_station(self): passenger = self.passenger order = create_test_order(passenger) confining_station = create_another_TLV_station() order.confining_station = confining_station order.save() # order, should get confining station resuscitate_work_stations() self.assertTrue( choose_workstation(order).station == confining_station, "confining station is expected") # order out of confining station service radius, should still assign the order order.from_lat, order.from_lon = FAR_AWAY_LAT, FAR_AWAY_LON order.to_lat, order.to_lon = None, None order.save() refresh_order(order) self.assertTrue( choose_workstation(order).station == confining_station, "confining station is expected") # create a REJECTED assignment by confining_station, should get None assignment = OrderAssignment( order=order, station=confining_station, work_station=confining_station.work_stations.all()[0], status=REJECTED) assignment.save() refresh_order(order) self.assertTrue( choose_workstation(order) is None, "no ws is expected.")
def test_choose_workstation_order_default_and_originating(self): """ Test the order when we have a default and an originating station """ order = self.order passenger = self.passenger tel_aviv_station = self.tel_aviv_station # should have 2 work stations (from fixtures) default_station = create_another_TLV_station(num_of_ws=2) originating_station = create_another_TLV_station(num_of_ws=2) # set originating and default station order.originating_station = originating_station order.save() passenger.default_station = default_station passenger.save() order.passenger = passenger order.save() resuscitate_work_stations() # round trip, in the following order for station in [originating_station ] * 2 + [default_station] * 2 + [tel_aviv_station] * 2: ws = choose_workstation(order) self.assertTrue( ws.station == station, "wrong station order: expected %s got %s" % (station, ws.station)) # order should return to originating_station ws = choose_workstation(order) self.assertTrue(ws.station == originating_station, "originating station is expected")
def _run_ignored_or_rejected_test(self, status): order = self.order tel_aviv = self.tel_aviv_station tel_aviv_ws1 = tel_aviv.work_stations.all()[0] tel_aviv_ws2 = tel_aviv.work_stations.all()[1] tel_aviv_2 = create_another_TLV_station() tel_aviv_ws3 = tel_aviv_2.work_stations.all()[0] resuscitate_work_stations() # create an IGNORED/REJECTED assignment by first station (ws1, ws2), should get ws3 assignment = OrderAssignment(order=order, station=tel_aviv, work_station=tel_aviv_ws1, status=status) assignment.save() ws_list = compute_ws_list(order) self.assertTrue( tel_aviv_ws1 not in ws_list and tel_aviv_ws2 not in ws_list, "this station ignored the order.") next_ws = choose_workstation(order) self.assertTrue(next_ws == tel_aviv_ws3, "tel aviv ws3 is expected.") # create an IGNORED/REJECTED assignment by ws3, should get None assignment = OrderAssignment(order=order, station=tel_aviv_2, work_station=tel_aviv_ws3, status=status) assignment.save() refresh_order(order) self.assertTrue( choose_workstation(order) is None, "no ws is expected.")
def test_choose_workstation_order_default_and_originating(self): """ Test the order when we have a default and an originating station """ order = self.order passenger = self.passenger tel_aviv_station = self.tel_aviv_station # should have 2 work stations (from fixtures) default_station = create_another_TLV_station(num_of_ws=2) originating_station = create_another_TLV_station(num_of_ws=2) # set originating and default station order.originating_station = originating_station order.save() passenger.default_station = default_station passenger.save() order.passenger = passenger order.save() resuscitate_work_stations() # round trip, in the following order for station in [originating_station]*2 + [default_station]*2 + [tel_aviv_station]*2: ws = choose_workstation(order) self.assertTrue(ws.station == station, "wrong station order: expected %s got %s" % (station, ws.station)) # order should return to originating_station ws = choose_workstation(order) self.assertTrue(ws.station == originating_station, "originating station is expected")
def test_choose_workstation_basics(self): order = self.order tel_aviv_ws1 = self.tel_aviv_station.work_stations.all()[0] tel_aviv_ws2 = self.tel_aviv_station.work_stations.all()[1] jerusalem_ws = self.jerusalem_station.work_stations.all()[0] # work stations are dead self.assertTrue( choose_workstation(order) is None, "work station are dead, none is expected") # live work station but it's in Jerusalem (order is from tel aviv) jerusalem_ws.is_online = True jerusalem_ws.save() self.assertTrue( choose_workstation(order) is None, "work station are dead, none is expected") refresh_order(order) # live but don't accept orders set_accept_orders_false([tel_aviv_ws1, tel_aviv_ws2]) resuscitate_work_stations() self.assertTrue( choose_workstation(order) is None, "don't accept orders, none is expected.") refresh_order(order) # tel_aviv_ws2 is live and accepts orders set_accept_orders_true([tel_aviv_ws2]) resuscitate_work_stations() self.assertTrue( choose_workstation(order) == tel_aviv_ws2, "tel aviv work station 2 is expected.") refresh_order(order)
def _run_ignored_or_rejected_test(self, status): order = self.order tel_aviv = self.tel_aviv_station tel_aviv_ws1 = tel_aviv.work_stations.all()[0] tel_aviv_ws2 = tel_aviv.work_stations.all()[1] tel_aviv_2 = create_another_TLV_station() tel_aviv_ws3 = tel_aviv_2.work_stations.all()[0] resuscitate_work_stations() # create an IGNORED/REJECTED assignment by first station (ws1, ws2), should get ws3 assignment = OrderAssignment(order=order, station=tel_aviv, work_station=tel_aviv_ws1, status=status) assignment.save() ws_list = compute_ws_list(order) self.assertTrue(tel_aviv_ws1 not in ws_list and tel_aviv_ws2 not in ws_list, "this station ignored the order.") next_ws = choose_workstation(order) self.assertTrue(next_ws == tel_aviv_ws3, "tel aviv ws3 is expected.") # create an IGNORED/REJECTED assignment by ws3, should get None assignment = OrderAssignment(order=order, station=tel_aviv_2, work_station=tel_aviv_ws3, status=status) assignment.save() refresh_order(order) self.assertTrue(choose_workstation(order) is None, "no ws is expected.")
def test_choose_workstation_basics(self): order = self.order tel_aviv_ws1 = self.tel_aviv_station.work_stations.all()[0] tel_aviv_ws2 = self.tel_aviv_station.work_stations.all()[1] jerusalem_ws = self.jerusalem_station.work_stations.all()[0] # work stations are dead self.assertTrue(choose_workstation(order) is None, "work station are dead, none is expected") # live work station but it's in Jerusalem (order is from tel aviv) jerusalem_ws.is_online = True jerusalem_ws.save() self.assertTrue(choose_workstation(order) is None, "work station are dead, none is expected") refresh_order(order) # live but don't accept orders set_accept_orders_false([tel_aviv_ws1, tel_aviv_ws2]) resuscitate_work_stations() self.assertTrue(choose_workstation(order) is None, "don't accept orders, none is expected.") refresh_order(order) # tel_aviv_ws2 is live and accepts orders set_accept_orders_true([tel_aviv_ws2]) resuscitate_work_stations() self.assertTrue(choose_workstation(order) == tel_aviv_ws2, "tel aviv work station 2 is expected.") refresh_order(order)
def test_dispatcher_sort_by_distance(self): order = self.order tel_aviv_station = self.tel_aviv_station resuscitate_work_stations() self.assertEqual(choose_workstation(order).station, tel_aviv_station) refresh_order(order) another_station = create_another_TLV_station() # create a closer station to order resuscitate_work_stations() self.assertEqual(choose_workstation(order).station, another_station) self.assertEqual(choose_workstation(order).station, tel_aviv_station)
def test_originating_station(self): passenger = self.passenger order = create_test_order(passenger) tel_aviv_station = self.tel_aviv_station originating_station = create_another_TLV_station() order.originating_station = originating_station order.save() # set the originating station self.client.post(reverse('ordering.order_manager.book_order'), data={"order_id": order.id}) passenger = Passenger.objects.get(id=passenger.id) # refresh passenger self.assertTrue( passenger.originating_station == originating_station, "passenger.originating_station should be tel_aviv_station and not %s" % passenger.originating_station) refresh_order(order) # resuscitate work stations and order resuscitate_work_stations() self.assertTrue( choose_workstation(order).station == originating_station, "originating station is expected") # check originating station overrides last assignment date criteria tel_aviv_station.last_assignment_date = datetime.datetime.now() tel_aviv_station.save() refresh_order(order) self.assertTrue( choose_workstation(order).station == originating_station, "originating station is expected") # test same originating and default stations results in one assignment passenger.default_station = originating_station passenger.save() order = refresh_order(order) order.passenger = passenger order.save() self.assertTrue( order.passenger.default_station == order.originating_station, "originating and default stations are not the same") resuscitate_work_stations() ws_list = compute_ws_list(order) count = ws_list.count(originating_station.work_stations.all()[0]) self.assertTrue( count == 1, "originating (==default) station should appear exactly once (got %d)" % count)
def test_dispatcher_sort_by_distance(self): order = self.order tel_aviv_station = self.tel_aviv_station resuscitate_work_stations() self.assertEqual(choose_workstation(order).station, tel_aviv_station) refresh_order(order) another_station = create_another_TLV_station( ) # create a closer station to order resuscitate_work_stations() self.assertEqual(choose_workstation(order).station, another_station) self.assertEqual(choose_workstation(order).station, tel_aviv_station)
def test_choose_workstation_order(self): order = self.order resuscitate_work_stations() station1 = self.tel_aviv_station # should have 2 work stations (from fixtures) station2 = create_another_TLV_station(num_of_ws=2) resuscitate_work_stations() ws_list = compute_ws_list(order) # stations should alternate self.assertTrue( ws_list[0].station == ws_list[2].station and ws_list[1].station == ws_list[3].station, "stations should alternate") # work stations should alternate self.assertTrue(ws_list[0] != ws_list[2] and ws_list[1] != ws_list[3], "work stations should alternate") # # scenario: station x -> station y (reject) -> station x # order = create_test_order() first_ws = choose_workstation(order) second_ws = choose_workstation(order) assignment = OrderAssignment(order=order, station=second_ws.station, work_station=second_ws, status=REJECTED) assignment.save() refresh_order(order) third_ws = choose_workstation(order) self.assertTrue(third_ws.station == first_ws.station) # # scenario: station x -> station y (not taken) -> station x -> station y other ws # order = create_test_order() first_ws = choose_workstation(order) second_ws = choose_workstation(order) assignment = OrderAssignment(order=order, station=second_ws.station, work_station=second_ws, status=NOT_TAKEN) assignment.save() third_ws = choose_workstation(order) fourth_ws = choose_workstation(order) self.assertTrue(second_ws.station == fourth_ws.station and second_ws != fourth_ws)
def test_default_station(self): order = self.order passenger = self.passenger tel_aviv_station = self.tel_aviv_station default_station = create_another_TLV_station() passenger.default_station = default_station passenger.save() order.passenger = passenger order.save() # resuscitate work stations and order resuscitate_work_stations() self.assertTrue(choose_workstation(order).station == default_station, "default station is expected.") # check default station overrides last assignment date criteria tel_aviv_station.last_assignment_date = datetime.datetime.now() tel_aviv_station.save() refresh_order(order) self.assertTrue(choose_workstation(order).station == default_station, "default station is expected")
def test_originating_station(self): passenger = self.passenger order = create_test_order(passenger) tel_aviv_station = self.tel_aviv_station originating_station = create_another_TLV_station() order.originating_station = originating_station order.save() # set the originating station self.client.post(reverse('ordering.order_manager.book_order'), data={"order_id": order.id}) passenger = Passenger.objects.get(id=passenger.id) # refresh passenger self.assertTrue(passenger.originating_station == originating_station, "passenger.originating_station should be tel_aviv_station and not %s" % passenger.originating_station) refresh_order(order) # resuscitate work stations and order resuscitate_work_stations() self.assertTrue(choose_workstation(order).station == originating_station, "originating station is expected") # check originating station overrides last assignment date criteria tel_aviv_station.last_assignment_date = datetime.datetime.now() tel_aviv_station.save() refresh_order(order) self.assertTrue(choose_workstation(order).station == originating_station, "originating station is expected") # test same originating and default stations results in one assignment passenger.default_station = originating_station passenger.save() order = refresh_order(order) order.passenger = passenger order.save() self.assertTrue(order.passenger.default_station == order.originating_station, "originating and default stations are not the same") resuscitate_work_stations() ws_list = compute_ws_list(order) count = ws_list.count(originating_station.work_stations.all()[0]) self.assertTrue(count == 1, "originating (==default) station should appear exactly once (got %d)" % count)
def test_default_station(self): order = self.order passenger = self.passenger tel_aviv_station = self.tel_aviv_station default_station = create_another_TLV_station() passenger.default_station = default_station passenger.save() order.passenger = passenger order.save() # resuscitate work stations and order resuscitate_work_stations() self.assertTrue( choose_workstation(order).station == default_station, "default station is expected.") # check default station overrides last assignment date criteria tel_aviv_station.last_assignment_date = datetime.datetime.now() tel_aviv_station.save() refresh_order(order) self.assertTrue( choose_workstation(order).station == default_station, "default station is expected")
def test_confine_to_station(self): passenger = self.passenger order = create_test_order(passenger) confining_station = create_another_TLV_station() order.confining_station = confining_station order.save() # order, should get confining station resuscitate_work_stations() self.assertTrue(choose_workstation(order).station == confining_station, "confining station is expected") # order out of confining station service radius, should still assign the order order.from_lat, order.from_lon = FAR_AWAY_LAT, FAR_AWAY_LON order.to_lat, order.to_lon = None, None order.save() refresh_order(order) self.assertTrue(choose_workstation(order).station == confining_station, "confining station is expected") # create a REJECTED assignment by confining_station, should get None assignment = OrderAssignment(order=order, station=confining_station, work_station=confining_station.work_stations.all()[0], status=REJECTED) assignment.save() refresh_order(order) self.assertTrue(choose_workstation(order) is None, "no ws is expected.")
def test_choose_workstation_order(self): order = self.order resuscitate_work_stations() station1 = self.tel_aviv_station # should have 2 work stations (from fixtures) station2 = create_another_TLV_station(num_of_ws=2) resuscitate_work_stations() ws_list = compute_ws_list(order) # stations should alternate self.assertTrue(ws_list[0].station == ws_list[2].station and ws_list[1].station == ws_list[3].station, "stations should alternate") # work stations should alternate self.assertTrue(ws_list[0] != ws_list[2] and ws_list[1] != ws_list[3], "work stations should alternate") # # scenario: station x -> station y (reject) -> station x # order = create_test_order() first_ws = choose_workstation(order) second_ws = choose_workstation(order) assignment = OrderAssignment(order=order, station=second_ws.station, work_station=second_ws, status=REJECTED) assignment.save() refresh_order(order) third_ws = choose_workstation(order) self.assertTrue(third_ws.station == first_ws.station) # # scenario: station x -> station y (not taken) -> station x -> station y other ws # order = create_test_order() first_ws = choose_workstation(order) second_ws = choose_workstation(order) assignment = OrderAssignment(order=order, station=second_ws.station, work_station=second_ws, status=NOT_TAKEN) assignment.save() third_ws = choose_workstation(order) fourth_ws = choose_workstation(order) self.assertTrue(second_ws.station == fourth_ws.station and second_ws != fourth_ws)