class AsyncTaskTest(TestCase):
def setUp(self):
self.get_redis = patch('celery_once.backends.redis.get_redis')
self.mocked_redis = self.get_redis.start()
self.redis = FakeStrictRedis()
self.mocked_redis.return_value = self.redis
@patch('delft3dcontainermanager.tasks.call_command')
def test_delft3dgt_pulse(self, mockCall):
"""
Assert that de delft3dgt_pulse task
calls the containersync_sceneupdate() only once.
"""
delft3dgt_pulse.delay()
# Set redis key with TTL 100 seconds from now
# so subsequent tasks won't run
self.redis.set('qo_delft3dcontainermanager.tasks.delft3dgt_pulse',
int(time()) + 100)
delft3dgt_pulse.delay()
delft3dgt_pulse.delay()
mockCall.assert_called_with('containersync_sceneupdate')
self.assertEqual(mockCall.call_count, 1)
def tearDown(self):
self.redis.flushall()
self.get_redis.stop()
def main():
redis = StrictRedis(**config)
fakeredis = FakeStrictRedis()
redis.flushall()
fakeredis.flushall()
print '[+] FakeRedis BLPOP:'
now = time()
popped = fakeredis.blpop('hello_world', 10)
print '[*] Took %.2f seconds' % (time() - now)
print '[*] Popped value:', popped
print
print '[+] Redis BLPOP:'
now = time()
popped = redis.blpop('hello_world', 10)
print '[*] Took %.2f seconds' % (time() - now)
print '[*] Popped value:', popped
def redis_storage():
redis = FakeStrictRedis()
yield CircuitRedisStorage(CircuitBreakerState.CLOSED, redis)
redis.flushall()
def redis(monkeypatch):
fake_redis = FakeStrictRedis()
fake_redis.flushall()
monkeypatch.setattr("celery_once.backends.redis.Redis.redis", fake_redis)
return fake_redis
class ManagementTest(TestCase):
mock_options = {
'autospec': True,
}
def setUp(self):
self.scene = Scene.objects.create(
name='Scene',
phase=Scene.phases.new
)
self.container_1_1 = Container.objects.create(
scene=self.scene,
container_type='preprocess',
docker_id='abcdefg'
)
self.container_1_0 = Container.objects.create(
scene=self.scene,
container_type='delft3d',
docker_id=''
)
self.container_0_1 = Container.objects.create(
scene=self.scene,
container_type='process',
docker_id='hijklmn'
)
# a freshly created Scene
self.scene_new = Scene.objects.create(
name='Scene_New',
phase=Scene.phases.fin
)
self.container_1_1_new = Container.objects.create(
scene=self.scene_new,
container_type='preprocess',
desired_state='created',
docker_state='non-existent',
docker_id=''
)
self.container_1_0_new = Container.objects.create(
scene=self.scene_new,
container_type='delft3d',
desired_state='created',
docker_state='non-existent',
docker_id=''
)
self.container_0_1_new = Container.objects.create(
scene=self.scene_new,
container_type='process',
desired_state='created',
docker_state='non-existent',
docker_id=''
)
self.get_redis = patch('celery_once.backends.redis.get_redis')
self.mocked_redis = self.get_redis.start()
self.redis = FakeStrictRedis()
self.mocked_redis.return_value = self.redis
@patch('delft3dworker.management.commands.'
'containersync_sceneupdate.Container.update_from_docker_snapshot')
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
def test_containersync_sceneupdate(self, mockClient, mockContainerupdate):
"""
Test match matrix for docker containers and model containers
TODO: Add test case with timeout error as return_value
"""
def inspect(container=''):
return {'Id': container, 'Config': {'Labels': {'type': 'preprocess'}}}
client = mockClient.return_value
client.containers.return_value = [{'Id': 'abcdefg', 'Status': 'running',
'Config': {'Labels': {'type': 'preprocess'}}},
{'Id': 'orphan', 'Status': 'running',
'Config': {'Labels': {'type': 'preprocess'}}}]
client.inspect_container.side_effect = inspect
out = StringIO()
call_command('containersync_sceneupdate', stderr=out)
# Docker container not in database
self.assertIn(
'Docker container orphan not found in database!', out.getvalue())
client.remove_container.assert_called_with(
container='orphan', force=True)
# Docker container in database
self.assertEqual(mockContainerupdate.call_count, 2)
mockContainerupdate.assert_called_with(
{'Config': {'Labels': {'type': 'preprocess'}}, 'Id': 'abcdefg'})
@patch('delft3dworker.management.commands.'
'containersync_sceneupdate.Container.update_from_docker_snapshot')
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
@patch('delft3dworker.management.commands.'
'containersync_sceneupdate.AsyncResult')
def test_containersync_scenekill(self, mockAsync, mockClient, mockContainerupdate):
"""
Test match matrix for docker containers and model containers
TODO: Add test case with timeout error as return_value
"""
client = mockClient.return_value
client.containers.return_value = [{'Id': 'abcdefg', 'Status': 'running',
'Config': {'Labels': {'type': 'notfromhere'}}},
{'Id': 'orphan', 'Status': 'running',
'Config': {'Labels': {'type': 'notfromhere'}}}]
def getresult():
return {'status': 'SUCCESS'}
# Mock celery result
result = mockAsync.return_value
result._get_task_meta.side_effect = getresult
result.result = client.containers.return_value
out = StringIO()
call_command('containersync_sceneupdate', stderr=out)
# Docker container not in database
assert not client.remove_container.called
@patch('delft3dworker.management.commands.'
'containersync_sceneupdate.Scene._local_scan_process')
def test_scanbucket_command(self, mocklocalscan):
call_command('scanbucket')
self.assertEqual(mocklocalscan.call_count, 1)
def tearDown(self):
self.redis.flushall()
self.get_redis.stop()
class TestStart(_TestOnPost):
# noinspection PyAttributeOutsideInit
def before(self):
super(TestStart, self).before()
self.redis = FakeStrictRedis()
self.resource = Start(self.redis)
self.api.add_route('/start/{game_id}', self.resource)
def after(self):
self.redis.flushall()
del self.redis
def test_without_userinfo(self):
body = self.simulate_request('/start/1', decode='utf-8', method='POST')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIsNone(self.redis.hget('game:1:run', data['run_id']),
'redis run hash should be empty')
self.assertIsNone(self.redis.hget('game:1:start', data['run_id']),
'redis start hash should be empty')
def test_with_uid(self):
_uid = 25
query_string = urlencode({
'uid': _uid,
'userinfo': 'nothing',
'hash': '1234'
})
body = self.simulate_request('/start/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertEquals(_uid, data['uid'], 'use the old uid')
self.assertEquals(str(data['uid']),
self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertIsNone(self.redis.hget('game:1:userinfo', data['uid']),
'should not save userinfo')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']),
'should record start time')
def test_with_userinfo_only(self):
query_string = urlencode(
{'userinfo': json.dumps({
'a': '1',
'b': '2'
})})
body = self.simulate_request('/start/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_400, self.srmock.status)
data = json.loads(body)
self.assertEquals('Missing parameter', data['title'])
def test_with_userinfo_and_hash(self):
_hash = 105
_userinfo = json.dumps({'field1': u'王思聪', 'field2': '15888888888'})
query_string = urlencode({'userinfo': _userinfo, 'hash': _hash})
body = self.simulate_request('/start/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertEquals(_hash, data['uid'], 'use the old uid')
self.assertEquals(str(data['uid']),
self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertEquals(_userinfo,
self.redis.hget('game:1:userinfo', data['uid']),
'store userinfo and uid in redis')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']),
'should record start time')
def test_with_userinfo_and_hash_collision(self):
_hash = 105
_userinfo = json.dumps({'field1': u'王思聪', 'field2': '15888888888'})
query_string = urlencode({'userinfo': _userinfo, 'hash': _hash})
self.redis.hset('game:1:userinfo', _hash, 'something different')
body = self.simulate_request('/start/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertNotEquals(
_hash, data['uid'],
'generate a new uid different from original hash')
self.assertEquals(str(data['uid']),
self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertEquals(_userinfo,
self.redis.hget('game:1:userinfo', data['uid']),
'store userinfo and uid in redis')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']),
'should record start time')
def test_with_used_userinfo_and_hash(self):
_hash = 105
_userinfo = json.dumps({'field1': u'王思聪', 'field2': '15888888888'})
query_string = urlencode({'userinfo': _userinfo, 'hash': _hash})
self.redis.hset('game:1:userinfo', _hash, _userinfo)
body = self.simulate_request('/start/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertEquals(_hash, data['uid'], 'use the original hash as uid')
self.assertEquals(str(data['uid']),
self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertEquals(_userinfo,
self.redis.hget('game:1:userinfo', data['uid']),
'store userinfo and uid in redis')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']),
'should record start time')
class TestEnd(_TestOnPost):
# noinspection PyAttributeOutsideInit
def before(self):
super(TestEnd, self).before()
self.redis = FakeStrictRedis()
self.redis.zadd('game:1:scores', 100, 100)
self.redis.zadd('game:1:scores', 110, 110)
self.resource = End(self.redis)
self.api.add_route('/end/{game_id}', self.resource)
self.api.req_options.auto_parse_form_urlencoded = True
def after(self):
self.redis.flushall()
del self.redis
def test_without_uid(self):
_run_id = 'some_random_thing'
_score = 105
query_string = urlencode({'run_id': _run_id, 'score': _score})
body = self.simulate_request('/end/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertNotIn('best_score', data, 'no best_score')
self.assertNotIn('best_rank', data, 'no best_rank')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(str(_score), self.redis.hget('game:1:final',
_run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id),
'should record end time')
def test_with_uid(self):
_run_id = 'some_random_thing'
_score = 105
_uid = 15
query_string = urlencode({
'run_id': _run_id,
'score': _score,
'uid': _uid
})
body = self.simulate_request('/end/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertIn('best_score', data, 'best_score has been set')
self.assertIn('best_rank', data, 'best_rank has been set')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(_score, data['best_score'],
'score should be set as best score')
self.assertEquals(1, data['best_rank'], 'best_rank should be 1')
self.assertEquals(str(_score), self.redis.hget('game:1:final',
_run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id),
'should record end time')
def test_update_best_records(self):
_run_id = 'some_random_thing'
_score = 105
_uid = 15
query_string = urlencode({
'run_id': _run_id,
'score': _score,
'uid': _uid
})
self.redis.hset('game:1:record:scores', _uid, 100)
self.redis.hset('game:1:record:ranks', _uid, 2)
body = self.simulate_request('/end/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertIn('best_score', data, 'best_score has been set')
self.assertIn('best_rank', data, 'best_rank has been set')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(_score, data['best_score'],
'score should be set as best score')
self.assertEquals(1, data['best_rank'], 'best_rank should be 1')
self.assertEquals(str(_score), self.redis.hget('game:1:final',
_run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id),
'should record end time')
def test_oot_update(self):
_run_id = 'some_random_thing'
_score = 105
_uid = 15
query_string = urlencode({
'run_id': _run_id,
'score': _score,
'uid': _uid
})
self.redis.hset('game:1:record:scores', _uid, 150)
self.redis.hset('game:1:record:ranks', _uid, 0)
body = self.simulate_request('/end/1',
method='POST',
query_string=query_string,
decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertIn('best_score', data, 'best_score has been set')
self.assertIn('best_rank', data, 'best_rank has been set')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(150, data['best_score'], 'score should be 150')
self.assertEquals(0, data['best_rank'], 'best_rank should be 0')
self.assertEquals(str(_score), self.redis.hget('game:1:final',
_run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id),
'should record end time')
class TestStart(_TestOnPost):
# noinspection PyAttributeOutsideInit
def before(self):
super(TestStart, self).before()
self.redis = FakeStrictRedis()
self.resource = Start(self.redis)
self.api.add_route('/start/{game_id}', self.resource)
def after(self):
self.redis.flushall()
del self.redis
def test_without_userinfo(self):
body = self.simulate_request('/start/1', decode='utf-8', method='POST')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIsNone(self.redis.hget('game:1:run', data['run_id']), 'redis run hash should be empty')
self.assertIsNone(self.redis.hget('game:1:start', data['run_id']), 'redis start hash should be empty')
def test_with_uid(self):
_uid = 25
query_string = urlencode({'uid': _uid, 'userinfo': 'nothing', 'hash': '1234'})
body = self.simulate_request('/start/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertEquals(_uid, data['uid'], 'use the old uid')
self.assertEquals(str(data['uid']), self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertIsNone(self.redis.hget('game:1:userinfo', data['uid']), 'should not save userinfo')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']), 'should record start time')
def test_with_userinfo_only(self):
query_string = urlencode({'userinfo': json.dumps({'a': '1', 'b': '2'})})
body = self.simulate_request('/start/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_400, self.srmock.status)
data = json.loads(body)
self.assertEquals('Missing parameter', data['title'])
def test_with_userinfo_and_hash(self):
_hash = 105
_userinfo = json.dumps({'field1': u'王思聪', 'field2': '15888888888'})
query_string = urlencode({'userinfo': _userinfo, 'hash': _hash})
body = self.simulate_request('/start/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertEquals(_hash, data['uid'], 'use the old uid')
self.assertEquals(str(data['uid']), self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertEquals(_userinfo, self.redis.hget('game:1:userinfo', data['uid']), 'store userinfo and uid in redis')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']), 'should record start time')
def test_with_userinfo_and_hash_collision(self):
_hash = 105
_userinfo = json.dumps({'field1': u'王思聪', 'field2': '15888888888'})
query_string = urlencode({'userinfo': _userinfo, 'hash': _hash})
self.redis.hset('game:1:userinfo', _hash, 'something different')
body = self.simulate_request('/start/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertNotEquals(_hash, data['uid'], 'generate a new uid different from original hash')
self.assertEquals(str(data['uid']), self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertEquals(_userinfo, self.redis.hget('game:1:userinfo', data['uid']), 'store userinfo and uid in redis')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']), 'should record start time')
def test_with_used_userinfo_and_hash(self):
_hash = 105
_userinfo = json.dumps({'field1': u'王思聪', 'field2': '15888888888'})
query_string = urlencode({'userinfo': _userinfo, 'hash': _hash})
self.redis.hset('game:1:userinfo', _hash, _userinfo)
body = self.simulate_request('/start/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('run_id', data, 'run_id has been set')
self.assertIn('uid', data, 'uid has been set')
self.assertEquals(_hash, data['uid'], 'use the original hash as uid')
self.assertEquals(str(data['uid']), self.redis.hget('game:1:run', data['run_id']),
'store run_id and uid in redis')
self.assertEquals(_userinfo, self.redis.hget('game:1:userinfo', data['uid']), 'store userinfo and uid in redis')
self.assertTrue(self.redis.hexists('game:1:start', data['run_id']), 'should record start time')
class TestEnd(_TestOnPost):
# noinspection PyAttributeOutsideInit
def before(self):
super(TestEnd, self).before()
self.redis = FakeStrictRedis()
self.redis.zadd('game:1:scores', 100, 100)
self.redis.zadd('game:1:scores', 110, 110)
self.resource = End(self.redis)
self.api.add_route('/end/{game_id}', self.resource)
self.api.req_options.auto_parse_form_urlencoded = True
def after(self):
self.redis.flushall()
del self.redis
def test_without_uid(self):
_run_id = 'some_random_thing'
_score = 105
query_string = urlencode({'run_id': _run_id, 'score': _score})
body = self.simulate_request('/end/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertNotIn('best_score', data, 'no best_score')
self.assertNotIn('best_rank', data, 'no best_rank')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(str(_score), self.redis.hget('game:1:final', _run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id), 'should record end time')
def test_with_uid(self):
_run_id = 'some_random_thing'
_score = 105
_uid = 15
query_string = urlencode({'run_id': _run_id, 'score': _score, 'uid': _uid})
body = self.simulate_request('/end/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertIn('best_score', data, 'best_score has been set')
self.assertIn('best_rank', data, 'best_rank has been set')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(_score, data['best_score'], 'score should be set as best score')
self.assertEquals(1, data['best_rank'], 'best_rank should be 1')
self.assertEquals(str(_score), self.redis.hget('game:1:final', _run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id), 'should record end time')
def test_update_best_records(self):
_run_id = 'some_random_thing'
_score = 105
_uid = 15
query_string = urlencode({'run_id': _run_id, 'score': _score, 'uid': _uid})
self.redis.hset('game:1:record:scores', _uid, 100)
self.redis.hset('game:1:record:ranks', _uid, 2)
body = self.simulate_request('/end/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertIn('best_score', data, 'best_score has been set')
self.assertIn('best_rank', data, 'best_rank has been set')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(_score, data['best_score'], 'score should be set as best score')
self.assertEquals(1, data['best_rank'], 'best_rank should be 1')
self.assertEquals(str(_score), self.redis.hget('game:1:final', _run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id), 'should record end time')
def test_oot_update(self):
_run_id = 'some_random_thing'
_score = 105
_uid = 15
query_string = urlencode({'run_id': _run_id, 'score': _score, 'uid': _uid})
self.redis.hset('game:1:record:scores', _uid, 150)
self.redis.hset('game:1:record:ranks', _uid, 0)
body = self.simulate_request('/end/1', method='POST', query_string=query_string, decode='utf-8')
self.assertEquals(falcon.HTTP_200, self.srmock.status)
data = json.loads(body)
self.assertIn('rank', data, 'rank has been set')
self.assertIn('best_score', data, 'best_score has been set')
self.assertIn('best_rank', data, 'best_rank has been set')
self.assertEquals(1, data['rank'], 'rank should be 1')
self.assertEquals(150, data['best_score'], 'score should be 150')
self.assertEquals(0, data['best_rank'], 'best_rank should be 0')
self.assertEquals(str(_score), self.redis.hget('game:1:final', _run_id))
self.assertTrue(self.redis.hexists('game:1:end', _run_id), 'should record end time')
class RedisworksTestCase(unittest.TestCase):
"""RedisWorks Tests."""
def setUp(self):
self.root = Root(redis=FakeStrictRedis)
self.red = FakeStrictRedis()
def tearDown(self):
# Clear data in fakeredis.
self.red.flushall()
def test_nested_format(self):
value = {1: 1, 2: {"a": "hello"}}
result = Root.doformat(value)
int_str = bTYPE_IDENTIFIER + b'num' + bITEM_DIVIDER + b'int' + bITEM_DIVIDER
expected_result = {int_str + b'1': int_str + b'1',
int_str + b'2': bTYPE_IDENTIFIER +
b'dict' + bITEM_DIVIDER +
b'dict' + bITEM_DIVIDER + b'{"a": "hello"}'}
self.assertEqual(result, expected_result)
def test_numbers(self):
today = datetime.date.today()
now = datetime.datetime.utcnow()
items = (10, 10.1, Decimal("10"), 10+1j, today, now)
for val in items:
self.root.part = val
result = self.red.get('root.part')
expected_result = Root.doformat(val)
self.assertEqual(result, expected_result)
# flushing dotobject local cache
self.root.flush()
self.assertEqual(self.root.part, val)
def test_return_string(self):
root2 = Root(redis=FakeStrictRedis, return_object=False)
val = 11.1
expected_result = b'11.1'
root2.part = val
# flushing dotobject local cache
root2.flush()
self.assertEqual(root2.part, expected_result)
def test_grandchild(self):
string = "for real?"
self.root.haha.wahaha = string
result = self.red.get('root.haha.wahaha')
expected_result = Root.doformat(string)
self.assertEqual(result, expected_result)
self.root.flush()
self.assertEqual(self.root.haha.wahaha, string)
self.assertEqual(self.root['haha.wahaha'], string)
def test_child_set(self):
value = {1, 2, 4}
expected_result = set(Root.doformat(value))
self.root.part_set = value
result = self.red.smembers('root.part_set')
self.assertEqual(result, expected_result)
self.root.flush()
self.assertEqual(self.root.part_set, value)
def test_child_dict(self):
value = {1: 1, 2: 2, 3: 4}
expected_result = Root.doformat(value)
self.root.part_dic = value
result = self.red.hgetall('root.part_dic')
self.assertEqual(result, expected_result)
self.root.flush()
self.assertEqual(self.root.part_dic, value)
def test_child_nested_dict(self):
value = {1: 1, 2: {"a": "hello"}, 3: 4}
expected_result = Root.doformat(value)
self.root.part = value
result = self.red.hgetall('root.part')
self.assertEqual(result, expected_result)
self.root.flush()
self.assertEqual(self.root.part, value)
def test_child_iterable(self):
value = [1, 3, "a"]
expected_result = Root.doformat(value)
self.root.part = value
result = self.red.lrange("root.part", 0, -1)
self.assertEqual(result, expected_result)
self.root.flush()
self.assertEqual(self.root.part, value)
def test_child_nested_iterable(self):
value = [1, 3, ["a", 3]]
expected_result = Root.doformat(value)
self.root.part = value
result = self.red.lrange("root.part", 0, -1)
self.assertEqual(result, expected_result)
self.root.flush()
self.assertEqual(self.root.part, value)
def test_many_different_children_types(self):
set_value = {1, 2, 4}
self.root.part_set = set_value
dict_value = {1: 1, 2: {"a": 1}}
self.root.part_dict = dict_value
list_value = [1, ["b", 3]]
self.root.part_list = list_value
self.root.flush()
self.assertEqual(self.root.part_set, set_value)
self.assertEqual(self.root.part_dict, dict_value)
self.assertEqual(self.root.part_list, list_value)
def test_many_different_children_types2(self):
mylist = [1, 3, 4]
self.root.my.list = mylist
some_date = datetime.datetime(2016, 8, 22, 10, 3, 19)
self.root.time = some_date
mydict = {1: 1, "a": "b"}
self.root.the.mapping.example = mydict
self.root.flush()
self.assertEqual(self.root.my.list, mylist)
self.assertEqual(self.root.time, some_date)
self.assertEqual(self.root.the.mapping.example, mydict)
def test_change_key_type(self):
mylist = [1, 3, 4]
self.root.something = mylist
st = "string"
self.root.something = st
self.assertEqual(self.root.something, st)
def test_number_comparison(self):
self.root.num = 10
num = self.root.num
self.assertIsInstance(num, LazyDot)
self.assertTrue(num > 8)
self.assertTrue(num < 11)
self.assertTrue(num <= 12)
self.assertTrue(num >= 10)
self.assertFalse(num > 10)
def test_number_math(self):
self.root.num = 10
num = self.root.num
self.assertIsInstance(num, LazyDot)
self.assertEqual(num * 2, 20)
def test_saving_set_removed_the_old_one(self):
self.root.myset = {1, 2, 3}
self.root.myset = {4, 5}
self.root.flush()
self.assertEqual(self.root.myset, {4, 5})
def test_saving_list_removed_the_old_one(self):
self.root.myset = [1, 2, 3]
self.root.myset = [4, 5]
self.root.flush()
self.assertEqual(self.root.myset, [4, 5])
def redis(monkeypatch):
fake_redis = FakeStrictRedis()
fake_redis.flushall()
monkeypatch.setattr("celery_once.tasks.QueueOnce.redis", fake_redis)
return fake_redis
class TaskTest(TestCase):
mock_options = {
'autospec': True,
}
def setUp(self):
self.get_redis = patch('celery_once.backends.redis.get_redis')
self.mocked_redis = self.get_redis.start()
self.redis = FakeStrictRedis()
self.mocked_redis.return_value = self.redis
@patch('delft3dcontainermanager.tasks.call_command')
def test_delft3dgt_pulse(self, mockCall):
"""
Assert that de delft3dgt_pulse task
calls the containersync_sceneupdate() function.
"""
delft3dgt_pulse.delay()
mockCall.assert_called_with('containersync_sceneupdate')
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
@patch('delft3dcontainermanager.tasks.logging.error', **mock_options)
def test_get_docker_ps(self, mockLogging, mockClient):
"""
Assert that the docker_ps task
calls the docker client.containers() function.
"""
containers = [
{
'Id': 'Aaa',
'Status': 'Running'
},
{
'Id': 'Bbb',
'Status': 'Host Down'
},
{
'Id': 'Ccc',
'Status': 'Up'
},
]
def inspect(container=''):
if container == 'Ccc':
raise
else:
return {
'Id': container,
'Config': {
'Labels': {
'type': 'preprocess'
}
}
}
mockClient.return_value.containers.return_value = containers
mockClient.return_value.inspect_container.side_effect = inspect
get_docker_ps.delay()
# Call docker ps for all containers, but only once
mockClient.return_value.containers.assert_called_with(all=True)
self.assertEqual(mockClient.return_value.containers.call_count, 1)
# Call inspect for all but Host Down container
self.assertEqual(mockClient.return_value.inspect_container.call_count,
2)
# Log error only for Ccc container
self.assertEqual(mockLogging.call_count, 1)
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
def test_get_docker_log(self, mockClient):
"""
Assert that the docker_log task
calls the docker client.logs() function.
"""
get_docker_log.delay("id", stdout=False, stderr=True)
mockClient.return_value.logs.assert_called_with(container="id",
stdout=False,
stderr=True,
stream=False,
timestamps=True,
tail=5)
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
def test_do_docker_create(self, mockClient):
"""
Assert that the docker_create task
calls the docker client.create_container() function.
"""
image = "IMAGENAME"
volumes = ['/:/data/output:z', '/:/data/input:ro']
memory_limit = '1g'
command = "echo test"
config = {}
environment = {'a': 1, 'b': 2}
label = {"type": "delft3d"}
folder = ['input', 'output']
name = 'test-8172318273'
workingdir = os.path.join(os.getcwd(), 'test')
folders = [os.path.join(workingdir, f) for f in folder]
parameters = {u'test': {u'1': u'a', u'2': u'b', 'units': 'ignoreme'}}
mockClient.return_value.create_host_config.return_value = config
do_docker_create.delay(label, parameters, environment, name, image,
volumes, memory_limit, folders, command)
# Assert that docker is called
mockClient.return_value.create_container.assert_called_with(
image,
host_config=config,
command=command,
name=name,
environment=environment,
labels=label)
# Assert that folders are created
listdir = os.listdir(workingdir)
for f in listdir:
self.assertIn(f, listdir)
for folder in folders:
ini = os.path.join(folder, 'input.ini')
self.assertTrue(os.path.isfile(ini))
config = configparser.SafeConfigParser()
config.readfp(open(ini))
for key in parameters.keys():
self.assertTrue(config.has_section(key))
for option, value in parameters[key].items():
if option != 'units':
self.assertTrue(config.has_option(key, option))
self.assertEqual(config.get(key, option), value)
else: # units should be ignored
self.assertFalse(config.has_option(key, option))
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
def test_do_docker_start(self, mockClient):
"""
Assert that the docker_start task
calls the docker client.start() function
"""
do_docker_start.delay("id")
mockClient.return_value.start.assert_called_with(container="id")
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
def test_do_docker_stop(self, mockClient):
"""
Assert that the docker_stop task
calls the docker client.stop() function
"""
do_docker_stop.delay("id", timeout=5)
mockClient.return_value.stop.assert_called_with(container="id",
timeout=5)
@patch('delft3dcontainermanager.tasks.Client', **mock_options)
def test_do_docker_remove(self, mockClient):
"""
Assert that the docker_remove task
calls the docker client.remove_container() function
"""
delay = do_docker_remove.delay("id")
mockClient.return_value.remove_container.assert_called_with(
container="id", force=False)
container, log = delay.result
self.assertEqual(container, "id")
self.assertEqual(log, "")
def test_do_docker_sync_filesystem(self):
"""
TODO: write test
"""
delay = do_docker_sync_filesystem.delay("id")
container, log = delay.result
self.assertEqual(container, "id")
self.assertEqual(log, "")
def tearDown(self):
self.redis.flushall()
self.get_redis.stop()
