def test_rule_created_deleted(self):
"""INTR test: availability changed after basic rule operations
"""
if self.__verbose_testing:
print('##### test_rule_created_deleted')
rule_1_pk = rule_jrpc.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(
starting_time=self.__rule_s_time, ending_time=self.__rule_e_time
)
)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(),
1,
'One availability slot should have been created'
)
rule_jrpc.remove_rule(self.__gs_1_id, rule_1_pk)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(),
0,
'No availability slots should be available'
)
def test_add_once_rule(self):
"""JRPC test: (O) cfg.gs.channel.addRule, cfg.gs.channel.removeRule
Should correctly add a ONCE rule to the system.
"""
if self.__verbose_testing:
print('>>> TEST (test_gs_channel_add_rule)')
# 1) add new rule to the database
starting_time = misc.get_next_midnight() - datetime.timedelta(hours=12)
ending_time = starting_time + datetime.timedelta(hours=4)
rule_cfg = db_tools.create_jrpc_once_rule(starting_time=starting_time,
ending_time=ending_time)
rule_id_1 = jrpc_rules.add_rule(self.__gs_1_id, rule_cfg)
# 2) get the rule back through the JRPC interface
rules_g1c1 = jrpc_rules.list_channel_rules(self.__gs_1_id)
expected_r = {
jrpc_serial.RULE_PK_K: rule_id_1,
jrpc_serial.RULE_PERIODICITY: jrpc_serial.RULE_PERIODICITY_ONCE,
jrpc_serial.RULE_OP: jrpc_serial.RULE_OP_ADD,
jrpc_serial.RULE_DATES: {
jrpc_serial.RULE_ONCE_S_TIME: starting_time.isoformat(),
jrpc_serial.RULE_ONCE_E_TIME: ending_time.isoformat()
}
}
if self.__verbose_testing:
misc.print_list(rules_g1c1, name='DATABASE')
misc.print_dictionary(expected_r)
self.assertEqual(rules_g1c1[0], expected_r)
jrpc_rules.remove_rule(self.__gs_1_id, rule_id_1)
self.__verbose_testing = False
def test_remove_rule(self):
"""JRPC test: cfg.gs.channel.removeRule
Should correctly remove any rule to the system.
"""
if self.__verbose_testing:
print('>>> TEST (test_gs_channel_add_rule)')
rule_cfg = db_tools.create_jrpc_once_rule()
rule_id = jrpc_rules.add_rule(self.__gs_1_id, rule_cfg)
jrpc_rules.remove_rule(self.__gs_1_id, rule_id)
self.assertRaises(rules.AvailabilityRule.DoesNotExist,
rules.AvailabilityRule.objects.get,
id=rule_id)
def test_remove_rule(self):
"""JRPC test: cfg.gs.channel.removeRule
Should correctly remove any rule to the system.
"""
if self.__verbose_testing:
print('>>> TEST (test_gs_channel_add_rule)')
rule_cfg = db_tools.create_jrpc_once_rule()
rule_id = jrpc_rules.add_rule(self.__gs_1_id, rule_cfg)
jrpc_rules.remove_rule(self.__gs_1_id, rule_id)
self.assertRaises(
rules.AvailabilityRule.DoesNotExist,
rules.AvailabilityRule.objects.get, id=rule_id
)
def test_rule_created_deleted(self):
"""INTR test: availability changed after basic rule operations
"""
if self.__verbose_testing:
print('##### test_rule_created_deleted')
rule_1_pk = rule_jrpc.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(starting_time=self.__rule_s_time,
ending_time=self.__rule_e_time))
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
1, 'One availability slot should have been created')
rule_jrpc.remove_rule(self.__gs_1_id, rule_1_pk)
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
0, 'No availability slots should be available')
def test_add_once_rule(self):
"""JRPC test: (O) cfg.gs.channel.addRule, cfg.gs.channel.removeRule
Should correctly add a ONCE rule to the system.
"""
if self.__verbose_testing:
print('>>> TEST (test_gs_channel_add_rule)')
# 1) add new rule to the database
starting_time = misc.get_next_midnight() - datetime.timedelta(hours=12)
ending_time = starting_time + datetime.timedelta(hours=4)
rule_cfg = db_tools.create_jrpc_once_rule(
starting_time=starting_time,
ending_time=ending_time
)
rule_id_1 = jrpc_rules.add_rule(self.__gs_1_id, rule_cfg)
# 2) get the rule back through the JRPC interface
rules_g1c1 = jrpc_rules.list_channel_rules(self.__gs_1_id)
expected_r = {
jrpc_serial.RULE_PK_K: rule_id_1,
jrpc_serial.RULE_PERIODICITY: jrpc_serial.RULE_PERIODICITY_ONCE,
jrpc_serial.RULE_OP: jrpc_serial.RULE_OP_ADD,
jrpc_serial.RULE_DATES: {
jrpc_serial.RULE_ONCE_S_TIME: starting_time.isoformat(),
jrpc_serial.RULE_ONCE_E_TIME: ending_time.isoformat()
}
}
if self.__verbose_testing:
misc.print_list(rules_g1c1, name='DATABASE')
misc.print_dictionary(expected_r)
self.assertEqual(rules_g1c1[0], expected_r)
jrpc_rules.remove_rule(self.__gs_1_id, rule_id_1)
self.__verbose_testing = False
def test_multiple_rules(self):
"""INTR test: multiple rules
"""
if self.__verbose_testing:
print('##### test_rule_created_deleted')
rule_1_pk = rule_jrpc.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(
starting_time=self.__rule_s_time, ending_time=self.__rule_e_time
)
)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(), 1
)
rule_2_pk = rule_jrpc.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(
operation=rule_jrpc.rule_serializers.RULE_OP_REMOVE,
starting_time=self.__rule_s_time, ending_time=self.__rule_e_time
)
)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(), 0
)
rule_jrpc.remove_rule(self.__gs_1_id, rule_2_pk)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(), 1
)
rule_3 = db_tools.create_jrpc_once_rule(
operation=rule_serializers.RULE_OP_REMOVE,
starting_time=self.__rule_s_time, ending_time=self.__rule_e_time
)
rule_3_pk = rule_jrpc.add_rule(self.__gs_1_id, rule_3)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(), 0
)
rule_jrpc.remove_rule(self.__gs_1_id, rule_3_pk)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(), 1
)
rule_jrpc.remove_rule(self.__gs_1_id, rule_1_pk)
self.assertEquals(
availability_models.AvailabilitySlot.objects.count(), 0
)
def test_multiple_rules(self):
"""INTR test: multiple rules
"""
if self.__verbose_testing:
print('##### test_rule_created_deleted')
rule_1_pk = rule_jrpc.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(starting_time=self.__rule_s_time,
ending_time=self.__rule_e_time))
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
1)
rule_2_pk = rule_jrpc.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(
operation=rule_jrpc.rule_serializers.RULE_OP_REMOVE,
starting_time=self.__rule_s_time,
ending_time=self.__rule_e_time))
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
0)
rule_jrpc.remove_rule(self.__gs_1_id, rule_2_pk)
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
1)
rule_3 = db_tools.create_jrpc_once_rule(
operation=rule_serializers.RULE_OP_REMOVE,
starting_time=self.__rule_s_time,
ending_time=self.__rule_e_time)
rule_3_pk = rule_jrpc.add_rule(self.__gs_1_id, rule_3)
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
0)
rule_jrpc.remove_rule(self.__gs_1_id, rule_3_pk)
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
1)
rule_jrpc.remove_rule(self.__gs_1_id, rule_1_pk)
self.assertEquals(availability_models.AvailabilitySlot.objects.count(),
0)
def test_generate_slots_once_rule(self):
"""UNIT test: services.configuration.models.rules - ONCE slots
This test validates that a ONCE rule generates the right amount of
slots depending on the interval relation with the start/end moments of
the rule itself.
"""
if self.__verbose_testing:
print('>>> test_generate_slots_once_rule:')
#######################################################################
# ### XXXX SIGNAL DISCONNECTED
django_signals.post_save.disconnect(
availability_signals.once_rule_saved,
sender=rule_models.AvailabilityRuleOnce
)
#######################################################################
# ### 1) rule after interval
rule_1_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight(),
ending_time=sn_misc.get_next_midnight() + py_timedelta(hours=4)
)
)
rule_1_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_1_id
).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_1_db_values[0], (
sn_misc.get_next_midnight() - py_timedelta(hours=12),
sn_misc.get_next_midnight() - py_timedelta(hours=3)
)
),
[]
)
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_1_id))
#######################################################################
# ### 2) rule before interval
rule_2_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() - py_timedelta(
hours=6
),
ending_time=sn_misc.get_next_midnight() - py_timedelta(
hours=4
)
)
)
rule_2_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_2_id
).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_2_db_values[0], (
sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9)
)
),
[]
)
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_2_id))
#######################################################################
# ### 3) rule FULLY inside interval
rule_3_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() + py_timedelta(
hours=2
),
ending_time=sn_misc.get_next_midnight() + py_timedelta(
hours=4
)
)
)
rule_3_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_3_id
).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_3_db_values[0], (
sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9)
)
), [(
sn_misc.get_next_midnight() + py_timedelta(hours=2),
sn_misc.get_next_midnight() + py_timedelta(hours=4)
)]
)
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_3_id))
#######################################################################
# ### 4) rule start before the interval
rule_4_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() - py_timedelta(
hours=1
),
ending_time=sn_misc.get_next_midnight() + py_timedelta(
hours=4
)
)
)
rule_4_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_4_id
).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_4_db_values[0], (
sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9)
)
), [(
sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=4)
)]
)
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_4_id))
#######################################################################
# ### 5) rule ends after the interval
rule_5_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() + py_timedelta(
hours=2
),
ending_time=sn_misc.get_next_midnight() + py_timedelta(
hours=12
)
)
)
rule_5_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_5_id
).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_5_db_values[0], (
sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9)
)
), [(
sn_misc.get_next_midnight() + py_timedelta(hours=2),
sn_misc.get_next_midnight() + py_timedelta(hours=9)
)]
)
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_5_id))
#######################################################################
# ### XXXX SIGNAL RECONNECTED
django_signals.post_save.connect(
availability_signals.once_rule_saved,
sender=rule_models.AvailabilityRuleOnce
)
def _test_3_generate_slots_several_rules_1(self):
"""INTR test: services.scheduling - add slots with several rules (3)
This method tests the addition of new availability slots when there
are several availability rules in the database.
"""
if self.__verbose_testing:
print('##### test_add_slots: several rules (1)')
# R1) ADD+ONCE (+1 slot)
rule_1_id = jrpc_rules_if.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(
starting_time=self.__rule_s_time, ending_time=self.__rule_e_time
)
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
self.assertEqual(
len(a_slots), 1, 'Only 1 slot expected, got = ' + str(len(a_slots))
)
av_slots = availability.AvailabilitySlot.objects.all()
self.assertEqual(
len(av_slots), 1, '1 slot expected, got = ' + str(len(av_slots))
)
if self.__verbose_testing:
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@1'
)
misc.print_list(av_slots, name='AVAILABLE@1')
# R2) ADD+DAILY (+2 slots)
rule_2_id = jrpc_rules_if.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_daily_rule(
date_i=self.__utc_s_date,
date_f=self.__utc_e_date,
starting_time=self.__utc_s_time,
ending_time=self.__utc_e_time
)
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
av_slots = availability.AvailabilitySlot.objects.all()
if self.__verbose_testing:
print('>>> today_utc = ' + str(misc.get_today_utc()))
print('>>> window = ' + str(
simulation.OrbitalSimulator.get_simulation_window()
))
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@2'
)
misc.print_list(av_slots, name='AVAILABLE@2')
expected_slots = 3
self.assertEqual(len(a_slots), expected_slots)
self.assertEqual(len(av_slots), expected_slots)
# R3) ADD-ONCE (-1 slot)
rule_3_id = jrpc_rules_if.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_once_rule(
operation=jrpc_serial.RULE_OP_REMOVE,
starting_time=self.__rule_s_time, ending_time=self.__rule_e_time
)
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
av_slots = availability.AvailabilitySlot.objects.all()
if self.__verbose_testing:
print('>>> today_utc = ' + str(misc.get_today_utc()))
print('>>> window = ' + str(
simulation.OrbitalSimulator.get_simulation_window()
))
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@3'
)
misc.print_list(av_slots, name='AVAILABLE@3')
expected_slots = 2
self.assertEqual(len(a_slots), expected_slots)
self.assertEqual(len(av_slots), expected_slots)
# R4) ADD-DAILY (-7 slots)
rule_4_id = jrpc_rules_if.add_rule(
self.__gs_1_id,
db_tools.create_jrpc_daily_rule(
operation=jrpc_serial.RULE_OP_REMOVE,
date_i=self.__utc_s_date,
date_f=self.__utc_e_date,
starting_time=self.__utc_s_time,
ending_time=self.__utc_e_time
)
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
av_slots = availability.AvailabilitySlot.objects.all()
if self.__verbose_testing:
print('>>> today_utc = ' + str(misc.get_today_utc()))
print('>>> window = ' + str(
simulation.OrbitalSimulator.get_simulation_window()
))
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@4'
)
misc.print_list(av_slots, name='AVAILABLE@4')
expected = 0
self.assertEqual(len(a_slots), expected)
self.assertEqual(len(av_slots), expected)
# REMOVE R#4 (+6 slots)
jrpc_rules_if.remove_rule(
groundstation_id=self.__gs_1_id,
rule_id=rule_4_id
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
av_slots = availability.AvailabilitySlot.objects.all()
if self.__verbose_testing:
print('>>> today_utc = ' + str(misc.get_today_utc()))
print('>>> window = ' + str(
simulation.OrbitalSimulator.get_simulation_window()
))
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@5'
)
misc.print_list(av_slots, name='AVAILABLE@5')
expected = 2
self.assertEqual(len(a_slots), expected)
self.assertEqual(len(av_slots), expected)
# REMOVE R#3 (+1 slot)
jrpc_rules_if.remove_rule(
groundstation_id=self.__gs_1_id,
rule_id=rule_3_id
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
av_slots = availability.AvailabilitySlot.objects.all()
if self.__verbose_testing:
print('>>> today_utc = ' + str(misc.get_today_utc()))
print('>>> window = ' + str(
simulation.OrbitalSimulator.get_simulation_window()
))
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@6'
)
misc.print_list(av_slots, name='AVAILABLE@6')
expected = 3
self.assertEqual(len(a_slots), expected)
self.assertEqual(len(av_slots), expected)
# REMOVE R#2 (-7 slots)
jrpc_rules_if.remove_rule(
groundstation_id=self.__gs_1_id,
rule_id=rule_2_id
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
self.assertEqual(len(a_slots), 1)
av_slots = availability.AvailabilitySlot.objects.all()
self.assertEqual(len(av_slots), 1)
if self.__verbose_testing:
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@7'
)
misc.print_list(av_slots, name='AVAILABLE@7')
# REMOVE R#1 (-1 slot)
jrpc_rules_if.remove_rule(
groundstation_id=self.__gs_1_id,
rule_id=rule_1_id
)
a_slots = rule_models.AvailabilityRule.objects.get_availability_slots(
self.__gs
)
self.assertEqual(len(a_slots), 0)
av_slots = availability.AvailabilitySlot.objects.all()
self.assertEqual(len(av_slots), 0)
if self.__verbose_testing:
misc.print_list(
rule_models.AvailabilityRule.objects.all(), name='RULES@8'
)
misc.print_list(av_slots, name='AVAILABLE@8')
self.__verbose_testing = False
def test_generate_slots_once_rule(self):
"""UNIT test: services.configuration.models.rules - ONCE slots
This test validates that a ONCE rule generates the right amount of
slots depending on the interval relation with the start/end moments of
the rule itself.
"""
if self.__verbose_testing:
print('>>> test_generate_slots_once_rule:')
#######################################################################
# ### XXXX SIGNAL DISCONNECTED
django_signals.post_save.disconnect(
availability_signals.once_rule_saved,
sender=rule_models.AvailabilityRuleOnce)
#######################################################################
# ### 1) rule after interval
rule_1_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight(),
ending_time=sn_misc.get_next_midnight() +
py_timedelta(hours=4)))
rule_1_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_1_id).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_1_db_values[0],
(sn_misc.get_next_midnight() - py_timedelta(hours=12),
sn_misc.get_next_midnight() - py_timedelta(hours=3))), [])
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_1_id))
#######################################################################
# ### 2) rule before interval
rule_2_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() -
py_timedelta(hours=6),
ending_time=sn_misc.get_next_midnight() -
py_timedelta(hours=4)))
rule_2_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_2_id).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_2_db_values[0],
(sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9))), [])
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_2_id))
#######################################################################
# ### 3) rule FULLY inside interval
rule_3_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() +
py_timedelta(hours=2),
ending_time=sn_misc.get_next_midnight() +
py_timedelta(hours=4)))
rule_3_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_3_id).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_3_db_values[0],
(sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9))),
[(sn_misc.get_next_midnight() + py_timedelta(hours=2),
sn_misc.get_next_midnight() + py_timedelta(hours=4))])
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_3_id))
#######################################################################
# ### 4) rule start before the interval
rule_4_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() -
py_timedelta(hours=1),
ending_time=sn_misc.get_next_midnight() +
py_timedelta(hours=4)))
rule_4_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_4_id).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_4_db_values[0],
(sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9))),
[(sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=4))])
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_4_id))
#######################################################################
# ### 5) rule ends after the interval
rule_5_id = rule_jrpc.add_rule(
self.__gs_1_id,
sn_helpers.create_jrpc_once_rule(
starting_time=sn_misc.get_next_midnight() +
py_timedelta(hours=2),
ending_time=sn_misc.get_next_midnight() +
py_timedelta(hours=12)))
rule_5_db_values = rule_models.AvailabilityRule.objects.filter(
pk=rule_5_id).values()
self.assertListEqual(
rule_models.AvailabilityRuleManager.generate_available_slots_once(
rule_5_db_values[0],
(sn_misc.get_next_midnight(),
sn_misc.get_next_midnight() + py_timedelta(hours=9))),
[(sn_misc.get_next_midnight() + py_timedelta(hours=2),
sn_misc.get_next_midnight() + py_timedelta(hours=9))])
self.assertTrue(rule_jrpc.remove_rule(self.__gs_1_id, rule_5_id))
#######################################################################
# ### XXXX SIGNAL RECONNECTED
django_signals.post_save.connect(
availability_signals.once_rule_saved,
sender=rule_models.AvailabilityRuleOnce)
def test_1_compatibility_sc_channel_added_deleted(self):
"""INTR test: compatibility changed generates operational slots
1) +GS_CH
2) +RULE
3) +SC_CH
4) -SC_CH
5) -RULE
6) -GS_CH
OperationalSlots should be available only in bewteen steps 3 and 4.
"""
if self.__verbose_testing:
print('##### test_add_slots: no rules')
self.__sc_1 = db_tools.create_sc(
user_profile=self.__user_profile,
identifier=self.__sc_1_id,
tle_id=self.__sc_1_tle_id,
)
self.assertTrue(
jrpc_gs_ch_if.gs_channel_create(
groundstation_id=self.__gs_1_id,
channel_id=self.__gs_1_ch_1_id,
configuration=self.__gs_1_ch_1_cfg),
'Channel should have been created!')
r_1_id = jrpc_rules_if.add_rule(self.__gs_1_id, self.__rule_1_cfg)
self.assertIsNot(r_1_id, 0, 'Rule should have been added!')
self.assertTrue(
jrpc_sc_ch_if.sc_channel_create(
spacecraft_id=self.__sc_1_id,
channel_id=self.__sc_1_ch_1_id,
configuration=self.__sc_1_ch_1_cfg),
'Channel should have been created!')
a_slots = availability_models.AvailabilitySlot.objects.get_applicable(
groundstation=self.__gs_1)
if self.__verbose_testing:
misc.print_list(a_slots, 'AvailabilitySlots')
misc.print_list(operational_models.OperationalSlot.objects.all(),
'OperationalSlots')
self.assertGreaterEqual(
len(operational_models.OperationalSlot.objects.all()), 2)
self.assertTrue(
jrpc_sc_ch_if.sc_channel_delete(spacecraft_id=self.__sc_1_id,
channel_id=self.__sc_1_ch_1_id))
expected = []
actual = list(
operational_models.OperationalSlot.objects.filter(
state=operational_models.STATE_FREE).values_list('state'))
if self.__verbose_testing:
print('>>> window = ' +
str(simulation.OrbitalSimulator.get_simulation_window()))
misc.print_list(rule_models.AvailabilityRule.objects.all())
misc.print_list(availability_models.AvailabilitySlot.objects.all())
misc.print_list(operational_models.OperationalSlot.objects.all())
misc.print_list(actual)
misc.print_list(expected)
self.assertEqual(actual, expected)
self.assertTrue(jrpc_rules_if.remove_rule(self.__gs_1_id, r_1_id),
'Rule should have been removed!')
expected = []
actual = list(
operational_models.OperationalSlot.objects.filter(
state=operational_models.STATE_FREE).values_list('state'))
self.assertEqual(actual, expected)
self.assertTrue(
jrpc_gs_ch_if.gs_channel_delete(groundstation_id=self.__gs_1_id,
channel_id=self.__gs_1_ch_1_id),
'Could not delete GroundStationChannel = ' +
str(self.__gs_1_ch_1_id))
expected = []
actual = list(
operational_models.OperationalSlot.objects.filter(
state=operational_models.STATE_FREE).values_list('state'))
self.assertEqual(actual, expected)
def test_propagate_simple(self):
"""INTR test: services.scheduling - slot propagation
This test validates the propagation of the slots with a simple set of
rules.
"""
if self.__verbose_testing:
print('>>> test_propagate_simple:')
r_1_s_time = misc.get_next_midnight() - datetime.timedelta(hours=12)
r_1_e_time = r_1_s_time + datetime.timedelta(hours=10)
r_cfg = db_tools.create_jrpc_daily_rule(
starting_time=r_1_s_time,
ending_time=r_1_e_time
)
self.assertEquals(list(availability.AvailabilitySlot.objects.all()), [])
r_1_id = jrpc_rules_if.add_rule(self.__gs_1_id, r_cfg)
x_pre = [
(
r_1_s_time,
r_1_e_time,
),
(
r_1_s_time + datetime.timedelta(days=1),
r_1_e_time + datetime.timedelta(days=1),
),
(
r_1_s_time + datetime.timedelta(days=2),
r_1_e_time + datetime.timedelta(days=2),
)
]
a_pre = list(
availability.AvailabilitySlot.objects.values_list('start', 'end')
)
self.assertEqual(a_pre, x_pre)
scheduling_tasks.populate_slots()
expected_post = [
(
r_1_s_time,
r_1_e_time,
),
(
r_1_s_time + datetime.timedelta(days=1),
r_1_e_time + datetime.timedelta(days=1),
),
(
r_1_s_time + datetime.timedelta(days=2),
r_1_e_time + datetime.timedelta(days=2),
),
(
r_1_s_time + datetime.timedelta(days=3),
r_1_e_time + datetime.timedelta(days=3),
)
]
actual_post = list(
availability.AvailabilitySlot.objects.values_list('start', 'end')
)
self.assertEqual(actual_post, expected_post)
self.assertTrue(jrpc_rules_if.remove_rule(self.__gs_1_id, r_1_id))
self.assertListEqual(
list(availability.AvailabilitySlot.objects.all()), []
)
self.assertListEqual(
list(operational.OperationalSlot.objects.all()), []
)
def test_1_compatibility_sc_channel_added_deleted(self):
"""INTR test: compatibility changed generates operational slots
1) +GS_CH
2) +RULE
3) +SC_CH
4) -SC_CH
5) -RULE
6) -GS_CH
OperationalSlots should be available only in bewteen steps 3 and 4.
"""
if self.__verbose_testing:
print('##### test_add_slots: no rules')
self.__sc_1 = db_tools.create_sc(
user_profile=self.__user_profile,
identifier=self.__sc_1_id,
tle_id=self.__sc_1_tle_id,
)
self.assertTrue(
jrpc_gs_ch_if.gs_channel_create(
groundstation_id=self.__gs_1_id,
channel_id=self.__gs_1_ch_1_id,
configuration=self.__gs_1_ch_1_cfg
),
'Channel should have been created!'
)
r_1_id = jrpc_rules_if.add_rule(self.__gs_1_id, self.__rule_1_cfg)
self.assertIsNot(r_1_id, 0, 'Rule should have been added!')
self.assertTrue(
jrpc_sc_ch_if.sc_channel_create(
spacecraft_id=self.__sc_1_id,
channel_id=self.__sc_1_ch_1_id,
configuration=self.__sc_1_ch_1_cfg
), 'Channel should have been created!'
)
a_slots = availability_models.AvailabilitySlot.objects.get_applicable(
groundstation=self.__gs_1
)
if self.__verbose_testing:
misc.print_list(a_slots, 'AvailabilitySlots')
misc.print_list(
operational_models.OperationalSlot.objects.all(),
'OperationalSlots'
)
self.assertGreaterEqual(
len(operational_models.OperationalSlot.objects.all()), 2
)
self.assertTrue(
jrpc_sc_ch_if.sc_channel_delete(
spacecraft_id=self.__sc_1_id, channel_id=self.__sc_1_ch_1_id
)
)
expected = []
actual = list(
operational_models.OperationalSlot.objects.filter(
state=operational_models.STATE_FREE
).values_list('state')
)
if self.__verbose_testing:
print('>>> window = ' + str(
simulation.OrbitalSimulator.get_simulation_window()
))
misc.print_list(rule_models.AvailabilityRule.objects.all())
misc.print_list(availability_models.AvailabilitySlot.objects.all())
misc.print_list(operational_models.OperationalSlot.objects.all())
misc.print_list(actual)
misc.print_list(expected)
self.assertEqual(actual, expected)
self.assertTrue(
jrpc_rules_if.remove_rule(self.__gs_1_id, r_1_id),
'Rule should have been removed!'
)
expected = []
actual = list(
operational_models.OperationalSlot.objects.filter(
state=operational_models.STATE_FREE
).values_list('state')
)
self.assertEqual(actual, expected)
self.assertTrue(
jrpc_gs_ch_if.gs_channel_delete(
groundstation_id=self.__gs_1_id,
channel_id=self.__gs_1_ch_1_id
),
'Could not delete GroundStationChannel = ' + str(
self.__gs_1_ch_1_id
)
)
expected = []
actual = list(
operational_models.OperationalSlot.objects.filter(
state=operational_models.STATE_FREE
).values_list('state')
)
self.assertEqual(actual, expected)