def test_main(self):
# test the prompt
sys.stdin = io.StringIO('dog')
with io.StringIO() as buf, redirect_stdout(buf):
try:
main()
except:
pass
self.assertEqual("Enter file name: ", buf.getvalue())
sys.stdin = sys.__stdin__
# test main
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest.txt', 'r')
outfile = open('main_out.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
main()
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('main_out_correct.txt', 'main_out.txt'))
self.assertTrue(compare_files('outtest.txt', 'MAD_tortoise.txt'))
def test_main(self):
# test the prompt
sys.stdin = io.StringIO('dog')
with io.StringIO() as buf, redirect_stdout(buf):
try:
main()
except:
pass
self.assertEqual("Enter file name: ", buf.getvalue())
sys.stdin = sys.__stdin__
# test main
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest_madlib.txt', 'r')
outfile = open('main_out.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
main()
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('main_out_correct_madlib.txt', 'main_out.txt'))
self.assertTrue(compare_files('outtest.txt', 'MAD_tortoise.txt'))
def test_4kb_file(self):
file_orig = "./testdata/basic/KB0004"
compress(file_orig, FILE_COMPRESSED_NAME, 1000, False)
decompress(FILE_COMPRESSED_NAME, FILE_DECOMPRESSED_NAME)
self.assertTrue(compare_files(file_orig, FILE_DECOMPRESSED_NAME))
os.remove(FILE_COMPRESSED_NAME)
os.remove(FILE_DECOMPRESSED_NAME)
def test_pdf_file(self):
file_orig = "./testdata/additional/pdf/Izb_04_08.pdf"
compress(file_orig, FILE_COMPRESSED_NAME, 1024 * 1024, False)
decompress(FILE_COMPRESSED_NAME, FILE_DECOMPRESSED_NAME)
self.assertTrue(compare_files(file_orig, FILE_DECOMPRESSED_NAME))
os.remove(FILE_COMPRESSED_NAME)
os.remove(FILE_DECOMPRESSED_NAME)
def test_bmp_file_2(self):
file_orig = "./testdata/additional/bmp/poirot_new.bmp"
compress(file_orig, FILE_COMPRESSED_NAME, 1024 * 1024, False)
decompress(FILE_COMPRESSED_NAME, FILE_DECOMPRESSED_NAME)
self.assertTrue(compare_files(file_orig, FILE_DECOMPRESSED_NAME))
os.remove(FILE_COMPRESSED_NAME)
os.remove(FILE_DECOMPRESSED_NAME)
def test_122kb_file_16mb_dict(self):
file_orig = "./testdata/basic/KB0122"
compress(file_orig, FILE_COMPRESSED_NAME, 3500, True)
decompress(FILE_COMPRESSED_NAME, FILE_DECOMPRESSED_NAME)
self.assertTrue(compare_files(file_orig, FILE_DECOMPRESSED_NAME))
os.remove(FILE_COMPRESSED_NAME)
os.remove(FILE_DECOMPRESSED_NAME)
def test_complete_mad_lib(self):
save_in = sys.stdin
infile = open('intest_cm.txt', 'r')
sys.stdin = infile
complete_mad_lib('tortoise.txt')
sys.stdin = save_in
infile.close()
self.assertTrue(compare_files('outtest.txt', 'MAD_tortoise.txt'))
def test_complete_mad_lib(self):
save_in = sys.stdin
infile = open('intest_cm.txt', 'r')
sys.stdin = infile
complete_mad_lib('tortoise.txt')
sys.stdin = save_in
infile.close()
self.assertTrue(compare_files('outtest.txt', 'MAD_tortoise.txt'))
def test_clean_and_jsonify(self):
'''
Fix this one by mocking the call to recalc
'''
# add a test for the default value of precision
fnames = ['wrcc_pcpn.html', 'wrcc_mint.html', 'wrcc_maxt.html']
fnames2 = ['wrcc_pcpn.json', 'wrcc_mint.json', 'wrcc_maxt.json']
files = os.listdir()
for f in fnames2:
if f in files:
os.remove(f)
clean_and_jsonify(fnames, -999, 2)
self.assertTrue(
compare_files('wrcc_pcpn_correct.json', 'wrcc_pcpn.json'))
self.assertTrue(
compare_files('wrcc_maxt_correct.json', 'wrcc_maxt.json'))
self.assertTrue(
compare_files('wrcc_mint_correct.json', 'wrcc_mint.json'))
def test_emoticons_main(self):
files = os.listdir()
if "emoticons_main_out.txt" in files:
os.remove("emoticons_main_out.txt")
with open("emoticons_main_out.txt", "w") as fp:
sys.stdout = fp
emoticons.main()
sys.stdout = sys.__stdout__
self.assertTrue(compare_files("emoticons_main_out_correct.txt", "emoticons_main_out.txt"))
def test_fishcatch_main(self):
files = os.listdir()
if "fishcatch_main_out.txt" in files:
os.remove("fishcatch_main_out.txt")
with open("fishcatch_main_out.txt", "w") as fp:
sys.stdout = fp
fishcatch.main()
sys.stdout = sys.__stdout__
self.assertTrue(compare_files("fishcatch_main_out_correct.txt", "fishcatch_main_out.txt"))
def test_emoticons_main(self):
files = os.listdir()
if 'emoticons_main_out.txt' in files:
os.remove('emoticons_main_out.txt')
with open('emoticons_main_out.txt', 'w') as fp:
sys.stdout = fp
emoticons.main()
sys.stdout = sys.__stdout__
self.assertTrue(compare_files('emoticons_main_out_correct.txt', 'emoticons_main_out.txt'))
def test_fishcatch_main(self):
files = os.listdir()
if 'fishcatch_main_out.txt' in files:
os.remove('fishcatch_main_out.txt')
with open('fishcatch_main_out.txt', 'w') as fp:
sys.stdout = fp
fishcatch.main()
sys.stdout = sys.__stdout__
self.assertTrue(compare_files('fishcatch_main_out_correct.txt', 'fishcatch_main_out.txt'))
def test_write_converted_csv(self):
files = os.listdir()
if 'csv_out.csv' in files:
os.remove('csv_out.csv')
names = ['Arctic Fox', 'Bat', 'Cougar']
body_weights = [28, 5.34, 94.3]
brain_weights = [2.8, .78, 9.43]
write_converted_csv('csv_out.csv', names, body_weights, brain_weights)
self.assertTrue(compare_files('csv_out_correct.csv', 'csv_out.csv'))
def test_main(self):
files = os.listdir()
if 'main_out.txt' in files:
os.remove('main_out.txt')
if 'BrainBodyWeightPounds.csv' in files:
os.remove('BrainBodyWeightPounds.csv')
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest_bbw.txt', 'r')
outfile = open('main_out.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
main()
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('main_out_correct_bbw.txt', 'main_out.txt'))
self.assertTrue(compare_files('BrainBodyWeightPounds_correct.csv', 'BrainBodyWeightPounds.csv'))
def test_main(self):
out = 'rpg_main_out.txt'
if os.path.isfile(out):
os.remove(out)
se = [3, 5, 12, 4, 10, 6, 1, 14, 3, 18, 2, 2, 1, 20, 5, 10, 4, 3, 15, 5]
with open(out, 'w') as fp:
with patch('builtins.input', side_effect=['\n', '\n', '\n', '\n']):
with patch('random.randrange', side_effect=se):
sys.stdout = fp
main()
sys.stdout = sys.__stdout__
self.assertTrue(compare_files('rpg_main_out_correct.txt', out))
def test_print_report(self):
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest_cm.txt', 'r')
outfile = open('report.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
print_report('tortoise.txt')
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('report_correct.txt', 'report.txt'))
def get_files():
if request.method == "POST":
file_1 = request.files['file_1']
filename_1 = secure_filename(file_1.filename)
file_path_1 = os.path.join(app.config['UPLOAD_FOLDER'], filename_1)
file_1.save(file_path_1)
file_2 = request.files['file_2']
filename_2 = secure_filename(file_1.filename)
file_path_2 = os.path.join(app.config['UPLOAD_FOLDER'], filename_2)
file_2.save(file_path_2)
return compare_files(file_path_1, file_path_2)
else:
return render_template("file_upload.html")
def test_print_report(self):
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest_cm.txt', 'r')
outfile = open('report.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
print_report('tortoise.txt')
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('report_correct.txt', 'report.txt'))
def test_main(self):
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest.txt')
outfile = open('main_out.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
main()
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('main_out_correct.txt','main_out.txt'))
def test_main(self):
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest.txt')
outfile = open('main_out.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
main()
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('main_out_correct.txt','main_out.txt'))
def f_score(corpus):
file_names = [
f for f in glob.glob(corpus + "/**", recursive=True)
if not os.path.isdir(f)
]
tp = 0
fp = 0
tn = 0
fn = 0
tries = 500
for test in range(tries):
print(test)
fileA = file_names[random.randint(0, len(file_names) - 1)]
fileB = file_names[random.randint(0, len(file_names) - 1)]
while fileA == fileB:
fileB = file_names[random.randint(0, len(file_names) - 1)]
if bool(random.getrandbits(1)):
generate_test_files(
random.randint(1, 100) / 100, fileA, fileB, corpus + "/tmp")
if compare_files(corpus, fileB, corpus + "/tmp") >= 0.01:
tp += 1
else:
fn += 1
else:
generate_test_files(0, fileA, fileB, corpus + "/tmp")
if compare_files(corpus, fileB, corpus + "/tmp") >= 0.01:
fp += 1
else:
tn += 1
precision = tp / (tp + fp)
recall = tp / (tp + fn)
fscore = 2 * (precision * recall) / (precision + recall)
print("precision:", precision)
print("recall:", recall)
print("f-score:", fscore)
os.remove(corpus + "/tmp")
def standard_test(corpus):
file_names = [
f for f in glob.glob(corpus + "/**", recursive=True)
if not os.path.isdir(f)
]
percents = []
score = []
similarities = []
tries = 100
steps = [100, 80, 60, 40, 20, 10, 6, 3, 1]
# steps = range(100, 0, -1)
for p in steps:
print("Testing", p, "%")
detections = 0
avg_sim = 0
for i in range(tries):
fileA = file_names[random.randint(0, len(file_names) - 1)]
fileB = file_names[random.randint(0, len(file_names) - 1)]
while fileA == fileB:
fileB = file_names[random.randint(0, len(file_names) - 1)]
generate_test_files(p / 100, fileA, fileB, corpus + "/tmp")
similarity = compare_files(corpus, fileB, corpus + "/tmp")
avg_sim += similarity
if similarity >= 0.01:
detections += 1
avg_sim /= tries
percents.append(str(p) + "%")
score.append(100 * detections / tries)
similarities.append(avg_sim)
os.remove(corpus + "/tmp")
# drawing a plot
font = {'family': 'DejaVu Sans', 'weight': 'bold', 'size': 12}
plt.rc('font', **font)
fig, ax1 = plt.subplots()
ax1.plot(percents, score, 'b-')
ax1.set_xlabel("Odstotek ujemanja")
ax1.set_ylabel("Zaznano")
ax1.set_ylim(0, 110)
ax2 = ax1.twinx()
ax2.bar(percents, similarities, align='center', alpha=0.5)
ax2.set_ylabel('Ocena ujemanja')
ax2.set_ylim(0, 1.1)
ax2.tick_params('y')
plt.title("Zaznava ujemanja")
plt.show()
def test_print_report(self):
save_in = sys.stdin
save_out = sys.stdout
infile = open('intest_cm.txt', 'r')
outfile = open('report.txt', 'w')
sys.stdin = infile
sys.stdout = outfile
print_report('tortoise.txt')
sys.stdin = save_in
sys.stdout = save_out
infile.close()
outfile.close()
self.assertTrue(compare_files('report_correct.txt', 'report.txt'))
line = open('report.txt').readline()
self.assertEquals('\n', line[0])
self.assertTrue('tortoise' not in inspect.getsource(print_report))
def update_data():
contract_expiration_list = run_over_time_frame()
download_raw_data(contract_expiration_list)
compare_files()
if (args.baselineDir != ""):
relTestDir = os.path.relpath(os.getcwd(), args.testDir)
baseFilename = args.baselineDir + "/" + relTestDir + "/" + outputDirectory + args.cmpFile
testFilename = args.testDir + "/" + relTestDir + "/" + outputDirectory + args.cmpFile
# compare with baseline run
returnCode = subprocess.call(["cmp", baseFilename, testFilename])
if (returnCode == 0):
# files identical
print("Comparison files identical")
exit(0)
elif (returnCode == 1):
# files differ
print("Comparison files differ")
compare_files(baseFilename,testFilename)
exit(1)
else:
# other error
print ("cmp: error code: ", returnCode)
exit(1)
else:
print ("No baseline defined")
exit(1)
def main(
credentials="",
service_csv="",
out_dir="",
appliance_dir="",
wrapcolumn=80,
tabsize=4,
no_only_differences=False,
no_remove_namespaces=False,
no_same_filenames=False,
):
parser = etree.XMLParser(
remove_blank_text=True,
strip_cdata=False,
)
crypto_rows = [[
"localfile",
"class",
"name",
"password",
"password alias",
"filename",
"subject",
"issuer",
"SANs",
"not before",
"not after",
]]
with open(service_csv, "rb") as fin:
for row in csv.DictReader(fin):
print row
dp_out_dir = os.path.join(
out_dir,
row["zone"],
row["environment"],
row["hostname"],
row["domain"],
)
if not os.path.exists(dp_out_dir):
os.makedirs(dp_out_dir)
appliance = datapower.DataPower(
row["hostname"],
credentials,
check_hostname=False,
)
#############################################################
# Get the domains config
filename = os.path.join(dp_out_dir, "domain-config.xml")
config = appliance.get_config(domain=row["domain"])
with open(filename, "wb") as fout:
fout.write(str(config))
#############################################################
# Get the files from service directory
command = " ".join([
"mast",
"contrib/fs-sync.py",
"from_dp",
"-a",
appliance.hostname,
"-c",
credentials,
"-n",
"-l local:///{}".format(row["name"].split("_")[-1] if
not appliance_dir else appliance_dir),
"-o",
os.path.join(dp_out_dir, "files"),
"-d",
row["domain"],
"-r",
"-i",
])
os.system(command)
#############################################################
# Get the files from local:/
command = " ".join([
"mast",
"contrib/fs-sync.py",
"from_dp",
"-a",
appliance.hostname,
"-c",
credentials,
"-n",
"-l local:///",
"-o",
os.path.join(dp_out_dir, "files"),
"-d",
row["domain"],
"-i",
])
os.system(command)
#############################################################
# Export the service
export = appliance.export(
domain=row["domain"],
obj=row["name"],
object_class=row["type"],
comment="{}-{}-{}-{}-{}-{}".format(
row["zone"],
row["environment"],
row["hostname"],
row["domain"],
row["type"],
row["name"],
),
format="XML",
persisted=False,
all_files=False,
referenced_files=False,
referenced_objects=True,
)
out_filename = os.path.join(dp_out_dir,
"{}.xcfg".format(row["name"]))
with open(out_filename, "wb") as fout:
fout.write(export)
#############################################################
# Get certificate details for all certificates
print("\n*** Getting certificate details")
tree = etree.parse(out_filename, parser)
# crypto_details += "{}{}".format(out_filename, os.linesep)
for cert_object in tree.xpath(
"//*[local-name() = 'CryptoCertificate' or local-name() = 'CryptoKey']"
):
_row = ['"{}"'.format(out_filename)]
name = cert_object.get("name")
_row.append('"{}"'.format(cert_object.tag))
_row.append('"{}"'.format(name))
# crypto_details += "{2}\t{0}: {1}{2}".format(cert_object.tag, name, os.linesep)
password = cert_object.find("Password")
password = "" if password is None else password.text
_row.append('"{}"'.format(password))
# crypto_details += "\t\tPASSWORD: {}{}".format(password, os.linesep)
password_alias = cert_object.find("Alias")
password_alias = "" if password_alias is None else password_alias.text
_row.append('"{}"'.format(password_alias))
# crypto_details += "\t\tPASSWORD_ALIAS: {}{}".format(password_alias, os.linesep)
remotefile = cert_object.find("Filename")
remotefile = "" if remotefile is None else remotefile.text
_row.append('"{}"'.format(remotefile))
# crypto_details += "\t\tFILENAME: {}{}".format(remotefile, os.linesep)
if cert_object.tag == "CryptoCertificate":
try:
details = etree.fromstring(
str(
get_cert_details(appliance, row["domain"],
cert_object.get("name"))))
except urllib2.HTTPError:
print("\tUnable to get details fpr {}".format(
cert_object.get("name")))
continue
subject = details.xpath(
"/*[local-name() = 'Envelope']"
"/*[local-name() = 'Body']"
"/*[local-name() = 'response']"
"/*[local-name() = 'view-certificate-details']"
"/CryptoCertificate"
"/CertificateDetails"
"/Subject")
subject = "" if not subject else subject[0].text
_row.append('"{}"'.format(subject))
# crypto_details += "\t\tSUBJECT: {}{}".format(subject, os.linesep)
issuer = details.xpath(
"/*[local-name() = 'Envelope']"
"/*[local-name() = 'Body']"
"/*[local-name() = 'response']"
"/*[local-name() = 'view-certificate-details']"
"/CryptoCertificate"
"/CertificateDetails"
"/Issuer")
issuer = "" if not issuer else issuer[0].text
_row.append('"{}"'.format(issuer))
# crypto_details += "\t\tISSUER: {}{}".format(issuer, os.linesep)
sans = details.xpath(
"/*[local-name() = 'Envelope']"
"/*[local-name() = 'Body']"
"/*[local-name() = 'response']"
"/*[local-name() = 'view-certificate-details']"
"/CryptoCertificate"
"/CertificateDetails"
"/Extensions"
"/Extension[@name='subjectAltName']"
"/item")
sans = [san.text for san in sans]
_row.append('"{}"'.format(" ".join(sans)))
# for san in sans:
# crypto_details += "\t\tSAN: {}{}".format(san, os.linesep)
notbefore = details.xpath(
"/*[local-name() = 'Envelope']"
"/*[local-name() = 'Body']"
"/*[local-name() = 'response']"
"/*[local-name() = 'view-certificate-details']"
"/CryptoCertificate"
"/CertificateDetails"
"/NotBefore")
notbefore = "" if not notbefore else notbefore[0].text
_row.append('"{}"'.format(notbefore))
# crypto_details += "\t\tNOT BEFORE: {}{}".format(notbefore, os.linesep)
notafter = details.xpath(
"/*[local-name() = 'Envelope']"
"/*[local-name() = 'Body']"
"/*[local-name() = 'response']"
"/*[local-name() = 'view-certificate-details']"
"/CryptoCertificate"
"/CertificateDetails"
"/NotAfter")
notafter = "" if not notafter else notafter[0].text
_row.append('"{}"'.format(notafter))
# crypto_details += "\t\tNOT AFTER: {}{}".format(notafter, os.linesep)
crypto_rows.append(_row)
with open(os.path.join(out_dir, "crypto-details.csv"), "wb") as fp:
for _row in crypto_rows:
fp.write("{}{}".format(",".join(_row), os.linesep))
with open(os.path.join(out_dir, "file-hashes.txt"), "wb") as fp:
sys.stdout = fp
#############################################################
# Diff xcfg files
print("{}*** Comparing Configuration".format(os.linesep))
diff_dir = os.path.join(out_dir, "diffs", "xcfg")
if not os.path.exists(diff_dir):
os.makedirs(diff_dir)
xcfgdiff(
xcfg_globs=[
os.path.join(out_dir, "*", "*", "*", "*", "*.xcfg")
],
out_dir=diff_dir,
wrapcolumn=wrapcolumn,
tabsize=tabsize,
no_only_differences=no_only_differences,
no_remove_namespaces=no_remove_namespaces,
)
#############################################################
# Diff xsl files
print("{}*** Comparing Stylesheets".format(os.linesep))
diff_dir = os.path.join(out_dir, "diffs", "xsl")
if not os.path.exists(diff_dir):
os.makedirs(diff_dir)
xsldiff(
xsl_globs=[
os.path.join(out_dir, "*", "*", "*", "*", "files", "*",
"local", "*", "*.xsl*")
],
out_dir=diff_dir,
wrapcolumn=wrapcolumn,
tabsize=tabsize,
no_only_differences=no_only_differences,
no_same_filenames=no_same_filenames,
)
print("{}*** Second Comparing Stylesheets".format(os.linesep))
diff_dir = os.path.join(out_dir, "diffs", "xsl")
if not os.path.exists(diff_dir):
os.makedirs(diff_dir)
xsldiff(
xsl_globs=[
os.path.join(out_dir, "*", "*", "*", "*", "files", "*",
"local", "*.xsl*")
],
out_dir=diff_dir,
wrapcolumn=wrapcolumn,
tabsize=tabsize,
no_only_differences=no_only_differences,
no_same_filenames=no_same_filenames,
)
#############################################################
# Diff xml files
print("\n*** Comparing XML documents")
diff_dir = os.path.join(out_dir, "diffs", "xml")
if not os.path.exists(diff_dir):
os.makedirs(diff_dir)
compare_files(
pattern=os.path.join(out_dir, "*", "*", "*", "*", "files", "*",
"local", "*", "*.xml"),
out_dir=diff_dir,
wrapcolumn=wrapcolumn,
tabsize=tabsize,
)
print("\n*** Comparing XML documents")
diff_dir = os.path.join(out_dir, "diffs", "xml")
if not os.path.exists(diff_dir):
os.makedirs(diff_dir)
compare_files(
pattern=os.path.join(out_dir, "*", "*", "*", "*", "files", "*",
"local", "*.xml"),
out_dir=diff_dir,
wrapcolumn=wrapcolumn,
tabsize=tabsize,
)
sys.stdout = sys.__stdout__
#############################################################
# Find all Load Balancer Groups
print("\n*** Finding all Load Balancer Groups")
lbg_out_file = os.path.join(out_dir, "LBGs.csv")
pattern = os.path.join(out_dir, "*", "*", "*", "*", "*.xcfg")
rows = []
rows.append("localfile, LBG{}".format(os.linesep))
for filename in glob(pattern):
lbg_dir = os.path.join(
os.path.dirname(filename),
"LBG",
)
if not os.path.exists(lbg_dir):
os.makedirs(lbg_dir)
print("{}:".format(filename))
tree = etree.parse(filename, parser)
for node in tree.xpath("//LoadBalancerGroup"):
name = node.get("name")
print("\t{}".format(name))
rows.append("{},{}{}".format(filename, name, os.linesep))
_filename = os.path.join(
lbg_dir,
"{}.xcfg".format(name),
)
with open(_filename, "wb") as fp:
fp.write(
XCFG_TEMPLATE.format(
etree.tostring(node, pretty_print=True)))
with open(lbg_out_file, "wb") as fp:
for row in rows:
fp.write("{}".format(row))
#############################################################
# Find unreferenced files
print("\n*** Looking for dynamically referenced objects")
find_dynamically_referenced_objects(
config_globs=[
os.path.join(out_dir, "*", "*", "*", "*", "*.xml"),
],
out_file=os.path.join(out_dir,
"dynamically_referenced_objects.txt"),
)
#############################################################
# Find cert:/// file references
cert_matches = defaultdict(list)
for dirname in glob(os.path.join(out_dir, "*", "*", "*", "*")):
for root, dirs, filenames in os.walk(dirname):
for filename in [os.path.join(root, f) for f in filenames]:
with open(filename, "r") as fp:
for line in fp:
if "cert:///" in line:
for match in re.findall(
'.*?(cert:///.*?)[<"]', line):
cert_matches[match].append(filename)
cert_file = os.path.join(out_dir, "referenced_cert_files.txt")
with open(cert_file, "wb") as fp:
for cert, filenames in cert_matches.items():
fp.write("{}{}".format(cert, os.linesep))
for filename in filenames:
fp.write("\t{}{}".format(filename, os.linesep))
