arsenetar/dupeguru
1
0
Fork 0
mirror of https://github.com/arsenetar/dupeguru.git synced 2025-05-11 11:19:48 +00:00
Code Releases Wiki Activity

Misc cleanups in core/tests

Browse Source
This commit is contained in:
Andrew Senetar 2021-08-21 03:52:09 -05:00
parent b4fa1d68f0
commit 0189c29f47
Signed by: arsenetar
GPG Key ID: C63300DCE48AB2F1
9 changed files with 119 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
core/tests/app_test.py
View File

@ -23,7 +23,7 @@ from ..scanner import ScanType
def add_fake_files_to_directories(directories, files): def add_fake_files_to_directories(directories, files):
directories.get_files = lambda j=None: iter(files) directories.get_files = lambda j=None: iter(files)
directories._dirs.append("this is just so Scan() doesnt return 3") directories._dirs.append("this is just so Scan() doesn't return 3")
class TestCaseDupeGuru: class TestCaseDupeGuru:
@ -43,7 +43,7 @@ class TestCaseDupeGuru:
dgapp.apply_filter("()[]\\.|+?^abc") dgapp.apply_filter("()[]\\.|+?^abc")
call = dgapp.results.apply_filter.calls[1] call = dgapp.results.apply_filter.calls[1]
eq_("\\(\\)\\[\\]\\\\\\.\\|\\+\\?\\^abc", call["filter_str"]) eq_("\\(\\)\\[\\]\\\\\\.\\|\\+\\?\\^abc", call["filter_str"])
dgapp.apply_filter("(*)") # In "simple mode", we want the * to behave as a wilcard dgapp.apply_filter("(*)") # In "simple mode", we want the * to behave as a wildcard
call = dgapp.results.apply_filter.calls[3] call = dgapp.results.apply_filter.calls[3]
eq_(r"\(.*\)", call["filter_str"]) eq_(r"\(.*\)", call["filter_str"])
dgapp.options["escape_filter_regexp"] = False dgapp.options["escape_filter_regexp"] = False
@ -88,14 +88,14 @@ class TestCaseDupeGuru:
eq_(1, len(calls)) eq_(1, len(calls))
eq_(sourcepath, calls[0]["path"]) eq_(sourcepath, calls[0]["path"])
def test_Scan_with_objects_evaluating_to_false(self): def test_scan_with_objects_evaluating_to_false(self):
class FakeFile(fs.File): class FakeFile(fs.File):
def __bool__(self): def __bool__(self):
return False return False
# At some point, any() was used in a wrong way that made Scan() wrongly return 1 # At some point, any() was used in a wrong way that made Scan() wrongly return 1
app = TestApp().app app = TestApp().app
f1, f2 = [FakeFile("foo") for i in range(2)] f1, f2 = [FakeFile("foo") for _ in range(2)]
f1.is_ref, f2.is_ref = (False, False) f1.is_ref, f2.is_ref = (False, False)
assert not (bool(f1) and bool(f2)) assert not (bool(f1) and bool(f2))
add_fake_files_to_directories(app.directories, [f1, f2]) add_fake_files_to_directories(app.directories, [f1, f2])
@ -124,7 +124,7 @@ class TestCaseDupeGuru:
assert not dgapp.result_table.rename_selected("foo") # no crash assert not dgapp.result_table.rename_selected("foo") # no crash
class TestCaseDupeGuru_clean_empty_dirs: class TestCaseDupeGuruCleanEmptyDirs:
@pytest.fixture @pytest.fixture
def do_setup(self, request): def do_setup(self, request):
monkeypatch = request.getfixturevalue("monkeypatch") monkeypatch = request.getfixturevalue("monkeypatch")
@ -184,7 +184,7 @@ class TestCaseDupeGuruWithResults:
tmppath["bar"].mkdir() tmppath["bar"].mkdir()
self.app.directories.add_path(tmppath) self.app.directories.add_path(tmppath)
def test_GetObjects(self, do_setup): def test_get_objects(self, do_setup):
objects = self.objects objects = self.objects
groups = self.groups groups = self.groups
r = self.rtable[0] r = self.rtable[0]
@ -197,7 +197,7 @@ class TestCaseDupeGuruWithResults:
assert r._group is groups[1] assert r._group is groups[1]
assert r._dupe is objects[4] assert r._dupe is objects[4]
def test_GetObjects_after_sort(self, do_setup): def test_get_objects_after_sort(self, do_setup):
objects = self.objects objects = self.objects
groups = self.groups[:] # we need an un-sorted reference groups = self.groups[:] # we need an un-sorted reference
self.rtable.sort("name", False) self.rtable.sort("name", False)
@ -212,7 +212,7 @@ class TestCaseDupeGuruWithResults:
# The first 2 dupes have been removed. The 3rd one is a ref. it stays there, in first pos. # The first 2 dupes have been removed. The 3rd one is a ref. it stays there, in first pos.
eq_(self.rtable.selected_indexes, [1]) # no exception eq_(self.rtable.selected_indexes, [1]) # no exception
def test_selectResultNodePaths(self, do_setup): def test_select_result_node_paths(self, do_setup):
app = self.app app = self.app
objects = self.objects objects = self.objects
self.rtable.select([1, 2]) self.rtable.select([1, 2])
@ -220,7 +220,7 @@ class TestCaseDupeGuruWithResults:
assert app.selected_dupes[0] is objects[1] assert app.selected_dupes[0] is objects[1]
assert app.selected_dupes[1] is objects[2] assert app.selected_dupes[1] is objects[2]
def test_selectResultNodePaths_with_ref(self, do_setup): def test_select_result_node_paths_with_ref(self, do_setup):
app = self.app app = self.app
objects = self.objects objects = self.objects
self.rtable.select([1, 2, 3]) self.rtable.select([1, 2, 3])
@ -229,7 +229,7 @@ class TestCaseDupeGuruWithResults:
assert app.selected_dupes[1] is objects[2] assert app.selected_dupes[1] is objects[2]
assert app.selected_dupes[2] is self.groups[1].ref assert app.selected_dupes[2] is self.groups[1].ref
def test_selectResultNodePaths_after_sort(self, do_setup): def test_select_result_node_paths_after_sort(self, do_setup):
app = self.app app = self.app
objects = self.objects objects = self.objects
groups = self.groups[:] # To keep the old order in memory groups = self.groups[:] # To keep the old order in memory
@ -256,7 +256,7 @@ class TestCaseDupeGuruWithResults:
app.remove_selected() app.remove_selected()
eq_(self.rtable.selected_indexes, []) # no exception eq_(self.rtable.selected_indexes, []) # no exception
def test_selectPowerMarkerRows_after_sort(self, do_setup): def test_select_powermarker_rows_after_sort(self, do_setup):
app = self.app app = self.app
objects = self.objects objects = self.objects
self.rtable.power_marker = True self.rtable.power_marker = True
@ -295,7 +295,7 @@ class TestCaseDupeGuruWithResults:
app.toggle_selected_mark_state() app.toggle_selected_mark_state()
eq_(app.results.mark_count, 0) eq_(app.results.mark_count, 0)
def test_refreshDetailsWithSelected(self, do_setup): def test_refresh_details_with_selected(self, do_setup):
self.rtable.select([1, 4]) self.rtable.select([1, 4])
eq_(self.dpanel.row(0), ("Filename", "bar bleh", "foo bar")) eq_(self.dpanel.row(0), ("Filename", "bar bleh", "foo bar"))
self.dpanel.view.check_gui_calls(["refresh"]) self.dpanel.view.check_gui_calls(["refresh"])
@ -303,7 +303,7 @@ class TestCaseDupeGuruWithResults:
eq_(self.dpanel.row(0), ("Filename", "---", "---")) eq_(self.dpanel.row(0), ("Filename", "---", "---"))
self.dpanel.view.check_gui_calls(["refresh"]) self.dpanel.view.check_gui_calls(["refresh"])
def test_makeSelectedReference(self, do_setup): def test_make_selected_reference(self, do_setup):
app = self.app app = self.app
objects = self.objects objects = self.objects
groups = self.groups groups = self.groups
@ -312,7 +312,7 @@ class TestCaseDupeGuruWithResults:
assert groups[0].ref is objects[1] assert groups[0].ref is objects[1]
assert groups[1].ref is objects[4] assert groups[1].ref is objects[4]
def test_makeSelectedReference_by_selecting_two_dupes_in_the_same_group(self, do_setup): def test_make_selected_reference_by_selecting_two_dupes_in_the_same_group(self, do_setup):
app = self.app app = self.app
objects = self.objects objects = self.objects
groups = self.groups groups = self.groups
@ -322,7 +322,7 @@ class TestCaseDupeGuruWithResults:
assert groups[0].ref is objects[1] assert groups[0].ref is objects[1]
assert groups[1].ref is objects[4] assert groups[1].ref is objects[4]
def test_removeSelected(self, do_setup): def test_remove_selected(self, do_setup):
app = self.app app = self.app
self.rtable.select([1, 4]) self.rtable.select([1, 4])
app.remove_selected() app.remove_selected()
@ -330,7 +330,7 @@ class TestCaseDupeGuruWithResults:
app.remove_selected() app.remove_selected()
eq_(len(app.results.dupes), 0) eq_(len(app.results.dupes), 0)
def test_addDirectory_simple(self, do_setup): def test_add_directory_simple(self, do_setup):
# There's already a directory in self.app, so adding another once makes 2 of em # There's already a directory in self.app, so adding another once makes 2 of em
app = self.app app = self.app
# any other path that isn't a parent or child of the already added path # any other path that isn't a parent or child of the already added path
@ -338,7 +338,7 @@ class TestCaseDupeGuruWithResults:
app.add_directory(otherpath) app.add_directory(otherpath)
eq_(len(app.directories), 2) eq_(len(app.directories), 2)
def test_addDirectory_already_there(self, do_setup): def test_add_directory_already_there(self, do_setup):
app = self.app app = self.app
otherpath = Path(op.dirname(__file__)) otherpath = Path(op.dirname(__file__))
app.add_directory(otherpath) app.add_directory(otherpath)
@ -346,7 +346,7 @@ class TestCaseDupeGuruWithResults:
eq_(len(app.view.messages), 1) eq_(len(app.view.messages), 1)
assert "already" in app.view.messages[0] assert "already" in app.view.messages[0]
def test_addDirectory_does_not_exist(self, do_setup): def test_add_directory_does_not_exist(self, do_setup):
app = self.app app = self.app
app.add_directory("/does_not_exist") app.add_directory("/does_not_exist")
eq_(len(app.view.messages), 1) eq_(len(app.view.messages), 1)
@ -362,7 +362,7 @@ class TestCaseDupeGuruWithResults:
# BOTH the ref and the other dupe should have been added # BOTH the ref and the other dupe should have been added
eq_(len(app.ignore_list), 3) eq_(len(app.ignore_list), 3)
def test_purgeIgnoreList(self, do_setup, tmpdir): def test_purge_ignorelist(self, do_setup, tmpdir):
app = self.app app = self.app
p1 = str(tmpdir.join("file1")) p1 = str(tmpdir.join("file1"))
p2 = str(tmpdir.join("file2")) p2 = str(tmpdir.join("file2"))
@ -378,14 +378,14 @@ class TestCaseDupeGuruWithResults:
assert not app.ignore_list.AreIgnored(dne, p1) assert not app.ignore_list.AreIgnored(dne, p1)
def test_only_unicode_is_added_to_ignore_list(self, do_setup): def test_only_unicode_is_added_to_ignore_list(self, do_setup):
def FakeIgnore(first, second): def fake_ignore(first, second):
if not isinstance(first, str): if not isinstance(first, str):
self.fail() self.fail()
if not isinstance(second, str): if not isinstance(second, str):
self.fail() self.fail()
app = self.app app = self.app
app.ignore_list.Ignore = FakeIgnore app.ignore_list.Ignore = fake_ignore
self.rtable.select([4]) self.rtable.select([4])
app.add_selected_to_ignore_list() app.add_selected_to_ignore_list()
@ -419,7 +419,7 @@ class TestCaseDupeGuruWithResults:
# don't crash # don't crash
class TestCaseDupeGuru_renameSelected: class TestCaseDupeGuruRenameSelected:
@pytest.fixture @pytest.fixture
def do_setup(self, request): def do_setup(self, request):
tmpdir = request.getfixturevalue("tmpdir") tmpdir = request.getfixturevalue("tmpdir")
@ -502,7 +502,6 @@ class TestAppWithDirectoriesInTree:
# refreshed. # refreshed.
node = self.dtree[0] node = self.dtree[0]
eq_(len(node), 3) # a len() call is required for subnodes to be loaded eq_(len(node), 3) # a len() call is required for subnodes to be loaded
subnode = node[0]
node.state = 1 # the state property is a state index node.state = 1 # the state property is a state index
node = self.dtree[0] node = self.dtree[0]
eq_(len(node), 3) eq_(len(node), 3)

135
core/tests/block_test.py
View File

@ -73,99 +73,6 @@ class TestCasegetblock:
eq_((meanred, meangreen, meanblue), b) eq_((meanred, meangreen, meanblue), b)
# class TCdiff(unittest.TestCase):
# def test_diff(self):
# b1 = (10, 20, 30)
# b2 = (1, 2, 3)
# eq_(9 + 18 + 27, diff(b1, b2))
#
# def test_diff_negative(self):
# b1 = (10, 20, 30)
# b2 = (1, 2, 3)
# eq_(9 + 18 + 27, diff(b2, b1))
#
# def test_diff_mixed_positive_and_negative(self):
# b1 = (1, 5, 10)
# b2 = (10, 1, 15)
# eq_(9 + 4 + 5, diff(b1, b2))
#
# class TCgetblocks(unittest.TestCase):
# def test_empty_image(self):
# im = empty()
# blocks = getblocks(im, 1)
# eq_(0, len(blocks))
#
# def test_one_block_image(self):
# im = four_pixels()
# blocks = getblocks2(im, 1)
# eq_(1, len(blocks))
# block = blocks[0]
# meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4
# eq_((meanred, meangreen, meanblue), block)
#
# def test_not_enough_height_to_fit_a_block(self):
# im = FakeImage((2, 1), [BLACK, BLACK])
# blocks = getblocks(im, 2)
# eq_(0, len(blocks))
#
# def xtest_dont_include_leftovers(self):
# # this test is disabled because getblocks is not used and getblock in cdeffed
# pixels = [
# RED,(0, 0x80, 0xff), BLACK,
# (0x80, 0, 0),(0, 0x40, 0x80), BLACK,
# BLACK, BLACK, BLACK
# ]
# im = FakeImage((3, 3), pixels)
# blocks = getblocks(im, 2)
# block = blocks[0]
# #Because the block is smaller than the image, only blocksize must be considered.
# meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4
# eq_((meanred, meangreen, meanblue), block)
#
# def xtest_two_blocks(self):
# # this test is disabled because getblocks is not used and getblock in cdeffed
# pixels = [BLACK for i in xrange(4 * 2)]
# pixels[0] = RED
# pixels[1] = (0, 0x80, 0xff)
# pixels[4] = (0x80, 0, 0)
# pixels[5] = (0, 0x40, 0x80)
# im = FakeImage((4, 2), pixels)
# blocks = getblocks(im, 2)
# eq_(2, len(blocks))
# block = blocks[0]
# #Because the block is smaller than the image, only blocksize must be considered.
# meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4
# eq_((meanred, meangreen, meanblue), block)
# eq_(BLACK, blocks[1])
#
# def test_four_blocks(self):
# pixels = [BLACK for i in xrange(4 * 4)]
# pixels[0] = RED
# pixels[1] = (0, 0x80, 0xff)
# pixels[4] = (0x80, 0, 0)
# pixels[5] = (0, 0x40, 0x80)
# im = FakeImage((4, 4), pixels)
# blocks = getblocks2(im, 2)
# eq_(4, len(blocks))
# block = blocks[0]
# #Because the block is smaller than the image, only blocksize must be considered.
# meanred = (0xff + 0x80) // 4
# meangreen = (0x80 + 0x40) // 4
# meanblue = (0xff + 0x80) // 4
# eq_((meanred, meangreen, meanblue), block)
# eq_(BLACK, blocks[1])
# eq_(BLACK, blocks[2])
# eq_(BLACK, blocks[3])
#
class TestCasegetblocks2: class TestCasegetblocks2:
def test_empty_image(self): def test_empty_image(self):
im = empty() im = empty()
@ -270,8 +177,8 @@ class TestCaseavgdiff:
def test_return_at_least_1_at_the_slightest_difference(self): def test_return_at_least_1_at_the_slightest_difference(self):
ref = (0, 0, 0) ref = (0, 0, 0)
b1 = (1, 0, 0) b1 = (1, 0, 0)
blocks1 = [ref for i in range(250)] blocks1 = [ref for _ in range(250)]
blocks2 = [ref for i in range(250)] blocks2 = [ref for _ in range(250)]
blocks2[0] = b1 blocks2[0] = b1
eq_(1, my_avgdiff(blocks1, blocks2)) eq_(1, my_avgdiff(blocks1, blocks2))
@ -280,41 +187,3 @@ class TestCaseavgdiff:
blocks1 = [ref, ref] blocks1 = [ref, ref]
blocks2 = [ref, ref] blocks2 = [ref, ref]
eq_(0, my_avgdiff(blocks1, blocks2)) eq_(0, my_avgdiff(blocks1, blocks2))
# class TCmaxdiff(unittest.TestCase):
# def test_empty(self):
# self.assertRaises(NoBlocksError, maxdiff,[],[])
#
# def test_two_blocks(self):
# b1 = (5, 10, 15)
# b2 = (255, 250, 245)
# b3 = (0, 0, 0)
# b4 = (255, 0, 255)
# blocks1 = [b1, b2]
# blocks2 = [b3, b4]
# expected1 = 5 + 10 + 15
# expected2 = 0 + 250 + 10
# expected = max(expected1, expected2)
# eq_(expected, maxdiff(blocks1, blocks2))
#
# def test_blocks_not_the_same_size(self):
# b = (0, 0, 0)
# self.assertRaises(DifferentBlockCountError, maxdiff,[b, b],[b])
#
# def test_first_arg_is_empty_but_not_second(self):
# #Don't return 0 (as when the 2 lists are empty), raise!
# b = (0, 0, 0)
# self.assertRaises(DifferentBlockCountError, maxdiff,[],[b])
#
# def test_limit(self):
# b1 = (5, 10, 15)
# b2 = (255, 250, 245)
# b3 = (0, 0, 0)
# b4 = (255, 0, 255)
# blocks1 = [b1, b2]
# blocks2 = [b3, b4]
# expected1 = 5 + 10 + 15
# expected2 = 0 + 250 + 10
# eq_(expected1, maxdiff(blocks1, blocks2, expected1 - 1))
#

4
core/tests/cache_test.py
View File

@ -17,7 +17,7 @@ except ImportError:
skip("Can't import the cache module, probably hasn't been compiled.") skip("Can't import the cache module, probably hasn't been compiled.")
class TestCasecolors_to_string: class TestCaseColorsToString:
def test_no_color(self): def test_no_color(self):
eq_("", colors_to_string([])) eq_("", colors_to_string([]))
@ -30,7 +30,7 @@ class TestCasecolors_to_string:
eq_("000102030405", colors_to_string([(0, 1, 2), (3, 4, 5)])) eq_("000102030405", colors_to_string([(0, 1, 2), (3, 4, 5)]))
class TestCasestring_to_colors: class TestCaseStringToColors:
def test_empty(self): def test_empty(self):
eq_([], string_to_colors("")) eq_([], string_to_colors(""))

6
core/tests/directories_test.py
View File

@ -92,7 +92,7 @@ def test_add_path():
assert p in d assert p in d
def test_AddPath_when_path_is_already_there(): def test_add_path_when_path_is_already_there():
d = Directories() d = Directories()
p = testpath["onefile"] p = testpath["onefile"]
d.add_path(p) d.add_path(p)
@ -112,7 +112,7 @@ def test_add_path_containing_paths_already_there():
eq_(d[0], testpath) eq_(d[0], testpath)
def test_AddPath_non_latin(tmpdir): def test_add_path_non_latin(tmpdir):
p = Path(str(tmpdir)) p = Path(str(tmpdir))
to_add = p["unicode\u201a"] to_add = p["unicode\u201a"]
os.mkdir(str(to_add)) os.mkdir(str(to_add))
@ -376,7 +376,7 @@ files: {self.d._exclude_list.compiled_files} all: {self.d._exclude_list.compiled
p1["$Recycle.Bin"]["subdir"].mkdir() p1["$Recycle.Bin"]["subdir"].mkdir()
self.d.add_path(p1) self.d.add_path(p1)
eq_(self.d.get_state(p1["$Recycle.Bin"]), DirectoryState.Excluded) eq_(self.d.get_state(p1["$Recycle.Bin"]), DirectoryState.Excluded)
# By default, subdirs should be excluded too, but this can be overriden separately # By default, subdirs should be excluded too, but this can be overridden separately
eq_(self.d.get_state(p1["$Recycle.Bin"]["subdir"]), DirectoryState.Excluded) eq_(self.d.get_state(p1["$Recycle.Bin"]["subdir"]), DirectoryState.Excluded)
self.d.set_state(p1["$Recycle.Bin"]["subdir"], DirectoryState.Normal) self.d.set_state(p1["$Recycle.Bin"]["subdir"], DirectoryState.Normal)
eq_(self.d.get_state(p1["$Recycle.Bin"]["subdir"]), DirectoryState.Normal) eq_(self.d.get_state(p1["$Recycle.Bin"]["subdir"]), DirectoryState.Normal)

153
core/tests/engine_test.py
View File

@ -103,10 +103,9 @@ class TestCasegetfields:
expected = [["a", "bc", "def"]] expected = [["a", "bc", "def"]]
actual = getfields(" - a bc def") actual = getfields(" - a bc def")
eq_(expected, actual) eq_(expected, actual)
expected = [["bc", "def"]]
class TestCaseunpack_fields: class TestCaseUnpackFields:
def test_with_fields(self): def test_with_fields(self):
expected = ["a", "b", "c", "d", "e", "f"] expected = ["a", "b", "c", "d", "e", "f"]
actual = unpack_fields([["a"], ["b", "c"], ["d", "e", "f"]]) actual = unpack_fields([["a"], ["b", "c"], ["d", "e", "f"]])
@ -218,24 +217,24 @@ class TestCaseWordCompareWithFields:
eq_([["c", "d", "f"], ["a", "b"]], second) eq_([["c", "d", "f"], ["a", "b"]], second)
class TestCasebuild_word_dict: class TestCaseBuildWordDict:
def test_with_standard_words(self): def test_with_standard_words(self):
itemList = [NamedObject("foo bar", True)] item_list = [NamedObject("foo bar", True)]
itemList.append(NamedObject("bar baz", True)) item_list.append(NamedObject("bar baz", True))
itemList.append(NamedObject("baz bleh foo", True)) item_list.append(NamedObject("baz bleh foo", True))
d = build_word_dict(itemList) d = build_word_dict(item_list)
eq_(4, len(d)) eq_(4, len(d))
eq_(2, len(d["foo"])) eq_(2, len(d["foo"]))
assert itemList[0] in d["foo"] assert item_list[0] in d["foo"]
assert itemList[2] in d["foo"] assert item_list[2] in d["foo"]
eq_(2, len(d["bar"])) eq_(2, len(d["bar"]))
assert itemList[0] in d["bar"] assert item_list[0] in d["bar"]
assert itemList[1] in d["bar"] assert item_list[1] in d["bar"]
eq_(2, len(d["baz"])) eq_(2, len(d["baz"]))
assert itemList[1] in d["baz"] assert item_list[1] in d["baz"]
assert itemList[2] in d["baz"] assert item_list[2] in d["baz"]
eq_(1, len(d["bleh"])) eq_(1, len(d["bleh"]))
assert itemList[2] in d["bleh"] assert item_list[2] in d["bleh"]
def test_unpack_fields(self): def test_unpack_fields(self):
o = NamedObject("") o = NamedObject("")
@ -269,7 +268,7 @@ class TestCasebuild_word_dict:
eq_(100, self.log[1]) eq_(100, self.log[1])
class TestCasemerge_similar_words: class TestCaseMergeSimilarWords:
def test_some_similar_words(self): def test_some_similar_words(self):
d = { d = {
"foobar": set([1]), "foobar": set([1]),
@ -281,11 +280,11 @@ class TestCasemerge_similar_words:
eq_(3, len(d["foobar"])) eq_(3, len(d["foobar"]))
class TestCasereduce_common_words: class TestCaseReduceCommonWords:
def test_typical(self): def test_typical(self):
d = { d = {
"foo": set([NamedObject("foo bar", True) for i in range(50)]), "foo": set([NamedObject("foo bar", True) for _ in range(50)]),
"bar": set([NamedObject("foo bar", True) for i in range(49)]), "bar": set([NamedObject("foo bar", True) for _ in range(49)]),
} }
reduce_common_words(d, 50) reduce_common_words(d, 50)
assert "foo" not in d assert "foo" not in d
@ -293,7 +292,7 @@ class TestCasereduce_common_words:
def test_dont_remove_objects_with_only_common_words(self): def test_dont_remove_objects_with_only_common_words(self):
d = { d = {
"common": set([NamedObject("common uncommon", True) for i in range(50)] + [NamedObject("common", True)]), "common": set([NamedObject("common uncommon", True) for _ in range(50)] + [NamedObject("common", True)]),
"uncommon": set([NamedObject("common uncommon", True)]), "uncommon": set([NamedObject("common uncommon", True)]),
} }
reduce_common_words(d, 50) reduce_common_words(d, 50)
@ -302,20 +301,20 @@ class TestCasereduce_common_words:
def test_values_still_are_set_instances(self): def test_values_still_are_set_instances(self):
d = { d = {
"common": set([NamedObject("common uncommon", True) for i in range(50)] + [NamedObject("common", True)]), "common": set([NamedObject("common uncommon", True) for _ in range(50)] + [NamedObject("common", True)]),
"uncommon": set([NamedObject("common uncommon", True)]), "uncommon": set([NamedObject("common uncommon", True)]),
} }
reduce_common_words(d, 50) reduce_common_words(d, 50)
assert isinstance(d["common"], set) assert isinstance(d["common"], set)
assert isinstance(d["uncommon"], set) assert isinstance(d["uncommon"], set)
def test_dont_raise_KeyError_when_a_word_has_been_removed(self): def test_dont_raise_keyerror_when_a_word_has_been_removed(self):
# If a word has been removed by the reduce, an object in a subsequent common word that # If a word has been removed by the reduce, an object in a subsequent common word that
# contains the word that has been removed would cause a KeyError. # contains the word that has been removed would cause a KeyError.
d = { d = {
"foo": set([NamedObject("foo bar baz", True) for i in range(50)]), "foo": set([NamedObject("foo bar baz", True) for _ in range(50)]),
"bar": set([NamedObject("foo bar baz", True) for i in range(50)]), "bar": set([NamedObject("foo bar baz", True) for _ in range(50)]),
"baz": set([NamedObject("foo bar baz", True) for i in range(49)]), "baz": set([NamedObject("foo bar baz", True) for _ in range(49)]),
} }
try: try:
reduce_common_words(d, 50) reduce_common_words(d, 50)
@ -329,7 +328,7 @@ class TestCasereduce_common_words:
o.words = [["foo", "bar"], ["baz"]] o.words = [["foo", "bar"], ["baz"]]
return o return o
d = {"foo": set([create_it() for i in range(50)])} d = {"foo": set([create_it() for _ in range(50)])}
try: try:
reduce_common_words(d, 50) reduce_common_words(d, 50)
except TypeError: except TypeError:
@ -342,9 +341,9 @@ class TestCasereduce_common_words:
# would not stay in 'bar' because 'foo' is not a common word anymore. # would not stay in 'bar' because 'foo' is not a common word anymore.
only_common = NamedObject("foo bar", True) only_common = NamedObject("foo bar", True)
d = { d = {
"foo": set([NamedObject("foo bar baz", True) for i in range(49)] + [only_common]), "foo": set([NamedObject("foo bar baz", True) for _ in range(49)] + [only_common]),
"bar": set([NamedObject("foo bar baz", True) for i in range(49)] + [only_common]), "bar": set([NamedObject("foo bar baz", True) for _ in range(49)] + [only_common]),
"baz": set([NamedObject("foo bar baz", True) for i in range(49)]), "baz": set([NamedObject("foo bar baz", True) for _ in range(49)]),
} }
reduce_common_words(d, 50) reduce_common_words(d, 50)
eq_(1, len(d["foo"])) eq_(1, len(d["foo"]))
@ -352,7 +351,7 @@ class TestCasereduce_common_words:
eq_(49, len(d["baz"])) eq_(49, len(d["baz"]))
class TestCaseget_match: class TestCaseGetMatch:
def test_simple(self): def test_simple(self):
o1 = NamedObject("foo bar", True) o1 = NamedObject("foo bar", True)
o2 = NamedObject("bar bleh", True) o2 = NamedObject("bar bleh", True)
@ -381,12 +380,12 @@ class TestCaseGetMatches:
eq_(getmatches([]), []) eq_(getmatches([]), [])
def test_simple(self): def test_simple(self):
itemList = [ item_list = [
NamedObject("foo bar"), NamedObject("foo bar"),
NamedObject("bar bleh"), NamedObject("bar bleh"),
NamedObject("a b c foo"), NamedObject("a b c foo"),
] ]
r = getmatches(itemList) r = getmatches(item_list)
eq_(2, len(r)) eq_(2, len(r))
m = first(m for m in r if m.percentage == 50) # "foo bar" and "bar bleh" m = first(m for m in r if m.percentage == 50) # "foo bar" and "bar bleh"
assert_match(m, "foo bar", "bar bleh") assert_match(m, "foo bar", "bar bleh")
@ -394,40 +393,40 @@ class TestCaseGetMatches:
assert_match(m, "foo bar", "a b c foo") assert_match(m, "foo bar", "a b c foo")
def test_null_and_unrelated_objects(self): def test_null_and_unrelated_objects(self):
itemList = [ item_list = [
NamedObject("foo bar"), NamedObject("foo bar"),
NamedObject("bar bleh"), NamedObject("bar bleh"),
NamedObject(""), NamedObject(""),
NamedObject("unrelated object"), NamedObject("unrelated object"),
] ]
r = getmatches(itemList) r = getmatches(item_list)
eq_(len(r), 1) eq_(len(r), 1)
m = r[0] m = r[0]
eq_(m.percentage, 50) eq_(m.percentage, 50)
assert_match(m, "foo bar", "bar bleh") assert_match(m, "foo bar", "bar bleh")
def test_twice_the_same_word(self): def test_twice_the_same_word(self):
itemList = [NamedObject("foo foo bar"), NamedObject("bar bleh")] item_list = [NamedObject("foo foo bar"), NamedObject("bar bleh")]
r = getmatches(itemList) r = getmatches(item_list)
eq_(1, len(r)) eq_(1, len(r))
def test_twice_the_same_word_when_preworded(self): def test_twice_the_same_word_when_preworded(self):
itemList = [NamedObject("foo foo bar", True), NamedObject("bar bleh", True)] item_list = [NamedObject("foo foo bar", True), NamedObject("bar bleh", True)]
r = getmatches(itemList) r = getmatches(item_list)
eq_(1, len(r)) eq_(1, len(r))
def test_two_words_match(self): def test_two_words_match(self):
itemList = [NamedObject("foo bar"), NamedObject("foo bar bleh")] item_list = [NamedObject("foo bar"), NamedObject("foo bar bleh")]
r = getmatches(itemList) r = getmatches(item_list)
eq_(1, len(r)) eq_(1, len(r))
def test_match_files_with_only_common_words(self): def test_match_files_with_only_common_words(self):
# If a word occurs more than 50 times, it is excluded from the matching process # If a word occurs more than 50 times, it is excluded from the matching process
# The problem with the common_word_threshold is that the files containing only common # The problem with the common_word_threshold is that the files containing only common
# words will never be matched together. We *should* match them. # words will never be matched together. We *should* match them.
# This test assumes that the common word threashold const is 50 # This test assumes that the common word threshold const is 50
itemList = [NamedObject("foo") for i in range(50)] item_list = [NamedObject("foo") for _ in range(50)]
r = getmatches(itemList) r = getmatches(item_list)
eq_(1225, len(r)) eq_(1225, len(r))
def test_use_words_already_there_if_there(self): def test_use_words_already_there_if_there(self):
@ -450,28 +449,28 @@ class TestCaseGetMatches:
eq_(100, self.log[-1]) eq_(100, self.log[-1])
def test_weight_words(self): def test_weight_words(self):
itemList = [NamedObject("foo bar"), NamedObject("bar bleh")] item_list = [NamedObject("foo bar"), NamedObject("bar bleh")]
m = getmatches(itemList, weight_words=True)[0] m = getmatches(item_list, weight_words=True)[0]
eq_(int((6.0 / 13.0) * 100), m.percentage) eq_(int((6.0 / 13.0) * 100), m.percentage)
def test_similar_word(self): def test_similar_word(self):
itemList = [NamedObject("foobar"), NamedObject("foobars")] item_list = [NamedObject("foobar"), NamedObject("foobars")]
eq_(len(getmatches(itemList, match_similar_words=True)), 1) eq_(len(getmatches(item_list, match_similar_words=True)), 1)
eq_(getmatches(itemList, match_similar_words=True)[0].percentage, 100) eq_(getmatches(item_list, match_similar_words=True)[0].percentage, 100)
itemList = [NamedObject("foobar"), NamedObject("foo")] item_list = [NamedObject("foobar"), NamedObject("foo")]
eq_(len(getmatches(itemList, match_similar_words=True)), 0) # too far eq_(len(getmatches(item_list, match_similar_words=True)), 0) # too far
itemList = [NamedObject("bizkit"), NamedObject("bizket")] item_list = [NamedObject("bizkit"), NamedObject("bizket")]
eq_(len(getmatches(itemList, match_similar_words=True)), 1) eq_(len(getmatches(item_list, match_similar_words=True)), 1)
itemList = [NamedObject("foobar"), NamedObject("foosbar")] item_list = [NamedObject("foobar"), NamedObject("foosbar")]
eq_(len(getmatches(itemList, match_similar_words=True)), 1) eq_(len(getmatches(item_list, match_similar_words=True)), 1)
def test_single_object_with_similar_words(self): def test_single_object_with_similar_words(self):
itemList = [NamedObject("foo foos")] item_list = [NamedObject("foo foos")]
eq_(len(getmatches(itemList, match_similar_words=True)), 0) eq_(len(getmatches(item_list, match_similar_words=True)), 0)
def test_double_words_get_counted_only_once(self): def test_double_words_get_counted_only_once(self):
itemList = [NamedObject("foo bar foo bleh"), NamedObject("foo bar bleh bar")] item_list = [NamedObject("foo bar foo bleh"), NamedObject("foo bar bleh bar")]
m = getmatches(itemList)[0] m = getmatches(item_list)[0]
eq_(75, m.percentage) eq_(75, m.percentage)
def test_with_fields(self): def test_with_fields(self):
@ -491,13 +490,13 @@ class TestCaseGetMatches:
eq_(m.percentage, 50) eq_(m.percentage, 50)
def test_only_match_similar_when_the_option_is_set(self): def test_only_match_similar_when_the_option_is_set(self):
itemList = [NamedObject("foobar"), NamedObject("foobars")] item_list = [NamedObject("foobar"), NamedObject("foobars")]
eq_(len(getmatches(itemList, match_similar_words=False)), 0) eq_(len(getmatches(item_list, match_similar_words=False)), 0)
def test_dont_recurse_do_match(self): def test_dont_recurse_do_match(self):
# with nosetests, the stack is increased. The number has to be high enough not to be failing falsely # with nosetests, the stack is increased. The number has to be high enough not to be failing falsely
sys.setrecursionlimit(200) sys.setrecursionlimit(200)
files = [NamedObject("foo bar") for i in range(201)] files = [NamedObject("foo bar") for _ in range(201)]
try: try:
getmatches(files) getmatches(files)
except RuntimeError: except RuntimeError:
@ -506,27 +505,27 @@ class TestCaseGetMatches:
sys.setrecursionlimit(1000) sys.setrecursionlimit(1000)
def test_min_match_percentage(self): def test_min_match_percentage(self):
itemList = [ item_list = [
NamedObject("foo bar"), NamedObject("foo bar"),
NamedObject("bar bleh"), NamedObject("bar bleh"),
NamedObject("a b c foo"), NamedObject("a b c foo"),
] ]
r = getmatches(itemList, min_match_percentage=50) r = getmatches(item_list, min_match_percentage=50)
eq_(1, len(r)) # Only "foo bar" / "bar bleh" should match eq_(1, len(r)) # Only "foo bar" / "bar bleh" should match
def test_MemoryError(self, monkeypatch): def test_memory_error(self, monkeypatch):
@log_calls @log_calls
def mocked_match(first, second, flags): def mocked_match(first, second, flags):
if len(mocked_match.calls) > 42: if len(mocked_match.calls) > 42:
raise MemoryError() raise MemoryError()
return Match(first, second, 0) return Match(first, second, 0)
objects = [NamedObject() for i in range(10)] # results in 45 matches objects = [NamedObject() for _ in range(10)] # results in 45 matches
monkeypatch.setattr(engine, "get_match", mocked_match) monkeypatch.setattr(engine, "get_match", mocked_match)
try: try:
r = getmatches(objects) r = getmatches(objects)
except MemoryError: except MemoryError:
self.fail("MemorryError must be handled") self.fail("MemoryError must be handled")
eq_(42, len(r)) eq_(42, len(r))
@ -563,7 +562,7 @@ class TestCaseGetMatchesByContents:
class TestCaseGroup: class TestCaseGroup:
def test_empy(self): def test_empty(self):
g = Group() g = Group()
eq_(None, g.ref) eq_(None, g.ref)
eq_([], g.dupes) eq_([], g.dupes)
@ -802,14 +801,14 @@ class TestCaseGroup:
eq_(0, len(g.candidates)) eq_(0, len(g.candidates))
class TestCaseget_groups: class TestCaseGetGroups:
def test_empty(self): def test_empty(self):
r = get_groups([]) r = get_groups([])
eq_([], r) eq_([], r)
def test_simple(self): def test_simple(self):
itemList = [NamedObject("foo bar"), NamedObject("bar bleh")] item_list = [NamedObject("foo bar"), NamedObject("bar bleh")]
matches = getmatches(itemList) matches = getmatches(item_list)
m = matches[0] m = matches[0]
r = get_groups(matches) r = get_groups(matches)
eq_(1, len(r)) eq_(1, len(r))
@ -819,15 +818,15 @@ class TestCaseget_groups:
def test_group_with_multiple_matches(self): def test_group_with_multiple_matches(self):
# This results in 3 matches # This results in 3 matches
itemList = [NamedObject("foo"), NamedObject("foo"), NamedObject("foo")] item_list = [NamedObject("foo"), NamedObject("foo"), NamedObject("foo")]
matches = getmatches(itemList) matches = getmatches(item_list)
r = get_groups(matches) r = get_groups(matches)
eq_(1, len(r)) eq_(1, len(r))
g = r[0] g = r[0]
eq_(3, len(g)) eq_(3, len(g))
def test_must_choose_a_group(self): def test_must_choose_a_group(self):
itemList = [ item_list = [
NamedObject("a b"), NamedObject("a b"),
NamedObject("a b"), NamedObject("a b"),
NamedObject("b c"), NamedObject("b c"),
@ -836,13 +835,13 @@ class TestCaseget_groups:
] ]
# There will be 2 groups here: group "a b" and group "c d" # There will be 2 groups here: group "a b" and group "c d"
# "b c" can go either of them, but not both. # "b c" can go either of them, but not both.
matches = getmatches(itemList) matches = getmatches(item_list)
r = get_groups(matches) r = get_groups(matches)
eq_(2, len(r)) eq_(2, len(r))
eq_(5, len(r[0]) + len(r[1])) eq_(5, len(r[0]) + len(r[1]))
def test_should_all_go_in_the_same_group(self): def test_should_all_go_in_the_same_group(self):
itemList = [ item_list = [
NamedObject("a b"), NamedObject("a b"),
NamedObject("a b"), NamedObject("a b"),
NamedObject("a b"), NamedObject("a b"),
@ -850,7 +849,7 @@ class TestCaseget_groups:
] ]
# There will be 2 groups here: group "a b" and group "c d" # There will be 2 groups here: group "a b" and group "c d"
# "b c" can fit in both, but it must be in only one of them # "b c" can fit in both, but it must be in only one of them
matches = getmatches(itemList) matches = getmatches(item_list)
r = get_groups(matches) r = get_groups(matches)
eq_(1, len(r)) eq_(1, len(r))
@ -869,8 +868,8 @@ class TestCaseget_groups:
assert o3 in g assert o3 in g
def test_four_sized_group(self): def test_four_sized_group(self):
itemList = [NamedObject("foobar") for i in range(4)] item_list = [NamedObject("foobar") for _ in range(4)]
m = getmatches(itemList) m = getmatches(item_list)
r = get_groups(m) r = get_groups(m)
eq_(1, len(r)) eq_(1, len(r))
eq_(4, len(r[0])) eq_(4, len(r[0]))

11
core/tests/exclude_test.py
View File

@ -5,12 +5,8 @@
# http://www.gnu.org/licenses/gpl-3.0.html # http://www.gnu.org/licenses/gpl-3.0.html
import io import io
# import os.path as op
from xml.etree import ElementTree as ET from xml.etree import ElementTree as ET
# from pytest import raises
from hscommon.testutil import eq_ from hscommon.testutil import eq_
from hscommon.plat import ISWINDOWS from hscommon.plat import ISWINDOWS
@ -144,11 +140,7 @@ class TestCaseListEmpty:
def test_force_add_not_compilable(self): def test_force_add_not_compilable(self):
"""Used when loading from XML for example""" """Used when loading from XML for example"""
regex = r"one))" regex = r"one))"
try: self.exclude_list.add(regex, forced=True)
self.exclude_list.add(regex, forced=True)
except Exception as e:
# Should not get an exception here unless it's a duplicate regex
raise e
marked = self.exclude_list.mark(regex) marked = self.exclude_list.mark(regex)
eq_(marked, False) # can't be marked since not compilable eq_(marked, False) # can't be marked since not compilable
eq_(len(self.exclude_list), 1) eq_(len(self.exclude_list), 1)
@ -232,7 +224,6 @@ class TestCaseListEmpty:
found = True found = True
if not found: if not found:
raise (Exception(f"Default RE {re} not found in compiled list.")) raise (Exception(f"Default RE {re} not found in compiled list."))
continue
eq_(len(default_regexes), len(self.exclude_list.compiled)) eq_(len(default_regexes), len(self.exclude_list.compiled))

6
core/tests/ignore_test.py
View File

@ -77,7 +77,7 @@ def test_save_to_xml():
eq_(len(subchildren), 3) eq_(len(subchildren), 3)
def test_SaveThenLoad(): def test_save_then_load():
il = IgnoreList() il = IgnoreList()
il.Ignore("foo", "bar") il.Ignore("foo", "bar")
il.Ignore("foo", "bleh") il.Ignore("foo", "bleh")
@ -92,7 +92,7 @@ def test_SaveThenLoad():
assert il.AreIgnored("\u00e9", "bar") assert il.AreIgnored("\u00e9", "bar")
def test_LoadXML_with_empty_file_tags(): def test_load_xml_with_empty_file_tags():
f = io.BytesIO() f = io.BytesIO()
f.write(b'<?xml version="1.0" encoding="utf-8"?><ignore_list><file><file/></file></ignore_list>') f.write(b'<?xml version="1.0" encoding="utf-8"?><ignore_list><file><file/></file></ignore_list>')
f.seek(0) f.seek(0)
@ -101,7 +101,7 @@ def test_LoadXML_with_empty_file_tags():
eq_(0, len(il)) eq_(0, len(il))
def test_AreIgnore_works_when_a_child_is_a_key_somewhere_else(): def test_are_ignore_works_when_a_child_is_a_key_somewhere_else():
il = IgnoreList() il = IgnoreList()
il.Ignore("foo", "bar") il.Ignore("foo", "bar")
il.Ignore("bar", "baz") il.Ignore("bar", "baz")

12
core/tests/results_test.py
View File

@ -402,7 +402,7 @@ class TestCaseResultsMarkings:
self.results.make_ref(d) self.results.make_ref(d)
eq_("0 / 3 (0.00 B / 3.00 B) duplicates marked.", self.results.stat_line) eq_("0 / 3 (0.00 B / 3.00 B) duplicates marked.", self.results.stat_line)
def test_SaveXML(self): def test_save_xml(self):
self.results.mark(self.objects[1]) self.results.mark(self.objects[1])
self.results.mark_invert() self.results.mark_invert()
f = io.BytesIO() f = io.BytesIO()
@ -419,7 +419,7 @@ class TestCaseResultsMarkings:
eq_("n", d1.get("marked")) eq_("n", d1.get("marked"))
eq_("y", d2.get("marked")) eq_("y", d2.get("marked"))
def test_LoadXML(self): def test_load_xml(self):
def get_file(path): def get_file(path):
return [f for f in self.objects if str(f.path) == path][0] return [f for f in self.objects if str(f.path) == path][0]
@ -485,7 +485,7 @@ class TestCaseResultsXML:
eq_("ibabtu", d1.get("words")) eq_("ibabtu", d1.get("words"))
eq_("ibabtu", d2.get("words")) eq_("ibabtu", d2.get("words"))
def test_LoadXML(self): def test_load_xml(self):
def get_file(path): def get_file(path):
return [f for f in self.objects if str(f.path) == path][0] return [f for f in self.objects if str(f.path) == path][0]
@ -517,7 +517,7 @@ class TestCaseResultsXML:
eq_(["ibabtu"], g2[0].words) eq_(["ibabtu"], g2[0].words)
eq_(["ibabtu"], g2[1].words) eq_(["ibabtu"], g2[1].words)
def test_LoadXML_with_filename(self, tmpdir): def test_load_xml_with_filename(self, tmpdir):
def get_file(path): def get_file(path):
return [f for f in self.objects if str(f.path) == path][0] return [f for f in self.objects if str(f.path) == path][0]
@ -529,7 +529,7 @@ class TestCaseResultsXML:
r.load_from_xml(filename, get_file) r.load_from_xml(filename, get_file)
eq_(2, len(r.groups)) eq_(2, len(r.groups))
def test_LoadXML_with_some_files_that_dont_exist_anymore(self): def test_load_xml_with_some_files_that_dont_exist_anymore(self):
def get_file(path): def get_file(path):
if path.endswith("ibabtu 2"): if path.endswith("ibabtu 2"):
return None return None
@ -545,7 +545,7 @@ class TestCaseResultsXML:
eq_(1, len(r.groups)) eq_(1, len(r.groups))
eq_(3, len(r.groups[0])) eq_(3, len(r.groups[0]))
def test_LoadXML_missing_attributes_and_bogus_elements(self): def test_load_xml_missing_attributes_and_bogus_elements(self):
def get_file(path): def get_file(path):
return [f for f in self.objects if str(f.path) == path][0] return [f for f in self.objects if str(f.path) == path][0]

8
core/tests/scanner_test.py
View File

@ -98,7 +98,7 @@ def test_trim_all_ref_groups(fake_fileexists):
eq_(s.discarded_file_count, 0) eq_(s.discarded_file_count, 0)
def test_priorize(fake_fileexists): def test_prioritize(fake_fileexists):
s = Scanner() s = Scanner()
f = [ f = [
no("foo", path="p1"), no("foo", path="p1"),
@ -133,7 +133,7 @@ def test_content_scan(fake_fileexists):
def test_content_scan_compare_sizes_first(fake_fileexists): def test_content_scan_compare_sizes_first(fake_fileexists):
class MyFile(no): class MyFile(no):
@property @property
def md5(file): def md5(self):
raise AssertionError() raise AssertionError()
s = Scanner() s = Scanner()
@ -587,8 +587,8 @@ def test_dont_count_ref_files_as_discarded(fake_fileexists):
eq_(s.discarded_file_count, 0) eq_(s.discarded_file_count, 0)
def test_priorize_me(fake_fileexists): def test_prioritize_me(fake_fileexists):
# in ScannerME, bitrate goes first (right after is_ref) in priorization # in ScannerME, bitrate goes first (right after is_ref) in prioritization
s = ScannerME() s = ScannerME()
o1, o2 = no("foo", path="p1"), no("foo", path="p2") o1, o2 = no("foo", path="p1"), no("foo", path="p2")
o1.bitrate = 1 o1.bitrate = 1