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 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 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.assertRestrictionBuffersEmpty(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 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 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 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 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 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 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 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.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.add(holder1) holder2 = ShipItem( self.ch.type_(typeId=2, groupId=92, attributes={Attribute.maxGroupFitted: 2})) fit.items.add(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.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(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 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 testMixExcessOriginal(self): # Check that original item attributes are used fit = Fit() holder1 = ShipItem( self.ch.type_(typeId=1, groupId=61, attributes={Attribute.maxGroupFitted: 1})) holder1.attributes[Attribute.maxGroupFitted] = 2 fit.items.add(holder1) holder2 = ShipItem( self.ch.type_(typeId=2, groupId=61, attributes={Attribute.maxGroupFitted: 2})) holder2.attributes[Attribute.maxGroupFitted] = 1 fit.items.add(holder2) restrictionError1 = fit.getRestrictionError(holder1, Restriction.maxGroupFitted) self.assertIsNotNone(restrictionError1) self.assertEqual(restrictionError1.maxGroup, 1) self.assertEqual(restrictionError1.holderGroup, 61) self.assertEqual(restrictionError1.groupHolders, 2) restrictionError2 = fit.getRestrictionError(holder2, Restriction.maxGroupFitted) self.assertIsNone(restrictionError2) fit.items.remove(holder1) fit.items.remove(holder2) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(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 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 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 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 testPassNoShip(self): # When no ship is assigned, no restriction # should be applied to ships fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.rigSize: 10})) fit.items.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.rigSize) self.assertIsNone(restrictionError) fit.items.remove(holder) 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 testPassNonShipHolder(self): # Check that non-ship holders are not affected # by restriction fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 501})) fit.items.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNone(restrictionError) fit.items.remove(holder) self.assertBuffersEmpty(fit)
def testPass(self): # No error should be raised when single skill # is added to fit fit = Fit() skill = Skill(self.ch.type_(typeId=56)) fit.items.append(skill) restrictionError = fit.getRestrictionError(skill, Restriction.skillUniqueness) self.assertIsNone(restrictionError) fit.items.remove(skill) self.assertBuffersEmpty(fit)
def testPassSubcapitalShipHolder(self): # Make sure no error raised when non-capital # item is added to fit fit = Fit() holder = ShipItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 500})) fit.items.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNone(restrictionError) fit.items.remove(holder) self.assertBuffersEmpty(fit)
def testPassNoShip(self): # Check that restriction isn't applied # when fit doesn't have ship fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, groupId=None)) fit.drones.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.droneGroup) self.assertIsNone(restrictionError) fit.drones.remove(holder) self.assertBuffersEmpty(fit)
def testPassSubcapitalShipHolder(self): # Make sure no error raised when non-capital # item is added to fit fit = Fit() holder = ShipItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 500})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNone(restrictionError) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassNonShipHolder(self): # Check that non-ship holders are not affected # by restriction fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 501})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNone(restrictionError) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPass(self): # No error should be raised when single skill # is added to fit fit = Fit() skill = Skill(self.ch.type_(typeId=56)) fit.items.add(skill) restrictionError = fit.getRestrictionError(skill, Restriction.skillUniqueness) self.assertIsNone(restrictionError) fit.items.remove(skill) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(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.subSystemSlot: 120})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.subsystemIndex) self.assertIsNone(restrictionError) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertBuffersEmpty(fit)
def testPassNoVolume(self): # Check that items with no volume attribute are not restricted fit = Fit() holder = ShipItem(self.ch.type_(typeId=1)) fit.items.append(holder) fit.ship = IndependentItem(self.ch.type_(typeId=2)) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertBuffersEmpty(fit)
def testFailNoShip(self): # Check that error is raised on attempt # to add capital item to fit w/o ship fit = Fit() holder = ShipItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 501})) fit.items.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.allowedVolume, 500) self.assertEqual(restrictionError.holderVolume, 501) fit.items.remove(holder) self.assertBuffersEmpty(fit)
def testPassNoShip(self): # Check that restriction isn't applied # when fit doesn't have ship fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, groupId=None)) fit.drones.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.droneGroup) self.assertIsNone(restrictionError) fit.drones.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassNoShip(self): # When no ship is assigned, no restriction # should be applied to ships fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.rigSize: 10})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.rigSize) self.assertIsNone(restrictionError) fit.items.remove(holder) 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.append(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.assertBuffersEmpty(fit)
def testPassNoVolume(self): # Check that items with no volume attribute are not restricted fit = Fit() holder = ShipItem(self.ch.type_(typeId=1)) fit.items.add(holder) fit.ship = IndependentItem(self.ch.type_(typeId=2)) 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 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.append(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.assertBuffersEmpty(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.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertBuffersEmpty(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.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertBuffersEmpty(fit)
def testFailExcessNoShip(self): # Make sure error is raised on fits without ship fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.upgradeCost: 0})) holder.attributes[Attribute.upgradeCost] = 50 fit.items.append(holder) 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) 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.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.boosterIndex) self.assertIsNone(restrictionError) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailNoShip(self): # Check that error is raised on attempt # to add capital item to fit w/o ship fit = Fit() holder = ShipItem(self.ch.type_(typeId=1, attributes={Attribute.volume: 501})) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.capitalItem) self.assertIsNotNone(restrictionError) self.assertEqual(restrictionError.allowedVolume, 500) self.assertEqual(restrictionError.holderVolume, 501) fit.items.remove(holder) 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.append(holder) restrictionError = fit.getRestrictionError(holder, Restriction.shipTypeGroup) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertBuffersEmpty(fit)
def testFailSingle(self): # Check that error is raised when single skill requirement # is not met fit = Fit() item = self.ch.type_(typeId=1) item.requiredSkills = {50: 3} holder = IndependentItem(item) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.skillRequirement) self.assertIsNotNone(restrictionError) self.assertCountEqual(restrictionError, ((50, None, 3),)) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testFailMultiple(self): # Check error raised when multiple skill requirements # are not met fit = Fit() item = self.ch.type_(typeId=1) item.requiredSkills = {48: 1, 50: 5} holder = IndependentItem(item) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.skillRequirement) self.assertIsNotNone(restrictionError) self.assertCountEqual(restrictionError, ((50, None, 5), (48, None, 1))) fit.items.remove(holder) self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassShipNoAttr(self): # If ship doesn't have rig size attribute, # no restriction is applied onto rigs fit = Fit() holder = IndependentItem( self.ch.type_(typeId=1, attributes={Attribute.rigSize: 10})) fit.items.add(holder) ship = IndependentItem(self.ch.type_(typeId=2)) fit.ship = ship restrictionError = fit.getRestrictionError(holder, Restriction.rigSize) self.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassShipNoRestriction(self): # Check that restriction isn't applied # when fit has ship, but without restriction # attribute fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, groupId=71)) fit.drones.add(holder) fit.ship = IndependentItem(self.ch.type_(typeId=2)) 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 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 testFailExcessNoShip(self): # Make sure error is raised on fits without ship 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) 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) 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.moduleHigh} holder = ShipItem(item) fit.items.add(holder) restrictionError = fit.getRestrictionError(holder, Restriction.highSlot) 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 testPassState(self): # When holder isn't online, it shouldn't consume anything fit = Fit() holder = IndependentItem(self.ch.type_(typeId=1, attributes={Attribute.droneBandwidthUsed: 0})) holder.attributes[Attribute.droneBandwidthUsed] = 50 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.assertIsNone(restrictionError) fit.items.remove(holder) fit.ship = None self.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(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.add(skill1) skill2 = Skill(item) fit.items.add(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.assertEqual(len(self.log), 0) self.assertRestrictionBuffersEmpty(fit)
def testPassNonSkills(self): # Not-skill holders shouldn't be tracked fit = Fit() item = self.ch.type_(typeId=70) holder1 = IndependentItem(item) fit.items.add(holder1) holder2 = IndependentItem(item) fit.items.add(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.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 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 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.add(holder1) holder2 = ShipItem(item) 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 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 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 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)