def setUp(self):
super().setUp()
self.tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.mod_sub
modifier.tgt_attr = self.tgt_attr.id
modifier.domain = Domain.ship
modifier.filter_type = FilterType.all_
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier, )
self.influence_source1 = IndependentItem(
self.ch.type_(type_id=1,
effects=(effect, ),
attributes={src_attr.id: -10}))
self.influence_source2 = IndependentItem(
self.ch.type_(type_id=2,
effects=(effect, ),
attributes={src_attr.id: 20}))
self.influence_source3 = IndependentItem(
self.ch.type_(type_id=3,
effects=(effect, ),
attributes={src_attr.id: -53}))
self.influence_target = ShipItem(
self.ch.type_(type_id=4, attributes={self.tgt_attr.id: 100}))
self.fit.items.add(self.influence_source1)
self.fit.items.add(self.influence_source2)
self.fit.items.add(self.influence_source3)
self.fit.items.add(self.influence_target)
def test_character(self):
tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.post_percent
modifier.tgt_attr = tgt_attr.id
modifier.domain = Domain.character
modifier.filter_type = None
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier, )
influence_source = IndependentItem(
self.ch.type_(type_id=1,
effects=(effect, ),
attributes={src_attr.id: 20}))
self.fit.items.add(influence_source)
item = self.ch.type_(type_id=2, attributes={tgt_attr.id: 100})
influence_target1 = IndependentItem(item)
self.fit.character = influence_target1
self.assertNotAlmostEqual(influence_target1.attributes[tgt_attr.id],
100)
self.fit.character = None
influence_target2 = IndependentItem(item)
self.fit.character = influence_target2
self.assertNotAlmostEqual(influence_target2.attributes[tgt_attr.id],
100)
self.fit.items.remove(influence_source)
self.fit.character = None
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_implant(self):
influence_source1 = IndependentItem(self.ch.type_(
type_id=1, effects=(self.effect,), category=Category.implant, attributes={self.src_attr.id: 50}))
influence_source2 = IndependentItem(self.ch.type_(
type_id=2, effects=(self.effect,), category=Category.implant, attributes={self.src_attr.id: 100}))
self.fit.items.add(influence_source1)
self.fit.items.add(influence_source2)
influence_target = ShipItem(self.ch.type_(type_id=3, attributes={self.tgt_attr.id: 100}))
self.fit.items.add(influence_target)
self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id], 300)
self.fit.items.remove(influence_source1)
self.fit.items.remove(influence_source2)
self.fit.items.remove(influence_target)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_log_other(self):
# Check how unknown operator value influences
# attribute calculator
tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
invalid_modifier = Modifier()
invalid_modifier.state = State.offline
invalid_modifier.scope = Scope.local
invalid_modifier.src_attr = src_attr.id
invalid_modifier.operator = 1008
invalid_modifier.tgt_attr = tgt_attr.id
invalid_modifier.domain = Domain.self_
invalid_modifier.filter_type = None
invalid_modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (invalid_modifier,)
holder = IndependentItem(self.ch.type_(
type_id=83, effects=(effect,), attributes={src_attr.id: 1.2, tgt_attr.id: 100}))
self.fit.items.add(holder)
self.assertAlmostEqual(holder.attributes[tgt_attr.id], 100)
self.assertEqual(len(self.log), 1)
log_record = self.log[0]
self.assertEqual(log_record.name, 'eos.fit.attribute_calculator.map')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(log_record.msg, 'malformed modifier on item 83: unknown operator 1008')
self.fit.items.remove(holder)
self.assert_link_buffers_empty(self.fit)
def test_error(self):
tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.post_percent
modifier.tgt_attr = tgt_attr.id
modifier.domain = Domain.target
modifier.filter_type = None
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier, )
influence_source = IndependentItem(
self.ch.type_(type_id=102,
effects=(effect, ),
attributes={src_attr.id: 20}))
# This functionality isn't implemented for now
self.fit.items.add(influence_source)
self.assertEqual(len(self.log), 2)
for log_record in self.log:
self.assertEqual(log_record.name,
'eos.fit.attribute_calculator.register')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(
log_record.msg,
'malformed modifier on item 102: unsupported target '
'domain {} for direct modification'.format(Domain.target))
self.fit.items.remove(influence_source)
self.assert_link_buffers_empty(self.fit)
def test_cap_modified(self):
# Make sure that holder's own specified attribute
# value is taken as cap, and it's taken with all
# modifications applied onto it
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = self.source_attr.id
modifier.operator = Operator.post_mul
modifier.tgt_attr = self.capping_attr.id
modifier.domain = Domain.self_
modifier.filter_type = None
modifier.filter_value = None
effect = self.ch.effect(effect_id=2, category=EffectCategory.passive)
effect.modifiers = (modifier, )
holder = IndependentItem(
self.ch.type_(type_id=1,
effects=(self.effect, effect),
attributes={
self.capped_attr.id: 3,
self.source_attr.id: 6,
self.capping_attr.id: 0.1
}))
self.fit.items.add(holder)
# Attr value is 3 * 6 = 18, but cap value is 0.1 * 6 = 0.6
self.assertAlmostEqual(holder.attributes[self.capped_attr.id], 0.6)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_cpu_modified(self):
src_attr = self.ch.attribute(attribute_id=1)
tgt_attr = self.ch.attribute(attribute_id=Attribute.cpu)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.post_percent
modifier.tgt_attr = tgt_attr.id
modifier.domain = Domain.self_
modifier.filter_type = None
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier, )
holder = IndependentItem(
self.ch.type_(type_id=1,
effects=(effect, ),
attributes={
src_attr.id: 20,
tgt_attr.id: 1.9444
}))
self.fit.items.add(holder)
self.assertAlmostEqual(holder.attributes[tgt_attr.id], 2.33)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_combination(self):
tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
invalid_modifier = Modifier()
invalid_modifier.state = State.offline
invalid_modifier.scope = Scope.local
invalid_modifier.src_attr = src_attr.id
invalid_modifier.operator = 1008
invalid_modifier.tgt_attr = tgt_attr.id
invalid_modifier.domain = Domain.self_
invalid_modifier.filter_type = None
invalid_modifier.filter_value = None
valid_modifier = Modifier()
valid_modifier.state = State.offline
valid_modifier.scope = Scope.local
valid_modifier.src_attr = src_attr.id
valid_modifier.operator = Operator.post_mul
valid_modifier.tgt_attr = tgt_attr.id
valid_modifier.domain = Domain.self_
valid_modifier.filter_type = None
valid_modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (invalid_modifier, valid_modifier)
holder = IndependentItem(self.ch.type_(
type_id=1, effects=(effect,), attributes={src_attr.id: 1.5, tgt_attr.id: 100}))
self.fit.items.add(holder)
# Make sure presence of invalid operator doesn't prevent
# from calculating value based on valid modifiers
self.assertNotAlmostEqual(holder.attributes[tgt_attr.id], 100)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 1)
self.assert_link_buffers_empty(self.fit)
def test_error(self):
tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.post_percent
modifier.tgt_attr = tgt_attr.id
modifier.domain = Domain.space
modifier.filter_type = None
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier, )
influence_source = IndependentItem(
self.ch.type_(type_id=34,
effects=(effect, ),
attributes={src_attr.id: 20}))
# Space domain was introduced in Eos as holder to contain in-space
# items like missiles or drones, but it can't be targeted directly
self.fit.items.add(influence_source)
self.assertEqual(len(self.log), 2)
for log_record in self.log:
self.assertEqual(log_record.name,
'eos.fit.attribute_calculator.register')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(
log_record.msg,
'malformed modifier on item 34: unsupported target '
'domain {} for direct modification'.format(Domain.space))
self.fit.items.remove(influence_source)
self.assert_link_buffers_empty(self.fit)
def test_error(self):
tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.post_percent
modifier.tgt_attr = tgt_attr.id
modifier.domain = Domain.other
modifier.filter_type = FilterType.all_
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier,)
influence_source = IndependentItem(self.ch.type_(
type_id=90, effects=(effect,), attributes={src_attr.id: 20}))
# Charge's container or module's charge can't be 'owner'
# of other holders, thus such modification type is unsupported
self.fit.items.add(influence_source)
self.assertEqual(len(self.log), 2)
for log_record in self.log:
self.assertEqual(log_record.name, 'eos.fit.attribute_calculator.register')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(
log_record.msg,
'malformed modifier on item 90: unsupported target domain '
'{} for filtered modification'.format(Domain.other)
)
self.fit.items.remove(influence_source)
self.assert_link_buffers_empty(self.fit)
def test_error(self):
tgt_attr = self.ch.attribute(attribute_id=1)
src_attr = self.ch.attribute(attribute_id=2)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.post_percent
modifier.tgt_attr = tgt_attr.id
modifier.domain = Domain.area
modifier.filter_type = FilterType.all_
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier,)
influence_source = IndependentItem(self.ch.type_(
type_id=56, effects=(effect,), attributes={src_attr.id: 20}))
# This domain just isn't used in EVE and unsupported by Eos by design
self.fit.items.add(influence_source)
self.assertEqual(len(self.log), 2)
for log_record in self.log:
self.assertEqual(log_record.name, 'eos.fit.attribute_calculator.register')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(
log_record.msg,
'malformed modifier on item 56: unsupported target domain '
'{} for filtered modification'.format(Domain.area)
)
self.fit.items.remove(influence_source)
self.assert_link_buffers_empty(self.fit)
def setUp(self):
super().setUp()
self.attr1 = self.ch.attribute(attribute_id=1)
self.attr2 = self.ch.attribute(attribute_id=2)
self.attr3 = self.ch.attribute(attribute_id=3)
self.holder = IndependentItem(self.ch.type_(type_id=1, attributes={self.attr1.id: 5, self.attr2.id: 10}))
self.fit.items.add(self.holder)
self.holder.attributes._MutableAttributeMap__modified_attributes = {self.attr2.id: 20, self.attr3.id: 40}
def test_cpu_down(self):
attr = self.ch.attribute(attribute_id=Attribute.cpu)
holder = IndependentItem(
self.ch.type_(type_id=1, attributes={attr.id: 2.3333}))
self.fit.items.add(holder)
self.assertAlmostEqual(holder.attributes[attr.id], 2.33)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_character(self):
influence_target = IndependentItem(self.ch.type_(type_id=2, attributes={self.tgt_attr.id: 100}))
self.fit.character = influence_target
self.assertNotAlmostEqual(influence_target.attributes[self.tgt_attr.id], 100)
self.fit.items.remove(self.influence_source)
self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id], 100)
self.fit.character = None
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_power_output(self):
attr = self.ch.attribute(attribute_id=Attribute.power_output)
holder = IndependentItem(
self.ch.type_(type_id=1, attributes={attr.id: 2.6666}))
self.fit.items.add(holder)
self.assertAlmostEqual(holder.attributes[attr.id], 2.67)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def setUp(self):
super().setUp()
self.tgt_attr = self.ch.attribute(attribute_id=1, stackable=1)
src_attr1 = self.ch.attribute(attribute_id=2)
src_attr2 = self.ch.attribute(attribute_id=3)
src_attr3 = self.ch.attribute(attribute_id=4)
src_attr4 = self.ch.attribute(attribute_id=5)
modifier_off = Modifier()
modifier_off.state = State.offline
modifier_off.scope = Scope.local
modifier_off.src_attr = src_attr1.id
modifier_off.operator = Operator.post_mul
modifier_off.tgt_attr = self.tgt_attr.id
modifier_off.domain = Domain.self_
modifier_off.filter_type = None
modifier_off.filter_value = None
modifier_on = Modifier()
modifier_on.state = State.online
modifier_on.scope = Scope.local
modifier_on.src_attr = src_attr2.id
modifier_on.operator = Operator.post_mul
modifier_on.tgt_attr = self.tgt_attr.id
modifier_on.domain = Domain.self_
modifier_on.filter_type = None
modifier_on.filter_value = None
modifier_act = Modifier()
modifier_act.state = State.active
modifier_act.scope = Scope.local
modifier_act.src_attr = src_attr3.id
modifier_act.operator = Operator.post_mul
modifier_act.tgt_attr = self.tgt_attr.id
modifier_act.domain = Domain.self_
modifier_act.filter_type = None
modifier_act.filter_value = None
modifier_over = Modifier()
modifier_over.state = State.overload
modifier_over.scope = Scope.local
modifier_over.src_attr = src_attr4.id
modifier_over.operator = Operator.post_mul
modifier_over.tgt_attr = self.tgt_attr.id
modifier_over.domain = Domain.self_
modifier_over.filter_type = None
modifier_over.filter_value = None
# Overload category will make sure that holder can enter all states
effect = self.ch.effect(effect_id=1, category=EffectCategory.overload)
effect.modifiers = (modifier_off, modifier_on, modifier_act,
modifier_over)
self.holder = IndependentItem(
self.ch.type_(type_id=1,
effects=(effect, ),
attributes={
self.tgt_attr.id: 100,
src_attr1.id: 1.1,
src_attr2.id: 1.3,
src_attr3.id: 1.5,
src_attr4.id: 1.7
}))
def test_fit_attr_update(self):
# Here we create 2 separate fits with ships affecting it;
# each ship affects module with different strength. When we
# pass module from one fit to another, its internal attribute
# storage should be cleared. If it wasn't cleared, we wouldn't
# be able to get refreshed value of attribute
src_attr = self.ch.attribute(attribute_id=1)
tgt_attr = self.ch.attribute(attribute_id=2)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = src_attr.id
modifier.operator = Operator.post_percent
modifier.tgt_attr = tgt_attr.id
modifier.domain = Domain.ship
modifier.filter_type = FilterType.all_
modifier.filter_value = None
effect = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect.modifiers = (modifier, )
ship1 = IndependentItem(
self.ch.type_(type_id=1,
effects=(effect, ),
attributes={src_attr.id: 10}))
ship2 = IndependentItem(
self.ch.type_(type_id=2,
effects=(effect, ),
attributes={src_attr.id: 20}))
module = ShipItem(
self.ch.type_(type_id=3, attributes={tgt_attr.id: 50}))
fit1 = Fit(self.ch)
fit1.ship = ship1
fit2 = Fit(self.ch)
fit2.ship = ship2
fit1.items.add(module)
self.assertAlmostEqual(module.attributes.get(tgt_attr.id), 55)
fit1.items.remove(module)
fit1.ship = None
self.assert_link_buffers_empty(fit1)
fit2.items.add(module)
self.assertAlmostEqual(module.attributes.get(tgt_attr.id), 60)
fit2.ship = None
fit2.items.remove(module)
self.assert_link_buffers_empty(fit2)
def test_absent_default_value(self):
# Default value should be used if attribute
# value is not available on item
attr = self.ch.attribute(attribute_id=1, default_value=5.6)
holder = IndependentItem(self.ch.type_(type_id=1))
self.fit.items.add(holder)
self.assertAlmostEqual(holder.attributes[attr.id], 5.6)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_other_domain(self):
influence_target = IndependentItem(
self.ch.type_(type_id=2, attributes={self.tgt_attr.id: 100}))
self.fit.items.add(influence_target)
self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id],
100)
self.fit.items.remove(self.influence_source)
self.fit.items.remove(influence_target)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_standard_attr_access(self):
attr = self.ch.attribute(attribute_id=Attribute.skill_level)
holder = IndependentItem(
self.ch.type_(type_id=1, attributes={attr.id: 3}))
self.fit.items.add(holder)
# If .skill direct attribute is not available, standard
# skill level attribute (from item attributes) should
# be returned
self.assertEqual(holder.attributes[Attribute.skill_level], 3)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_attribute_data_error(self):
# Check case when attribute value is available, but
# cache handler doesn't know about such attribute
holder = IndependentItem(self.ch.type_(type_id=57, attributes={105: 20}))
self.fit.items.add(holder)
self.assertRaises(KeyError, holder.attributes.__getitem__, 105)
self.assertEqual(len(self.log), 1)
log_record = self.log[0]
self.assertEqual(log_record.name, 'eos.fit.attribute_calculator.map')
self.assertEqual(log_record.levelno, logging.ERROR)
self.assertEqual(log_record.msg, 'unable to fetch metadata for attribute 105, requested for item 57')
self.fit.items.remove(holder)
self.assert_link_buffers_empty(self.fit)
def test_positioned(self):
holder = IndependentItem(
self.ch.type_(type_id=1,
effects=(self.effect, ),
attributes={
self.tgt_attr.id: 100,
self.src_attr.id: 20
}))
self.fit.character = holder
self.assertNotAlmostEqual(holder.attributes[self.tgt_attr.id], 100)
self.fit.character = None
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_attribute(self):
attr1 = self.ch.attribute(attribute_id=1)
attr2 = self.ch.attribute(attribute_id=2)
attr3 = self.ch.attribute(attribute_id=3)
modifier1 = Modifier()
modifier1.state = State.offline
modifier1.scope = Scope.local
modifier1.src_attr = attr1.id
modifier1.operator = Operator.post_mul
modifier1.tgt_attr = attr2.id
modifier1.domain = Domain.ship
modifier1.filter_type = None
modifier1.filter_value = None
effect1 = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect1.modifiers = (modifier1, )
holder1 = CharacterItem(
self.ch.type_(type_id=1,
effects=(effect1, ),
attributes={attr1.id: 5}))
modifier2 = Modifier()
modifier2.state = State.offline
modifier2.scope = Scope.local
modifier2.src_attr = attr2.id
modifier2.operator = Operator.post_percent
modifier2.tgt_attr = attr3.id
modifier2.domain = Domain.ship
modifier2.filter_type = FilterType.all_
modifier2.filter_value = None
effect2 = self.ch.effect(effect_id=2, category=EffectCategory.passive)
effect2.modifiers = (modifier2, )
holder2 = IndependentItem(
self.ch.type_(type_id=2,
effects=(effect2, ),
attributes={attr2.id: 7.5}))
holder3 = ShipItem(self.ch.type_(type_id=3, attributes={attr3.id:
0.5}))
self.fit.items.add(holder1)
self.fit.ship = holder2
self.fit.items.add(holder3)
self.assertAlmostEqual(holder3.attributes[attr3.id], 0.6875)
holder1.attributes[attr1.id] = 4
# Manually changed attribute must trigger damaging whole chain
# of attributes, effectively allowing us to recalculate its new value
self.assertAlmostEqual(holder3.attributes[attr3.id], 0.65)
self.fit.items.remove(holder1)
self.fit.ship = None
self.fit.items.remove(holder3)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_cap_default(self):
# Check that cap is applied properly when holder
# doesn't have base value of capping attribute
holder = IndependentItem(
self.ch.type_(type_id=1,
effects=(self.effect, ),
attributes={
self.capped_attr.id: 3,
self.source_attr.id: 6
}))
self.fit.items.add(holder)
self.assertAlmostEqual(holder.attributes[self.capped_attr.id], 5)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_absent_base_value_error(self):
# Check case when default value of attribute cannot be
# determined. and item itself doesn't define any value
# either
attr = self.ch.attribute(attribute_id=89)
holder = IndependentItem(self.ch.type_(type_id=649))
self.fit.items.add(holder)
self.assertRaises(KeyError, holder.attributes.__getitem__, attr.id)
self.assertEqual(len(self.log), 1)
log_record = self.log[0]
self.assertEqual(log_record.name, 'eos.fit.attribute_calculator.map')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(log_record.msg, 'unable to find base value for attribute 89 on item 649')
self.fit.items.remove(holder)
self.assert_link_buffers_empty(self.fit)
def test_attribute(self):
attr1 = self.ch.attribute(attribute_id=1)
attr2 = self.ch.attribute(attribute_id=2)
attr3 = self.ch.attribute(attribute_id=3)
modifier1 = Modifier()
modifier1.state = State.offline
modifier1.scope = Scope.local
modifier1.src_attr = attr1.id
modifier1.operator = Operator.post_mul
modifier1.tgt_attr = attr2.id
modifier1.domain = Domain.ship
modifier1.filter_type = None
modifier1.filter_value = None
effect1 = self.ch.effect(effect_id=1, category=EffectCategory.passive)
effect1.modifiers = (modifier1, )
holder1 = CharacterItem(
self.ch.type_(type_id=1,
effects=(effect1, ),
attributes={attr1.id: 5}))
modifier2 = Modifier()
modifier2.state = State.offline
modifier2.scope = Scope.local
modifier2.src_attr = attr2.id
modifier2.operator = Operator.post_percent
modifier2.tgt_attr = attr3.id
modifier2.domain = Domain.ship
modifier2.filter_type = FilterType.all_
modifier2.filter_value = None
effect2 = self.ch.effect(effect_id=2, category=EffectCategory.passive)
effect2.modifiers = (modifier2, )
holder2 = IndependentItem(
self.ch.type_(type_id=2,
effects=(effect2, ),
attributes={attr2.id: 7.5}))
holder3 = ShipItem(self.ch.type_(type_id=3, attributes={attr3.id:
0.5}))
self.fit.items.add(holder1)
self.fit.ship = holder2
self.fit.items.add(holder3)
self.assertAlmostEqual(holder3.attributes[attr3.id], 0.6875)
self.fit.items.remove(holder1)
# When holder1 is removed, attr2 of holder2 and attr3 of holder3
# must be cleaned to allow recalculation of attr3 based on new data
self.assertAlmostEqual(holder3.attributes[attr3.id], 0.5375)
self.fit.ship = None
self.fit.items.remove(holder3)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_independent(self):
holder = IndependentItem(
self.ch.type_(type_id=1,
effects=(self.effect, ),
attributes={
self.tgt_attr.id: 100,
self.src_attr.id: 20
}))
self.fit.items.add(holder)
self.assertNotAlmostEqual(holder.attributes[self.tgt_attr.id], 100)
# We do not test attribute value after item removal here, because
# removed holder (which is both source and target in this test set)
# essentially becomes detached, which is covered by other tests
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_log(self):
self.effect.modifiers = (self.invalid_modifier,)
holder = IndependentItem(self.ch.type_(
type_id=754, effects=(self.effect,), attributes={self.src_attr.id: 20}))
self.fit.items.add(holder)
self.assertEqual(len(self.log), 2)
for log_record in self.log:
self.assertEqual(log_record.name, 'eos.fit.attribute_calculator.register')
self.assertEqual(log_record.levelno, logging.WARNING)
self.assertEqual(
log_record.msg,
'malformed modifier on item 754: unsupported target '
'domain 1972 for filtered modification'
)
self.fit.items.remove(holder)
self.assert_link_buffers_empty(self.fit)
def test_cap_original(self):
# Make sure that holder's own specified attribute
# value is taken as cap
holder = IndependentItem(
self.ch.type_(type_id=1,
effects=(self.effect, ),
attributes={
self.capped_attr.id: 3,
self.source_attr.id: 6,
self.capping_attr.id: 2
}))
self.fit.items.add(holder)
self.assertAlmostEqual(holder.attributes[self.capped_attr.id], 2)
self.fit.items.remove(holder)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_other_holder(self):
# Here we check some "random" holder, w/o linking holders
influence_source = ContainerHolder(
self.ch.type_(type_id=1,
effects=(self.effect, ),
attributes={self.src_attr.id: 20}))
self.fit.items.add(influence_source)
influence_target = IndependentItem(
self.ch.type_(type_id=2, attributes={self.tgt_attr.id: 100}))
self.fit.items.add(influence_target)
self.assertAlmostEqual(influence_target.attributes[self.tgt_attr.id],
100)
self.fit.items.remove(influence_source)
self.fit.items.remove(influence_target)
self.assertEqual(len(self.log), 0)
self.assert_link_buffers_empty(self.fit)
def test_source_attr_update(self):
# Here we check if attributes are updated if fit gets new
# source instance; we do not actually switch source but we
# switch cache_handler, and it should be enough
cache_handler1 = CacheHandler()
cache_handler2 = CacheHandler()
src_attr1 = cache_handler1.attribute(attribute_id=1)
tgt_attr1 = cache_handler1.attribute(attribute_id=2, max_attribute=33)
cache_handler1.attribute(attribute_id=33, default_value=100)
src_attr2 = cache_handler2.attribute(attribute_id=1)
tgt_attr2 = cache_handler2.attribute(attribute_id=2, max_attribute=333)
cache_handler2.attribute(attribute_id=333, default_value=500)
modifier = Modifier()
modifier.state = State.offline
modifier.scope = Scope.local
modifier.src_attr = 1
modifier.operator = Operator.post_percent
modifier.tgt_attr = 2
modifier.domain = Domain.ship
modifier.filter_type = FilterType.all_
modifier.filter_value = None
effect1 = cache_handler1.effect(effect_id=1, category=EffectCategory.passive)
effect1.modifiers = (modifier,)
effect2 = cache_handler1.effect(effect_id=111, category=EffectCategory.passive)
effect2.modifiers = (modifier,)
# Our holders from test environment fo not update undelying
# item automatically when source is changed, thus we do it
# manually
ship_item1 = cache_handler1.type_(type_id=8, effects=(effect1,), attributes={src_attr1.id: 10})
ship_item2 = cache_handler2.type_(type_id=8, effects=(effect2,), attributes={src_attr2.id: 20})
module_item1 = cache_handler1.type_(type_id=4, attributes={tgt_attr1.id: 50})
module_item2 = cache_handler2.type_(type_id=4, attributes={tgt_attr2.id: 75})
fit = Fit(cache_handler1)
ship = IndependentItem(ship_item1)
module = ShipItem(module_item1)
fit.ship = ship
fit.items.add(module)
self.assertAlmostEqual(module.attributes.get(tgt_attr1.id), 55)
# As we have capped attr, this auxiliary map shouldn't be None
self.assertIsNotNone(module.attributes._cap_map)
# Make an 'source switch': remove holders from attribute_calculator
for holder in (ship, module):
disabled_states = set(filter(lambda s: s <= holder.state, State))
fit._link_tracker.disable_states(holder, disabled_states)
fit._link_tracker.remove_holder(holder)
# Refresh holders and replace source
fit.source.cache_handler = cache_handler2
ship.attributes.clear()
ship.item = ship_item2
module.attributes.clear()
module.item = module_item2
# When we cleared holders, auxiliary map for capped attrs should be None.
# Using data in this map, attributes which depend on capping attribute will
# be cleared. If we don't clear it, there're chances that in new data this
# capping-capped attribute pair won't exist, thus if attribute with ID which
# used to cap is changed, it will clear attribute which used to be capped -
# and we do not want it within scope of new data.
self.assertIsNone(module.attributes._cap_map)
# Add holders again, when new items are in holders
for holder in (ship, module):
fit._link_tracker.add_holder(holder)
enabled_states = set(filter(lambda s: s <= holder.state, State))
fit._link_tracker.enable_states(holder, enabled_states)
# Now we should have calculated value based on both updated attribs
# if attribs weren't refreshed, we would use old value for modification
# (10 instead of 20)
self.assertAlmostEqual(module.attributes.get(tgt_attr2.id), 90)
fit.ship = None
fit.items.remove(module)
self.assert_link_buffers_empty(fit)