def run():
"""
create a CSEBase
"""
resource = ResourcesFactory().create(ResourceType.CSEBase.value)
resource.set_csi(settings.GHOSTM2M['CSE-ID'])
base = DBConnection().db[settings.GHOSTM2M['CSE-ID']]
result = base.find_one({
'ty': ResourceType.CSEBase.value,
'csi': settings.GHOSTM2M['CSE-ID']
})
if result is None:
ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'], resource)
print('Creado CSEBase. ', ri)
else:
print('CSEBase ya existe. ', result)
def valid(self):
result = DBConnection().db['users'].find_one({'_id': self._username})
if result is None:
return False
elif self._pwd == result['pwd']:
return True
else:
return False
def test_api_create_ae(self):
# create admin user
result = DBConnection().db['users'].find_one(
{'_id': settings.GHOSTM2M['admin-user']['username']})
if result is None:
DBConnection().db['users'].insert_one({
'_id':
settings.GHOSTM2M['admin-user']['username'],
'pwd':
settings.GHOSTM2M['admin-user']['pwd']
})
# send request for create AE
request = {
'm2m:rqp': {
'op':
1,
'ty':
1,
'pc': {
'm2m:ae': {
"apn": "lector-tarjetas"
}
},
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'//localhost:80/Cernicalo'
}
}
response = self.client.post('/~/Cernicalo/',
json.dumps(request),
content_type="application/json")
self.assertEqual(response.status_code, 200)
response_content = json.loads(response.content)
self.assertIn('m2m:rsp', response_content)
self.assertIn('pc', response_content['m2m:rsp'])
self.assertIn('m2m:ae', response_content['m2m:rsp']['pc'])
def run():
"""
reset db
"""
try:
DBConnection().db_client.drop_database(settings.GHOSTM2M["dbname"])
DBConnection().db_client.drop_database('users')
print('OK')
except Exception as e:
print(str(e))
# create CSEBase
resource = ResourcesFactory().create(ResourceType.CSEBase.value)
resource.set_csi(settings.GHOSTM2M['CSE-ID'])
base = DBConnection().db[settings.GHOSTM2M['CSE-ID']]
result = base.find_one({
'ty': ResourceType.CSEBase.value,
'csi': settings.GHOSTM2M['CSE-ID']
})
if result is None:
ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'], resource)
print('Creado CSEBase. ', ri)
else:
print('CSEBase ya existe. ', result)
# create user admin
try:
users = DBConnection().db['users']
result = users.insert_one({
'_id':
settings.GHOSTM2M['admin-user']['username'],
'pwd':
settings.GHOSTM2M['admin-user']['pwd']
})
print("se crea usuario admin")
except Exception as e:
print('no se crea usuario admin')
print(str(e))
def __init__(self):
self._db = DBConnection().db
class ResourceMapper:
def __init__(self):
self._db = DBConnection().db
def store(self, cseid, resource):
if isinstance(resource, Resource):
to_store = resource.toDict()[resource.get_rtn()].copy()
to_store['rtn'] = resource.get_rtn()
to_store['ty'] = resource.ty
result = self._db[cseid].insert_one(to_store)
return str(result.inserted_id)
else:
raise TypeError
def retrieve(self, cseid, ft):
if cseid not in self._db.list_collection_names():
raise KeyError
result = self._db[cseid].find_one(ft)
if result is None:
return None
elif 'ty' in result:
resource = ResourcesFactory().create(ty=result['ty'])
resource.load(pc={resource.get_rtn(): result})
rtn = None
if 'rtn' in result:
rtn = result['rtn']
result.pop('rtn')
else:
raise KeyError
_id = None
if '_id' in result:
_id = result['_id']
result.pop('_id')
else:
raise KeyError
resource.load({rtn: result})
resource.set_id(str(_id))
return resource
else:
raise TypeError
def discovery(self, cseid, pi, fc):
mongodb_filter = dict()
mongodb_filter = fc.copy()
if 'ty' in mongodb_filter:
mongodb_filter['ty'] = int(mongodb_filter['ty'])
#TODO continue with params in Table Summary on Filter conditions (Table 7.3.3.17.0 Document TS-0004)
mongodb_filter['pi'] = str(pi)
result = self._db[cseid].find(mongodb_filter)
ret = list()
for doc in result:
ret.append('//{}/{}'.format(cseid, str(doc['_id'])))
return ret
def tearDown(self):
#sys.stderr.write('Eliminar base de datos test.\n')
DBConnection().db_client.drop_database(
settings.GHOSTM2M["dbname-test"])
def test_api_retrieve(self):
f = ResourcesFactory()
# create admin user
result = DBConnection().db['users'].find_one(
{'_id': settings.GHOSTM2M['admin-user']['username']})
if result is None:
DBConnection().db['users'].insert_one({
'_id':
settings.GHOSTM2M['admin-user']['username'],
'pwd':
settings.GHOSTM2M['admin-user']['pwd']
})
# create CSE
csebase = f.create(ResourceType.CSEBase.value)
csebase.set_csi(settings.GHOSTM2M['CSE-ID'])
csebase_ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'],
csebase)
# create AE
ae = f.create(ty=ResourceType.AE.value,
pi=csebase_ri,
pc={'m2m:ae': {
'api': 'test',
'apn': 'rfid-reader'
}})
ae_mapper = MappersFactory().get(ae)
ae_ri = ae_mapper.store(settings.GHOSTM2M['CSE-ID'], ae)
ae.set_id(ae_ri)
# create Container
cnt = f.create(ty=ResourceType.container.value,
pi=ae_ri,
pc={'m2m:cnt': {
'rn': 'corner-rfids'
}})
cnt_mapper = MappersFactory().get(cnt)
cnt_ri = cnt_mapper.store(settings.GHOSTM2M['CSE-ID'], cnt)
cnt.set_id(cnt_ri)
# create ContentInstance
cin = f.create(ty=ResourceType.contentInstance.value,
pi=cnt_ri,
pc={'m2m:cin': {
'con': 'abcdef'
}})
cin_mapper = MappersFactory().get(cin)
cin_ri = cin_mapper.store(settings.GHOSTM2M['CSE-ID'], cin)
cin.set_id(cin_ri)
# Request CSE
#
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo', request_str,
'application/json')
self.assertEqual(response.status_code, 200)
response_cse = json.loads(response.content)['m2m:rsp']
self.assertIn('rsc', response_cse)
self.assertEqual(response_cse['rsc'], ResponseStatusCode.OK.value)
# Request AE
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(ae_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_ae = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_ae)
self.assertIn('m2m:ae', response_ae['pc'])
self.assertIn('apn', response_ae['pc']['m2m:ae'])
self.assertIn('ri', response_ae['pc']['m2m:ae'])
# Request Container
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cnt)
self.assertIn('m2m:cnt', response_cnt['pc'])
self.assertIn('rn', response_cnt['pc']['m2m:cnt'])
self.assertIn('ri', response_cnt['pc']['m2m:cnt'])
self.assertIn('cni', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['cni'], 1)
# Request ContentInstance
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cin_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cin = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cin)
self.assertIn('m2m:cin', response_cin['pc'])
self.assertIn('con', response_cin['pc']['m2m:cin'])
self.assertIn('ri', response_cin['pc']['m2m:cin'])
self.assertIn('pi', response_cin['pc']['m2m:cin'])
self.assertEqual(response_cin['pc']['m2m:cin']['pi'], cnt_ri)
# Request <last> <ContentInstance>
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET',
'/~/Cernicalo/{}/la'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_la = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cin)
# Check updated parent <Container>
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cnt)
self.assertIn('m2m:cnt', response_cnt['pc'])
self.assertIn('rn', response_cnt['pc']['m2m:cnt'])
self.assertIn('ri', response_cnt['pc']['m2m:cnt'])
self.assertIn('la', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['la'], cin_ri)
# create another ContentInstance
cin = f.create(ty=ResourceType.contentInstance.value,
pi=cnt_ri,
pc={'m2m:cin': {
'con': 'segundocontent'
}})
cin_mapper = MappersFactory().get(cin)
cin_ri = cin_mapper.store(settings.GHOSTM2M['CSE-ID'], cin)
cin.set_id(cin_ri)
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
self.assertIn('cni', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['cni'], 2)
self.assertIn('la', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['la'], cin_ri)
request_str = json.dumps(request)
response = self.client.generic(
'GET',
'/~/Cernicalo/{}?ty={}'.format(cnt_ri,
ResourceType.contentInstance.value),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
self.assertIn('m2m:rsp', json.loads(response.content))
response_discovery = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_discovery)
self.assertIn('m2m:uril', response_discovery['pc'])
self.assertIsInstance(response_discovery['pc']['m2m:uril'], list)
def test_api_create_cin(self):
# create admin user
result = DBConnection().db['users'].find_one(
{'_id': settings.GHOSTM2M['admin-user']['username']})
if result is None:
DBConnection().db['users'].insert_one({
'_id':
settings.GHOSTM2M['admin-user']['username'],
'pwd':
settings.GHOSTM2M['admin-user']['pwd']
})
# send request for create AE
request = {
'm2m:rqp': {
'op':
1,
'ty':
1,
'pc': {
'm2m:ae': {
"apn": "lector-tarjetas"
}
},
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'//localhost:80/Cernicalo'
}
}
response = self.client.post('/~/Cernicalo/',
json.dumps(request),
content_type="application/json")
self.assertEqual(response.status_code, 200)
response_ae = json.loads(response.content)['m2m:rsp']
factory = ResourcesFactory()
parent_ae = factory.create(request['m2m:rqp']['ty'],
pc=response_ae['pc'])
request = {
'm2m:rqp': {
'op':
Operation.Create.value,
'ty':
ResourceType.container.value,
'pc': {
'm2m:cnt': {
'rn': 'corners-rfids'
}
},
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo/{}'.format(parent_ae.ri),
}
}
response = self.client.post('/~/Cernicalo/{}'.format(parent_ae.ri),
json.dumps(request),
content_type="application/json")
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
cnt = factory.create(request['m2m:rqp']['ty'], pc=response_cnt['pc'])
request = {
'm2m:rqp': {
'op':
Operation.Create.value,
'ty':
ResourceType.contentInstance.value,
'pc': {
'm2m:cin': {
'con': 'hola mundo!'
}
},
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo/{}'.format(cnt.ri),
}
}
response = self.client.post('/~/Cernicalo/{}'.format(cnt.ri),
json.dumps(request),
content_type="application/json")
self.assertIn('m2m:rsp', json.loads(response.content))
response_cin = json.loads(response.content)['m2m:rsp']
self.assertIn('m2m:cin', response_cin['pc'])
cin = factory.create(request['m2m:rqp']['ty'], pc=response_cin['pc'])
self.assertIsInstance(cin, ContentInstance)
self.assertEqual(cin.pi, cnt.ri)
self.assertEqual(cin.con, 'hola mundo!')
parent = ResourceMapper().retrieve(cseid=settings.GHOSTM2M['CSE-ID'],
ft={'_id': ObjectId(cin.pi)})
self.assertIsInstance(parent, Container)
self.assertNotEqual(parent.la, None)
def setUp(self):
self.c = Client()
settings.GHOSTM2M["dbname-test"]
DBConnection().set_db(settings.GHOSTM2M["dbname-test"])