def setUp(self, get_session_mock, socket_client_mock):
"""Setting up Agent object
:param get_session_mock: MagicMock object for patching session.get
it's used to Mock Hydrus response to ApiDoc
"""
# Mocking get for ApiDoc to Server, so hydrus doesn't need to be up
get_session_mock.return_value.json.return_value = drone_doc
socket_client_mock.return_value = None
self.agent = Agent("http://localhost:8080/api")
self.redis_proxy = RedisProxy()
self.redis_connection = self.redis_proxy.get_connection()
self.redis_graph = Graph("apigraph", self.redis_connection)
def start_agent():
"""Receive hydrus server URL and start the Agent
:param body['url']: Entrypoint URL for the hydrus server
:return: Success message
"""
global agent
global url
body = request.get_data()
body = body.decode('utf8').replace("'", '"')
body = json.loads(body)
url = body['url']
agent = Agent(url)
return "Server started successfully"
from flask import Flask, request, send_from_directory
from flask_cors import CORS
from hydra_agent.agent import Agent
import sys
import json
import os
from requests import get
app = Flask(__name__, static_folder='console-frontend/build/')
# Setting CORS so it allows requests from our React app in localhost:3000
CORS(app, resources={r"*": {"origins": "http://*****:*****@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def serve(path):
"""Default endpoint, it serves the built static React App
:return: Served file
"""
file_path = os.path.join(app.static_folder, path)
if path != "" and os.path.exists(file_path):
return send_from_directory(app.static_folder, path)
else:
return send_from_directory(app.static_folder, 'index.html')
class TestAgent(unittest.TestCase):
"""
TestCase for Agent Class
"""
@patch('hydra_agent.agent.socketio.Client.connect')
@patch('hydra_agent.agent.Session.get')
def setUp(self, get_session_mock, socket_client_mock):
"""Setting up Agent object
:param get_session_mock: MagicMock object for patching session.get
it's used to Mock Hydrus response to ApiDoc
"""
# Mocking get for ApiDoc to Server, so hydrus doesn't need to be up
get_session_mock.return_value.json.return_value = drone_doc
socket_client_mock.return_value = None
self.agent = Agent("http://*****:*****@patch('hydra_agent.agent.Session.get')
def test_get_url(self, get_session_mock):
"""Tests get method from the Agent with URL
:param get_session_mock: MagicMock object for patching session.get
"""
state_object = {
"@id": "/api/StateCollection/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2",
"@context": "/api/contexts/StateCollection.jsonld"
}
get_session_mock.return_value.status_code = 200
get_session_mock.return_value.json.return_value = state_object
response = self.agent.get("http://*****:*****@patch('hydra_agent.agent.Session.get')
def test_get_class_properties(self, get_session_mock):
"""Tests get method from the Agent by class name and properties
:param get_session_mock: MagicMock object for patching session.get
"""
state_object = {
"@id": "/api/StateCollection/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "North",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2",
"@context": "/api/contexts/StateCollection.jsonld"
}
get_session_mock.return_value.status_code = 200
get_session_mock.return_value.json.return_value = state_object
response_url = self.agent.get("http://*****:*****@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.put')
def test_get_collection(self, put_session_mock, embedded_get_mock):
"""Tests get method from the Agent when fetching collections
:param put_session_mock: MagicMock object for patching session.put
:param embedded_get_mock: MagicMock object for patching session.get
"""
new_object = {
"@type": "Drone",
"DroneState": "1",
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
collection_url = "http://*****:*****@context": "/api/contexts/StateCollection.jsonld",
"@id": "/api/StateCollection/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
# Mocking an object to be used for a property that has an embedded link
embedded_get_mock.return_value.status_code = 200
embedded_get_mock.return_value.json.return_value = state_object
response, new_object_url = self.agent.put(collection_url, new_object)
simplified_collection = \
{
"@context": "/api/contexts/DroneCollection.jsonld",
"@id": "/api/DroneCollection/",
"@type": "DroneCollection",
"members": [
{
"@id": "/api/DroneCollection/1",
"@type": "Drone"
}
],
}
embedded_get_mock.return_value.json.return_value = \
simplified_collection
get_collection_url = self.agent.get(collection_url)
get_collection_resource_type = self.agent.get(resource_type="Drone")
self.assertEqual(type(get_collection_url), list)
self.assertEqual(type(get_collection_resource_type), list)
self.assertEqual(get_collection_resource_type, get_collection_url)
get_collection_cached = self.agent.get(resource_type="Drone",
cached_limit=1)
self.assertEqual(get_collection_cached[0]["@id"],
get_collection_url[0]["@id"])
@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.put')
def test_put(self, put_session_mock, embedded_get_mock):
"""Tests put method from the Agent
:param put_session_mock: MagicMock object for patching session.put
:param embedded_get_mock: MagicMock object for patching session.get
"""
new_object = {
"@type": "Drone",
"DroneState": "1",
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
collection_url = "http://*****:*****@context": "/api/contexts/StateCollection.jsonld",
"@id": "/api/StateCollection/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
# Mocking an object to be used for a property that has an embedded link
embedded_get_mock.return_value.status_code = 200
embedded_get_mock.return_value.json.return_value = state_object
response, new_object_url = self.agent.put(collection_url, new_object)
# Assert if object was inserted queried and inserted successfully
get_new_object_url = self.agent.get(new_object_url)
self.assertEqual(get_new_object_url, new_object)
get_new_object_type = self.agent.get(resource_type="Drone",
filters={'name': "Smart Drone"},
cached_limit=1)
self.assertEqual(get_new_object_url, get_new_object_type[0])
@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.post')
@patch('hydra_agent.agent.Session.put')
def test_post(self, put_session_mock, post_session_mock,
embedded_get_mock):
"""Tests post method from the Agent
:param put_session_mock: MagicMock object for patching session.put
:param post_session_mock: MagicMock object for patching session.post
"""
new_object = {
"@type": "Drone",
"DroneState": "1",
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
collection_url = "http://*****:*****@context": "/api/contexts/StateCollection.jsonld",
"@id": "/api/StateCollection/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
# Mocking an object to be used for a property that has an embedded link
embedded_get_mock.return_value.status_code = 200
embedded_get_mock.return_value.json.return_value = state_object
response = self.agent.post(new_object_url, new_object)
# Assert if object was updated successfully as intended
get_new_object = self.agent.get(new_object_url)
self.assertEqual(get_new_object, new_object)
@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.delete')
@patch('hydra_agent.agent.Session.put')
def test_delete(self, put_session_mock, delete_session_mock,
get_session_mock):
"""Tests post method from the Agent
:param put_session_mock: MagicMock object for patching session.put
:param delete_session_mock: MagicMock object to patch session.delete
:param get_session_mock: MagicMock object for patching session.get
"""
new_object = {
"@type": "Drone",
"DroneState": "/api/StateCollection/1",
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
collection_url = "http://*****:*****@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.put')
def test_edges(self, put_session_mock, embedded_get_mock):
"""Tests to check if all edges are being created properly
:param put_session_mock: MagicMock object for patching session.put
:param embedded_get_mock: MagicMock object for patching session.get
"""
new_object = {
"@type": "Drone",
"DroneState": "1",
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
collection_url = "http://*****:*****@context": "/api/contexts/StateCollection.jsonld",
"@id": "/api/StateCollection/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
# Mocking an object to be used for a property that has an embedded link
embedded_get_mock.return_value.status_code = 200
embedded_get_mock.return_value.json.return_value = state_object
response, new_object_url = self.agent.put(collection_url, new_object)
# Checking if Drone Collection has an edge to the Drone Resource
query = "MATCH (p)-[r]->() WHERE p.type = 'DroneCollection' \
RETURN type(r)"
query_result = self.redis_graph.query(query)
self.assertEqual(query_result.result_set[0][0], 'has_Drone')
# Checking if State Collection has an edge to the State Resource
query = "MATCH (p)-[r]->() WHERE p.type = 'StateCollection' \
RETURN type(r)"
query_result = self.redis_graph.query(query)
self.assertEqual(query_result.result_set[0][0], 'has_State')
# Checking if Drone Resource has an edge to the State Resource
query = "MATCH (p)-[r]->() WHERE p.type = 'Drone' RETURN type(r)"
query_result = self.redis_graph.query(query)
self.assertEqual(query_result.result_set[0][0], 'has_State')
class TestAgent(unittest.TestCase):
"""
TestCase for Agent Class
"""
@patch('hydra_agent.agent.socketio.Client.connect')
@patch('hydra_agent.agent.Session.get')
def setUp(self, get_session_mock, socket_client_mock):
"""Setting up Agent object
:param get_session_mock: MagicMock object for patching session.get
it's used to Mock Hydrus response to ApiDoc
"""
# Mocking get for ApiDoc to Server, so hydrus doesn't need to be up
get_session_mock.return_value.json.return_value = drone_doc
socket_client_mock.return_value = None
try:
self.agent = Agent("http://*****:*****@patch('hydra_agent.agent.Session.get')
def test_get_url(self, get_session_mock):
"""Tests get method from the Agent with URL
:param get_session_mock: MagicMock object for patching session.get
"""
state_object = {
"@id": "/api/State/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2",
"@context": "/api/contexts/StateCollection.jsonld"
}
get_session_mock.return_value.status_code = 200
get_session_mock.return_value.json.return_value = state_object
response = self.agent.get("http://*****:*****@patch('hydra_agent.agent.Session.get')
def test_get_class_properties(self, get_session_mock):
"""Tests get method from the Agent by class name and properties
:param get_session_mock: MagicMock object for patching session.get
"""
state_object = {
"@id": "/api/State/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "North",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2",
"@context": "/api/contexts/State.jsonld"
}
get_session_mock.return_value.status_code = 200
get_session_mock.return_value.json.return_value = state_object
response_url = self.agent.get("http://*****:*****@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.put')
def test_get_collection(self, put_session_mock, embedded_get_mock):
"""Tests get method from the Agent when fetching collections
:param put_session_mock: MagicMock object for patching session.put
:param embedded_get_mock: MagicMock object for patching session.get
"""
new_object = {"@type": "DroneCollection", "members": ["1"]}
collection_url = "http://*****:*****@context": "/api/contexts/DroneCollection.jsonld",
"@id": "/api/DroneCollection/1",
"@type": "DroneCollection",
"members": [
{
"@id": "/api/Drone/1",
"@type": "Drone"
}
],
"search": {
"@type": "hydra:IriTemplate",
"hydra:mapping": [{
"@type": "hydra:IriTemplateMapping",
"hydra:property": "http://auto.schema.org/speed",
"hydra:required": False,
"hydra:variable": "DroneState[Speed]"}
],
"hydra:template": "/serverapi/Drone(DroneState[Speed])",
"hydra:variableRepresentation": "hydra:BasicRepresentation",
},
"totalItems": 1,
"view": {
"@id": "/serverapi/DroneCollection?page=1",
"@type": "PartialCollectionView",
"first": "/serverapi/DroneCollection?page=1",
"last": "/serverapi/DroneCollection?page=1",
"next": "/serverapi/DroneCollection?page=1"
}
}
embedded_get_mock.return_value.json.return_value = simplified_collection
embedded_get_mock.return_value.status_code = 200
response, new_object_url = self.agent.put(collection_url, new_object)
get_collection_url = self.agent.get(collection_url)
self.assertEqual(type(get_collection_url), dict)
# get_collection_cached = self.agent.get(resource_type="Drone",
# cached_limit=1)
# self.assertEqual(get_collection_cached[0]["@id"],
# get_collection_url['members'][0]["@id"])
@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.put')
def test_put(self, put_session_mock, embedded_get_mock):
"""Tests put method from the Agent
:param put_session_mock: MagicMock object for patching session.put
:param embedded_get_mock: MagicMock object for patching session.get
"""
new_object = {
"@type": "Drone",
"DroneState": "1",
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
class_url = "http://*****:*****@context": "/api/contexts/State.jsonld",
"@id": "/api/State/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
drone_res = {
"@context": "/api/contexts/Drone.jsonld",
"@id": "/api/Drone/1",
"@type": "Drone",
"DroneState": {
"@id": "/api/State/1",
"@type": "State",
"Battery": "C1WE92",
"Direction": "Q9VV88",
"DroneID": "6EBGT5",
"Position": "A",
"SensorStatus": "335Y8B",
"Speed": "IZPSTE"
},
"MaxSpeed": "A3GZ37",
"Sensor": "E7JD5Q",
"model": "HB14CX",
"name": "Priaysnhu"
}
fake_responses = [Mock(), Mock(), Mock(), Mock()]
fake_responses[0].json.return_value = drone_res
fake_responses[0].status_code = 200
fake_responses[1].json.return_value = state_object
fake_responses[1].status_code = 200
fake_responses[2].json.return_value = drone_res
fake_responses[2].status_code = 200
fake_responses[3].json.return_value = drone_res
fake_responses[3].status_code = 200
# Mocking an object to be used for a property that has an embedded link
embedded_get_mock.return_value.status_code = 200
embedded_get_mock.side_effect = fake_responses
response, new_object_url = self.agent.put(new_object_url, new_object)
# Assert if object was inserted queried and inserted successfully
get_new_object_url = self.agent.get(new_object_url)
self.assertEqual(get_new_object_url, drone_res)
get_new_object_type = self.agent.get(new_object_url,
filters={'name': "Smart Drone"})
self.assertEqual(get_new_object_url, get_new_object_type)
@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.post')
@patch('hydra_agent.agent.Session.put')
def test_post(self, put_session_mock, post_session_mock,
embedded_get_mock):
"""Tests post method from the Agent
:param put_session_mock: MagicMock object for patching session.put
:param post_session_mock: MagicMock object for patching session.post
"""
new_object = {
"@type": "Drone",
"DroneState": {
"@type": "State",
"Battery": "C1WE92",
"Direction": "Q9VV88",
"DroneID": "6EBGT5",
"Position": "A",
"SensorStatus": "335Y8B",
"Speed": "IZPSTE"
},
"MaxSpeed": "A3GZ37",
"Sensor": "E7JD5Q",
"model": "HB14CX",
"name": "Priyanshu"
}
class_url = "http://*****:*****@context": "/api/contexts/State.jsonld",
"@id": "/api/State/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
drone_res = {
"@context": "/api/contexts/Drone.jsonld",
"@id": "/api/Drone/2",
"@type": "Drone",
"DroneState": {
"@id": "/api/State/1",
"@type": "State",
"Battery": "C1WE92",
"Direction": "Q9VV88",
"DroneID": "6EBGT5",
"Position": "A",
"SensorStatus": "335Y8B",
"Speed": "IZPSTE"
},
"MaxSpeed": "A3GZ37",
"Sensor": "E7JD5Q",
"model": "HB14CX",
"name": "Priaysnhu"
}
fake_responses = [Mock(), Mock(), Mock()]
fake_responses[0].json.return_value = drone_res
fake_responses[0].status_code = 200
fake_responses[1].json.return_value = state_object
fake_responses[1].status_code = 200
# Mocking an object to be used for a property that has an embedded link
embedded_get_mock.return_value.status_code = 200
embedded_get_mock.side_effect = fake_responses
response, new_object_url = self.agent.put(new_object_url, new_object)
post_session_mock.return_value.status_code = 200
post_session_mock.return_value.json.return_value = {"msg": "success"}
new_object['DroneState']['@id'] = "/api/State/1"
new_object['name'] = "Updated Name"
# Mocking an object to be used for a property that has an embedded link
response = self.agent.post(new_object_url, new_object)
# Assert if object was updated successfully as intended
fake_responses[2].json.return_value = new_object
fake_responses[2].status_code = 200
get_new_object = self.agent.get(new_object_url)
self.assertEqual(get_new_object, new_object)
@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.delete')
@patch('hydra_agent.agent.Session.put')
def test_delete(self, put_session_mock, delete_session_mock,
get_session_mock):
"""Tests post method from the Agent
:param put_session_mock: MagicMock object for patching session.put
:param delete_session_mock: MagicMock object to patch session.delete
:param get_session_mock: MagicMock object for patching session.get
"""
new_object = {
"@type": "Drone",
"DroneState": "/api/StateCollection/1",
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
class_url = "http://*****:*****@context": "/api/contexts/State.jsonld",
"@id": "/api/State/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
drone_res = {
"@context": "/api/contexts/Drone.jsonld",
"@id": "/api/Drone/1",
"@type": "Drone",
"DroneState": {
"@id": "/api/State/1",
"@type": "State",
"Battery": "C1WE92",
"Direction": "Q9VV88",
"DroneID": "6EBGT5",
"Position": "A",
"SensorStatus": "335Y8B",
"Speed": "IZPSTE"
},
"MaxSpeed": "A3GZ37",
"Sensor": "E7JD5Q",
"model": "HB14CX",
"name": "Priaysnhu"
}
fake_responses = [Mock(), Mock(), Mock()]
fake_responses[0].json.return_value = drone_res
fake_responses[0].status_code = 200
fake_responses[1].json.return_value = state_object
fake_responses[1].status_code = 200
fake_responses[2].text = {"msg": "resource doesn't exist"}
# Mocking an object to be used for a property that has an embedded link
get_session_mock.return_value.status_code = 200
get_session_mock.side_effect = fake_responses
response, new_object_url = self.agent.put(new_object_url, new_object)
delete_session_mock.return_value.status_code = 200
delete_session_mock.return_value.json.return_value = {"msg": "success"}
response = self.agent.delete(new_object_url)
get_new_object = self.agent.get(new_object_url)
# Assert if nothing different was returned by Redis
self.assertEqual(get_new_object, {"msg": "resource doesn't exist"})
def test_basic_iri_templates(self):
"""Tests the URI constructed on the basis of Basic Representation
"""
simplified_response = {
"@context": "/serverapi/contexts/DroneCollection.jsonld",
"@id": "/serverapi/DroneCollection/",
"@type": "DroneCollection",
"members": [
{
"@id": "/serverapi/DroneCollection/1",
"@type": "Drone"
},
],
"search": {
"@type":
"hydra:IriTemplate",
"hydra:mapping": [{
"@type": "hydra:IriTemplateMapping",
"hydra:property": "http://schema.org/name",
"hydra:required": False,
"hydra:variable": "name"
}, {
"@type": "hydra:IriTemplateMapping",
"hydra:property": "pageIndex",
"hydra:required": False,
"hydra:variable": "pageIndex"
}, {
"@type": "hydra:IriTemplateMapping",
"hydra:property": "limit",
"hydra:required": False,
"hydra:variable": "limit"
}, {
"@type": "hydra:IriTemplateMapping",
"hydra:property": "offset",
"hydra:required": False,
"hydra:variable": "offset"
}],
"hydra:template":
"/serverapi/(pageIndex, limit, offset)",
"hydra:variableRepresentation":
"hydra:BasicRepresentation"
},
"view": {
"@id": "/serverapi/DroneCollection?page=1",
"@type": "PartialCollectionView",
"first": "/serverapi/DroneCollection?page=1",
"last": "/serverapi/DroneCollection?page=1",
"next": "/serverapi/DroneCollection?page=1"
}
}
sample_mapping_object = {
"name": "Drone1",
"pageIndex": "1",
"limit": "10",
"offset": "1"
}
url = urlparse(
expand_template("http://*****:*****@context": "/serverapi/contexts/DroneCollection.jsonld",
"@id": "/serverapi/DroneCollection/",
"@type": "DroneCollection",
"members": [
{
"@id": "/serverapi/DroneCollection/1",
"@type": "Drone"
},
],
"search": {
"@type":
"hydra:IriTemplate",
"hydra:mapping": [{
"@type": "hydra:IriTemplateMapping",
"hydra:property": "http://schema.org/name",
"hydra:required": False,
"hydra:variable": "name"
}, {
"@type": "hydra:IriTemplateMapping",
"hydra:property": "pageIndex",
"hydra:required": False,
"hydra:variable": "pageIndex"
}, {
"@type": "hydra:IriTemplateMapping",
"hydra:property": "limit",
"hydra:required": False,
"hydra:variable": "limit"
}, {
"@type": "hydra:IriTemplateMapping",
"hydra:property": "offset",
"hydra:required": False,
"hydra:variable": "offset"
}],
"hydra:template":
"/serverapi/(pageIndex, limit, offset)",
"hydra:variableRepresentation":
"hydra:ExplicitRepresentation"
},
"view": {
"@id": "/serverapi/DroneCollection?page=1",
"@type": "PartialCollectionView",
"first": "/serverapi/DroneCollection?page=1",
"last": "/serverapi/DroneCollection?page=1",
"next": "/serverapi/DroneCollection?page=1"
}
}
sample_mapping_object = {
"url_demo": {
"@id": "http://www.hydra-cg.com/"
},
"prop_with_language": {
"@language": "en",
"@value": "A simple string"
},
"prop_with_type": {
"@value": "5.5",
"@type": "http://www.w3.org/2001/XMLSchema#decimal"
},
"str_prop": "A simple string"
}
url = urlparse(
expand_template("http://*****:*****@patch('hydra_agent.agent.Session.get')
@patch('hydra_agent.agent.Session.put')
def test_edges(self, put_session_mock, embedded_get_mock):
"""Tests to check if all edges are being created properly
:param put_session_mock: MagicMock object for patching session.put
:param embedded_get_mock: MagicMock object for patching session.get
"""
new_object = {
"@type": "Drone",
"DroneState": {
"@type": "State",
"Battery": "C1WE92",
"Direction": "Q9VV88",
"DroneID": "6EBGT5",
"Position": "A",
"SensorStatus": "335Y8B",
"Speed": "IZPSTE"
},
"name": "Smart Drone",
"model": "Hydra Drone",
"MaxSpeed": "999",
"Sensor": "Wind"
}
class_url = "http://*****:*****@context": "/api/contexts/State.jsonld",
"@id": "/api/State/1",
"@type": "State",
"Battery": "sensor Ex",
"Direction": "speed Ex",
"DroneID": "sensor Ex",
"Position": "model Ex",
"SensorStatus": "sensor Ex",
"Speed": "2"
}
drone_res = {
"@context": "/api/contexts/Drone.jsonld",
"@id": "/api/Drone/1",
"@type": "Drone",
"DroneState": {
"@id": "/api/State/1",
"@type": "State",
"Battery": "C1WE92",
"Direction": "Q9VV88",
"DroneID": "6EBGT5",
"Position": "A",
"SensorStatus": "335Y8B",
"Speed": "IZPSTE"
},
"MaxSpeed": "A3GZ37",
"Sensor": "E7JD5Q",
"model": "HB14CX",
"name": "Priaysnhu"
}
fake_responses = [Mock(), Mock()]
fake_responses[0].json.return_value = drone_res
fake_responses[0].status_code = 200
fake_responses[1].json.return_value = state_object
fake_responses[1].status_code = 200
# Mocking an object to be used for a property that has an embedded link
embedded_get_mock.return_value.status_code = 200
embedded_get_mock.side_effect = fake_responses
response, new_object_url = self.agent.put(class_url, new_object)
# Checking if Drone Class has an edge to the Drone Resource
query = "MATCH (p)-[r]->() WHERE p.type = 'Drone' \
RETURN type(r)"
query_result = self.redis_graph.query(query)
self.assertEqual(query_result.result_set[0][0], 'has_Drone')
# Checking if State has an edge to the State Resource
query = "MATCH (p)-[r]->() WHERE p.type = 'State' \
RETURN type(r)"
query_result = self.redis_graph.query(query)
self.assertEqual(query_result.result_set[0][0], 'has_State')
# Checking if Drone Resource has an edge to the State Resource
query = "MATCH (p)-[r]->() WHERE p.type = 'Drone' RETURN type(r)"
query_result = self.redis_graph.query(query)
self.assertEqual(query_result.result_set[1][0], 'has_State')