def testColumnTypeForOnlyOneTable(self):
"""test getting the column type for only one table"""
mappings = {
'id': 'float',
'that': 'varchar',
'different': 'integer',
'bla': 'real'
}
self.sql_type_helper._information = (
fake_database_information.FakeDatabaseInformation(None, mappings))
model = [
sql_query_column_model.SQLColumnModel('id'),
sql_query_column_model.SQLColumnModel('that'),
sql_query_column_model.SQLColumnModel('different'),
sql_query_column_model.SQLColumnModel('bla')
]
result = self.sql_type_helper._ColumnTypeForMultipleTables(
'other', model, '')
self.assertEqual(len(result), 4)
self.assertEqual(result[0].sql_column, 'id')
self.assertEqual(result[1].sql_column, 'that')
self.assertEqual(result[2].sql_column, 'different')
self.assertEqual(result[3].sql_column, 'bla')
self.assertEqual(result[0].sql_column_type, float)
self.assertEqual(result[1].sql_column_type, str)
self.assertEqual(result[2].sql_column_type, int)
self.assertEqual(result[3].sql_column_type, float)
def testGetColumnsAndTimestampColumnWithNoData(self):
"""test the getting of the column and timestamp column"""
timestamps = ['this', 'that', 'another']
columns = [
sql_query_column_model.SQLColumnModel('not'),
sql_query_column_model.SQLColumnModel('this'),
sql_query_column_model.SQLColumnModel('another'),
sql_query_column_model.SQLColumnModel('that'),
sql_query_column_model.SQLColumnModel('alsonot')
]
actual = self.helper.GetColumnsAndTimestampColumn(
columns, timestamps, [])
self.assertEqual(len(actual), 2)
self.assertEqual(len(actual[0]), 2)
self.assertEqual(len(actual[1]), 3)
self.assertEqual(actual[0][0].sql_column, 'not')
self.assertEqual(actual[0][1].sql_column, 'alsonot')
self.assertEqual(actual[1][0].sql_column, 'this')
self.assertEqual(actual[1][1].sql_column, 'another')
self.assertEqual(actual[1][2].sql_column, 'that')
self.assertEqual(actual[1][0].timestamp, '')
self.assertEqual(actual[1][1].timestamp, '')
self.assertEqual(actual[1][2].timestamp, '')
self.assertEqual(actual[1][0].expected_message, 'Not: Alsonot: ')
self.assertEqual(actual[1][1].expected_message, 'Not: Alsonot: ')
self.assertEqual(actual[1][2].expected_message, 'Not: Alsonot: ')
self.assertEqual(actual[0][0].GetFirstDataForTimeEvent('this'), '')
self.assertEqual(actual[0][0].GetFirstDataForTimeEvent('that'), '')
self.assertEqual(actual[0][0].GetFirstDataForTimeEvent('another'), '')
self.assertEqual(actual[0][1].GetFirstDataForTimeEvent('this'), '')
self.assertEqual(actual[0][1].GetFirstDataForTimeEvent('that'), '')
self.assertEqual(actual[0][1].GetFirstDataForTimeEvent('another'), '')
def testColumnTypeForMultipleTables(self):
"""test getting the column type for multiple table"""
mappings = {'id': 'blob', 'that': 'varchar', 'different': 'integer'}
tables = ['db1', 'db2', 'db3']
query = (
'select db1.id , db2.that, db1.different,db2.id as id2, db3.id as '
'id3 from db1 join db2 join db3')
self.sql_type_helper._information = (
fake_database_information.FakeDatabaseInformation(None, mappings))
model = [
sql_query_column_model.SQLColumnModel('id'),
sql_query_column_model.SQLColumnModel('that'),
sql_query_column_model.SQLColumnModel('different'),
sql_query_column_model.SQLColumnModel('id2'),
sql_query_column_model.SQLColumnModel('id3')
]
result = self.sql_type_helper._ColumnTypeForMultipleTables(
tables, model, query)
self.assertEqual(len(result), 5)
self.assertEqual(result[0].sql_column, 'id')
self.assertEqual(result[1].sql_column, 'that')
self.assertEqual(result[2].sql_column, 'different')
self.assertEqual(result[3].sql_column, 'id2')
self.assertEqual(result[4].sql_column, 'id3')
self.assertEqual(result[0].sql_column_type, bytes)
self.assertEqual(result[1].sql_column_type, str)
self.assertEqual(result[2].sql_column_type, int)
self.assertEqual(result[3].sql_column_type, bytes)
self.assertEqual(result[4].sql_column_type, bytes)
def testAddMissingTypesFromSchemaForMultipleOneTable(self):
"""test getting missing types from schema multiple tables"""
mappings = {'id': 'blob', 'that': 'varchar', 'different': 'integer'}
tables = ['db1', 'db2', 'db3']
query = (
'select db1.id , db2.that, db1.different,db2.id as id2, db3.id as '
'id3 from db1 join db2 join db3')
self.sql_type_helper._information = (
fake_database_information.FakeDatabaseInformation(
tables, mappings))
self.sql_type_helper._explain = (
fake_explain_query_plan.FakeExplainQueryPlan(locked_tables=tables))
model = [
sql_query_column_model.SQLColumnModel('id'),
sql_query_column_model.SQLColumnModel('that'),
sql_query_column_model.SQLColumnModel('different'),
sql_query_column_model.SQLColumnModel('id2'),
sql_query_column_model.SQLColumnModel('id3')
]
result = self.sql_type_helper.AddMissingTypesFromSchema(model, query)
self.assertEqual(len(result), 5)
self.assertEqual(result[0].sql_column, 'id')
self.assertEqual(result[1].sql_column, 'that')
self.assertEqual(result[2].sql_column, 'different')
self.assertEqual(result[3].sql_column, 'id2')
self.assertEqual(result[4].sql_column, 'id3')
self.assertEqual(result[0].sql_column_type, bytes)
self.assertEqual(result[1].sql_column_type, str)
self.assertEqual(result[2].sql_column_type, int)
self.assertEqual(result[3].sql_column_type, bytes)
self.assertEqual(result[4].sql_column_type, bytes)
def testAddMissingTypesFromSchemaForOnlyOneTable(self):
"""test getting missing types from schema if only one table"""
mappings = {
'id': 'float',
'that': 'varchar',
'different': 'integer',
'bla': 'real'
}
query = "select id, that, db.different, bla from db"
tables = ['db']
self.sql_type_helper._explain = (
fake_explain_query_plan.FakeExplainQueryPlan(locked_tables=tables))
self.sql_type_helper._information = (
fake_database_information.FakeDatabaseInformation(
tables, mappings))
model = [
sql_query_column_model.SQLColumnModel('id'),
sql_query_column_model.SQLColumnModel('that'),
sql_query_column_model.SQLColumnModel('different'),
sql_query_column_model.SQLColumnModel('bla')
]
result = self.sql_type_helper.AddMissingTypesFromSchema(model, query)
self.assertEqual(len(result), 4)
self.assertEqual(result[0].sql_column, 'id')
self.assertEqual(result[1].sql_column, 'that')
self.assertEqual(result[2].sql_column, 'different')
self.assertEqual(result[3].sql_column, 'bla')
self.assertEqual(result[0].sql_column_type, float)
self.assertEqual(result[1].sql_column_type, str)
self.assertEqual(result[2].sql_column_type, int)
self.assertEqual(result[3].sql_column_type, float)
def testGetDuplicateColumnNamesIfDistinct(self):
"""test a distinct list"""
columns = list()
columns.append(sql_query_column_model.SQLColumnModel('a'))
columns.append(sql_query_column_model.SQLColumnModel('b'))
columns.append(sql_query_column_model.SQLColumnModel('c'))
result = self.sql_type_helper.GetDuplicateColumnNames(columns)
expected = []
self.assertEqual(result, expected)
def testGetDuplicateColumnNamesIfOneDuplicate(self):
"""test a duplicate list with one duplicate"""
columns = list()
columns.append(sql_query_column_model.SQLColumnModel('a'))
columns.append(sql_query_column_model.SQLColumnModel('a'))
columns.append(sql_query_column_model.SQLColumnModel('b'))
columns.append(sql_query_column_model.SQLColumnModel('c'))
result = self.sql_type_helper.GetDuplicateColumnNames(columns)
expected = ['a']
self.assertEqual(result, expected)
def testColumnAsSnakeCaseHasUnderline(self):
"""Test column as description for a name ending with an underscore
resulting in an error."""
column = sql_query_column_model.SQLColumnModel('error_')
actual = column.GetColumnAsSnakeCase()
expected = 'error_'
self.assertEqual(actual, expected)
def testGetColumnsAndTimestampColumnWithData(self):
"""test the getting of the column and timestamp column"""
timestamps = ['this', 'that', 'another']
columns = [
sql_query_column_model.SQLColumnModel('not'),
sql_query_column_model.SQLColumnModel('this'),
sql_query_column_model.SQLColumnModel('another'),
sql_query_column_model.SQLColumnModel('that'),
sql_query_column_model.SQLColumnModel('alsonot')
]
actual = self.helper.GetColumnsAndTimestampColumn(
columns, timestamps,
[['first', 'second', 'third', 'fourth', 'fifth'],
['the', 'next', 'data', 'row', 'things'],
['last', 'stuff', 'and', 'some', 'thing']])
self.assertEqual(len(actual), 2)
self.assertEqual(len(actual[0]), 2)
self.assertEqual(len(actual[1]), 3)
self.assertEqual(actual[0][0].sql_column, 'not')
self.assertEqual(actual[0][1].sql_column, 'alsonot')
self.assertEqual(actual[1][0].sql_column, 'this')
self.assertEqual(actual[1][1].sql_column, 'another')
self.assertEqual(actual[1][2].sql_column, 'that')
self.assertEqual(actual[1][0].timestamp, 'second')
self.assertEqual(actual[1][1].timestamp, 'data')
self.assertEqual(actual[1][2].timestamp, 'some')
self.assertEqual(actual[0][0].GetFirstDataForTimeEvent('this'),
'first')
self.assertEqual(actual[0][0].GetFirstDataForTimeEvent('that'), 'last')
self.assertEqual(actual[0][0].GetFirstDataForTimeEvent('another'),
'the')
self.assertEqual(actual[0][1].GetFirstDataForTimeEvent('this'),
'fifth')
self.assertEqual(actual[0][1].GetFirstDataForTimeEvent('that'),
'thing')
self.assertEqual(actual[0][1].GetFirstDataForTimeEvent('another'),
'things')
self.assertEqual(actual[1][0].expected_message,
'Not: first Alsonot: fifth')
self.assertEqual(actual[1][1].expected_message,
'Not: the Alsonot: things')
self.assertEqual(actual[1][2].expected_message,
'Not: last Alsonot: thing')
def testColumnTypeAsNameString(self):
"""Test getting the type for a string."""
column = sql_query_column_model.SQLColumnModel('string', str)
actual_type = column.sql_column_type
expected_type = str
actual = column.GetColumnTypeAsName()
expected = 'str'
self.assertEqual(actual_type, expected_type)
self.assertEqual(actual, expected)
def testColumnTypeAsNameInt(self):
"""Test getting the type for an int"""
column = sql_query_column_model.SQLColumnModel('string', int)
actual_type = column.sql_column_type
expected_type = int
actual = column.GetColumnTypeAsName()
expected = 'int'
self.assertEqual(actual_type, expected_type)
self.assertEqual(actual, expected)
def testGetColumnsAndTimestampColumnEmptyTimestamp(self):
"""test the getting of the column and timestamp column"""
columns = [
sql_query_column_model.SQLColumnModel('not'),
sql_query_column_model.SQLColumnModel('this'),
sql_query_column_model.SQLColumnModel('another'),
sql_query_column_model.SQLColumnModel('that'),
sql_query_column_model.SQLColumnModel('alsonot')
]
actual = self.helper.GetColumnsAndTimestampColumn(columns, [], [])
self.assertEqual(len(actual), 2)
self.assertEqual(len(actual[0]), 5)
self.assertEqual(len(actual[1]), 0)
self.assertEqual(actual[0][0].sql_column, 'not')
self.assertEqual(actual[0][1].sql_column, 'this')
self.assertEqual(actual[0][2].sql_column, 'another')
self.assertEqual(actual[0][3].sql_column, 'that')
self.assertEqual(actual[0][4].sql_column, 'alsonot')
def testGetAssumedTimestamps(self):
"""test the the parsing of assumed timestamps"""
columns = [
sql_query_column_model.SQLColumnModel('not'),
sql_query_column_model.SQLColumnModel('usertime'),
sql_query_column_model.SQLColumnModel('timecreation'),
sql_query_column_model.SQLColumnModel('date'),
sql_query_column_model.SQLColumnModel('time'),
sql_query_column_model.SQLColumnModel('DaTe'),
sql_query_column_model.SQLColumnModel('TiMe'),
sql_query_column_model.SQLColumnModel('userdate'),
sql_query_column_model.SQLColumnModel('datecreation')
]
actual = self.helper.GetAssumedTimestamps(columns)
expected = [
'usertime', 'timecreation', 'date', 'time', 'DaTe', 'TiMe',
'userdate', 'datecreation'
]
self.assertEqual(actual, expected)
def GetColumnInformationFromDescription(
self, descriptions: []) -> [sql_query_column_model.SQLColumnModel]:
"""Getting Information for the column out of the cursor.
Args:
descriptions: the descriptions of the cursor
Returns:
[sql_query_column_model.SQLColumnModel]: a list with all the column
names, the types are None
"""
sql_column = []
if descriptions:
sql_column = [
sql_query_column_model.SQLColumnModel(description[0],
type(None))
for description in descriptions
]
return sql_column
def testGetDistinctColumnsFromSQLQueryDataEmpty(self):
"""test the creating of a distinct list of all attributes of the queries
with an empty array"""
queries = list()
column1 = sql_query_model.SQLQueryModel(columns=[],
timestamp_columns=[],
query="",
name="",
needs_customizing=False,
amount_events=0)
column2 = sql_query_model.SQLQueryModel(
columns=[sql_query_column_model.SQLColumnModel('first')],
timestamp_columns=[],
query="",
name="",
needs_customizing=False,
amount_events=0)
queries.append(column1)
queries.append(column2)
actual = self.helper.GetDistinctColumnsFromSQLQueryData(queries)
expected = ['first']
self.assertEqual(actual, expected)
def testColumnAsDescriptionShortName(self):
"""Test column as description for a short name."""
column = sql_query_column_model.SQLColumnModel('short')
actual = column.GetColumnAsDescription()
expected = 'Short'
self.assertEqual(actual, expected)
def testColumnAsSnakeCaseLongNamePascalCase(self):
"""Test snake case for for a long name with pascal case."""
column = sql_query_column_model.SQLColumnModel('TheOneLongColumnName')
actual = column.GetColumnAsSnakeCase()
expected = 'the_one_long_column_name'
self.assertEqual(actual, expected)
def testColumnAsSnakeCaseStartWithNumber(self):
"""Test snake case for a name with numbers resulting in an error."""
column = sql_query_column_model.SQLColumnModel('123error')
actual = column.GetColumnAsSnakeCase()
expected = '123error'
self.assertEqual(actual, expected)
def testColumnAsSnakeCaseWithNumber(self):
"""Test snake case for a short name only small letters."""
column = sql_query_column_model.SQLColumnModel('int2val')
actual = column.GetColumnAsSnakeCase()
expected = 'int2val'
self.assertEqual(actual, expected)
def testColumnAsDescriptionLongNamePascalCase(self):
"""Test column as description for a long name with pascal case."""
column = sql_query_column_model.SQLColumnModel('TheOneLongColumnName')
actual = column.GetColumnAsDescription()
expected = 'The One Long Column Name'
self.assertEqual(actual, expected)
def testGetDistinctColumnsFromSQLQueryData(self):
"""test the creating of a distinct list of all attributes of the queries"""
queries = list()
column1 = sql_query_model.SQLQueryModel(columns=[
sql_query_column_model.SQLColumnModel('createdDate'),
sql_query_column_model.SQLColumnModel('updatedAt'),
sql_query_column_model.SQLColumnModel('screenName')
],
timestamp_columns=[],
query="",
name="",
needs_customizing=False,
amount_events=0)
column2 = sql_query_model.SQLQueryModel(columns=[
sql_query_column_model.SQLColumnModel('profileImageUrl'),
sql_query_column_model.SQLColumnModel('screenName'),
sql_query_column_model.SQLColumnModel('userId')
],
timestamp_columns=[],
query="",
name="",
needs_customizing=False,
amount_events=0)
column3 = sql_query_model.SQLQueryModel(columns=[
sql_query_column_model.SQLColumnModel('screenName'),
sql_query_column_model.SQLColumnModel('createdDate'),
sql_query_column_model.SQLColumnModel('createdDate')
],
timestamp_columns=[],
query="",
name="",
needs_customizing=False,
amount_events=0)
column4 = sql_query_model.SQLQueryModel(columns=[
sql_query_column_model.SQLColumnModel('screenNameSecond'),
sql_query_column_model.SQLColumnModel('createdDate')
],
timestamp_columns=[],
query="",
name="",
needs_customizing=False,
amount_events=0)
queries.append(column1)
queries.append(column2)
queries.append(column3)
queries.append(column4)
actual = self.helper.GetDistinctColumnsFromSQLQueryData(queries)
expected = [
'created_date', 'profile_image_url', 'screen_name',
'screen_name_second', 'updated_at', 'user_id'
]
self.assertEqual(actual, expected)
