def reporter():
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(
os.path.join(path, "..", "approvals_reporters.json"))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
return factory.get_first_working()
def setUp(self):
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(os.path.join(path, '..', 'approvals_reporters.json'))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
self.reporter = factory.get_first_working()
self.results = []
def setUpClass(cls):
cls.code_examples = [
(),
("code1", ),
("code1", "code2"),
("JAVASCRIPT", "code1", "code2"),
("code1", "code2", "ARGUMENTS", "arg1", "arg2"),
("code1", "code2", "arguments", "arg1", "arg2"),
("javascript", "code1", "code2"),
("JAVASCRIPT", "code1", "code2", "ARGUMENTS"),
("JAVASCRIPT", "code1", "code2", "argUMENTs"),
("ARGUMENTS", "JAVASCRIPT", "code1", "code2"),
("JAVASCRIPT", "code1", "code2", "ARGUMENTS", "arg1", "arg2"),
("ARGUMENTS", "arg1", "arg2", "JAVASCRIPT", "code1", "code2"),
("aRGUMENTS", "arg1", "arg2", "jAVASCRIPT", "code1", "code2"),
("JAVASCRIPTCODE", "code1", "code2"),
("JAVASCRIPT", "code1", "code2", "ARGUMENTS ARG2", "arg3"),
]
cls.js = JavaScriptKeywords(None)
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(
os.path.join(path, os.pardir, "approvals_reporters.json"))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
cls.reporter = factory.get_first_working()
def setUpClass(cls):
cls.javascript = JavaScriptKeywords(None)
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(
os.path.join(path, '..', 'approvals_reporters.json'))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
cls.reporter = factory.get_first_working()
def reporter():
if JYTHON:
return None
else:
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(os.path.join(path, '..', 'approvals_reporters.json'))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
return factory.get_first_working()
def setUpClass(cls):
cls.log_dir = '/log/dir'
cls.creator = WebDriverCreator(cls.log_dir)
path = os.path.dirname(__file__)
if not JYTHON:
reporter_json = os.path.abspath(os.path.join(path, '..', 'approvals_reporters.json'))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
cls.reporter = factory.get_first_working()
def diff_reporter():
diff_reporter_factory = GenericDiffReporterFactory()
try:
with open(Path(__file__).parent / "reporters.json") as fin:
for config in json.load(fin):
diff_reporter_factory.add_default_reporter_config(config)
except FileNotFoundError:
pass
differ = diff_reporter_factory.get_first_working()
return partial(verify, reporter=differ)
def setUpClass(cls):
cls.log_dir = "/log/dir"
cls.creator = WebDriverCreator(cls.log_dir)
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(
os.path.join(path, "..", "approvals_reporters.json")
)
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
cls.reporter = factory.get_first_working()
def test_convert_github_markdown_for_input_to_pandoc_in_root_docdir(
self) -> None:
with open('test_markdown_conversion_input.md') as f:
input = f.read()
converted_markdown, converted_rst = markdown_conversion.convert_markdown_text_to_restructured_text(
input, '')
reporter = GenericDiffReporterFactory().get('AraxisMergeMac')
failure_count = 0
try:
namer = Namer('.md')
verify_with_namer(converted_markdown, namer, reporter)
except (ApprovalException):
failure_count += 1
try:
namer = Namer('.rst')
verify_with_namer(converted_rst, namer, reporter)
except (ApprovalException):
failure_count += 1
self.assertEqual(failure_count, 0)
def test_returns_none_when_files_are_same_files(self):
namer = Namer()
writer = StringWriter("b")
reporter = GenericDiffReporterFactory().get_first_working()
approver = FileApprover()
error = approver.verify(namer, writer, reporter)
self.assertEqual(None, error)
def setUpClass(cls):
cls.code_examples = [(),
('code1',), ('code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2'),
('code1', 'code2', 'ARGUMENTS', 'arg1', 'arg2'),
('code1', 'code2', 'arguments', 'arg1', 'arg2'),
('javascript', 'code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2', 'ARGUMENTS'),
('JAVASCRIPT', 'code1', 'code2', 'argUMENTs'),
('ARGUMENTS', 'JAVASCRIPT', 'code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2', 'ARGUMENTS', 'arg1', 'arg2'),
('ARGUMENTS', 'arg1', 'arg2', 'JAVASCRIPT', 'code1', 'code2'),
('aRGUMENTS', 'arg1', 'arg2', 'jAVASCRIPT', 'code1', 'code2'),
('JAVASCRIPTCODE', 'code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2', 'ARGUMENTS ARG2', 'arg3')]
cls.js = JavaScriptKeywords(None)
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(os.path.join(path, os.pardir, 'approvals_reporters.json'))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
cls.reporter = factory.get_first_working()
def setUpClass(cls):
cls.code_examples = [(),
('code1',), ('code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2'),
('code1', 'code2', 'ARGUMENTS', 'arg1', 'arg2'),
('code1', 'code2', 'arguments', 'arg1', 'arg2'),
('javascript', 'code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2', 'ARGUMENTS'),
('JAVASCRIPT', 'code1', 'code2', 'argUMENTs'),
('ARGUMENTS', 'JAVASCRIPT', 'code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2', 'ARGUMENTS', 'arg1', 'arg2'),
('ARGUMENTS', 'arg1', 'arg2', 'JAVASCRIPT', 'code1', 'code2'),
('aRGUMENTS', 'arg1', 'arg2', 'jAVASCRIPT', 'code1', 'code2'),
('JAVASCRIPTCODE', 'code1', 'code2'),
('JAVASCRIPT', 'code1', 'code2', 'ARGUMENTS ARG2', 'arg3')]
cls.js = JavaScriptKeywords(None)
path = os.path.dirname(__file__)
reporter_json = os.path.abspath(os.path.join(path, '..', 'approvals_reporters.json'))
factory = GenericDiffReporterFactory()
factory.load(reporter_json)
cls.reporter = factory.get_first_working()
class GenericDiffReporterTests(unittest.TestCase):
def setUp(self) -> None:
self.factory = GenericDiffReporterFactory()
if os.path.exists(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
os.mkdir(self.tmp_dir)
def tearDown(self) -> None:
shutil.rmtree(self.tmp_dir)
def test_list_configured_reporters(self) -> None:
verify(to_json(self.factory.list()))
def test_document_existing_reporters(self) -> None:
reporters = self.factory.list()
reporters.sort()
markdown = ""
for reporter in reporters:
markdown += f"* { reporter}\n"
verify(markdown,options=Options().for_file.with_extension(".md"))
def test_get_reporter(self) -> None:
verify(str(self.factory.get("BeyondCompare4")))
def test_get_winmerge(self) -> None:
self.assert_for_reporter("WinMerge")
def test_get_araxis(self) -> None:
self.assert_for_reporter("AraxisMergeWin")
def assert_for_reporter(self, reporter):
the_reporter = self.factory.get(reporter)
verify(
str(the_reporter), MultiReporter(ReportWithBeyondCompare(), the_reporter)
)
def test_get_araxis_mac(self) -> None:
self.assert_for_reporter("AraxisMergeMac")
def test_get_beyondcompare4_mac(self) -> None:
self.assert_for_reporter("BeyondCompare4Mac")
def test_constructs_valid_diff_command(self) -> None:
reporter = cast(GenericDiffReporter, self.factory.get("BeyondCompare4"))
namer = get_default_namer()
received = namer.get_received_filename()
approved = namer.get_approved_filename()
command = reporter.get_command(received, approved)
expected_command = [reporter.path, received, approved]
self.assertEqual(command, expected_command)
def test_empty_approved_file_created_when_one_does_not_exist(self) -> None:
namer = get_default_namer()
received = namer.get_received_filename()
approved = namer.get_approved_filename()
if os.path.isfile(approved):
os.remove(approved)
self.assertFalse(os.path.isfile(approved))
reporter = self.factory.get("BeyondCompare4")
setattr(reporter, "run_command", lambda command_array: None)
setattr(reporter, "is_working", lambda: True)
reporter.report(received, approved)
self.assertEqual(0, os.stat(approved).st_size)
def test_approved_file_not_changed_when_one_exists_already(self) -> None:
namer = get_default_namer()
approved = namer.get_approved_filename()
os.remove(approved)
approved_contents = "Approved"
with open(approved, "w") as approved_file:
approved_file.write(approved_contents)
reporter = self.factory.get("BeyondCompare4")
setattr(reporter, "run_command", lambda command_array: None)
reporter.report(namer.get_received_filename(), approved)
with open(approved, "r") as approved_file:
actual_contents = approved_file.read()
self.assertEqual(actual_contents, approved_contents)
def test_serialization(self) -> None:
n = get_default_namer()
saved_reporters_file = os.path.join(n.get_directory(), "saved-reporters.json")
self.factory.save(saved_reporters_file)
try:
with open(saved_reporters_file, "r") as f:
file_contents = f.read()
# remove the absolute path to the python_native_reporter.py file since it is different on every machine
regex = re.compile(r'.*"([^"]*)python_native_reporter.py')
match = regex.findall(file_contents)
if match:
file_contents = file_contents.replace(match[0], "")
file_contents = file_contents.replace("python.exe", "python")
verify(file_contents)
finally:
os.remove(saved_reporters_file)
def test_deserialization(self) -> None:
namer = get_default_namer()
full_name = os.path.join(namer.get_directory(), "custom-reporters.json")
reporters = self.factory.load(full_name)
verify(to_json(reporters))
def test_notworking_in_environment(self) -> None:
reporter = GenericDiffReporter(create_config(["Custom", "NotReal"]))
self.assertFalse(reporter.is_working())
def test_find_working_reporter(self) -> None:
r = self.factory.get_first_working()
if r:
self.assertTrue(r.is_working())
def test_remove_reporter(self) -> None:
self.factory.remove("meld")
verify(to_json(self.factory.list()))
@staticmethod
def instantiate_reporter_for_test() -> GenericDiffReporter:
program = r"C:\Windows\System32\help.exe" if is_windows_os() else "echo"
reporter = GenericDiffReporter.create(program)
setattr(reporter, "run_command", lambda command_array: None)
return reporter
@property
def tmp_dir(self) -> str:
test_dir = os.path.dirname(os.path.realpath(__file__))
return os.path.join(test_dir, "tmp")
@property
def received_file_path(self) -> str:
return os.path.join(self.tmp_dir, "received_file.txt")
@property
def approved_file_path(self) -> str:
return os.path.join(self.tmp_dir, "approved_file.txt")
def test_empty_approved_file_created_when_one_does_not_exist_2(self) -> None:
self.assertFileDoesNotExist(self.approved_file_path)
reporter = self.instantiate_reporter_for_test()
reporter.report(self.received_file_path, self.approved_file_path)
self.assertFileIsEmpty(self.approved_file_path)
def assertFileDoesNotExist(self, file_path: str) -> None:
file_exists = os.path.isfile(file_path)
if file_exists:
msg = "File {} exists when it shouldn't".format(file_path)
self.fail(msg)
def assertFileIsEmpty(self, file_path: str) -> None:
file_size = os.stat(file_path).st_size
if file_size != 0:
msg = f"File is not empty: {file_path}"
self.fail(msg)
def test_get_pycharm_reporter(self) -> None:
verify(str(self.factory.get("PyCharm")))
def test_non_working_reporter_does_not_report(self) -> None:
self.assertFileDoesNotExist(self.approved_file_path)
reporter = GenericDiffReporter(create_config(["Custom", "NotReal"]))
success = reporter.report(self.received_file_path, self.approved_file_path)
self.assertFalse(success)
def _test_string_representation(self) -> None:
reporter = GenericDiffReporter(create_config(["Custom", "NotReal"]))
expected = "GenericDiffReporter(...)"
self.assertEqual(expected, str(reporter))
def setUp(self) -> None:
self.factory = GenericDiffReporterFactory()
if os.path.exists(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
os.mkdir(self.tmp_dir)
def setUp(self):
self.reporter = GenericDiffReporterFactory().get('BeyondCompare4Mac')
def __init__(self):
factory = GenericDiffReporterFactory()
reporters = list(factory.get_all_reporters())
reporters.append(CommandLineReporter())
super(DiffReporter, self).__init__(*reporters)
def __init__(self, reporter_factory=None):
factory = reporter_factory or GenericDiffReporterFactory()
reporters = list(factory.get_all_reporters())
reporters.append(IntroductionReporter())
super(__class__, self).__init__(*reporters)
def __init__(self, reporter_factory=None):
factory = reporter_factory or GenericDiffReporterFactory()
reporters = list(factory.get_all_reporters())
reporters.append(PythonNativeReporter())
super(DiffReporter, self).__init__(*reporters)
def setUp(self):
self.reporter = GenericDiffReporterFactory().get("DiffMerge")
def setUp(self):
self.reporter = GenericDiffReporterFactory().get_first_working()
def setUp(self):
factory = GenericDiffReporterFactory()
import os
print(os.getcwd())
factory.load('tst/reporters.json')
self.reporter = factory.get_first_working()
def diff_reporter():
diff_reporter_factory = GenericDiffReporterFactory()
diff_reporter_factory.load(
os.path.join(flowkit_toplevel_dir,
"approvaltests_diff_reporters.json"))
return diff_reporter_factory.get_first_working()
class GenericDiffReporterTests(unittest.TestCase):
def setUp(self):
self.factory = GenericDiffReporterFactory()
self.reporter = self.factory.get_first_working()
if os.path.exists(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
os.mkdir(self.tmp_dir)
def tearDown(self):
shutil.rmtree(self.tmp_dir)
def test_list_configured_reporters(self):
verify(to_json(self.factory.list()), self.reporter)
def test_get_reporter(self):
verify(str(self.factory.get("BeyondCompare4")), self.reporter)
def test_get_winmerge(self):
verify(str(self.factory.get("WinMerge")), self.factory.get("WinMerge"))
def test_get_araxis(self):
verify(str(self.factory.get("AraxisMergeWin")),
self.factory.get("AraxisMergeWin"))
def test_get_araxis_mac(self):
verify(str(self.factory.get("AraxisMergeMac")),
self.factory.get("AraxisMergeMac"))
def test_get_beyondcompare4_mac(self):
verify(str(self.factory.get("BeyondCompare4Mac")),
self.factory.get("BeyondCompare4Mac"))
def test_constructs_valid_diff_command(self):
reporter = self.factory.get("BeyondCompare4")
namer = Namer()
received = namer.get_received_filename()
approved = namer.get_approved_filename()
command = reporter.get_command(received, approved)
expected_command = [reporter.path, received, approved]
self.assertEqual(command, expected_command)
def test_empty_approved_file_created_when_one_does_not_exist(self):
namer = Namer()
received = namer.get_received_filename()
approved = namer.get_approved_filename()
if os.path.isfile(approved):
os.remove(approved)
self.assertFalse(os.path.isfile(approved))
reporter = self.factory.get("BeyondCompare4")
reporter.run_command = lambda command_array: None
reporter.report(received, approved)
self.assertEqual(0, os.stat(approved).st_size)
def test_approved_file_not_changed_when_one_exists_already(self):
namer = Namer()
approved_contents = "Approved"
approved = namer.get_approved_filename()
os.remove(approved)
with open(approved, 'w') as approved_file:
approved_file.write(approved_contents)
reporter = self.factory.get("BeyondCompare4")
reporter.run_command = lambda command_array: None
reporter.report(namer.get_received_filename(), approved)
with open(approved, 'r') as approved_file:
actual_contents = approved_file.read()
self.assertEqual(actual_contents, approved_contents)
def test_serialization(self):
n = Namer()
saved_reporters_file = os.path.join(n.get_directory(),
'saved-reporters.json')
self.factory.save(saved_reporters_file)
try:
with open(saved_reporters_file, 'r') as f:
file_contents = f.read()
# remove the absolute path to the python_native_reporter.py file since it is different on every machine
regex = re.compile(r'.*"([^"]*)python_native_reporter.py')
match = regex.findall(file_contents)
if match:
file_contents = file_contents.replace(match[0], "")
verify(file_contents, self.reporter)
finally:
os.remove(saved_reporters_file)
def test_deserialization(self):
namer = Namer()
full_name = os.path.join(namer.get_directory(),
'custom-reporters.json')
reporters = self.factory.load(full_name)
verify(to_json(reporters), self.reporter)
def test_notworking_in_environment(self):
reporter = GenericDiffReporter(('Custom', 'NotReal'))
self.assertFalse(reporter.is_working())
def test_find_working_reporter(self):
r = self.factory.get_first_working()
self.assertIsNotNone(r)
def test_remove_reporter(self):
self.factory.remove("meld")
verify(to_json(self.factory.list()), self.reporter)
@staticmethod
def instantiate_reporter_for_test():
reporter = GenericDiffReporter.create('echo')
reporter.run_command = lambda command_array: None
return reporter
@property
def tmp_dir(self):
test_dir = os.path.dirname(os.path.realpath(__file__))
return os.path.join(test_dir, 'tmp')
@property
def received_file_path(self):
return os.path.join(self.tmp_dir, 'received_file.txt')
@property
def approved_file_path(self):
return os.path.join(self.tmp_dir, 'approved_file.txt')
def test_empty_approved_file_created_when_one_does_not_exist(self):
self.assertFileDoesNotExist(self.approved_file_path)
reporter = self.instantiate_reporter_for_test()
reporter.report(self.received_file_path, self.approved_file_path)
self.assertFileIsEmpty(self.approved_file_path)
def test_approved_file_not_changed_when_one_exists_already(self):
approved_contents = "Approved"
with open(self.approved_file_path, 'w') as approved_file:
approved_file.write(approved_contents)
reporter = self.instantiate_reporter_for_test()
reporter.report(self.received_file_path, self.approved_file_path)
with open(self.approved_file_path, 'r') as approved_file:
actual_contents = approved_file.read()
self.assertEqual(actual_contents, approved_contents)
def assertFileDoesNotExist(self, file_path):
file_exists = os.path.isfile(file_path)
if file_exists:
msg = "File {} exists when it shouldn't".format(file_path)
self.fail(msg)
def assertFileIsEmpty(self, file_path):
file_size = os.stat(file_path).st_size
if file_size != 0:
msg = "File is not empty: {}" % file_path
self.fail(msg)
def test_get_pycharm_reporter(self):
verify(str(self.factory.get("PyCharm")), reporter=self.reporter)
def test_non_working_reporter_does_not_report(self):
self.assertFileDoesNotExist(self.approved_file_path)
reporter = GenericDiffReporter(('Custom', 'NotReal'))
success = reporter.report(self.received_file_path,
self.approved_file_path)
self.assertFalse(success)
def diff_reporter():
diff_reporter_factory = GenericDiffReporterFactory()
return diff_reporter_factory.get("opendiff")
def setUp(self):
self.factory = GenericDiffReporterFactory()
self.reporter = self.factory.get_first_working()
if os.path.exists(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
os.mkdir(self.tmp_dir)