def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
instance.port.return_value = [{
'HostIp': '127.0.0.1',
'HostPort': 1234
}]
instance.containers.return_value = [{
u'Command':
u'/entrypoint.sh redis-server',
u'Created':
1443632967,
u'Id':
u'mocked',
u'Image':
u'redis',
u'Labels': {},
u'Names': [u'/livetest-redis-tLJpZ'],
u'Ports': [{
u'PrivatePort': 6379,
u'Type': u'tcp'
}],
u'Status':
u'Up About a minute'
}]
self.instance = instance
self.builder = SolrDockerRunner(network_mode="host")
def setUp(self):
"""
Starts a solr node for all the tests
"""
self.name = 'livetest-solr-{}'.format(gen_salt(5))
self.builder = SolrDockerRunner(
name=self.name,
)
self.builder.start()
self.port = self.builder.client.port(
self.builder.container['Id'],
8983
)[0]['HostPort']
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
instance.port.return_value = [{'HostIp': '127.0.0.1', 'HostPort': 1234}]
instance.containers.return_value = [
{
u'Command': u'/entrypoint.sh redis-server',
u'Created': 1443632967,
u'Id': u'mocked',
u'Image': u'redis',
u'Labels': {},
u'Names': [u'/livetest-redis-tLJpZ'],
u'Ports': [{u'PrivatePort': 6379, u'Type': u'tcp'}],
u'Status': u'Up About a minute'
}
]
self.instance = instance
self.builder = SolrDockerRunner(network_mode="host")
class TestSolrProvisioner(unittest.TestCase):
"""
Test the SolrProvisioner. Use the Docker builder to create the index
"""
def setUp(self):
"""
Starts a solr node for all the tests
"""
self.name = 'livetest-solr-{}'.format(gen_salt(5))
self.builder = SolrDockerRunner(
name=self.name,
)
self.builder.start()
self.port = self.builder.client.port(
self.builder.container['Id'],
8983
)[0]['HostPort']
def tearDown(self):
"""
Tears down the consul node used by the tests
"""
self.builder.teardown()
def _provision(self, service):
"""
Run the provision for a given service
"""
SolrProvisioner(service, container=self.builder)()
def test_provisioning_recommender_service(self):
"""
First run the provisioner and then we can check that the documents have been added to the solr index
"""
self._provision('recommender')
# Obtain what we expect to find
config_file = '{}/{}/recommender/recommender.json'.format(
SolrProvisioner.template_dir,
SolrProvisioner.name,
)
with open(config_file) as json_file:
config = json.load(json_file)
# Compare with consul
for document in config:
response = requests.get('http://{host}:{port}/solr/query?q=bibcode:{bibcode}'.format(
host='localhost',
port=self.port,
bibcode=document['bibcode'])
)
self.assertEqual(
200,
response.status_code,
msg='We expect a 200 response but got: {}, {}'.format(response.status_code, response.json())
)
actual_document = response.json()['response']['docs'][0]
# Not all key/values are returned in the same fashion, so the following specified are some hand-picked
# keywords that we want to test were entered correctly into Solr
known_keys = ['pubdate', 'first_author', 'abstract', 'read_count', 'doctype', 'year', 'bibcode', 'volume']
for key in known_keys:
self.assertIn(
key,
actual_document.keys(),
msg='Could not find key "{}" in response: {}'.format(key, actual_document.keys())
)
self.assertEqual(
document[key],
actual_document[key],
msg='Key "{}" mismatch: expected "{}" != actual "{}"'.format(
key,
document[key],
actual_document[key]
)
)
class TestSolrDockerRunner(unittest.TestCase):
"""
Test the docker runner specifically for Solr
"""
@mock.patch('mc.builders.Client')
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
instance.port.return_value = [{'HostIp': '127.0.0.1', 'HostPort': 1234}]
instance.containers.return_value = [
{
u'Command': u'/entrypoint.sh redis-server',
u'Created': 1443632967,
u'Id': u'mocked',
u'Image': u'redis',
u'Labels': {},
u'Names': [u'/livetest-redis-tLJpZ'],
u'Ports': [{u'PrivatePort': 6379, u'Type': u'tcp'}],
u'Status': u'Up About a minute'
}
]
self.instance = instance
self.builder = SolrDockerRunner(network_mode="host")
def test_ready(self):
"""
Tests the health check of the service
"""
with mock.patch.object(mc.builders.requests,
'get',
side_effect=requests.ConnectionError):
self.assertFalse(self.builder.ready)
with HTTMock(response_500):
self.assertFalse(self.builder.ready)
with HTTMock(response_404):
self.assertTrue(self.builder.ready)
@mock.patch('mc.builders.PostgresDockerRunner.service_provisioner')
def test_can_provision(self, mocked):
"""
Tests that there is a method that allows provisioning
"""
self.builder.provision(services=['adsaws'])
mocked.assert_has_calls([
mock.call(container=self.builder, requirements=None, services=['adsaws']),
mock.call()()
])
@mock.patch('mc.builders.SolrDockerRunner.service_provisioner')
def test_can_provision(self, mocked):
"""
Tests that there is a method that allows provisioning
"""
self.builder.provision(services=['recommender'])
mocked.assert_has_calls([
mock.call(container=self.builder, requirements=None, services=['recommender']),
mock.call()()
])
@mock.patch('mc.builders.SolrDockerRunner.service_provisioner')
def test_does_not_raise_for_non_existing_service(self, mocked):
"""
Tests that it skips services it does not know about
"""
instance = mocked.return_value
try:
self.builder.provision(services=['unknown_service'])
except Exception as e:
self.fail('Provisioning failed: {}'.format(e))
self.assertTrue(instance.called)
class TestSolrDockerRunner(unittest.TestCase):
"""
Test the docker runner specifically for Solr
"""
@mock.patch('mc.builders.Client')
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
instance.port.return_value = [{
'HostIp': '127.0.0.1',
'HostPort': 1234
}]
instance.containers.return_value = [{
u'Command':
u'/entrypoint.sh redis-server',
u'Created':
1443632967,
u'Id':
u'mocked',
u'Image':
u'redis',
u'Labels': {},
u'Names': [u'/livetest-redis-tLJpZ'],
u'Ports': [{
u'PrivatePort': 6379,
u'Type': u'tcp'
}],
u'Status':
u'Up About a minute'
}]
self.instance = instance
self.builder = SolrDockerRunner(network_mode="host")
def test_ready(self):
"""
Tests the health check of the service
"""
with mock.patch.object(mc.builders.requests,
'get',
side_effect=requests.ConnectionError):
self.assertFalse(self.builder.ready)
with HTTMock(response_500):
self.assertFalse(self.builder.ready)
with HTTMock(response_404):
self.assertTrue(self.builder.ready)
@mock.patch('mc.builders.PostgresDockerRunner.service_provisioner')
def test_can_provision(self, mocked):
"""
Tests that there is a method that allows provisioning
"""
self.builder.provision(services=['adsaws'])
mocked.assert_has_calls([
mock.call(container=self.builder,
requirements=None,
services=['adsaws']),
mock.call()()
])
@mock.patch('mc.builders.SolrDockerRunner.service_provisioner')
def test_can_provision(self, mocked):
"""
Tests that there is a method that allows provisioning
"""
self.builder.provision(services=['recommender'])
mocked.assert_has_calls([
mock.call(container=self.builder,
requirements=None,
services=['recommender']),
mock.call()()
])
@mock.patch('mc.builders.SolrDockerRunner.service_provisioner')
def test_does_not_raise_for_non_existing_service(self, mocked):
"""
Tests that it skips services it does not know about
"""
instance = mocked.return_value
try:
self.builder.provision(services=['unknown_service'])
except Exception as e:
self.fail('Provisioning failed: {}'.format(e))
self.assertTrue(instance.called)
def setUp(self):
self.name = 'livetest-solr-{}'.format(gen_salt(5))
self.builder = SolrDockerRunner(name=self.name, )
