def test_mix_usage_zero(self):
# If some item has zero usage and drone bandwidth error is still raised,
# check it's not raised for item with zero usage
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 50
}).id)
item1 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 100
}).id,
state=State.online)
self.fit.drones.add(item1)
item2 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 0
}).id,
state=State.online)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.drone_bandwidth)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.output, 50)
self.assertEqual(error1.total_use, 100)
self.assertEqual(error1.item_use, 100)
# Action
error2 = self.get_error(item2, Restriction.drone_bandwidth)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_multiple(self):
# When multiple consumers require less than drone bandwidth output
# alone, but in sum want more than total output, it should be erroneous
# situation
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 40
}).id)
item1 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 25
}).id,
state=State.online)
self.fit.drones.add(item1)
item2 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 20
}).id,
state=State.online)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.drone_bandwidth)
# Verification
self.assertIsNotNone(error1)
self.assertEqual(error1.output, 40)
self.assertEqual(error1.total_use, 45)
self.assertEqual(error1.item_use, 25)
# Action
error2 = self.get_error(item2, Restriction.drone_bandwidth)
# Verification
self.assertIsNotNone(error2)
self.assertEqual(error2.output, 40)
self.assertEqual(error2.total_use, 45)
self.assertEqual(error2.item_use, 20)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass(self):
# When total consumption is less than output, no errors should be raised
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 50
}).id)
item1 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 25
}).id,
state=State.online)
self.fit.drones.add(item1)
item2 = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 20
}).id,
state=State.online)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.drone_bandwidth)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.drone_bandwidth)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_effect_disabled(self):
fit = Fit()
item = Drone(self.mktype(attrs={
AttrId.dmg_mult: 2.5,
AttrId.em_dmg: 52,
AttrId.therm_dmg: 63,
AttrId.kin_dmg: 74,
AttrId.expl_dmg: 85,
self.cycle_attr.id: 4000
},
effects=[self.effect],
default_effect=self.effect).id,
state=State.active)
item.set_effect_mode(self.effect.id, EffectMode.force_stop)
fit.drones.add(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 0)
self.assertAlmostEqual(volley.thermal, 0)
self.assertAlmostEqual(volley.kinetic, 0)
self.assertAlmostEqual(volley.explosive, 0)
self.assertAlmostEqual(volley.total, 0)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_reload(self):
fit = Fit()
item = Drone(
self.mktype(
attrs={
AttrId.dmg_mult: 2.5,
AttrId.em_dmg: 52,
AttrId.therm_dmg: 63,
AttrId.kin_dmg: 74,
AttrId.expl_dmg: 85,
self.cycle_attr.id: 4000},
effects=[self.effect],
default_effect=self.effect).id,
state=State.active)
fit.drones.add(item)
# Verification
dps = item.get_dps(reload=True)
self.assertAlmostEqual(dps.em, 32.5)
self.assertAlmostEqual(dps.thermal, 39.375)
self.assertAlmostEqual(dps.kinetic, 46.25)
self.assertAlmostEqual(dps.explosive, 53.125)
self.assertAlmostEqual(dps.total, 171.25)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_generic(self):
fit = Fit()
item = Drone(
self.mktype(
attrs={
AttrId.dmg_mult: 2.5,
AttrId.em_dmg: 52,
AttrId.therm_dmg: 63,
AttrId.kin_dmg: 74,
AttrId.expl_dmg: 85,
self.cycle_attr.id: 4000},
effects=[self.effect],
default_effect=self.effect).id,
state=State.active)
fit.drones.add(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 130)
self.assertAlmostEqual(volley.thermal, 157.5)
self.assertAlmostEqual(volley.kinetic, 185)
self.assertAlmostEqual(volley.explosive, 212.5)
self.assertAlmostEqual(volley.total, 685)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_use_multiple(self):
self.fit.drones.add(Drone(self.mktype(attrs={AttrId.volume: 50}).id))
self.fit.drones.add(Drone(self.mktype(attrs={AttrId.volume: 30}).id))
# Verification
self.assertAlmostEqual(self.fit.stats.dronebay.used, 80)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_multiple(self):
self.fit.drones.add(Drone(self.mktype().id, state=State.online))
self.fit.drones.add(Drone(self.mktype().id, state=State.online))
# Verification
self.assertEqual(self.fit.stats.launched_drones.used, 2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_modified(self):
# Make sure modified drone bandwidth values are taken
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.drone_bandwidth: 50
}).id)
src_attr = self.mkattr()
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=AttrId.drone_bandwidth_used,
operator=ModOperator.post_mul,
affector_attr_id=src_attr.id)
effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier])
item = Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 50,
src_attr.id: 2
},
effects=[effect]).id,
state=State.online)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.drone_bandwidth)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.output, 50)
self.assertEqual(error.total_use, 100)
self.assertEqual(error.item_use, 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_no_effect(self):
tgt_attr = self.mkattr()
src_attr = self.mkattr()
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.owner_skillrq,
affectee_domain=ModDomain.target,
affectee_filter_extra_arg=56,
affectee_attr_id=tgt_attr.id,
operator=ModOperator.post_percent,
affector_attr_id=src_attr.id)
effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier])
influence_src = Implant(
self.mktype(attrs={
src_attr.id: 20
}, effects=[effect]).id)
influence_tgt = Drone(
self.mktype(
attrs={
tgt_attr.id: 100,
AttrId.required_skill_1: 56,
AttrId.required_skill_1_level: 1
}).id)
self.fit.drones.add(influence_tgt)
# Action
self.fit.implants.add(influence_src)
# Verification
self.assertAlmostEqual(influence_tgt.attrs[tgt_attr.id], 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_item_not_loaded(self):
self.fit.drones.add(Drone(self.allocate_type_id(), state=State.online))
# Verification
self.assertEqual(self.fit.stats.launched_drones.used, 1)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_item_class_other(self):
self.fit.drones.add(Drone(self.mktype().id))
# Verification
self.assertEqual(self.fit.stats.fighter_squads.used, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_multiple(self):
self.fit.drones.add(
Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 50
}).id,
state=State.online))
self.fit.drones.add(
Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 30
}).id,
state=State.online))
# Verification
self.assertAlmostEqual(self.fit.stats.drone_bandwidth.used, 80)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_item_not_loaded(self):
self.fit.drones.add(Drone(self.allocate_type_id()))
# Verification
self.assertAlmostEqual(self.fit.stats.dronebay.used, 0)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_item_class_other(self):
item_type = self.mktype(group_id=12,
attrs={AttrId.max_group_fitted: 1})
item1 = Drone(item_type.id)
self.fit.drones.add(item1)
item2 = Drone(item_type.id)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.max_group_fitted)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.max_group_fitted)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_drone_fail_not_loaded(self):
item = Drone(self.allocate_type_id())
self.fit.drones.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_use_single_no_rounding(self):
self.fit.drones.add(
Drone(self.mktype(attrs={
AttrId.volume: 55.5555555555
}).id))
# Verification
self.assertAlmostEqual(self.fit.stats.dronebay.used, 55.5555555555)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_greater(self):
self.fit.character = Character(self.mktype(
attrs={AttrId.max_active_drones: 5}).id)
item_type = self.mktype()
item1 = Drone(item_type.id, state=State.online)
item2 = Drone(item_type.id, state=State.online)
self.fit.drones.add(item1)
self.fit.drones.add(item2)
# Action
error1 = self.get_error(item1, Restriction.launched_drone)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.launched_drone)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_drone_pass_loaded(self):
item = Drone(self.mktype().id)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.loaded_item)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_drone_pass(self):
item = Drone(self.mktype(category_id=TypeCategoryId.drone).id)
self.fit.drones.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_drone(self):
drone = Drone(self.make_item_types())
self.fit.drones.add(drone)
self.assertAlmostEqual(drone.attrs[self.tgt_attr_id], 18)
# Action
self.fit.solar_system.source = 'src2'
# Verification
self.assertAlmostEqual(drone.attrs[self.tgt_attr_id], 14)
# 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.drone_bandwidth: 0}).id)
item = Drone(self.allocate_type_id(), state=State.online)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.drone_bandwidth)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_ship_absent(self):
# Check that restriction isn't applied when fit doesn't have ship
item = Drone(self.mktype(group_id=None).id)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.drone_group)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_ship_not_loaded(self):
self.fit.ship = Ship(self.allocate_type_id())
item = Drone(self.mktype(group_id=56).id)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.drone_group)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_use_single_no_rounding(self):
self.fit.drones.add(
Drone(self.mktype(attrs={
AttrId.drone_bandwidth_used: 55.5555555555
}).id,
state=State.online))
# Verification
self.assertAlmostEqual(self.fit.stats.drone_bandwidth.used,
55.5555555555)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_state(self):
self.fit.character = Character(self.mktype(
attrs={AttrId.max_active_drones: 0}).id)
item = Drone(self.mktype().id, state=State.offline)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.launched_drone)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_drone_fail_category_other(self):
item = Drone(self.mktype(category_id=1008).id)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.item_class)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.item_class, Drone)
self.assertCountEqual(error.allowed_classes, [])
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail_char_not_loaded(self):
self.fit.character = Character(self.allocate_type_id())
item = Drone(self.mktype().id, state=State.online)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.launched_drone)
# 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_domain_other(self):
influence_tgt = Drone(
self.mktype(group_id=35, attrs={
self.tgt_attr.id: 100
}).id)
self.fit.drones.add(influence_tgt)
# Action
self.fit.rigs.add(self.influence_src)
# Verification
self.assertAlmostEqual(influence_tgt.attrs[self.tgt_attr.id], 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_skill_other(self):
influence_tgt = Drone(self.mktype(attrs={
self.tgt_attr.id: 100,
AttrId.required_skill_1: 87,
AttrId.required_skill_1_level: 1}).id)
self.fit.drones.add(influence_tgt)
# Action
self.fit.rigs.add(self.influence_src)
# Verification
self.assertAlmostEqual(influence_tgt.attrs[self.tgt_attr.id], 100)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_attr_therm_absent(self):
fit = Fit()
item = Drone(self.mktype(attrs={
AttrId.dmg_mult: 2.5,
AttrId.em_dmg: 52,
AttrId.kin_dmg: 74,
AttrId.expl_dmg: 85,
self.cycle_attr.id: 4000
},
effects=[self.effect],
default_effect=self.effect).id,
state=State.active)
fit.drones.add(item)
# Verification
volley = item.get_volley()
self.assertAlmostEqual(volley.em, 130)
self.assertAlmostEqual(volley.thermal, 0)
self.assertAlmostEqual(volley.kinetic, 185)
self.assertAlmostEqual(volley.explosive, 212.5)
self.assertAlmostEqual(volley.total, 527.5)
# Cleanup
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_fail_ship_attr_absent(self):
self.fit.ship = Ship(self.mktype().id)
item = Drone(self.mktype(attrs={AttrId.volume: 50}).id)
self.fit.drones.add(item)
# Action
error = self.get_error(item, Restriction.dronebay_volume)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.output, 0)
self.assertEqual(error.total_use, 50)
self.assertEqual(error.item_use, 50)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)