def test_selftest(self):
coll = dut.TraceableCollection()
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
# Self test should pass
coll.self_test()
# Create first item
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
# Improper use: add target on item level (no sanity check and no automatic reverse link)
item1.add_target(self.fwd_relation, self.identification_tgt)
# Improper use is not detected at level of item-level
item1.self_test()
# Add item to collection
coll.add_item(item1)
# Self test should fail as target item is not in collection
with self.assertRaises(dut.MultipleTraceabilityExceptions):
coll.self_test()
# Self test one limited scope (no matching document), should pass
coll.self_test('document-does-not-exist.rst')
# Creating and adding second item, self test should still fail as no automatic reverse relation
item2 = item.TraceableItem(self.identification_tgt)
item2.set_document(self.docname)
coll.add_item(item2)
with self.assertRaises(dut.MultipleTraceabilityExceptions):
coll.self_test()
# Mimicing the automatic reverse relation, self test should pass
item2.add_target(self.rev_relation, self.identification_src)
coll.self_test()
def test_add_item(self):
coll = dut.TraceableCollection()
# Initially no items
self.assertFalse(coll.has_item(self.identification_src))
self.assertIsNone(coll.get_item(self.identification_src))
item_iterator = coll.iter_items()
self.assertNotIn(self.identification_src, item_iterator)
self.assertNotIn(self.identification_tgt, item_iterator)
# Add an item
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
coll.add_item(item1)
self.assertTrue(coll.has_item(self.identification_src))
self.assertEqual(item1, coll.get_item(self.identification_src))
# Add same item: should give warning
with self.assertRaises(exception.TraceabilityException):
coll.add_item(item1)
self.assertTrue(coll.has_item(self.identification_src))
self.assertEqual(1, len(coll.items))
self.assertEqual(item1, coll.get_item(self.identification_src))
# Add a second item, make sure first one is still there
self.assertFalse(coll.has_item(self.identification_tgt))
item2 = item.TraceableItem(self.identification_tgt)
item2.set_document(self.docname)
coll.add_item(item2)
self.assertTrue(coll.has_item(self.identification_tgt))
self.assertEqual(item2, coll.get_item(self.identification_tgt))
self.assertEqual(item1, coll.get_item(self.identification_src))
# Verify iterator
item_iterator = coll.iter_items()
self.assertIn(self.identification_src, item_iterator)
self.assertIn(self.identification_tgt, item_iterator)
# Self test should pass
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
coll.self_test()
def test_related(self):
coll = dut.TraceableCollection()
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
self.assertFalse(
coll.are_related(self.identification_src, [],
self.identification_tgt))
item1 = item.TraceableItem(self.identification_src)
coll.add_item(item1)
self.assertFalse(
coll.are_related(self.identification_src, [],
self.identification_tgt))
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
# placeholder should be excluded
self.assertFalse(
coll.are_related(self.identification_src, [],
self.identification_tgt))
item2 = item.TraceableItem(self.identification_tgt)
# placeholder is replaced by actual item
coll.add_item(item2)
self.assertTrue(
coll.are_related(self.identification_src, [],
self.identification_tgt))
self.assertTrue(
coll.are_related(self.identification_src, [self.fwd_relation],
self.identification_tgt))
self.assertTrue(
coll.are_related(self.identification_src,
[self.fwd_relation, 'another-relation'],
self.identification_tgt))
def test_export_single_item(self, json_mock):
json_mock_object = MagicMock(spec=dut.json)
json_mock.return_value = json_mock_object
open_mock = mock_open()
coll = dut.TraceableCollection()
item1 = item.TraceableItem(self.identification_src)
coll.add_item(item1)
with patch('mlx.traceable_collection.open', open_mock, create=True):
coll.export(self.mock_export_file)
open_mock.assert_called_once_with(self.mock_export_file, 'w')
def test_add_relation_pair_unidir(self):
coll = dut.TraceableCollection()
# Initially no relations, so no reverse
self.assertIsNone(coll.get_reverse_relation(self.unidir_relation))
# Add a uni-directional relation pair
coll.add_relation_pair(self.unidir_relation)
# Reverse for fwd should be nothing
self.assertEqual(coll.NO_RELATION_STR,
coll.get_reverse_relation(self.unidir_relation))
# Self test should pass
coll.self_test()
def test_add_relation_unknown_source(self):
# with unknown source item, exception is expected
coll = dut.TraceableCollection()
item2 = item.TraceableItem(self.identification_tgt)
item2.set_document(self.docname)
coll.add_item(item2)
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
with self.assertRaises(ValueError):
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
# Self test should pass
coll.self_test()
def test_get_items(self):
coll = dut.TraceableCollection()
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
self.assertEqual(0, len(coll.get_items('\w*')))
item1 = item.TraceableItem(self.identification_src)
coll.add_item(item1)
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
# placeholder should be excluded
self.assertEqual(1, len(coll.get_items('\w*')))
item2 = item.TraceableItem(self.identification_tgt)
# placeholder is replaced by actual item
coll.add_item(item2)
self.assertEqual(2, len(coll.get_items('\w*')))
# Empty filter should match all items
self.assertEqual(2, len(coll.get_items('')))
def test_stringify(self):
coll = dut.TraceableCollection()
# Assert relation pairs are printed
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
collstr = str(coll)
self.assertIn(self.fwd_relation, collstr)
self.assertIn(self.rev_relation, collstr)
# Add some items and relations, assert they are in the string
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
coll.add_item(item1)
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
collstr = str(coll)
self.assertIn(self.identification_src, collstr)
self.assertIn(self.identification_tgt, collstr)
def test_add_relation_pair_bidir(self):
coll = dut.TraceableCollection()
# Initially no relations, so no reverse
self.assertIsNone(coll.get_reverse_relation(self.fwd_relation))
relations_iterator = coll.iter_relations()
self.assertNotIn(self.fwd_relation, relations_iterator)
self.assertNotIn(self.rev_relation, relations_iterator)
# Add a bi-directional relation pair
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
# Reverse for fwd should be rev, and vice-versa
self.assertEqual(self.rev_relation,
coll.get_reverse_relation(self.fwd_relation))
self.assertEqual(self.fwd_relation,
coll.get_reverse_relation(self.rev_relation))
# Verify relations iterator
relations_iterator = coll.iter_relations()
self.assertIn(self.fwd_relation, relations_iterator)
self.assertIn(self.rev_relation, relations_iterator)
# Self test should pass
coll.self_test()
def test_get_items_attribute(self):
coll = dut.TraceableCollection()
item1 = item.TraceableItem(self.identification_src)
coll.add_item(item1)
item2 = item.TraceableItem(self.identification_tgt)
coll.add_item(item2)
self.assertEqual(2, len(coll.get_items('')))
self.assertEqual(
0,
len(
coll.get_items(
'', {self.attribute_key: self.attribute_value_src})))
self.assertEqual(
0,
len(
coll.get_items(
'', {self.attribute_key: self.attribute_value_tgt})))
item1.add_attribute(self.attribute_key, self.attribute_value_src)
self.assertEqual(
1,
len(
coll.get_items(
'', {self.attribute_key: self.attribute_value_src})))
self.assertEqual(
0,
len(
coll.get_items(
'', {self.attribute_key: self.attribute_value_tgt})))
item2.add_attribute(self.attribute_key, self.attribute_value_tgt)
self.assertEqual(
1,
len(
coll.get_items(
'', {self.attribute_key: self.attribute_value_src})))
self.assertEqual(
1,
len(
coll.get_items(
'', {self.attribute_key: self.attribute_value_tgt})))
def test_add_relation_happy(self):
# Normal addition of relation, everything is there
coll = dut.TraceableCollection()
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
item2 = item.TraceableItem(self.identification_tgt)
item2.set_document(self.docname)
coll.add_item(item1)
coll.add_item(item2)
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
# Assert explicit forward relation is created
relations = item1.iter_targets(self.fwd_relation,
explicit=True,
implicit=False)
self.assertEqual(1, len(relations))
self.assertEqual(relations[0], self.identification_tgt)
relations = item1.iter_targets(self.fwd_relation,
explicit=False,
implicit=True)
self.assertEqual(0, len(relations))
# Assert item2 is not a placeholder item
item2_read = coll.get_item(self.identification_tgt)
self.assertFalse(item2.is_placeholder())
self.assertEqual(item2, item2_read)
# Assert implicit reverse relation is created
relations = item2.iter_targets(self.rev_relation,
explicit=False,
implicit=True)
self.assertEqual(1, len(relations))
self.assertEqual(relations[0], self.identification_src)
relations = item2.iter_targets(self.fwd_relation,
explicit=True,
implicit=False)
self.assertEqual(0, len(relations))
# Self test should pass
coll.self_test()
def test_add_relation_unidirectional(self):
# Normal addition of uni-directional relation
coll = dut.TraceableCollection()
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
coll.add_item(item1)
coll.add_relation_pair(self.unidir_relation)
coll.add_relation(self.identification_src, self.unidir_relation,
self.identification_tgt)
# Assert explicit forward relation is created
relations = item1.iter_targets(self.unidir_relation,
explicit=True,
implicit=False)
self.assertEqual(1, len(relations))
self.assertEqual(relations[0], self.identification_tgt)
relations = item1.iter_targets(self.unidir_relation,
explicit=False,
implicit=True)
self.assertEqual(0, len(relations))
# Assert item2 is not existent
self.assertIsNone(coll.get_item(self.identification_tgt))
# Self test should pass
coll.self_test()
def test_add_relation_unknown_relation(self):
# with unknown relation, warning is expected
coll = dut.TraceableCollection()
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
item2 = item.TraceableItem(self.identification_tgt)
item2.set_document(self.docname)
coll.add_item(item1)
coll.add_item(item2)
with self.assertRaises(exception.TraceabilityException):
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
relations = item1.iter_targets(self.fwd_relation,
explicit=True,
implicit=True)
self.assertEqual(0, len(relations))
relations = item2.iter_targets(self.fwd_relation,
explicit=True,
implicit=True)
self.assertEqual(0, len(relations))
# Self test should pass
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
coll.self_test()
def test_add_relation_unknown_target(self):
# With unknown target item, the generation of a placeholder is expected
coll = dut.TraceableCollection()
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
coll.add_item(item1)
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
# Assert explicit forward relation is created
relations = item1.iter_targets(self.fwd_relation,
explicit=True,
implicit=False)
self.assertEqual(1, len(relations))
self.assertEqual(relations[0], self.identification_tgt)
relations = item1.iter_targets(self.fwd_relation,
explicit=False,
implicit=True)
self.assertEqual(0, len(relations))
# Assert placeholder item is created
item2 = coll.get_item(self.identification_tgt)
self.assertIsNotNone(item2)
self.assertEqual(self.identification_tgt, item2.get_id())
self.assertTrue(item2.is_placeholder())
# Assert implicit reverse relation is created
relations = item2.iter_targets(self.rev_relation,
explicit=False,
implicit=True)
self.assertEqual(1, len(relations))
self.assertEqual(relations[0], self.identification_src)
relations = item2.iter_targets(self.fwd_relation,
explicit=True,
implicit=False)
self.assertEqual(0, len(relations))
# Self test should fail, as we have a placeholder item
with self.assertRaises(dut.MultipleTraceabilityExceptions):
coll.self_test()
def test_add_item_overwrite(self):
coll = dut.TraceableCollection()
item1 = item.TraceableItem(self.identification_src)
item1.set_document(self.docname)
coll.add_item(item1)
coll.add_relation_pair(self.fwd_relation, self.rev_relation)
coll.add_relation(self.identification_src, self.fwd_relation,
self.identification_tgt)
# Add target item: should update existing one (keeping relations)
item2 = item.TraceableItem(self.identification_tgt)
item2.set_document(self.docname)
coll.add_item(item2)
# Assert old relations are still there
item1_out = coll.get_item(self.identification_src)
item2_out = coll.get_item(self.identification_tgt)
relations = item1_out.iter_targets(self.fwd_relation)
self.assertEqual(1, len(relations))
self.assertEqual(relations[0], self.identification_tgt)
relations = item2_out.iter_targets(self.rev_relation)
self.assertEqual(1, len(relations))
self.assertEqual(relations[0], self.identification_src)
# Assert item are not placeholders
self.assertFalse(item1_out.is_placeholder())
self.assertFalse(item2_out.is_placeholder())
def test_init(self):
coll = dut.TraceableCollection()
# Self test should fail as no relations configured
with self.assertRaises(exception.TraceabilityException):
coll.self_test()
def test_export_no_items(self):
open_mock = mock_open()
coll = dut.TraceableCollection()
with patch('mlx.traceable_collection.open', open_mock, create=True):
coll.export(self.mock_export_file)
open_mock.assert_called_once_with(self.mock_export_file, 'w')
