class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection()
def test_add(self):
coll2 = self.conn.create_collection('coll2')
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
def test_delete(self):
coll2 = self.conn.create_collection('coll2')
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# delete w/ object
so = SearchOptions()
so.commonparams.q("id:1")
coll2.delete(so)
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 0)
# delete w/ dict
so = {"q": "id:2"}
coll2.delete(so)
res = coll2.search({"q": "id:2"}).result
self.assertTrue(len(res.response.docs) == 0)
coll2.drop()
class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv('SOLR_VERSION', '6.1.0'))
self.collparams = {}
confname = os.getenv('SOLR_CONFNAME', '')
if confname != '':
self.collparams['collection_config_name'] = confname
def test_add(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
def test_delete(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# delete w/ object
so = SearchOptions()
so.commonparams.q("id:1")
coll2.delete(so)
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 0)
# delete w/ dict
so = {"q": "id:2"}
coll2.delete(so)
res = coll2.search({"q": "id:2"}).result
self.assertTrue(len(res.response.docs) == 0)
coll2.drop()
def test_custom_params_search(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
res_1 = coll2.add(docs, {'omitHeader': "false"})
self.assertEquals(0, res_1.responseHeader.status)
coll2.commit()
res_2 = coll2.search({"q": "id:1", "omitHeader": "false"}).result
self.assertEquals(0, res_2.responseHeader.status)
class TestConnection(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv("SOLR_VERSION", "6.1.0"))
self.collparams = {}
confname = os.getenv("SOLR_CONFNAME", "")
if confname != "":
self.collparams["collection_config_name"] = confname
def test_list(self):
self.conn["foo"].create(**self.collparams)
colls = self.conn.list()
self.assertTrue(len(colls) >= 1)
self.conn["foo"].drop()
def test_live_nodes(self):
nodes = self.conn.live_nodes
# to support easy use of solrcloud gettingstarted
self.assertTrue(len(nodes) >= 1)
def test_cluster_leader(self):
leader = self.conn.cluster_leader
self.assertTrue(leader is not None)
def test_create_collection(self):
coll = self.conn.create_collection("test2", **self.collparams)
self.assertTrue(isinstance(coll, SolrCollection))
self.conn.test2.drop()
def test_create_collection_https(self):
test_conn = SolrConnection(server="localhost", use_https=True)
self.assertTrue(test_conn.url_template.startswith("https:"))
test_conn = SolrConnection(server="localhost", use_https=False)
self.assertTrue(test_conn.url_template.startswith("http:"))
test_conn = SolrConnection(server="localhost")
self.assertTrue(test_conn.url_template.startswith("http:"))
class TestConnection(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv('SOLR_VERSION', '6.1.0'))
self.collparams = {}
confname = os.getenv('SOLR_CONFNAME', '')
if confname != '':
self.collparams['collection_config_name'] = confname
def test_list(self):
self.conn['foo'].create(**self.collparams)
colls = self.conn.list()
self.assertTrue(len(colls) >= 1)
self.conn['foo'].drop()
def test_live_nodes(self):
nodes = self.conn.live_nodes
# to support easy use of solrcloud gettingstarted
self.assertTrue(len(nodes) >= 1)
def test_cluster_leader(self):
leader = self.conn.cluster_leader
self.assertTrue(leader is not None)
def test_create_collection(self):
coll = self.conn.create_collection('test2', **self.collparams)
self.assertTrue(isinstance(coll, SolrCollection))
self.conn.test2.drop()
class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv('SOLR_VERSION', '6.1.0'))
self.collparams = {}
confname = os.getenv('SOLR_CONFNAME', '')
if confname != '':
self.collparams['collection_config_name'] = confname
def test_add(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
def test_delete(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# delete w/ object
so = SearchOptions()
so.commonparams.q("id:1")
coll2.delete(so)
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 0)
# delete w/ dict
so = {"q": "id:2"}
coll2.delete(so)
res = coll2.search({"q": "id:2"}).result
self.assertTrue(len(res.response.docs) == 0)
coll2.drop()
class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection()
def test_add(self):
coll2 = self.conn.create_collection('coll2')
docs = [{"id":str(_id),"includes":"silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q":"id:1"}).result
self.assertTrue(len(res.response.docs)== 1)
coll2.drop()
class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection()
def test_add(self):
coll2 = self.conn.create_collection('coll2')
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection()
def test_add(self):
coll2 = self.conn.create_collection('coll2')
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
def test_delete(self):
coll2 = self.conn.create_collection('coll2')
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# delete w/ object
so = SearchOptions()
so.commonparams.q("id:1")
coll2.delete(so)
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 0)
# delete w/ dict
so = {"q": "id:2"}
coll2.delete(so)
res = coll2.search({"q": "id:2"}).result
self.assertTrue(len(res.response.docs) == 0)
coll2.drop()
class TestCollectionAdmin(unittest.TestCase):
def setUp(self):
self.conn = Connection()
def test_create_collection(self):
coll2 = self.conn.create_collection('coll2')
time.sleep(3)
coll2.drop()
time.sleep(3)
def test_reload(self):
coll2 = self.conn.create_collection('coll2')
time.sleep(3)
res = coll2.reload()
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_split_shard(self):
coll2 = self.conn.create_collection('coll2')
time.sleep(3)
res = coll2.split_shard('shard1',
ranges="80000000-90000000,90000001-7fffffff")
time.sleep(3)
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_create_shard(self):
coll2 = self.conn.create_collection('coll2',
router_name='implicit',
shards='myshard1',
max_shards_per_node=3)
time.sleep(3)
res = coll2.create_shard('shard_my')
time.sleep(3)
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_create_delete_alias(self):
coll2 = self.conn.create_collection('coll2')
coll2.create_alias('alias2')
time.sleep(3)
self.assertTrue(self.conn.alias2.is_alias())
coll2.delete_alias('alias2')
coll2.drop()
def test_delete_replica(self):
coll2 = self.conn.create_collection('coll2',
router_name='implicit',
shards='myshard1',
max_shards_per_node=6,
replication_factor=2)
time.sleep(3)
coll2.delete_replica('core_node2', 'myshard1')
coll2.drop()
class TestCollectionAdmin(unittest.TestCase):
def setUp(self):
self.conn = Connection()
def test_create_collection(self):
coll2 = self.conn.create_collection('coll2')
time.sleep(3)
coll2.drop()
time.sleep(3)
def test_reload(self):
coll2 = self.conn.create_collection('coll2')
time.sleep(3)
res = coll2.reload()
self.assertTrue(getattr(res,'success') is not None)
coll2.drop()
def test_split_shard(self):
coll2 = self.conn.create_collection('coll2')
time.sleep(3)
res = coll2.split_shard('shard1',ranges="80000000-90000000,90000001-7fffffff")
time.sleep(3)
self.assertTrue(getattr(res,'success') is not None)
coll2.drop()
def test_create_shard(self):
coll2 = self.conn.create_collection('coll2',
router_name='implicit',
shards='myshard1',max_shards_per_node=3)
time.sleep(3)
res = coll2.create_shard('shard_my')
time.sleep(3)
self.assertTrue(getattr(res,'success') is not None)
coll2.drop()
def test_create_delete_alias(self):
coll2 = self.conn.create_collection('coll2')
coll2.create_alias('alias2')
time.sleep(3)
self.assertTrue(self.conn.alias2.is_alias())
coll2.delete_alias('alias2')
coll2.drop()
def test_delete_replica(self):
coll2 = self.conn.create_collection('coll2',
router_name='implicit',
shards='myshard1',
max_shards_per_node=6,
replication_factor=2)
time.sleep(3)
coll2.delete_replica('core_node2','myshard1')
coll2.drop()
class TestConnection(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection()
def test_list(self):
colls = self.conn.list()
self.assertTrue(len(colls) >= 1)
def test_live_nodes(self):
nodes = self.conn.live_nodes
self.assertTrue(len(nodes) == 1)
def test_cluster_leader(self):
leader = self.conn.cluster_leader
self.assertTrue(leader is not None)
def test_create_collection(self):
coll = self.conn.create_collection('test2')
self.assertTrue(isinstance(coll, SolrCollection))
self.conn.test2.drop()
class TestConnection(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection()
def test_list(self):
colls = self.conn.list()
self.assertTrue(len(colls)>=1)
def test_live_nodes(self):
nodes = self.conn.live_nodes
self.assertTrue(len(nodes)==1)
def test_cluster_leader(self):
leader = self.conn.cluster_leader
self.assertTrue(leader is not None)
def test_create_collection(self):
coll = self.conn.create_collection('test2')
self.assertTrue(isinstance(coll,SolrCollection))
self.conn.test2.drop()
class TestCollectionAdmin(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv('SOLR_VERSION', '6.1.0'))
self.collparams = {}
confname = os.getenv('SOLR_CONFNAME', '')
if confname != '':
self.collparams['collection_config_name'] = confname
def test_create_collection(self):
original_count = len(self.conn.list())
coll2 = self.conn.create_collection('coll2', **self.collparams)
self.assertEqual(len(self.conn.list()), original_count+1)
self.conn.list()
time.sleep(3)
coll3 = self.conn.create_collection('coll3', **self.collparams)
self.assertEqual(len(self.conn.list()), original_count+2)
# todo calling state here means the integration works, but what should we assert?
coll2.state
coll2.drop()
self.assertEqual(len(self.conn.list()), original_count+1)
time.sleep(3)
coll3.drop()
self.assertEqual(len(self.conn.list()), original_count)
def test_reload(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
time.sleep(3)
res = coll2.reload()
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_split_shard(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
time.sleep(3)
res = coll2.split_shard('shard1', ranges="80000000-90000000,90000001-7fffffff")
time.sleep(3)
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_create_shard(self):
coll2 = self.conn.create_collection('coll2',
router_name='implicit',
shards='myshard1', max_shards_per_node=3,
**self.collparams)
time.sleep(3)
res = coll2.create_shard('shard_my')
time.sleep(3)
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_create_delete_alias(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
coll2.create_alias('alias2')
time.sleep(3)
self.assertTrue(self.conn.alias2.is_alias())
coll2.delete_alias('alias2')
coll2.drop()
def test_delete_replica(self):
try:
coll2 = self.conn.create_collection('test_delete_replica',
router_name='implicit',
shards='myshard1',
max_shards_per_node=6,
replication_factor=2,
**self.collparams)
except ReadTimeout:
print("Encountered read timeout while testing delete replicate")
print("This generally doesn't mean the collection wasn't created with the settings passed.")
coll2 = self.conn['test_delete_replica']
time.sleep(3)
firstReplica = list(coll2.shards['shards']['myshard1']['replicas'].dict.keys())[0]
result = coll2.delete_replica(firstReplica, 'myshard1')
self.assertTrue(result.success)
coll2.drop()
class TestCollectionAdmin(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv('SOLR_VERSION', '6.1.0'))
self.collparams = {}
confname = os.getenv('SOLR_CONFNAME', '')
if confname != '':
self.collparams['collection_config_name'] = confname
def test_create_collection(self):
original_count = len(self.conn.list())
coll2 = self.conn.create_collection('coll2', **self.collparams)
self.assertEqual(len(self.conn.list()), original_count + 1)
self.conn.list()
time.sleep(3)
coll3 = self.conn.create_collection('coll3', **self.collparams)
self.assertEqual(len(self.conn.list()), original_count + 2)
# todo calling state here means the integration works, but what should we assert?
coll2.state
coll2.drop()
self.assertEqual(len(self.conn.list()), original_count + 1)
time.sleep(3)
coll3.drop()
self.assertEqual(len(self.conn.list()), original_count)
def test_reload(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
time.sleep(3)
res = coll2.reload()
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_split_shard(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
time.sleep(3)
res = coll2.split_shard('shard1',
ranges="80000000-90000000,90000001-7fffffff")
time.sleep(3)
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_create_shard(self):
coll2 = self.conn.create_collection('coll2',
router_name='implicit',
shards='myshard1',
max_shards_per_node=3,
**self.collparams)
time.sleep(3)
res = coll2.create_shard('shard_my')
time.sleep(3)
self.assertTrue(getattr(res, 'success') is not None)
coll2.drop()
def test_create_delete_alias(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
coll2.create_alias('alias2')
time.sleep(3)
self.assertTrue(self.conn.alias2.is_alias())
coll2.delete_alias('alias2')
coll2.drop()
def test_delete_replica(self):
try:
coll2 = self.conn.create_collection('test_delete_replica',
router_name='implicit',
shards='myshard1',
max_shards_per_node=6,
replication_factor=2,
**self.collparams)
except ReadTimeout:
print "Encountered read timeout while testing delete replicate"
print "This generally doesn't mean the collection wasn't created with the settings passed."
coll2 = self.conn['test_delete_replica']
time.sleep(3)
coll2.delete_replica('core_node2', 'myshard1')
coll2.drop()
class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv('SOLR_VERSION', '6.1.0'))
self.collparams = {}
confname = os.getenv('SOLR_CONFNAME', '')
if confname != '':
self.collparams['collection_config_name'] = confname
def test_add(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
def test_delete(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# delete w/ object
so = SearchOptions()
so.commonparams.q("id:1")
coll2.delete(so)
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 0)
# delete w/ dict
so = {"q": "id:2"}
coll2.delete(so)
res = coll2.search({"q": "id:2"}).result
self.assertTrue(len(res.response.docs) == 0)
coll2.drop()
def test_custom_params_search(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
res_1 = coll2.add(docs, {'omitHeader': "false"})
self.assertEqual(0, res_1.responseHeader.status)
coll2.commit()
res_2 = coll2.search({"q": "id:1", "omitHeader": "false"}).result
self.assertEqual(0, res_2.responseHeader.status)
def test_post_body_search(self):
coll2 = self.conn.create_collection('coll2', **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# JSON DSL Query format
res = coll2.search({},"POST", '{"query": "id:1"}').result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
class TestCollectionAdmin(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv("SOLR_VERSION", "6.1.0"))
self.collparams = {}
confname = os.getenv("SOLR_CONFNAME", "")
if confname != "":
self.collparams["collection_config_name"] = confname
def test_create_collection(self):
original_count = len(self.conn.list())
coll2 = self.conn.create_collection("coll2", **self.collparams)
time.sleep(3)
self.assertEqual(len(self.conn.list()), original_count + 1)
self.conn.list()
time.sleep(3)
coll3 = self.conn.create_collection("coll3", **self.collparams)
time.sleep(3)
self.assertEqual(len(self.conn.list()), original_count + 2)
# todo calling state here means the integration works, but what should we assert?
coll2.state
coll2.drop()
time.sleep(3)
self.assertEqual(len(self.conn.list()), original_count + 1)
time.sleep(3)
coll3.drop()
time.sleep(3)
self.assertEqual(len(self.conn.list()), original_count)
def test_reload(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
time.sleep(3)
res = coll2.reload()
self.assertTrue(getattr(res, "success") is not None)
coll2.drop()
def test_split_shard(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
time.sleep(3)
res = coll2.split_shard("shard1",
ranges="80000000-90000000,90000001-7fffffff")
time.sleep(3)
self.assertTrue(getattr(res, "success") is not None)
coll2.drop()
def test_create_shard(self):
coll2 = self.conn.create_collection("coll2",
router_name="implicit",
shards="myshard1",
max_shards_per_node=3,
**self.collparams)
time.sleep(3)
res = coll2.create_shard("shard_my")
time.sleep(3)
self.assertTrue(getattr(res, "success") is not None)
coll2.drop()
def test_create_delete_alias(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
coll2.create_alias("alias2")
time.sleep(3)
self.assertTrue(self.conn.alias2.is_alias())
coll2.delete_alias("alias2")
coll2.drop()
def test_delete_replica(self):
try:
coll2 = self.conn.create_collection("test_delete_replica",
router_name="implicit",
shards="myshard1",
max_shards_per_node=6,
replication_factor=2,
**self.collparams)
except ReadTimeout:
print("Encountered read timeout while testing delete replicate")
print(
"This generally doesn't mean the collection wasn't created with the settings passed."
)
coll2 = self.conn["test_delete_replica"]
time.sleep(3)
firstReplica = list(
coll2.shards["shards"]["myshard1"]["replicas"].dict.keys())[0]
result = coll2.delete_replica(firstReplica, "myshard1")
self.assertTrue(result.success)
coll2.drop()
class TestCollectionSearch(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv("SOLR_VERSION", "6.1.0"))
self.collparams = {}
confname = os.getenv("SOLR_CONFNAME", "")
if confname != "":
self.collparams["collection_config_name"] = confname
def test_add(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
def test_delete(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# delete w/ object
so = SearchOptions()
so.commonparams.q("id:1")
coll2.delete(so)
res = coll2.search({"q": "id:1"}).result
self.assertTrue(len(res.response.docs) == 0)
# delete w/ dict
so = {"q": "id:2"}
coll2.delete(so)
res = coll2.search({"q": "id:2"}).result
self.assertTrue(len(res.response.docs) == 0)
coll2.drop()
def test_custom_params_search(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
res_1 = coll2.add(docs, {"omitHeader": "false"})
self.assertEqual(0, res_1.responseHeader.status)
coll2.commit()
res_2 = coll2.search({"q": "id:1", "omitHeader": "false"}).result
self.assertEqual(0, res_2.responseHeader.status)
def test_post_body_search(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
docs = [{"id": str(_id), "includes": "silly text"} for _id in range(5)]
coll2.add(docs)
coll2.commit()
# JSON DSL Query format
res = coll2.search({}, "POST", '{"query": "id:1"}').result
self.assertTrue(len(res.response.docs) == 1)
coll2.drop()
class TestCollectionAdmin(unittest.TestCase):
def setUp(self):
self.conn = SolrConnection(version=os.getenv("SOLR_VERSION", "6.1.0"))
self.collparams = {}
confname = os.getenv("SOLR_CONFNAME", "")
if confname != "":
self.collparams["collection_config_name"] = confname
def test_create_collection(self):
original_count = len(self.conn.list())
coll2 = self.conn.create_collection("coll2", **self.collparams)
self.assertEqual(len(self.conn.list()), original_count + 1)
self.conn.list()
time.sleep(3)
coll3 = self.conn.create_collection("coll3", **self.collparams)
self.assertEqual(len(self.conn.list()), original_count + 2)
# todo calling state here means the integration works, but what should we assert?
coll2.state
coll2.drop()
self.assertEqual(len(self.conn.list()), original_count + 1)
time.sleep(3)
coll3.drop()
self.assertEqual(len(self.conn.list()), original_count)
def test_reload(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
time.sleep(3)
res = coll2.reload()
self.assertTrue(getattr(res, "success") is not None)
coll2.drop()
def test_split_shard(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
time.sleep(3)
res = coll2.split_shard("shard1", ranges="80000000-90000000,90000001-7fffffff")
time.sleep(3)
self.assertTrue(getattr(res, "success") is not None)
coll2.drop()
def test_create_shard(self):
coll2 = self.conn.create_collection(
"coll2", router_name="implicit", shards="myshard1", max_shards_per_node=3, **self.collparams
)
time.sleep(3)
res = coll2.create_shard("shard_my")
time.sleep(3)
self.assertTrue(getattr(res, "success") is not None)
coll2.drop()
def test_create_delete_alias(self):
coll2 = self.conn.create_collection("coll2", **self.collparams)
coll2.create_alias("alias2")
time.sleep(3)
self.assertTrue(self.conn.alias2.is_alias())
coll2.delete_alias("alias2")
coll2.drop()
def test_delete_replica(self):
try:
coll2 = self.conn.create_collection(
"test_delete_replica",
router_name="implicit",
shards="myshard1",
max_shards_per_node=6,
replication_factor=2,
**self.collparams
)
except ReadTimeout:
print "Encountered read timeout while testing delete replicate"
print "This generally doesn't mean the collection wasn't created with the settings passed."
coll2 = self.conn["test_delete_replica"]
time.sleep(3)
coll2.delete_replica("core_node2", "myshard1")
coll2.drop()
