def test_fail_multiple(self):
# Check that error works for multiple items
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.fighter_heavy_slots: 1
}).id)
item_type = self.mktype(attrs={AttrId.fighter_squadron_is_heavy: 1})
item1 = FighterSquad(item_type.id)
item2 = FighterSquad(item_type.id)
self.fit.fighters.add(item1)
self.fit.fighters.add(item2)
# Action
error1 = self.get_error(item1, Restriction.fighter_squad_heavy)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.used, 2)
self.assertEqual(error1.total, 1)
# Action
error2 = self.get_error(item2, Restriction.fighter_squad_heavy)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.used, 2)
self.assertEqual(error2.total, 1)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_ability_disabling_no_ability(self):
# Setup
src_attr = self.mkattr()
tgt_attr = self.mkattr()
modifier = self.mkmod(
affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=tgt_attr.id,
operator=ModOperator.post_percent,
affector_attr_id=src_attr.id)
effect = self.mkeffect(
effect_id=EffectId.fighter_ability_attack_m,
category_id=EffectCategoryId.active,
modifiers=[modifier])
fighter_type = self.mktype(
attrs={src_attr.id: 50, tgt_attr.id: 10},
effects=[effect],
default_effect=effect,
abilities_data={
FighterAbilityId.pulse_cannon: AbilityData(0, math.inf)})
fit = Fit()
item = FighterSquad(fighter_type.id, state=State.active)
fit.fighters.add(item)
self.assertAlmostEqual(item.attrs[tgt_attr.id], 15)
# Verification
with self.assertRaises(NoSuchAbilityError):
item.set_ability_status(FighterAbilityId.beam_cannon, False)
self.assertIs(item.abilities[FighterAbilityId.pulse_cannon], True)
self.assertAlmostEqual(item.attrs[tgt_attr.id], 15)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_use_multiple(self):
self.fit.fighters.add(FighterSquad(self.mktype().id))
self.fit.fighters.add(FighterSquad(self.mktype().id))
# Verification
self.assertEqual(self.fit.stats.fighter_squads.used, 2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_multiple(self):
item_type = self.mktype(attrs={AttrId.fighter_squadron_is_light: 1.0})
self.fit.fighters.add(FighterSquad(item_type.id))
self.fit.fighters.add(FighterSquad(item_type.id))
# Verification
self.assertEqual(self.fit.stats.fighter_squads_light.used, 2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_ability_disabling_item_not_loaded(self):
# Setup
fit = Fit()
item = FighterSquad(self.allocate_type_id(), state=State.active)
fit.fighters.add(item)
# Verification
with self.assertRaises(NoSuchAbilityError):
item.set_ability_status(FighterAbilityId.beam_cannon, False)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def make_item(self, attrs):
return FighterSquad(self.mktype(attrs=attrs,
effects=(self.effect_attack,
self.effect_kamikaze),
default_effect=self.effect_attack,
abilities_data=self.abilities_data).id,
state=State.active)
def test_status_item_inactive(self):
# Even when item is not set to active, ability statuses should be shown
# like item is active
# Setup
effect1 = self.mkeffect(
effect_id=EffectId.fighter_ability_attack_m,
category_id=EffectCategoryId.active)
effect2 = self.mkeffect(
effect_id=EffectId.fighter_ability_microwarpdrive,
category_id=EffectCategoryId.active)
effect3 = self.mkeffect(
effect_id=EffectId.fighter_ability_missiles,
category_id=EffectCategoryId.active)
fighter_type = self.mktype(
effects=(effect1, effect2, effect3),
default_effect=effect1,
abilities_data={
FighterAbilityId.pulse_cannon: AbilityData(0, math.inf),
FighterAbilityId.microwarpdrive: AbilityData(60, math.inf),
FighterAbilityId.heavy_rocket_salvo_em: AbilityData(0, 12)})
fit = Fit()
item = FighterSquad(fighter_type.id, state=State.online)
fit.fighters.add(item)
# Verification
abilities = item.abilities
self.assertEqual(len(abilities), 3)
self.assertIs(abilities[FighterAbilityId.pulse_cannon], True)
self.assertIs(abilities[FighterAbilityId.microwarpdrive], False)
self.assertIs(abilities[FighterAbilityId.heavy_rocket_salvo_em], False)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_use_item_attr_absent(self):
self.fit.fighters.add(FighterSquad(self.mktype().id))
# Verification
self.assertEqual(self.fit.stats.fighter_squads_light.used, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_item_not_loaded(self):
self.fit.fighters.add(FighterSquad(self.allocate_type_id()))
# Verification
self.assertEqual(self.fit.stats.fighter_squads_light.used, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def setUp(self):
StatsTestCase.setUp(self)
self.mkattr(attr_id=AttrId.em_dmg)
self.mkattr(attr_id=AttrId.therm_dmg)
self.mkattr(attr_id=AttrId.kin_dmg)
self.mkattr(attr_id=AttrId.expl_dmg)
self.mkattr(attr_id=AttrId.dmg_mult)
self.mkattr(attr_id=AttrId.volume)
self.mkattr(attr_id=AttrId.capacity)
self.mkattr(attr_id=AttrId.reload_time)
self.mkattr(attr_id=AttrId.charge_rate)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_em)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_therm)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_kin)
self.mkattr(attr_id=AttrId.fighter_ability_kamikaze_dmg_expl)
cycle_attr = self.mkattr()
effect_dd = self.mkeffect(effect_id=EffectId.projectile_fired,
category_id=EffectCategoryId.active,
duration_attr_id=cycle_attr.id)
effect_suppressor = self.mkeffect(
effect_id=EffectId.fighter_ability_kamikaze,
category_id=EffectCategoryId.target,
duration_attr_id=cycle_attr.id)
item_dd = ModuleHigh(self.mktype(attrs={
AttrId.dmg_mult: 2,
AttrId.capacity: 1,
AttrId.charge_rate: 1,
cycle_attr.id: 2500,
AttrId.reload_time: 2000
},
effects=[effect_dd],
default_effect=effect_dd).id,
state=State.active)
item_dd.charge = Charge(
self.mktype(
attrs={
AttrId.volume: 1.0,
AttrId.em_dmg: 1.2,
AttrId.therm_dmg: 2.4,
AttrId.kin_dmg: 4.8,
AttrId.expl_dmg: 9.6
}).id)
self.item_suppressor = FighterSquad(self.mktype(
attrs={
AttrId.fighter_ability_kamikaze_dmg_em: 50000,
AttrId.fighter_ability_kamikaze_dmg_therm: 50000,
AttrId.fighter_ability_kamikaze_dmg_kin: 50000,
AttrId.fighter_ability_kamikaze_dmg_expl: 50000,
AttrId.fighter_squadron_max_size: 6,
cycle_attr.id: 10000
},
effects=[effect_suppressor],
default_effect=effect_suppressor,
abilities_data={
FighterAbilityId.kamikaze: AbilityData(0, math.inf)
}).id,
state=State.active)
self.fit.modules.high.append(item_dd)
self.fit.fighters.add(self.item_suppressor)
def test_pass_greater(self):
self.fit.ship = Ship(self.mktype(attrs={AttrId.fighter_tubes: 5}).id)
item1 = FighterSquad(self.mktype().id)
item2 = FighterSquad(self.mktype().id)
self.fit.fighters.add(item1)
self.fit.fighters.add(item2)
# Action
error1 = self.get_error(item1, Restriction.fighter_squad)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.fighter_squad)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_item_attr_zero(self):
self.fit.fighters.add(FighterSquad(self.mktype(
attrs={AttrId.fighter_squadron_is_heavy: 0.0}).id))
# Verification
self.assertEqual(self.fit.stats.fighter_squads_heavy.used, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fighter_squad_fail_not_loaded(self):
item = FighterSquad(self.allocate_type_id())
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.loaded_item)
# Verification
self.assertIsNotNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_status_item_not_loaded(self):
# Setup
fit = Fit()
item = FighterSquad(self.allocate_type_id(), state=State.active)
fit.fighters.add(item)
# Verification
self.assertEqual(len(item.abilities), 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_fighter_squad(self):
fighter_squad = FighterSquad(self.make_item_types())
self.fit.fighters.add(fighter_squad)
self.assertAlmostEqual(fighter_squad.attrs[self.tgt_attr_id], 18)
# Action
self.fit.solar_system.source = 'src2'
# Verification
self.assertAlmostEqual(fighter_squad.attrs[self.tgt_attr_id], 14)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_equal(self):
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.fighter_heavy_slots: 2
}).id)
item_type = self.mktype(attrs={AttrId.fighter_squadron_is_heavy: 1})
item1 = FighterSquad(item_type.id)
item2 = FighterSquad(item_type.id)
self.fit.fighters.add(item1)
self.fit.fighters.add(item2)
# Action
error1 = self.get_error(item1, Restriction.fighter_squad_heavy)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.fighter_squad_heavy)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fighter_squad_fail_attr_absent(self):
item = FighterSquad(self.mktype(category_id=TypeCategoryId.fighter).id)
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.item_class)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.item_class, FighterSquad)
self.assertCountEqual(error.allowed_classes, [])
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_ship_not_loaded(self):
self.fit.ship = Ship(self.allocate_type_id())
item = FighterSquad(self.mktype().id)
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.fighter_squad)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.used, 1)
self.assertEqual(error.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_ship_absent(self):
# When stats module does not specify total tube quantity, make sure it's
# assumed to be 0
item = FighterSquad(self.mktype().id)
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.fighter_squad)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.used, 1)
self.assertEqual(error.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_item_not_loaded(self):
# Item still counts even when it's not loaded
self.fit.ship = Ship(self.mktype(attrs={AttrId.fighter_tubes: 0}).id)
item = FighterSquad(self.allocate_type_id())
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.fighter_squad)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.used, 1)
self.assertEqual(error.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_item_attr_absent(self):
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.fighter_light_slots: 0
}).id)
item = FighterSquad(self.mktype().id)
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.fighter_squad_light)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fighter_squad_pass(self):
item = FighterSquad(
self.mktype(category_id=TypeCategoryId.fighter,
attrs={
AttrId.fighter_squadron_is_heavy: 1.0
}).id)
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.item_class)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_item_not_loaded(self):
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.fighter_heavy_slots: 0
}).id)
item = FighterSquad(self.allocate_type_id())
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.fighter_squad_heavy)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_single(self):
# Check that error is raised when quantity of used slot exceeds slot
# quantity provided by ship
self.fit.ship = Ship(self.mktype(attrs={AttrId.fighter_tubes: 0}).id)
item = FighterSquad(self.mktype().id)
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.fighter_squad)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.used, 1)
self.assertEqual(error.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fighter_squad_fail_category_other(self):
item = FighterSquad(
self.mktype(category_id=1008,
attrs={
AttrId.fighter_squadron_is_heavy: 1.0
}).id)
self.fit.fighters.add(item)
# Action
error = self.get_error(item, Restriction.item_class)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.item_class, FighterSquad)
self.assertCountEqual(error.allowed_classes, [])
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def make_item(self, attrs):
return FighterSquad(self.mktype(attrs=attrs,
effects=[self.effect],
default_effect=self.effect,
abilities_data=self.abilities_data).id,
state=State.active)