def test_get_column_returns_a_column(self, mock_column_type):
mock_column_type.return_value = TableManager.COLUMN_MAPPINGS.get('3')
table_manager = TableManager('./test_fixture.csv', 'test_table',
self.metadata)
column = table_manager.get_column('test_column')
self.assertTrue(type(column) is Column)
self.assertEqual(column.name, 'test_column')
def test_get_columns_returns_columns_equal_to_columns_in_csv(
self, mock_column_type):
mock_column_type.return_value = TableManager.COLUMN_MAPPINGS.get('3')
table_manager = TableManager('./test_fixture.csv', 'test_table',
self.metadata)
columns = table_manager.get_columns()
self.assertEqual(len(columns), 4)
class TestSum(unittest.TestCase):
"""Automatic tests"""
def setUp(self):
self.table_mng = TableManager()
self.table_mng.table_df.from_dict(ROWS)
def test_write_json(self):
"""
Test if the file is created properly.When the path is
passed as parameter to pands.to_json, the return should be None
"""
result = self.table_mng.write_table_json()
self.assertIsNone(result, "Should be a None")
self.assertEqual(True,
os.path.exists(r"../app/integrations/data.json"))
def test_dataframe_columns(self):
"""Test integrity of columns"""
self.table_mng.create_table(["Oceania", "Americas"])
self.assertIn(
"country",
self.table_mng.table_df.columns,
"Country should be a column in df",
)
self.assertEqual(self.table_mng.table_df.shape[1], 4,
"Should be 4 columns")
self.assertEqual(
self.table_mng.table_df.columns.values.tolist(),
["region", "country", "language", "time"],
)
def test_get_data_should_return_a_list_of_dicts(self):
table_manager = TableManager('./test_fixture.csv', 'test_table',
self.metadata)
data = table_manager.get_data()
self.assertEqual(data, [{
u'Total_price_for_in-state_students_living_on_campus_2016-17_DRVI':
u'100000',
u'Institution_Name':
u'A University',
u'Total_price_for_in-district_students_living_on_campus__2016-17_':
u'100000',
u'UnitID':
u'1'
}, {
u'Total_price_for_in-state_students_living_on_campus_2016-17_DRVI':
u'3000',
u'Institution_Name':
u'B University',
u'Total_price_for_in-district_students_living_on_campus__2016-17_':
u'3000',
u'UnitID':
u'2'
}, {
u'Total_price_for_in-state_students_living_on_campus_2016-17_DRVI':
u'30',
u'Institution_Name':
u'C University',
u'Total_price_for_in-district_students_living_on_campus__2016-17_':
u'30',
u'UnitID':
u'3'
}])
def test_primary_key_returns_a_primary_key_column(self):
table_manager = TableManager('./test_fixture.csv', 'test_table',
self.metadata)
pk_column = table_manager.primary_key()
self.assertTrue(type(pk_column) is Column)
self.assertEqual(pk_column.name, 'id')
self.assertTrue(type(pk_column.type) is Integer)
self.assertEqual(pk_column.primary_key, True)
def test_get_table_returns_table_with_four_columns(self, mock_column_type):
mock_column_type.return_value = TableManager.COLUMN_MAPPINGS.get('3')
table_manager = TableManager('./test_fixture.csv', 'test_table',
self.metadata)
table = table_manager.get_table()
self.assertTrue(type(table) is Table)
self.assertEqual(table.name, 'test_table')
self.assertEqual(len(table.columns), 4)
def test_format_column_name_removes_white_space_and_parentheses(self):
column_name = 'this is an entirely too long column name ' \
'(mySQL only supports up to 64 characters (but aliases can be longer))'
table_manager = TableManager('./test_fixture.csv', 'test_table',
self.metadata)
new_name = table_manager.format_column_name(column_name)
self.assertTrue(len(new_name) <= 64)
self.assertTrue(' ' not in new_name)
self.assertTrue(')' not in new_name)
self.assertTrue('(' not in new_name)
class Main:
def __init__(self):
self.exit = False
self.table_manager = TableManager()
self.table_manager.add_tables()
self.userOptions()
def userOptions(self):
if self.exit == False:
table_choice = input(
"What would you like to do: \n 1 - Check-in a table \n 2 - Check-out a table \n 3 - Print status of all tables \n 4 - Quit \n Enter choice: "
)
if table_choice == '1':
self.table_manager.check_in()
self.userOptions()
elif table_choice == '2':
self.table_manager.check_out(
) #only works if I execute the add_task function and then this one.
self.userOptions()
elif table_choice == '3':
self.table_manager.printList()
self.userOptions()
elif table_choice == '4':
self.quit()
else:
print("Not sure what you are asking for!?")
def quit(self):
print("Goodbye!")
self.exit = True
def main():
mongodb = Mongo()
table_mng = TableManager()
auth = Auth()
regions = get_regions(os.getenv("REGIONS_API"))
table_mng.create_table(regions)
auth.get_authorization()
if not auth.is_authenticated:
logging.info("User is not authenticated so database can't be shown")
return
mongodb.insert_documents(table_mng.table_df)
mongodb.list_documents()
def process_fuzzy_query(user_query, threshold, db_mgr):
"""Process query with fuzzy constraints
"""
query = Query()
parser = QueryParser()
fuzzy_mgr = FuzzyManager()
table_mgr = TableManager()
# Parse user query
print('\nParsing query ...')
parser.parse_query(query, user_query)
print(query)
print('Query parsed.')
# Verify correctness of the query
print('Validating query ...')
parser.validate_query(query)
print('Query validated. No errors found.')
# Retrieve requested table
print('\nRetrieving requested table from the database ...')
db_mgr.retrieve_table(query.table_name, IN_FILE)
print('Table retrieved and saved to \'{}\' file.'.format(IN_FILE))
# Parse constraints and obtain intervals
print('\nParsing constraints from the query and obtaining intervals ...')
fuzzy_mgr.parse_constraints(query.constraints, threshold, FCL_FILE)
print(json.dumps(query.constraints, indent=4, ensure_ascii=False))
print('Constraints parsed.')
# Search for tuples
print('\nExtracting tuples that meet the requirement ...')
table_mgr.extract_tuples(query.constraints, query.conjunction, IN_FILE,
TMP_FILE)
print('Tuples extracted and saved to temporary files.')
# Parse and execute instruction with function
print('\nExecuting instruction ...')
table_mgr.execute_instruction(query.instruction, query.function,
query.columns, TMP_FILE, OUT_FILE)
print(
'Instruction executed. Output saved to \'{}\' file.'.format(OUT_FILE))
def test_clean_row_strips_any_empty_keys_and_empty_values(self):
table_manager = TableManager('./test_fixture.csv', 'test_table',
self.metadata)
uncleaned_row = {u'': 'data', u'column': u''}
table_manager.clean_row(uncleaned_row)
self.assertEqual(uncleaned_row, {u'column': None})
def setUp(self):
self.table_mng = TableManager()
self.table_mng.table_df.from_dict(ROWS)
def __init__(self):
self.exit = False
self.table_manager = TableManager()
self.table_manager.add_tables()
self.userOptions()