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 TestBase(unittest.TestCase):
def setUp(self, settings=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings is None:
settings = os.path.join(self.this_directory, 'test_settings.py')
self.setupDB()
self.settings = settings
self.app = eve.Eve(settings=self.settings)
self.app.register_blueprint(eve_swagger.swagger)
self.app.config['SWAGGER_INFO'] = {
'title': 'Test eve-swagger',
'version': '0.0.1'
}
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
self.swagger_doc = self.get_swagger_doc()
def tearDown(self):
del self.app
self.dropDB()
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)
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def get_swagger_doc(self):
r = self.test_client.get('/api-docs')
return self.parse_response(r)
def parse_response(self, r):
try:
v = json.loads(r.get_data().decode('utf-8'))
except ValueError:
v = None
return v
class settingsTestCase(TestMinimal):
def setUp(self):
return super().setUp(settings_file = './settings.py')
def dropDB(self):
self.connection = MongoClient(MONGO_HOST,MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def setupDB(self):
self.connection = MongoClient(MONGO_HOST,MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
def testGet(self):
return_json,return_code = self.get(url)
self.assert200(return_code)
def testPost(self):
return_json, return_code = self.post(url, {"cjv": 0.1231231})
self.assertFalse(self.domain)
self.assertFalse(return_json)
class TestBase(unittest.TestCase):
def setUp(self, settings=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings is None:
settings = os.path.join(self.this_directory, "test_settings.py")
self.setupDB()
self.settings = settings
self.app = eve.Eve(settings=self.settings)
self.app.register_blueprint(eve_swagger.swagger)
self.app.config["SWAGGER_INFO"] = {"title": "Test eve-swagger", "version": "0.0.1"}
self.test_client = self.app.test_client()
self.domain = self.app.config["DOMAIN"]
self.swagger_doc = self.get_swagger_doc()
def tearDown(self):
del self.app
self.dropDB()
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)
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def get_swagger_doc(self):
r = self.test_client.get("/api-docs")
return self.parse_response(r)
def parse_response(self, r):
try:
v = json.loads(r.get_data().decode("utf-8"))
except ValueError:
v = None
return v
class TestKilnShare(TestMinimal):
def setUp(self):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
self.settings_file = os.path.join(self.this_directory,
'../../settings.py')
self.connection = None
self.setupDB()
self.app = kiln_share.create_app()
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
# Setup some common test users.
self.user1 = [('X-Kiln-Share-Id', 'foo')]
self.user2 = [('X-Kiln-Share-Id', 'bar')]
def setupDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def get(self, url, headers=None, content_type='application/json'):
if headers is None:
headers = []
headers.append(('Content-Type', content_type))
r = self.test_client.get(url, headers=headers)
return self.parse_response(r)
def test_multi_tenancy(self):
kiln = {
'name': 'Test kiln',
'share_type': 'any',
'location': {
'type': 'Point',
'coordinates': [ 10.321, 5.123 ]
},
'power': 'electric',
'chamber_size': 100,
'max_temperature': 1000,
'cost_per_fire': 10.50,
'description': 'foo bar'
}
headers1 = deepcopy(self.user1)
r = self.post('auth/kilns', headers=headers1, data=kiln)
self.assertEqual(r[1], 201)
r = self.get('auth/kilns', headers=headers1)
self.assertEqual(r[1], 200)
result = r[0]
self.assertEqual(result['_meta']['total'], 1)
# Now with another user.
headers2 = deepcopy(self.user2)
r = self.get('auth/kilns', headers=headers2)
self.assertEqual(r[1], 200)
result = r[0]
self.assertEqual(result['_meta']['total'], 0)
def test_images(self):
headers1 = deepcopy(self.user1)
kiln = {
'name': 'Test kiln',
'share_type': 'any',
'location': {
'type': 'Point',
'coordinates': [ 10.321, 5.123 ]
},
'power': 'electric',
'chamber_size': 100,
'max_temperature': 1000,
'cost_per_fire': 10.50,
'description': 'foo bar'
}
r = self.post('auth/kilns', headers=headers1, data=kiln)
kiln_id = r[0]['_id']
# Post an image.
headers1 = deepcopy(self.user1)
headers1.append(('Content-Type', 'multipart/form-data'))
location = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
file_ = open(os.path.join(location, 'img.jpg'));
file_content = file_.read()
data = {
'file': (BytesIO(file_content), 'img.png'),
'kiln': kiln_id
}
# Use test client directly to avoid json encoding.
r = self.test_client.post('auth/images', data=data, headers=headers1)
self.assertEqual(r.status_code, 201)
def test_conversations_and_messages(self):
headers1 = deepcopy(self.user1)
headers2 = deepcopy(self.user2)
headers3 = [('X-Kiln-Share-Id', 'baz')]
# Check no data exists.
for headers in [headers1, headers2, headers3]:
r = self.get('auth/conversations', headers=headers)
self.assertEqual(r[1], 200)
result = r[0]
self.assertEqual(result['_meta']['total'], 0)
# Create a conversation.
data = {
'participants': ['bar']
}
r = self.post('auth/conversations', data=data, headers=headers1)
self.assertEqual(r[1], 201)
conversation_id = r[0]['_id']
# Both users should see the conversation.
for headers in [headers1, headers2]:
r = self.get('auth/conversations', headers=headers)
self.assertEqual(r[1], 200)
result = r[0]
self.assertEqual(result['_meta']['total'], 1)
# But user 3 should not.
r = self.get('auth/conversations', headers=headers3)
self.assertEqual(r[1], 200)
result = r[0]
self.assertEqual(result['_meta']['total'], 0)
# Now send a message.
data = {
'text': 'hello'
}
url = 'auth/conversations/%s/messages' % conversation_id
r = self.post(url, data=data, headers=deepcopy(self.user1))
self.assertEqual(r[1], 201)
# User 3 shouldn't be able to post to the conversation.
r = self.post(url, data=data, headers=headers3)
self.assertEqual(r[1], 403)
# Both users should see the message when fetching the
# conversation.
for headers in [headers1, headers2]:
url = 'auth/conversations/%s' % conversation_id
r = self.get(url, headers=headers)
self.assertEqual(r[1], 200)
result = r[0]
self.assertEqual(len(result['messages']), 1)
def tearDown(self):
client = MongoClient('localhost', 27017)
client.drop_database(TestConfig.MONGO_DBNAME)
def clearDB():
client = MongoClient("mongodb://localhost")
client.drop_database('maskeraid')
return ""
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 assertCustomParams(self, link, params):
self.assertTrue('href' in link)
url_params = parse_qs(urlparse(link['href']).query)
for param, values in params.lists():
self.assertTrue(param in url_params)
for value in values:
self.assertTrue(value in url_params[param])
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 assert428(self, status):
self.assertEqual(status, 428)
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, settings=None):
self.this_directory = os.path.dirname(os.path.realpath(__file__))
if settings is None:
settings = os.path.join(self.this_directory, 'test_settings.py')
self.setupDB()
self.settings = settings
self.app = eve.Eve(settings=self.settings)
eve_embedded.embedded.install(self.app)
self.test_client = self.app.test_client()
self.domain = self.app.config['DOMAIN']
def tearDown(self):
del self.app
self.dropDB()
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)
# seed
result = self.connection[MONGO_DBNAME].people.\
insert_one({
'name': "John"
})
result = self.connection[MONGO_DBNAME].people.\
insert_one({
'name': "Peter",
"relations": [
{
"relation_type": "family",
"relation": result.inserted_id,
}
],
"rest_relations": [
{
"relation_type": "family",
"relation": result.inserted_id,
}
]
})
# result = self.connection[MONGO_DBNAME].people.\
# insert_one({'name': "Peter"})
# print(result.inserted_id)
# ObjectId('54f112defba522406c9cc208')
def dropDB(self):
self.connection = MongoClient(MONGO_HOST, MONGO_PORT)
self.connection.drop_database(MONGO_DBNAME)
self.connection.close()
def parse_response(self, r):
try:
v = json.loads(r.get_data().decode('utf-8'))
except ValueError:
v = None
return v
