def testMixUsageZero(self):
# If some holder has zero usage and cpu error is
# still raised, check it's not raised for holder with
# zero usage
fit = Fit()
item = self.ch.type_(typeId=1, attributes={Attribute.cpu: 0})
holder1 = IndependentItem(item)
holder1.attributes[Attribute.cpu] = 100
holder1.state = State.online
fit.items.add(holder1)
holder2 = IndependentItem(item)
holder2.attributes[Attribute.cpu] = 0
holder2.state = State.online
fit.items.add(holder2)
ship = IndependentItem(self.ch.type_(typeId=2))
ship.attributes[Attribute.cpuOutput] = 50
fit.ship = ship
restrictionError1 = fit.getRestrictionError(holder1, Restriction.cpu)
self.assertIsNotNone(restrictionError1)
self.assertEqual(restrictionError1.output, 50)
self.assertEqual(restrictionError1.totalUsage, 100)
self.assertEqual(restrictionError1.holderConsumption, 100)
restrictionError2 = fit.getRestrictionError(holder2, Restriction.cpu)
self.assertIsNone(restrictionError2)
fit.items.remove(holder1)
fit.items.remove(holder2)
fit.ship = None
self.assertEqual(len(self.log), 0)
self.assertRestrictionBuffersEmpty(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.moduleHigh}
holder1 = ShipItem(item)
fit.items.add(holder1)
holder2 = ShipItem(item)
fit.items.add(holder2)
ship = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.hiSlots: 5}))
ship.attributes[Attribute.hiSlots] = 1
fit.ship = ship
restrictionError1 = fit.getRestrictionError(holder1, Restriction.highSlot)
self.assertIsNotNone(restrictionError1)
self.assertEqual(restrictionError1.slotsMax, 1)
self.assertEqual(restrictionError1.slotsUsed, 2)
restrictionError2 = fit.getRestrictionError(holder2, Restriction.highSlot)
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.assertRestrictionBuffersEmpty(fit)
def testPassNegativeUse(self):
# Check that even if use of one holder exceeds
# cpu output, negative use of other holder may help
# to avoid raising error
fit = Fit()
item = self.ch.type_(typeId=1, attributes={Attribute.cpu: 0})
holder1 = IndependentItem(item)
holder1.attributes[Attribute.cpu] = 50
holder1.state = State.online
fit.items.add(holder1)
holder2 = IndependentItem(item)
holder2.attributes[Attribute.cpu] = -15
holder2.state = State.online
fit.items.add(holder2)
ship = IndependentItem(self.ch.type_(typeId=2))
ship.attributes[Attribute.cpuOutput] = 40
fit.ship = ship
restrictionError1 = fit.getRestrictionError(holder1, Restriction.cpu)
self.assertIsNone(restrictionError1)
restrictionError2 = fit.getRestrictionError(holder2, Restriction.cpu)
self.assertIsNone(restrictionError2)
fit.items.remove(holder1)
fit.items.remove(holder2)
fit.ship = None
self.assertEqual(len(self.log), 0)
self.assertRestrictionBuffersEmpty(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.cpu: 0})
holder1 = IndependentItem(item)
holder1.attributes[Attribute.cpu] = 25
holder1.state = State.online
fit.items.add(holder1)
holder2 = IndependentItem(item)
holder2.attributes[Attribute.cpu] = 20
holder2.state = State.online
fit.items.add(holder2)
ship = IndependentItem(self.ch.type_(typeId=2))
ship.attributes[Attribute.cpuOutput] = 50
fit.ship = ship
restrictionError1 = fit.getRestrictionError(holder1, Restriction.cpu)
self.assertIsNone(restrictionError1)
restrictionError2 = fit.getRestrictionError(holder2, Restriction.cpu)
self.assertIsNone(restrictionError2)
fit.items.remove(holder1)
fit.items.remove(holder2)
fit.ship = None
self.assertEqual(len(self.log), 0)
self.assertRestrictionBuffersEmpty(fit)
def testMixUsageZero(self):
# If some holder has zero usage and drone bay volume error is
# still raised, check it's not raised for holder with
# zero 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] = 0
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, 100)
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.assertRestrictionBuffersEmpty(fit)
def testPassNegativeUse(self):
# Check that even if use of one holder exceeds drone bay volume
# output, negative use of other holder may help to avoid raising error
fit = Fit()
item = self.ch.type_(typeId=1, attributes={Attribute.volume: 0})
holder1 = IndependentItem(item)
holder1.attributes[Attribute.volume] = 50
fit.drones.add(holder1)
holder2 = IndependentItem(item)
holder2.attributes[Attribute.volume] = -15
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.assertIsNone(restrictionError1)
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.assertRestrictionBuffersEmpty(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 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 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 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 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 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 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.moduleHigh}
holder1 = ShipItem(item)
fit.items.add(holder1)
holder2 = ShipItem(item)
fit.items.add(holder2)
ship = IndependentItem(self.ch.type_(typeId=2))
ship.attributes[Attribute.hiSlots] = 1
fit.ship = ship
restrictionError1 = fit.getRestrictionError(holder1, Restriction.highSlot)
self.assertIsNotNone(restrictionError1)
self.assertEqual(restrictionError1.slotsMax, 1)
self.assertEqual(restrictionError1.slotsUsed, 2)
restrictionError2 = fit.getRestrictionError(holder2, Restriction.highSlot)
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.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 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 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 testMixUsageNegative(self):
# If some holder has negative usage and calibration error is
# still raised, check it's not raised for holder with
# negative 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] = -10
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, 90)
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 testFailExcessMultiple(self):
# When multiple consumers require less than cpu 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.cpu: 0})
holder1 = IndependentItem(item)
holder1.attributes[Attribute.cpu] = 25
holder1.state = State.online
fit.items.add(holder1)
holder2 = IndependentItem(item)
holder2.attributes[Attribute.cpu] = 20
holder2.state = State.online
fit.items.add(holder2)
ship = IndependentItem(self.ch.type_(typeId=2))
ship.attributes[Attribute.cpuOutput] = 40
fit.ship = ship
restrictionError1 = fit.getRestrictionError(holder1, Restriction.cpu)
self.assertIsNotNone(restrictionError1)
self.assertEqual(restrictionError1.output, 40)
self.assertEqual(restrictionError1.totalUsage, 45)
self.assertEqual(restrictionError1.holderConsumption, 25)
restrictionError2 = fit.getRestrictionError(holder2, Restriction.cpu)
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.assertRestrictionBuffersEmpty(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.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] = 50
fit.ship = ship
restrictionError1 = fit.getRestrictionError(holder1,
Restriction.droneBayVolume)
self.assertIsNone(restrictionError1)
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.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 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 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 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 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.append(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.assertBuffersEmpty(fit)
def testPassMatch1(self):
# Check that no error raised when drone of group
# matching to first restriction attribute is added
fit = Fit()
holder = IndependentItem(self.ch.type_(typeId=1, groupId=22))
fit.drones.add(holder)
fit.ship = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.allowedDroneGroup1: 22}))
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 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.append(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.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.append(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.assertBuffersEmpty(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.append(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.assertBuffersEmpty(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.append(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.assertBuffersEmpty(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.append(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.assertBuffersEmpty(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.append(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.assertBuffersEmpty(fit)
def testFailMismatchCombined(self):
# Check that error is returned on attempt
# to add drone from group mismatching to
# both restriction attributes
fit = Fit()
holder = IndependentItem(self.ch.type_(typeId=1, groupId=803))
fit.drones.append(holder)
fit.ship = IndependentItem(self.ch.type_(typeId=2, attributes={Attribute.allowedDroneGroup1: 48, Attribute.allowedDroneGroup2: 106}))
restrictionError = fit.getRestrictionError(holder, Restriction.droneGroup)
self.assertIsNotNone(restrictionError)
self.assertCountEqual(restrictionError.allowedGroups, (48, 106))
self.assertEqual(restrictionError.droneGroup, 803)
fit.drones.remove(holder)
fit.ship = None
self.assertBuffersEmpty(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.append(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.assertBuffersEmpty(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 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 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.append(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.assertBuffersEmpty(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 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.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 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 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.upgradeCost] = 100
fit.items.append(holder)
ship = IndependentItem(self.ch.type_(typeId=2))
ship.attributes[Attribute.upgradeCapacity] = 50
fit.ship = ship
restrictionError = fit.getRestrictionError(holder, Restriction.calibration)
self.assertIsNone(restrictionError)
fit.items.remove(holder)
fit.ship = None
self.assertBuffersEmpty(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 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 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 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 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 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 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 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 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 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 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 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 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)
