def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
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'
}]
instance.create_host_config.return_value = {
'NetworkMode': 'host',
"Memory": 104857600
}
self.instance = instance
self.builder = DockerRunner(image='redis',
name='redis',
mem_limit="100m",
network_mode="host")
def setUp(self):
self.name = 'livetest-redis-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image=config.DEPENDENCIES['REDIS']['IMAGE'],
name=self.name,
mem_limit="50m",
)
class TestDockerRunner(unittest.TestCase):
"""
Test the docker runner
"""
def setUp(self):
self.name = 'livetest-redis-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image=config.DEPENDENCIES['REDIS']['IMAGE'],
name=self.name,
mem_limit="50m",
)
def tearDown(self):
"""
the teardown() method should result in the container being stopped and
removed
"""
self.builder.teardown()
print self.builder.client.containers(
filters={'status': 'running'}
)
running = [i['Names'][0] for i in self.builder.client.containers(
filters={'status': 'running'}
)]
self.assertNotIn(self.name, running)
self.assertNotIn(
{'Id': self.builder.container['Id']},
self.builder.client.containers(quiet=True, all=True)
)
def test_initialization(self):
"""
the Dockerrunner.setup() method should modify its container
attribute, that container should exist in `docker ps -a`
"""
self.assertIn('Id', self.builder.container)
self.assertIn(
{'Id': self.builder.container['Id']},
self.builder.client.containers(quiet=True, all=True)
)
def test_start(self):
"""
the start() method should run an option callback after calling
docker.Client.start with the expected container id
The container should be listed in `docker ps`
"""
def cb(container):
self.assertEqual(container['Id'], self.builder.container['Id'])
self.builder.start(callback=cb)
running = [i['Id'] for i in self.builder.client.containers(
filters={'status': 'running'}
)]
self.assertIn(self.builder.container['Id'], running)
class TestDockerRunner(unittest.TestCase):
"""
Test the docker runner
"""
def setUp(self):
self.name = 'livetest-redis-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image=config.DEPENDENCIES['REDIS']['IMAGE'],
name=self.name,
mem_limit="50m",
)
def tearDown(self):
"""
the teardown() method should result in the container being stopped and
removed
"""
self.builder.teardown()
print self.builder.client.containers(filters={'status': 'running'})
running = [
i['Names'][0] for i in self.builder.client.containers(
filters={'status': 'running'})
]
self.assertNotIn(self.name, running)
self.assertNotIn({'Id': self.builder.container['Id']},
self.builder.client.containers(quiet=True, all=True))
def test_initialization(self):
"""
the Dockerrunner.setup() method should modify its container
attribute, that container should exist in `docker ps -a`
"""
self.assertIn('Id', self.builder.container)
self.assertIn({'Id': self.builder.container['Id']},
self.builder.client.containers(quiet=True, all=True))
def test_start(self):
"""
the start() method should run an option callback after calling
docker.Client.start with the expected container id
The container should be listed in `docker ps`
"""
def cb(container):
self.assertEqual(container['Id'], self.builder.container['Id'])
self.builder.start(callback=cb)
running = [
i['Id'] for i in self.builder.client.containers(
filters={'status': 'running'})
]
self.assertIn(self.builder.container['Id'], running)
class TestDockerRunner(unittest.TestCase):
"""
Test the docker runner
"""
@mock.patch('mc.builders.Client')
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
self.instance = instance
self.builder = DockerRunner(
image='redis',
name='redis',
mem_limit="100m",
network_mode="host"
)
def test_initialization(self):
"""
the Dockerrunner.setup() method should modify its container
attribute, and client.create_container should be called with the
expected kwargs
"""
self.assertEqual(self.builder.container, {'Id': 'mocked'})
self.instance.create_container.assert_called_with(
host_config={'NetworkMode': 'host', "Memory": 104857600},
name='redis',
image='redis',
command=None
)
self.instance.pull.assert_called_with('redis')
def test_start(self):
"""
the start() method should run an option callback after calling
docker.Client.start with the expected container id
"""
def cb(container):
self.assertEqual(container, {'Id': 'mocked'})
self.builder.start(callback=cb)
self.instance.start.assert_called_with(container='mocked')
def test_teardown(self):
"""
the teardown() method should be called with the correct container id
"""
self.builder.teardown()
self.instance.stop.assert_called_with(container='mocked')
self.instance.remove_container.assert_called_with(container='mocked')
def setUp(self):
self.name = 'livetest-redis-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image=config.DEPENDENCIES['REDIS']['IMAGE'],
name=self.name,
mem_limit="50m",
)
def setUp(self):
self.name = 'livetest-redis-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image='redis',
name=self.name,
mem_limit="50m",
)
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
self.instance = instance
self.builder = DockerRunner(
image='redis',
name='redis',
mem_limit="100m",
network_mode="host"
)
class TestBaseDockerRunner(unittest.TestCase):
def setUp(self):
self.name = 'livetest-service-{}'.format(gen_salt(5))
self.builder = DockerRunner(name=self.name, )
def tearDown(self):
"""
teardown the containers
"""
try:
self.builder.teardown()
except:
pass
def helper_is_service_ready(self):
"""
Check if the instance is ready
"""
self.builder.start()
self.assertTrue(self.builder.running)
self.assertTrue(self.builder.ready)
self.builder.teardown()
self.assertFalse(self.builder.ready)
self.assertFalse(self.builder.running)
class TestBaseDockerRunner(unittest.TestCase):
def setUp(self):
self.name = 'livetest-service-{}'.format(gen_salt(5))
self.builder = DockerRunner(
name=self.name,
)
def tearDown(self):
"""
teardown the containers
"""
try:
self.builder.teardown()
except:
pass
def helper_is_service_ready(self):
"""
Check if the instance is ready
"""
self.builder.start()
self.assertTrue(self.builder.running)
self.assertTrue(self.builder.ready)
self.builder.teardown()
self.assertFalse(self.builder.ready)
self.assertFalse(self.builder.running)
def setUp(self):
self.name = 'livetest-postgres-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image='postgres',
name=self.name,
mem_limit="50m",
port_bindings={5432: None},
)
self.builder.start()
self.port = self.builder.client.port(
self.builder.container['Id'],
5432
)[0]['HostPort']
# Give some seconds for postgres to warm up and become available
time.sleep(10)
def setUp(self):
"""
Starts a consul node for all the tests
"""
self.name = 'livetest-consul-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image='adsabs/consul:v1.0.0',
name=self.name,
mem_limit="50m",
port_bindings={8500: None},
command=['-server', '-bootstrap']
)
self.builder.start()
self.port = self.builder.client.port(
self.builder.container['Id'],
8500
)[0]['HostPort']
# Let consul start
time.sleep(5)
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
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'
}
]
instance.create_host_config.return_value = {'NetworkMode': 'host', "Memory": 104857600}
self.instance = instance
self.builder = DockerRunner(
image='redis',
name='redis',
mem_limit="100m",
network_mode="host"
)
class TestDockerRunner(unittest.TestCase):
"""
Test the docker runner
"""
@mock.patch('mc.builders.Client')
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
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'
}
]
instance.create_host_config.return_value = {'NetworkMode': 'host', "Memory": 104857600}
self.instance = instance
self.builder = DockerRunner(
image='redis',
name='redis',
mem_limit="100m",
network_mode="host"
)
def test_initialization(self):
"""
the Dockerrunner.setup() method should modify its container
attribute, and client.create_container should be called with the
expected kwargs
"""
self.assertEqual(self.builder.container, {'Id': 'mocked'})
self.instance.create_container.assert_called_with(
host_config={'NetworkMode': 'host', "Memory": 104857600},
name='redis',
image='redis',
command=None,
environment=None
)
self.instance.pull.assert_called_with('redis')
def test_start(self):
"""
the start() method should run an option callback after calling
docker.Client.start with the expected container id
"""
def cb(container):
self.assertEqual(container, {'Id': 'mocked'})
self.builder.start(callback=cb)
self.instance.start.assert_called_with(container='mocked')
def test_teardown(self):
"""
the teardown() method should be called with the correct container id
"""
self.builder.time_out = 0.1
self.builder.teardown()
self.instance.stop.assert_called_with(container='mocked')
self.instance.remove_container.assert_called_with(container='mocked')
def test_running(self):
"""
Tests if the docker container is running
"""
self.instance.containers.return_value = []
self.assertFalse(self.builder.running)
self.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.assertTrue(self.builder.running)
def test_can_provision(self):
"""
Tests that there is a method that allows provisioning
"""
self.assertIsNone(self.builder.provision(services=['adsaws']))
class TestPostgresProvisioner(unittest.TestCase):
"""
Test the PostgresProvisioner. Use the Docker builder to create the database
"""
def setUp(self):
self.name = 'livetest-postgres-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image='postgres',
name=self.name,
mem_limit="50m",
port_bindings={5432: None},
)
self.builder.start()
self.port = self.builder.client.port(
self.builder.container['Id'],
5432
)[0]['HostPort']
# Give some seconds for postgres to warm up and become available
time.sleep(10)
def tearDown(self):
self.builder.teardown()
def _make_db_connection(self, db, user=None):
"""
retruns a sqlalchemy connection object to a database
"""
if user is None:
user = db
engine = create_engine(
'postgresql://{user}@localhost:{port}/{db}'.format(
user=user, port=self.port, db=db
)
)
return engine.connect()
def _provision(self, service):
"""
Run the provision for a given service
"""
# Modifying a live application's config is the most straightforward
# way to connect to a non-default port for this test case
app = create_app()
app.config['DEPENDENCIES']['POSTGRES']['PORT'] = self.port
with app.app_context():
PostgresProvisioner(service)()
def test_provisioning_adsws(self):
"""
after running the provisioner, make sure that the anon user and
anon oauth2client exist within the postgres instance
"""
self._provision('adsws')
conn = self._make_db_connection('adsws')
res = conn.execute('SELECT * FROM users').fetchall()
anon_user = filter(
lambda i: i['email'] == 'anonymous@ads',
res,
)[0]
self.assertIsNotNone(anon_user)
res = conn.execute('SELECT * FROM oauth2client').fetchall()
anon_client = filter(
lambda i: i['user_id'] == anon_user['id'],
res,
)
self.assertIsNotNone(anon_client)
def test_provisioning_recommender(self):
"""
after running the provisioner, make sure that the recommender has the
expected tables and that they return at least 1 row
"""
self._provision('recommender')
conn = self._make_db_connection('recommender')
coreads = conn.execute('SELECT * FROM coreads').fetchall()
clusters = conn.execute('SELECT * FROM clusters').fetchall()
clustering = conn.execute('SELECT * FROM clustering').fetchall()
self.assertGreater(len(coreads), 0)
self.assertGreater(len(clusters), 0)
self.assertGreater(len(clustering), 0)
class TestDockerRunner(unittest.TestCase):
"""
Test the docker runner
"""
@mock.patch('mc.builders.Client')
def setUp(self, mocked):
instance = mocked.return_value
instance.create_container.return_value = {'Id': 'mocked'}
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'
}]
instance.create_host_config.return_value = {
'NetworkMode': 'host',
"Memory": 104857600
}
self.instance = instance
self.builder = DockerRunner(image='redis',
name='redis',
mem_limit="100m",
network_mode="host")
def test_initialization(self):
"""
the Dockerrunner.setup() method should modify its container
attribute, and client.create_container should be called with the
expected kwargs
"""
self.assertEqual(self.builder.container, {'Id': 'mocked'})
self.instance.create_container.assert_called_with(host_config={
'NetworkMode': 'host',
"Memory": 104857600
},
name='redis',
image='redis',
command=None,
environment=None)
self.instance.pull.assert_called_with('redis')
def test_start(self):
"""
the start() method should run an option callback after calling
docker.Client.start with the expected container id
"""
def cb(container):
self.assertEqual(container, {'Id': 'mocked'})
self.builder.start(callback=cb)
self.instance.start.assert_called_with(container='mocked')
def test_teardown(self):
"""
the teardown() method should be called with the correct container id
"""
self.builder.time_out = 0.1
self.builder.teardown()
self.instance.stop.assert_called_with(container='mocked')
self.instance.remove_container.assert_called_with(container='mocked')
def test_running(self):
"""
Tests if the docker container is running
"""
self.instance.containers.return_value = []
self.assertFalse(self.builder.running)
self.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.assertTrue(self.builder.running)
def test_can_provision(self):
"""
Tests that there is a method that allows provisioning
"""
self.assertIsNone(self.builder.provision(services=['adsaws']))
def setUp(self):
self.name = 'livetest-service-{}'.format(gen_salt(5))
self.builder = DockerRunner(name=self.name, )
class TestConsulProvisioner(unittest.TestCase):
"""
Test the ConsulProvisioner. Use the Docker builder to create the key/value
store
"""
def setUp(self):
"""
Starts a consul node for all the tests
"""
self.name = 'livetest-consul-{}'.format(gen_salt(5))
self.builder = DockerRunner(
image='adsabs/consul:v1.0.0',
name=self.name,
mem_limit="50m",
port_bindings={8500: None},
command=['-server', '-bootstrap']
)
self.builder.start()
self.port = self.builder.client.port(
self.builder.container['Id'],
8500
)[0]['HostPort']
# Let consul start
time.sleep(5)
def tearDown(self):
"""
Tears down the consul node used by the tests
"""
self.builder.teardown()
def test_running_consul(self):
"""
Checks that consul is started correctly via docker
"""
response = requests.get('http://localhost:{}'
.format(self.port))
self.assertEqual(
response.status_code,
200,
msg='Consul service is non-responsive: {}'.format(response.text)
)
def _provision(self, service):
"""
Run the provision for a given service
"""
app = create_app()
app.config['DEPENDENCIES']['CONSUL']['PORT'] = self.port
with app.app_context():
ConsulProvisioner(service)()
def test_provisioning_adsws_service(self):
"""
First run the provisioner and then we can check that some configuration
values have been correctly set in the key/value store
"""
self._provision('adsws')
# Obtain what we expect to find
config_file = '{}/{}/adsws/adsws.config.json'.format(
ConsulProvisioner.template_dir,
ConsulProvisioner.name,
)
with open(config_file) as json_file:
config = json.load(json_file)
# Compare with consul
consul = consulate.Consul(port=self.port)
for key in config:
self.assertIn(key, consul.kv.keys())
self.assertEqual(config[key], json.loads(consul.kv.get(key)))
def setUp(self):
self.name = 'livetest-service-{}'.format(gen_salt(5))
self.builder = DockerRunner(
name=self.name,
)
