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))
