def setUp(self): disconnect() # try docker mongo host = settings._MONGODB_DATABASE_STR \ % (settings._MONGODB_HOST, self.mongodb_name) connect(self.mongodb_name, host=host) self.__test_id=0
def _post_teardown(self): from mongoengine.connection import get_connection, disconnect for db_name, db_alias in settings.MONGO_DATABASES.items(): connection = get_connection(db_alias) connection.drop_database(db_name) disconnect(db_alias) super(MongoTestCase, self)._post_teardown()
def __init__(self, method_name='runtest'): disconnect() db_name = 'test_%s' % settings.MONGOENGINE['db'] self.database = connect(db_name)[db_name] super(MongoTestCase, self).__init__(method_name)
def setup_databases(self, **kwargs): from mongoengine.connection import connect, disconnect for db_name, db_alias in settings.MONGO_DATABASES.items(): disconnect(db_alias) connect(db_name, port=settings.MONGO_PORT) print 'Creating mongo test database ' + db_name return super(MongoTestRunner, self).setup_databases(**kwargs)
def teardown_databases(self, *args, **kwargs): for alias, params in self._iter_test_databases(): connection = get_connection(alias) print("Dropping test database for alias '%s': %s" % (alias, params['name'])) connection.drop_database(params['name']) disconnect(alias) return super(TestRunner, self).teardown_databases(*args, **kwargs)
def test_connect_disconnect_works_on_same_document(self): """Ensure that the connect/disconnect works properly with a single Document""" db1 = 'db1' db2 = 'db2' # Ensure freshness of the 2 databases through pymongo client = MongoClient('localhost', 27017) client.drop_database(db1) client.drop_database(db2) # Save in db1 connect(db1) class User(Document): name = StringField(required=True) user1 = User(name='John is in db1').save() disconnect() # Make sure save doesnt work at this stage with self.assertRaises(MongoEngineConnectionError): User(name='Wont work').save() # Save in db2 connect(db2) user2 = User(name='Bob is in db2').save() disconnect() db1_users = list(client[db1].user.find()) self.assertEqual(db1_users, [{'_id': user1.id, 'name': 'John is in db1'}]) db2_users = list(client[db2].user.find()) self.assertEqual(db2_users, [{'_id': user2.id, 'name': 'Bob is in db2'}])
def teardown_databases(self, old_config, **kwargs): from mongoengine.connection import get_connection, disconnect connection = get_connection() connection.drop_database(self.mongodb_name) print 'Dropping mongo test database: ' + self.mongodb_name disconnect() super(MongoTestRunner, self).teardown_databases(old_config, **kwargs)
def setUp(self): if os.environ.get('KARDBOARD_SETTINGS'): os.environ['KARDBOARD_SETTINGS'] = '' from kardboard import default_settings default_settings.TEMPLATE_DEBUG = True from kardboard.views import app from flask.ext.mongoengine import MongoEngine from kardboard.util import now delattr(app, 'db') from mongoengine.connection import connect, disconnect disconnect() app.config.from_object('kardboard.default_settings') app.config['MONGODB_DB'] = 'kardboard_unittest' app.config['TESTING'] = True app.config['CELERY_ALWAYS_EAGER'] = True connect(app.config['MONGODB_DB']) app.db = MongoEngine(app) self.config = app.config self.app = app.test_client() self.flask_app = app self.used_keys = [] self._setup_logging() self.now = now super(KardboardTestCase, self).setUp()
def setup_databases(self, **kwargs): #db_name = super(MongoTestRunner,self).setup_databases(**kwargs) disconnect() connect(self.mongo_name) print 'MongoTestRunner: setup %s' % (self.mongo_name) #return db_name return
def teardown_databases(self, old_config, **kwargs): from mongoengine.connection import get_connection, disconnect for db_name, db_alias in settings.MONGO_DATABASES.items(): connection = get_connection(db_alias) connection.drop_database(db_name) print 'Dropping mongo test database: ' + db_name disconnect(db_alias) super(MongoTestRunner, self).teardown_databases(old_config, **kwargs)
def _pre_setup(self): from mongoengine.connection import connect, disconnect, get_connection for db_name, db_alias in settings.MONGO_DATABASES.items(): connection = get_connection(db_alias) connection.drop_database(db_name) disconnect(db_alias) connect(db_name, port=settings.MONGO_PORT) super(MongoTestCase, self)._pre_setup()
def connect_db(db_alias): disconnect('default') # Hack to avoid mongoengine caching connection User._collection = None Handin._collection = None return connect(test_db_name(db_alias))
def _pre_setup(self): from mongoengine.connection import connect, disconnect disconnect() import urllib, os pwd = urllib.quote_plus(os.environ['MONGODB_PWD']) uri = "mongodb://" + os.environ['MONGODB_USR'] + ":" + pwd + "@127.0.0.1/" + self.mongodb_name + "?authMechanism=SCRAM-SHA-1" connect(self.mongodb_name, host=uri) super(SearchappTest, self)._pre_setup()
def _post_teardown(self): from mongoengine.connection import get_db, disconnect database = get_db() for collection in database.collection_names(): if collection == 'system.indexes' or collection == 'english_words': continue database.drop_collection(collection) disconnect() super(MongoTestCase, self)._post_teardown()
def setup_databases(self, **kwangs): global _running_test _running_test = True disconnect() connect(MONGO_DB) print 'Creating test-database: ' + MONGO_DB print 'restoring default data' call(["mongorestore", "--db", MONGO_DB, DUMP_DIR]) return MONGO_DB
def setUpClass(self): from app import config self.app = start_app(config.Test) # connect to the test db from mongoengine.connection import connect, disconnect, get_connection disconnect() from app.database import Database self.db = Database(app=self.app)
def drop_database_and_reconnect(self, reconnect=True): disconnect() self.db.drop_database(self.db_name) # Mongoengine sometimes doesn't recreate unique indexes # in between test runs, adding the below 'reset' to fix this # https://github.com/hmarr/mongoengine/issues/422 QuerySet._reset_already_indexed() if reconnect: self.db = connect(self.db_name)
def _pre_setup(self): super(MongoTestCase, self)._pre_setup() disconnect() db_name = 'test_%s' % settings.MONGOENGINE['db'] self._database = connect( # pylint: disable=attribute-defined-outside-init db_name, tz_aware=settings.USE_TZ )[db_name]
def __init__(self): try: host = get_config_value("MONGO", "host") port = int(get_config_value("MONGO", "port")) name = get_config_value("MONGO", "name") disconnect() connect(db=name, host=host, port=port) self.conn = get_connection() except: logger.error('Connection to MongoDB could not be established.')
def save_article_result_with_queue(queue): disconnect() lazy_connect() while 1: try: article = queue.get(timeout=1) except Empty: break save_article_result(article, queue) queue.task_done()
def _post_teardown(self): """ Function: _post_teardown -------------------- Automatically called after any test for dropping the DB and disconnecting from MongoDB. """ from mongoengine.connection import get_connection, disconnect connection = get_connection() connection.drop_database(self.mongodb_name) disconnect() super(B2noteappTest, self)._post_teardown()
def reconnect(): """ Re-establish a connection to the mongo database """ global _CONNECTION, _DATABASE disconnect() _CONNECTION = None _DATABASE = None initialize()
def _pre_setup(self): if PY3: raise SkipTest('django does not have Python 3 support') from mongoengine.connection import connect, disconnect, get_connection for db_name, db_alias in settings.MONGO_DATABASES.items(): connection = get_connection(db_alias) connection.drop_database(db_name) disconnect(db_alias) connect(db_name, port=settings.MONGO_PORT) super(MongoTestCase, self)._pre_setup()
def _fixture_setup(self): from mongoengine.connection import connect, disconnect disconnect() connect(self.mongodb_name) from mongoengine.django.mongo_auth.models import MongoUser if MongoUser.objects.filter(username="******").count() == 0: MongoUser.objects.create_superuser("admin", "*****@*****.**", "admin") if MongoUser.objects.filter(username="******").count() == 0: MongoUser.objects.create_user("library_user", "*****@*****.**", "secret") setup_test_environment()
def _pre_setup(self): if PY3: raise SkipTest('django does not have Python 3 support') from mongoengine.connection import connect, disconnect, get_connection from neerbee.users.models import Bee for db_name, db_alias in settings.MONGO_DATABASES.items(): db_name = 'test_%s' % db_name connection = get_connection(db_alias) connection.drop_database(db_name) disconnect(db_alias) connect(db_name, port=settings.MONGO_PORT) Bee.create_user(username="******", email="*****@*****.**", password="******") super(MongoTestCase, self)._pre_setup()
def _pre_setup(self): """ Function: _pre_setup -------------------- Automatically called before any test for connecting to MongoDB. """ from mongoengine.connection import connect, disconnect disconnect() import urllib, os pwd = urllib.quote_plus(os.environ['MONGODB_PWD']) uri = "mongodb://" + os.environ['MONGODB_USR'] + ":" + pwd + "@127.0.0.1/" + self.mongodb_name + "?authMechanism=SCRAM-SHA-1" connect(self.mongodb_name, host=uri) super(B2noteappTest, self)._pre_setup()
def setUp(self): self.app = application.app bcrypt = Bcrypt(self.app) # forcibly reconnect to testing db connection.disconnect() self.app.config['MONGO_CONFIG']['db_name'] = 'pipeline_testing' self.connection = connect( self.app.config['MONGO_CONFIG']['db_name'] , host=self.app.config['MONGO_CONFIG']['host'] , port=int(self.app.config['MONGO_CONFIG']['port']) ) # drop any lingering test dbs self.connection.drop_database( self.app.config['MONGO_CONFIG']['db_name']) member_user = User( admin_rights = False , email = '*****@*****.**' , email_confirmation_code = 'goodday' , email_confirmed = True , last_login_time = datetime.datetime.utcnow() , password_hash = bcrypt.generate_password_hash('hola!') , registration_time = datetime.datetime.utcnow() , verified = True) member_user.save() ''' create a test org ''' test_org = Organization( label = 'best-org' , name = 'best org') test_org.save() # save membership member_user.update(push__organizations = test_org) ''' create a test project ''' test_project = Project( creation_time = datetime.datetime.utcnow() , label = 'best-project' , name = 'best project' , organization = test_org) test_project.save() test_org.update(push__projects=test_project) ''' create a data-less upload ''' '''
def setUp(self): disconnect() settings.MONGODB = connect('test_newsblur') settings.REDIS_STORY_HASH_POOL = redis.ConnectionPool(host=settings.REDIS_STORY['host'], port=6379, db=10) settings.REDIS_FEED_READ_POOL = redis.ConnectionPool(host=settings.SESSION_REDIS_HOST, port=6379, db=10) r = redis.Redis(connection_pool=settings.REDIS_STORY_HASH_POOL) r.delete('RS:1') r.delete('lRS:1') r.delete('RS:1:766') r.delete('zF:766') r.delete('F:766') self.client = Client()
def teardown_databases(self, old_config, **kwargs): from mongoengine.connection import get_connection, disconnect disconnect() # Removes the MongoDB database connection = get_connection() connection.drop_database(self.mongodb_name) print 'Dropping MongoDB test database, name: ' + self.mongodb_name # Removes ElasticSearch index conn = pyes.ES(settings.ES_SERVERS, basic_auth=settings.ES_AUTH) try: conn.indices.delete_index(settings.TENANT.slug) print 'Successfully removed elasticsearch index {0}'.format(settings.TENANT.slug) except: print 'elasticsearch index {0} can\'t be removed'.format(settings.TENANT.slug) super(VosaeTestRunner, self).teardown_databases(old_config, **kwargs)
def _post_teardown(self): for collection in self._database.collection_names(): if collection == 'system.indexes': # pragma: no cover continue self._database.drop_collection(collection) # Mongoengine models need to forget about their collection (to recreate indexes). Hackish, I know. # FIXME: __subclasses__ may only take direct descendants into account! for model in Document.__subclasses__(): if hasattr(model, '_collection'): del model._collection disconnect() super(MongoTestCase, self)._post_teardown()
def test_disconnect_cleans_globals(self): """Ensure that the disconnect() method cleans the globals objects""" connections = mongoengine.connection._connections dbs = mongoengine.connection._dbs connection_settings = mongoengine.connection._connection_settings connect("mongoenginetest") assert len(connections) == 1 assert len(dbs) == 0 assert len(connection_settings) == 1 class TestDoc(Document): pass TestDoc.drop_collection() # triggers the db assert len(dbs) == 1 disconnect() assert len(connections) == 0 assert len(dbs) == 0 assert len(connection_settings) == 0
def test_connect_disconnect_works_on_same_document(self): """Ensure that the connect/disconnect works properly with a single Document""" db1 = 'db1' db2 = 'db2' # Ensure freshness of the 2 databases through pymongo client = MongoClient('localhost', 27017) client.drop_database(db1) client.drop_database(db2) # Save in db1 connect(db1) class User(Document): name = StringField(required=True) user1 = User(name='John is in db1').save() disconnect() # Make sure save doesnt work at this stage with self.assertRaises(MongoEngineConnectionError): User(name='Wont work').save() # Save in db2 connect(db2) user2 = User(name='Bob is in db2').save() disconnect() db1_users = list(client[db1].user.find()) self.assertEqual(db1_users, [{ '_id': user1.id, 'name': 'John is in db1' }]) db2_users = list(client[db2].user.find()) self.assertEqual(db2_users, [{ '_id': user2.id, 'name': 'Bob is in db2' }])
def test_connect_disconnect_works_on_same_document(self): """Ensure that the connect/disconnect works properly with a single Document""" db1 = "db1" db2 = "db2" # Ensure freshness of the 2 databases through pymongo client = MongoClient("localhost", 27017) client.drop_database(db1) client.drop_database(db2) # Save in db1 connect(db1) class User(Document): name = StringField(required=True) user1 = User(name="John is in db1").save() disconnect() # Make sure save doesnt work at this stage with self.assertRaises(ConnectionFailure): User(name="Wont work").save() # Save in db2 connect(db2) user2 = User(name="Bob is in db2").save() disconnect() db1_users = list(client[db1].user.find()) self.assertEqual(db1_users, [{ "_id": user1.id, "name": "John is in db1" }]) db2_users = list(client[db2].user.find()) self.assertEqual(db2_users, [{ "_id": user2.id, "name": "Bob is in db2" }])
def test_disconnect_cleans_cached_collection_attribute_in_document(self): """Ensure that the disconnect() method works properly""" connect("mongoenginetest") class History(Document): pass assert History._collection is None History.drop_collection() History.objects.first( ) # will trigger the caching of _collection attribute assert History._collection is not None disconnect() assert History._collection is None with pytest.raises(ConnectionFailure) as exc_info: History.objects.first() assert "You have not defined a default connection" == str( exc_info.value)
def test_disconnect_cleans_cached_collection_attribute_in_document(self): """Ensure that the disconnect() method works properly""" conn1 = connect("mongoenginetest") class History(Document): pass self.assertIsNone(History._collection) History.drop_collection() History.objects.first() # will trigger the caching of _collection attribute self.assertIsNotNone(History._collection) disconnect() self.assertIsNone(History._collection) with self.assertRaises(ConnectionFailure) as ctx_err: History.objects.first() self.assertEqual( "You have not defined a default connection", str(ctx_err.exception) )
class ApiTestCase(TestCase): # Delete test database connection = get_connection() connection.drop_database('test') disconnect() # Define a test database @classmethod def setUpClass(cls): super(ApiTestCase, cls).setUpClass() s1 = Submission(10, 1, 'https://www.google.com', False, 'Google page', '13/01/2018') s1.save() s2 = Submission(1, 10, 'https://www.reddit.com/r/Python/subreddit', True, 'Reddit 1', '12/01/2018') s2.save() s3 = Submission(100, 11, 'https://www.maps.google.com', False, 'Google maps page', '11/01/2018') s3.save() s4 = Submission(90, 90, 'https://www.reddit.com/r/Python/subreddit', True, 'Reddit 2', '12/01/2018') s4.save() s5 = Submission(80, 100, 'https://www.maps.google.com', False, 'Google maps page', '11/01/2018') s5.save() s6 = Submission(6, 20, 'https://www.reddit.com/r/Python/subreddit', True, 'Reddit 3', '12/01/2018') s6.save() s7 = Submission(0, 30, 'https://www.maps.google.com', False, 'Google maps page', '11/01/2018') s7.save() s8 = Submission(0, 80, 'https://www.reddit.com/r/Python/subreddit', True, 'Reddit 4', '12/01/2018') s8.save() s9 = Submission(17, 9, 'https://www.maps.google.com', False, 'Google maps page', '11/01/2018') s9.save() s10 = Submission(28, 25, 'https://www.reddit.com/r/Python/subreddit', True, 'Reddit 5', '12/01/2018') s10.save() submission_u1 = [s1.id, s2.id] u1 = User(username="******", submissions=submission_u1) u1.save() submission_u2 = [s3.id, s4.id, s5.id, s6.id, s7.id, s8.id, s9.id, s10.id] u2 = User(username="******", submissions=submission_u2) u2.save() def test_get_submissions(self): """ Ensure connection with Submission collection """ submissions = Submission.objects self.assertEqual(10, submissions[0].punctuation) self.assertEqual(True, submissions[1].is_discussion) self.assertEqual('https://www.maps.google.com', submissions[2].url) def test_get_users(self): """ Ensure connection with User collection """ users = User.objects self.assertEqual('user1', users[0].username) self.assertEqual('user2', users[1].username) def test_api_top_points(self): """ Ensure API call of top points. """ url = 'http://127.0.0.1:8000/api/submissions/top/points/any/' response = self.client.get(url, format='json') json_response = json.loads(response.content) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(json_response[0]['punctuation'], 100) self.assertEqual(json_response[1]['punctuation'], 90) self.assertEqual(json_response[2]['punctuation'], 80) self.assertEqual(json_response[3]['punctuation'], 28) self.assertEqual(json_response[4]['punctuation'], 17) self.assertEqual(json_response[5]['punctuation'], 10) self.assertEqual(json_response[6]['punctuation'], 6) self.assertEqual(json_response[7]['punctuation'], 1) self.assertEqual(json_response[8]['punctuation'], 0) self.assertEqual(json_response[9]['punctuation'], 0) def test_api_top_points_discussions(self): """ Ensure API call of top points (only for discussions). """ url = 'http://127.0.0.1:8000/api/submissions/top/points/discussions/' response = self.client.get(url, format='json') json_response = json.loads(response.content) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(json_response[0]['punctuation'], 90) self.assertEqual(json_response[1]['punctuation'], 28) self.assertEqual(json_response[2]['punctuation'], 6) self.assertEqual(json_response[3]['punctuation'], 1) self.assertEqual(json_response[4]['punctuation'], 0) def test_api_top_points_articles(self): """ Ensure API call of top points (only for articles). """ url = 'http://127.0.0.1:8000/api/submissions/top/points/articles/' response = self.client.get(url, format='json') json_response = json.loads(response.content) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(json_response[0]['punctuation'], 100) self.assertEqual(json_response[1]['punctuation'], 80) self.assertEqual(json_response[2]['punctuation'], 17) self.assertEqual(json_response[3]['punctuation'], 10) self.assertEqual(json_response[4]['punctuation'], 0) def test_api_top_comments(self): """ Ensure API call of top discussed. """ url = 'http://127.0.0.1:8000/api/submissions/top/discussed/any/' response = self.client.get(url, format='json') json_response = json.loads(response.content) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(json_response[0]['number_comments'], 100) self.assertEqual(json_response[1]['number_comments'], 90) self.assertEqual(json_response[2]['number_comments'], 80) self.assertEqual(json_response[3]['number_comments'], 30) self.assertEqual(json_response[4]['number_comments'], 25) self.assertEqual(json_response[5]['number_comments'], 20) self.assertEqual(json_response[6]['number_comments'], 11) self.assertEqual(json_response[7]['number_comments'], 10) self.assertEqual(json_response[8]['number_comments'], 9) self.assertEqual(json_response[9]['number_comments'], 1) def test_api_top_comments_discussions(self): """ Ensure API call of top discussed (only for discussions). """ url = 'http://127.0.0.1:8000/api/submissions/top/discussed/discussions/' response = self.client.get(url, format='json') json_response = json.loads(response.content) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(json_response[0]['number_comments'], 90) self.assertEqual(json_response[1]['number_comments'], 80) self.assertEqual(json_response[2]['number_comments'], 25) self.assertEqual(json_response[3]['number_comments'], 20) self.assertEqual(json_response[4]['number_comments'], 10) def test_api_top_comments_articles(self): """ Ensure API call of top discussed (only for articles). """ url = 'http://127.0.0.1:8000/api/submissions/top/discussed/articles/' response = self.client.get(url, format='json') json_response = json.loads(response.content) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(json_response[0]['number_comments'], 100) self.assertEqual(json_response[1]['number_comments'], 30) self.assertEqual(json_response[2]['number_comments'], 11) self.assertEqual(json_response[3]['number_comments'], 9) self.assertEqual(json_response[4]['number_comments'], 1) def test_api_top_submitters(self): """ Ensure API call of top submitters. """ url = 'http://127.0.0.1:8000/api/users/top/submitters/' response = self.client.get(url, format='json') json_response = json.loads(response.content) self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(json_response[0]['numberOfSubmissions'], 8) self.assertEqual(json_response[1]['numberOfSubmissions'], 2)
def tearDown(self): unittest.TestCase.tearDown(self) delete_database() disconnect('omega')
def teardown_databases(self, *args): db_name = connection._connection_settings['default']['name'] connection.get_connection().drop_database(db_name) connection.disconnect()
from unittest import TestCase from mongoengine.connection import connect, disconnect from app.ieee.controller import Controller from app.models import Issue, Article disconnect('default') connect('ieee_crawler_test') class TestIssueCrawler(TestCase): def setUp(self): # IEEE Transactions on Smart Grid self.__crawler = Controller.get_journal(5165411).get_past_issue( 2016, 1) issue = Issue.objects.get(entry_number=self.__crawler.entry_number) for article in Article.objects.filter(issue_reference=issue): article.delete() for article in Article.objects.filter(entry_number='7399422'): article.delete() def test_crawl_article_numbers(self): numbers = self.__crawler.crawl_article_numbers() self.assertEqual(numbers, [ '7361793', '7361800', '7270336', '7307227', '7271086', '7323868', '7128404', '7061965', '7095603', '7112181', '7095589', '7055343', '7152979', '7100914', '7064776', '7055363', '7063233', '7175042', '7122362', '7115170', '7063969', '7115166', '7121016', '7108042', '7273948', '7163618', '7052382', '7172536', '7152969', '7091026', '7127028', '7112542', '7127033', '7110380', '7173055', '7244250', '7064771', '7130652', '7161386', '7361794', '7361792', '7361698', '7017584', '6987318', '6998860', '6999960', '7063250', '7017597',
from mongoengine import connect, connection from models.gansevoortreview import GansevoortReview from datetime import datetime from models.reviewrecency import ReviewRecency def parsedate(date): return datetime.strptime(date, '%B %d, %Y') def calculatereviewrecency(date): lastreviewdate = parsedate('November 21, 2018') firstreviewdate = parsedate('December 15, 2003') dm = (lastreviewdate - firstreviewdate).total_seconds() t = (datetime.now() - date).total_seconds() return exp(-t / dm) dbname = "data-mining" connect(dbname) ReviewRecency.drop_collection() for review in GansevoortReview.objects: reviewrecency = ReviewRecency(reviewId=review.id, value=calculatereviewrecency( parsedate(review.date))) reviewrecency.save() print(ReviewRecency.objects.count()) connection.disconnect(dbname)
def __exit__(self, *args): connection.disconnect() print("AmazingQuant Database Disconnect")
def test_disconnect_silently_pass_if_alias_does_not_exist(self): connections = mongoengine.connection._connections assert len(connections) == 0 disconnect(alias="not_exist")
def test_disconnect_silently_pass_if_alias_does_not_exist(self): connections = mongoengine.connection._connections self.assertEqual(len(connections), 0) disconnect(alias='not_exist')
def resetMongo(): disconnect() return "Maybe disconnected from Mongo"
def setup_databases(self, **kwargs): from mongoengine.connection import connect, disconnect disconnect() connect(self.mongodb_name, port=settings.MONGO_PORT) print 'Creating mongo test database ' + self.mongodb_name return super(MongoTestRunner, self).setup_databases(**kwargs)
def tearDown(self): # NOTE: It's important we disconnect here otherwise tests will fail disconnect()
##Crée une classe des utilsateurs class User(Document): meta = {"colection": "my_test"} username = fields.StringField(required=True) profile_image = fields.ImageField(thumbnail_size=(150, 150, False)) ## charger l'image chirac = User(username='******') my_image = open(path, 'rb') chirac.profile_image.replace(my_image, filename="Twitter_1.jpeg") chirac.save() ## Récuperer l'image user = User.objects(username="******").first() Image(user.profile_image.thumbnail.read()) # Stocker les textes file_names = ['jacque chirac_Instagram.json', 'jacque chirac_Twitter.json'] for file_name in file_names: with open(file_name) as f: file_data = json.load(f) # load data from JSON to dict for k, v in file_data.items(): collection.insert_one(v) disconnect()
def on_error(self, status_code, data): print(status_code) disconnect()
def __init__(self, methodName='runtest'): connection.disconnect() super(MongoEngineTestCase, self).__init__(methodName)
def teardown_databases(self, old_config, **kwargs): from mongoengine.connection import get_connection, disconnect connection = get_connection() connection.drop_database(self.mongodb_name) print('Dropping mongo test database: ' + self.mongodb_name) disconnect()
def setup_databases(self, **kwargs): connection.disconnect() connect(self.db_name, **getattr(settings, 'MONGO_DATABASE_OPTIONS', {}))
def _disconnect_db(): global __connected if __connected: disconnect() __connected = False _importer.remove_meta()
def worker_teardown(self, worker_ctx): disconnect(self.alias) super(MongoDB, self).worker_teardown(worker_ctx=worker_ctx)
def tearDown(self): from mongoengine.connection import get_connection, disconnect connection = get_connection() connection.drop_database(settings._MONGODB_TEST_NAME) disconnect() super().tearDownClass()
def setUp(self): disconnect() settings.MONGODB = connect('test_newsblur') self.client = Client(HTTP_USER_AGENT='Mozilla/5.0')
def tearDown(self): disconnect() super().tearDown()
def setup_databases(self, **kwargs): from mongoengine.connection import connect, disconnect disconnect() connect(self.mongodb_name, host='mongodb://mongo/' + self.mongodb_name) print('Creating mongo test database ' + self.mongodb_name)
def setUp(self): disconnect() settings.MONGODB = connect('test_newsblur') self.client = Client()
from .settings import * env = os.environ.get # SECURITY WARNING: keep the secret key used in production secret! SECRET_KEY = 't+1v*0e%uz4u4*=v-s40&y$rrtt7s%rl^r)2j^-h_x(l7(bjxb' # SECURITY WARNING: don't run with debug turned on in production! DEBUG = False ALLOWED_HOSTS = ['*'] from mongoengine import connect, connection connection.disconnect() connect('theshop-db', host='mongo') CACHES['default']['LOCATION'] = 'redis://redis:6379/1' # CELERY SETTINGS BROKER_URL = 'redis://redis:6379/0' GOOGLE_API_KEY = env('GOOGLE_API_KEY') or '' FCM_API_KEY = env('FCM_API_KEY') or '' FCM_DJANGO_SETTINGS = { "FCM_SERVER_KEY": FCM_API_KEY, "ONE_DEVICE_PER_USER": True, "DELETE_INACTIVE_DEVICES": True, }
from functools import wraps app = Flask(__name__) app.config['SECRET_KEY'] = 'Th1s1ss3cr3t' app.config['MONGODB_DB'] = 'post_service' db = MongoEngine(app) connect('db', host='localhost', port=27017, alias='postdb') class PostDetails(Document): name = StringField(index=True) post = StringField() user_id = StringField() disconnect(alias='postdb') def token_required(f): @wraps(f) def decorator(*args, **kwargs): token = None if 'X-Access-Token' in request.headers: token = request.headers['X-Access-Token'] if not token: return jsonify({'message': 'a valid token is missing'}) data = jwt.decode(token, app.config['SECRET_KEY']) public_id = data['public_id'] current_user = requests.get( "http://127.0.0.1:5001/userpublicid/{}".format(public_id))