def test_check_type(self):
self.test_targets.extend([
database_f.DBField.data_type_syntax,
database_f.VarcharField.data_type_syntax,
database_f.DBField.check_type,
database_f.BooleanField.check_type,
database_f.DateField.check_type,
database_f.DoubleField.check_type,
database_f.IntegerField.check_type,
database_f.SerialField.check_type,
database_f.TextField.check_type,
database_f.TimestampField.check_type,
database_f.VarcharField.check_type,
])
cursor = database_f.get_test_cursor()
# We actually want to make our table
sync_f.check_table(cursor, fake_info, fix=True)
# Use this query to grab info about the rows
db_info_dict = {}
query = """SELECT data_type, column_name FROM INFORMATION_SCHEMA.COLUMNS where table_name = 'fake_connected'"""
try: cursor.execute(query)
except Exception as e:
raise Exception("Database error: %s\nQuery: %s" % (str(e.args[0]).replace("\n",""), query))
for row in cursor:
db_info_dict[row['column_name']] = row['data_type']
# BooleanField
the_field = database_f.BooleanField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['b1'], fake_info), [])
self.assertEqual(the_field.check_type(db_info_dict['v1'], fake_info),
["ALTER TABLE fake_connected ALTER COLUMN the_field TYPE boolean;"]
)
# DateField
the_field = database_f.DateField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['date_field'], fake_info), [])
self.assertEqual(the_field.check_type(db_info_dict['v1'], fake_info),
["ALTER TABLE fake_connected ALTER COLUMN the_field TYPE date;"]
)
# DoubleField
the_field = database_f.DoubleField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['d1'], fake_info), [])
self.assertEqual(the_field.check_type(db_info_dict['v1'], fake_info),
["ALTER TABLE fake_connected ALTER COLUMN the_field TYPE double precision;"]
)
# IntegerField
the_field = database_f.IntegerField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['i1'], fake_info), [])
self.assertEqual(the_field.check_type(db_info_dict['v1'], fake_info),
["ALTER TABLE fake_connected ALTER COLUMN the_field TYPE integer;"]
)
# SerialField
the_field = database_f.SerialField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['s1'], fake_info), [])
self.assertRaises(Exception, the_field.check_type, (db_info_dict['v1'], fake_info))
# TextField
the_field = database_f.TextField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['t1'], fake_info), [])
self.assertEqual(the_field.check_type(db_info_dict['v1'], fake_info),
["ALTER TABLE fake_connected ALTER COLUMN the_field TYPE text;"]
)
# TimestampField
the_field = database_f.TimestampField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['time_field'], fake_info), [])
self.assertEqual(the_field.check_type(db_info_dict['v1'], fake_info),
["ALTER TABLE fake_connected ALTER COLUMN the_field TYPE timestamp without time zone;"]
)
# VarcharField
the_field = database_f.VarcharField("the_field")
self.assertEqual(the_field.check_type(db_info_dict['v1'], fake_info), [])
self.assertEqual(the_field.check_type(db_info_dict['i1'], fake_info),
["ALTER TABLE fake_connected ALTER COLUMN the_field TYPE varchar(255);"]
)
# Drop it incase it affects any other tests
try:
cursor.execute("DROP TABLE fake_connected")
except Exception:
pass
def test_check_default(self):
self.test_targets.extend([
database_f.DBField.data_type_syntax,
database_f.VarcharField.data_type_syntax,
database_f.DBField.check_default,
database_f.BooleanField.check_default,
database_f.DateField.check_default,
database_f.DoubleField.check_default,
database_f.IntegerField.check_default,
database_f.SerialField.check_default,
database_f.TextField.check_default,
database_f.TimestampField.check_default,
database_f.VarcharField.check_default,
])
cursor = database_f.get_test_cursor()
# We actually want to make our table
sync_f.check_table(cursor, fake_info, fix=True)
# Use this query to grab info about the rows
db_info_dict = {}
query = """SELECT column_default, column_name FROM INFORMATION_SCHEMA.COLUMNS where table_name = 'fake_connected'"""
try: cursor.execute(query)
except Exception as e:
raise Exception("Database error: %s\nQuery: %s" % (str(e.args[0]).replace("\n",""), query))
for row in cursor:
db_info_dict[row['column_name']] = row['column_default']
# Have one correct and one incorrect default to ensure it's not replacing the correct ones
# BooleanField
self.assertEqual(database_f.BooleanField("the_field", default=False).check_default(
db_info_dict['b1'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT 'False';"])
self.assertEqual(database_f.BooleanField("the_field", default=True).check_default(
db_info_dict['b1'], fake_info
), [])
# DateField
self.assertEqual(database_f.DateField("the_field", default="1000-01-01").check_default(
db_info_dict['date_field'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT '1000-01-01';"])
self.assertEqual(database_f.DateField("the_field", default="2000-10-30").check_default(
db_info_dict['date_field'], fake_info
), [])
# DoubleField
self.assertEqual(database_f.DoubleField("the_field", default=1.5).check_default(
db_info_dict['d1'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT '1.5';"])
self.assertEqual(database_f.DoubleField("the_field", default=1.1).check_default(
db_info_dict['d1'], fake_info
), [])
# IntegerField
self.assertEqual(database_f.IntegerField("the_field", default=5).check_default(
db_info_dict['i1'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT '5';"])
self.assertEqual(database_f.IntegerField("the_field", default=1).check_default(
db_info_dict['i1'], fake_info
), [])
self.assertEqual(database_f.IntegerField("the_field", default=-1).check_default(
db_info_dict['i1'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT '-1';"])
# SerialField
self.assertEqual(database_f.SerialField("the_field", default=5).check_default(
db_info_dict['s1'], fake_info
), [])
self.assertEqual(database_f.SerialField("the_field", default=1).check_default(
db_info_dict['s1'], fake_info
), [])
# TextField
self.assertEqual(database_f.TextField("the_field", default='tt').check_default(
db_info_dict['t1'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT 'tt';"])
self.assertEqual(database_f.TextField("the_field", default='t1').check_default(
db_info_dict['t1'], fake_info
), [])
# TimestampField
self.assertEqual(database_f.TimestampField("the_field", default='2012-1-5 10:00:00').check_default(
db_info_dict['time_field'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT '2012-1-5 10:00:00';"])
self.assertEqual(database_f.TimestampField("the_field", default='2000-10-30 12:50:59').check_default(
db_info_dict['time_field'], fake_info
), [])
# VarcharField
self.assertEqual(database_f.VarcharField("the_field", default='vvv').check_default(
db_info_dict['v1'], fake_info
), ["ALTER TABLE fake_connected ALTER COLUMN the_field SET DEFAULT 'vvv';"])
self.assertEqual(database_f.VarcharField("the_field", default='v1').check_default(
db_info_dict['v1'], fake_info
), [])
# Drop it incase it affects any other tests
try:
cursor.execute("DROP TABLE fake_connected")
except Exception:
pass
def test_check_structure(self):
self.test_targets.append(sync_f.check_table)
self.test_targets.append(sync_f.check_table_fields)
self.test_targets.append(sync_f.create_table)
cursor = database_f.get_test_cursor()
# Just incase it's lingering from a previous test
try:
cursor.execute("DROP TABLE fake_connected")
except Exception:
pass
r = sync_f.check_table(cursor, fake_info, fix=False, show_fixes=True, die_queitly=False)
self.assertEqual(r, """create table fake_connected
(
s1 Serial NOT NULL,
v1 varchar(255) NOT NULL default 'v1',
v2 varchar(255) NOT NULL default 'v2',
i1 integer NOT NULL default '1',
i2 integer NOT NULL default '2',
t1 text NOT NULL default 't1',
t2 text NOT NULL default 't2',
d1 double precision NOT NULL default '1.1',
b1 boolean NOT NULL default 'True',
afield integer[] NOT NULL default '{0}',
bfield integer[] NOT NULL default '{1,2}',
date_field date NOT NULL default '2000-10-30',
time_field timestamp without time zone NOT NULL default '2000-10-30 12:50:59',
primary key (s1)
)
\033[31mTable missing\033[30;0m (fake_connected)""")
# Now we actually fix it
sync_f.check_table(cursor, fake_info, fix=True, show_fixes=False, die_queitly=False)
# And make sure it's done properly
r = sync_f.check_table(cursor, fake_info, fix=False, show_fixes=True, die_queitly=False)
self.assertEqual("\033[32mfake_connected is correct\033[30;0m", r)
# TEST CHECK_TABLE_FIELDS
#------------------------
# Start by making sure it shows as correct
r = sync_f.check_table_fields(cursor, fake_info, fix=False, show_fixes=False)
self.assertEqual("\033[32mfake_connected is correct\033[30;0m", r)
# Drop a field from the table to make sure we'll fix it
query = """ALTER TABLE fake_connected DROP COLUMN t1;"""
try: cursor.execute(query)
except Exception as e:
raise Exception("Database error: %s\nQuery: %s" % (str(e.args[0]).replace("\n",""), query))
r = sync_f.check_table_fields(cursor, fake_info, fix=False, show_fixes=True)
self.assertEqual("""\033[31mcolumn missing in fake_connected\033[30;0m (t1)
Fixes:
alter table fake_connected add column t1 text NOT NULL default 't1'
""", r)
# Drop the table, just to make sure it doesn't mess with anything else
query = """DROP TABLE fake_connected"""
try: cursor.execute(query)
except Exception as e:
raise Exception("Database error: %s\nQuery: %s" % (str(e.args[0]).replace("\n",""), query))
