def test_not_raise_when_database_was_initiated(self):
"""[DatabaseTestCase] - Not raises ValueError when connect to inititated database"""
database1 = Database.init("localhost:27027", dbname='test')
database2 = Database.init("localhost:27027", dbname='test')
database1.should.be.equal(database2)
def test_not_raise_when_database_was_initiated(self):
"""[DatabaseTestCase] - Not raises ValueError when connect to inititated database"""
database1 = Database.init("localhost:27027", dbname='test')
database2 = Database.init("localhost:27027", dbname='test')
database1.should.be.equal(database2)
def test_raises_erro_when_use_collection_with_not_initialized_database(
self):
"""[CollectionTestCase] - Raises DatabaseError when use collection with a not initialized database"""
class CollectionTest(Collection):
__collection__ = 'collection_test'
Database.disconnect()
CollectionTest().save.when.called_with(callback=None) \
.throw(DatabaseError, 'you must be initialize database before perform this action')
Database.init(["localhost:27027", "localhost:27028"], dbname='test')
def test_raises_erro_when_use_collection_with_not_initialized_database(self):
"""[CollectionTestCase] - Raises DatabaseError when use collection with a not initialized database"""
class CollectionTest(Collection):
__collection__ = 'collection_test'
Database.disconnect()
CollectionTest().save.when.called_with(callback=None) \
.throw(DatabaseError, 'you must be initialize database before perform this action')
Database.init(["localhost:27027", "localhost:27028"], dbname='test')
def test_count_documents_in_find(self):
"""[ClientTestCase] - counting documents in query"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
'_id': ObjectId(),
'param': 'shouldbeparam1'
}, {
'_id': ObjectId(),
'param': 'shouldbeparam1'
}, {
'_id': ObjectId(),
'param': 'shouldbeparam2'
}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.find({
"param": 'shouldbeparam1'
}).count(callback=self.stop)
total = self.wait()
total.should.be.equal(2)
def test_find_document(self):
"""[ClientTestCase] - find a document"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
'_id': ObjectId(),
'someflag': 1
}, {
'_id': ObjectId(),
'someflag': 1
}, {
'_id': ObjectId(),
'someflag': 2
}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.find({'someflag': 1}, callback=self.stop)
response, error = self.wait()
response[0]['_id'].should.be(documents[0]['_id'])
response[1]['_id'].should.be(documents[1]['_id'])
error.should.be.none
def test_insert_and_find_with_elemmatch(self):
documents = [{
'_id': ObjectId(),
'name': 'should be name 1',
'comment': [{'author': 'joe'}, {'author': 'ana'}]
}, {
'_id': ObjectId(),
'name': 'should be name 2',
'comment': [{'author': 'ana'}]
}]
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
db.articles.insert(documents, callback=self.stop)
self.wait()
db.articles.find({'comment.author': 'joe'}, ('comment.$.author', ), limit=-1, callback=self.stop)
result, _ = self.wait()
keys = result.keys()
keys.sort()
keys.should.be.equal(['_id', 'comment'])
str(result['_id']).should.be.equal(str(documents[0]['_id']))
result['comment'].should.have.length_of(1)
result['comment'][0]['author'].should.be.equal('joe')
_.should.be.none
def test_update_document(self):
"""[ClientTestCase] - update a document"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
'_id': ObjectId(),
'name': 'shouldbename'
}, {
'_id': ObjectId(),
'name': 'shouldbename2'
}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.update(documents[0],
{'$set': {
'name': 'should be a new name'
}},
callback=self.stop)
response, error = self.wait()
response['ok'].should.be.equal(1.0)
error.should.be.none
def test_raises_error_when_could_not_find_node(self):
"""[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes"""
database = Database.init(["localhost:27030"], dbname="test")
database.send_message.when.called_with("", callback=None).throw(
DatabaseError, "could not find an available node"
)
def test_find_one_document(self):
"""[ClientTestCase] - find one document"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
'_id': ObjectId(),
'param': 'shouldbeparam'
}, {
'_id': ObjectId(),
'param': 'shouldbeparam1'
}, {
'_id': ObjectId(),
'param': 'shouldbeparam2'
}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.find_one({'param': 'shouldbeparam1'},
callback=self.stop)
response, error = self.wait()
response['_id'].should.be(documents[1]['_id'])
error.should.be.none
def test_distinct_all_documents(self):
"""[ClientTestCase] - distinct among all documents"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
'_id': ObjectId(),
'param': 'shouldbeparam1',
'uuid': 100
}, {
'_id': ObjectId(),
'param': 'shouldbeparam1',
'uuid': 100
}, {
'_id': ObjectId(),
'param': 'shouldbeparam2',
'uuid': 200
}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.distinct('uuid', callback=self.stop)
distincts = self.wait()
distincts.should.have.length_of(2)
distincts[0].should.be.equal(100)
distincts[1].should.be.equal(200)
def test_send_test_message(self):
"""[DatabaseTestCase] - Send a test message to database"""
Database.init(["localhost:27027", "localhost:27028"], dbname="test")
object_id = ObjectId()
message_test = message.query(0, "mongotor_test.$cmd", 0, 1, {"driverOIDTest": object_id})
Database().send_message(message_test, callback=self.stop)
response, _ = self.wait()
response = helpers._unpack_response(response)
result = response["data"][0]
result["oid"].should.be(object_id)
result["ok"].should.be(1.0)
result["str"].should.be(str(object_id))
def test_run_command(self):
"""[DatabaseTestCase] - Run a database command"""
database = Database.init(["localhost:27027"], dbname='test')
database.command('ismaster', callback=self.stop)
response, error = self.wait()
response['ok'].should.be.ok
def test_run_command(self):
"""[DatabaseTestCase] - Run a database command"""
database = Database.init(["localhost:27027"], dbname='test')
database.command('ismaster', callback=self.stop)
response, error = self.wait()
response['ok'].should.be.ok
def test_send_test_message(self):
"""[DatabaseTestCase] - Send a test message to database"""
Database.init(["localhost:27027", "localhost:27028"], dbname='test')
object_id = ObjectId()
message_test = message.query(0, 'mongotor_test.$cmd', 0, 1,
{'driverOIDTest': object_id})
Database().send_message(message_test, callback=self.stop)
response, _ = self.wait()
response = helpers._unpack_response(response)
result = response['data'][0]
result['oid'].should.be(object_id)
result['ok'].should.be(1.0)
result['str'].should.be(str(object_id))
def test_send_test_message(self):
"""[DatabaseTestCase] - Send a test message to database"""
Database.init(["localhost:27027", "localhost:27028"], dbname='test')
object_id = ObjectId()
message_test = message.query(0, 'mongotor_test.$cmd', 0, 1,
{'driverOIDTest': object_id})
Database().send_message(message_test, callback=self.stop)
response, _ = self.wait()
response = helpers._unpack_response(response)
result = response['data'][0]
result['oid'].should.be(object_id)
result['ok'].should.be(1.0)
result['str'].should.be(str(object_id))
def test_raises_error_when_could_not_find_node(self):
"""[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes"""
database = Database.init(["localhost:27030"], dbname='test')
def send_message():
database.send_message('', callback=self.stop)
self.wait()
send_message.when.called.throw(DatabaseError, 'could not find an available node')
def test_raises_error_when_could_not_find_node(self):
"""[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes"""
database = Database.init(["localhost:27030"], dbname='test')
def send_message():
database.send_message('', callback=self.stop)
self.wait()
send_message.when.called.throw(DatabaseError,
'could not find an available node')
def test_aggregate_collection(self):
"""[ClientTestCase] - aggregate command"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
"title": "this is my title",
"author": "bob",
"posted": datetime.now(),
"pageViews": 5,
"tags": ["good", "fun"],
}, {
"title": "this is my title",
"author": "joe",
"posted": datetime.now(),
"pageViews": 5,
"tags": ["good"],
}]
db.articles.insert(documents, callback=self.stop)
response, error = self.wait()
try:
pipeline = {
"$project": {
"author": 1,
"tags": 1,
}
}, {
"$unwind": "$tags"
}, {
"$group": {
"_id": {
"tags": "$tags"
},
"authors": {
"$addToSet": "$author"
}
}
}
db.articles.aggregate(pipeline, callback=self.stop)
response = self.wait()
response['result'][0]['_id'].should.be.equal({u'tags': u'fun'})
response['result'][0]['authors'].should.be.equal([u'bob'])
response['result'][1]['_id'].should.be.equal({u'tags': u'good'})
response['result'][1]['authors'].should.be.equal([u'joe', u'bob'])
finally:
db.articles.remove({}, callback=self.stop)
self.wait()
def test_insert_a_single_document(self):
"""[ClientTestCase] - insert a single document with client"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
document = {'_id': ObjectId(), 'name': 'shouldbename'}
db.collection_test.insert(document, callback=self.stop)
response, error = self.wait()
response['ok'].should.be.equal(1.0)
error.should.be.none
def test_insert_a_single_document(self):
"""[ClientTestCase] - insert a single document with client"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
document = {'_id': ObjectId(), 'name': 'shouldbename'}
db.collection_test.insert(document, callback=self.stop)
response, error = self.wait()
response['ok'].should.be.equal(1.0)
error.should.be.none
def test_aggregate_collection(self):
"""[ClientTestCase] - aggregate command"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
"title": "this is my title",
"author": "bob",
"posted": datetime.now(),
"pageViews": 5,
"tags": ["good", "fun"],
}, {
"title": "this is my title",
"author": "joe",
"posted": datetime.now(),
"pageViews": 5,
"tags": ["good"],
}]
db.articles.insert(documents, callback=self.stop)
response, error = self.wait()
try:
pipeline = {
"$project": {
"author": 1,
"tags": 1,
}
}, {
"$unwind": "$tags"
}, {
"$group": {
"_id": {"tags": "$tags"},
"authors": {"$addToSet": "$author"}
}
}
db.articles.aggregate(pipeline, callback=self.stop)
response = self.wait()
response['result'][0]['_id'].should.be.equal({u'tags': u'fun'})
response['result'][0]['authors'].should.be.equal([u'bob'])
response['result'][1]['_id'].should.be.equal({u'tags': u'good'})
response['result'][1]['authors'].should.be.equal([u'joe', u'bob'])
finally:
db.articles.remove({}, callback=self.stop)
self.wait()
def test_count_all_documents(self):
"""[ClientTestCase] - counting among all documents"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{'_id': ObjectId(), 'param': 'shouldbeparam1'},
{'_id': ObjectId(), 'param': 'shouldbeparam1'},
{'_id': ObjectId(), 'param': 'shouldbeparam2'}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.count(callback=self.stop)
total = self.wait()
total.should.be.equal(3)
def test_remove_document_by_spec(self):
"""[ClientTestCase] - remove a document by spec"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{'_id': ObjectId(), 'name': 'shouldbename'},
{'_id': ObjectId(), 'name': 'shouldbename2'}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.remove({'name': 'shouldbename'}, callback=self.stop)
response, error = self.wait()
response['ok'].should.be.equal(1.0)
error.should.be.none
def test_find_on_secondary(self):
"""[SecondaryPreferredTestCase] - test find document from secondary"""
db = Database.init(["localhost:27027", "localhost:27028"], dbname='test',
read_preference=ReadPreference.SECONDARY_PREFERRED)
db._connect(callback=self.stop)
self.wait()
doc = {'_id': ObjectId()}
db.test.insert(doc, callback=self.stop)
self.wait()
time.sleep(2)
db.test.find_one(doc, callback=self.stop)
doc_found, error = self.wait()
doc_found.should.be.eql(doc)
def test_raises_error_when_mode_is_secondary_and_secondary_is_down(self):
"""[ReplicaSetTestCase] - Raise error when mode is secondary and secondary is down"""
os.system("make mongo-kill-node2")
time.sleep(1) # stops are fast
try:
db = Database.init(["localhost:27027", "localhost:27028"], dbname="test")
db._connect(callback=self.stop)
self.wait()
Database().send_message.when.called_with((None, ""), read_preference=ReadPreference.SECONDARY).throw(
DatabaseError
)
finally:
os.system("make mongo-start-node2")
time.sleep(5) # wait to become secondary again
def test_update_document(self):
"""[ClientTestCase] - update a document"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{'_id': ObjectId(), 'name': 'shouldbename'},
{'_id': ObjectId(), 'name': 'shouldbename2'}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.update(documents[0], {'$set': {'name':
'should be a new name'}}, callback=self.stop)
response, error = self.wait()
response['ok'].should.be.equal(1.0)
error.should.be.none
def test_check_connections_when_use_cursors(self):
"""[ConnectionPoolTestCase] - check connections when use cursors"""
db = Database.init('localhost:27027', dbname='test', maxconnections=10, maxusage=29)
try:
for i in range(2):
db.cards.insert({'_id': ObjectId(), 'range': i}, callback=self.stop)
self.wait()
db._nodes[0].pool._connections.should.be.equal(0)
db.cards.find({}, callback=self.stop)
self.wait()
db._nodes[0].pool._connections.should.be.equal(0)
finally:
Database.disconnect()
def test_raises_error_when_mode_is_secondary_and_secondary_is_down(self):
"""[ReplicaSetTestCase] - Raise error when mode is secondary and secondary is down"""
os.system('make mongo-kill-node2')
time.sleep(1) # stops are fast
try:
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
db._connect(callback=self.stop)
self.wait()
Database().send_message.when.called_with((None, ''),
read_preference=ReadPreference.SECONDARY)\
.throw(DatabaseError)
finally:
os.system('make mongo-start-node2')
time.sleep(5) # wait to become secondary again
def test_find_on_secondary(self):
"""[SecondaryPreferredTestCase] - test find document from secondary"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test',
read_preference=ReadPreference.SECONDARY_PREFERRED)
db._connect(callback=self.stop)
self.wait()
doc = {'_id': ObjectId()}
db.test.insert(doc, callback=self.stop)
self.wait()
time.sleep(2)
db.test.find_one(doc, callback=self.stop)
doc_found, error = self.wait()
doc_found.should.be.eql(doc)
def test_distinct_documents_in_find(self):
"""[ClientTestCase] - distinct documents in query"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{'_id': ObjectId(), 'param': 'shouldbeparam1', 'uuid': 100},
{'_id': ObjectId(), 'param': 'shouldbeparam1', 'uuid': 100},
{'_id': ObjectId(), 'param': 'shouldbeparam2', 'uuid': 200}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.find({"param": 'shouldbeparam1'}).distinct('uuid', callback=self.stop)
distincts = self.wait()
distincts.should.have.length_of(1)
distincts[0].should.be.equal(100)
def test_find_document(self):
"""[ClientTestCase] - find a document"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{'_id': ObjectId(), 'someflag': 1},
{'_id': ObjectId(), 'someflag': 1},
{'_id': ObjectId(), 'someflag': 2}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.find({'someflag': 1}, callback=self.stop)
response, error = self.wait()
response[0]['_id'].should.be(documents[0]['_id'])
response[1]['_id'].should.be(documents[1]['_id'])
error.should.be.none
def test_find_one_document_by_id(self):
"""[ClientTestCase] - find one document by id"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{'_id': ObjectId(), 'param': 'shouldbeparam'},
{'_id': ObjectId(), 'param': 'shouldbeparam1'},
{'_id': ObjectId(), 'param': 'shouldbeparam2'}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.find_one(documents[2]['_id'],
callback=self.stop)
response, error = self.wait()
response['_id'].should.be(documents[2]['_id'])
error.should.be.none
def test_configure_nodes(self):
"""[ReplicaSetTestCase] - Configure nodes"""
db = Database.init(["localhost:27027", "localhost:27028"], dbname='test')
db._connect(callback=self.stop)
self.wait()
master_node = ReadPreference.select_primary_node(Database()._nodes)
secondary_node = ReadPreference.select_node(Database()._nodes, mode=ReadPreference.SECONDARY)
master_node.host.should.be('localhost')
master_node.port.should.be(27027)
secondary_node.host.should.be('localhost')
secondary_node.port.should.be(27028)
nodes = Database()._nodes
nodes.should.have.length_of(2)
def test_group(self):
"""[ClientTestCase] - group command"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
group = {
'key': None,
'condition': {
'author': 'joe'
},
'initial': {
'csum': 0
},
'reduce': 'function(obj,prev){prev.csum+=obj.pageViews;}'
}
documents = [{
"title": "this is my title",
"author": "bob",
"posted": datetime.now(),
"pageViews": 5,
"tags": ["good", "fun"],
}, {
"title": "this is my title",
"author": "joe",
"posted": datetime.now(),
"pageViews": 6,
"tags": ["good"],
}, {
"title": "this is my title",
"author": "joe",
"posted": datetime.now(),
"pageViews": 10,
"tags": ["good"],
}]
db.articles.insert(documents, callback=self.stop)
response, error = self.wait()
try:
db.articles.group(callback=self.stop, **group)
result = self.wait()
result['retval'][0]['csum'].should.be.equal(16)
finally:
db.articles.remove({}, callback=self.stop)
self.wait()
def test_raises_error_when_mode_is_secondary_and_secondary_is_down(self):
"""[ReplicaSetTestCase] - Raise error when mode is secondary and secondary is down"""
os.system('make mongo-kill > /dev/null 2>&1')
os.system('make mongo-start-node1')
os.system('make mongo-start-arbiter')
time.sleep(10)
try:
db = Database.init(["localhost:27027", "localhost:27028"], dbname='test')
db._connect(callback=self.stop)
self.wait()
Database().send_message.when.called_with((None, ''),
read_preference=ReadPreference.SECONDARY)\
.throw(DatabaseError)
finally:
os.system('make mongo-start-node2')
time.sleep(10)
def test_configure_nodes(self):
"""[ReplicaSetTestCase] - Configure nodes"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
db._connect(callback=self.stop)
self.wait()
master_node = ReadPreference.select_primary_node(Database()._nodes)
secondary_node = ReadPreference.select_node(
Database()._nodes, mode=ReadPreference.SECONDARY)
master_node.host.should.be('localhost')
master_node.port.should.be(27027)
secondary_node.host.should.be('localhost')
secondary_node.port.should.be(27028)
nodes = Database()._nodes
nodes.should.have.length_of(2)
def test_remove_document_by_spec(self):
"""[ClientTestCase] - remove a document by spec"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
documents = [{
'_id': ObjectId(),
'name': 'shouldbename'
}, {
'_id': ObjectId(),
'name': 'shouldbename2'
}]
db.collection_test.insert(documents, callback=self.stop)
response, error = self.wait()
db.collection_test.remove({'name': 'shouldbename'}, callback=self.stop)
response, error = self.wait()
response['ok'].should.be.equal(1.0)
error.should.be.none
def test_group(self):
"""[ClientTestCase] - group command"""
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
group = {
'key': None,
'condition': {'author': 'joe'},
'initial': {'csum': 0},
'reduce': 'function(obj,prev){prev.csum+=obj.pageViews;}'
}
documents = [{
"title": "this is my title",
"author": "bob",
"posted": datetime.now(),
"pageViews": 5,
"tags": ["good", "fun"],
}, {
"title": "this is my title",
"author": "joe",
"posted": datetime.now(),
"pageViews": 6,
"tags": ["good"],
}, {
"title": "this is my title",
"author": "joe",
"posted": datetime.now(),
"pageViews": 10,
"tags": ["good"],
}]
db.articles.insert(documents, callback=self.stop)
response, error = self.wait()
try:
db.articles.group(callback=self.stop, **group)
result = self.wait()
result['retval'][0]['csum'].should.be.equal(16)
finally:
db.articles.remove({}, callback=self.stop)
self.wait()
def test_insert_and_find_with_elemmatch(self):
documents = [{
'_id': ObjectId(),
'name': 'should be name 1',
'comment': [{
'author': 'joe'
}, {
'author': 'ana'
}]
}, {
'_id': ObjectId(),
'name': 'should be name 2',
'comment': [{
'author': 'ana'
}]
}]
db = Database.init(["localhost:27027", "localhost:27028"],
dbname='test')
db.articles.insert(documents, callback=self.stop)
self.wait()
db.articles.find({'comment.author': 'joe'}, ('comment.$.author', ),
limit=-1,
callback=self.stop)
result, _ = self.wait()
keys = result.keys()
keys.sort()
keys.should.be.equal(['_id', 'comment'])
str(result['_id']).should.be.equal(str(documents[0]['_id']))
result['comment'].should.have.length_of(1)
result['comment'][0]['author'].should.be.equal('joe')
_.should.be.none
def test_check_connections_when_use_cursors(self):
"""[ConnectionPoolTestCase] - check connections when use cursors"""
db = Database.init('localhost:27027',
dbname='test',
maxconnections=10,
maxusage=29)
try:
for i in range(2):
db.cards.insert({
'_id': ObjectId(),
'range': i
},
callback=self.stop)
self.wait()
db._nodes[0].pool._connections.should.be.equal(0)
db.cards.find({}, callback=self.stop)
self.wait()
db._nodes[0].pool._connections.should.be.equal(0)
finally:
Database.disconnect()
def test_disconnect_database(self):
"""[DatabaseTestCase] - Disconnect the database"""
Database.init(["localhost:27027"], dbname='test')
Database.disconnect()
Database._instance.should.be.none
def setUp(self):
super(CollectionTestCase, self).setUp()
Database.init(["localhost:27027", "localhost:27028"], dbname='test')
def setUp(self):
super(ManagerTestCase, self).setUp()
Database.init(["localhost:27027", "localhost:27028"], dbname='mongotor_test')
def setUp(self):
super(CollectionTestCase, self).setUp()
Database.init(["localhost:27027", "localhost:27028"], dbname='test')
def test_create_singleton_database_connection(self):
"""[DatabaseTestCase] - Create a singleton database connection"""
database = Database.init("localhost:27027", dbname='test')
database.should.be.equal(Database())
def test_disconnect_database(self):
"""[DatabaseTestCase] - Disconnect the database"""
Database.init(["localhost:27027"], dbname='test')
Database.disconnect()
Database._instance.should.be.none
def test_raises_error_when_could_not_find_node(self):
"""[DatabaseTestCase] - Raises DatabaseError when could not find valid nodes"""
database = Database.init(["localhost:27030"], dbname='test')
database.send_message.when.called_with("", callback=None) \
.throw(DatabaseError, 'could not find an available node')
def setUp(self):
super(SignalTestCase, self).setUp()
SignalTestCase.signal_triggered = False
Database.init(["localhost:27027", "localhost:27028"], dbname='mongotor_test')
def test_create_singleton_database_connection(self):
"""[DatabaseTestCase] - Create a singleton database connection"""
database = Database.init("localhost:27027", dbname='test')
database.should.be.equal(Database())
def setUp(self):
super(ManagerTestCase, self).setUp()
Database.init(["localhost:27027", "localhost:27028"],
dbname='mongotor_test')
def setUp(self):
super(SignalTestCase, self).setUp()
SignalTestCase.signal_triggered = False
Database.init(["localhost:27027", "localhost:27028"],
dbname='mongotor_test')
