def delete(config, *argv):
connection = db_controller.connection(config)['data']
state = db_controller.connection(config)['state']
if state == 'success':
if len(argv) == 1:
table_list = db_controller.get_all_table(connection)
elif len(argv) == 2:
table_list = argv[1].split(',')
true_count = sum(
db_controller.get(connection, argv[0], table_list).values())
deleted_value = db_controller.delete(connection, argv[0], table_list)
error = true_count - deleted_value['data']
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
connection.close()
return {
'data': {
'all': count_all,
'deleted': deleted_value['data'],
'error': error
},
'state': deleted_value['state']
}
else:
return {'data': None, 'state': state}
def test_get_all_table(self):
#true
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': 3306,
'user': '******',
'password': '',
'name': 'DB'
}
connection = db_controller.connection(config)['data']
self.assertEqual(db_controller.get_all_table(connection), ['data'])
self.assertEqual(len(db_controller.get_all_table(connection)), 1)
connection.close()
def test_backup(self):
# backup success
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
connection = db_controller.connection(config)['data']
tables = db_controller.get_all_table(connection)
clause = 'updated_date <= \'2018-02-02\''
expected_mess = 'success'
return_value = db_controller.backup(config, clause, tables)
self.assertIsNotNone(return_value['data'])
self.assertEqual(return_value['state'], expected_mess)
connection.close()
# no such table
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'BackupDB'
}
tables = ['datab']
clause1 = "updated_date <= '2018-02-02'"
expected_mess = 'success'
return_value = db_controller.backup(config, clause1, tables)
self.assertIsNone(return_value['data'])
self.assertNotEqual(return_value['state'], expected_mess)
def delete_backup(config, backup_config, *argv):
print('start')
connection = db_controller.connection(config)['data']
state = db_controller.connection(config)['state']
print('backup')
if state == 'success':
if len(argv) == 1:
table_list = db_controller.get_all_table(connection)
elif len(argv) == 2:
table_list = argv[1].split(',')
if backup(config, backup_config, argv[0], table_list) == False:
connection.close()
return {'data': None, 'state': 'false to backup'}
else:
true_count = sum(
db_controller.get(connection, argv[0], table_list).values())
delete = db_controller.delete(connection, argv[0], table_list)
state2 = delete['state']
deleted = delete['data']
error = true_count - deleted
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
connection.close()
return {
'data': {
'all': count_all,
'deleted': deleted,
'error': error
},
'state': state2
}
else:
return {'data': None, 'state': state}
def test_delete(self):
#there's no table
print('test_delete:')
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': 3306,
'user': '******',
'password': '',
'name': 'BackupDB'
}
connection = db_controller.connection(config)['data']
tables = db_controller.get_all_table(connection)
clause = "updated_date <= '2018-01-01'"
expected_data = 0
expected_mess = 'success'
return_value = db_controller.delete(connection, clause, tables)
self.assertEqual(return_value['data'], expected_data)
self.assertEqual(return_value['state'], expected_mess)
connection.close()
#success
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': 3306,
'user': '******',
'password': '',
'name': 'DB'
}
connection = db_controller.connection(config)['data']
tables = db_controller.get_all_table(connection)
clause = "updated_date <= '2018-01-01'"
expected_data = db_controller.get(connection, clause, tables)['data']
expected_mess = 'success'
return_value = db_controller.delete(connection, clause, tables)
self.assertEqual(return_value['data'], expected_data)
self.assertEqual(return_value['state'], expected_mess)
connection.close()
#there's no record found
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': 3306,
'user': '******',
'password': '',
'name': 'DB'
}
connection = db_controller.connection(config)['data']
tables = db_controller.get_all_table(connection)
clause = "updated_date >= '2018-11-01'"
expected_data = 0
expected_mess = 'success'
return_value = db_controller.delete(connection, clause, tables)
self.assertEqual(return_value['data'], expected_data)
self.assertEqual(return_value['state'], expected_mess)
connection.close()
#no such data table
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': 3306,
'user': '******',
'password': '',
'name': 'BackupDB'
}
connection = db_controller.connection(config)['data']
tables = ['data']
clause = "updated_date <= '2018-01-01'"
expected_data = 0
expected_mess = 'bug'
return_value = db_controller.delete(connection, clause, tables)
self.assertEqual(return_value['data'], expected_data)
self.assertEqual(return_value['state'], expected_mess)
connection.close()
def test_delete(self):
# true, no table list
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
clause = "updated_date <= '2017-12-20'"
connection = db_controller.connection(config)['data']
deleted = sum(
db_controller.get(
connection, clause,
db_controller.get_all_table(connection)).values())
connection.close()
result = backup_controller.delete(config, clause)
connection = db_controller.connection(config)['data']
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
expected_data = {'all': count_all, 'deleted': deleted, 'error': 0}
expected_mes = 'success'
connection.close()
self.assertEqual(result['data'], expected_data)
self.assertEqual(result['state'], expected_mes)
# true, table list exist
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
clause = "updated_date <= '2018-01-01'"
tables = 'data'
tb = tables.split(",")
connection = db_controller.connection(config)['data']
x = db_controller.get(connection, clause, tb)
deleted = sum(x.values())
connection.close()
result = backup_controller.delete(config, clause, tables)
connection = db_controller.connection(config)['data']
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
expected_data = {'all': count_all, 'deleted': deleted, 'error': 0}
expected_mes = 'success'
connection.close()
self.assertEqual(result['data'], expected_data)
self.assertEqual(result['state'], expected_mes)
# tablelist with one wrong one
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
clause = "updated_date <= '2018-01-03'"
tables = 'data,beta'
tb = tables.split(",")
connection = db_controller.connection(config)['data']
deleted = sum(db_controller.get(connection, clause, tb).values())
connection.close()
result = backup_controller.delete(config, clause, tables)
connection = db_controller.connection(config)['data']
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
expected_data = {'all': count_all, 'deleted': deleted, 'error': 0}
expected_mes = 'some records are not deleted'
connection.close()
self.assertEqual(result['data'], expected_data)
self.assertEqual(result['state'], expected_mes)
# not existed table list
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
clause = "updated_date <= '2018-02-01'"
tables = 'theta,beta'
tb = tables.split(",")
result = backup_controller.delete(config, clause, tables)
connection = db_controller.connection(config)['data']
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
expected_data = {'all': count_all, 'deleted': 0, 'error': 0}
expected_mes = 'some records are not deleted'
connection.close()
self.assertEqual(result['data'], expected_data)
self.assertEqual(result['state'], expected_mes)
def test_delete_backup(self):
# true, no table list
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
backup_config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'BackupDB'
}
clause = "updated_date <= '2018-02-01'"
connection = db_controller.connection(config)['data']
deleted = sum(
db_controller.get(
connection, clause,
db_controller.get_all_table(connection)).values())
connection.close()
result = backup_controller.delete_backup(config, backup_config, clause)
connection = db_controller.connection(config)['data']
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
expected_data = {'all': count_all, 'deleted': deleted, 'error': 0}
expected_mes = 'success'
connection.close()
self.assertEqual(result['data'], expected_data)
self.assertEqual(result['state'], expected_mes)
# true, table list exist
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
backup_config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'BackupDB'
}
clause = "updated_date <= '2018-02-02'"
tables = 'data'
tb = tables.split(",")
connection = db_controller.connection(config)['data']
deleted = sum(db_controller.get(connection, clause, tb).values())
connection.close()
result = backup_controller.delete_backup(config, backup_config, clause,
tables)
connection = db_controller.connection(config)['data']
count_all = sum(
db_controller.get(
connection, "1",
db_controller.get_all_table(connection)).values())
expected_data = {'all': count_all, 'deleted': deleted, 'error': 0}
expected_mes = 'success'
connection.close()
self.assertEqual(result['data'], expected_data)
self.assertEqual(result['state'], expected_mes)
# no such table)
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
backup_config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'BackupDB'
}
clause = "updated_date <= '2018-03-03'"
tables = 'theta,beta'
result = backup_controller.delete_backup(config, backup_config, clause,
tables)
expected_mes = 'false to backup'
self.assertIsNone(result['data'])
self.assertEqual(result['state'], expected_mes)
# no backup config:
config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'DB'
}
backup_config = {
'client': 'mysql',
'host': '127.0.0.1',
'port': '3306',
'user': '******',
'password': '',
'name': 'XSackupDB'
}
clause = "updated_date <= '2018-04-04'"
tables = 'theta,beta'
result = backup_controller.delete_backup(config, backup_config, clause,
tables)
expected_mes = 'false to backup'
self.assertIsNone(result['data'])
self.assertEqual(result['state'], expected_mes)