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_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_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.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 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_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_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_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_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 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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)