def test_reset(self):
"""
Tests: sadface.reset()
A sadface document is created and manipulated then reset is used
to return the document to it's initial state
"""
# Iniitialise a SADFace document
sf.initialise()
expected = None
out = sf.get_title()
self.assertEqual(out, expected)
# Explicitly alter it
expected = "DAKA DAKA"
sf.set_title(expected)
out = sf.get_title()
self.assertEqual(out, expected)
# Reset the document - this should now be in the pre-init, empty-dict state
sf.reset()
expected = {}
out = sf.sd
self.assertEqual(out, expected)
def test_get_scheme(self):
"""
TESTS: sadface.get_scheme() with default values
"""
sf.initialise()
result = sf.get_node("invalid-uuid")
self.assertEqual(result, None)
def test_config_load(self):
"""
TESTS: sadface.config.load()
"""
# No specified configuration file. location is None
with self.assertRaises(Exception) as context:
sf.config.load()
self.assertTrue("Tried to load config file but location is set to None"
in str(context.exception))
# With bad configuration file
sf.config.set_location("examples/minimal.py")
with self.assertRaises(SystemExit):
sf.config.load()
# With good configuration file
sf.config.set_location("etc/test.cfg")
sf.config.load()
sf.initialise()
out = sf.get_document()
out['metadata']['core']['created'] = ""
out['metadata']['core']['edited'] = ""
out['metadata']['core']['id'] = ""
expected = json.loads(
'{ "edges": [], "metadata": { "core": { "analyst_email": "*****@*****.**", "analyst_name": "Inigo Montoya", "created": "", "edited": "", "id": "", "version": "0.5" } }, "nodes": [], "resources": []}'
)
self.assertEqual(out, expected)
def test_get_connections(self):
"""
TESTS: sadface.get_connections()
"""
sf.initialise()
# Test with a non-existant ID
results = sf.get_connections("TESTID")
self.assertEqual([], results)
# Test with existing ID that we create with no connections
source_atom = sf.add_atom("SOURCE")
results = sf.get_connections(source_atom.get("id"))
self.assertEqual([], results)
# Test with existing ID + known added connections
target_atom = sf.add_atom("TARGET")
edge = sf.add_edge(source_atom.get("id"), target_atom.get("id"))
results = sf.get_connections(source_atom.get("id"))
self.assertNotEqual([], results)
self.assertEqual(len(results), 1)
self.assertEqual(edge.get("id"), results[0].get("id"))
self.assertEqual(source_atom.get("id"), results[0].get("source_id"))
self.assertEqual(target_atom.get("id"), results[0].get("target_id"))
def test_get_scheme_metadata(self):
"""
TESTS: sadface.get_scheme_metadata(scheme_id, namespace=None, key=None)
"""
sf.initialise()
a = sf.add_scheme("scheme")
sf.add_scheme_metadata(a.get("id"), "TEST_NS", "TEST_KEY", "TEST_VAL")
sf.add_scheme_metadata(a.get("id"), "TEST_NS", "TEST_KEY2", "TEST_VA2")
sf.add_scheme_metadata(a.get("id"), "core", "TEST_KEY3", "TEST_VA3")
expected = {
'core': {
'TEST_KEY3': 'TEST_VA3'
},
'TEST_NS': {
'TEST_KEY': 'TEST_VAL',
'TEST_KEY2': 'TEST_VA2'
}
}
m = sf.get_scheme_metadata(a.get("id"))
self.assertEqual(expected, m)
expected = {'TEST_KEY3': 'TEST_VA3'}
m = sf.get_scheme_metadata(a.get("id"), "core")
self.assertEqual(expected, m)
expected = {'TEST_KEY': 'TEST_VAL', 'TEST_KEY2': 'TEST_VA2'}
m = sf.get_scheme_metadata(a.get("id"), "TEST_NS")
self.assertEqual(expected, m)
expected = "TEST_VA2"
m = sf.get_scheme_metadata(a.get("id"), "TEST_NS", "TEST_KEY2")
self.assertEqual(expected, m)
def test_add_atom_metadata(self):
"""
TESTS: sadface.add_atom_metadata()
"""
sf.initialise()
# Add an atom
atom_text = "test atom"
atom = sf.add_atom(atom_text)
atom_id = atom.get("id")
# Check atom metadata is empty
atom = sf.get_atom(atom_id)
self.assertEqual(atom_id, atom.get("id"))
meta = atom.get("metadata").get("core")
self.assertEqual(0, len(meta))
# add core metadata
sf.add_atom_metadata(atom_id, "core", "KEY1", "VALUE1")
atom = sf.get_atom(atom_id)
meta = atom.get("metadata").get("core")
self.assertNotEqual(0, len(meta))
self.assertEqual("VALUE1", meta.get("KEY1"))
# add metadata to new namespace
sf.add_atom_metadata(atom_id, "META1", "KEY1", "VALUE1")
atom = sf.get_atom(atom_id)
meta = atom.get("metadata").get("META1")
self.assertNotEqual(0, len(meta))
self.assertEqual("VALUE1", meta.get("KEY1"))
def test_add_scheme_metadata(self):
"""
TESTS: sadface.add_scheme_metadata()
"""
sf.initialise()
# Add an scheme
scheme_text = "test scheme"
scheme = sf.add_scheme(scheme_text)
scheme_id = scheme.get("id")
# Check scheme metadata is empty
scheme = sf.get_scheme(scheme_id)
self.assertEqual(scheme_id, scheme.get("id"))
meta = scheme.get("metadata").get("core")
self.assertEqual(0, len(meta))
# add core metadata
sf.add_scheme_metadata(scheme_id, "core", "KEY1", "VALUE1")
scheme = sf.get_scheme(scheme_id)
meta = scheme.get("metadata").get("core")
self.assertNotEqual(0, len(meta))
self.assertEqual("VALUE1", meta.get("KEY1"))
# add metadata to new namespace
sf.add_scheme_metadata(scheme_id, "META1", "KEY1", "VALUE1")
scheme = sf.get_scheme(scheme_id)
meta = scheme.get("metadata").get("META1")
self.assertNotEqual(0, len(meta))
self.assertEqual("VALUE1", meta.get("KEY1"))
def test_add_resource(self):
"""
TESTS: sadface.add_resource(content)
"""
sf.initialise()
new_resource = sf.add_resource("DAKA DAKA")
new_resource_content = new_resource.get("content")
new_resource_type = new_resource.get("type")
self.assertTrue(new_resource.get("id"))
out = new_resource.get("id")
result = False
try:
if UUID(out, version=4):
result = True
except:
pass
self.assertTrue(result)
self.assertTrue(new_resource.get("metadata"))
self.assertTrue(type(new_resource.get("metadata")) is dict)
expected = {"core"}
self.assertEqual(set(expected), set(new_resource.get("metadata")))
self.assertEqual(new_resource_content, "DAKA DAKA")
self.assertEqual(new_resource_type, "text")
def test_get_source(self):
"""
TESTS: sadface.get_source()
"""
sf.initialise()
# Add an atom
text = "DAKA DAKA"
atom = sf.add_atom(text)
atom_id = sf.contains_atom(text)
# Add a resource
resource_text = "test resource"
resource = sf.add_resource(resource_text)
resource_id = resource.get("id")
s = sf.get_source(atom_id, resource_id)
self.assertEqual(s, None)
# Add source to the atom, referencing the resource
offset = 5
length = len(resource_text)
sf.add_source(atom_id, resource_id, resource_text, offset, length)
# Now retrieve the source and test it
s = sf.get_source(atom_id, resource_id)
self.assertEqual(s.get("resource_id"), resource_id)
self.assertEqual(s.get("text"), resource_text)
self.assertEqual(s.get("offset"), offset)
self.assertEqual(s.get("length"), length)
def test_add_resource_metadata(self):
"""
TESTS: sadface.add_resource_metadata()
"""
sf.initialise()
# Add a resource
resource_text = "test resource"
resource = sf.add_resource(resource_text)
resource_id = resource.get("id")
# Check resource metadata is empty
resource = sf.get_resource(resource_id)
self.assertEqual(resource_id, resource.get("id"))
meta = resource.get("metadata").get("core")
self.assertEqual(0, len(meta))
# add metadata to core namespace
sf.add_resource_metadata(resource_id, "core", "KEY1", "VALUE1")
resource = sf.get_resource(resource_id)
meta = resource.get("metadata").get("core")
self.assertNotEqual(0, len(meta))
self.assertEqual("VALUE1", meta.get("KEY1"))
# add metadata to a new namespace
sf.add_resource_metadata(resource_id, "META1", "KEY1", "VALUE1")
resource = sf.get_resource(resource_id)
meta = resource.get("metadata").get("META1")
self.assertNotEqual(0, len(meta))
self.assertEqual("VALUE1", meta.get("KEY1"))
def test_get_analyst(self):
"""
TESTS: sadface.get_analyst()
"""
sf.initialise()
analyst = "A User"
retrieved_analyst = sf.get_analyst()
self.assertEqual(retrieved_analyst, analyst)
def test_get_version(self):
"""
Tests: sadface.get_version()
"""
sf.initialise()
out = sf.get_version()
expected = "0.5"
self.assertEqual(out, expected)
def test_list_schemes(self):
"""
Tests: sadface.get_arguments() with default values after init
"""
sf.initialise()
out = sf.list_schemes()
expected = []
self.assertEqual(out, expected)
def test_get_notes(self):
"""
Tests: sadface.get_notes() with default values after init
"""
sf.initialise()
out = sf.get_notes()
expected = None
self.assertEqual(out, expected)
def test_list_resources(self):
"""
Tests: sadface.list_resources()
"""
sf.initialise()
out = sf.list_resources()
expected = []
self.assertEqual(out, expected)
def test_get_edited(self):
"""
Tests: sadface.get_edited()
"""
sf.initialise()
# Check that timestamp for edited time is a string
timestamp = sf.get_edited()
self.assertEqual(True, isinstance(timestamp, str))
def test_set_atom_text(self):
"""
TESTS: sadface.set_atom_text()
"""
sf.initialise()
atom = sf.add_atom("DAKA DAKA")
atom_id = atom.get("id")
sf.set_atom_text(atom_id, "MORE DAKA")
self.assertEqual(sf.get_atom_text(atom_id), "MORE DAKA")
def test_get_resource(self):
"""
TESTS: sadface.get_resource(resource_id)
"""
sf.initialise()
new_resource = sf.add_resource("DAKA DAKA")
new_resource_id = new_resource.get("id")
retrieved_resource = sf.get_resource(new_resource_id)
self.assertEqual(retrieved_resource, new_resource)
def test_set_title(self):
"""
Tests: sadface.get_title() & set_title
"""
sf.initialise()
t = "test title"
sf.set_title(t)
out = sf.get_title()
expected = t
self.assertEqual(out, expected)
def test_set_edited(self):
"""
TESTS: sadface.set_edited(timestamp)
"""
sf.initialise()
# TEST 1: Set edited timestamp then retrieve & compare
timestamp = sf.now()
sf.set_edited(timestamp)
retrieved_timestamp = sf.get_edited()
self.assertEqual(timestamp, retrieved_timestamp)
def test_set_claim(self):
"""
TESTS: sadface.set_claim()
"""
sf.initialise()
self.assertEqual(sf.get_claim(), None)
atom = sf.add_atom("DAKA DAKA")
atom_id = atom.get("id")
sf.set_claim(atom_id)
self.assertEqual(sf.get_claim(), atom_id)
def test_get_scheme(self):
"""
TESTS: sadface.get_scheme() after a scheme has been added
"""
sf.initialise()
scheme_node = sf.add_scheme("test-scheme")
scheme_node_id = scheme_node.get("id")
result = sf.get_scheme(scheme_node_id)
self.assertEqual(result.get("id"), scheme_node_id)
self.assertEqual(result.get("text"), scheme_node.get("text"))
def test_append_notes(self):
"""
TESTS: sadface.append_notes()
"""
sf.initialise()
text = "DAKA DAKA"
sf.append_notes(text)
self.assertEqual(sf.get_notes(), text)
text2 = "MORE DAKA"
sf.append_notes(text2)
self.assertEqual(sf.get_notes(), text + text2)
def test_set_document_id(self):
"""
TESTS: sadface.set_document_id(id)
"""
sf.initialise()
current_id = sf.get_document_id()
self.assertNotEqual(None, current_id)
test_id = "1234567890abcdefgh"
sf.set_document_id(test_id)
current_id = sf.get_document_id()
self.assertEqual(test_id, current_id)
def test_get_atom(self):
"""
TESTS: sadface.get_atom()
"""
sf.initialise()
self.assertEqual(sf.get_atom("unknown-id"), None)
text = "DAKA DAKA"
atom = sf.add_atom(text)
atom_id = atom.get("id")
result = sf.get_atom(atom_id)
result_id = result.get("id")
self.assertEqual(result_id, atom_id)
def test_clear_notes(self):
"""
Tests: sadface.clear_notes()
"""
sf.initialise()
self.assertEqual(sf.get_notes(), None)
text = "DAKA DAKA"
sf.add_notes(text)
self.assertEqual(sf.get_notes(), text)
sf.clear_notes()
self.assertEqual(sf.get_notes(), None)
def test_add_conflict(self):
"""
TESTS: add_conflict(arg_text=None, arg_id=None, conflict_text=None, conflict_id=None)
"""
sf.initialise()
a_text = "roses are red"
c_text = "roses are white"
conflict = sf.add_conflict(arg_text=a_text, conflict_text=c_text)
self.assertEqual(a_text, conflict.get("argument").get("text"))
self.assertEqual(c_text, conflict.get("conflict").get("text"))
self.assertEqual("conflict", conflict.get("scheme").get("name"))
def test_delete_scheme(self):
"""
"""
sf.initialise()
# Remove non-existing scheme
with self.assertRaises(ValueError):
sf.delete_scheme("FAKE_ID")
# Remove existing scheme
s = sf.add_scheme("TEST_SCHEME_NAME")
retrieved = sf.get_scheme(s.get("id"))
self.assertEqual(s, retrieved)
def test_get_document_id(self):
"""
Tests: sadface.get_argument_id() with default values after init
"""
sf.initialise()
out = sf.get_document_id()
result = False
try:
if UUID(out, version=4):
result = True
except:
pass
self.assertTrue(result)
def test_get_edge(self):
"""
TESTS: sadface.get_edge()
"""
sf.initialise()
source = sf.add_atom("source")
target = sf.add_atom("target")
edge = sf.add_edge(source.get("id"), target.get("id"))
retrieved_edge = sf.get_edge(edge.get("id"))
self.assertEqual(retrieved_edge.get("source_id"), source.get("id"))
self.assertEqual(retrieved_edge.get("target_id"), target.get("id"))
self.assertEqual(retrieved_edge.get("id"), edge.get("id"))
