def setUp(self):
CalculatorTestCase.setUp(self)
self.tgt_attr = self.mkattr()
src_attr = self.mkattr()
modifier = self.mkmod(
affectee_filter=ModAffecteeFilter.domain,
affectee_domain=ModDomain.ship,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_div,
affector_attr_id=src_attr.id)
effect = self.mkeffect(
category_id=EffectCategoryId.passive, modifiers=[modifier])
self.influence_src1 = Implant(self.mktype(
attrs={src_attr.id: 1.2}, effects=[effect]).id)
self.influence_src2 = Implant(self.mktype(
attrs={src_attr.id: 1.5}, effects=[effect]).id)
self.influence_src3 = Implant(self.mktype(
attrs={src_attr.id: 0.1}, effects=[effect]).id)
self.influence_src4 = Implant(self.mktype(
attrs={src_attr.id: 0.75}, effects=[effect]).id)
self.influence_src5 = Implant(self.mktype(
attrs={src_attr.id: 5}, effects=[effect]).id)
self.influence_tgt = Rig(self.mktype(attrs={self.tgt_attr.id: 100}).id)
self.fit.implants.add(self.influence_src1)
self.fit.implants.add(self.influence_src2)
self.fit.implants.add(self.influence_src3)
self.fit.implants.add(self.influence_src4)
self.fit.implants.add(self.influence_src5)
self.fit.rigs.add(self.influence_tgt)
def test_clear(self):
fit = Fit()
item1 = Implant(self.mktype().id)
item2 = Implant(self.mktype().id)
fit.implants.add(item1)
fit.implants.add(item2)
# Action
fit.implants.clear()
# Verification
self.assertEqual(len(fit.implants), 0)
# Cleanup
self.assert_item_buffers_empty(item1)
self.assert_item_buffers_empty(item2)
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_pass_items_not_loaded(self):
item_type_id = self.allocate_type_id()
item1 = Implant(item_type_id)
item2 = Implant(item_type_id)
self.fit.implants.add(item1)
self.fit.implants.add(item2)
# Action
error1 = self.get_error(item1, Restriction.implant_index)
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.implant_index)
self.assertIsNone(error2)
# 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.domain_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 = Rig(
self.mktype(
attrs={
tgt_attr.id: 100,
AttrId.required_skill_1: 56,
AttrId.required_skill_1_level: 1
}).id)
self.fit.rigs.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_cap_update(self):
# If cap updates, capped attributes should be updated too
item = Rig(
self.mktype(attrs={
self.capped_attr.id: 3,
self.src_attr.id: 6,
self.capping_attr.id: 2
},
effects=[self.effect]).id)
self.fit.rigs.add(item)
# Check attribute vs initial cap
self.assertAlmostEqual(item.attrs[self.capped_attr.id], 2)
# Add something which changes capping attribute
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.domain,
affectee_domain=ModDomain.ship,
affectee_attr_id=self.capping_attr.id,
operator=ModOperator.post_mul,
affector_attr_id=self.src_attr.id)
effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier])
cap_updater = Implant(
self.mktype(attrs={
self.src_attr.id: 3.5
}, effects=[effect]).id)
self.fit.implants.add(cap_updater)
# Verification
# As capping attribute is updated, capped attribute must be updated too
self.assertAlmostEqual(item.attrs[self.capped_attr.id], 7)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_slots_different(self):
# Items taking different slots shouldn't trigger any errors
item1 = Implant(self.mktype(attrs={self.index_attr.id: 120}).id)
item2 = Implant(self.mktype(attrs={self.index_attr.id: 121}).id)
self.fit.implants.add(item1)
self.fit.implants.add(item2)
# Action
error1 = self.get_error(item1, Restriction.implant_index)
# Verification
self.assertIsNone(error1)
# Action
error2 = self.get_error(item2, Restriction.implant_index)
# Verification
self.assertIsNone(error2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_power_output(self):
attr = self.mkattr(attr_id=AttrId.power_output)
item = Implant(self.mktype(attrs={attr.id: 2.6666}).id)
self.fit.implants.add(item)
# Verification
self.assertAlmostEqual(item.attrs[attr.id], 2.67)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_fail(self):
# Check that if 2 or more items are put into single slot index, error is
# raised
item_type = self.mktype(attrs={self.index_attr.id: 120})
item1 = Implant(item_type.id)
item2 = Implant(item_type.id)
self.fit.implants.add(item1)
self.fit.implants.add(item2)
# Action
error1 = self.get_error(item1, Restriction.implant_index)
self.assertIsNotNone(error1)
self.assertEqual(error1.slot_index, 120)
# Action
error2 = self.get_error(item2, Restriction.implant_index)
self.assertIsNotNone(error2)
self.assertEqual(error2.slot_index, 120)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_skill(self):
influence_src1 = Implant(self.mktype(
category_id=TypeCategoryId.skill,
attrs={self.src_attr.id: 50},
effects=[self.effect]).id)
influence_src2 = Implant(self.mktype(
category_id=TypeCategoryId.skill,
attrs={self.src_attr.id: 100},
effects=[self.effect]).id)
self.fit.implants.add(influence_src1)
self.fit.implants.add(influence_src2)
influence_tgt = Rig(self.mktype(attrs={self.tgt_attr.id: 100}).id)
# Action
self.fit.rigs.add(influence_tgt)
# Verification
self.assertAlmostEqual(influence_tgt.attrs[self.tgt_attr.id], 300)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_implant_fail_not_loaded(self):
item = Implant(self.allocate_type_id())
self.fit.implants.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_domain_character(self):
influence_tgt = Implant(self.mktype(attrs={self.tgt_attr.id: 100}).id)
self.fit.implants.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_implant_pass_loaded(self):
item = Implant(self.mktype().id)
self.fit.implants.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_pass(self):
# Single item which takes some slot shouldn't trigger any errors
item = Implant(self.mktype(attrs={self.index_attr.id: 120}).id)
self.fit.implants.add(item)
# Action
error = self.get_error(item, Restriction.implant_index)
# Verification
self.assertIsNone(error)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_implant(self):
implant = Implant(self.make_item_types())
self.fit.implants.add(implant)
self.assertAlmostEqual(implant.attrs[self.tgt_attr_id], 18)
# Action
self.fit.solar_system.source = 'src2'
# Verification
self.assertAlmostEqual(implant.attrs[self.tgt_attr_id], 14)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_add_item(self):
fit = Fit()
item = Implant(self.mktype().id)
# Action
fit.implants.add(item)
# Verification
self.assertEqual(len(fit.implants), 1)
self.assertIn(item, fit.implants)
# Cleanup
self.assert_item_buffers_empty(item)
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_absent_default_value(self):
# Default value should be used if attribute value is not available on
# item type
attr = self.mkattr(default_value=5.6)
item = Implant(self.mktype().id)
# Action
self.fit.implants.add(item)
# Verification
self.assertAlmostEqual(item.attrs[attr.id], 5.6)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_remove_item_failure(self):
fit = Fit()
item = Implant(self.mktype().id)
# Action
with self.assertRaises(KeyError):
fit.implants.remove(item)
# Verification
self.assertEqual(len(fit.implants), 0)
# Cleanup
self.assert_item_buffers_empty(item)
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_implant_fail_attr_absent(self):
item = Implant(self.mktype(category_id=1008).id)
self.fit.implants.add(item)
# Action
error = self.get_error(item, Restriction.item_class)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.item_class, Implant)
self.assertCountEqual(error.allowed_classes, [])
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_bool(self):
fit = Fit()
item = Implant(self.mktype().id)
self.assertIs(bool(fit.implants), False)
fit.implants.add(item)
self.assertIs(bool(fit.implants), True)
fit.implants.remove(item)
self.assertIs(bool(fit.implants), False)
# Cleanup
self.assert_item_buffers_empty(item)
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_implant_pass(self):
item = Implant(
self.mktype(category_id=TypeCategoryId.implant,
attrs={
AttrId.implantness: 3
}).id)
self.fit.implants.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_domain_character(self):
item = Implant(
self.mktype(attrs={
self.tgt_attr.id: 100,
self.src_attr.id: 20
},
effects=[self.effect]).id)
# Action
self.fit.implants.add(item)
# Verification
self.assertAlmostEqual(item.attrs[self.tgt_attr.id], 120)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_calculation(self):
attr1 = self.mkattr()
attr2 = self.mkattr()
attr3 = self.mkattr()
attr4 = self.mkattr()
modifier1 = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.self,
affectee_attr_id=attr2.id,
operator=ModOperator.post_mul,
affector_attr_id=attr1.id)
effect1 = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier1])
modifier2 = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.ship,
affectee_attr_id=attr3.id,
operator=ModOperator.post_percent,
affector_attr_id=attr2.id)
effect2 = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier2])
modifier3 = self.mkmod(affectee_filter=ModAffecteeFilter.domain,
affectee_domain=ModDomain.ship,
affectee_attr_id=attr4.id,
operator=ModOperator.post_percent,
affector_attr_id=attr3.id)
effect3 = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier3])
implant = Implant(
self.mktype(attrs={
attr1.id: 5,
attr2.id: 20
},
effects=(effect1, effect2)).id)
ship = Ship(self.mktype(attrs={attr3.id: 150}, effects=[effect3]).id)
rig = Rig(self.mktype(attrs={attr4.id: 12.5}).id)
self.fit.implants.add(implant)
self.fit.ship = ship
# Action
self.fit.rigs.add(rig)
# Verification
# If everything is processed properly, item1 will multiply attr2 by
# attr1 on self, resulting in 20 * 5 = 100, then apply it as percentage
# modifier on ship's (item2) attr3, resulting in 150 + 100% = 300, then
# it is applied to all entities assigned to ship, including item3, to
# theirs attr4 as percentage modifier again - so final result is 12.5 +
# 300% = 50
self.assertAlmostEqual(rig.attrs[attr4.id], 50)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def setUp(self):
CalculatorTestCase.setUp(self)
self.tgt_attr = self.mkattr()
src_attr = self.mkattr()
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.item,
affectee_domain=ModDomain.ship,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_percent,
affector_attr_id=src_attr.id)
effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier])
self.influence_src = Implant(
self.mktype(attrs={
src_attr.id: 20
}, effects=[effect]).id)
def test_cap_attr_unmodified(self):
# Make sure that item's own specified attribute value is taken as cap
item = Implant(
self.mktype(attrs={
self.capped_attr.id: 3,
self.src_attr.id: 6,
self.capping_attr.id: 2
},
effects=[self.effect]).id)
self.fit.implants.add(item)
# Verification
self.assertAlmostEqual(item.attrs[self.capped_attr.id], 2)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def test_pass_item_class_other(self):
# Check that restriction is not applied to items which are not drones
self.fit.ship = Ship(
self.mktype(attrs={
AttrId.allowed_drone_group_1: 4
}).id)
item = Implant(self.mktype(group_id=56).id)
self.fit.implants.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_cap_default(self):
# Check that cap is applied properly when item doesn't have base value
# of capping attribute
item = Implant(
self.mktype(attrs={
self.capped_attr.id: 3,
self.src_attr.id: 6
},
effects=[self.effect]).id)
self.fit.implants.add(item)
# Verification
self.assertAlmostEqual(item.attrs[self.capped_attr.id], 5)
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)
def setUp(self):
CalculatorTestCase.setUp(self)
self.tgt_attr = self.mkattr()
src_attr = self.mkattr()
modifier = self.mkmod(affectee_filter=ModAffecteeFilter.owner_skillrq,
affectee_domain=ModDomain.character,
affectee_filter_extra_arg=EosTypeId.current_self,
affectee_attr_id=self.tgt_attr.id,
operator=ModOperator.post_percent,
affector_attr_id=src_attr.id)
effect = self.mkeffect(category_id=EffectCategoryId.passive,
modifiers=[modifier])
self.influence_src_type = self.mktype(attrs={src_attr.id: 20},
effects=[effect])
self.influence_src = Implant(self.influence_src_type.id)
def test_add_item_type_failure(self):
fit = Fit()
item_type = self.mktype()
item = Implant(item_type.id)
# Action
with self.assertRaises(TypeError):
fit.skills.add(item)
# Verification
self.assertEqual(len(fit.skills), 0)
self.assertNotIn(item, fit.skills)
self.assertNotIn(item_type.id, fit.skills)
fit.implants.add(item)
# Cleanup
self.assert_item_buffers_empty(item)
self.assert_solsys_buffers_empty(fit.solar_system)
self.assert_log_entries(0)
def test_skill_other(self):
influence_tgt = Implant(
self.mktype(
attrs={
self.tgt_attr.id: 100,
AttrId.required_skill_1: 87,
AttrId.required_skill_1_level: 1
}).id)
self.fit.implants.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_single_replacement(self):
item = Implant(
self.mktype(category_id=TypeCategoryId.implant,
attrs={
AttrId.boosterness: 3
}).id)
self.fit.implants.add(item)
# Action
error = self.get_error(item, Restriction.item_class)
# Verification
self.assertIsNotNone(error)
self.assertEqual(error.item_class, Implant)
self.assertCountEqual(error.allowed_classes, [Booster])
# Cleanup
self.assert_solsys_buffers_empty(self.fit.solar_system)
self.assert_log_entries(0)