class NodesFindAllTest(unittest.TestCase):
def setUp(self):
"""
Tests for findall() and findall_withUserID()
Create 1 user, 1 issue and 5 value nodes
User ranks values 0, 3, 4
Issue has values 0, 1, 4
"""
self.handler = Handler()
self.issue = Node(self.handler, "TestIssue")
self.nodes = [ Node(self.handler, "TestValue") for i in range(0, 5) ]
self.user = User(self.handler)
Link(self.handler, self.issue.node, self.nodes[0].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[1].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[4].node, "HAS")
Rank(self.handler, self.user.node, self.nodes[0].node, 1)
Rank(self.handler, self.user.node, self.nodes[3].node, 2)
Rank(self.handler, self.user.node, self.nodes[4].node, -1)
def tearDown(self):
self.handler.clean_up()
def test_findall(self):
"""
test that all TestValue nodes are returned
"""
node_ids = [ node.node_id for node in self.nodes ]
nodes = graph.nodes.find_all("TestValue")
for node in nodes:
self.assertIn(node["node_id"], node_ids)
def test_parent_issue_findall(self):
"""
test that only TestValue nodes 0, 1, 4 are returned as the other nodes do
not have a link from the TestIssue node
"""
nodeIn_ids = [self.nodes[0].node_id, self.nodes[1].node_id, self.nodes[4].node_id]
nodeNotIn_ids = [self.nodes[2].node_id, self.nodes[3].node_id]
args = dict(parent_id=self.issue.node_id, parent_label="TestIssue")
nodes = graph.nodes.find_all("TestValue", **args)
for node in nodes:
self.assertIn(node["node_id"], nodeIn_ids)
self.assertNotEqual(node["node_id"], nodeNotIn_ids)
def test_parent_issue_findall_withUserID(self):
"""
test that only TestValue 2 nodes 0, 4 are returned as the other nodes do
not have a link from the TestIssue node or are not ranked by the user
"""
nodeIn_ids = [self.nodes[0].node_id, self.nodes[4].node_id]
nodeNotIn_ids = [self.nodes[1].node_id, self.nodes[2].node_id, self.nodes[3].node_id]
args = dict(parent_id=self.issue.node_id, parent_label="TestIssue")
nodes = graph.nodes.find_all_withUserID("TestValue", self.user.node_id,**args)
for node in nodes:
self.assertIn(node["node_id"], nodeIn_ids)
self.assertNotEqual(node["node_id"], nodeNotIn_ids)
class NodeTest(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
def tearDown(self):
self.handler.clean_up()
def runner(self):
data = dict(id=self.node.node_id)
rv = self.app.get(self.endpoint, data=data)
response = safe_json_loads(rv.data)
contains_id = set(data.items()).issubset(set(response.items()))
self.assertTrue(contains_id, msg="response does not contain node id")
class NodeTest(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
def tearDown(self):
self.handler.clean_up()
def runner(self):
data = dict(id=self.node.node_id)
rv = self.app.get(self.endpoint, data=data)
response = safe_json_loads(rv.data)
contains_id = set(data.items()).issubset(set(response.items()))
self.assertTrue(contains_id, msg="response does not contain node id")
def setUp(self):
"""
Tests for findall() and findall_withUserID()
Create 1 user, 1 issue and 5 value nodes
User ranks values 0, 3, 4
Issue has values 0, 1, 4
"""
self.handler = Handler()
self.issue = Node(self.handler, "TestIssue")
self.nodes = [Node(self.handler, "TestValue") for i in range(0, 5)]
self.user = User(self.handler)
Link(self.handler, self.issue.node, self.nodes[0].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[1].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[4].node, "HAS")
Rank(self.handler, self.user.node, self.nodes[0].node, 1)
Rank(self.handler, self.user.node, self.nodes[3].node, 2)
Rank(self.handler, self.user.node, self.nodes[4].node, -1)
class RankTest(unittest.TestCase):
rank = randint(0, 99)
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user = User(self.handler)
self.issue_id = str(uuid.uuid4())
def tearDown(self):
self.handler.clean_up()
def parameters(self):
return dict(
user_id=self.user.node_id,
node_id=self.node.node_id,
rank=self.rank,
issue_id=self.issue_id,
)
def find_link(self):
link = graph.links.find(self.user.node, self.node.node, "RANKS")
self.handler.add_link(link)
return link
def check_rank(self):
link = self.find_link()
assert link, "failed to find link"
self.assertEqual(link.properties["rank"], self.rank)
def check_status_code(self, code):
assert code == 200, "status code not 200"
def check_response(self, expected, data):
response = safe_json_loads(data)
error = "expecting: {0}, actual: {1}".format(expected, response)
assert response == expected, error
def runner(self):
rv = self.app.post(self.endpoint, data=self.data)
expected = dict(success=True)
self.check_status_code(rv.status_code)
self.check_response(expected, rv.data)
self.check_rank()
class RankTest(unittest.TestCase):
rank = randint(0, 99)
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user = User(self.handler)
self.issue_id = str(uuid.uuid4())
def tearDown(self):
self.handler.clean_up()
def parameters(self):
return dict(
user_id=self.user.node_id,
node_id=self.node.node_id,
rank=self.rank,
issue_id=self.issue_id,
)
def find_link(self):
link = graph.links.find(self.user.node, self.node.node, "RANKS")
self.handler.add_link(link)
return link
def check_rank(self):
link = self.find_link()
assert link, "failed to find link"
self.assertEqual(link.properties["rank"], self.rank)
def check_status_code(self, code):
assert code == 200, "status code not 200"
def check_response(self, expected, data):
response = safe_json_loads(data)
error = "expecting: {0}, actual: {1}".format(expected, response)
assert response == expected, error
def runner(self):
rv = self.app.post(self.endpoint, data=self.data)
expected = dict(success=True)
self.check_status_code(rv.status_code)
self.check_response(expected, rv.data)
self.check_rank()
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user_id = str(uuid.uuid4())
self.node = Node(self.handler, "Value")
self.endpoint = "/api/rank/value"
self.data = dict(user_id=self.user_id,
node_id=self.node.node_id,
rank=self.rank,
issue_id=str(uuid.uuid4()))
class NodesTest(unittest.TestCase):
SIZE = 3
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
def tearDown(self):
self.handler.clean_up()
def parameters(self):
return dict(filter_id=self.filter_id)
def init_db(self, parent_type, child_type):
"""
create parent and multiple children
then create a link from parent to every child
"""
self.parent = Node(self.handler, parent_type)
self.children = [
Node(self.handler, child_type) for x in range(0, self.SIZE)
]
for node in self.children:
Link(self.handler, self.parent.node, node.node, child_type.upper())
def check_status_code(self, code):
self.assertEqual(code, 200, msg="status code not 200")
def check_response(self, data):
response = safe_json_loads(data)
actual = [node["node_id"] for node in response["nodes"]]
msg = "response nodes contain an invalid node_id"
for node_id in [node.node_id for node in self.children]:
self.assertIn(node_id, actual, msg=msg)
def runner(self):
rv = self.app.get(self.endpoint, data=self.data)
self.check_status_code(rv.status_code)
self.check_response(rv.data)
class NodesTest(unittest.TestCase):
SIZE = 3
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
def tearDown(self):
self.handler.clean_up()
def parameters(self):
return dict(filter_id=self.filter_id)
def init_db(self, parent_type, child_type):
"""
create parent and multiple children
then create a link from parent to every child
"""
self.parent = Node(self.handler, parent_type)
self.children = [ Node(self.handler, child_type) for x in range(0, self.SIZE) ]
for node in self.children:
Link(self.handler, self.parent.node, node.node, child_type.upper())
def check_status_code(self, code):
self.assertEqual(code, 200, msg="status code not 200")
def check_response(self, data):
response = safe_json_loads(data)
actual = [ node["node_id"] for node in response["nodes"] ]
msg= "response nodes contain an invalid node_id"
for node_id in [ node.node_id for node in self.children ]:
self.assertIn(node_id, actual, msg=msg)
def runner(self):
rv = self.app.get(self.endpoint, data=self.data)
self.check_status_code(rv.status_code)
self.check_response(rv.data)
class LoginTests(unittest.TestCase):
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user = User(self.handler)
self.endpoint = "/api/login"
def tearDown(self):
self.handler.clean_up()
def parameters(self):
return dict(username=self.user.node_id, password=PASSWORD)
def check_status_code(self, code):
assert code == 200, "status code not 200"
def test_valid(self):
rv = self.app.post(self.endpoint, data=self.parameters())
self.check_status_code(rv.status_code)
self.assertTrue(safe_json_loads(rv.data)["success"],
msg="success not true")
def test_invalid_username(self):
data = self.parameters()
data["username"] = str(uuid.uuid4())
rv = self.app.post(self.endpoint, data=data)
self.check_status_code(rv.status_code)
msg = "login should have failed, invalid username"
self.assertFalse(safe_json_loads(rv.data)["success"], msg=msg)
def test_invalid_password(self):
data = self.parameters()
data["password"] = str(uuid.uuid4())
rv = self.app.post(self.endpoint, data=data)
self.check_status_code(rv.status_code)
msg = "login should have failed, invalid password"
self.assertFalse(safe_json_loads(rv.data)["success"], msg=msg)
def setUp(self):
"""
Tests for findall() and findall_withUserID()
Create 1 user, 1 issue and 5 value nodes
User ranks values 0, 3, 4
Issue has values 0, 1, 4
"""
self.handler = Handler()
self.issue = Node(self.handler, "TestIssue")
self.nodes = [ Node(self.handler, "TestValue") for i in range(0, 5) ]
self.user = User(self.handler)
Link(self.handler, self.issue.node, self.nodes[0].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[1].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[4].node, "HAS")
Rank(self.handler, self.user.node, self.nodes[0].node, 1)
Rank(self.handler, self.user.node, self.nodes[3].node, 2)
Rank(self.handler, self.user.node, self.nodes[4].node, -1)
class MapTest(unittest.TestCase):
strength = randint(0, 99)
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user = User(self.handler)
def tearDown(self):
args = dict(start_node=self.map_node,
rel_type="MAPS",
bidirectional=True)
for link in graph.graph.match(**args):
self.handler.add_link(link)
self.handler.clean_up()
def postSetUp(self):
self.data = self.parameters()
self.map_id = "{0}-{1}".format(self.src.node_id, self.dst.node_id)
# make sure each node is ranked by the user
Rank(self.handler, self.user.node, self.src.node, 1)
Rank(self.handler, self.user.node, self.dst.node, 1)
def parameters(self):
return dict(user_id=self.user.node_id,
strength=self.strength,
src_id=self.src.node_id,
dst_id=self.dst.node_id)
def check_status_code(self, code):
self.assertEqual(code, 200, msg="status code not 200")
def check_map(self):
self.map_node = graph.nodes.find("Map", self.map_id)
self.handler.add_node(self.map_node)
self.assertIsNotNone(self.map_node, msg="Map node was not created")
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user = User(self.handler)
self.endpoint = "/api/login"
class NodesFindAllTest(unittest.TestCase):
def setUp(self):
"""
Tests for findall() and findall_withUserID()
Create 1 user, 1 issue and 5 value nodes
User ranks values 0, 3, 4
Issue has values 0, 1, 4
"""
self.handler = Handler()
self.issue = Node(self.handler, "TestIssue")
self.nodes = [Node(self.handler, "TestValue") for i in range(0, 5)]
self.user = User(self.handler)
Link(self.handler, self.issue.node, self.nodes[0].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[1].node, "HAS")
Link(self.handler, self.issue.node, self.nodes[4].node, "HAS")
Rank(self.handler, self.user.node, self.nodes[0].node, 1)
Rank(self.handler, self.user.node, self.nodes[3].node, 2)
Rank(self.handler, self.user.node, self.nodes[4].node, -1)
def tearDown(self):
self.handler.clean_up()
def test_findall(self):
"""
test that all TestValue nodes are returned
"""
node_ids = [node.node_id for node in self.nodes]
nodes = graph.nodes.find_all("TestValue")
for node in nodes:
self.assertIn(node["node_id"], node_ids)
def test_parent_issue_findall(self):
"""
test that only TestValue nodes 0, 1, 4 are returned as the other nodes do
not have a link from the TestIssue node
"""
nodeIn_ids = sorted([
self.nodes[0].node_id, self.nodes[1].node_id, self.nodes[4].node_id
])
args = dict(parent_id=self.issue.node_id, parent_label="TestIssue")
answer_ids = sorted([
node["node_id"]
for node in graph.nodes.find_all("TestValue", **args)
])
self.assertEqual(nodeIn_ids, answer_ids)
def test_parent_issue_findall_withUserID(self):
"""
test that only TestValue 2 nodes 0, 4 are returned as the other nodes do
not have a link from the TestIssue node or are not ranked by the user
"""
nodeIn_ids = sorted([self.nodes[0].node_id, self.nodes[4].node_id])
args = dict(parent_id=self.issue.node_id, parent_label="TestIssue")
answer_nodes = graph.nodes.find_all_withUserID("TestValue",
self.user.node_id,
**args)
#for node in nodes:
# self.assertIn(node["node_id"], nodeIn_ids)
# self.assertNotIn(node["node_id"], nodeNotIn_ids)
answer_ids = sorted([node["node_id"] for node in answer_nodes])
self.assertEqual(nodeIn_ids, answer_ids)
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user = User(self.handler)
self.issue_id = str(uuid.uuid4())
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
self.user = User(self.handler)
self.issue_id = str(uuid.uuid4())
def setUp(self):
self.app = app.test_client()
self.handler = Handler()
