def update_lease_wrapper(self, reservation: ReservationClient,
rtype: ResourceType, units: int,
cs: ABCConcreteSet, term: Term):
if reservation.state == ReservationStates.Ticketed:
reservation.leased_resources = reservation.resources.abstract_clone(
)
reservation.leased_resources.units = units
reservation.leased_resources.type = rtype
reservation.leased_resources.set_resources(cset=cs)
reservation.previous_lease_term = None
reservation.previous_term = reservation.term
reservation.lease_term = term.clone()
reservation.term = reservation.lease_term
reservation.transition(prefix="redeem",
state=ReservationStates.Active,
pending=ReservationPendingStates.None_)
else:
reservation.leased_resources.units = units
reservation.leased_resources.type = rtype
reservation.leased_resources.resources.change(concrete_set=cs,
configure=False)
reservation.previous_lease_term = reservation.requested_term
reservation.previous_term = reservation.term
reservation.lease_term = term.clone()
reservation.term = reservation.lease_term
reservation.transition(prefix="redeem",
state=ReservationStates.Active,
pending=ReservationPendingStates.None_)
def update_ticket_wrapper(self, reservation: ReservationClient,
rtype: ResourceType, units: int, ticket: Ticket,
term: Term):
if reservation.state == ReservationStates.Nascent:
reservation.resources = reservation.get_approved_resources(
).abstract_clone()
reservation.resources.units = units
reservation.resources.type = rtype
reservation.resources.set_resources(cset=ticket)
reservation.previous_ticket_term = None
reservation.previous_term = None
reservation.term = term.clone()
reservation.ticket_term = reservation.term
reservation.transition(prefix="ticket",
state=ReservationStates.Ticketed,
pending=ReservationPendingStates.None_)
else:
reservation.resources.units = units
reservation.resources.type = rtype
reservation.resources.resources.change(concrete_set=ticket,
configure=False)
reservation.previous_term = reservation.term
reservation.previous_ticket_term = reservation.ticket_term
reservation.term = term.clone()
reservation.ticket_term = reservation.term
reservation.transition(prefix="extendticket",
state=ReservationStates.ActiveTicketed,
pending=ReservationPendingStates.None_)
def get_authority(self,
name: str = BaseTestCase.authority_name,
guid: ID = BaseTestCase.authority_guid):
authority = self.get_registered_new_actor()
authority.set_recovered(value=True)
Term.set_clock(clock=authority.get_actor_clock())
return authority
def get_authority(self, name: str = BaseTestCase.authority_name, guid: ID = BaseTestCase.authority_guid):
db = self.get_container_database()
db.reset_db()
authority = super().get_authority()
authority.set_recovered(value=True)
authority.set_aggregate_resource_model(aggregate_resource_model=self.arm)
authority.get_plugin().handler_processor.add_config_mapping(mapping=self.get_config_map())
Term.set_clock(authority.get_actor_clock())
return authority
def check_not_valid(self, *, term: Term):
failed = False
try:
term.validate()
except Exception:
failed = True
self.assertTrue(failed)
def get_broker(self,
*,
name: str = BaseTestCase.broker_name,
guid: ID = BaseTestCase.broker_guid) -> ABCBrokerMixin:
db = self.get_container_database()
db.reset_db()
self.broker = super().get_broker()
self.broker.set_recovered(value=True)
Term.set_clock(self.broker.get_actor_clock())
return self.broker
def test_equals(self):
start = 1000
end = 1499
length = 500
t = Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t, start=start, new_start=start, end=end)
self.assertEqual(length, t.get_length())
self.assertTrue(t == t)
t1 = Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t1, start=start, new_start=start, end=end)
self.assertEqual(length, t1.get_length())
t2 = Term(start=ActorClock.from_milliseconds(milli_seconds=start + 100),
end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t2, start=start + 100, new_start=start + 100, end=end)
self.assertEqual(length - 100, t2.get_length())
self.assertTrue(t == t1)
self.assertFalse(t == t2)
self.assertFalse(t == 11)
class Abc:
def __init__(self):
self.num = 1
self.assertFalse(t == Abc())
def test_change(self):
start = 1000
end = 1499
length = 500
t = Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t, start=start, new_start=start, end=end)
self.assertEqual(length, t.get_length())
t1 = t.change_length(length=2 * length)
self.check(term=t1, start=start, new_start=start, end=end+length)
self.assertEqual(length * 2, t1.get_length())
t1 = t.change_length(length=int(length/2))
self.check(term=t1, start=start, new_start=start, end=int(end - length/2))
self.assertEqual(length / 2, t1.get_length())
def test_c_fail(self):
controller = self.get_controller()
clock = controller.get_actor_clock()
Term.clock = clock
resources = ResourceSet(units=1, rtype=ResourceType(resource_type="1"))
slice_obj = SliceFactory.create(slice_id=ID(), name="fail")
controller.register_slice(slice_object=slice_obj)
start = 5
end = 10
term = Term(start=clock.cycle_start_date(cycle=start), end=clock.cycle_end_date(cycle=end))
r1 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj)
r1.set_renewable(renewable=False)
controller.register(reservation=r1)
controller.demand(rid=r1.get_reservation_id())
r2 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj)
r2.set_renewable(renewable=False)
controller.register(reservation=r2)
controller.demand(rid=r2.get_reservation_id())
for i in range(1, end + 3):
controller.external_tick(cycle=i)
while controller.get_current_cycle() != i:
time.sleep(0.001)
if i >= start and (i < (end - 1)):
self.assertTrue(r1.is_closed())
self.assertTrue(r2.is_closed())
self.assertTrue(r2.get_notices().__contains__(Constants.CLOSURE_BY_TICKET_REVIEW_POLICY))
def ticket(self, *, reservation: ABCBrokerReservation,
node_id_to_reservations: dict) -> Tuple[bool, dict, Any]:
self.logger.debug(
f"cycle: {self.actor.get_current_cycle()} new ticket request: "
f"{reservation}/{type(reservation).__name__}")
error_msg = None
start = self.align_start(
when=reservation.get_requested_term().get_new_start_time())
end = self.align_end(
when=reservation.get_requested_term().get_end_time())
resource_type = reservation.get_requested_resources().get_type()
if resource_type is None or not self.inventory.contains_type(
resource_type=resource_type):
resource_type = self.get_default_resource_type()
if resource_type is not None:
inv = self.inventory.get(resource_type=resource_type)
if inv is not None:
self.logger.debug(f"Inventory type: {type(inv)}")
term = Term(start=start, end=end)
return self.ticket_inventory(
reservation=reservation,
inv=inv,
term=term,
node_id_to_reservations=node_id_to_reservations)
else:
reservation.fail(message=Constants.NO_POOL)
else:
reservation.fail(message=Constants.NO_POOL)
return False, node_id_to_reservations, error_msg
def test_extend(self):
start_ms = 1000
end_ms = 1499
length_ms = 500
t = Term(start=ActorClock.from_milliseconds(milli_seconds=start_ms),
end=ActorClock.from_milliseconds(milli_seconds=end_ms))
self.assertEqual(length_ms, t.get_length())
self.check(term=t, start=start_ms, new_start=start_ms, end=end_ms)
# extend with same length
t1 = t.extend()
self.check(term=t1, start=start_ms, new_start=end_ms + 1, end=end_ms + length_ms)
self.assertEqual(length_ms, t1.get_length())
self.assertEqual(2 * length_ms, t1.get_full_length())
self.assertTrue(t1.extends_term(old_term=t))
# extend multiple times
for i in range(10):
t2 = t1.extend()
self.check(start=ActorClock.to_milliseconds(when=t1.get_start_time()),
new_start=ActorClock.to_milliseconds(when=t1.get_end_time()) + 1,
end=ActorClock.to_milliseconds(when=t1.get_end_time()) + length_ms,
term=t2)
self.assertEqual(length_ms, t2.get_length())
self.assertEqual(t1.get_full_length() + length_ms, t2.get_full_length())
self.assertTrue(t2.extends_term(old_term=t1))
t1 = t2
# extend with 1000
l = 1000
t1 = t.extend(length=l)
self.check(start=start_ms, new_start=end_ms+1, end=end_ms+l, term=t1)
self.assertEqual(l, t1.get_length())
self.assertEqual(l + length_ms, t1.get_full_length())
# extend multiple times
for i in range(10):
t2 = t1.extend()
self.check(start=ActorClock.to_milliseconds(when=t1.get_start_time()),
new_start=ActorClock.to_milliseconds(when=t1.get_end_time()) + 1,
end=ActorClock.to_milliseconds(when=t1.get_end_time()) + l,
term=t2)
self.assertEqual(l, t2.get_length())
self.assertEqual(t1.get_full_length() + l, t2.get_full_length())
self.assertTrue(t2.extends_term(old_term=t2))
t1 = t2
def get_extend_lease_request(self, authority: ABCAuthority, delegation: ABCDelegation,
request: ABCAuthorityReservation):
req_start = authority.get_actor_clock().cycle_start_date(cycle=self.TicketStartCycle)
req_new_start = authority.get_actor_clock().cycle_start_date(cycle=self.TicketEndCycle + 1)
req_end = authority.get_actor_clock().cycle_end_date(cycle=self.TicketNewEndCycle)
req_term = Term(start=req_start, end=req_end, new_start=req_new_start)
rtype = ResourceType(resource_type=request.get_requested_resources().get_sliver().resource_type.name)
ticket = self.get_ticket(self.TicketUnits, rtype, req_term, delegation, authority)
new_request = self.get_request_from_request(request, req_term, ticket)
return new_request
def add_reservation_private(self, *, reservation: TicketReservationAvro):
result = ResultAvro()
slice_id = ID(uid=reservation.get_slice_id())
rset = Converter.get_resource_set(res_mng=reservation)
term = Term(start=ActorClock.from_milliseconds(
milli_seconds=reservation.get_start()),
end=ActorClock.from_milliseconds(
milli_seconds=reservation.get_end()))
broker = None
if reservation.get_broker() is not None:
broker = ID(uid=reservation.get_broker())
rid = None
if reservation.get_reservation_id() is not None:
rid = ID(uid=reservation.get_reservation_id())
else:
rid = ID()
rc = ClientReservationFactory.create(rid=rid,
resources=rset,
term=term)
rc.set_renewable(renewable=reservation.is_renewable())
if rc.get_state() != ReservationStates.Nascent or rc.get_pending_state(
) != ReservationPendingStates.None_:
result.set_code(ErrorCodes.ErrorInvalidReservation.value)
result.set_message(
"Only reservations in Nascent.None can be added")
return None, result
slice_obj = self.client.get_slice(slice_id=slice_id)
if slice_obj is None:
result.set_code(ErrorCodes.ErrorNoSuchSlice.value)
result.set_message(ErrorCodes.ErrorNoSuchSlice.interpret())
return None, result
rc.set_slice(slice_object=slice_obj)
proxy = None
if broker is None:
proxy = self.client.get_default_broker()
else:
proxy = self.client.get_broker(guid=broker)
if proxy is None:
result.set_code(ErrorCodes.ErrorNoSuchBroker.value)
result.set_message(ErrorCodes.ErrorNoSuchBroker.interpret())
return None, result
rc.set_broker(broker=proxy)
self.client.register(reservation=rc)
return rc.get_reservation_id(), result
def get_redeem_request(self, authority: ABCAuthority, delegation: ABCDelegation):
req_start = authority.get_actor_clock().cycle_start_date(cycle=self.TicketStartCycle)
req_end = authority.get_actor_clock().cycle_end_date(cycle=self.TicketEndCycle)
req_term = Term(start=req_start, end=req_end)
sliver = self.build_sliver()
ticket = self.get_ticket(units=self.TicketUnits, rtype=ResourceType(resource_type=sliver.resource_type.name),
term=req_term, source=delegation,
actor=authority)
request = self.get_request(req_term, ticket, sliver)
return request
def get_reservation_for_network_node(self, start: datetime, end: datetime,
sliver: NodeSliver):
slice_obj = SliceFactory.create(slice_id=ID(), name="test-slice")
rtype = ResourceType(resource_type=sliver.resource_type.name)
rset = ResourceSet(units=1, rtype=rtype, sliver=sliver)
term = Term(start=start, end=end)
request = BrokerReservationFactory.create(rid=ID(),
resources=rset,
term=term,
slice_obj=slice_obj)
return request
def get_close(self, *, term: Term) -> int:
"""
Return the cycle when a term closes
@params term: the term
@returns the cycle of the end of a term
"""
if self.lazy_close:
return -1
else:
return self.clock.cycle(when=term.get_end_time()) + 1
def translate_term(*, term: Term) -> TermAvro:
avro_term = TermAvro()
if term.get_start_time() is not None:
avro_term.start_time = ActorClock.to_milliseconds(when=term.get_start_time())
else:
term.start_time = 0
if term.get_end_time() is not None:
avro_term.end_time = ActorClock.to_milliseconds(when=term.get_end_time())
else:
term.end_time = 0
if term.get_new_start_time() is not None:
avro_term.new_start_time = ActorClock.to_milliseconds(when=term.get_new_start_time())
else:
avro_term.new_start_time = 0
return avro_term
def check(self, *, term: Term, start: int = None, new_start: int = None, end: int = None):
if start is not None and new_start is not None and end is not None:
self.assertIsNotNone(term.start_time)
self.assertIsNotNone(term.new_start_time)
self.assertIsNotNone(term.end_time)
self.assertIsNotNone(term.get_start_time())
self.assertIsNotNone(term.get_new_start_time())
self.assertIsNotNone(term.get_end_time())
self.assertEqual(start, ActorClock.to_milliseconds(when=term.get_start_time()))
self.assertEqual(new_start, ActorClock.to_milliseconds(when=term.get_new_start_time()))
self.assertEqual(end, ActorClock.to_milliseconds(when=term.get_end_time()))
else:
self.assertIsNone(term.start_time)
self.assertIsNone(term.new_start_time)
self.assertIsNone(term.end_time)
self.assertIsNone(term.get_start_time())
self.assertIsNone(term.get_new_start_time())
self.assertIsNone(term.get_end_time())
def translate_term_from_avro(*, term: TermAvro) -> Term:
start_time = None
end_time = None
new_start_time = None
if term.start_time > 0:
start_time = ActorClock.from_milliseconds(milli_seconds=term.start_time)
if term.end_time > 0:
end_time = ActorClock.from_milliseconds(milli_seconds=term.end_time)
if term.new_start_time > 0:
new_start_time = ActorClock.from_milliseconds(milli_seconds=term.new_start_time)
return Term(start=start_time, end=end_time, new_start=new_start_time)
def get_request_from_request(self, request: ABCBrokerReservation,
units: int, rtype: ResourceType,
start: datetime, end: datetime):
rset = ResourceSet(units=units, rtype=rtype)
term = Term(start=request.get_term().get_start_time(),
end=end,
new_start=start)
result = BrokerReservationFactory.create(
rid=request.get_reservation_id(),
resources=rset,
term=term,
slice_obj=request.get_slice())
result.set_sequence_in(sequence=request.get_sequence_in() + 1)
return result
def test_d_nascent(self):
controller = self.get_controller()
clock = controller.get_actor_clock()
Term.clock = clock
resources = ResourceSet(units=1, rtype=ResourceType(resource_type="1"))
slice_obj = SliceFactory.create(slice_id=ID(), name="nascent")
controller.register_slice(slice_object=slice_obj)
start = 5
end = 10
term = Term(start=clock.cycle_start_date(cycle=start), end=clock.cycle_end_date(cycle=end))
r1 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj)
r1.set_renewable(renewable=False)
controller.register(reservation=r1)
controller.demand(rid=r1.get_reservation_id())
r2 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj)
r2.set_renewable(renewable=False)
controller.register(reservation=r2)
r2demanded = False
for i in range(1, end + 3):
controller.external_tick(cycle=i)
while controller.get_current_cycle() != i:
time.sleep(0.001)
if i == (start -3) and not r2demanded:
self.assertTrue(r1.is_ticketed())
self.assertTrue(r2.is_nascent())
controller.demand(rid=r2.get_reservation_id())
r2demanded = True
if i >= start and (i < end - 1):
self.assertTrue(r1.is_active())
self.assertTrue(r2.is_active())
if i > end:
self.assertTrue(r1.is_closed())
self.assertTrue(r2.is_closed())
def test_d_add_update_get_unit(self):
actor = self.prepare_actor_database()
db = actor.get_plugin().get_database()
slice_obj = SliceFactory.create(slice_id=ID(), name="slice-1")
db.add_slice(slice_object=slice_obj)
rset = ResourceSet()
term = Term(start=datetime.now(),
end=datetime.now().replace(minute=20))
res = AuthorityReservationFactory.create(resources=rset,
term=term,
slice_obj=slice_obj,
rid=ID())
db.add_reservation(reservation=res)
rtype = ResourceType(resource_type="12")
u = Unit(rid=res.get_reservation_id(),
slice_id=slice_obj.get_slice_id(),
actor_id=actor.get_guid())
u.set_resource_type(rtype=rtype)
db.add_unit(u=u)
self.assertIsNotNone(db.get_unit(uid=u.get_id()))
def test_validate(self):
with self.assertRaises(Exception):
self.check_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=10),
new_start=ActorClock.from_milliseconds(milli_seconds=100),
end=ActorClock.from_milliseconds(milli_seconds=10)))
self.check_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=10),
new_start=ActorClock.from_milliseconds(milli_seconds=100),
end=ActorClock.from_milliseconds(milli_seconds=99)))
self.check_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=10),
new_start=ActorClock.from_milliseconds(milli_seconds=1000),
end=ActorClock.from_milliseconds(milli_seconds=1000)))
self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100),
end=ActorClock.from_milliseconds(milli_seconds=10)))
self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100),
end=ActorClock.from_milliseconds(milli_seconds=100)))
self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100),
end=ActorClock.from_milliseconds(milli_seconds=1000),
new_start=ActorClock.from_milliseconds(milli_seconds=10)))
self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100),
end=ActorClock.from_milliseconds(milli_seconds=10),
new_start=ActorClock.from_milliseconds(milli_seconds=10000)))
def allocate_extending_reservation_set(self, *, requests: ReservationSet):
if requests is not None:
for reservation in requests.values():
if reservation.is_extending_ticket(
) and not reservation.is_closed():
start = reservation.get_requested_term(
).get_new_start_time()
end = self.align_end(
when=reservation.get_requested_term().get_end_time())
resource_type = reservation.get_resources().get_type()
inv = self.inventory.get(resource_type=resource_type)
if inv is not None:
ext_term = Term(
start=reservation.get_term().get_start_time(),
end=end,
new_start=start)
self.extend_private(reservation=reservation,
inv=inv,
term=ext_term)
else:
reservation.fail(message=Constants.NO_POOL)
def test_shift(self):
start = 1000
end = 1499
length = 500
t = Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t, start=start, new_start=start, end=end)
self.assertEqual(length, t.get_length())
t1 = t.shift(date=ActorClock.from_milliseconds(milli_seconds=start-500))
self.check(term=t1, start=start-500, new_start=start-500, end=end-500)
self.assertEqual(length, t1.get_length())
t1 = t.shift(date=ActorClock.from_milliseconds(milli_seconds=start))
self.check(term=t1, start=start, new_start=start, end=end)
self.assertEqual(length, t1.get_length())
t1 = t.shift(date=ActorClock.from_milliseconds(milli_seconds=start+500))
self.check(term=t1, start=start + 500, new_start=start + 500, end=end + 500)
self.assertEqual(length, t1.get_length())
def test_contains(self):
start = 1000
end = 1499
length = 500
t = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t, start=start, new_start=start, end=end)
self.assertEqual(length, t.get_length())
# self -> true
self.assertTrue(t.contains(term=t))
# self - 1 from the right
self.assertTrue(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start), length=length-1)))
# self + 1 from the left
self.assertTrue(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end))))
# self +1 from the left, -1 from the right
self.assertTrue(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end - 1))))
self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start -1),
end=ActorClock.from_milliseconds(milli_seconds=end))))
self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start -100),
end=ActorClock.from_milliseconds(milli_seconds=start))))
self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end + 1))))
self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end + 100))))
self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start - 100),
end=ActorClock.from_milliseconds(milli_seconds=end + 100))))
self.assertTrue(t.contains(date=ActorClock.from_milliseconds(milli_seconds=start)))
self.assertTrue(t.contains(date=ActorClock.from_milliseconds(milli_seconds=end)))
self.assertTrue(t.contains(date=ActorClock.from_milliseconds(milli_seconds=int((start + end)/2))))
self.assertFalse(t.contains(date=ActorClock.from_milliseconds(milli_seconds=start -1)))
self.assertFalse(t.contains(date=ActorClock.from_milliseconds(milli_seconds=end + 1)))
def get_approved_term(*, reservation: ABCBrokerReservation) -> Term:
return Term(
start=reservation.get_requested_term().get_start_time(),
end=reservation.get_requested_term().get_end_time(),
new_start=reservation.get_requested_term().get_new_start_time())
def test_ends(self):
start = 1000
end = 1499
length = 500
t = Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t, start=start, new_start=start, end=end)
self.assertEqual(length, t.get_length())
# term cannot end before it started
self.assertFalse(t.ends_before(date=t.get_start_time()))
self.assertFalse(t.expired(date=t.get_start_time()))
self.assertTrue(t.ends_after(date=t.get_start_time()))
self.assertFalse(t.ends_before(date=t.get_end_time()))
self.assertFalse(t.ends_after(date=t.get_end_time()))
self.assertFalse(t.expired(date=t.get_end_time()))
self.assertFalse(t.ends_before(date=ActorClock.from_milliseconds(milli_seconds=start - 100)))
self.assertTrue(t.ends_after(date=ActorClock.from_milliseconds(milli_seconds=start - 100)))
self.assertFalse(t.expired(date=ActorClock.from_milliseconds(milli_seconds=start - 100)))
self.assertTrue(t.ends_before(date=ActorClock.from_milliseconds(milli_seconds=end + 1)))
self.assertTrue(t.expired(date=ActorClock.from_milliseconds(milli_seconds=end + 1)))
self.assertFalse(t.ends_after(date=ActorClock.from_milliseconds(milli_seconds=end + 1)))
def check_valid(term: Term):
term.validate()
def test_create(self):
length = 500
start = 1000
new_start = 1500
end = 1999
old_end = 1499
with self.assertRaises(Exception):
Term()
with self.assertRaises(Exception):
t2 = Term(start=ActorClock.from_milliseconds(milli_seconds=start))
# Term(start, length)
t3 = Term(start=ActorClock.from_milliseconds(milli_seconds=start), length=length)
self.check(term=t3, start=start, new_start=start, end=old_end)
self.assertEqual(length, t3.get_length())
# Term(start, end)
t4 = Term(start=ActorClock.from_milliseconds(milli_seconds=start),
end=ActorClock.from_milliseconds(milli_seconds=old_end))
self.check(term=t4, start=start, new_start=start, end=old_end)
self.assertEqual(length, t4.get_length())
# Term(start, end, new_start)
t5 = Term(start=ActorClock.from_milliseconds(milli_seconds=start),
new_start=ActorClock.from_milliseconds(milli_seconds=new_start),
end=ActorClock.from_milliseconds(milli_seconds=end))
self.check(term=t5, start=start, new_start=new_start, end=end)
# NOTE: length is measured only relative to newStartTime!!!
self.assertEqual(length, t5.get_length())
