def test_uri_connect(self):
conn = connect(uri="mongodb://localhost/%s" % DBNAME)
self.assertTrue(isinstance(conn, pymongo.MongoClient))
connection = Connection.instance()
self.assertEqual(connection._database, DBNAME)
conn.close()
# overriding the database name
conn = connect(DBNAME, uri="mongodb://localhost/foobar")
self.assertTrue(isinstance(conn, pymongo.MongoClient))
connection = Connection.instance()
self.assertEqual(connection._database, DBNAME)
conn.close()
def test_uri_connect(self):
conn = connect(uri="mongodb://localhost/%s" % DBNAME)
self.assertTrue(isinstance(conn, pymongo.Connection))
connection = Connection.instance()
self.assertEqual(connection._database, DBNAME)
conn.disconnect()
# overriding the database name
conn = connect(DBNAME, uri="mongodb://localhost/foobar")
self.assertTrue(isinstance(conn, pymongo.Connection))
connection = Connection.instance()
self.assertEqual(connection._database, DBNAME)
conn.disconnect()
def test_uri_connect(self):
conn = connect(uri="mongodb://localhost/%s" % DBNAME)
self.assertIsInstance(conn, pymongo.MongoClient)
connection = Connection.instance()
self.assertEqual(connection._database, DBNAME)
conn.close()
# overriding the database name
conn = connect(DBNAME, uri="mongodb://localhost/foobar")
self.assertIsInstance(conn, pymongo.MongoClient)
connection = Connection.instance()
self.assertEqual(connection._database, DBNAME)
conn.close()
def main(application=None):
"""
Startup sequence for CM Satellite
:param application: optional Application instance (if used inside twistd)
:type application: twisted.application.service.Application
"""
configure_logging("satellite", settings.CONFIG_PATH, settings.LOG_PATH, settings.DEFAULT_LOG_FORMAT, False)
##Twisted logs
observer = PythonLoggingObserver()
observer.start()
log = logging.getLogger("cm")
log.info("****************************************************************")
log.info("Starting CloudMailing SATELLITE version %s" % VERSION )
log.info("Serial: %s" % settings.SERIAL)
log.info("Twisted version %s", twisted.version.short())
log.info("****************************************************************")
ssl_context_factory = ssl.ClientContextFactory()
db_conn = connect(settings.SATELLITE_DATABASE)
Db.getInstance(settings.SATELLITE_DATABASE)
init_db(db_conn[settings.SATELLITE_DATABASE])
# attach the service to its parent application
start_satellite_service(application=application, master_ip=settings.MASTER_IP, master_port=settings.MASTER_PORT,
ssl_context_factory=ssl_context_factory)
def test_bad_drop(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u"bad_drop"
foo.save(safe=True)
try:
self.assertRaises(TypeError, getattr, args=(foo, "drop"))
finally:
foo.delete()
conn.disconnect()
def test_search_before_new(self):
""" Testing the bug where fields are not populated before search. """
class Bar(Model):
field = Field()
conn = connect(DBNAME)
result_id = conn[DBNAME]["bar"].save({"field": "test"})
result = Bar.search(field="test").first()
self.assertEqual(result.id, result_id)
conn.disconnect()
def test_create_delete(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u'create_delete'
idval = foo.save(safe=True)
try:
self.assertTrue(type(idval) is pymongo.objectid.ObjectId)
self.assertTrue(foo.id == idval)
finally:
foo.delete()
conn.disconnect()
def test_count(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u'count'
foo.save(safe=True)
count = Foo.count()
try:
self.assertTrue(count == 1)
finally:
foo.delete()
conn.disconnect()
def __init__(self, module=""):
conf = get_config()['log'][module]
self.host = conf['host']
self.db = conf['db']
self.tb = conf['tb']
try:
self.conn = mogo.connect(self.db, self.host)
self.log = self.conn[self.db][self.tb]
except:
raise RuntimeError("Error: Mongo is down.")
def connect_to_db(self, db_name=None):
if db_name is None:
db_name = settings.TEST_DATABASE
self.db_conn = connect(db_name)
self.db_sync = self.db_conn[db_name]
self.db = Db.getInstance(db_name, pool_size=1).db
# self.db_conn.drop_database(db_name)
db = Connection.instance().get_database()
for col in db.collection_names(include_system_collections=False):
if not col.startswith('_'):
db.drop_collection(col)
def test_setattr_save(self):
conn = connect(DBNAME)
foo = Foo.new(bar=u"baz")
foo.save(safe=True)
self.assertTrue(Foo.grab(foo.id) != None)
setattr(foo, "bar", u"quz")
self.assertEqual(foo.bar, u"quz")
self.assertEqual(getattr(foo, "bar"), "quz")
foo.save(safe=True)
result = Foo.grab(foo.id)
self.assertEqual(result.bar, "quz")
conn.disconnect()
def test_grab(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u'grab'
idval = foo.save(safe=True)
newfoo = Foo.grab(str(idval))
try:
self.assertTrue(newfoo != None)
self.assertTrue(newfoo.id == idval)
finally:
foo.delete()
conn.disconnect()
def test_find_one(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u'find_one'
idval = foo.save(safe=True)
foo2 = Foo.find_one({u'bar': u'find_one'})
try:
self.assertTrue(foo2._get_id() == idval)
self.assertTrue(foo2 == foo)
finally:
foo.delete()
conn.disconnect()
def main(application=None):
"""
Startup sequence for CM Master
:param application: optional Application instance (if used inside twistd)
:type application: twisted.application.service.Application
"""
parser = argparse.ArgumentParser(description='Start the Master process for CloudMailing.')
parser.add_argument('-p', '--port', type=int, default=33620, help='port number for Master MailingManager (default: 33620)')
parser.add_argument('--api-interface', default='', help='network interface (IP address) on which API should listen (default: <empty> = all)')
parser.add_argument('--api-port', type=int, default=33610, help='port number for API (default: 33610)')
parser.add_argument('--api-dont-use-ssl', action='store_true', default=False, help='ask API to not use secure port (SSL)')
args = parser.parse_args()
configure_logging("master", settings.CONFIG_PATH, settings.LOG_PATH, settings.DEFAULT_LOG_FORMAT, False)
##Twisted logs
observer = PythonLoggingObserver()
observer.start()
log = logging.getLogger("cm")
log.info("****************************************************************")
log.info("Starting CloudMailing version %s" % VERSION )
log.info("Serial: %s" % settings.SERIAL)
log.info("Twisted version %s", twisted.version.short())
log.info("****************************************************************")
ssl_context_factory = make_SSL_context()
db_conn = None
while not db_conn:
try:
db_conn = connect(settings.MASTER_DATABASE)
init_master_db(db_conn[settings.MASTER_DATABASE])
log.info("Connected to database '%s'", settings.MASTER_DATABASE)
except (pymongo.errors.ConnectionFailure, pymongo.errors.ServerSelectionTimeoutError):
log.error("Failed to connect to database server!")
# special case for MailFountain hardward only
if os.path.exists("/data/mongodb/mongod.lock"):
os.remove("/data/mongodb/mongod.lock")
os.system('su -m mongodb -c "mongod --config /usr/local/etc/mongodb.conf --dbpath /data/mongodb/ --repair"')
os.system("service mongod start")
else:
log.info(" Trying again in 5 seconds...")
time.sleep(5)
Db.getInstance(settings.MASTER_DATABASE, pool_size=10, watchdog_timeout=60)
# attach the service to its parent application
apiService = get_api_service(application, port=args.api_port,
interface=args.api_interface,
ssl_context_factory=not args.api_dont_use_ssl and ssl_context_factory or None)
start_master_service(application, master_port=args.port, ssl_context_factory=ssl_context_factory)
def test_search_ref(self):
conn = connect(DBNAME)
company = Company.new(name="Foo, Inc.")
company.save()
user = Person.new(name="Test", email="*****@*****.**")
user.company = company
user.save(safe=True)
try:
self.assertTrue(company.people.count() == 1)
finally:
user.delete()
company.delete()
conn.disconnect()
def main():
mongo_uri = os.environ.get("MONGOHQ_URL") or \
"mongodb://localhost:27017/meetr_test"
mongo_uri_parts = urlparse.urlparse(mongo_uri)
database = mongo_uri_parts.path[1:]
mogo.connect(database, host=mongo_uri)
app = Application([
# List routes here
("/", index_handler.IndexHandler),
("/users/(\w+)/meetups", meetup_handler.MeetupListHandler),
("/meetups/(\w+)", meetup_handler.MeetupHandler),
("/meetups/(\w+)/activities", meetup_handler.MeetupActivitiesHandler),
("/meetups/(\w+)/people", meetup_handler.MeetupPeopleHandler),
("/activities/(\w+)", activity_handler.ActivityHandler),
("/activities/(\w+)/votes", activity_handler.ActivityVotesHandler),
], static_path="meetr/static")
port = os.environ.get("PORT") or 3000
app.listen(port)
IOLoop.instance().start()
def test_search(self):
conn = connect(DBNAME)
nothing = Foo.search(bar=u'whatever').first()
self.assertEqual(nothing, None)
foo = Foo.new()
foo.bar = u"search"
foo.save(safe=True)
result = foo.search(bar=u"search")
try:
self.assertTrue(result.count() == 1)
self.assertTrue(result.first() == foo)
finally:
foo.delete()
conn.disconnect()
def test_ref(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u"ref"
foo.save(safe=True)
#result = Foo.find_one({"bar": "ref"})
new = Foo.find_one({"bar": "ref"})
#new.bar = "Testing"
new.ref = foo
new.save(safe=True)
result2 = Foo.find_one({"bar": "ref"})
try:
self.assertTrue(result2.ref == foo)
finally:
result2.delete()
conn.disconnect()
def start_instance(settings):
settings.mogo_connection = connect('pytx')
settings.ui_modules = uimodules
# updating the surveys
for survey in survey_list:
existing = survey.__class__.search(key=survey.key).first()
if existing:
existing.delete()
survey.save()
app = tornado.web.Application(views.routes, **settings)
logging.info("starting app at port", settings['httpd_port'])
http_server = tornado.httpserver.HTTPServer(app)
http_server.listen(settings.httpd_port, address='127.0.0.1')
try: tornado.ioloop.IOLoop.instance().start()
except KeyboardInterrupt: pass
def test_find(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u'find'
foo.save(safe=True)
foo2 = Foo.new()
foo2.bar = u'find'
foo2.save()
result = Foo.find({'bar': u'find'})
self.assertTrue(result.count() == 2)
f = result[0] # should be first one
try:
self.assertTrue(type(f) is Foo)
self.assertTrue(f.bar == u'find')
for f in result:
self.assertTrue(type(f) is Foo)
finally:
foo.delete()
foo2.delete()
conn.disconnect()
def test_save_over(self):
conn = connect(DBNAME)
foo = Foo.new()
foo.bar = u'update'
foo.save(safe=True)
result = Foo.find_one({'bar': u'update'})
result["hidden"] = True
#result.bar = u"new update"
setattr(result, "bar", u"new update")
result.save(safe=True)
result2 = Foo.find_one({'bar': 'new update'})
self.assertEqual(result.id, result2.id)
try:
self.assertTrue(result == result2)
self.assertTrue(result["hidden"])
self.assertTrue(result2["hidden"])
self.assertTrue(result2.bar == u'new update')
self.assertTrue(result.bar == u'new update')
finally:
foo.delete()
conn.disconnect()
def setUp(self):
self._conn = connect(DBNAME)
from mogo import Model, Field, connect, ReferenceField
from reddit_comments import troll_classifier
import sys
import time
import settings
import logging
logger = logging.getLogger(__name__)
connect(settings.MONGO_DB_NAME,
host=settings.MONGO_HOST,
port=settings.MONGO_PORT)
class Submission(Model):
object_id = Field(unicode, required=True)
title = Field(unicode, required=True)
permalink = Field(unicode, required=True)
url = Field(unicode, required=True)
date_added = Field(int, required=True)
@property
def comments(self):
return Comment.search(submission=self, is_classified=False)
@property
def troll_count(self):
total_comments = Comment.search(submission=self).count()
not_trolls = Comment.search(submission=self,
is_classified=True,
is_troll=False).count()
def setUp(self):
self._conn = connect(DBNAME)
def setUp(self):
super(MogoFieldTests, self).setUp()
self._mongo_connection = connect("__test_change_field_name")
from mogo import Model, Field, connect, ReferenceField
from reddit_comments import troll_classifier
import sys
import time
import settings
import logging
logger = logging.getLogger(__name__)
connect(settings.MONGO_DB_NAME, host=settings.MONGO_HOST, port=settings.MONGO_PORT)
class Submission(Model):
object_id = Field(unicode, required=True)
title = Field(unicode, required=True)
permalink = Field(unicode, required=True)
url = Field(unicode, required=True)
date_added = Field(int, required=True)
@property
def comments(self):
return Comment.search(submission=self, is_classified=False)
@property
def troll_count(self):
total_comments = Comment.search(submission=self).count()
not_trolls = Comment.search(submission=self, is_classified=True, is_troll=False).count()
return total_comments - not_trolls
class Comment(Model):
def setUp(self):
super(MogoFieldTests, self).setUp()
self._mongo_connection = connect("__test_change_field_name")
def test_connect(self):
conn = connect(DBNAME)
self.assertTrue(isinstance(conn, pymongo.Connection))
connection = Connection.instance()
self.assertTrue(connection._database == DBNAME)
conn.disconnect()
