def test_config_size(size, config):
config.size = size
ag = AircraftGenerator(config=config)
ag.populate()
assert ag.config.size == config.size
def gen_mixed(config):
prob_good = 0.6
prob_noisy = 0.3
prob_bad = 0.1
config._prob_weights = [prob_good, prob_noisy, prob_bad]
ag = AircraftGenerator(config=config)
ag.populate()
yield ag
def test_work_orders_have_valid_executiondate(config):
"""Tests that the relation between workorders and maintenanceevents is meaningful
this covers the second part of the query
Basically, we want to test that the following
```sql
select
*
from
"AMOS".workorders w
where
not exists (
select
*
from
"AMOS".maintenanceevents m2
where
w.aircraftregistration = m2.aircraftregistration
and w.executiondate between starttime and starttime + duration)
```
Check issue #6
returns nothing, if prob_good = 1
returns a proportion of size of prob_bad and prob_noisy, if they are not zero
"""
config.size = 100
ag = AircraftGenerator(config=config)
ag.populate()
assert config._prob_weights == [1, 0, 0]
wo_execution_date = [
wo.executiondate for wo in chain(ag.tlb_orders, ag.forecasted_orders)
]
me_airc_starttimes = [me.starttime for me in ag.maintenance_events]
me_airc_endtimes = [
me.starttime + me.duration for me in ag.maintenance_events
]
# Maintenance event can include several work orders and each work order is
# inside one maintenance event. However, this reference is not explicit.
# It is represented as I said above by the same aircraft registration
# 2) and the fact that the execution date of the work order is inside the time
# interval of the maintenance event (startdate, startdate + duration).
for ed, start, end in zip(wo_execution_date, me_airc_starttimes,
me_airc_endtimes):
assert ed >= start
assert ed <= end
def gen_noisy(config):
config.size = 10
prob_good = 0
prob_noisy = 1
prob_bad = 0
config._prob_weights = [prob_good, prob_noisy, prob_bad]
ag = AircraftGenerator(config=config)
ag.populate()
yield ag
def gen(config):
# tweak the config a little
config.size = 10
prob_good = 1
prob_noisy = 0
prob_bad = 0
config._prob_weights = [prob_good, prob_noisy, prob_bad]
ag = AircraftGenerator(config=config)
ag.populate()
yield ag
def test_slots_size(config, size):
config.flight_slots_size = size
config.maintenance_slots_size = size
total_size = size * 2
ag = AircraftGenerator(config=config)
ag.populate()
assert len(ag.maintenance_slots) + len(ag.flight_slots) == total_size
assert len(ag.maintenance_slots) == size
assert len(ag.flight_slots) == size
def test_work_orders_have_valid_aircraftregistration(config):
"""Tests that the relation between workorders and maintenanceevents is meaningful
Check issue #6
Basically, we want to test that the following
```sql
select
*
from
"AMOS".workorders w
where
not exists (
select
*
from
"AMOS".maintenanceevents m2
where
w.aircraftregistration = m2.aircraftregistration
and w.executiondate between starttime and starttime + duration)
```
returns nothing, if prob_good = 1
returns a proportion of size of prob_bad and prob_noisy, if they are not zero
"""
config = BaseConfig(size=10)
ag = AircraftGenerator(config=config)
ag.populate()
assert ag.config._prob_weights == [1, 0, 0]
# uno de los business rules dice que cada workorders por un aircraft debería
# estar dentro de al menos un maintenance events
# (w.executiondate between starttime and starttime+duration).
airc_regs_wo = [
wo.aircraftregistration
for wo in chain(ag.forecasted_orders, ag.tlb_orders)
]
airc_regs_me = [me.aircraftregistration for me in ag.maintenance_events]
# Maintenance event can include several work orders and each work order is
# inside one maintenance event. However, this reference is not explicit.
# It is represented as I said above by the same aircraft registration and
# the fact that the execution date of the work order is inside the time
# interval of the maintenance event (startdate, startdate + duration).
assert len(airc_regs_me) == len(airc_regs_wo)
assert set(airc_regs_me) == set(airc_regs_wo)
def test_work_orders_size(size):
"""Tests that work orders' size matches
:param config: [description]
:type config: [type]
:param size: [description]
:type size: [type]
"""
config = BaseConfig(size=size,
forecasted_orders_size=size,
tlb_orders_size=size)
ag = AircraftGenerator(config=config)
ag.populate()
assert len(ag.tlb_orders) <= size
assert len(ag.forecasted_orders) <= size
assert len(ag.tlb_orders) + len(ag.forecasted_orders) == size
def test_slots_with_same_aircraft_do_overlap_when_prob_bad_non_zero():
"""tests R20: Two Slots of the same aircraft cannot overlap in time.
SELECT count(*)
FROM flights f1
WHERE NOT EXISTS
(SELECT * FROM flights f2 WHERE f1.flightid <> f2.flightid and f1.aircraftregistration = f2.aircraftregistration
and (f1.actualdeparture, f1.actualarrival) overlaps (f2.actualdeparture,f2.actualarrival));
"""
config = BaseConfig(size=100, prob_bad=1)
assert config._prob_weights == [0, 0, 1]
ag = AircraftGenerator(config=config)
ag.populate()
# fetch all airc. regs.
aircraft_registrations = [f.aircraftregistration for f in ag.flight_slots]
# paranoid check
assert ag.config.size == config.size
assert len(ag.flight_slots) == config.size
bad_checks_count = 0
for ar in aircraft_registrations:
# fetch all flights with that ar code
same_aircraft_flights = [
f for f in ag.flight_slots
if (f.aircraftregistration == ar and f.cancelled is False)
]
# check that the flights with this ar don't overlap
if len(same_aircraft_flights) >= 2:
for flight_1, flight_2 in permutations(same_aircraft_flights, 2):
ts1 = flight_1.actualdeparture
te1 = flight_1.actualarrival
ts2 = flight_2.actualdeparture
te2 = flight_2.actualarrival
min_end = min(te1, te2)
max_start = max(ts1, ts2)
if min_end > max_start:
bad_checks_count += 1
assert bad_checks_count == 100
def test_totals(custom_size):
config = BaseConfig(
size=custom_size,
flight_slots_size=custom_size,
maintenance_slots_size=custom_size,
tlb_orders_size=custom_size,
forecasted_orders_size=custom_size,
max_attach_size=1,
max_work_orders=1,
)
ag = AircraftGenerator(config=config)
ag.populate()
assert config.size == custom_size
assert config.flight_slots_size == custom_size
assert config.maintenance_slots_size == custom_size
assert config.tlb_orders_size == custom_size
assert config.forecasted_orders_size == custom_size
assert config.max_attach_size == 1
assert config.max_work_orders == 1
entities = [
ag.flight_slots,
ag.maintenance_slots,
ag.maintenance_events,
ag.operational_interruptions,
ag.manufacturers,
ag.work_packages,
ag.tlb_orders,
ag.forecasted_orders,
ag.attachments,
ag.maintenance_personnel,
]
total_instances = sum([len(entity) for entity in entities])
assert ag.total_entities == len(entities)
assert ag.total_instances == total_instances
def test_attachments_size(slots_size, attch_size):
config = BaseConfig(
flight_slots_size=slots_size,
maintenance_slots_size=slots_size,
max_attach_size=attch_size,
)
ag = AircraftGenerator(config=config)
assert ag.config.max_attach_size == attch_size
assert ag.config.maintenance_slots_size == slots_size
assert ag.config.flight_slots_size == slots_size
ag.populate()
# ois_events_size is controlled by flight_slots_size, not cancelled
# maintenance_events_size is controlled by maintenance_slots_size
assert sum(1 for f in ag.flight_slots
if not f.cancelled) == len(ag.operational_interruptions)
assert len(ag.maintenance_events) == len(ag.maintenance_slots)
assert (len(ag.attachments) == (len(ag.maintenance_events) +
len(ag.operational_interruptions)) *
ag.config.max_attach_size)
def to_csv(args):
config = BaseConfig(
size=args.rows,
prob_good=(1 - (args.prob_noisy + args.prob_bad)),
prob_noisy=args.prob_noisy,
prob_bad=args.prob_bad,
)
print(config._prob_weights)
ag = AircraftGenerator(config)
ag.populate()
ag.to_csv(path=args.out_path)
def to_sql(args):
config = BaseConfig(
size=args.rows,
prob_good=1 - (args.prob_noisy + args.prob_bad),
prob_noisy=args.prob_noisy,
prob_bad=args.prob_bad,
)
_sqla_url = {
"drivername": "postgres",
"username": args.db_user,
"password": args.db_pwd,
"host": args.db_host,
"port": args.db_port,
"database": args.db_name,
}
engine = create_engine(URL(**_sqla_url), echo=args.verbose)
# create session
if args.hard:
logging.info("Wiping database")
delete_all(engine)
logging.info("Creating tables from scratch")
create_all(engine)
# # select *
# result = engine.execute(
# """
# select
# *
# from
# pg_catalog.pg_tables
# where
# schemaname != 'information_schema'
# and schemaname != 'pg_catalog';"""
# )
# for _r in result:
# print(_r)
session = get_session(engine)
ag = AircraftGenerator(config)
ag.populate()
ag.to_sql(session)
def test_that_nothing_breaks(config):
ag = AircraftGenerator(config=config)
ag.populate()