class TestMultiMongo(TestBase):
def setUp(self):
super(TestMultiMongo, self).setUp()
self.setupDB2()
schema = {
'author': {
'type': 'string'
},
'title': {
'type': 'string'
},
}
settings = {'schema': schema, 'mongo_prefix': 'MONGO1'}
self.app.register_resource('works', settings)
def tearDown(self):
super(TestMultiMongo, self).tearDown()
self.dropDB2()
def setupDB2(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO1_DBNAME)
self.connection[MONGO1_DBNAME].add_user(MONGO1_USERNAME,
MONGO1_PASSWORD)
self.bulk_insert2()
def dropDB2(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO1_DBNAME)
self.connection.close()
def bulk_insert2(self):
_db = self.connection[MONGO1_DBNAME]
works = self.random_works(self.known_resource_count)
_db.works.insert(works)
self.work = _db.works.find_one()
self.connection.close()
def random_works(self, num):
works = []
for i in range(num):
dt = datetime.now()
work = {
'author': self.random_string(20),
'title': self.random_string(30),
eve.LAST_UPDATED: dt,
eve.DATE_CREATED: dt,
}
works.append(work)
return works
class TestMultiMongo(TestBase):
def setUp(self):
super(TestMultiMongo, self).setUp()
self.setupDB2()
schema = {
'author': {'type': 'string'},
'title': {'type': 'string'},
}
settings = {
'schema': schema,
'mongo_prefix': 'MONGO1'
}
self.app.register_resource('works', settings)
def tearDown(self):
super(TestMultiMongo, self).tearDown()
self.dropDB2()
def setupDB2(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO1_DBNAME)
self.connection[MONGO1_DBNAME].add_user(MONGO1_USERNAME,
MONGO1_PASSWORD)
self.bulk_insert2()
def dropDB2(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO1_DBNAME)
self.connection.close()
def bulk_insert2(self):
_db = self.connection[MONGO1_DBNAME]
works = self.random_works(self.known_resource_count)
_db.works.insert(works)
self.work = _db.works.find_one()
self.connection.close()
def random_works(self, num):
works = []
for i in range(num):
dt = datetime.now()
work = {
'author': self.random_string(20),
'title': self.random_string(30),
eve.LAST_UPDATED: dt,
eve.DATE_CREATED: dt,
}
works.append(work)
return works
class TestMinimal(unittest.TestCase):
""" Start the building of the tests for an application
based on Eve by subclassing this class and provide proper settings
using :func:`setUp()`
"""
app = ValueStack(close_pymongo_connection)
def setUp(self, settings_file=None, url_converters=None):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
"""
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings_file is None:
# Load the settings file, using a robust path
settings_file = os.path.join(self.this_directory,
'test_settings.py')
self.connection = None
self.known_resource_count = 101
self.setupDB()
self.settings_file = settings_file
self.app = eve.Eve(settings=self.settings_file,
url_converters=url_converters)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def tearDown(self):
del self.app
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert201(self, status):
self.assertEqual(status, 201)
def assert204(self, status):
self.assertEqual(status, 204)
def assert301(self, status):
self.assertEqual(status, 301)
def assert304(self, status):
self.assertEqual(status, 304)
def assert404(self, status):
self.assertEqual(status, 404)
def assert422(self, status):
self.assertEqual(status, 422)
def get(self, resource, query='', item=None):
if resource in self.domain:
resource = self.domain[resource]['url']
if item:
request = '/%s/%s%s' % (resource, item, query)
else:
request = '/%s%s' % (resource, query)
r = self.test_client.get(request)
return self.parse_response(r)
def post(self, url, data, headers=None, content_type='application/json'):
if headers is None:
headers = []
headers.append(('Content-Type', content_type))
r = self.test_client.post(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def put(self, url, data, headers=None):
if headers is None:
headers = []
headers.append(('Content-Type', 'application/json'))
r = self.test_client.put(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def patch(self, url, data, headers=None):
if headers is None:
headers = []
headers.append(('Content-Type', 'application/json'))
r = self.test_client.patch(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def delete(self, url, headers=None):
r = self.test_client.delete(url, headers=headers)
return self.parse_response(r)
def parse_response(self, r):
try:
v = json.loads(r.get_data())
except json.JSONDecodeError:
v = None
return v, r.status_code
def assertValidationErrorStatus(self, status):
self.assertEqual(status,
self.app.config.get('VALIDATION_ERROR_STATUS'))
def assertValidationError(self, response, matches):
self.assertTrue(eve.STATUS in response)
self.assertTrue(eve.STATUS_ERR in response[eve.STATUS])
self.assertTrue(ISSUES in response)
issues = response[ISSUES]
self.assertTrue(len(issues))
for k, v in matches.items():
self.assertTrue(k in issues)
self.assertTrue(v in issues[k])
def assertExpires(self, resource):
# TODO if we ever get access to response.date (it is None), compare
# it with Expires
r = self.test_client.get(resource)
expires = r.headers.get('Expires')
self.assertTrue(expires is not None)
def assertCacheControl(self, resource):
r = self.test_client.get(resource)
cache_control = r.headers.get('Cache-Control')
self.assertTrue(cache_control is not None)
self.assertEqual(cache_control,
self.domain[self.known_resource]['cache_control'])
def assertIfModifiedSince(self, resource):
r = self.test_client.get(resource)
last_modified = r.headers.get('Last-Modified')
self.assertTrue(last_modified is not None)
r = self.test_client.get(resource,
headers=[('If-Modified-Since', last_modified)
])
self.assert304(r.status_code)
self.assertTrue(not r.get_data())
def assertItem(self, item, resource):
self.assertEqual(type(item), dict)
updated_on = item.get(self.app.config['LAST_UPDATED'])
self.assertTrue(updated_on is not None)
try:
datetime.strptime(updated_on, self.app.config['DATE_FORMAT'])
except Exception as e:
self.fail('Cannot convert field "%s" to datetime: %s' %
(self.app.config['LAST_UPDATED'], e))
created_on = item.get(self.app.config['DATE_CREATED'])
self.assertTrue(updated_on is not None)
try:
datetime.strptime(created_on, self.app.config['DATE_FORMAT'])
except Exception as e:
self.fail('Cannot convert field "%s" to datetime: %s' %
(self.app.config['DATE_CREATED'], e))
link = item.get('_links')
_id = item.get(self.domain[resource]['id_field'])
self.assertItemLink(link, _id)
def assertPagination(self, response, page, total, max_results):
p_key, mr_key = self.app.config['QUERY_PAGE'], \
self.app.config['QUERY_MAX_RESULTS']
self.assertTrue(self.app.config['META'] in response)
meta = response.get(self.app.config['META'])
self.assertTrue(p_key in meta)
self.assertTrue(mr_key in meta)
self.assertTrue('total' in meta)
self.assertEqual(meta[p_key], page)
self.assertEqual(meta[mr_key], max_results)
self.assertEqual(meta['total'], total)
def assertHomeLink(self, links):
self.assertTrue('parent' in links)
link = links['parent']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('home', link['title'])
self.assertEqual("/", link['href'])
def assertResourceLink(self, links, resource):
self.assertTrue('self' in links)
link = links['self']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s" % url, link['href'])
def assertCollectionLink(self, links, resource):
self.assertTrue('collection' in links)
link = links['collection']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s" % url, link['href'])
def assertNextLink(self, links, page):
self.assertTrue('next' in links)
link = links['next']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('next page', link['title'])
self.assertTrue("%s=%d" %
(self.app.config['QUERY_PAGE'], page) in link['href'])
def assertPrevLink(self, links, page):
self.assertTrue('prev' in links)
link = links['prev']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('previous page', link['title'])
if page > 1:
self.assertTrue(
"%s=%d" %
(self.app.config['QUERY_PAGE'], page) in link['href'])
def assertItemLink(self, links, item_id):
self.assertTrue('self' in links)
link = links['self']
# TODO we are too deep here to get a hold of the due title. Should fix.
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertTrue('/%s' % item_id in link['href'])
def assertLastLink(self, links, page):
if page:
self.assertTrue('last' in links)
link = links['last']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('last page', link['title'])
self.assertTrue(
"%s=%d" %
(self.app.config['QUERY_PAGE'], page) in link['href'])
else:
self.assertTrue('last' not in links)
def assert400(self, status):
self.assertEqual(status, 400)
def assert401(self, status):
self.assertEqual(status, 401)
def assert401or405(self, status):
self.assertTrue(status == 401 or 405)
def assert403(self, status):
self.assertEqual(status, 403)
def assert405(self, status):
self.assertEqual(status, 405)
def assert412(self, status):
self.assertEqual(status, 412)
def assert500(self, status):
self.assertEqual(status, 500)
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
if MONGO_USERNAME:
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
pass
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
class TestMinimal(unittest.TestCase):
""" Start the building of the tests for an application
based on Eve by subclassing this class and provide proper settings
using :func:`setUp()`
"""
app = ValueStack(close_pymongo_connection)
def setUp(self, settings_file=None, url_converters=None):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
"""
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings_file is None:
# Load the settings file, using a robust path
settings_file = os.path.join(self.this_directory,
'test_settings.py')
self.connection = None
self.known_resource_count = 101
self.setupDB()
self.settings_file = settings_file
self.app = eve.Eve(settings=self.settings_file,
url_converters=url_converters)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def tearDown(self):
del self.app
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert201(self, status):
self.assertEqual(status, 201)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def get(self, resource, query='', item=None):
if resource in self.domain:
resource = self.domain[resource]['url']
if item:
request = '/%s/%s%s' % (resource, item, query)
else:
request = '/%s%s' % (resource, query)
r = self.test_client.get(request)
return self.parse_response(r)
def post(self, url, data, headers=None, content_type='application/json'):
if headers is None:
headers = []
headers.append(('Content-Type', content_type))
r = self.test_client.post(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def put(self, url, data, headers=None):
if headers is None:
headers = []
headers.append(('Content-Type', 'application/json'))
r = self.test_client.put(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def patch(self, url, data, headers=None):
if headers is None:
headers = []
headers.append(('Content-Type', 'application/json'))
r = self.test_client.patch(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def delete(self, url, headers=None):
r = self.test_client.delete(url, headers=headers)
return self.parse_response(r)
def parse_response(self, r):
try:
v = json.loads(r.get_data())
except json.JSONDecodeError:
v = None
return v, r.status_code
def assertValidationError(self, response, matches):
self.assertTrue(eve.STATUS in response)
self.assertTrue(eve.STATUS_ERR in response[eve.STATUS])
self.assertTrue(ISSUES in response)
issues = response[ISSUES]
self.assertTrue(len(issues))
for k, v in matches.items():
self.assertTrue(k in issues)
self.assertTrue(v in issues[k])
def assertExpires(self, resource):
# TODO if we ever get access to response.date (it is None), compare
# it with Expires
r = self.test_client.get(resource)
expires = r.headers.get('Expires')
self.assertTrue(expires is not None)
def assertCacheControl(self, resource):
r = self.test_client.get(resource)
cache_control = r.headers.get('Cache-Control')
self.assertTrue(cache_control is not None)
self.assertEqual(cache_control,
self.domain[self.known_resource]['cache_control'])
def assertIfModifiedSince(self, resource):
r = self.test_client.get(resource)
last_modified = r.headers.get('Last-Modified')
self.assertTrue(last_modified is not None)
r = self.test_client.get(resource, headers=[('If-Modified-Since',
last_modified)])
self.assert304(r.status_code)
self.assertTrue(not r.get_data())
def assertItem(self, item):
self.assertEqual(type(item), dict)
updated_on = item.get(self.app.config['LAST_UPDATED'])
self.assertTrue(updated_on is not None)
try:
datetime.strptime(updated_on, self.app.config['DATE_FORMAT'])
except Exception as e:
self.fail('Cannot convert field "%s" to datetime: %s' %
(self.app.config['LAST_UPDATED'], e))
created_on = item.get(self.app.config['DATE_CREATED'])
self.assertTrue(updated_on is not None)
try:
datetime.strptime(created_on, self.app.config['DATE_FORMAT'])
except Exception as e:
self.fail('Cannot convert field "%s" to datetime: %s' %
(self.app.config['DATE_CREATED'], e))
link = item.get('_links')
_id = item.get(self.app.config['ID_FIELD'])
self.assertItemLink(link, _id)
def assertPagination(self, response, page, total, max_results):
self.assertTrue(self.app.config['META'] in response)
meta = response.get(self.app.config['META'])
self.assertTrue('page' in meta)
self.assertTrue('max_results' in meta)
self.assertTrue('total' in meta)
self.assertEqual(meta['page'], page)
self.assertEqual(meta['max_results'], max_results)
self.assertEqual(meta['total'], total)
def assertHomeLink(self, links):
self.assertTrue('parent' in links)
link = links['parent']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('home', link['title'])
self.assertEqual("%s" % self._get_server_name(),
link['href'])
def assertResourceLink(self, links, resource):
self.assertTrue('self' in links)
link = links['self']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s/%s" % (self._get_server_name(),
url),
link['href'])
def assertCollectionLink(self, links, resource):
self.assertTrue('collection' in links)
link = links['collection']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s/%s" % (self._get_server_name(),
url), link['href'])
def assertNextLink(self, links, page):
self.assertTrue('next' in links)
link = links['next']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('next page', link['title'])
self.assertTrue("page=%d" % page in link['href'])
def assertPrevLink(self, links, page):
self.assertTrue('prev' in links)
link = links['prev']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('previous page', link['title'])
if page > 1:
self.assertTrue("page=%d" % page in link['href'])
def assertItemLink(self, links, item_id):
self.assertTrue('self' in links)
link = links['self']
# TODO we are too deep here to get a hold of the due title. Should fix.
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertTrue('/%s' % item_id in link['href'])
def assertLastLink(self, links, page):
if page:
self.assertTrue('last' in links)
link = links['last']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('last page', link['title'])
self.assertTrue("page=%d" % page in link['href'])
else:
self.assertTrue('last' not in links)
def assert400(self, status):
self.assertEqual(status, 400)
def assert401(self, status):
self.assertEqual(status, 401)
def assert401or405(self, status):
self.assertTrue(status == 401 or 405)
def assert403(self, status):
self.assertEqual(status, 403)
def assert405(self, status):
self.assertEqual(status, 405)
def assert412(self, status):
self.assertEqual(status, 412)
def assert500(self, status):
self.assertEqual(status, 500)
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
if MONGO_USERNAME:
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
pass
def _get_server_name(self):
server_name = self.app.config.get('SERVER_NAME', '')
url_protocol = self.app.config.get('URL_PROTOCOL', '')
if url_protocol:
server_name = '%s://%s' % (url_protocol, server_name)
return server_name
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
class TestBase(TestMinimal):
DEVICES = 'devices'
DEVICE_EVENT = 'events/devices'
EVENTS = 'events'
PLACES = 'places'
SNAPSHOT = 'snapshot'
ACCOUNTS = 'accounts'
def setUp(self, settings_file=None, url_converters=None):
from ereuse_devicehub import default_settings as settings
self.set_settings(settings)
self.app = DeviceHub()
self.prepare()
@staticmethod
def set_settings(settings):
settings.MONGO_DBNAME = 'devicehubtest'
settings.DATABASES = 'dht1', 'dht2' # Some tests use 2 databases
settings.DHT1_DBNAME = 'dht1_'
settings.DHT2_DBNAME = 'dht2_'
settings.GRD_DEBUG = True # We do not want to actually fulfill GRD
settings.APP_NAME = 'DeviceHub'
settings.DEBUG = True
settings.TESTING = True
settings.LOG = True
settings.GRD = False
settings.AGENT_ACCOUNTS = {
'self': ('*****@*****.**', '12345')
}
def prepare(self):
self.MONGO_DBNAME = self.app.config['MONGO_DBNAME']
self.MONGO_HOST = self.app.config['MONGO_HOST']
self.MONGO_PORT = self.app.config['MONGO_PORT']
self.DATABASES = self.app.config['DATABASES']
self.connection = None
self.setupDB()
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
self.token = self._login()
self.auth_header = ('authorization', 'Basic ' + self.token)
def setupDB(self):
self.connection = MongoClient(self.MONGO_HOST, self.MONGO_PORT)
self.db = self.connection[self.MONGO_DBNAME]
self.drop_databases()
self.create_dummy_user()
self.create_self_machine_account()
# We call the method again as we have erased the DB
self.app.grd_submitter_caller = SubmitterCaller(self.app, GRDSubmitter)
# self.app.grd_submitter_caller.token = self.app.grd_submitter_caller.prepare_user(self.app)
# self.app.grd_submitter_caller.process = None
def create_dummy_user(self):
self.db.accounts.insert(
{
'email': "[email protected]",
'password': AccountDomain.encrypt_password('1234'),
'role': 'admin',
'token': 'NOFATDNNUB',
'databases': self.app.config['DATABASES'],
'defaultDatabase': self.app.config['DATABASES'][0],
'@type': 'Account'
}
)
self.account = self.db.accounts.find_one({'email': '[email protected]'})
def create_self_machine_account(self):
email, password = self.app.config['AGENT_ACCOUNTS']['self']
self.db.accounts.insert(
{
'role': 'superuser',
'token': 'QYADFBPNZZDFJEWAFGGF',
'databases': self.app.config['DATABASES'],
'@type': 'Account',
'email': email,
'password': AccountDomain.encrypt_password(password)
}
)
def tearDown(self):
self.dropDB()
del self.app
def drop_databases(self):
self.connection.drop_database(self.MONGO_DBNAME)
for database in self.DATABASES:
self.connection.drop_database(self.app.config[database.upper().replace('-', '') + '_DBNAME'])
def dropDB(self):
self.drop_databases()
self.connection.close()
def full(self, resource_name: str, resource: dict or str or ObjectId) -> dict:
return resource if type(resource) is dict else self.get(resource_name, '', str(resource))[0]
def select_database(self, url):
if 'accounts' in url:
return ''
else:
return self.app.config['DATABASES'][0]
def get(self, resource, query='', item=None, authorize=True, database=None):
if resource in self.domain:
resource = self.domain[resource]['url']
if item:
request = '/%s/%s%s' % (resource, item, query)
else:
request = '/%s%s' % (resource, query)
database = database or self.select_database(resource)
return self._get(database + request, self.token if authorize else None)
def _get(self, url, token=None, **kwargs):
environ_base = {'HTTP_AUTHORIZATION': 'Basic ' + token} if token else {}
environ_base.update(kwargs.pop('environ_base', {}))
r = self.test_client.get(url, environ_base=environ_base, **kwargs)
return self.parse_response(r)
def post(self, url, data, headers=None, content_type='application/json'):
full_url = self.select_database(url) + '/' + url
headers = headers or []
return self._post(full_url, data, self.token, headers, content_type)
def _post(self, url, data, token, headers=None, content_type='application/json'):
headers = headers or []
headers.append(('authorization', 'Basic ' + token))
if type(data) is str:
headers.append(('Content-Type', content_type))
r = self.test_client.post(url, data=data, headers=headers)
return self.parse_response(r)
return super(TestBase, self).post(url, data, headers, content_type)
def patch(self, url, data, headers=None):
headers = headers or []
return self._patch(self.select_database(url) + '/' + url, data, self.token, headers)
def _patch(self, url, data, token, headers=None):
headers = headers or []
headers.append(('authorization', 'Basic ' + token))
return super(TestBase, self).patch(url, data, headers)
def put(self, url, data, headers=None):
headers = headers or []
return super(TestBase, self).put(self.select_database(url) + '/' + url, data, headers + [self.auth_header])
def delete(self, url, headers=None):
headers = headers or []
return super(TestBase, self).delete(self.select_database(url) + '/' + url, headers + [self.auth_header])
def _login(self) -> str:
return super(TestBase, self).post('/login', {"email": "[email protected]", "password": "******"})[0]['token']
def assert308(self, status):
self.assertEqual(status, 308)
class TestMinimal(unittest.TestCase):
""" Start the building of the tests for an application
based on Eve by subclassing this class and provide proper settings
using :func:`setUp()`
"""
def setUp(self, settings_file='eve/tests/test_settings.py'):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
"""
self.known_resource_count = 101
self.setupDB()
self.settings_file = settings_file
self.app = eve.Eve(settings=self.settings_file)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def tearDown(self):
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def get(self, resource, query='', item=None):
if resource in self.domain:
resource = self.domain[resource]['url']
if item:
request = '/%s/%s/' % (resource, item)
else:
request = '/%s/%s' % (resource, query)
r = self.test_client.get(request)
return self.parse_response(r)
def parse_response(self, r):
v = json.loads(r.get_data()) if r.status_code == 200 else None
return v, r.status_code
def assertValidationError(self, response, key, matches):
self.assertTrue(key in response)
k = response[key]
self.assertTrue('status' in k)
self.assertTrue(eve.STATUS_ERR in k['status'])
self.assertTrue('issues' in k)
issues = k['issues']
self.assertTrue(len(issues))
for match in matches:
self.assertTrue(match in issues[0])
def assertExpires(self, resource):
# TODO if we ever get access to response.date (it is None), compare
# it with Expires
r = self.test_client.get(resource)
expires = r.headers.get('Expires')
self.assertTrue(expires is not None)
def assertCacheControl(self, resource):
r = self.test_client.get(resource)
cache_control = r.headers.get('Cache-Control')
self.assertTrue(cache_control is not None)
self.assertEqual(cache_control,
self.domain[self.known_resource]['cache_control'])
def assertIfModifiedSince(self, resource):
r = self.test_client.get(resource)
last_modified = r.headers.get('Last-Modified')
self.assertTrue(last_modified is not None)
r = self.test_client.get(resource, headers=[('If-Modified-Since',
last_modified)])
self.assert304(r.status_code)
self.assertTrue(not r.get_data())
def assertItem(self, item):
self.assertEqual(type(item), dict)
_id = item.get(self.app.config['ID_FIELD'])
self.assertTrue(_id is not None)
match = re.compile(self.app.config['ITEM_URL']).match(_id)
self.assertTrue(match is not None)
self.assertEqual(match.group(), _id)
updated_on = item.get(self.app.config['LAST_UPDATED'])
self.assertTrue(updated_on is not None)
try:
datetime.strptime(updated_on, self.app.config['DATE_FORMAT'])
except Exception as e:
self.fail('Cannot convert field "%s" to datetime: %s' %
(self.app.config['LAST_UPDATED'], e))
link = item.get('_links')
self.assertItemLink(link, _id)
def assertHomeLink(self, links):
self.assertTrue('parent' in links)
link = links['parent']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('home', link['title'])
self.assertEqual("%s" % self.app.config['SERVER_NAME'], link['href'])
def assertResourceLink(self, links, resource):
self.assertTrue('self' in links)
link = links['self']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s/%s/" % (self.app.config['SERVER_NAME'], url),
link['href'])
def assertCollectionLink(self, links, resource):
self.assertTrue('collection' in links)
link = links['collection']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s/%s/" % (self.app.config['SERVER_NAME'], url),
link['href'])
def assertNextLink(self, links, page):
self.assertTrue('next' in links)
link = links['next']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('next page', link['title'])
self.assertTrue("page=%d" % page in link['href'])
def assertPrevLink(self, links, page):
self.assertTrue('prev' in links)
link = links['prev']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('previous page', link['title'])
if page > 1:
self.assertTrue("page=%d" % page in link['href'])
def assertItemLink(self, links, item_id):
self.assertTrue('self' in links)
link = links['self']
#TODO we are too deep here to get a hold of the due title. Should fix.
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertTrue('/%s/' % item_id in link['href'])
def assertLastLink(self, links, page):
if page:
self.assertTrue('last' in links)
link = links['last']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('last page', link['title'])
self.assertTrue("page=%d" % page in link['href'])
else:
self.assertTrue('last' not in links)
def assert400(self, status):
self.assertEqual(status, 400)
def assert401(self, status):
self.assertEqual(status, 401)
def assert401or405(self, status):
self.assertTrue(status == 401 or 405)
def assert403(self, status):
self.assertEqual(status, 403)
def assert405(self, status):
self.assertEqual(status, 405)
def assert412(self, status):
self.assertEqual(status, 412)
def assert500(self, status):
self.assertEqual(status, 500)
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
if MONGO_USERNAME:
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
pass
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
class TestBase(unittest.TestCase):
def setUp(self):
self.setupDB()
self.settings_file = 'eve/tests/test_settings.py'
self.app = Eve(settings=self.settings_file)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
self.known_resource = 'contacts'
self.known_resource_url = ('/%s/' %
self.domain[self.known_resource]['url'])
self.empty_resource = 'empty'
self.empty_resource_url = '/%s/' % self.empty_resource
self.unknown_resource = 'unknown'
self.unknown_resource_url = '/%s/' % self.unknown_resource
self.unknown_item_id = '4f46445fc88e201858000000'
self.unknown_item_name = 'unknown'
self.unknown_item_id_url = ('/%s/%s/' %
(self.domain[self.known_resource]['url'],
self.unknown_item_id))
self.unknown_item_name_url = ('/%s/%s/' %
(self.domain[self.known_resource]['url'],
self.unknown_item_name))
self.readonly_resource = 'payments'
self.readonly_resource_url = (
'/%s/' % self.domain[self.readonly_resource]['url'])
self.different_resource = 'users'
self.different_resource_url = ('/%s/' %
self.domain[
self.different_resource]['url'])
def tearDown(self):
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def setupDB(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO_DBNAME)
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME, MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
_db = self.connection[MONGO_DBNAME]
_db.contacts.insert(self.random_contacts(100))
_db.contacts.insert(self.random_users(2))
_db.payments.insert(self.random_payments(10))
_db.invoices.insert(self.random_invoices(1))
self.connection.close()
def dropDB(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def random_contacts(self, num, standard_date_fields=True):
schema = DOMAIN['contacts']['schema']
contacts = []
for i in range(num):
dt = datetime.now()
contact = {
'ref': self.random_string(schema['ref']['maxlength']),
'prog': i,
'role': random.choice(schema['role']['allowed']),
'rows': self.random_rows(random.randint(0, 5)),
'alist': self.random_list(random.randint(0, 5)),
'location': {
'address': 'address ' + self.random_string(5),
'city': 'city ' + self.random_string(3),
},
'born': datetime.today() + timedelta(
days=random.randint(-10, 10)),
'tid': ObjectId(),
}
if standard_date_fields:
contact[eve.LAST_UPDATED] = dt
contact[eve.DATE_CREATED] = dt
contacts.append(contact)
return contacts
def random_users(self, num):
users = self.random_contacts(num)
for user in users:
user['username'] = self.random_string(10)
return users
def random_payments(self, num):
payments = []
for i in range(num):
dt = datetime.now()
payment = {
'a_string': self.random_string(10),
'a_number': i,
eve.LAST_UPDATED: dt,
eve.DATE_CREATED: dt,
}
payments.append(payment)
return payments
def random_invoices(self, num):
invoices = []
for i in range(num):
dt = datetime.now()
invoice = {
'inv_number': self.random_string(10),
eve.LAST_UPDATED: dt,
eve.DATE_CREATED: dt,
}
invoices.append(invoice)
return invoices
def random_string(self, num):
return (''.join(random.choice(string.ascii_uppercase)
for x in range(num)))
def random_list(self, num):
alist = []
for i in range(num):
alist.append(['string' + str(i), random.randint(1000, 9999)])
return alist
def random_rows(self, num):
schema = DOMAIN['contacts']['schema']['rows']['schema']['schema']
rows = []
for i in range(num):
rows.append(
{
'sku': self.random_string(schema['sku']['maxlength']),
'price': random.randint(100, 1000),
}
)
return rows
class TestBase(unittest.TestCase):
def setUp(self):
""" Prepare the test fixture """
self.setupDB()
self.app = run.app
self.domain = self.app.config['DOMAIN']
self.test_client = self.app.test_client()
self.valid_auth = [('Authorization', 'Basic dG9rZW4xOg==')]
self.headers = [('Content-Type', 'application/json')] + self.valid_auth
def tearDown(self):
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert201(self, status):
self.assertEqual(status, 201)
def assert204(self, status):
self.assertEqual(status, 204)
def assert401(self, status):
self.assertEqual(status, 401)
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
if MONGO_USERNAME:
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
MONGO_PASSWORD)
db = self.connection[MONGO_DBNAME]
self.accounts_insert(db)
self.company_insert(db)
db.connection.close()
def accounts_insert(self, db):
user_accounts = [
{'u': '*****@*****.**', 'p': 'pw1', 't': 'token1', 'r': ['app']},
{'u': '*****@*****.**', 'p': 'pw1', 't': 'token2', 'r': ['user']},
]
db.user_accounts.insert(user_accounts)
def company_insert(self, db):
company = {'n': 'test_company', 'p': 'pw1'}
self.company_id = str(db.companies.insert(company))
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def post(self, url, payload):
r = self.test_client.post(url, data=json.dumps(payload),
headers=self.headers)
return self.parse_response(r)
def put(self, url, payload, etag):
headers = self.headers + [('If-Match', etag)]
r = self.test_client.put(url, data=json.dumps(payload),
headers=headers)
return self.parse_response(r)
def delete(self, url, etag):
headers = self.headers + [('If-Match', etag)]
r = self.test_client.delete(url, headers=headers)
return self.parse_response(r)
def get(self, url):
r = self.test_client.get(url, headers=self.headers)
return self.parse_response(r)
def parse_response(self, r):
try:
v = json.loads(r.get_data())
except json.JSONDecodeError:
v = None
return v, r.status_code
class TestBase(unittest.TestCase):
def setUp(self):
self.setupDB()
self.settings_file = 'eve/tests/test_settings.py'
self.app = Eve(settings=self.settings_file)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
self.known_resource = 'contacts'
self.known_resource_url = ('/%s/' %
self.domain[self.known_resource]['url'])
self.empty_resource = 'empty'
self.empty_resource_url = '/%s/' % self.empty_resource
self.unknown_resource = 'unknown'
self.unknown_resource_url = '/%s/' % self.unknown_resource
self.unknown_item_id = '4f46445fc88e201858000000'
self.unknown_item_name = 'unknown'
self.unknown_item_id_url = (
'/%s/%s/' %
(self.domain[self.known_resource]['url'], self.unknown_item_id))
self.unknown_item_name_url = (
'/%s/%s/' %
(self.domain[self.known_resource]['url'], self.unknown_item_name))
self.readonly_resource = 'payments'
self.readonly_resource_url = (
'/%s/' % self.domain[self.readonly_resource]['url'])
self.different_resource = 'users'
self.different_resource_url = (
'/%s/' % self.domain[self.different_resource]['url'])
def tearDown(self):
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def setupDB(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO_DBNAME)
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME, MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
_db = self.connection[MONGO_DBNAME]
_db.contacts.insert(self.random_contacts(100))
_db.contacts.insert(self.random_users(2))
_db.payments.insert(self.random_payments(10))
_db.invoices.insert(self.random_invoices(1))
self.connection.close()
def dropDB(self):
self.connection = MongoClient()
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def random_contacts(self, num, standard_date_fields=True):
schema = DOMAIN['contacts']['schema']
contacts = []
for i in range(num):
dt = datetime.now()
contact = {
'ref': self.random_string(schema['ref']['maxlength']),
'prog': i,
'role': random.choice(schema['role']['allowed']),
'rows': self.random_rows(random.randint(0, 5)),
'alist': self.random_list(random.randint(0, 5)),
'location': {
'address': 'address ' + self.random_string(5),
'city': 'city ' + self.random_string(3),
},
'born':
datetime.today() + timedelta(days=random.randint(-10, 10)),
'tid': ObjectId(),
}
if standard_date_fields:
contact[eve.LAST_UPDATED] = dt
contact[eve.DATE_CREATED] = dt
contacts.append(contact)
return contacts
def random_users(self, num):
users = self.random_contacts(num)
for user in users:
user['username'] = self.random_string(10)
return users
def random_payments(self, num):
payments = []
for i in range(num):
dt = datetime.now()
payment = {
'a_string': self.random_string(10),
'a_number': i,
eve.LAST_UPDATED: dt,
eve.DATE_CREATED: dt,
}
payments.append(payment)
return payments
def random_invoices(self, num):
invoices = []
for i in range(num):
dt = datetime.now()
invoice = {
'inv_number': self.random_string(10),
eve.LAST_UPDATED: dt,
eve.DATE_CREATED: dt,
}
invoices.append(invoice)
return invoices
def random_string(self, num):
return (''.join(
random.choice(string.ascii_uppercase) for x in range(num)))
def random_list(self, num):
alist = []
for i in range(num):
alist.append(['string' + str(i), random.randint(1000, 9999)])
return alist
def random_rows(self, num):
schema = DOMAIN['contacts']['schema']['rows']['schema']['schema']
rows = []
for i in range(num):
rows.append({
'sku': self.random_string(schema['sku']['maxlength']),
'price': random.randint(100, 1000),
})
return rows
class TestMinimal(pea.TestCase):
""" Start the building of the tests for the PulsePod API
by subclassing this class and provide proper settings
using :func:`setUp()`
"""
def setUp(self, config=None):
""" Prepare the test fixture
:param config: the name of the config class. Defaults
to `testing`.
"""
super(TestMinimal, self).setUp()
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if config is None:
config = 'testing'
elif config in ('production', 'development', 'heroku'):
assert 0, "Unable to run tests with %s config" % config
self.connection = None
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
self.setupDB()
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
self.config = self.app.config
self.DataMessage = {
'message_content': u'020f5be1018446df5314512d41b6028446df5' +
'339ecb6427438df53cee69f4255038446df538dc656427438df530dbe' +
'9442642adf53011aa641'
}
self.DeployMessage = {
'message_content': u'030f5b310026032229c58b436b4003e1b655'
}
def tearDown(self):
super(TestMinimal, self).tearDown()
self.dropDB()
self.app_context.pop()
del self.app
def assert200(self, status):
self.assertEqual(status, 200)
def assert201(self, status):
self.assertEqual(status, 201)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def get(self, resource, query='', item=None, headers=None):
if resource in self.domain:
resource = self.domain[resource]['url']
if item:
request = '/%s/%s%s' % (resource, item, query)
else:
request = '/%s%s' % (resource, query)
r = self.test_client.get(request)
return self.parse_response(r)
def post(self, url, data, headers=None, content_type='application/json'):
if headers is None:
headers = []
headers.append(('Content-Type', content_type))
r = self.test_client.post(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def put(self, url, data, headers=None):
if headers is None:
headers = []
headers.append(('Content-Type', 'application/json'))
r = self.test_client.put(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def patch(self, url, data, headers=None):
if headers is None:
headers = []
headers.append(('Content-Type', 'application/json'))
r = self.test_client.patch(url, data=json.dumps(data), headers=headers)
return self.parse_response(r)
def delete(self, url, headers=None):
r = self.test_client.delete(url, headers=headers)
return self.parse_response(r)
def bulk_insert(self):
pass
def parse_response(self, r):
try:
v = json.loads(r.get_data())
except json.JSONDecodeError:
v = None
return v, r.status_code
def setupDB(self):
settings = self.app.config['MONGODB_SETTINGS']
self.connection = MongoClient(settings['HOST'],
settings['PORT'])
self.connection.drop_database(settings['DB'])
if 'USERNAME' in settings:
self.connection[settings['DB']].add_user(
settings['USERNAME'], settings['PASSWORD'])
self.Pod = models.Pod
self.User = models.User
self.Message = models.Message
self.Notebook = models.Notebook
self.Sensor = models.Sensor
self.Data = models.Data
self.bulk_insert()
def dropDB(self):
settings = self.app.config['MONGODB_SETTINGS']
self.connection = MongoClient(
settings['HOST'],
settings['PORT'])
self.connection.drop_database(settings['DB'])
self.connection.close()
class TestMinimal(unittest.TestCase):
""" Start the building of the tests for an application
based on Eve by subclassing this class and provide proper settings
using :func:`setUp()`
"""
def setUp(self, settings_file=None):
""" Prepare the test fixture
:param settings_file: the name of the settings file. Defaults
to `eve/tests/test_settings.py`.
"""
if settings_file is None:
# Load the settings file, using a robust path
THIS_DIRECTORY = os.path.dirname(os.path.realpath(__file__))
settings_file = os.path.join(THIS_DIRECTORY, 'test_settings.py')
self.known_resource_count = 101
self.setupDB()
self.settings_file = settings_file
self.app = eve.Eve(settings=self.settings_file)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def tearDown(self):
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def get(self, resource, query='', item=None):
if resource in self.domain:
resource = self.domain[resource]['url']
if item:
request = '/%s/%s' % (resource, item)
else:
request = '/%s%s' % (resource, query)
r = self.test_client.get(request)
return self.parse_response(r)
def parse_response(self, r):
v = json.loads(r.get_data()) if r.status_code == 200 else None
return v, r.status_code
def assertValidationError(self, response, key, matches):
self.assertTrue(key in response)
k = response[key]
self.assertTrue('status' in k)
self.assertTrue(eve.STATUS_ERR in k['status'])
self.assertTrue('issues' in k)
issues = k['issues']
self.assertTrue(len(issues))
for match in matches:
self.assertTrue(match in issues[0])
def assertExpires(self, resource):
# TODO if we ever get access to response.date (it is None), compare
# it with Expires
r = self.test_client.get(resource)
expires = r.headers.get('Expires')
self.assertTrue(expires is not None)
def assertCacheControl(self, resource):
r = self.test_client.get(resource)
cache_control = r.headers.get('Cache-Control')
self.assertTrue(cache_control is not None)
self.assertEqual(cache_control,
self.domain[self.known_resource]['cache_control'])
def assertIfModifiedSince(self, resource):
r = self.test_client.get(resource)
last_modified = r.headers.get('Last-Modified')
self.assertTrue(last_modified is not None)
r = self.test_client.get(resource,
headers=[('If-Modified-Since', last_modified)
])
self.assert304(r.status_code)
self.assertTrue(not r.get_data())
def assertItem(self, item):
self.assertEqual(type(item), dict)
_id = item.get(self.app.config['ID_FIELD'])
self.assertTrue(_id is not None)
match = re.compile(self.app.config['ITEM_URL']).match(_id)
self.assertTrue(match is not None)
self.assertEqual(match.group(), _id)
updated_on = item.get(self.app.config['LAST_UPDATED'])
self.assertTrue(updated_on is not None)
try:
datetime.strptime(updated_on, self.app.config['DATE_FORMAT'])
except Exception as e:
self.fail('Cannot convert field "%s" to datetime: %s' %
(self.app.config['LAST_UPDATED'], e))
created_on = item.get(self.app.config['DATE_CREATED'])
self.assertTrue(updated_on is not None)
try:
datetime.strptime(created_on, self.app.config['DATE_FORMAT'])
except Exception as e:
self.fail('Cannot convert field "%s" to datetime: %s' %
(self.app.config['DATE_CREATED'], e))
link = item.get('_links')
self.assertItemLink(link, _id)
def assertHomeLink(self, links):
self.assertTrue('parent' in links)
link = links['parent']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('home', link['title'])
self.assertEqual("%s" % self.app.config['SERVER_NAME'], link['href'])
def assertResourceLink(self, links, resource):
self.assertTrue('self' in links)
link = links['self']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s/%s" % (self.app.config['SERVER_NAME'], url),
link['href'])
def assertCollectionLink(self, links, resource):
self.assertTrue('collection' in links)
link = links['collection']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
url = self.domain[resource]['url']
self.assertEqual(url, link['title'])
self.assertEqual("%s/%s" % (self.app.config['SERVER_NAME'], url),
link['href'])
def assertNextLink(self, links, page):
self.assertTrue('next' in links)
link = links['next']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('next page', link['title'])
self.assertTrue("page=%d" % page in link['href'])
def assertPrevLink(self, links, page):
self.assertTrue('prev' in links)
link = links['prev']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('previous page', link['title'])
if page > 1:
self.assertTrue("page=%d" % page in link['href'])
def assertItemLink(self, links, item_id):
self.assertTrue('self' in links)
link = links['self']
#TODO we are too deep here to get a hold of the due title. Should fix.
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertTrue('/%s' % item_id in link['href'])
def assertLastLink(self, links, page):
if page:
self.assertTrue('last' in links)
link = links['last']
self.assertTrue('title' in link)
self.assertTrue('href' in link)
self.assertEqual('last page', link['title'])
self.assertTrue("page=%d" % page in link['href'])
else:
self.assertTrue('last' not in links)
def assert400(self, status):
self.assertEqual(status, 400)
def assert401(self, status):
self.assertEqual(status, 401)
def assert401or405(self, status):
self.assertTrue(status == 401 or 405)
def assert403(self, status):
self.assertEqual(status, 403)
def assert405(self, status):
self.assertEqual(status, 405)
def assert412(self, status):
self.assertEqual(status, 412)
def assert500(self, status):
self.assertEqual(status, 500)
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
if MONGO_USERNAME:
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
pass
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
class TestMinimal(TestBase):
def setUp(self):
""" Prepare the test fixture
"""
self.setupDB()
super(TestMinimal, self).setUp()
self.app = Eve(settings='settings.py', auth=run.Auth)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def tearDown(self):
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def assert400(self, status):
self.assertEqual(status, 400)
def assert401(self, status):
self.assertEqual(status, 401)
def assert401or405(self, status):
self.assertTrue(status == 401 or 405)
def assert403(self, status):
self.assertEqual(status, 403)
def assert405(self, status):
self.assertEqual(status, 405)
def assert412(self, status):
self.assertEqual(status, 412)
def assert500(self, status):
self.assertEqual(status, 500)
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
if MONGO_USERNAME:
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
accounts = [
{
'u': '*****@*****.**',
'p': 'pw1',
't': 'token1',
'r': ['app']
},
{
'u': '*****@*****.**',
'p': 'pw1',
't': 'token2',
'r': ['user']
},
]
_db = self.connection[MONGO_DBNAME]
_db.accounts.insert(accounts)
self.connection.close()
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
class TestBase(unittest.TestCase):
def setUp(self):
self.app = eve_example.app
self.client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
self.setupDb()
def tearDown(self):
self.dropDB()
del self.app
def setupDb(self):
self.connection = MongoClient(self.app.config['MONGO_URI'])
self.db = self.connection.get_default_database()
self.connection.drop_database(self.db)
self.bulk_insert()
def bulk_insert(self):
files = glob(os.path.join(os.path.dirname(__file__), '../data/*.json'))
for path in files:
collection = self.db[os.path.splitext(os.path.basename(path))[0]]
with open(path, 'r') as fh:
for line in fh:
collection.insert(json.loads(line))
def dropDB(self):
self.connection.drop_database(self.app.config['MONGO_DBNAME'])
self.connection.close()
self.connection = None
def epoch(self):
return datetime(1970, 1, 1)
def date_now(self):
return datetime.utcnow().replace(microsecond=0)
def basic_auth_headers(self, username, password):
auth = base64.b64encode((username + ':' + password).encode('ascii'))
return [('Authorization', 'Basic ' + auth.decode('ascii'))]
def auth(self, user):
return [('Authorization', 'Bearer %s' % user['token'])]
def admin_auth(self):
return self.basic_auth_headers('admin', self.app.config['ADMIN_PASSWORD'])
def resolve_resource(self, resource, item=None):
resource_params = []
if isinstance(resource, tuple):
resource_params = list(resource[0:-1])
resource = resource[-1]
if resource in self.domain:
resource = self.domain[resource]['url']
if resource_params:
resource = re.sub(r'<.*?>', lambda v: str(resource_params.pop()), resource)
if item:
if isinstance(item, dict):
item = item.get('id')
request = '/%s/%s' % (resource, str(item))
else:
request = '/%s' % (resource)
return request
def get(self, resource, item=None, query='', headers=[]):
url = self.resolve_resource(resource, item)
res = self.client.get(url + query, headers=headers)
return self.parse_response(res)
def post(self, resource, data, item=None, headers=[], content_type=None):
if not content_type:
content_type = 'application/json'
headers.append(('Content-Type', content_type))
url = self.resolve_resource(resource, item)
res = self.client.post(url, data=json.dumps(data), headers=headers)
return self.parse_response(res)
def put(self, resource, data, item=None, headers=[]):
headers.append(('Content-Type', 'application/json'))
url = self.resolve_resource(resource, item)
res = self.client.put(url, data=json.dumps(data), headers=headers)
return self.parse_response(res)
def patch(self, resource, data, item=None, headers=[]):
headers.append(('Content-Type', 'application/json'))
url = self.resolve_resource(resource, item)
res = self.client.patch(url, data=json.dumps(data), headers=headers)
return self.parse_response(res)
def delete(self, resource, item=None, headers=None):
url = self.resolve_resource(resource, item)
res = self.client.delete(url, headers=headers)
return self.parse_response(res)
def parse_response(self, res):
val = None
if res.get_data():
val = res.get_data().decode("utf-8")
try:
val = json.loads(val)
except ValueError:
self.fail("'%s' is not valid JSON" % (val))
return val, res.status_code
def create(self, resource, data, user=None):
if not user:
user = self.u.john
data, status = self.post(resource, data, headers=self.auth(user))
if status != 201:
print(data)
self.assertNoError(data)
return ObjectId(data['_id'])
def fetch(self, resource, item=None, user=None):
if not user:
user = self.u.john
data, status = self.get(resource, item=item, headers=self.auth(user))
self.assertNoError(data)
return data
def modify(self, resource, item, body, user=None):
if not user:
user = self.u.john
data, status = self.patch(resource, body, item=item,
headers=self.auth(user))
self.assertNoError(data)
return data
def remove(self, resource, item, user=None):
if not user:
user = self.u.john
data, status = self.delete(resource, item,
headers=self.auth(user))
self.assertNoError(data)
def assertNoError(self, response):
if response is None:
return
self.assertIsInstance(response, dict)
if eve.STATUS in response:
self.assertTrue(eve.STATUS_OK in response[eve.STATUS],
'status is not OK: %s' % response)
def assertValidationError(self, response, matches):
self.assertTrue(eve.STATUS in response, 'missing status')
self.assertTrue(eve.STATUS_ERR in response[eve.STATUS],
'status is not ERR')
self.assertTrue(ISSUES in response, 'response as no issues')
issues = response[ISSUES]
self.assertTrue(len(issues))
for k, v in matches.items():
self.assertTrue(k in issues, 'no "%s" error' % k)
self.assertTrue(v in issues[k],
'"%s" error does not contain "%s"' % (k, v))
def assertTimeEqual(self, time1, time2):
self.assertAlmostEqual(time1, time2, delta=timedelta(seconds=10))
class TestMinimal(TestBase):
def setUp(self):
""" Prepare the test fixture
"""
self.setupDB()
super(TestMinimal, self).setUp()
self.app = Eve(settings='settings.py', auth=run.Auth)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def tearDown(self):
self.dropDB()
def assert200(self, status):
self.assertEqual(status, 200)
def assert301(self, status):
self.assertEqual(status, 301)
def assert404(self, status):
self.assertEqual(status, 404)
def assert304(self, status):
self.assertEqual(status, 304)
def assert400(self, status):
self.assertEqual(status, 400)
def assert401(self, status):
self.assertEqual(status, 401)
def assert401or405(self, status):
self.assertTrue(status == 401 or 405)
def assert403(self, status):
self.assertEqual(status, 403)
def assert405(self, status):
self.assertEqual(status, 405)
def assert412(self, status):
self.assertEqual(status, 412)
def assert500(self, status):
self.assertEqual(status, 500)
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
if MONGO_USERNAME:
self.connection[MONGO_DBNAME].add_user(MONGO_USERNAME,
MONGO_PASSWORD)
self.bulk_insert()
def bulk_insert(self):
accounts = [
{'u': '*****@*****.**', 'p': 'pw1', 't': 'token1', 'r': ['app']},
{'u': '*****@*****.**', 'p': 'pw1', 't': 'token2', 'r': ['user']},
]
_db = self.connection[MONGO_DBNAME]
_db.accounts.insert(accounts)
self.connection.close()
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
