def test_run_sql(self):
# Expected to return True
self.assertTrue(save_results_instance.run_sql(sql1), True)
self.assertTrue(save_results_instance.run_sql(sql2), True)
self.assertTrue(save_results_instance.run_sql(sql3), True)
# Expected to return False
self.assertFalse(save_results_instance.run_sql(sql4), False)
# Expected to return True
tdtestpy.delete_one_file(save_result_output)
self.assertTrue(save_results_instance.run_file(save_result_queries), True)
def test_validate_sql_results(self):
# Expected to return True because sql1 count and dbcinfo_org count is 3 and vice versa
self.assertTrue(validate_instance.validate_sql_results(sql1, sql1_org_result), True)
self.assertTrue(validate_instance.validate_sql_results(sql2, sql2_org_result), True)
self.assertTrue(validate_instance.validate_sql_results(sql3, sql3_org_result), True)
# Expected to return False because sql2 count is 1 and dbcinfo_org count is 3 and vice versa
self.assertFalse(validate_instance.validate_sql_results(sql1, sql2_org_result), False)
self.assertFalse(validate_instance.validate_sql_results(sql2, sql1_org_result), False)
# Delete control file before create
tdtestpy.delete_one_file(control_file)
# Expected to return True
self.assertTrue(validate_instance.create_control_file(sql1, "dbcinfo1"), True)
self.assertTrue(validate_instance.create_control_file(sql2, "dbcinfo2"), True)
self.assertTrue(validate_instance.create_control_file(sql3, "dbcinfo3"), True)
dbc_con = udaExec.connect(method=con_method, system=dbsName, username=user_name, password=user_password)
"""
# Testing tail logs
#get_tail_file ()
my_tails = Tail_Logs (logs_directory = "/qd0047/jenkins/jobs/CI-TestDev/jobs/tqst_ldi_pll/workspace/tqst_ldi_pll/output/snorri/2016-06-08-16-18/latest", \
logs_extension = "*.log")
my_tails.get_tail_file()
"""
# Testing for GetSQLResults
output_file = "test_output.log"
tdtestpy.delete_one_file(output_file)
sql = "select * from dbc.dbcinf"
write_results = tdtestpy.SaveSQLResults (dbc_con, output_file, test_ignore_errors, delimiter = ',', data_only = False, retlimit = 2)
if not write_results.run_sql (sql):
exit(1)
sql_file = os.path.join(working_dir, "sql.txt")
if not write_results.run_file (sql_file):
exit(1)
#test_cont (dbc_con)
def run_dml_item_inventory_plan(dbs_name, user_name, ignore_errors, run_result=None):
try:
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
with db_connect.cursor() as cursor:
# Run end isolated loading just in case prior run failed
item_inv_plan_eil = user_name.strip() + "_ITEM_INV_PLAN_LDI"
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (item_inv_plan_eil), ignoreErrors=[9887])
# Delete so we can use TPT streams to load it back
cursor.execute("delete ITEM_INVENTORY_PLAN_LDI where ITEM_INVENTORY_PLAN_DT < '1970-11-28'", ignoreErrors=ignore_errors)
logging.info ("TPT export for ITEM_INVENTORY_PLAN_LDI started")
if not tdtestpy.run_single_tpt(item_inventory_plan_export_file, item_inventory_plan_export_log, directory_path, \
dbs_name, user_name, user_name, item_inventory_plan_data_file, tracelevel):
msg = "TPT export for ITEM_INVENTORY_PLAN_LDI failed, please review " + item_inventory_plan_export_log
logging.info ("TPT export for ITEM_INVENTORY_PLAN_LDI completed with failure")
tdtestpy.copy_file (item_inventory_plan_export_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT export for ITEM_INVENTORY_PLAN_LDI completed successful")
tdtestpy.copy_file (item_inventory_plan_export_log, passed_dir)
logging.info ("TPT stream for ITEM_INVENTORY_PLAN_LDI started")
if not tdtestpy.run_single_tpt(item_inventory_plan_stream_file, item_inventory_plan_stream_log, directory_path, \
dbs_name, user_name, user_name, item_inventory_plan_data_file, tracelevel):
msg = "TPT stream for ITEM_INVENTORY_PLAN_LDI failed, please review " + item_inventory_plan_stream_log
logging.info ("TPT stream for ITEM_INVENTORY_PLAN_LDI completed with failure")
tdtestpy.copy_file (item_inventory_plan_stream_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT stream for ITEM_INVENTORY_PLAN_LDI completed successful")
tdtestpy.copy_file (item_inventory_plan_stream_log, passed_dir)
# Delete data file if TPT export and stream ran successful
tdtestpy.delete_one_file (item_inventory_plan_data_file_full_path)
cursor.execute("Select ITEM_INVENTORY_PLAN_DT, LOCATION_ID, ITEM_ID from ITEM_INVENTORY_PLAN_LDI sample 100")
result_set = cursor.fetchall()
index_combo_list = []
for row in result_set:
# Created sublist
combo_id = [row["ITEM_INVENTORY_PLAN_DT"], row["LOCATION_ID"], row["ITEM_ID"]]
# Append sublist to main list
index_combo_list.append(combo_id)
# Extract sublist from main list and replace index
for index_combo in index_combo_list:
cursor.execute("update ITEM_INVENTORY_PLAN_LDI set PLAN_ON_HAND_QTY = 0 \
where ITEM_INVENTORY_PLAN_DT = '%s' and LOCATION_ID = %s and ITEM_ID = '%s'" % (index_combo[0], \
index_combo[1], index_combo[2]), ignoreErrors=ignore_errors)
cursor.execute("delete ITEM_INVENTORY_PLAN_LDI \
where ITEM_INVENTORY_PLAN_DT = '%s' and LOCATION_ID = %s and ITEM_ID = '%s'" % (index_combo[0], \
index_combo[1], index_combo[2]), ignoreErrors=ignore_errors)
# Trim down main list to 20 elements
new_index_combo_list = index_combo_list[0:20]
for new_index_combo in new_index_combo_list:
cursor.execute("insert into ITEM_INVENTORY_PLAN_LDI select * from sit_ldi_pll_stage.ITEM_INVENTORY_PLAN_LDI \
where ITEM_INVENTORY_PLAN_DT = '%s' and LOCATION_ID = %s and ITEM_ID = '%s'" % (new_index_combo[0], \
new_index_combo[1], new_index_combo[2]), ignoreErrors=ignore_errors)
cursor.execute("update ITEM_INVENTORY_PLAN_LDI set PLAN_ON_HAND_RETAIL_AMT = PLAN_ON_HAND_QTY \
where ITEM_INVENTORY_PLAN_DT = '%s' and LOCATION_ID = %s and ITEM_ID = '%s'" % (new_index_combo[0], \
new_index_combo[1], new_index_combo[2]), ignoreErrors=ignore_errors)
cursor.execute("MERGE into ITEM_INVENTORY_PLAN_LDI as t1 \
using sit_ldi_pll_stage.ITEM_INVENTORY_PLAN_LDI as t2 \
on t1.ITEM_INVENTORY_PLAN_DT = t2.ITEM_INVENTORY_PLAN_DT \
and t1.LOCATION_ID = t2.LOCATION_ID \
and t1.ITEM_ID = t2.ITEM_ID \
WHEN MATCHED THEN \
UPDATE SET PLAN_ON_HAND_RETAIL_AMT = t2.PLAN_ON_HAND_RETAIL_AMT \
WHEN NOT MATCHED THEN \
insert (ITEM_INVENTORY_PLAN_DT, LOCATION_ID, ITEM_ID, PLAN_ON_HAND_QTY, PLAN_ON_HAND_RETAIL_AMT) \
values (t2.ITEM_INVENTORY_PLAN_DT, t2.LOCATION_ID, t2.ITEM_ID, t2.PLAN_ON_HAND_QTY, \
t2.PLAN_ON_HAND_RETAIL_AMT)", ignoreErrors=ignore_errors)
# Remove logically deleted rows to free up space
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (item_inv_plan_eil), ignoreErrors=[9887])
cursor.execute("ALTER TABLE ITEM_INVENTORY_PLAN_LDI RELEASE DELETED ROWS AND RESET LOAD IDENTITY", ignoreErrors=ignore_errors)
except Exception as e:
if run_result is None:
return str(e)
else:
run_result.put(str(e))
if run_result is None:
return True
else:
run_result.put(True)
def run_dml_item(dbs_name, user_name, item_available, ignore_errors, run_result=None):
try:
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
with db_connect.cursor() as cursor:
# Run end isolated loading just in case prior run failed
item_eil = user_name.strip() + "_ITEM_LDI"
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (item_eil), ignoreErrors=[9887])
cursor.execute("delete item_ldi \
where ITEM_AVAILABLE = '%s' \
and ITEM_ID not in (select ITEM_ID from ITEM_INVENTORY_LDI) \
and ITEM_ID not in (select ITEM_ID from ITEM_INVENTORY_PLAN_LDI) \
and ITEM_ID not in (select RETURNED_ITEM_ID from RETURN_TRANSACTION_LINE_LDI) \
and ITEM_ID not in (select ITEM_ID from SALES_TRANSACTION_LINE_PLL) \
and ITEM_ID not in (select ITEM_ID from ITEM_PRICE_HISTORY)" % (item_available[0]), ignoreErrors=ignore_errors)
cursor.execute("update item_ldi set ITEM_DESC = 'Product being recall and taking off store shelves' \
where ITEM_AVAILABLE = '%s'" % (item_available[0]), ignoreErrors=ignore_errors)
cursor.execute("MERGE into item_ldi as i1 \
using sit_ldi_pll_stage.item_ldi as i2 \
on i1.ITEM_ID = i2.ITEM_ID and i1.ITEM_LEVEL = i2.ITEM_LEVEL \
WHEN MATCHED THEN \
UPDATE SET ITEM_DESC = i2.ITEM_DESC \
WHEN NOT MATCHED THEN \
insert (ITEM_ID, ITEM_NAME, ITEM_LEVEL, ITEM_DESC, ITEM_SUBCLASS_CD, \
ITEM_TYPE_CD, INVENTORY_IND, VENDOR_PARTY_ID, COMMODITY_CD, BRAND_CD, \
ITEM_AVAILABLE, PRODUCT_IMEI, ITEM_JSON, ITEM_XML) \
values (i2.ITEM_ID, i2.ITEM_NAME, i2.ITEM_LEVEL, i2.ITEM_DESC, \
i2.ITEM_SUBCLASS_CD, i2.ITEM_TYPE_CD, i2.INVENTORY_IND, i2.VENDOR_PARTY_ID, \
i2.COMMODITY_CD, i2.BRAND_CD, i2.ITEM_AVAILABLE, i2.PRODUCT_IMEI, i2.ITEM_JSON, \
i2.ITEM_XML)", ignoreErrors=ignore_errors)
cursor.execute("update item_ldi set INVENTORY_IND = 'HQO' \
where ITEM_AVAILABLE = ''", ignoreErrors=ignore_errors)
cursor.execute("delete item_ldi \
where ITEM_AVAILABLE = '' \
and ITEM_LEVEL < 15 \
and ITEM_ID not in (select ITEM_ID from ITEM_INVENTORY_LDI) \
and ITEM_ID not in (select ITEM_ID from ITEM_INVENTORY_PLAN_LDI) \
and ITEM_ID not in (select RETURNED_ITEM_ID from RETURN_TRANSACTION_LINE_LDI) \
and ITEM_ID not in (select ITEM_ID from SALES_TRANSACTION_LINE_PLL) \
and ITEM_ID not in (select ITEM_ID from ITEM_PRICE_HISTORY)", ignoreErrors=ignore_errors)
logging.info ("TPT export for item_ldi started")
if not tdtestpy.run_single_tpt(item_ldi_export_file, item_ldi_export_log, directory_path, \
dbs_name, user_name, user_name, item_ldi_data_file, tracelevel):
msg = "TPT export for item_ldi failed, please review " + item_ldi_export_log
logging.info ("TPT export for item_ldi completed with failure")
tdtestpy.copy_file (item_ldi_export_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT export for item_ldi completed successful")
tdtestpy.copy_file (item_ldi_export_log, passed_dir)
logging.info ("TPT stream for item_ldi started")
if not tdtestpy.run_single_tpt(item_ldi_stream_file, item_ldi_stream_log, directory_path, \
dbs_name, user_name, user_name, item_ldi_data_file, tracelevel):
msg = "TPT stream for item_ldi failed, please review " + item_ldi_stream_log
logging.info ("TPT stream for item_ldi completed with failure")
tdtestpy.copy_file (item_ldi_stream_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT stream for item_ldi completed successful")
tdtestpy.copy_file (item_ldi_stream_log, passed_dir)
# Delete data file if TPT export and stream ran successful
tdtestpy.delete_one_file (item_ldi_data_file_full_path)
# Remove logically deleted rows to free up space
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (item_eil), ignoreErrors=[9887])
cursor.execute("ALTER TABLE ITEM_INVENTORY_PLAN_LDI RELEASE DELETED ROWS AND RESET LOAD IDENTITY", ignoreErrors=ignore_errors)
except Exception as e:
if run_result is None:
return str(e)
else:
run_result.put(str(e))
if run_result is None:
return True
else:
run_result.put(True)
def run_dml_return_trans_line(dbs_name, user_name, TRAN_LINE_STATUS_CD_LIST, ignore_errors, run_result=None):
try:
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
with db_connect.cursor() as cursor:
# Run end isolated loading just in case prior run failed
return_trans_line_eil = user_name.strip() + "_RETURN_TRANS_LINE_LDI"
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (return_trans_line_eil), ignoreErrors=[9887])
cursor.execute("update RETURN_TRANSACTION_LINE_LDI set TRAN_LINE_STATUS_CD = '%s' \
where TRAN_LINE_STATUS_CD = '%s'" % (TRAN_LINE_STATUS_CD_LIST[0], TRAN_LINE_STATUS_CD_LIST[1]), \
ignoreErrors=ignore_errors)
cursor.execute("delete RETURN_TRANSACTION_LINE_LDI \
where TRAN_LINE_STATUS_CD in ('A', 'B')", ignoreErrors=ignore_errors)
logging.info ("TPT export for RETURN_TRANSACTION_LINE_LDI started")
if not tdtestpy.run_single_tpt(return_transaction_line_export_file, return_transaction_line_export_log, directory_path, \
dbs_name, user_name, user_name, return_transaction_line_data_file, tracelevel):
msg = "TPT export for RETURN_TRANSACTION_LINE_LDI failed, please review " + return_transaction_line_export_log
logging.info ("TPT export for RETURN_TRANSACTION_LINE_LDI completed with failure")
tdtestpy.copy_file (return_transaction_line_export_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT export for RETURN_TRANSACTION_LINE_LDI completed successful")
tdtestpy.copy_file (return_transaction_line_export_log, passed_dir)
logging.info ("TPT stream for RETURN_TRANSACTION_LINE_LDI started")
if not tdtestpy.run_single_tpt(return_transaction_line_stream_file, return_transaction_line_stream_log, directory_path, \
dbs_name, user_name, user_name, return_transaction_line_data_file, tracelevel):
msg = "TPT stream for RETURN_TRANSACTION_LINE_LDI failed, please review " + return_transaction_line_stream_log
logging.info ("TPT stream for RETURN_TRANSACTION_LINE_LDI completed with failure")
tdtestpy.copy_file (return_transaction_line_stream_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT stream for RETURN_TRANSACTION_LINE_LDI completed successful")
tdtestpy.copy_file (return_transaction_line_stream_log, passed_dir)
# Delete data file if TPT export and stream ran successful
tdtestpy.delete_one_file (return_transaction_line_data_file_full_path)
cursor.execute("delete RETURN_TRANSACTION_LINE_LDI \
where TRAN_LINE_STATUS_CD = '%s'" % (TRAN_LINE_STATUS_CD_LIST[0]), ignoreErrors=ignore_errors)
cursor.execute("insert into RETURN_TRANSACTION_LINE_LDI select * from sit_ldi_pll_stage.RETURN_TRANSACTION_LINE_LDI \
where TRAN_LINE_STATUS_CD in ('%s', '%s')" % (TRAN_LINE_STATUS_CD_LIST[0], TRAN_LINE_STATUS_CD_LIST[1]), ignoreErrors=ignore_errors)
# Remove logically deleted rows to free up space
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (return_trans_line_eil), ignoreErrors=[9887])
cursor.execute("ALTER TABLE RETURN_TRANSACTION_LINE_LDI RELEASE DELETED ROWS AND RESET LOAD IDENTITY", ignoreErrors=ignore_errors)
except Exception as e:
if run_result is None:
return str(e)
else:
run_result.put(str(e))
if run_result is None:
return True
else:
run_result.put(True)
def run_dml_item_inventory(dbs_name, user_name, location_id_list, ignore_errors, run_result=None):
try:
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
with db_connect.cursor() as cursor:
# Run end isolated loading just in case prior run failed
item_inv_eil = user_name.strip() + "_ITEM_INV_LDI"
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (item_inv_eil), ignoreErrors=[9887])
cursor.execute("delete ITEM_INVENTORY_LDI \
where ITEM_INV_DT < '1975-01-01'", ignoreErrors=ignore_errors)
logging.info ("TPT export for ITEM_INVENTORY_LDI started")
if not tdtestpy.run_single_tpt(item_inventory_export_file, item_inventory_export_log, directory_path, \
dbs_name, user_name, user_name, item_inventory_data_file, tracelevel):
msg = "TPT export for ITEM_INVENTORY_LDI failed, please review " + item_inventory_export_log
logging.info ("TPT export for ITEM_INVENTORY_LDI completed with failure")
tdtestpy.copy_file (item_inventory_export_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT export for ITEM_INVENTORY_LDI completed successful")
tdtestpy.copy_file (item_inventory_export_log, passed_dir)
logging.info ("TPT stream for ITEM_INVENTORY_LDI started")
if not tdtestpy.run_single_tpt(item_inventory_stream_file, item_inventory_stream_log, directory_path, \
dbs_name, user_name, user_name, item_inventory_data_file, tracelevel):
msg = "TPT stream for ITEM_INVENTORY_LDI failed, please review " + item_inventory_stream_log
logging.info ("TPT stream for ITEM_INVENTORY_LDI completed with failure")
tdtestpy.copy_file (item_inventory_stream_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT stream for ITEM_INVENTORY_LDI completed successful")
tdtestpy.copy_file (item_inventory_stream_log, passed_dir)
# Delete data file if TPT export and stream ran successful
tdtestpy.delete_one_file (item_inventory_data_file_full_path)
for location_id in location_id_list:
cursor.execute("update ITEM_INVENTORY_LDI set ON_HAND_AT_RETAIL_AMT = 10000 \
where LOCATION_ID = %s" % (location_id), ignoreErrors=ignore_errors)
cursor.execute("delete ITEM_INVENTORY_LDI \
where LOCATION_ID = %s" % (location_id), ignoreErrors=ignore_errors)
location_id_set = str(tuple(location_id_list))
cursor.execute("insert into ITEM_INVENTORY_LDI select * from sit_ldi_pll_stage.ITEM_INVENTORY_LDI \
where LOCATION_ID in %s" % (location_id_set), ignoreErrors=ignore_errors)
# Remove logically deleted rows to free up space
cursor.execute("END ISOLATED LOADING FOR QUERY_BAND 'LDILoadGroup=%s;'" % (item_inv_eil), ignoreErrors=[9887])
cursor.execute("ALTER TABLE ITEM_INVENTORY_LDI RELEASE DELETED ROWS AND RESET LOAD IDENTITY", ignoreErrors=ignore_errors)
except Exception as e:
if run_result is None:
return str(e)
else:
run_result.put(str(e))
if run_result is None:
return True
else:
run_result.put(True)
pll_read_clone = args.pll_read_clone
all_read_clone = args.all_read_clone
ldi_write = args.ldi_write
pll_write = args.pll_write
validate_results = args.validate_results
dbc_password = args.dbc_password
node_password = args.node_password
update_control_file = args.update_control_file
tpt_trace_level = args.tpt_trace_level
action_on_error = args.action_on_error
#run_timestamp = time.strftime("%Y-%m-%d-%H-%M")
jmeter_prop_name = os.path.join(working_dir, "..", "tqst_ldi_pll.properties")
tdtestpy.delete_one_file (jmeter_prop_name)
# dump python log file to choosing directory for easy access
create_jmeter_prop_log = os.path.join(working_dir, "create_jmeter_properties.log")
fh = logging.FileHandler(create_jmeter_prop_log, mode="a", encoding="utf8")
fh.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
fh.setLevel(logging.DEBUG)
root = logging.getLogger()
root.addHandler(fh)
try:
# Debug info
logging.info("*************************************DEBUG INFO********************************************")
logging.info("System Name: %s" % (dbs_name))
logging.info("Run Test: %s" % (run_test))
def run_dml_transaction1(dbs_name, user_name, ignore_errors, run_result=None):
try:
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
with db_connect.cursor() as cursor:
# SALES_TRANSACTION_PLL table
cursor.execute("delete SALES_TRANSACTION_PLL where TRAN_DATE between '1970-01-01' and '1980-01-01'", ignoreErrors=ignore_errors)
logging.info ("TPT export for sale_trans_pll started")
if not tdtestpy.run_single_tpt(sale_trans_pll_export_file, sale_trans_pll_export_log, directory_path, \
dbs_name, user_name, user_name, sale_trans_pll_data_file, tracelevel):
msg = "TPT export for sale_trans_pll failed, please review " + sale_trans_pll_export_log
logging.info ("TPT export for sale_trans_pll completed with failure")
tdtestpy.copy_file (sale_trans_pll_export_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT export for sale_trans_pll completed successful")
tdtestpy.copy_file (sale_trans_pll_export_log, passed_dir)
logging.info ("TPT stream for sale_trans_pll started")
if not tdtestpy.run_single_tpt(sale_trans_pll_stream_file, sale_trans_pll_stream_log, directory_path, \
dbs_name, user_name, user_name, sale_trans_pll_data_file, tracelevel):
msg = "TPT stream for sale_trans_pll failed, please review " + sale_trans_pll_stream_log
logging.info ("TPT stream for sale_trans_pll completed with failure")
tdtestpy.copy_file (sale_trans_pll_stream_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT stream for sale_trans_pll completed successful")
tdtestpy.copy_file (sale_trans_pll_stream_log, passed_dir)
# Delete data file if TPT export and stream ran successful
tdtestpy.delete_one_file (sale_trans_pll_data_file_full_path)
# SALES_TRANSACTION_LINE_PLL table
cursor.execute("update SALES_TRANSACTION_LINE_PLL set TRAN_LINE_DATE = current_date, UNIT_COST_AMT = 12.10 \
where LOCATION < 50", ignoreErrors=ignore_errors)
cursor.execute("delete SALES_TRANSACTION_LINE_PLL where LOCATION < 50", ignoreErrors=ignore_errors)
cursor.execute("insert into SALES_TRANSACTION_LINE_PLL select * from sit_ldi_pll_stage.SALES_TRANSACTION_LINE_PLL \
where LOCATION < 50", ignoreErrors=ignore_errors)
# PARTY_PLL table
cursor.execute("delete PARTY_PLL where PARTY_STATE BETWEEN 'A' AND 'B'", ignoreErrors=ignore_errors)
cursor.execute("insert into PARTY_PLL select * from sit_ldi_pll_stage.PARTY_PLL \
where PARTY_STATE BETWEEN 'A' AND 'B'", ignoreErrors=ignore_errors)
# LOCATION_PLL table
cursor.execute("delete LOCATION_PLL where LOCATION_EFFECTIVE_DT < '1980-01-01'", ignoreErrors=ignore_errors)
cursor.execute("insert into LOCATION_PLL select * from sit_ldi_pll_stage.LOCATION_PLL \
where LOCATION_EFFECTIVE_DT < '1980-01-01'", ignoreErrors=ignore_errors)
except Exception as e:
if run_result is None:
return str(e)
else:
run_result.put(str(e))
if run_result is None:
return True
else:
run_result.put(True)
def run_dml_transaction4(dbs_name, user_name, ignore_errors, run_result=None):
try:
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
with db_connect.cursor() as cursor:
# SALES_TRANSACTION_PLL table
cursor.execute("insert into SALES_TRANSACTION_PLL select * from sit_ldi_pll_stage.SALES_TRANSACTION_PLL \
where TRAN_DATE > '2010-01-01'", ignoreErrors=ignore_errors)
cursor.execute("update SALES_TRANSACTION_PLL set VISIT_ID = 123, TRAN_STATUS_CD = 'T' \
where TRAN_DATE > '2010-01-01'", ignoreErrors=ignore_errors)
cursor.execute("delete SALES_TRANSACTION_PLL where TRAN_DATE > '2010-01-01'", ignoreErrors=ignore_errors)
cursor.execute("insert into SALES_TRANSACTION_PLL select * from sit_ldi_pll_stage.SALES_TRANSACTION_PLL \
where TRAN_DATE > '2010-01-01'", ignoreErrors=ignore_errors)
# SALES_TRANSACTION_LINE_PLL table
cursor.execute("delete SALES_TRANSACTION_LINE_PLL where LOCATION between 331 and 350", ignoreErrors=ignore_errors)
cursor.execute("insert into SALES_TRANSACTION_LINE_PLL select * from sit_ldi_pll_stage.SALES_TRANSACTION_LINE_PLL \
where LOCATION between 331 and 350", ignoreErrors=ignore_errors)
# PARTY_PLL table
cursor.execute("delete PARTY_PLL where PARTY_STATE = 'N'", ignoreErrors=ignore_errors)
logging.info ("TPT export for party_pll started")
if not tdtestpy.run_single_tpt(party_pll_export_file, party_pll_export_log, directory_path, \
dbs_name, user_name, user_name, party_pll_data_file, tracelevel):
msg = "TPT export for party_pll failed, please review " + party_pll_export_log
logging.info ("TPT export for party_pll completed with failure")
tdtestpy.copy_file (party_pll_export_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT export for party_pll completed successful")
tdtestpy.copy_file (party_pll_export_log, passed_dir)
logging.info ("TPT stream for party_pll started")
if not tdtestpy.run_single_tpt(party_pll_stream_file, party_pll_stream_log, directory_path, \
dbs_name, user_name, user_name, party_pll_data_file, tracelevel):
msg = "TPT stream for party_pll failed, please review " + party_pll_stream_log
logging.info ("TPT stream for party_pll completed with failure")
tdtestpy.copy_file (party_pll_stream_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT stream for party_pll completed successful")
tdtestpy.copy_file (party_pll_stream_log, passed_dir)
# Delete data file if TPT export and stream ran successful
tdtestpy.delete_one_file (party_pll_data_file_full_path)
cursor.execute("MERGE into PARTY_PLL as t1 \
using (select * from sit_ldi_pll_stage.PARTY_PLL where PARTY_STATE in ('N', 'O', 'P', 'S', 'T', 'W')) as t2 \
on t1.PARTY_ID = t2.PARTY_ID \
and t1.PARTY_STATE = t2.PARTY_STATE \
and t1.PARTY_CITY = t2.PARTY_CITY \
WHEN MATCHED THEN \
UPDATE SET LOCATION_POINT = t2.LOCATION_POINT, ACTIVE_AREA = t2.ACTIVE_AREA, ACTIVE_LINES = t2.ACTIVE_LINES,\
KEY_LINE = t2.KEY_LINE, KEY_POINTS = t2.KEY_POINTS, ALL_RELATED_GEO = t2.ALL_RELATED_GEO \
WHEN NOT MATCHED THEN \
insert (PARTY_ID, PARTY_TYPE_CD, PARTY_FIRSTNAME, PARTY_LASTNAME, PARTY_STREET_ADDRESS, \
PARTY_CITY, PARTY_STATE, PARTY_ZIP, PARTY_INFO_SOURCE_TYPE_CD, PARTY_START_DT, \
PARTY_FIRST_PURCHASE_DT, LOCATION_POINT, ACTIVE_AREA, ACTIVE_LINES, KEY_LINE, KEY_POINTS, ALL_RELATED_GEO) \
values (t2.PARTY_ID, t2.PARTY_TYPE_CD, t2.PARTY_FIRSTNAME, t2.PARTY_LASTNAME, t2.PARTY_STREET_ADDRESS, \
t2.PARTY_CITY, t2.PARTY_STATE, t2.PARTY_ZIP, t2.PARTY_INFO_SOURCE_TYPE_CD, t2.PARTY_START_DT, \
t2.PARTY_FIRST_PURCHASE_DT, t2.LOCATION_POINT, t2.ACTIVE_AREA, t2.ACTIVE_LINES, t2.KEY_LINE, \
t2.KEY_POINTS, t2.ALL_RELATED_GEO)", ignoreErrors=ignore_errors)
# LOCATION_PLL table
cursor.execute("update LOCATION_PLL set CHANNEL_CD = '12345', CHAIN_CD = 'ABCD', DISTRICT_CD = '456789' \
where LOCATION_EFFECTIVE_DT between '1990-02-01' and '2000-01-01'", ignoreErrors=ignore_errors)
cursor.execute("delete LOCATION_PLL where LOCATION_EFFECTIVE_DT between '1990-02-01' and '2000-01-01'", ignoreErrors=ignore_errors)
cursor.execute("insert into LOCATION_PLL select * from sit_ldi_pll_stage.LOCATION_PLL \
where LOCATION_EFFECTIVE_DT between '1990-02-01' and '2000-01-01'", ignoreErrors=ignore_errors)
except Exception as e:
if run_result is None:
return str(e)
else:
run_result.put(str(e))
if run_result is None:
return True
else:
run_result.put(True)
def run_dml_transaction2(dbs_name, user_name, ignore_errors, run_result=None):
try:
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
with db_connect.cursor() as cursor:
# SALES_TRANSACTION_PLL table
cursor.execute("update SALES_TRANSACTION_PLL set TRANS_YEAR = '2016', TRAN_TYPE_CD = 'T' \
where TRAN_DATE between '1980-02-01' and '1990-01-01'", ignoreErrors=ignore_errors)
cursor.execute("delete SALES_TRANSACTION_PLL where TRAN_DATE between '1980-02-01' and '1990-01-01'", ignoreErrors=ignore_errors)
cursor.execute("insert into SALES_TRANSACTION_PLL select * from sit_ldi_pll_stage.SALES_TRANSACTION_PLL \
where TRAN_DATE between '1980-02-01' and '1990-01-01'", ignoreErrors=ignore_errors)
# SALES_TRANSACTION_LINE_PLL table
cursor.execute("delete SALES_TRANSACTION_LINE_PLL where LOCATION > 480", ignoreErrors=ignore_errors)
logging.info ("TPT export for sale_trans_line_pll started")
if not tdtestpy.run_single_tpt(sale_trans_line_pll_export_file, sale_trans_line_pll_export_log, directory_path, \
dbs_name, user_name, user_name, sale_trans_line_pll_data_file, tracelevel):
msg = "TPT export for sale_trans_line_pll failed, please review " + sale_trans_line_pll_export_log
logging.info ("TPT export for sale_trans_line_pll completed with failure")
tdtestpy.copy_file (sale_trans_line_pll_export_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT export for sale_trans_line_pll completed successful")
tdtestpy.copy_file (sale_trans_line_pll_export_log, passed_dir)
logging.info ("TPT stream for sale_trans_line_pll started")
if not tdtestpy.run_single_tpt(sale_trans_line_pll_stream_file, sale_trans_line_pll_stream_log, directory_path, \
dbs_name, user_name, user_name, sale_trans_line_pll_data_file, tracelevel):
msg = "TPT stream for sale_trans_line_pll failed, please review " + sale_trans_line_pll_stream_log
logging.info ("TPT stream for sale_trans_line_pll completed with failure")
tdtestpy.copy_file (sale_trans_line_pll_stream_log, faileddir)
if run_result is None:
return msg
else:
run_result.put(msg)
logging.info ("TPT stream for sale_trans_line_pll completed successful")
tdtestpy.copy_file (sale_trans_line_pll_stream_log, passed_dir)
# Delete data file if TPT export and stream ran successful
tdtestpy.delete_one_file (sale_trans_line_pll_data_file_full_path)
# PARTY_PLL table
cursor.execute("delete PARTY_PLL where PARTY_STATE BETWEEN 'C' AND 'K' \
and PARTY_START_DT < '2012-01-01'", ignoreErrors=ignore_errors)
cursor.execute("update PARTY_PLL set PARTY_START_DT = '2016-01-01' \
where PARTY_STATE BETWEEN 'C' AND 'K'", ignoreErrors=ignore_errors)
cursor.execute("MERGE into PARTY_PLL as t1 \
using (select * from sit_ldi_pll_stage.PARTY_PLL where PARTY_STATE BETWEEN 'C' AND 'K') as t2 \
on t1.PARTY_ID = t2.PARTY_ID \
and t1.PARTY_STATE = t2.PARTY_STATE \
and t1.PARTY_CITY = t2.PARTY_CITY \
WHEN MATCHED THEN \
UPDATE SET PARTY_START_DT = t2.PARTY_START_DT \
WHEN NOT MATCHED THEN \
insert (PARTY_ID, PARTY_TYPE_CD, PARTY_FIRSTNAME, PARTY_LASTNAME, PARTY_STREET_ADDRESS, \
PARTY_CITY, PARTY_STATE, PARTY_ZIP, PARTY_INFO_SOURCE_TYPE_CD, PARTY_START_DT, \
PARTY_FIRST_PURCHASE_DT, LOCATION_POINT, ACTIVE_AREA, ACTIVE_LINES, KEY_LINE, KEY_POINTS, ALL_RELATED_GEO) \
values (t2.PARTY_ID, t2.PARTY_TYPE_CD, t2.PARTY_FIRSTNAME, t2.PARTY_LASTNAME, t2.PARTY_STREET_ADDRESS, \
t2.PARTY_CITY, t2.PARTY_STATE, t2.PARTY_ZIP, t2.PARTY_INFO_SOURCE_TYPE_CD, t2.PARTY_START_DT, \
t2.PARTY_FIRST_PURCHASE_DT, t2.LOCATION_POINT, t2.ACTIVE_AREA, t2.ACTIVE_LINES, t2.KEY_LINE, \
t2.KEY_POINTS, t2.ALL_RELATED_GEO)", ignoreErrors=ignore_errors)
# LOCATION_PLL table
cursor.execute("update LOCATION_PLL set CHAIN_CD = 'This is test' \
where LOCATION_EFFECTIVE_DT between '1980-02-01' and '1990-01-01'", ignoreErrors=ignore_errors)
cursor.execute("delete LOCATION_PLL where LOCATION_EFFECTIVE_DT between '1980-02-01' and '1990-01-01'", ignoreErrors=ignore_errors)
cursor.execute("insert into LOCATION_PLL select * from sit_ldi_pll_stage.LOCATION_PLL \
where LOCATION_EFFECTIVE_DT between '1980-02-01' and '1990-01-01'", ignoreErrors=ignore_errors)
except Exception as e:
if run_result is None:
return str(e)
else:
run_result.put(str(e))
if run_result is None:
return True
else:
run_result.put(True)
tpt_trace_level = args.tpt_trace_level
pll_write_ignore_errors = tdtestpy.get_ignore_errors(common_error) + ignore_error
# Set logs variables
pll_tables_write = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "latest")
faileddir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "failed")
passed_dir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "passed")
# Delete old_logs from latest
prior_run_id = int(str(iteration)) - 1
prior_check_log_name = user_name + "_pll_write_checktable_" + str(prior_run_id) + ".log"
old_checktable_log = os.path.join(pll_tables_write, prior_check_log_name)
tdtestpy.delete_one_file(old_checktable_log)
prior_testuser = user_name + "_pll_write_loop_" + str(prior_run_id) + ".log"
old_testuser_log = os.path.join(pll_tables_write, prior_testuser)
tdtestpy.delete_one_file(old_testuser_log)
prior_p_export_name = user_name + "_party_pll_tpt_export_loop_" + str(prior_run_id) + ".log"
old_p_export_log = os.path.join(pll_tables_write, prior_p_export_name)
tdtestpy.delete_one_file(old_p_export_log)
prior_p_stream_name = user_name + "_party_pll_tpt_stream_loop_" + str(prior_run_id) + ".log"
old_p_stream_log = os.path.join(pll_tables_write, prior_p_stream_name)
tdtestpy.delete_one_file(old_p_stream_log)
prior_l_export_name = user_name + "_location_pll_tpt_export_loop_" + str(prior_run_id) + ".log"
loopnum = "L" + iteration
pll_tables_read = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "latest")
faileddir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "failed")
passed_dir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "passed")
pll_tables_read_ignore_errors = tdtestpy.get_ignore_errors(common_error) + ignore_error
pll_tables_read_queries = os.path.join(scriptPath, "sql", "pll_tables_read.txt")
bteq_log = user_name + "_pll_tables_read_loop_" + iteration + "_clone.log"
bteq_out_file = os.path.join(pll_tables_read, bteq_log)
# Delete old log from latest
prior_run_id = int(str(iteration)) - 1
org_pll_read_clone = pll_read_clone
if org_pll_read_clone == 1:
old_bteq_log = user_name + "_pll_tables_read_loop_" + str(prior_run_id) + "_clone.log"
old_bteq_out_file = os.path.join(pll_tables_read, old_bteq_log)
tdtestpy.delete_one_file(old_bteq_out_file)
else:
while org_pll_read_clone != 0:
old_bteq_log = user_name + "_pll_tables_read_loop_" + str(prior_run_id) + "_clone" + str(org_pll_read_clone) + ".log"
old_bteq_out_file = os.path.join(pll_tables_read, old_bteq_log)
tdtestpy.delete_one_file(old_bteq_out_file)
org_pll_read_clone -= 1
old_testuser = user_name + "_pll_read_loop_" + str(prior_run_id) + "_python.log"
old_test_log_name = os.path.join(pll_tables_read, old_testuser)
tdtestpy.delete_one_file(old_test_log_name)
# dump python log to demo_log_path
testuser = user_name + "_pll_read_loop_" + iteration + "_python.log"
test_log_name = os.path.join(pll_tables_read, testuser)
fh = logging.FileHandler(test_log_name, mode="a", encoding="utf8")
"failed")
passed_dir = os.path.join(scriptPath, "output", dbs_name,
run_timestamp, "passed")
test_log_name = os.path.join(validate_result, testuser)
prior_log_name = os.path.join(validate_result, prior_user)
validate_result_ignore_errors = tdtestpy.get_ignore_errors(
common_error) + ignore_error
validate_fail_log = os.path.join(faileddir, "validate_fail_debug.log")
controldir = os.path.join(scriptPath, "controlfiles")
confrolname = "original_results.pickle"
controlfile = os.path.join(controldir, confrolname)
fail_count = 0
# Remove old debug file
tdtestpy.delete_one_file(validate_fail_log)
tdtestpy.delete_one_file(prior_log_name)
# dump python log to demo_log_path
fh = logging.FileHandler(test_log_name, mode="a", encoding="utf8")
fh.setFormatter(
logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
fh.setLevel(logging.DEBUG)
root = logging.getLogger()
root.addHandler(fh)
# Start validate
logging.info(
"================== Start validate Test ==================")
dbc_con = udaExec.connect(method=con_method,
system=dbsName,
username=user_name,
password=user_password)
"""
# Testing tail logs
#get_tail_file ()
my_tails = Tail_Logs (logs_directory = "/qd0047/jenkins/jobs/CI-TestDev/jobs/tqst_ldi_pll/workspace/tqst_ldi_pll/output/snorri/2016-06-08-16-18/latest", \
logs_extension = "*.log")
my_tails.get_tail_file()
"""
# Testing for GetSQLResults
output_file = "test_output.log"
tdtestpy.delete_one_file(output_file)
sql = "select * from dbc.dbcinf"
write_results = tdtestpy.SaveSQLResults(dbc_con,
output_file,
test_ignore_errors,
delimiter=',',
data_only=False,
retlimit=2)
if not write_results.run_sql(sql):
exit(1)
sql_file = os.path.join(working_dir, "sql.txt")
if not write_results.run_file(sql_file):
exit(1)
bteq_ignore_errors = tdtestpy.get_ignore_errors(
common_error) + ignore_error
bteq_errorlevel_set = str(tuple(bteq_ignore_errors))
bteq_in_file = os.path.join(scriptPath, "sql", "all_tables_read.txt")
bteq_log = user_name + "_all_tables_read_loop_" + iteration + "_clone.log"
bteq_out_file = os.path.join(all_tables_read, bteq_log)
# Delete old log from latest
prior_run_id = int(str(iteration)) - 1
org_all_read_clone = all_read_clone
if org_all_read_clone == 1:
old_bteq_log = user_name + "_all_tables_read_loop_" + str(
prior_run_id) + "_clone.log"
old_bteq_out_file = os.path.join(all_tables_read, old_bteq_log)
tdtestpy.delete_one_file(old_bteq_out_file)
else:
while org_all_read_clone != 0:
old_bteq_log = user_name + "_all_tables_read_loop_" + str(
prior_run_id) + "_clone" + str(org_all_read_clone) + ".log"
old_bteq_out_file = os.path.join(all_tables_read, old_bteq_log)
tdtestpy.delete_one_file(old_bteq_out_file)
org_all_read_clone -= 1
old_testuser = user_name + "_all_read_loop_" + str(
prior_run_id) + "_python.log"
old_test_log_name = os.path.join(all_tables_read, old_testuser)
tdtestpy.delete_one_file(old_test_log_name)
# dump python log to demo_log_path
testuser = user_name + "_all_read_loop_" + iteration + "_python.log"
self.assertTrue(save_results_instance.run_file(save_result_queries), True)
if __name__ == '__main__':
args = setup_argparse()
dbs_name = args.dbs_name
user_name = args.user_name
user_password = args.user_password
ignore_error = args.ignore_error
sql_queries = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "sql", "create_user.txt")
control_file = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "controlfile", "original_results.pickle")
save_result_queries = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "sql", "save_results.txt")
save_result_output = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "results_output.txt")
tdtestpy.delete_one_file(save_result_output)
udaExec = teradata.UdaExec (appName="tdtestpy", version="1.0", logConsole=True)
db_connect = udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_password)
dbc_instance = tdtestpy.DBSaccess (db_connect)
validate_instance = tdtestpy.SQLValidation (db_connect, control_file)
allresults = validate_instance.load_control_file()
sql1_org_result = allresults["dbcinfo1"]
sql2_org_result = allresults["dbcinfo2"]
sql3_org_result = allresults["dbcinfo3"]
sql1 = "select count(*) from dbc.dbcinfo"
sql2 = "select count(*) from dbc.dbcinfo where InfoKey = 'RELEASE'"
sql3 = "select InfoKey from dbc.dbcinfo"
sql4 = "select count(*) from dbc.dbcinf"
testuser = user_name + "_validate_result_loop_" + iteration + ".log"
validate_result = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "latest")
faileddir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "failed")
passed_dir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "passed")
test_log_name = os.path.join(validate_result, testuser)
prior_log_name = os.path.join(validate_result, prior_user)
validate_result_ignore_errors = tdtestpy.get_ignore_errors(common_error) + ignore_error
validate_fail_log = os.path.join(faileddir, "validate_fail_debug.log")
controldir = os.path.join(scriptPath, "controlfiles")
confrolname = "original_results.pickle"
controlfile = os.path.join(controldir, confrolname)
fail_count = 0
# Remove old debug file
tdtestpy.delete_one_file(validate_fail_log)
tdtestpy.delete_one_file(prior_log_name)
# dump python log to demo_log_path
fh = logging.FileHandler(test_log_name, mode="a", encoding="utf8")
fh.setFormatter(logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s"))
fh.setLevel(logging.DEBUG)
root = logging.getLogger()
root.addHandler(fh)
# Start validate
logging.info("================== Start validate Test ==================")
with udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_name) as db_connect:
random_return_trans_status = random.sample(set(return_trans_status), 2) random_location_id = random.sample(set(location_id), 30) # Set logs variables ldi_tables_write = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "latest") faileddir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "failed") passed_dir = os.path.join(scriptPath, "output", dbs_name, run_timestamp, "passed") # Delete old_logs from latest prior_run_id = int(str(iteration)) - 1 prior_check_log_name = user_name + "_ldi_write_checktable_" + str(prior_run_id) + ".log" old_checktable_log = os.path.join(ldi_tables_write, prior_check_log_name) tdtestpy.delete_one_file(old_checktable_log) prior_testuser = user_name + "_ldi_write_loop_" + str(prior_run_id) + ".log" old_testuser = os.path.join(ldi_tables_write, prior_testuser) tdtestpy.delete_one_file(old_testuser) prior_iip_export_name = user_name + "_item_inv_plan_ldi_tpt_export_loop_" + str(prior_run_id) + ".log" old_iip_export_name = os.path.join(ldi_tables_write, prior_iip_export_name) tdtestpy.delete_one_file(old_iip_export_name) prior_iip_stream_name = user_name + "_item_inv_plan_ldi_tpt_stream_loop_" + str(prior_run_id) + ".log" old_iip_stream_name = os.path.join(ldi_tables_write, prior_iip_stream_name) tdtestpy.delete_one_file(old_iip_stream_name)
tpt_queries = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "sql", "tpt_data.txt")
tpt_export = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "export.tpt")
tpt_export_log = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "export_out.log")
tpt_stream = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "stream.tpt")
tpt_failed = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "export_no_table.tpt")
tpt_failed_log = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "failed_out.log")
tpt_stream_log = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "stream_out.log")
tpt_incorrect_password_log = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "incorrect_password_out.log")
tpt_export_pipe_log = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "export_pipe_out.log")
tpt_stream_pipe_log = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "stream_pipe_out.log")
tpt_export_pipe_log_failed = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "export_pipe_failed_out.log")
tpt_stream_pipe_log_no_row = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "stream_pipe_no_row_out.log")
tpt_export_pipe_log_incorrect_pass = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "export_pipe_incorrect_pass_out.log")
tpt_stream_pipe_log_incorrect_pass = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "stream_pipe_incorrect_pass_out.log")
tpt_named_pipe = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt", "test_pipe.dat")
tpt_directory = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "tpt")
bteq_output = os.path.join(os.path.dirname(os.path.realpath(__file__)), '..', "bteq_output.txt")
tdtestpy.delete_one_file(bteq_output)
udaExec = teradata.UdaExec (appName="tdtestpy", version="1.0", logConsole=True)
db_connect = udaExec.connect(method="odbc", system=dbs_name, username=user_name, password=user_password)
dbc_instance = tdtestpy.DBSaccess (db_connect)
# Clean up test database before start unit testing just in case it failed prior run
dbc_instance.drop_user("tdtestpy_unit_test_tpt")
#http://stackoverflow.com/questions/1029891/python-unittest-is-there-a-way-to-pass-command-line-options-to-the-app
sys.argv[1:] = args.unittest_args
unittest.main()