def testFModsRabbitMQ(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
self.assertEqual(fm.getConfig('rabbitmq'), {})
self.assertEqual(fm.getTmpFolder('rabbitmq'), 'data/tmp/git/rabbitmq')
fm.scan()
self.assertTrue(fm.count() > 7)
rabbitmq1 = fm.newRabbitMQ('rabbitmq')
#conn = rabbitmq1.getConnect()
#self.assertIsNone(conn)
# Start service
srvRabbitMQ = fm.newDocker('rabbitmq')
self.assertTrue(srvRabbitMQ.run())
self.assertTrue(srvRabbitMQ.statusWaiting('running'))
self.assertEqual(srvRabbitMQ.status(), 'running')
# Test connect
queue = 'log3'
exchange = 'log3'
routing_key = ''
exchange_type = 'fanout'
rabbitmq1.init()
#self.assertTrue(rabbitmq1.createRoute(exchange, exchange_type, routing_key, queue))
self.assertTrue(rabbitmq1.send(exchange, routing_key, 'message 1'))
self.assertTrue(rabbitmq1.send(exchange, routing_key, 'message 2'))
rabbitmq2 = fm.newRabbitMQ('rabbitmq')
time.sleep(1)
msg, ok = rabbitmq2.receive(queue)
self.assertTrue(ok)
self.assertEqual(msg, 'message 1')
msg, ok = rabbitmq2.receive(queue)
self.assertTrue(ok)
self.assertEqual(msg, 'message 2')
self.assertTrue(
rabbitmq1.sendFile(exchange, routing_key, 'data/files/test.txt'))
self.assertTrue(
rabbitmq1.receiveAndCompareFile(queue, 'data/files/test.txt'))
rabbitmq1.close()
rabbitmq2.close()
# Remove
self.assertTrue(srvRabbitMQ.remove())
self.assertEqual(srvRabbitMQ.status(), 'not found')
def testFModsFTP(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
self.assertEqual(fm.getConfig('ftp'), {})
self.assertEqual(fm.getTmpFolder('ftp'), 'data/tmp/git/ftp')
fm.scan()
self.assertTrue(fm.count() > 7)
# Start service
srvFTP = fm.newDocker('ftp')
self.assertTrue(srvFTP.run())
self.assertEqual(srvFTP.status(), 'running')
ftp = fm.newFTP('ftp')
conn = ftp.reconnect()
self.assertIsNotNone(conn)
self.assertEqual(ftp.getDirList(''), ['incoming'])
self.assertEqual(ftp.getFileList(''), ['incoming'])
self.assertFalse(ftp.cd('incoming'))
self.assertFalse(ftp.cd('incoming2'))
self.assertTrue(ftp.mkDir('/folder-test/folder-test2'))
self.assertEqual(ftp.getFileList('/folder-test'), ['/folder-test/folder-test2'])
self.assertTrue(ftp.uploadFile('folder-test', 'test.txt', 'data/files/test.txt'))
self.assertEqual(ftp.getFileList('/folder-test'), ['/folder-test/folder-test2', '/folder-test/test.txt'])
self.assertTrue(ftp.downloadFile('folder-test', 'test.txt', 'data/files/test2.txt'))
self.assertTrue(ftp.compareFiles('folder-test', 'test.txt', 'data/files/test2.txt'))
os.remove('data/files/test2.txt')
self.assertTrue(ftp.compareFiles('folder-test', 'test.txt', 'data/files/test.txt'))
self.assertFalse(ftp.compareFiles('folder-test1', 'test.txt', 'data/files/test2.txt'))
self.assertFalse(ftp.compareFiles('folder-test', 'test.txt', 'data/files/test1.txt'))
self.assertFalse(ftp.compareFiles('folder-test', 'test1.txt', 'data/files/test.txt'))
self.assertEqual(ftp.getDirList(''), ['folder-test', 'incoming'])
ftp.init()
self.assertEqual(ftp.getDirList(''), ['folder-test', 'folder-test1', 'incoming'])
# Remove
ok = srvFTP.remove()
self.assertEqual(ok, True)
res = srvFTP.status()
self.assertEqual(res, 'not found')
def testFModsKafka(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
self.assertEqual(fm.getConfig('kafka'), {})
self.assertEqual(fm.getTmpFolder('kafka'), 'data/tmp/git/kafka')
fm.scan()
self.assertTrue(fm.count() > 7)
channel = 'channel-test'
kafka1 = fm.newKafka('kafka')
kafka2 = fm.newKafka('kafka')
# Start service
srvKafka = fm.newDocker('kafka')
self.assertTrue(
srvKafka.startCompose(
os.path.join(os.getcwd(),
'data/mods/kafka/docker-compose.yml')))
self.assertTrue(srvKafka.statusWaiting('running'))
self.assertEqual(srvKafka.status(), 'running')
# Test connect
self.assertIsNotNone(kafka1.reconnect())
kafka1.init()
self.assertTrue(kafka1.send(channel, 'message 1'))
msg, ok = kafka2.receive(channel)
self.assertTrue(ok)
self.assertEqual(msg, 'message 1')
# kafka2.receiveAll(channel)
self.assertTrue(kafka1.sendFile(channel, 'data/files/test.txt'))
self.assertTrue(
kafka2.receiveAndCompareFile(channel, 'data/files/test.txt'))
kafka1.close()
kafka2.close()
# Remove
self.assertTrue(
srvKafka.stopCompose(
os.path.join(os.getcwd(),
'data/mods/kafka/docker-compose.yml')))
self.assertEqual(srvKafka.status(), 'not found')
def testDockerCompose(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
fm.scan()
self.assertTrue(fm.count() > 5)
srvDocker = fm.newDocker('kafka') # Docker Compose
self.assertTrue(srvDocker.startCompose())
self.assertTrue(srvDocker.stopCompose())
self.assertFalse(srvDocker.startCompose('d1.yaml'))
self.assertFalse(srvDocker.stopCompose('d1.yaml'))
def testDockerRun000(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
fm.scan()
self.assertTrue(fm.count() > 7)
srvNginx000 = fm.newDocker('nginx-000')
#
res, ok = srvNginx000.logs()
self.assertEqual(ok, False)
res = srvNginx000.status()
self.assertEqual(res, 'not found')
def testDockerBuild(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
fm.scan()
self.assertTrue(fm.count() > 5)
# Test: Docker build
srvGit = fm.newGIT('srv-report')
srvDocker = fm.newDocker('srv-report')
self.assertTrue(srvGit.clone())
self.assertTrue(srvDocker.statusWaiting('not found'))
self.assertTrue(srvDocker.build())
self.assertTrue(srvDocker.run())
res = srvDocker.status()
self.assertEqual(res, 'running')
self.assertTrue(srvDocker.statusWaiting('running'))
self.assertTrue(srvDocker.remove())
self.assertEqual(srvDocker.status(), 'not found')
def testDockerRun(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
fm.scan()
self.assertTrue(fm.count() > 5)
srvNginx = fm.newDocker('nginx')
srvNginx.stop()
srvNginx.remove()
res = srvNginx.status()
self.assertEqual(res, 'not found')
res, ok = srvNginx.logs()
self.assertFalse(ok)
self.assertEqual(res, '')
# Test: Docker run
self.assertTrue(srvNginx.run())
self.assertEqual(srvNginx.status(), 'running')
try:
r = requests.get('http://127.0.0.1:3010')
self.assertEqual(r.status_code, 404)
except Exception as e:
print("FATAL: http://127.0.0.1:3010: %s" % (str(e)))
self.assertEqual(srvNginx.status(), 'running')
self.assertTrue(srvNginx.remove())
self.assertEqual(srvNginx.status(), 'not found')
try:
r = requests.get('http://127.0.0.1:3010')
self.assertIsNone(r.status_code)
except Exception as e:
print("FATAL: http://127.0.0.1:3010: %s" % (str(e)))
def testFModsMINIO(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
self.assertEqual(fm.getConfig('minio'), {})
self.assertEqual(fm.getTmpFolder('minio'), 'data/tmp/git/minio')
fm.scan()
self.assertTrue(fm.count() > 7)
#config_need = dict(sorted({('CONTAINER_NAME', 'minio-test'), ('CONTAINER_ENV_S3_ACCESS_KEY', 'user'), ('CONTAINER_ENV_S3_SECRET_KEY', 'pwd'), ('CONTAINER_PORTS', '3010:9000'), ('CONTAINER_SRC', 'minio/minio'), ('S3_ACCESS_KEY', 'user'), ('S3_SECRET_KEY', 'pwd'), ('NAME', 'minio'), ('TYPE', 'docker'), ('S3_PORT', '3010')}))
#cfg = fm.getConfig('minio')
#cfg.pop('MOD_PATH', None)
#self.assertEqual(cfg, config_need)
minio = fm.newMinIO('minio')
#conn = minio.reconnect()
#self.assertIsNone(conn)
# Start service
srvMINIO = fm.newDocker('minio')
self.assertTrue(srvMINIO.run())
self.assertEqual(srvMINIO.status(), 'running')
# Test connect
conn = minio.reconnect()
self.assertIsNotNone(conn)
self.assertEqual(minio.getBasketsList(), [])
self.assertTrue(minio.mkDir('bucket-test', 'folder1/folder12'))
self.assertTrue(minio.mkDir('bucket-test', 'folder1/folder13'))
self.assertEqual(minio.getListObjects('bucket-test', 'folder1'),
['folder1/folder12', 'folder1/folder13'])
self.assertTrue(
minio.uploadFile('bucket-test', 'folder1/test.txt',
'data/files/test.txt'))
self.assertEqual(
minio.getListObjects('bucket-test', 'folder1'),
['folder1/folder12', 'folder1/folder13', 'folder1/test.txt'])
self.assertTrue(
minio.downloadFile('bucket-test', 'folder1/test.txt',
'data/files/test2.txt'))
self.assertTrue(
minio.compareFiles('bucket-test', 'folder1/test.txt',
'data/files/test2.txt'))
os.remove('data/files/test2.txt')
self.assertTrue(
minio.compareFiles('bucket-test', 'folder1/test.txt',
'data/files/test.txt'))
self.assertFalse(
minio.compareFiles('bucket-test1', 'folder2/test.txt',
'data/files/test2.txt'))
self.assertFalse(
minio.compareFiles('bucket-test', 'test.txt',
'data/files/test1.txt'))
self.assertFalse(
minio.compareFiles('bucket-test', 'test1.txt',
'data/files/test.txt'))
self.assertEqual(minio.getBasketsList(), ['bucket-test'])
minio.init()
self.assertEqual(minio.getBasketsList(),
['bucket-test', 'bucket-test2'])
self.assertEqual(minio.getListObjects('bucket-test'), [
'folder000', 'folder1/folder12', 'folder1/folder13',
'folder1/test.txt'
])
self.assertEqual(minio.getListObjects('bucket-test2'),
['folder1/folder1'])
# Remove
self.assertTrue(srvMINIO.remove())
self.assertEqual(srvMINIO.status(), 'not found')
def testFModsPostgre(self):
fm = FMods("data/mods/", "data/tmp/", True)
self.assertEqual(fm.count(), 0)
self.assertEqual(fm.getConfig('pg'), {})
self.assertEqual(fm.getTmpFolder('pg'), 'data/tmp/git/pg')
fm.scan()
self.assertTrue(fm.count() > 7)
#config_need = dict(sorted({('CONTAINER_ENV_POSTGRES_DB', 'test-db'), ('ORDER', 0), ('CONTAINER_ENV_POSTGRES_PASSWORD', 'pwd'), ('CONTAINER_ENV_POSTGRES_USER', 'user'), ('CONTAINER_NAME', 'pg-test'), ('DB_PORT', '17432'), ('CONTAINER_PORTS', '17432:5432'), ('CONTAINER_NAME', 'pg-test'), ('CONTAINER_SRC', 'postgres:alpine'), ('DB_NAME', 'test-db'), ('DB_PASSWORD', 'pwd'), ('DB_USER', 'user'), ('NAME', 'pg'), ('TYPE', 'docker')}))
#cfg = fm.getConfig('pg')
#cfg.pop('MOD_PATH', None)
#self.assertEqual(cfg, config_need)
pg = fm.newPostgre('pg')
self.assertIsNone(pg.reconnect())
# Start service
srvPg = fm.newDocker('pg')
ok = srvPg.run()
self.assertTrue(ok)
res = srvPg.status()
self.assertEqual(res, 'running')
# Test connect
self.assertIsNotNone(pg.reconnect())
tbl = pg.getTableList()
self.assertEqual(tbl, [])
self.assertTrue(pg.loadSQL('data/postgre/create_table.sql'))
tbl = pg.getTableList()
self.assertEqual(tbl, [('public', 'article')])
self.assertTrue(pg.loadSQL('data/postgre/create_tables.sql'))
tbl = pg.getTableList()
self.assertEqual(tbl, [('public', 'article'), ('public', 'article2'),
('public', 'article3')])
res = pg.getData('select * from public.article')
self.assertEqual(res, [])
self.assertTrue(pg.loadSQL('data/postgre/insert.sql'))
res = pg.getData('select * from public.article')
self.assertEqual(res, [(1, 'article 1', 'description', None)])
# Migration
mgPg = fm.newMigrate('pg')
self.assertTrue(mgPg.run())
self.assertEqual(pg.getTableList(), [('public', 'article'),
('public', 'article2'),
('public', 'article3'),
('public', 'job'),
('public', 'schedule'),
('public', 'schema_migrations')])
# Remove
ok = srvPg.remove()
self.assertEqual(ok, True)
res = srvPg.status()
self.assertEqual(res, 'not found')