def test_detached_none(self):
# Check that first found None is removed
fit = self.make_fit()
holder1 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
holder2 = Mock(_fit=None, state=State.offline, spec_set=CachingHolder(1))
fit.container.place(1, holder1)
fit.container.place(3, holder2)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
fit.container.remove(None)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 3)
self.assertIs(fit.container[0], holder1)
self.assertIsNone(fit.container[1])
self.assertIs(fit.container[2], holder2)
self.assertIs(holder1._fit, fit)
self.assertIs(holder2._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
# Misc
fit.container.remove(holder1)
fit.container.remove(holder2)
self.assert_object_buffers_empty(fit.container)
def test_slice(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.online,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.place(3, holder2)
slice_full = fit.container[:]
self.assertEqual(len(slice_full), 4)
self.assertIs(slice_full[0], holder1)
self.assertIsNone(slice_full[1])
self.assertIsNone(slice_full[2])
self.assertIs(slice_full[3], holder2)
slice_positive = fit.container[0:2]
self.assertEqual(len(slice_positive), 2)
self.assertIs(slice_positive[0], holder1)
self.assertIsNone(slice_positive[1])
slice_negative = fit.container[-2:]
self.assertEqual(len(slice_negative), 2)
self.assertIsNone(slice_negative[0])
self.assertIs(slice_negative[1], holder2)
slice_step = fit.container[::2]
self.assertEqual(len(slice_step), 2)
self.assertIs(slice_step[0], holder1)
self.assertIsNone(slice_step[1])
fit.container.remove(holder1)
fit.container.remove(holder2)
self.assert_object_buffers_empty(fit.container)
def test_detached_holder_onto_holder(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.overload,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
fit.container.append(holder1)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(SlotTakenError, fit.container.place, 0, holder2)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 1)
self.assertIs(fit.container[0], holder1)
self.assertIs(holder1._fit, fit)
self.assertIsNone(holder2._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
# Misc
fit.container.remove(holder1)
self.assert_object_buffers_empty(fit.container)
def test_detached_holder_solid(self):
# Check case when all slots of list are filled
fit = self.make_fit()
holder1 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
holder2 = Mock(_fit=None, state=State.offline, spec_set=CachingHolder(1))
holder3 = Mock(_fit=None, state=State.offline, spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.append(holder2)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_before = len(holder3._clear_volatile_attrs.mock_calls)
# Action
fit.container.equip(holder3)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 3)
self.assertIs(fit.container[2], holder3)
self.assertIs(holder3._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_after = len(holder3._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
self.assertEqual(holder3_cleans_after - holder3_cleans_before, 0)
# Misc
fit.container.remove(holder1)
fit.container.remove(holder2)
fit.container.remove(holder3)
self.assert_object_buffers_empty(fit.container)
def test_detached_add_holder_value_failure_existing_type_id(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
_type_id=1,
state=State.offline,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
_type_id=1,
state=State.offline,
spec_set=CachingHolder(1))
fit.container.add(holder1)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(ValueError, fit.container.add, holder2)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertEqual(len(fit.container), 1)
self.assertIs(fit.container[1], holder1)
self.assertIn(holder1, fit.container)
self.assertIs(holder1._fit, fit)
self.assertIsNone(holder2._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
# Misc
fit.container.remove(holder1)
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_contains(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
_type_id=1,
state=State.active,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
_type_id=2,
state=State.offline,
spec_set=CachingHolder(1))
self.assertFalse(holder1 in fit.container)
self.assertFalse(holder2 in fit.container)
fit.container.add(holder1)
self.assertTrue(holder1 in fit.container)
self.assertFalse(holder2 in fit.container)
fit.container.add(holder2)
self.assertTrue(holder1 in fit.container)
self.assertTrue(holder2 in fit.container)
fit.container.remove(holder1)
self.assertFalse(holder1 in fit.container)
self.assertTrue(holder2 in fit.container)
fit.container.remove(holder2)
self.assertFalse(holder1 in fit.container)
self.assertFalse(holder2 in fit.container)
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_attached_clear(self):
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder1 = Mock(_fit=None, state=State.overload, spec_set=CachingHolder(1))
holder2 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
fit.container.add(holder1)
fit.container.add(holder2)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
fit.container.clear()
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertEqual(len(fit.container), 0)
self.assertIsNone(holder1._fit)
self.assertIsNone(holder2._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 1)
self.assertGreaterEqual(holder1_cleans_after - holder1_cleans_before, 1)
self.assertGreaterEqual(holder2_cleans_after - holder2_cleans_before, 1)
# Misc
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_detached_none_outside(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.overload,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.online,
spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.append(holder2)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
fit.container.insert(6, None)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 2)
self.assertIs(fit.container[0], holder1)
self.assertIs(fit.container[1], holder2)
self.assertIs(holder1._fit, fit)
self.assertIs(holder2._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
# Misc
fit.container.remove(holder1)
fit.container.remove(holder2)
self.assert_object_buffers_empty(fit.container)
def test_contains(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.offline,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.offline,
spec_set=CachingHolder(1))
self.assertFalse(holder1 in fit.container)
self.assertFalse(None in fit.container)
self.assertFalse(holder2 in fit.container)
fit.container.append(holder1)
self.assertTrue(holder1 in fit.container)
self.assertFalse(None in fit.container)
self.assertFalse(holder2 in fit.container)
fit.container.place(3, holder2)
self.assertTrue(holder1 in fit.container)
self.assertTrue(None in fit.container)
self.assertTrue(holder2 in fit.container)
fit.container.remove(holder1)
self.assertFalse(holder1 in fit.container)
self.assertTrue(None in fit.container)
self.assertTrue(holder2 in fit.container)
fit.container.remove(holder2)
self.assertFalse(holder1 in fit.container)
self.assertFalse(None in fit.container)
self.assertFalse(holder2 in fit.container)
self.assert_object_buffers_empty(fit.container)
def test_detached_holder_after_nones(self):
fit = self.make_fit()
holder1 = Mock(_fit=None, state=State.overload, spec_set=CachingHolder(1))
holder2 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
holder3 = Mock(_fit=None, state=State.overload, spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.place(3, holder2)
fit.container.place(6, holder3)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_before = len(holder3._clear_volatile_attrs.mock_calls)
# Action
fit.container.remove(holder2)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 6)
self.assertIs(fit.container[0], holder1)
self.assertIsNone(fit.container[1])
self.assertIsNone(fit.container[2])
self.assertIsNone(fit.container[3])
self.assertIsNone(fit.container[4])
self.assertIs(fit.container[5], holder3)
self.assertIs(holder1._fit, fit)
self.assertIsNone(holder2._fit)
self.assertIs(holder3._fit, fit)
st_cleans_between = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_between = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_between = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_between = len(holder3._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_between - st_cleans_before, 0)
self.assertEqual(holder1_cleans_between - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_between - holder2_cleans_before, 0)
self.assertEqual(holder3_cleans_between - holder3_cleans_before, 0)
# Action
fit.container.remove(holder3)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 1)
self.assertIs(fit.container[0], holder1)
self.assertIs(holder1._fit, fit)
self.assertIsNone(holder2._fit)
self.assertIsNone(holder3._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_after = len(holder3._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_between, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_between, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_between, 0)
self.assertEqual(holder3_cleans_after - holder3_cleans_between, 0)
# Misc
fit.container.remove(holder1)
self.assert_object_buffers_empty(fit.container)
def test_attached_holder_inside_type_failure(self):
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder1 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.online,
spec_set=CachingHolder(1))
holder3 = Mock(_fit=None,
state=State.offline,
spec_set=OtherCachingHolder(1))
fit.container.append(holder1)
fit.container.append(holder2)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_before = len(holder3._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(TypeError, fit.container.insert, 1, holder3)
# Checks
self.assertEqual(len(fit.lt), 2)
self.assertIn(holder1, fit.lt)
self.assertEqual(fit.lt[holder1],
{State.offline, State.online, State.active})
self.assertIn(holder2, fit.lt)
self.assertEqual(fit.lt[holder2], {State.offline, State.online})
self.assertEqual(len(fit.rt), 2)
self.assertIn(holder1, fit.rt)
self.assertEqual(fit.rt[holder1],
{State.offline, State.online, State.active})
self.assertIn(holder2, fit.rt)
self.assertEqual(fit.rt[holder2], {State.offline, State.online})
self.assertEqual(len(fit.st), 2)
self.assertIn(holder1, fit.st)
self.assertEqual(fit.st[holder1],
{State.offline, State.online, State.active})
self.assertIn(holder2, fit.st)
self.assertEqual(fit.st[holder2], {State.offline, State.online})
self.assertIs(len(fit.container), 2)
self.assertIs(fit.container[0], holder1)
self.assertIs(fit.container[1], holder2)
self.assertIs(holder1._fit, fit)
self.assertIs(holder2._fit, fit)
self.assertIsNone(holder3._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_after = len(holder3._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
self.assertEqual(holder3_cleans_after - holder3_cleans_before, 0)
# Misc
fit.container.remove(holder1)
fit.container.remove(holder2)
self.assert_object_buffers_empty(fit.container)
def test_attached_index_holder(self):
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder1 = Mock(_fit=None,
state=State.overload,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.append(holder2)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
fit.container.free(0)
# Checks
self.assertEqual(len(fit.lt), 1)
self.assertIn(holder2, fit.lt)
self.assertEqual(fit.lt[holder2],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.rt), 1)
self.assertIn(holder2, fit.rt)
self.assertEqual(fit.rt[holder2],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.st), 1)
self.assertIn(holder2, fit.st)
self.assertEqual(fit.st[holder2],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.container), 2)
self.assertIsNone(fit.container[0])
self.assertIs(fit.container[1], holder2)
self.assertIsNone(holder1._fit)
self.assertIs(holder2._fit, fit)
st_cleans_between = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_between = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_between = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_between - st_cleans_before, 1)
self.assertEqual(holder1_cleans_between - holder1_cleans_before, 1)
self.assertEqual(holder2_cleans_between - holder2_cleans_before, 1)
# Action
fit.container.free(1)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.container), 0)
self.assertIsNone(holder1._fit)
self.assertIsNone(holder2._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_between, 1)
self.assertEqual(holder1_cleans_after - holder1_cleans_between, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_between, 1)
# Misc
self.assert_object_buffers_empty(fit.container)
def test_detached_none(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.append(holder2)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(ValueError, fit.container.free, None)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 2)
self.assertIs(fit.container[0], holder1)
self.assertIs(fit.container[1], holder2)
self.assertIs(holder1._fit, fit)
self.assertIs(holder2._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
# Misc
fit.container.free(holder1)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
fit.container.free(None)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 2)
self.assertIsNone(fit.container[0])
self.assertIs(fit.container[1], holder2)
self.assertIsNone(holder1._fit)
self.assertIs(holder2._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
# Misc
fit.container.free(holder2)
self.assert_object_buffers_empty(fit.container)
def test_detached_holder_inside_value_failure(self):
fit = self.make_fit()
fit_other = self.make_fit()
holder1 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.overload,
spec_set=CachingHolder(1))
holder3 = Mock(_fit=None,
state=State.overload,
spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.append(holder2)
fit_other.container.append(holder3)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_before = len(holder3._clear_volatile_attrs.mock_calls)
st_other_cleans_before = len(
fit_other.stats._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(ValueError, fit.container.insert, 1, holder3)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertEqual(len(fit_other.lt), 0)
self.assertEqual(len(fit_other.rt), 0)
self.assertEqual(len(fit_other.st), 0)
self.assertIs(len(fit.container), 2)
self.assertIs(fit.container[0], holder1)
self.assertIs(fit.container[1], holder2)
self.assertIs(len(fit_other.container), 1)
self.assertIs(fit_other.container[0], holder3)
self.assertIs(holder1._fit, fit)
self.assertIs(holder2._fit, fit)
self.assertIs(holder3._fit, fit_other)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_after = len(holder3._clear_volatile_attrs.mock_calls)
st_other_cleans_after = len(
fit_other.stats._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
self.assertEqual(holder3_cleans_after - holder3_cleans_before, 0)
self.assertEqual(st_other_cleans_after - st_other_cleans_before, 0)
# Misc
fit.container.remove(holder1)
fit.container.remove(holder2)
fit_other.container.remove(holder3)
self.assert_object_buffers_empty(fit.container)
self.assert_object_buffers_empty(fit_other.container)
def test_iter(self):
fit = self.make_fit()
holder1 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
holder2 = Mock(_fit=None, state=State.offline, spec_set=CachingHolder(1))
self.assertEqual(set(holder for holder in fit.container), set())
fit.container.add(holder1)
self.assertEqual(set(holder for holder in fit.container), {holder1})
fit.container.add(holder2)
self.assertEqual(set(holder for holder in fit.container), {holder1, holder2})
fit.container.remove(holder1)
self.assertEqual(set(holder for holder in fit.container), {holder2})
fit.container.remove(holder2)
self.assertEqual(set(holder for holder in fit.container), set())
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_len(self):
fit = self.make_fit()
holder1 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
holder2 = Mock(_fit=None, state=State.online, spec_set=CachingHolder(1))
self.assertEqual(len(fit.container), 0)
fit.container.add(holder1)
self.assertEqual(len(fit.container), 1)
fit.container.add(holder2)
self.assertEqual(len(fit.container), 2)
fit.container.remove(holder1)
self.assertEqual(len(fit.container), 1)
fit.container.remove(holder2)
self.assertEqual(len(fit.container), 0)
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_attached_add_holder(self):
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder = Mock(_fit=None, state=State.online, spec_set=CachingHolder(1))
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_before = len(holder._clear_volatile_attrs.mock_calls)
# Action
fit.container.add(holder)
# Checks
self.assertEqual(len(fit.lt), 1)
self.assertIn(holder, fit.lt)
self.assertEqual(fit.lt[holder], {State.offline, State.online})
self.assertEqual(len(fit.rt), 1)
self.assertIn(holder, fit.rt)
self.assertEqual(fit.rt[holder], {State.offline, State.online})
self.assertEqual(len(fit.st), 1)
self.assertIn(holder, fit.st)
self.assertEqual(fit.st[holder], {State.offline, State.online})
self.assertEqual(len(fit.container), 1)
self.assertIn(holder, fit.container)
self.assertIs(holder._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_after = len(holder._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 1)
self.assertEqual(holder_cleans_after - holder_cleans_before, 1)
# Misc
fit.container.remove(holder)
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_detached_add_holder_value_failure(self):
fit = self.make_fit()
fit_other = self.make_fit()
holder = Mock(_fit=None, state=State.overload, spec_set=CachingHolder(1))
fit_other.container.add(holder)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_before = len(holder._clear_volatile_attrs.mock_calls)
st_other_cleans_before = len(fit_other.stats._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(ValueError, fit.container.add, holder)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertEqual(len(fit.container), 0)
self.assertEqual(len(fit_other.lt), 0)
self.assertEqual(len(fit_other.rt), 0)
self.assertEqual(len(fit_other.st), 0)
self.assertEqual(len(fit_other.container), 1)
self.assertIn(holder, fit_other.container)
self.assertIs(holder._fit, fit_other)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_after = len(holder._clear_volatile_attrs.mock_calls)
st_other_cleans_after = len(fit_other.stats._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder_cleans_after - holder_cleans_before, 0)
self.assertEqual(st_other_cleans_after - st_other_cleans_before, 0)
# Misc
fit_other.container.remove(holder)
self.assert_fit_buffers_empty(fit)
self.assert_fit_buffers_empty(fit_other)
self.assert_object_buffers_empty(fit.container)
self.assert_object_buffers_empty(fit_other.container)
def test_none_to_none(self, source_mgr):
source_mgr.default = None
holder = Mock(_fit=None,
state=State.offline,
spec_set=CachingHolder(1))
fit = self.make_fit(source=None)
fit.container.add(holder)
holder_calls_before = len(holder.mock_calls)
lt_calls_before = len(fit._link_tracker.mock_calls)
rt_calls_before = len(fit._restriction_tracker.mock_calls)
st_calls_before = len(fit.stats.mock_calls)
sm_calls_before = len(source_mgr.mock_calls)
# Action
fit.source = None
# Checks
holder_calls_after = len(holder.mock_calls)
lt_calls_after = len(fit._link_tracker.mock_calls)
rt_calls_after = len(fit._restriction_tracker.mock_calls)
st_calls_after = len(fit.stats.mock_calls)
sm_calls_after = len(source_mgr.mock_calls)
self.assertEqual(holder_calls_after - holder_calls_before, 0)
self.assertEqual(lt_calls_after - lt_calls_before, 0)
self.assertEqual(rt_calls_after - rt_calls_before, 0)
self.assertEqual(st_calls_after - st_calls_before, 0)
self.assertEqual(sm_calls_after - sm_calls_before, 0)
def test_detached_add_holder(self):
fit = self.make_fit()
holder = Mock(_fit=None,
_type_id=1,
state=State.offline,
spec_set=CachingHolder(1))
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_before = len(holder._clear_volatile_attrs.mock_calls)
# Action
fit.container.add(holder)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertEqual(len(fit.container), 1)
self.assertIs(fit.container[1], holder)
self.assertIn(holder, fit.container)
self.assertIs(holder._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_after = len(holder._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder_cleans_after - holder_cleans_before, 0)
# Misc
fit.container.remove(holder)
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_attached_delitem_holder(self):
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder = Mock(_fit=None,
_type_id=1,
state=State.active,
spec_set=CachingHolder(1))
fit.container.add(holder)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_before = len(holder._clear_volatile_attrs.mock_calls)
# Action
del fit.container[1]
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertEqual(len(fit.container), 0)
self.assertIsNone(holder._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_after = len(holder._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 1)
self.assertEqual(holder_cleans_after - holder_cleans_before, 1)
# Misc
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_detached_holder_onto_none_type_failure(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.online,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.online,
spec_set=OtherCachingHolder(1))
fit.container.insert(1, holder1)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(TypeError, fit.container.place, 0, holder2)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertIs(len(fit.container), 2)
self.assertIsNone(fit.container[0])
self.assertIs(fit.container[1], holder1)
self.assertIs(holder1._fit, fit)
self.assertIsNone(holder2._fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 0)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 0)
# Misc
fit.container.remove(holder1)
self.assert_object_buffers_empty(fit.container)
def test_attached_index_outside(self):
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
fit.container.append(holder)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_before = len(holder._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(IndexError, fit.container.free, 5)
# Checks
self.assertEqual(len(fit.lt), 1)
self.assertIn(holder, fit.lt)
self.assertEqual(fit.lt[holder],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.rt), 1)
self.assertIn(holder, fit.rt)
self.assertEqual(fit.rt[holder],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.st), 1)
self.assertIn(holder, fit.st)
self.assertEqual(fit.st[holder],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.container), 1)
self.assertIs(fit.container[0], holder)
self.assertIs(holder._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_after = len(holder._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder_cleans_after - holder_cleans_before, 0)
# Misc
fit.container.free(holder)
self.assert_object_buffers_empty(fit.container)
def test_attached_delitem_holder_failure(self):
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder = Mock(_fit=None,
_type_id=1,
state=State.active,
spec_set=CachingHolder(1))
fit.container.add(holder)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_before = len(holder._clear_volatile_attrs.mock_calls)
# Action
self.assertRaises(KeyError, fit.container.__delitem__, 3)
# Checks
self.assertEqual(len(fit.lt), 1)
self.assertIn(holder, fit.lt)
self.assertEqual(fit.lt[holder],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.rt), 1)
self.assertIn(holder, fit.rt)
self.assertEqual(fit.rt[holder],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.st), 1)
self.assertIn(holder, fit.st)
self.assertEqual(fit.st[holder],
{State.offline, State.online, State.active})
self.assertEqual(len(fit.container), 1)
self.assertIs(holder._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_after = len(holder._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder_cleans_after - holder_cleans_before, 0)
# Misc
fit.container.remove(holder)
self.assert_fit_buffers_empty(fit)
self.assert_object_buffers_empty(fit.container)
def test_detached_index_none(self):
fit = self.make_fit()
holder = Mock(_fit=None,
state=State.offline,
spec_set=CachingHolder(1))
fit.container.place(1, holder)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_before = len(holder._clear_volatile_attrs.mock_calls)
# Action
fit.container.free(0)
# Checks
self.assertEqual(len(fit.lt), 0)
self.assertEqual(len(fit.rt), 0)
self.assertEqual(len(fit.st), 0)
self.assertEqual(len(fit.container), 2)
self.assertIsNone(fit.container[0])
self.assertIs(fit.container[1], holder)
self.assertIs(holder._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder_cleans_after = len(holder._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 0)
self.assertEqual(holder_cleans_after - holder_cleans_before, 0)
# Misc
fit.container.free(holder)
self.assert_object_buffers_empty(fit.container)
def test_attached_holder_first_hole(self):
# Check that leftmost empty slot is taken
source = Mock(spec_set=Source)
fit = self.make_fit(source=source)
holder1 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
holder2 = Mock(_fit=None, state=State.offline, spec_set=CachingHolder(1))
holder3 = Mock(_fit=None, state=State.online, spec_set=CachingHolder(1))
holder4 = Mock(_fit=None, state=State.active, spec_set=CachingHolder(1))
fit.container.append(holder1)
fit.container.insert(3, holder2)
fit.container.insert(6, holder3)
st_cleans_before = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_before = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_before = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_before = len(holder3._clear_volatile_attrs.mock_calls)
holder4_cleans_before = len(holder4._clear_volatile_attrs.mock_calls)
# Action
fit.container.equip(holder4)
# Checks
self.assertEqual(len(fit.lt), 4)
self.assertIn(holder4, fit.lt)
self.assertEqual(fit.lt[holder4], {State.offline, State.online, State.active})
self.assertEqual(len(fit.rt), 4)
self.assertIn(holder4, fit.rt)
self.assertEqual(fit.rt[holder4], {State.offline, State.online, State.active})
self.assertEqual(len(fit.st), 4)
self.assertIn(holder4, fit.st)
self.assertEqual(fit.st[holder4], {State.offline, State.online, State.active})
self.assertIs(len(fit.container), 7)
self.assertIs(fit.container[1], holder4)
self.assertIs(holder4._fit, fit)
st_cleans_after = len(fit.stats._clear_volatile_attrs.mock_calls)
holder1_cleans_after = len(holder1._clear_volatile_attrs.mock_calls)
holder2_cleans_after = len(holder2._clear_volatile_attrs.mock_calls)
holder3_cleans_after = len(holder3._clear_volatile_attrs.mock_calls)
holder4_cleans_after = len(holder4._clear_volatile_attrs.mock_calls)
self.assertEqual(st_cleans_after - st_cleans_before, 1)
self.assertEqual(holder1_cleans_after - holder1_cleans_before, 1)
self.assertEqual(holder2_cleans_after - holder2_cleans_before, 1)
self.assertEqual(holder3_cleans_after - holder3_cleans_before, 1)
self.assertEqual(holder4_cleans_after - holder4_cleans_before, 1)
# Misc
fit.container.remove(holder1)
fit.container.remove(holder2)
fit.container.remove(holder3)
fit.container.remove(holder4)
self.assert_object_buffers_empty(fit.container)
def test_len(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.overload,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.offline,
spec_set=CachingHolder(1))
self.assertEqual(len(fit.container), 0)
fit.container.append(holder1)
self.assertEqual(len(fit.container), 1)
fit.container.place(3, holder2)
self.assertEqual(len(fit.container), 4)
fit.container.remove(holder1)
self.assertEqual(len(fit.container), 3)
fit.container.remove(holder2)
self.assertEqual(len(fit.container), 0)
self.assert_object_buffers_empty(fit.container)
def test_iter(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.online,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.active,
spec_set=CachingHolder(1))
self.assertEqual(list(holder for holder in fit.container), [])
fit.container.append(holder1)
self.assertEqual(list(holder for holder in fit.container), [holder1])
fit.container.place(3, holder2)
self.assertEqual(list(holder for holder in fit.container),
[holder1, None, None, holder2])
fit.container.remove(holder1)
self.assertEqual(list(holder for holder in fit.container),
[None, None, holder2])
fit.container.remove(holder2)
self.assertEqual(list(holder for holder in fit.container), [])
self.assert_object_buffers_empty(fit.container)
def test_holder_view(self):
fit = self.make_fit()
holder1 = Mock(_fit=None,
state=State.online,
spec_set=CachingHolder(1))
holder2 = Mock(_fit=None,
state=State.offline,
spec_set=CachingHolder(1))
view = fit.container.holders()
self.assertEqual(len(view), 0)
self.assertEqual(list(view), [])
self.assertFalse(holder1 in view)
self.assertFalse(holder2 in view)
self.assertFalse(None in view)
fit.container.append(holder1)
self.assertEqual(len(view), 1)
self.assertEqual(list(view), [holder1])
self.assertTrue(holder1 in view)
self.assertFalse(holder2 in view)
self.assertFalse(None in view)
fit.container.place(3, holder2)
self.assertEqual(len(view), 2)
self.assertEqual(list(view), [holder1, holder2])
self.assertTrue(holder1 in view)
self.assertTrue(holder2 in view)
self.assertFalse(None in view)
fit.container.free(holder1)
self.assertEqual(len(view), 1)
self.assertEqual(list(view), [holder2])
self.assertFalse(holder1 in view)
self.assertTrue(holder2 in view)
self.assertFalse(None in view)
fit.container.free(holder2)
self.assertEqual(len(view), 0)
self.assertEqual(list(view), [])
self.assertFalse(holder1 in view)
self.assertFalse(holder2 in view)
self.assertFalse(None in view)
self.assert_object_buffers_empty(fit.container)
def test_none_to_literal_source(self, source_mgr):
source = Mock(spec_set=Source)
source_mgr.get.side_effect = lambda alias: source if alias == 'src_alias' else None
source_mgr.default = None
holder = Mock(_fit=None,
state=State.offline,
spec_set=CachingHolder(1))
fit = self.make_fit(source=None)
fit.container.add(holder)
holder_calls_before = len(holder.mock_calls)
lt_calls_before = len(fit._link_tracker.mock_calls)
rt_calls_before = len(fit._restriction_tracker.mock_calls)
st_calls_before = len(fit.stats.mock_calls)
sm_calls_before = len(source_mgr.mock_calls)
fit._link_tracker.add_holder.side_effect = lambda h: self.assertIs(
h._fit.source, source)
fit._link_tracker.enable_states.side_effect = lambda h, s: self.assertIs(
h._fit.source, source)
fit._restriction_tracker.enable_states.side_effect = lambda h, s: self.assertIs(
h._fit.source, source)
fit.stats.enable_states.side_effect = lambda h, s: self.assertIs(
h._fit.source, source)
holder._refresh_source.side_effect = lambda: self.assertIs(
holder._fit.source, source)
# Action
fit.source = 'src_alias'
# Checks
holder_calls_after = len(holder.mock_calls)
lt_calls_after = len(fit._link_tracker.mock_calls)
rt_calls_after = len(fit._restriction_tracker.mock_calls)
st_calls_after = len(fit.stats.mock_calls)
sm_calls_after = len(source_mgr.mock_calls)
self.assertEqual(holder_calls_after - holder_calls_before, 2)
holder_calls = holder.mock_calls[-2:]
self.assertIn(call._refresh_source(), holder_calls)
self.assertIn(call._clear_volatile_attrs(), holder_calls)
self.assertEqual(lt_calls_after - lt_calls_before, 2)
self.assertEqual(fit._link_tracker.mock_calls[-2],
call.add_holder(holder))
self.assertEqual(fit._link_tracker.mock_calls[-1],
call.enable_states(holder, {State.offline}))
self.assertEqual(rt_calls_after - rt_calls_before, 1)
self.assertEqual(fit._restriction_tracker.mock_calls[-1],
call.enable_states(holder, {State.offline}))
self.assertEqual(st_calls_after - st_calls_before, 2)
self.assertEqual(fit.stats.mock_calls[-2],
call._clear_volatile_attrs())
self.assertEqual(fit.stats.mock_calls[-1],
call._enable_states(holder, {State.offline}))
self.assertEqual(sm_calls_after - sm_calls_before, 1)
self.assertEqual(source_mgr.mock_calls[-1], call.get('src_alias'))
