def test_insertFile_skipErrors(self):
# Similar to test_insertFile_commandline, but just test to see if skipErrors option works
# Test run will show errror / warning messages from the app, but these are expected
DBUtil.runDBScript(
self.SCRIPT_FILE,
False) # Assume this works based on test_runDBScript method
tableName = "TestTypes"
columnNames = ["MyReal", "MyYesNo", "MyText", "MyInteger"]
idFile = StringIO()
# Try with bogus data that should generate errors
dataFile = StringIO()
dataFile.write("ABCD\tPositive\tBadTest\t100.123\n")
dataFile.write("700.7\t" + FALSE_STR + "\tXTest\t777\n")
dataFile.write("1,099\tNegative\tMoBadTest\tfoo\n")
dataFile = StringIO(dataFile.getvalue())
idFile = StringIO()
origStdin = sys.stdin
origStdout = sys.stdout
sys.stdin = dataFile
sys.stdout = idFile
argv = ["DBUtil.py", "-i-", "-t" + tableName, "-o-"]
argv.extend(columnNames)
expectErr = True
actualErr = False
try:
DBUtil.main(argv)
except Exception, err:
actualErr = True
def test_updateFromFile_commandline(self):
# Similar to test_updateFromFile, but from higher-level command-line interface
DBUtil.runDBScript( self.SCRIPT_FILE, False ) # Assume this works based on test_runDBScript method
# Insert some blank data first to update
for idValue in self.ID_DATA:
DBUtil.execute("insert into TestTypes ("+self.ID_COL+") values (%s)",(idValue,));
# Negative test case
results = DBUtil.execute( self.DATA_QUERY );
self.assertNotEqual( self.DATA_ROWS, results );
# Now do the actual update from the file, but build in column names to data file
dataFileWithCols = StringIO();
dataFileWithCols.write(self.DATA_COLS);
dataFileWithCols.write(self.DATA_FILE.getvalue());
dataFileWithCols = StringIO(dataFileWithCols.getvalue());
sys.stdin = dataFileWithCols;
argv = ["DBUtil.py","-u-","-t"+self.DATA_TABLE,"-d\\t"]
DBUtil.main(argv)
# Verify positive results
results = DBUtil.execute( self.DATA_QUERY );
self.assertEqual( self.DATA_ROWS, results );
########################################################
# Repeat test but data file will use more than one key column (adding MyText)
# Further note that MyText is used as both a key column to look up the row to update
# and as a value column to modify
dataFileWithCols = StringIO()
dataFileWithCols.write("MyInteger\tMyText\tMyText\tMyReal\tMyYesNo\n");
dataFileWithCols.write("100\tATest\tAAA\tNone\t"+TRUE_STR+"\t\n");
dataFileWithCols.write("200\tNone\tBBB\t222.2\tNone\t\n");
dataFileWithCols.write("300\tCTest\tNone\t333.3\t"+TRUE_STR+"\t\n");
dataFileWithCols = StringIO(dataFileWithCols.getvalue())
# Expected results after this update
self.DATA_ROWS = [];
self.DATA_ROWS.append([100,None, True, "AAA",]);
self.DATA_ROWS.append([200,200.2,False, None,]); # This row is unchanged, because one of the key values cannot be found as null
self.DATA_ROWS.append([300,333.3,True, None,]);
# Negative test case
results = DBUtil.execute( self.DATA_QUERY );
self.assertNotEqual( self.DATA_ROWS, results );
# Now do the actual update from the file, but with an extra parameter specifying 2 key columns
sys.stdin = dataFileWithCols;
argv = ["DBUtil.py","-u-","-t"+self.DATA_TABLE,"-n2"]
DBUtil.main(argv)
# Verify positive results
results = DBUtil.execute( self.DATA_QUERY );
self.assertEqual( self.DATA_ROWS, results );
def test_runDBScript_commandline(self):
# Equivalent to test_runDBScript, but try higher level interface
# through command-line "main" method
origStdin = sys.stdin
sys.stdin = self.SCRIPT_FILE
argv = ["DBUtil.py","--script","-"]
DBUtil.main(argv)
sys.stdin = origStdin
# Run some other commands to see if scripts produced expected results
results = DBUtil.execute("select * from TestTypes where MyInteger > %s", (200,))
self.assertEqual( 2, len(results) )
results = DBUtil.execute("select * from TestTypes where MyInteger < %s", (100,))
self.assertEqual( 0, len(results) )
def test_runDBScript_skipErrors(self):
# Similar to test_runDBScript_commandline, but test skipErrors option
origStdin = sys.stdin
sys.stdin = self.SCRIPT_FILE
argv = ["DBUtil.py", "--script", "-"]
DBUtil.main(argv)
sys.stdin = origStdin
# Run script again. Should generate errors from redundant create table, etc. But skip
self.SCRIPT_FILE.seek(0)
origStdin = sys.stdin
sys.stdin = self.SCRIPT_FILE
argv = ["DBUtil.py", "--script", "--skipErrors", "-"]
DBUtil.main(argv)
sys.stdin = origStdin
# Run script again. Should generate errors from redundant create table, etc. Verify by catch
self.SCRIPT_FILE.seek(0)
origStdin = sys.stdin
sys.stdin = self.SCRIPT_FILE
argv = ["DBUtil.py", "--script", "-"]
expectErr = True
actualErr = False
try:
DBUtil.main(argv)
except Exception, err:
actualErr = True
def test_insertFile_commandline(self):
# Similar to test_insertFile, but from higher-level command-line interface
DBUtil.runDBScript( self.SCRIPT_FILE, False ) # Assume this works based on test_runDBScript method
tableName = "TestTypes"
columnNames = self.DATA_COLS.split();
idFile = StringIO()
# Slightly different test, specify tab as delimiter, not just any whitespace
origStdin = sys.stdin
origStdout = sys.stdout
sys.stdin = self.MULTI_LINE_DATA_FILE
sys.stdout = idFile
argv = ["DBUtil.py","-i-","-d\\t","-t"+tableName,"-o-"]
DBUtil.main(argv)
sys.stdout = origStdout
sys.stdin = origStdin
self.assertEqual( 3, idFile.getvalue().count("\n") )
results = DBUtil.execute( self.DATA_QUERY );
self.assertEqual( self.MULTI_LINE_DATA_ROWS, results );
def test_execute_commandline(self):
# Run basic executes for both an update and a select query, but
# using the higher-level command-line "main" method interface
DBUtil.runDBScript( self.SCRIPT_FILE, False ) # Assume this works based on test_runDBScript method
origStdout = sys.stdout
sys.stdout = StringIO()
argv = ["DBUtil.py","select count(*) from TestTypes where MyInteger > 200","-"]
DBUtil.main(argv)
self.assertEqual( 2, int(sys.stdout.getvalue()) )
sys.stdout = origStdout
origStdout = sys.stdout
sys.stdout = StringIO()
argv = ["DBUtil.py","insert into TestTypes (MyText,MyInteger,MyYesNo) values ('Another',255,True)","-"]
DBUtil.main(argv)
#self.assertEqual( 1, int(sys.stdout.getvalue()) )
sys.stdout = origStdout
origStdout = sys.stdout
sys.stdout = StringIO()
argv = ["DBUtil.py","select count(*) from TestTypes where MyInteger > 200","-"]
DBUtil.main(argv)
self.assertEqual( 3, int(sys.stdout.getvalue()) )
sys.stdout = origStdout
# Different test, includeColumnNames
origStdout = sys.stdout
sys.stdout = StringIO()
argv = ["DBUtil.py","-c","select TestTypes_id,MyText,MyInteger,MyReal,MyDateTime,MyYesNo from TestTypes where MyInteger > 200 and MyYesNo = True","-"]
DBUtil.main(argv)
sampleLines = sys.stdout.getvalue().split("\n")
expected = ["TestTypes_id","MyText","MyInteger","MyReal","MyDateTime","MyYesNo"]
sampleColumns = sampleLines[0].split()
for iCol in range(len(expected)): # Case-insensitive comparison
expected[iCol] = expected[iCol].lower()
sampleColumns[iCol] = sampleColumns[iCol].lower();
for iCol, col in enumerate(sampleColumns):
self.assertEqual(expected[iCol],col)
self.assertEqual( 2+1+1, len(sampleLines) ) # 2 data lines + 1 column name line + 1 newline at end of output
sys.stdout = origStdout
dataFile = StringIO()
dataFile.write("ABCD\tPositive\tBadTest\t100.123\n")
dataFile.write("700.7\t" + FALSE_STR + "\tXTest\t777\n")
dataFile.write("1,099\tNegative\tMoBadTest\tfoo\n")
dataFile = StringIO(dataFile.getvalue())
idFile = StringIO()
origStdin = sys.stdin
origStdout = sys.stdout
sys.stdin = dataFile
sys.stdout = idFile
argv = ["DBUtil.py", "-i-", "-t" + tableName, "-o-",
"-e"] # -e option skipsErrors
argv.extend(columnNames)
DBUtil.main(argv)
sys.stdout = origStdout
sys.stdin = origStdin
# Still expect 1 row to get through successfuly, despite other invalid input
self.assertEqual(1, idFile.getvalue().count("\n"))
results = DBUtil.execute(
"select count(*) from TestTypes where MyText like %s", ("%Test", ))
self.assertEqual(1, results[0][0])
def test_insertFile_dateParsing(self):
# Create a test data file to insert, and verify no errors
DBUtil.runDBScript(
self.SCRIPT_FILE,
False) # Assume this works based on test_runDBScript method
def test_insertFile_skipErrors(self):
# Similar to test_insertFile_commandline, but just test to see if skipErrors option works
# Test run will show errror / warning messages from the app, but these are expected
DBUtil.runDBScript(
self.SCRIPT_FILE,
False) # Assume this works based on test_runDBScript method
tableName = "TestTypes"
columnNames = ["MyReal", "MyYesNo", "MyText", "MyInteger"]
idFile = StringIO()
# Try with bogus data that should generate errors
dataFile = StringIO()
dataFile.write("ABCD\tPositive\tBadTest\t100.123\n")
dataFile.write("700.7\t" + FALSE_STR + "\tXTest\t777\n")
dataFile.write("1,099\tNegative\tMoBadTest\tfoo\n")
dataFile = StringIO(dataFile.getvalue())
idFile = StringIO()
origStdin = sys.stdin
origStdout = sys.stdout
sys.stdin = dataFile
sys.stdout = idFile
argv = ["DBUtil.py", "-i-", "-t" + tableName, "-o-"]
argv.extend(columnNames)
expectErr = True
actualErr = False
try:
DBUtil.main(argv)
except Exception as err:
actualErr = True
self.assertEqual(expectErr, actualErr)
sys.stdout = origStdout
sys.stdin = origStdin
# Expect no rows succesffuly inserted since errors in input
self.assertEqual(0, idFile.getvalue().count("\n"))
results = DBUtil.execute(
"select count(*) from TestTypes where MyText like %s", ("%Test", ))
self.assertEqual(0, results[0][0])
# Try again, with bogus data that should generate errors
dataFile = StringIO()
dataFile.write("ABCD\tPositive\tBadTest\t100.123\n")
dataFile.write("700.7\t" + FALSE_STR + "\tXTest\t777\n")
dataFile.write("1,099\tNegative\tMoBadTest\tfoo\n")
dataFile = StringIO(dataFile.getvalue())
idFile = StringIO()
origStdin = sys.stdin
origStdout = sys.stdout
sys.stdin = dataFile
sys.stdout = idFile
argv = ["DBUtil.py", "-i-", "-t" + tableName, "-o-",
"-e"] # -e option skipsErrors
argv.extend(columnNames)
DBUtil.main(argv)
sys.stdout = origStdout
sys.stdin = origStdin
# Still expect 1 row to get through successfuly, despite other invalid input
self.assertEqual(1, idFile.getvalue().count("\n"))
results = DBUtil.execute(
"select count(*) from TestTypes where MyText like %s", ("%Test", ))
self.assertEqual(1, results[0][0])
