def test_fetch_text_indexes(self):
"""
Ensure that the document fetch from the database returns the
DesignDocument format as expected when retrieving a design document
containing query index views.
"""
# This is not the preferred way of dealing with query index
# views but it works best for this test.
data = {
"_id": "_design/ddoc001",
"language": "query",
"indexes": {
"index001": {
"index": {
"index_array_lengths": True,
"fields": [{"name": "name", "type": "string"}, {"name": "age", "type": "number"}],
"default_field": {"enabled": True, "analyzer": "german"},
"default_analyzer": "keyword",
"selector": {},
},
"analyzer": {"name": "perfield", "default": "keyword", "fields": {"$default": "german"}},
}
},
}
doc = self.db.create_document(data)
self.assertIsInstance(doc, Document)
ddoc = DesignDocument(self.db, "_design/ddoc001")
ddoc.fetch()
self.assertIsInstance(ddoc, DesignDocument)
data["_rev"] = doc["_rev"]
data["views"] = dict()
self.assertEqual(ddoc, data)
self.assertIsInstance(ddoc["indexes"]["index001"], dict)
def test_rewrite_rule(self):
"""
Test that design document URL is rewritten to the expected test document.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
ddoc['rewrites'] = [
{"from": "",
"to": "/../../rewrite_doc",
"method": "GET",
"query": {}
}
]
self.assertIsInstance(ddoc.rewrites, list)
self.assertIsInstance(ddoc.rewrites[0], dict)
ddoc.save()
doc = Document(self.db, 'rewrite_doc')
doc.save()
resp = self.client.r_session.get('/'.join([ddoc.document_url, '_rewrite']))
self.assertEquals(
resp.json(),
{
'_id': 'rewrite_doc',
'_rev': doc['_rev']
}
)
def test_delete_a_query_index_view(self):
"""
Test deleting a query index view fails as expected.
"""
# This is not the preferred way of dealing with query index
# views but it works best for this test.
data = {
'_id': '_design/ddoc001',
'language': 'query',
'views': {
'view001': {'map': {'fields': {'name': 'asc', 'age': 'asc'}},
'reduce': '_count',
'options': {'def': {'fields': ['name', 'age']},
'w': 2}
}
}
}
self.db.create_document(data)
ddoc = DesignDocument(self.db, '_design/ddoc001')
ddoc.fetch()
with self.assertRaises(CloudantException) as cm:
ddoc.delete_view('view001')
err = cm.exception
self.assertEqual(
str(err),
'Cannot delete a query index view using this method.'
)
def test_text_index_save_fails_with_existing_search_index(self):
"""
Tests that save fails when language is not query and both a query text
index and a search index exist in the design document.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
search_index = ('function (doc) {\n index("default", doc._id); '
'if (doc._id) {index("name", doc.name, '
'{"store": true}); }\n}')
ddoc.add_search_index('search001', search_index)
self.assertIsInstance(
ddoc['indexes']['search001']['index'], str
)
ddoc.save()
self.assertTrue(ddoc['_rev'].startswith('1-'))
ddoc_remote = DesignDocument(self.db, '_design/ddoc001')
ddoc_remote.fetch()
ddoc_remote['indexes']['index001'] = {
'index': {'index_array_lengths': True,
'fields': [{'name': 'name', 'type': 'string'},
{'name': 'age', 'type': 'number'}],
'default_field': {'enabled': True, 'analyzer': 'german'},
'default_analyzer': 'keyword',
'selector': {}},
'analyzer': {'name': 'perfield','default': 'keyword',
'fields': {'$default': 'german'}}}
self.assertIsInstance(ddoc_remote['indexes']['index001']['index'], dict)
with self.assertRaises(CloudantException) as cm:
ddoc_remote.save()
err = cm.exception
self.assertEqual(
str(err),
'Function for search index index001 must be of type string.'
)
def create_views(self):
"""
Create a design document with views for use with tests.
"""
self.ddoc = DesignDocument(self.db, 'ddoc001')
self.ddoc.add_view('view001',
'function (doc) {\n emit(doc._id, 1);\n}')
self.ddoc.add_view('view002',
'function (doc) {\n emit(doc._id, 1);\n}', '_count')
self.ddoc.add_view(
'view003',
'function (doc) {\n emit(Math.floor(doc.age / 2), 1);\n}')
self.ddoc.add_view(
'view004',
'function (doc) {\n emit(Math.floor(doc.age / 2), 1);\n}',
'_count')
self.ddoc.add_view(
'view005', 'function (doc) {\n emit([doc.name, doc.age], 1);\n}')
self.ddoc.add_view(
'view006', 'function (doc) {\n emit([doc.name, doc.age], 1);\n}',
'_count')
self.ddoc.save()
self.view001 = self.ddoc.get_view('view001')
self.view002 = self.ddoc.get_view('view002')
self.view003 = self.ddoc.get_view('view003')
self.view004 = self.ddoc.get_view('view004')
self.view005 = self.ddoc.get_view('view005')
self.view006 = self.ddoc.get_view('view006')
def test_new_ddoc_add_view(self):
mock_database = mock.Mock()
ddoc = DesignDocument(mock_database, '_design/unittest')
ddoc.add_view('view1', "MAP")
self.assertIn('view1', ddoc['views'])
self.assertEqual(ddoc['views']['view1'].map, 'MAP')
self.assertEqual(ddoc['views']['view1'].reduce, None)
def test_fetch_query_views(self):
"""
Ensure that the document fetch from the database returns the
DesignDocument format as expected when retrieving a design document
containing query index views.
"""
# This is not the preferred way of dealing with query index
# views but it works best for this test.
data = {
"_id": "_design/ddoc001",
"language": "query",
"views": {
"view001": {
"map": {"fields": {"name": "asc", "age": "asc"}},
"reduce": "_count",
"options": {"def": {"fields": ["name", "age"]}, "w": 2},
}
},
}
doc = self.db.create_document(data)
self.assertIsInstance(doc, Document)
data["_rev"] = doc["_rev"]
ddoc = DesignDocument(self.db, "_design/ddoc001")
ddoc.fetch()
self.assertIsInstance(ddoc, DesignDocument)
self.assertEqual(ddoc, data)
self.assertIsInstance(ddoc["views"]["view001"], QueryIndexView)
def test_fetch_query_views(self):
"""
Ensure that the document fetch from the database returns the
DesignDocument format as expected when retrieving a design document
containing query index views.
"""
# This is not the preferred way of dealing with query index
# views but it works best for this test.
data = {
'_id': '_design/ddoc001',
'language': 'query',
'views': {
'view001': {'map': {'fields': {'name': 'asc', 'age': 'asc'}},
'reduce': '_count',
'options': {'def': {'fields': ['name', 'age']},
'w': 2}
}
}
}
doc = self.db.create_document(data)
self.assertIsInstance(doc, Document)
data['_rev'] = doc['_rev']
ddoc = DesignDocument(self.db, '_design/ddoc001')
ddoc.fetch()
self.assertIsInstance(ddoc, DesignDocument)
self.assertEqual(ddoc, data)
self.assertIsInstance(ddoc['views']['view001'], QueryIndexView)
def test_fetch_text_indexes(self):
"""
Ensure that the document fetch from the database returns the
DesignDocument format as expected when retrieving a design document
containing query index views.
"""
# This is not the preferred way of dealing with query index
# views but it works best for this test.
data = {
'_id': '_design/ddoc001',
'language': 'query',
'indexes': {'index001':
{'index': {'index_array_lengths': True,
'fields': [{'name': 'name', 'type': 'string'},
{'name': 'age', 'type': 'number'}],
'default_field': {'enabled': True,
'analyzer': 'german'},
'default_analyzer': 'keyword',
'selector': {}},
'analyzer': {'name': 'perfield',
'default': 'keyword',
'fields': {'$default': 'german'}}}}}
doc = self.db.create_document(data)
self.assertIsInstance(doc, Document)
data['_rev'] = doc['_rev']
ddoc = DesignDocument(self.db, '_design/ddoc001')
ddoc.fetch()
self.assertIsInstance(ddoc, DesignDocument)
self.assertEqual(ddoc, data)
self.assertIsInstance(ddoc['indexes']['index001'], dict)
def test_list_views(self):
mock_database = mock.Mock()
ddoc = DesignDocument(mock_database, '_design/unittest')
ddoc['views'] = {
'view1': {'map': "MAP", 'reduce': 'REDUCE'},
'view2': {'map': "MAP", 'reduce': 'REDUCE'},
}
self.assertListEqual(sorted(ddoc.list_views()), ['view1', 'view2'])
def test_constructor_without_docid(self):
"""
Test instantiating a DesignDocument without providing an id
"""
ddoc = DesignDocument(self.db)
self.assertIsInstance(ddoc, DesignDocument)
self.assertIsNone(ddoc.get("_id"))
self.assertEqual(ddoc.get("views"), {})
def create_summaries(conn):
"""
Get summary statistics from a view in the sentiments db and update the
summaries db.
"""
# query view
logging.info('Querying database for summary...')
db = conn['sentiments']
ddoc = DesignDocument(db, '_design/summary')
ddoc.fetch()
view = ddoc.get_view('summary-view')
view_results = view(group=True)['rows']
logging.info('Query completed.')
# switch to summaries db
db = conn['summaries']
for view_result in view_results:
symbol = view_result['key']
unix_date = int(time.mktime(date.today().timetuple()))
# query for today's summary record
query = Query(db,
fields=['_id', 'symbol', 'date', 'summary'],
selector={
'symbol': {
'$eq': symbol
},
'date': {
'$eq': unix_date
}
})
if query.result[0]:
# A record for today already exists so overwrite it. This should not normally happen.
record = db[query.result[0][0]['_id']]
summary = record['summary']
logging.info('Updating summary for %s', symbol)
record['summary'] = view_result['value']
summary.save()
else:
# Creating a new summary
logging.info('Creating summary for %s...', symbol)
data = {
'symbol': symbol,
'date': unix_date,
'summary': view_result['value']
}
new_summary = db.create_document(data)
if new_summary.exists():
logging.info('Finished creating summary.')
else:
logging.error('Failed to create summary.')
# don't exceed rate limit
time.sleep(1)
def __contains__(self, key):
if not self.remote:
if key in list(self.keys(remote=False)):
return True
if key.startswith("_design/"):
doc = DesignDocument(self, key)
else:
doc = Document(self, key)
return doc.exists()
def test_view_context(self):
db = mock.Mock()
db.database_name = 'unittest'
ddoc = DesignDocument(db, "_design/tests")
ddoc._database_host = "https://bob.cloudant.com"
view1 = View(ddoc, "view1", map_func=self.map_func)
with view1.custom_result() as v:
self.assertTrue(isinstance(v, Result))
def test_constructor_with_docid(self):
"""
Test instantiating a DesignDocument providing an id
not prefaced with '_design/'
"""
ddoc = DesignDocument(self.db, 'ddoc001')
self.assertIsInstance(ddoc, DesignDocument)
self.assertEqual(ddoc.get('_id'), '_design/ddoc001')
self.assertEqual(ddoc.get('views'), {})
def test_ddoc_update_view(self):
mock_database = mock.Mock()
ddoc = DesignDocument(mock_database, '_design/unittest')
ddoc.add_view('view1', "MAP", "REDUCE")
ddoc.update_view('view1', "UPDATED_MAP", "REDUCE")
self.assertTrue('view1' in ddoc['views'])
self.assertEqual(ddoc['views']['view1'].map, 'UPDATED_MAP')
self.assertEqual(ddoc['views']['view1'].reduce, 'REDUCE')
def test_constructor_with_design_docid(self):
"""
Test instantiating a DesignDocument providing an id
prefaced with '_design/'
"""
ddoc = DesignDocument(self.db, "_design/ddoc001")
self.assertIsInstance(ddoc, DesignDocument)
self.assertEqual(ddoc.get("_id"), "_design/ddoc001")
self.assertEqual(ddoc.get("views"), {})
def test_adding_query_index_view(self):
"""
Test that adding a query index view fails as expected.
"""
ddoc = DesignDocument(self.db, "_design/ddoc001")
ddoc["language"] = "query"
with self.assertRaises(CloudantException) as cm:
ddoc.add_view("view001", {"foo": "bar"})
err = cm.exception
self.assertEqual(str(err), "Cannot add a MapReduce view to a " "design document for query indexes.")
def updateViews(symptoms_db, covidsafe_db, covid_db):
# Update Views
ddoc_symptoms = DesignDocument(symptoms_db, 'symptoms')
view = View(ddoc_symptoms, 'symptoms_location')
covidsafe_ddoc = DesignDocument(covidsafe_db, 'covidsafe')
view = View(covidsafe_ddoc, 'symptoms_location')
covid_ddoc = DesignDocument(covid_db, 'covid')
view = View(covid_ddoc, 'symptoms_location')
def get_transactions(self, page, pagesize):
print("Portfolio.get_transactions()")
skip = page * pagesize
ddoc = DesignDocument(self.db, 'transactions')
ddoc.fetch()
view = View(ddoc, 'history')
return view(include_docs=False,
limit=pagesize,
skip=skip,
reduce=False)['rows']
def test_create_non_partitioned_design_document(self):
ddoc_id = 'empty_ddoc'
ddoc = DesignDocument(self.db, ddoc_id, partitioned=False)
ddoc.save()
r = self.db.r_session.get(ddoc.document_url)
r.raise_for_status()
self.assertFalse(r.json()['options']['partitioned'])
def test_update_non_existing_view(self):
"""
Test that updating a non-existing view fails as expected.
"""
ddoc = DesignDocument(self.db, "_design/ddoc001")
try:
ddoc.update_view("view001", "function (doc) {\n emit(doc._id, 1);\n}")
self.fail("Above statement should raise an Exception")
except CloudantArgumentError as err:
self.assertEqual(str(err), "View view001 does not exist in this design doc")
def test_view_callable_with_invalid_javascript(self):
"""
Test error condition when Javascript errors exist. This test is only
valid for CouchDB because the map function Javascript is validated on
the Cloudant server when attempting to save a design document so invalid
Javascript is not possible there.
"""
self.populate_db_with_documents()
ddoc = DesignDocument(self.db, 'ddoc001')
ddoc.add_view(
'view001',
'This is not valid Javascript'
)
ddoc.save()
# Verify that the ddoc and view were saved remotely
# along with the invalid Javascript
del ddoc
ddoc = DesignDocument(self.db, 'ddoc001')
ddoc.fetch()
view = ddoc.get_view('view001')
self.assertEqual(view.map, 'This is not valid Javascript')
try:
for row in view.result:
self.fail('Above statement should raise an Exception')
except requests.HTTPError as err:
self.assertEqual(err.response.status_code, 500)
def test_deleting_non_existing_index(self):
"""
Tests how deleting a non-existing index is handled.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
index = Index(self.db, 'ddoc001', 'index001', fields=['name', 'age'])
self.assertFalse(ddoc.exists())
with self.assertRaises(requests.HTTPError) as cm:
index.delete()
err = cm.exception
self.assertEqual(err.response.status_code, 404)
def test_existing_ddoc_add_view(self):
mock_database = mock.Mock()
ddoc = DesignDocument(mock_database, '_design/unittest')
ddoc['views'] = {
'view1': {'map': "MAP", 'reduce': 'REDUCE'}
}
ddoc.add_view('view2', "MAP2")
self.assertIn('view1', ddoc['views'])
self.assertIn('view2', ddoc['views'])
self.assertEqual(ddoc['views']['view2'].map, 'MAP2')
self.assertEqual(ddoc['views']['view2'].reduce, None)
def test_deleting_index(self):
"""
Test that deleting an index works as expected.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
self.assertFalse(ddoc.exists())
index = Index(self.db, 'ddoc001', 'index001', fields=['name', 'age'])
index.create()
self.assertTrue(ddoc.exists())
index.delete()
self.assertFalse(ddoc.exists())
def test_deleting_non_existing_index(self):
"""
Tests how deleting a non-existing index is handled.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
index = Index(self.db, 'ddoc001', 'index001', fields=['name', 'age'])
self.assertFalse(ddoc.exists())
with self.assertRaises(requests.HTTPError) as cm:
index.delete()
err = cm.exception
self.assertEqual(err.response.status_code, 404)
def test_deleting_index(self):
"""
Test that deleting an index works as expected.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
self.assertFalse(ddoc.exists())
index = Index(self.db, 'ddoc001', 'index001', fields=['name', 'age'])
index.create()
self.assertTrue(ddoc.exists())
index.delete()
self.assertFalse(ddoc.exists())
def test_get_info(self):
"""
Test that the appropriate "not implemented" exception is raised
when attempting to execute the .info() method
"""
ddoc = DesignDocument(self.db, "_design/ddoc001")
try:
ddoc.info()
self.fail("Above statement should raise an Exception")
except NotImplementedError as err:
self.assertEqual(str(err), "_info not yet implemented")
def test_mr_view_save_succeeds(self):
"""
Tests that save succeeds when no language is specified and views are map
reduce views.
"""
ddoc = DesignDocument(self.db, "_design/ddoc001")
view_map = "function (doc) {\n emit(doc._id, 1);\n}"
view_reduce = "_count"
db_copy = "{0}-copy".format(self.db.database_name)
ddoc.add_view("view001", view_map, view_reduce, dbcopy=db_copy)
ddoc.save()
self.assertTrue(ddoc["_rev"].startswith("1-"))
def test_setting_id(self):
"""
Ensure when setting the design document id that it is
prefaced by '_design/'
"""
ddoc = DesignDocument(self.db)
ddoc["_id"] = "ddoc001"
self.assertEqual(ddoc["_id"], "_design/ddoc001")
del ddoc["_id"]
self.assertIsNone(ddoc.get("_id"))
ddoc["_id"] = "_design/ddoc002"
self.assertEqual(ddoc["_id"], "_design/ddoc002")
def test_mr_view_save_succeeds(self):
"""
Tests that save succeeds when no language is specified and views are map
reduce views.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
view_map = 'function (doc) {\n emit(doc._id, 1);\n}'
view_reduce = '_count'
db_copy = '{0}-copy'.format(self.db.database_name)
ddoc.add_view('view001', view_map, view_reduce, dbcopy=db_copy)
ddoc.save()
self.assertTrue(ddoc['_rev'].startswith('1-'))
def raw_view(self, view_path, params):
params = deepcopy(params)
params.pop('dynamic_properties', None)
if view_path == '_all_docs':
return self.cloudant_database.all_docs(**params)
else:
view_path = view_path.split('/')
assert len(view_path) == 4
ddoc = DesignDocument(self.cloudant_database, view_path[1])
ddoc.fetch()
view = ddoc.get_view(view_path[3])
return view(**params)
def test_setting_id(self):
"""
Ensure when setting the design document id that it is
prefaced by '_design/'
"""
ddoc = DesignDocument(self.db)
ddoc['_id'] = 'ddoc001'
self.assertEqual(ddoc['_id'], '_design/ddoc001')
del ddoc['_id']
self.assertIsNone(ddoc.get('_id'))
ddoc['_id'] = '_design/ddoc002'
self.assertEqual(ddoc['_id'], '_design/ddoc002')
def test_search_index_save_succeeds(self):
"""
Tests that save succeeds when no language is specified for search
indexes.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
search_index = ('function (doc) {\n index("default", doc._id); '
'if (doc._id) {index("name", doc.name, '
'{"store": true}); }\n}')
ddoc.add_search_index('search001', search_index)
ddoc.save()
self.assertTrue(ddoc['_rev'].startswith('1-'))
def test_deleting_index_without_index_name(self):
"""
Tests that deleting an index without an index name provided fails as
expected.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
index = Index(self.db, 'ddoc001', fields=['name', 'age'])
self.assertFalse(ddoc.exists())
with self.assertRaises(CloudantArgumentError) as cm:
index.delete()
err = cm.exception
self.assertEqual(
str(err), 'Deleting an index requires an index name be provided.')
def test_ddoc_delete_view(self):
mock_database = mock.Mock()
ddoc = DesignDocument(mock_database, '_design/unittest')
ddoc.add_view('view1', "MAP", "REDUCE")
ddoc.add_view('view2', "MAP", "REDUCE")
self.assertIn('view1', ddoc['views'])
self.assertIn('view2', ddoc['views'])
ddoc.delete_view('view2')
self.assertIn('view1', ddoc['views'])
self.assertNotIn('view2', ddoc['views'])
self.assertEqual(ddoc['views']['view1'].map, 'MAP')
self.assertEqual(ddoc['views']['view1'].reduce, 'REDUCE')
def create_search_index(self):
"""
Create a design document with search indexes for use
with search query tests.
"""
self.search_ddoc = DesignDocument(self.db, 'searchddoc001')
self.search_ddoc['indexes'] = {'searchindex001': {
'index': 'function (doc) {\n index("default", doc._id); \n '
'if (doc.name) {\n index("name", doc.name, {"store": true}); \n} '
'if (doc.age) {\n index("age", doc.age, {"facet": true}); \n} \n} '
}
}
self.search_ddoc.save()
def test_create_unpartitioned_query_index(self):
"""
Test that create_query_index works on an unpartitioned database
"""
ddoc = DesignDocument(self.db,
document_id="unpartitioned_query_index_ddoc")
ddoc["language"] = "query"
ddoc.save()
index = self.db.create_query_index(
design_document_id="_design/unpartitioned_query_index_ddoc",
fields=["key"],
partitioned=False)
index.create()
self.assertGreater(len(self.db.get_query_indexes()), 0)
def create_db_sentiments(conn):
""" Make "sentiments" database """
logging.info('Creating database "sentiments"...')
db_sentiments = conn.create_database('sentiments')
logging.info('Done creating database.')
# create summary view
logging.info('Creating views in database "sentiments"...')
summary_ddoc = DesignDocument(db_sentiments, document_id='summary')
with open('db/sentiments/summary.design.json') as f:
ddoc_spec = json.load(f)
for view_spec in ddoc_spec['views']:
fns = ddoc_spec['views'][view_spec]
map_fn = fns['map']
if 'reduce' in fns:
reduce_fn = fns['reduce']
summary_ddoc.add_view(view_spec, map_fn, reduce_fn)
else:
summary_ddoc.add_view(view_spec, map_fn)
summary_ddoc.create()
logging.info('Finished creating views.')
def test_adding_query_index_view(self):
"""
Test that adding a query index view fails as expected.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
ddoc['language'] = 'query'
with self.assertRaises(CloudantException) as cm:
ddoc.add_view('view001', {'foo': 'bar'})
err = cm.exception
self.assertEqual(
str(err),
'Cannot add a MapReduce view to a '
'design document for query indexes.'
)
def test_deleting_index_without_index_name(self):
"""
Tests that deleting an index without an index name provided fails as
expected.
"""
ddoc = DesignDocument(self.db, '_design/ddoc001')
index = Index(self.db, 'ddoc001', fields=['name', 'age'])
self.assertFalse(ddoc.exists())
with self.assertRaises(CloudantArgumentError) as cm:
index.delete()
err = cm.exception
self.assertEqual(
str(err),
'Deleting an index requires an index name be provided.'
)
def read_only_except_admin(database, database_name: str):
"""
A variation of this
https://gist.github.com/ThibaultJanBeyer/389bca37f4b6973b84908895300bb7de
"""
try:
design_doc = DesignDocument(database=database,
document_id="_design/auth")
design_doc[
"validate_doc_update"] = "function(newDoc, oldDoc, userCtx, secObj) { if (userCtx.roles.indexOf('admin') !== -1 || userCtx.name==='admin') { return; } else { throw ({ forbidden: 'Only admins may edit this database' }); } }"
design_doc.save()
except:
print(f"A design document for {database_name} already exists.")
def test_create_an_index_using_design_prefix(self):
"""
Test that a JSON index is created correctly in the remote database when
the ddoc id is already prefixed by '_design/'
"""
index = Index(self.db,
'_design/ddoc001',
'index001',
fields=['name', 'age'])
index.create()
self.assertEqual(index.design_document_id, '_design/ddoc001')
self.assertEqual(index.name, 'index001')
with DesignDocument(self.db, index.design_document_id) as ddoc:
self.assertIsInstance(ddoc.get_view(index.name), QueryIndexView)
self.assertEquals(ddoc['_id'], index.design_document_id)
self.assertTrue(ddoc['_rev'].startswith('1-'))
self.assertEquals(ddoc['indexes'], {})
self.assertEquals(ddoc['language'], 'query')
self.assertEquals(ddoc['lists'], {})
self.assertEquals(ddoc['shows'], {})
self.assertListEqual(list(ddoc['views'].keys()), [index.name])
view = ddoc['views'][index.name]
self.assertEquals(view['map']['fields']['age'], 'asc')
self.assertEquals(view['map']['fields']['name'], 'asc')
self.assertEquals(view['options']['def']['fields'],
['name', 'age'])
self.assertEquals(view['reduce'], '_count')
def test_create_an_index_with_empty_ddoc_index_name(self):
"""
Test that a JSON index is created in the remote database.
"""
index = Index(self.db, '', '', fields=['name', 'age'])
index.create()
self.assertIsNotNone(index.design_document_id)
self.assertTrue(index.design_document_id.startswith('_design/'))
self.assertIsNotNone(index.name)
with DesignDocument(self.db, index.design_document_id) as ddoc:
self.assertIsInstance(ddoc.get_view(index.name), QueryIndexView)
self.assertEquals(ddoc['_id'], index.design_document_id)
self.assertTrue(ddoc['_rev'].startswith('1-'))
self.assertEquals(ddoc['indexes'], {})
self.assertEquals(ddoc['language'], 'query')
self.assertEquals(ddoc['lists'], {})
self.assertEquals(ddoc['shows'], {})
self.assertListEqual(list(ddoc['views'].keys()), [index.name])
view = ddoc['views'][index.name]
self.assertEquals(view['map']['fields']['age'], 'asc')
self.assertEquals(view['map']['fields']['name'], 'asc')
self.assertEquals(view['options']['def']['fields'],
['name', 'age'])
self.assertEquals(view['reduce'], '_count')
def test_create_an_index_with_empty_ddoc_index_name(self):
"""
Test that a JSON index is created in the remote database.
"""
index = Index(self.db, '', '', fields=['name', 'age'])
index.create()
self.assertIsNotNone(index.design_document_id)
self.assertTrue(index.design_document_id.startswith('_design/'))
self.assertIsNotNone(index.name)
with DesignDocument(self.db, index.design_document_id) as ddoc:
self.assertEqual(ddoc['language'], 'query')
self.assertListEqual(list(ddoc['views'].keys()), [index.name])
self.assertIsInstance(ddoc.get_view(index.name), QueryIndexView)
self.assertTrue(ddoc['_rev'].startswith('1-'))
self.assertEqual(ddoc,
{'_id': index.design_document_id,
'_rev': ddoc['_rev'],
'indexes': {},
'language': 'query',
'views': {index.name: {'map': {'fields': {'name': 'asc',
'age': 'asc'}},
'reduce': '_count',
'options': {'def': {'fields': ['name',
'age']},
}}},
'lists': {},
'shows': {}
}
)
def test_create_a_search_index_no_kwargs(self):
"""
Test that a TEXT index is created in the remote database.
"""
index = TextIndex(self.db, 'ddoc001', 'index001')
index.create()
self.assertEqual(index.design_document_id, '_design/ddoc001')
self.assertEqual(index.name, 'index001')
with DesignDocument(self.db, index.design_document_id) as ddoc:
self.assertEqual(ddoc['language'], 'query')
self.assertListEqual(list(ddoc['indexes'].keys()), ['index001'])
self.assertTrue(ddoc['_rev'].startswith('1-'))
self.assertEqual(ddoc,
{'_id': '_design/ddoc001',
'_rev': ddoc['_rev'],
'language': 'query',
'views': {},
'indexes': {'index001':
{'index': {'index_array_lengths': True,
'fields': 'all_fields',
'default_field': {},
'default_analyzer': 'keyword',
'selector': {}},
'analyzer': {'name': 'perfield',
'default': 'keyword',
'fields': {'$default': 'standard'}}}},
'lists': {},
'shows': {}
}
)
def getDocumentRangeKey(self, design, view, is_desc=True, start_key="", end_key="", limit=False ):
global mydb
view_connect = View(DesignDocument(mydb,document_id=design),view)
if limit:
return view_connect(descending=is_desc, startkey=start_key, endkey=end_key, limit=limit)['rows']
else:
return view_connect(descending=is_desc, startkey=start_key, endkey=end_key)['rows']
def _access_covidsafe_nums():
client = CouchDB("admin",
"password",
url='http://172.26.131.173:5984',
connect=True)
session = client.session()
db = client['tweet-covid-covidsafe']
#Connect a designdocument name covid
ddoc = DesignDocument(db, 'covidsafe')
total = 0
view = View(ddoc, 'sentiment_location', partition_key='name')
for i in view(reduce=True, group=True, group_level=1)['rows']:
#print(i['value'])
total = total + i['value']
view = View(ddoc, 'sentiment_location', partition_key='geo')
for i in view(reduce=True, group=True, group_level=1)['rows']:
#print(i['value'])
total = total + i['value']
view = View(ddoc, 'sentiment_location', partition_key='none')
for i in view(reduce=True, group=True, group_level=1)['rows']:
#print(i['value'])
total = total + i['value']
return total
def test_constructor(self):
"""
Test instantiating a View
"""
ddoc = DesignDocument(self.db, 'ddoc001')
view = View(ddoc,
'view001',
'function (doc) {\n emit(doc._id, 1);\n}',
'_count',
dbcopy='{0}-copy'.format(self.db.database_name))
self.assertEqual(view.design_doc, ddoc)
self.assertEqual(view.view_name, 'view001')
self.assertIsInstance(view['map'], _Code)
self.assertEqual(view['map'],
'function (doc) {\n emit(doc._id, 1);\n}')
self.assertIsInstance(view['reduce'], _Code)
self.assertEqual(view['reduce'], '_count')
self.assertEqual(view['dbcopy'],
'{0}-copy'.format(self.db.database_name))
self.assertEqual(
view, {
'map': 'function (doc) {\n emit(doc._id, 1);\n}',
'reduce': '_count',
'dbcopy': '{0}-copy'.format(self.db.database_name)
})
def test_create_a_search_index_no_kwargs(self):
"""
Test that a TEXT index is created in the remote database.
"""
index = TextIndex(self.db, 'ddoc001', 'index001')
index.create()
self.assertEqual(index.design_document_id, '_design/ddoc001')
self.assertEqual(index.name, 'index001')
with DesignDocument(self.db, index.design_document_id) as ddoc:
self.assertEquals(ddoc['_id'], index.design_document_id)
self.assertTrue(ddoc['_rev'].startswith('1-'))
self.assertEquals(ddoc['language'], 'query')
self.assertEquals(ddoc['lists'], {})
self.assertEquals(ddoc['shows'], {})
self.assertEquals(ddoc['views'], {})
index = ddoc['indexes']['index001']
self.assertEquals(index['analyzer']['default'], 'keyword')
self.assertEquals(index['analyzer']['fields']['$default'],
'standard')
self.assertEquals(index['analyzer']['name'], 'perfield')
self.assertEquals(index['index']['default_analyzer'], 'keyword')
self.assertEquals(index['index']['default_field'], {})
self.assertEquals(index['index']['fields'], 'all_fields')
self.assertEquals(index['index']['selector'], {})
self.assertTrue(index['index']['index_array_lengths'])
def view_covid(name, partition_key="", area_col="area_code", var_col="variable", val_col="count", reduce=True,
group=True, group_level=2,
docid="", dbname="",
ip="", username="******", password="******", port=5984, connect=True):
"""
View database
"""
url = f"http://{ip}:{port}"
client = CouchDB(username, password, url=url, connect=connect)
db = client[dbname] # database
ddoc = DesignDocument(db, docid)
# View
view = View(ddoc, name, partition_key=partition_key)
area_codes = []
variables = []
counts = []
for row in view(reduce=reduce, group=group, group_level=group_level)['rows']:
var, code = row["key"] # variable, area code
variables.append(var)
area_codes.append(code)
counts.append(row["value"])
# Data
data = pd.DataFrame(
{area_col: map(str, area_codes), var_col: variables, val_col: counts}) # area code in geo-map string stype
return data
def test_create_a_search_index_with_kwargs(self):
"""
Test that a TEXT index is created in the remote database.
"""
index = TextIndex(
self.db,
'ddoc001',
'index001',
fields=[{'name': 'name', 'type':'string'},
{'name': 'age', 'type':'number'}],
selector={},
default_field={'enabled': True, 'analyzer': 'german'})
index.create()
self.assertEqual(index.design_document_id, '_design/ddoc001')
self.assertEqual(index.name, 'index001')
with DesignDocument(self.db, index.design_document_id) as ddoc:
self.assertEquals(ddoc['_id'], index.design_document_id)
self.assertTrue(ddoc['_rev'].startswith('1-'))
self.assertEquals(ddoc['language'], 'query')
self.assertEquals(ddoc['lists'], {})
self.assertEquals(ddoc['shows'], {})
self.assertEquals(ddoc['views'], {})
index = ddoc['indexes']['index001']
self.assertEquals(index['analyzer']['default'], 'keyword')
self.assertEquals(index['analyzer']['fields']['$default'], 'german')
self.assertEquals(index['analyzer']['name'], 'perfield')
self.assertEquals(index['index']['default_analyzer'], 'keyword')
self.assertEquals(index['index']['default_field']['analyzer'], 'german')
self.assertEquals(index['index']['fields'], [{'name': 'name', 'type': 'string'}, {'name': 'age', 'type': 'number'}])
self.assertEquals(index['index']['selector'], {})
self.assertTrue(index['index']['default_field']['enabled'])
self.assertTrue(index['index']['index_array_lengths'])
def test_retrieve_view_url(self):
"""
Test the retrieval of the View url
"""
ddoc = DesignDocument(self.db, 'ddoc001')
view = View(ddoc, 'view001')
self.assertEqual(view.url, '/'.join(
(ddoc.document_url, '_view/view001')))
def test_reduce_setter(self):
"""
Test that the reduce setter works
"""
ddoc = DesignDocument(self.db, 'ddoc001')
view = View(ddoc, 'view001')
self.assertIsNone(view.get('reduce'))
view.reduce = '_count'
self.assertEqual(view.get('reduce'), '_count')
def test_get_feed_using_filter(self):
"""
Test getting content back for a feed using filter
"""
self.populate_db_with_documents(6)
ddoc = DesignDocument(self.db, '_design/ddoc001')
ddoc['filters'] = {
'even_docs': 'function(doc, req){if (doc.age % 2 != 0){return false;} return true;}'
}
ddoc.create()
feed = Feed(self.db, filter='ddoc001/even_docs')
changes = list()
for change in feed:
self.assertSetEqual(set(change.keys()), set(['seq', 'changes', 'id']))
changes.append(change)
expected = set(['julia000', 'julia002', 'julia004'])
self.assertSetEqual(set([x['id'] for x in changes]), expected)
self.assertTrue(str(feed.last_seq).startswith('7'))
def test_reduce_getter(self):
"""
Test that the reduce getter works
"""
ddoc = DesignDocument(self.db, 'ddoc001')
view = View(ddoc, 'view001')
self.assertIsNone(view.reduce)
view.reduce = '_count'
self.assertIsInstance(view.reduce, _Code)
self.assertEqual(view.reduce, '_count')
def test_map_getter(self):
"""
Test that the map getter works
"""
ddoc = DesignDocument(self.db, 'ddoc001')
view = View(ddoc, 'view001')
self.assertIsNone(view.map)
view.map = 'function (doc) {\n emit(doc._id, 1);\n}'
self.assertIsInstance(view.map, _Code)
self.assertEqual(view.map, 'function (doc) {\n emit(doc._id, 1);\n}')
def test_map_setter(self):
"""
Test that the map setter works
"""
ddoc = DesignDocument(self.db, 'ddoc001')
view = View(ddoc, 'view001')
self.assertIsNone(view.get('map'))
view.map = 'function (doc) {\n emit(doc._id, 1);\n}'
self.assertEqual(view.get('map'),
'function (doc) {\n emit(doc._id, 1);\n}')
def getDocumentByKey(self, design, view, key=False, is_desc=True, limit=False):
global mydb
view_connect = View(DesignDocument(mydb,document_id=design),view)
if key:
if limit:
return view_connect(descending=is_desc, key=key, limit=limit)['rows']
else:
return view_connect(descending=is_desc, key=key)['rows']
else:
return view_connect(descending=is_desc)['rows']
