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_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']