def testPass(self): # When total consumption is less than output, # no errors should be raised fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.power: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.power] = 25 holder1.state = State.online fit.items.add(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.power] = 20 holder2.state = State.online fit.items.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.powerOutput] = 50 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.powerGrid) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.powerGrid) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testPassNegativeUse(self): # Check that even if use of one holder exceeds # power grid output, negative use of other holder may help # to avoid raising error fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.power: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.power] = 50 holder1.state = State.online fit.items.add(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.power] = -15 holder2.state = State.online fit.items.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.powerOutput] = 40 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.powerGrid) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.powerGrid) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testMixUsageZero(self): # If some holder has zero usage and power grid error is # still raised, check it's not raised for holder with # zero usage fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.power: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.power] = 100 holder1.state = State.online fit.items.add(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.power] = 0 holder2.state = State.online fit.items.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.powerOutput] = 50 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.powerGrid) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.output, 50) self.assertEqual(restrictionError1.totalUsage, 100) self.assertEqual(restrictionError1.holderConsumption, 100) restrictionError2 = fit.getRestrictionError(holder2, Restriction.powerGrid) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testFailExcessMultiple(self): # When multiple consumers require less than power grid output # alone, but in sum want more than total output, it should # be erroneous situation fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.power: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.power] = 25 holder1.state = State.online fit.items.add(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.power] = 20 holder2.state = State.online fit.items.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.powerOutput] = 40 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.powerGrid) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.output, 40) self.assertEqual(restrictionError1.totalUsage, 45) self.assertEqual(restrictionError1.holderConsumption, 25) restrictionError2 = fit.getRestrictionError(holder2, Restriction.powerGrid) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.output, 40) self.assertEqual(restrictionError2.totalUsage, 45) self.assertEqual(restrictionError2.holderConsumption, 20) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testFailExcessMultiple(self): # When multiple consumers require less than drone bay volume output # alone, but in sum want more than total output, it should # be erroneous situation fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.volume: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.volume] = 25 fit.drones.add(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.volume] = 20 fit.drones.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.droneCapacity] = 40 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.droneBayVolume) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.output, 40) self.assertEqual(restrictionError1.totalUsage, 45) self.assertEqual(restrictionError1.holderConsumption, 25) restrictionError2 = fit.getRestrictionError(holder2, Restriction.droneBayVolume) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.output, 40) self.assertEqual(restrictionError2.totalUsage, 45) self.assertEqual(restrictionError2.holderConsumption, 20) fit.drones.remove(holder1) fit.drones.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testFailNoAttr(self): # Check that any positive number of drones # results in error when character is assigned # to fit, but no restriction attribute available fit = Fit() item = self.ch.type_(typeId=1) holder1 = IndependentItem(item) holder1.state = State.online fit.drones.add(holder1) holder2 = IndependentItem(item) holder2.state = State.online fit.drones.add(holder2) char = IndependentItem(self.ch.type_(typeId=2)) char.attributes[Attribute.maxActiveDrones] = 1 fit.character = char restrictionError1 = fit.getRestrictionError(holder1, Restriction.launchedDrone) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.maxLaunchedDrones, 1) self.assertEqual(restrictionError1.launchedDrones, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.launchedDrone) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.maxLaunchedDrones, 1) self.assertEqual(restrictionError2.launchedDrones, 2) fit.drones.remove(holder1) fit.drones.remove(holder2) self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testMixUsageNegative(self): # If some holder has negative usage and drone bandwidth error is # still raised, check it's not raised for holder with # negative usage fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.droneBandwidthUsed: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.droneBandwidthUsed] = 100 holder1.state = State.online fit.items.append(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.droneBandwidthUsed] = -10 holder2.state = State.online fit.items.append(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.droneBandwidth] = 50 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.droneBandwidth) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.output, 50) self.assertEqual(restrictionError1.totalUsage, 90) self.assertEqual(restrictionError1.holderConsumption, 100) restrictionError2 = fit.getRestrictionError(holder2, Restriction.droneBandwidth) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertBuffersEmpty(fit)
def testFailExcessAll(self): # Make sure error is raised for all holders exceeding # their group restriction fit = Fit() item = self.ch.type_(typeId=1, groupId=6, attributes={Attribute.maxGroupOnline: 1}) holder1 = ShipItem(item) holder1.state = State.online fit.items.add(holder1) holder2 = ShipItem(item) holder2.state = State.online fit.items.add(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupOnline) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.maxGroup, 1) self.assertEqual(restrictionError1.holderGroup, 6) self.assertEqual(restrictionError1.groupHolders, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupOnline) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.maxGroup, 1) self.assertEqual(restrictionError2.holderGroup, 6) self.assertEqual(restrictionError2.groupHolders, 2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessModified(self): # Check that modified attribute value is taken, not original fit = Fit() item = self.ch.type_(typeId=1) holder1 = IndependentItem(item) holder1.state = State.online fit.drones.add(holder1) holder2 = IndependentItem(item) holder2.state = State.online fit.drones.add(holder2) char = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.maxActiveDrones: 3})) char.attributes[Attribute.maxActiveDrones] = 1 fit.character = char restrictionError1 = fit.getRestrictionError(holder1, Restriction.launchedDrone) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.maxLaunchedDrones, 1) self.assertEqual(restrictionError1.launchedDrones, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.launchedDrone) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.maxLaunchedDrones, 1) self.assertEqual(restrictionError2.launchedDrones, 2) fit.drones.remove(holder1) fit.drones.remove(holder2) self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testPassNegativeUse(self): # Check that even if use of one holder exceeds # drone bandwidth output, negative use of other holder may help # to avoid raising error fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.droneBandwidthUsed: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.droneBandwidthUsed] = 50 holder1.state = State.online fit.items.append(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.droneBandwidthUsed] = -15 holder2.state = State.online fit.items.append(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.droneBandwidth] = 40 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.droneBandwidth) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.droneBandwidth) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertBuffersEmpty(fit)
def testMixUsageNegative(self): # If some holder has negative usage and drone bay volume error is # still raised, check it's not raised for holder with # negative usage fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.volume: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.volume] = 100 fit.drones.add(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.volume] = -10 fit.drones.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.droneCapacity] = 50 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.droneBayVolume) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.output, 50) self.assertEqual(restrictionError1.totalUsage, 90) self.assertEqual(restrictionError1.holderConsumption, 100) restrictionError2 = fit.getRestrictionError(holder2, Restriction.droneBayVolume) self.assertIsNone(restrictionError2) fit.drones.remove(holder1) fit.drones.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testFailExcess(self): # Check that excessive number of drones results # in failure, even when character is assigned to # fit and max number attribute is available fit = Fit() item = self.ch.type_(typeId=1) holder1 = IndependentItem(item) holder1.state = State.online fit.drones.add(holder1) holder2 = IndependentItem(item) holder2.state = State.online fit.drones.add(holder2) char = IndependentItem(self.ch.type_(typeId=2)) char.attributes[Attribute.maxActiveDrones] = 1 fit.character = char restrictionError1 = fit.getRestrictionError(holder1, Restriction.launchedDrone) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.maxLaunchedDrones, 1) self.assertEqual(restrictionError1.launchedDrones, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.launchedDrone) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.maxLaunchedDrones, 1) self.assertEqual(restrictionError2.launchedDrones, 2) fit.drones.remove(holder1) fit.drones.remove(holder2) self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testMixUsageZero(self): # If some holder has zero usage and calibration error is # still raised, check it's not raised for holder with # zero usage fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.upgradeCost: 0}) holder1 = IndependentItem(item) holder1.attributes[Attribute.upgradeCost] = 100 fit.items.add(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.upgradeCost] = 0 fit.items.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.upgradeCapacity] = 50 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.calibration) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.output, 50) self.assertEqual(restrictionError1.totalUsage, 100) self.assertEqual(restrictionError1.holderConsumption, 100) restrictionError2 = fit.getRestrictionError(holder2, Restriction.calibration) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFail(self): # Check that error is raised when number of used # slots exceeds slot amount provided by ship fit = Fit() item = self.ch.type_(typeId=1) item.slots = {Slot.subsystem} holder1 = ShipItem(item) fit.items.add(holder1) holder2 = ShipItem(item) fit.items.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.maxSubSystems] = 1 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.subsystemSlot) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.slotsMax, 1) self.assertEqual(restrictionError1.slotsUsed, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.subsystemSlot) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.slotsMax, 1) self.assertEqual(restrictionError2.slotsUsed, 2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testFailModified(self): # Make sure that modified number of slot output # is taken fit = Fit() item = self.ch.type_(typeId=1) item.slots = {Slot.subsystem} holder1 = ShipItem(item) fit.items.add(holder1) holder2 = ShipItem(item) fit.items.add(holder2) ship = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.maxSubSystems: 5})) ship.attributes[Attribute.maxSubSystems] = 1 fit.ship = ship restrictionError1 = fit.getRestrictionError(holder1, Restriction.subsystemSlot) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.slotsMax, 1) self.assertEqual(restrictionError1.slotsUsed, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.subsystemSlot) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.slotsMax, 1) self.assertEqual(restrictionError2.slotsUsed, 2) fit.items.remove(holder1) fit.items.remove(holder2) fit.ship = None self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testPassDifferent(self): # Holders taking different slots shouldn't trigger any errors fit = Fit() holder1 = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.boosterness: 120})) fit.items.append(holder1) holder2 = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.boosterness: 121})) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.boosterIndex) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.boosterIndex) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testPassNone(self): # When typeIDs of skills are None, they should be ignored fit = Fit() item = self.ch.type_(typeId=None) skill1 = Skill(item) fit.items.append(skill1) skill2 = Skill(item) fit.items.append(skill2) restrictionError1 = fit.getRestrictionError(skill1, Restriction.skillUniqueness) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(skill2, Restriction.skillUniqueness) self.assertIsNone(restrictionError2) fit.items.remove(skill1) fit.items.remove(skill2) self.assertBuffersEmpty(fit)
def testPassNonSkills(self): # Not-skill holders shouldn't be tracked fit = Fit() item = self.ch.type_(typeId=70) holder1 = IndependentItem(item) fit.items.append(holder1) holder2 = IndependentItem(item) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.skillUniqueness) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.skillUniqueness) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testPassHolderNoneGroup(self): # Check that holders with None group are not affected fit = Fit() item = self.ch.type_(typeId=1, groupId=None, attributes={Attribute.maxGroupFitted: 1}) holder1 = ShipItem(item) fit.items.append(holder1) holder2 = ShipItem(item) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupFitted) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupFitted) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testPassDifferent(self): # Holders taking different slots shouldn't trigger any errors fit = Fit() holder1 = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.subSystemSlot: 120})) fit.items.add(holder1) holder2 = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.subSystemSlot: 121})) fit.items.add(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.subsystemIndex) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.subsystemIndex) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testPassHolderNonShip(self): # Non-ship holders shouldn't be affected fit = Fit() item = self.ch.type_(typeId=1, groupId=12, attributes={Attribute.maxGroupActive: 1}) holder1 = IndependentItem(item) fit.items.append(holder1) holder2 = IndependentItem(item) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupActive) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupActive) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testPassState(self): # No errors should occur if holders are not online+ fit = Fit() item = self.ch.type_(typeId=1, groupId=886, attributes={Attribute.maxGroupOnline: 1}) holder1 = ShipItem(item) fit.items.append(holder1) holder2 = ShipItem(item) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupOnline) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupOnline) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testPass(self): # Make sure no errors are raised when number of added # items doesn't exceed any restrictions fit = Fit() item = self.ch.type_(typeId=1, groupId=860, attributes={Attribute.maxGroupFitted: 2}) holder1 = ShipItem(item) fit.items.append(holder1) holder2 = ShipItem(item) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupFitted) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupFitted) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testFail(self): # Check that multiple skills with this ID raise error fit = Fit() item = self.ch.type_(typeId=56) skill1 = Skill(item) fit.items.append(skill1) skill2 = Skill(item) fit.items.append(skill2) restrictionError1 = fit.getRestrictionError(skill1, Restriction.skillUniqueness) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.skill, 56) restrictionError2 = fit.getRestrictionError(skill2, Restriction.skillUniqueness) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.skill, 56) fit.items.remove(skill1) fit.items.remove(skill2) self.assertBuffersEmpty(fit)
def testPassState(self): # No errors should occur if holders are not active+ fit = Fit() item = self.ch.type_(typeId=1, groupId=886, attributes={Attribute.maxGroupActive: 1}) holder1 = ShipItem(item) holder1.state = State.online fit.items.add(holder1) holder2 = ShipItem(item) holder2.state = State.online fit.items.add(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupActive) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupActive) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testMixExcessOne(self): # Make sure error is raised for just holders which excess # restriction,even if they're from the same group fit = Fit() holder1 = ShipItem(self.ch.type_(typeId=1, groupId=92, attributes={Attribute.maxGroupFitted: 1})) fit.items.append(holder1) holder2 = ShipItem(self.ch.type_(typeId=2, groupId=92, attributes={Attribute.maxGroupFitted: 2})) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupFitted) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.maxGroup, 1) self.assertEqual(restrictionError1.holderGroup, 92) self.assertEqual(restrictionError1.groupHolders, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupFitted) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testPassHolderNoneGroup(self): # Check that holders with None group are not affected fit = Fit() item = self.ch.type_(typeId=1, groupId=None, attributes={Attribute.maxGroupOnline: 1}) holder1 = ShipItem(item) holder1.state = State.online fit.items.add(holder1) holder2 = ShipItem(item) holder2.state = State.online fit.items.add(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupOnline) self.assertIsNone(restrictionError1) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupOnline) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFail(self): # Check that if 2 or more holders are put into single slot # index, error is raised fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.boosterness: 120}) holder1 = IndependentItem(item) fit.items.append(holder1) holder2 = IndependentItem(item) fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.boosterIndex) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.holderSlotIndex, 120) restrictionError2 = fit.getRestrictionError(holder2, Restriction.boosterIndex) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.holderSlotIndex, 120) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testFailOriginal(self): # Make sure that original attributes are used fit = Fit() item = self.ch.type_(typeId=1, attributes={Attribute.boosterness: 120}) holder1 = IndependentItem(item) holder1.attributes[Attribute.boosterness] = 119 fit.items.append(holder1) holder2 = IndependentItem(item) holder2.attributes[Attribute.boosterness] = 121 fit.items.append(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.boosterIndex) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.holderSlotIndex, 120) restrictionError2 = fit.getRestrictionError(holder2, Restriction.boosterIndex) self.assertIsNotNone(restrictionError2) self.assertEqual(restrictionError2.holderSlotIndex, 120) fit.items.remove(holder1) fit.items.remove(holder2) self.assertBuffersEmpty(fit)
def testPass(self): # Single holder which takes some slot shouldn't # trigger any errors fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.boosterness: 120})) fit.items.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.boosterIndex) self.assertIsNone(restrictionError) fit.items.remove(holder) self.assertBuffersEmpty(fit)
def testPassCapitalShip(self): # Check that capital holders can be added to # capital ship fit = Fit() holder = ShipItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 501})) fit.items.add(holder) shipItem = self.ch.type_(typeId=2) shipItem.requiredSkills = {ConstType.capitalShips: 1} fit.ship = IndependentItem(shipItem) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailNoShip(self): # Make sure that absence of ship # is considered as 0 output fit = Fit() item = self.ch.type_(typeId=1) item.slots = {Slot.launcher} holder = ShipItem(item) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.launcherSlot) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.slotsMax, 0) self.assertEqual(restrictionError.slotsUsed, 1) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessNoShip(self): # Make sure error is raised on fits without ship fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.power: 0})) holder.attributes[Attribute.power] = 50 holder.state = State.online fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.powerGrid) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.output, 0) self.assertEqual(restrictionError.totalUsage, 50) self.assertEqual(restrictionError.holderConsumption, 50) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassState(self): # When holder isn't online, it shouldn't consume anything fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.power: 0})) holder.attributes[Attribute.power] = 50 fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.powerOutput] = 40 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.powerGrid) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassMatch2(self): # Check that no error raised when drone of group # matching to second restriction attribute is added fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, groupId=67)) fit.drones.add(holder) fit.ship = IndependentItem( self.ch.type_(typeId=2, attributes={Attribute.allowedDroneGroup2: 67})) restrictionError = fit.getRestrictionError(holder, Restriction.droneGroup) self.assertIsNone(restrictionError) fit.drones.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessNoChar(self): # Check that any positive number of drones # results in error when no character is assigned # to fit fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1)) holder.state = State.online fit.drones.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.launchedDrone) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.maxLaunchedDrones, 0) self.assertEqual(restrictionError.launchedDrones, 1) fit.drones.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassNonShipHolder(self): # Holders not belonging to ship shouldn't be affected fit = Fit() ship = IndependentItem(self.ch.type_(typeId=772, groupId=31)) fit.ship = ship holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.canFitShipType1: 10})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailSubcapitalShip(self): # Check that error is raised on attempt # to add capital item to fit with subcapital # ship fit = Fit() holder = ShipItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 501})) fit.items.add(holder) fit.ship = IndependentItem(self.ch.type_(typeId=2)) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.allowedVolume, 500) self.assertEqual(restrictionError.holderVolume, 501) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassNonDrone(self): # Check that restriction is not applied # to holders which are not drones fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, groupId=56)) fit.items.add(holder) fit.ship = IndependentItem( self.ch.type_(typeId=2, attributes={Attribute.allowedDroneGroup1: 4})) restrictionError = fit.getRestrictionError(holder, Restriction.droneGroup) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailNoShip(self): # Absent ship should trigger this error too fit = Fit() holder = ShipItem( self.ch.type_(typeId=1, attributes={Attribute.canFitShipType1: 10})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNotNone(restrictionError) self.assertCountEqual(restrictionError.allowedTypes, (10, )) self.assertCountEqual(restrictionError.allowedGroups, ()) self.assertEqual(restrictionError.shipType, None) self.assertEqual(restrictionError.shipGroup, None) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassNonDrone(self): # Make sure nothing but drone container is restricted fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.volume: 0})) holder.attributes[Attribute.volume] = 50 fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.droneCapacity] = 40 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.droneBayVolume) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassSatisfied(self): # Check that error isn't raised when all skill requirements # are met fit = Fit() item = self.ch.type_(typeId=1) item.requiredSkills = {50: 3} holder = IndependentItem(item) fit.items.add(holder) skill = Skill(self.ch.type_(typeId=50)) skill.level = 3 fit.items.add(skill) restrictionError = fit.getRestrictionError(holder, Restriction.skillRequirement) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.items.remove(skill) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassGroupMatch(self): # When type of ship matches group-restriction attribute, # no error should be raised fit = Fit() ship = IndependentItem(self.ch.type_(typeId=554, groupId=23)) fit.ship = ship holder = ShipItem( self.ch.type_(typeId=1, attributes={Attribute.canFitShipGroup1: 23})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassNoOriginalAttr(self): # When added holder's item doesn't have original attribute, # holder shouldn't be tracked by register, and thus, no # errors should be raised fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1)) holder.attributes[Attribute.cpu] = 100 holder.state = State.online fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.cpuOutput] = 50 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.cpu) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailShipNoAttr(self): # Make sure that absence of specifier of slot output # is considered as 0 output fit = Fit() item = self.ch.type_(typeId=1) item.slots = {Slot.moduleHigh} holder = ShipItem(item) fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.highSlot) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.slotsMax, 0) self.assertEqual(restrictionError.slotsUsed, 1) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailOriginalVolume(self): # Make sure original volume value is taken fit = Fit() holder = ShipItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 501})) # Set volume below 500 to check that even when # modified attributes are available, raw attributes # are taken holder.attributes[Attribute.volume] = 100 fit.items.add(holder) fit.ship = IndependentItem(self.ch.type_(typeId=2)) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.allowedVolume, 500) self.assertEqual(restrictionError.holderVolume, 501) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailMismatch(self): # Error should be raised when mismatching rig size # is added to ship fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.rigSize: 10})) fit.items.add(holder) ship = IndependentItem( self.ch.type_(typeId=2, attributes={Attribute.rigSize: 6})) fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.rigSize) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.allowedSize, 6) self.assertEqual(restrictionError.holderSize, 10) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailPartial(self): # Make sure satisfied skill requirements are not shown # up in error fit = Fit() item = self.ch.type_(typeId=1) item.requiredSkills = {48: 1, 50: 5} holder = IndependentItem(item) fit.items.add(holder) skill = Skill(self.ch.type_(typeId=48)) skill.level = 5 fit.items.add(skill) restrictionError = fit.getRestrictionError(holder, Restriction.skillRequirement) self.assertIsNotNone(restrictionError) self.assertCountEqual(restrictionError, ((50, None, 5),)) fit.items.remove(holder) fit.items.remove(skill) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailDroneNone(self): # Check that drone from None group is subject # to restriction fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, groupId=None)) fit.drones.add(holder) fit.ship = IndependentItem( self.ch.type_(typeId=2, attributes={Attribute.allowedDroneGroup1: 1896})) restrictionError = fit.getRestrictionError(holder, Restriction.droneGroup) self.assertIsNotNone(restrictionError) self.assertCountEqual(restrictionError.allowedGroups, (1896, )) self.assertEqual(restrictionError.droneGroup, None) fit.drones.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessShipNoAttr(self): # When ship is assigned, but doesn't have drone bandwidth output # attribute, error should be raised for drone bandwidth consumers too fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.droneBandwidthUsed: 0})) holder.attributes[Attribute.droneBandwidthUsed] = 50 holder.state = State.online fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.droneBandwidth) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.output, 0) self.assertEqual(restrictionError.totalUsage, 50) self.assertEqual(restrictionError.holderConsumption, 50) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailOriginal(self): # Original value must be taken fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.rigSize: 10})) holder.attributes[Attribute.rigSize] = 5 fit.items.add(holder) ship = IndependentItem( self.ch.type_(typeId=2, attributes={Attribute.rigSize: 6})) ship.attributes[Attribute.rigSize] = 5 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.rigSize) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.allowedSize, 6) self.assertEqual(restrictionError.holderSize, 10) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessModified(self): # Make sure modified drone bandwidth values are taken fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.droneBandwidthUsed: 40})) holder.attributes[Attribute.droneBandwidthUsed] = 100 holder.state = State.online fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.droneBandwidth: 45})) ship.attributes[Attribute.droneBandwidth] = 50 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.droneBandwidth) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.output, 50) self.assertEqual(restrictionError.totalUsage, 100) self.assertEqual(restrictionError.holderConsumption, 100) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailMismatch2(self): # Check that error is returned on attempt # to add drone from group mismatching to # second restriction attribute fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, groupId=797)) fit.drones.add(holder) fit.ship = IndependentItem( self.ch.type_(typeId=2, attributes={Attribute.allowedDroneGroup2: 69})) restrictionError = fit.getRestrictionError(holder, Restriction.droneGroup) self.assertIsNotNone(restrictionError) self.assertCountEqual(restrictionError.allowedGroups, (69, )) self.assertEqual(restrictionError.droneGroup, 797) fit.drones.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailType5(self): # Check that fifth type-restriction attribute affects # holder fit = Fit() ship = IndependentItem(self.ch.type_(typeId=772, groupId=31)) fit.ship = ship holder = ShipItem( self.ch.type_(typeId=1, attributes={Attribute.fitsToShipType: 10})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNotNone(restrictionError) self.assertCountEqual(restrictionError.allowedTypes, (10, )) self.assertCountEqual(restrictionError.allowedGroups, ()) self.assertEqual(restrictionError.shipType, 772) self.assertEqual(restrictionError.shipGroup, 31) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessSingle(self): # When ship provides drone bandwidth output, but single consumer # demands for more, error should be raised fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.droneBandwidthUsed: 0})) holder.attributes[Attribute.droneBandwidthUsed] = 50 holder.state = State.online fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.droneBandwidth] = 40 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.droneBandwidth) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.output, 40) self.assertEqual(restrictionError.totalUsage, 50) self.assertEqual(restrictionError.holderConsumption, 50) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassCombinedMatch(self): # Check that it's enough to match any condition # to be fittable fit = Fit() ship = IndependentItem(self.ch.type_(typeId=554, groupId=23)) fit.ship = ship holder = ShipItem( self.ch.type_(typeId=1, attributes={ Attribute.canFitShipType1: 1089, Attribute.canFitShipGroup1: 23 })) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessShipNoAttr(self): # When ship is assigned, but doesn't have calibration output # attribute, error should be raised for calibration consumers too fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.upgradeCost: 0})) holder.attributes[Attribute.upgradeCost] = 50 fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.calibration) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.output, 0) self.assertEqual(restrictionError.totalUsage, 50) self.assertEqual(restrictionError.holderConsumption, 50) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassMultiSkill(self): # Make sure max skill level is taken fit = Fit() item1 = self.ch.type_(typeId=1) item1.requiredSkills = {50: 4} holder = IndependentItem(item1) fit.items.add(holder) item2 = self.ch.type_(typeId=50) skill1 = Skill(item2) skill1.level = 1 fit.items.add(skill1) skill2 = Skill(item2) skill2.level = 5 fit.items.add(skill2) restrictionError = fit.getRestrictionError(holder, Restriction.skillRequirement) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.items.remove(skill1) fit.items.remove(skill2) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessModified(self): # Make sure modified drone bay volume values are taken fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.volume: 40})) holder.attributes[Attribute.volume] = 100 fit.drones.add(holder) ship = IndependentItem( self.ch.type_(typeId=2, attributes={Attribute.droneCapacity: 45})) ship.attributes[Attribute.droneCapacity] = 50 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.droneBayVolume) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.output, 50) self.assertEqual(restrictionError.totalUsage, 100) self.assertEqual(restrictionError.holderConsumption, 100) fit.drones.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailExcessSingle(self): # When ship provides calibration output, but single consumer # demands for more, error should be raised fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.upgradeCost: 0})) holder.attributes[Attribute.upgradeCost] = 50 fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) ship.attributes[Attribute.upgradeCapacity] = 40 fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.calibration) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.output, 40) self.assertEqual(restrictionError.totalUsage, 50) self.assertEqual(restrictionError.holderConsumption, 50) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)