Python environment.IndependentItem类代码示例

 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 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 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.add(holder1)
     holder2 = IndependentItem(item)
     holder2.attributes[Attribute.droneBandwidthUsed] = -10
     holder2.state = State.online
     fit.items.add(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.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 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
     # 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 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 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 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.append(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.assertBuffersEmpty(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.append(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.assertBuffersEmpty(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.droneBandwidthUsed] = 100
     holder.state = State.online
     fit.items.append(holder)
     ship = IndependentItem(self.ch.type_(typeId=2))
     ship.attributes[Attribute.droneBandwidth] = 50
     fit.ship = ship
     restrictionError = fit.getRestrictionError(holder, Restriction.droneBandwidth)
     self.assertIsNone(restrictionError)
     fit.items.remove(holder)
     fit.ship = None
     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)
     holder1.state = State.online
     fit.items.append(holder1)
     holder2 = IndependentItem(item)
     holder2.state = State.online
     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 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.append(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.assertBuffersEmpty(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.append(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.assertBuffersEmpty(fit)