mirror of
https://github.com/arsenetar/dupeguru.git
synced 2024-11-14 11:39:03 +00:00
372 lines
14 KiB
Python
372 lines
14 KiB
Python
# Created By: Virgil Dupras
|
|
# Created On: 2006/11/11
|
|
# $Id$
|
|
# Copyright 2009 Hardcoded Software (http://www.hardcoded.net)
|
|
#
|
|
# This software is licensed under the "HS" License as described in the "LICENSE" file,
|
|
# which should be included with this package. The terms are also available at
|
|
# http://www.hardcoded.net/licenses/hs_license
|
|
|
|
import tempfile
|
|
import shutil
|
|
import logging
|
|
import os.path as op
|
|
|
|
from nose.tools import eq_
|
|
|
|
from hsutil.path import Path
|
|
from hsutil.testcase import TestCase
|
|
from hsutil.decorators import log_calls
|
|
from hsutil import io
|
|
import hsfs.phys
|
|
|
|
from .results_test import GetTestGroups
|
|
from .. import engine, data
|
|
try:
|
|
from ..app_cocoa import DupeGuru as DupeGuruBase
|
|
except ImportError:
|
|
from nose.plugins.skip import SkipTest
|
|
raise SkipTest("These tests can only be run on OS X")
|
|
|
|
class DupeGuru(DupeGuruBase):
|
|
def __init__(self):
|
|
DupeGuruBase.__init__(self, data, '/tmp', appid=4)
|
|
|
|
def _start_job(self, jobid, func):
|
|
func(nulljob)
|
|
|
|
|
|
def r2np(rows):
|
|
#Transforms a list of rows [1,2,3] into a list of node paths [[1],[2],[3]]
|
|
return [[i] for i in rows]
|
|
|
|
class TCDupeGuru(TestCase):
|
|
def setUp(self):
|
|
self.app = DupeGuru()
|
|
self.objects,self.matches,self.groups = GetTestGroups()
|
|
self.app.results.groups = self.groups
|
|
tmppath = self.tmppath()
|
|
io.mkdir(tmppath + 'foo')
|
|
io.mkdir(tmppath + 'bar')
|
|
self.app.directories.add_path(tmppath)
|
|
|
|
def test_GetObjects(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
groups = self.groups
|
|
g,d = app.GetObjects([0])
|
|
self.assert_(g is groups[0])
|
|
self.assert_(d is None)
|
|
g,d = app.GetObjects([0,0])
|
|
self.assert_(g is groups[0])
|
|
self.assert_(d is objects[1])
|
|
g,d = app.GetObjects([1,0])
|
|
self.assert_(g is groups[1])
|
|
self.assert_(d is objects[4])
|
|
|
|
def test_GetObjects_after_sort(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
groups = self.groups[:] #To keep the old order in memory
|
|
app.sort_groups(0,False) #0 = Filename
|
|
#Now, the group order is supposed to be reversed
|
|
g,d = app.GetObjects([0,0])
|
|
self.assert_(g is groups[1])
|
|
self.assert_(d is objects[4])
|
|
|
|
def test_GetObjects_out_of_range(self):
|
|
app = self.app
|
|
self.assertEqual((None,None),app.GetObjects([2]))
|
|
self.assertEqual((None,None),app.GetObjects([]))
|
|
self.assertEqual((None,None),app.GetObjects([1,2]))
|
|
|
|
def test_selected_result_node_paths(self):
|
|
# app.selected_dupes is correctly converted into node paths
|
|
app = self.app
|
|
objects = self.objects
|
|
paths = [[0, 0], [0, 1], [1]]
|
|
app.SelectResultNodePaths(paths)
|
|
eq_(app.selected_result_node_paths(), paths)
|
|
|
|
def test_selected_result_node_paths_after_deletion(self):
|
|
# cases where the selected dupes aren't there are correctly handled
|
|
app = self.app
|
|
objects = self.objects
|
|
paths = [[0, 0], [0, 1], [1]]
|
|
app.SelectResultNodePaths(paths)
|
|
app.RemoveSelected()
|
|
# The first 2 dupes have been removed. The 3rd one is a ref. it stays there, in first pos.
|
|
eq_(app.selected_result_node_paths(), [[0]]) # no exception
|
|
|
|
def test_selectResultNodePaths(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
app.SelectResultNodePaths([[0,0],[0,1]])
|
|
self.assertEqual(2,len(app.selected_dupes))
|
|
self.assert_(app.selected_dupes[0] is objects[1])
|
|
self.assert_(app.selected_dupes[1] is objects[2])
|
|
|
|
def test_selectResultNodePaths_with_ref(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
app.SelectResultNodePaths([[0,0],[0,1],[1]])
|
|
self.assertEqual(3,len(app.selected_dupes))
|
|
self.assert_(app.selected_dupes[0] is objects[1])
|
|
self.assert_(app.selected_dupes[1] is objects[2])
|
|
self.assert_(app.selected_dupes[2] is self.groups[1].ref)
|
|
|
|
def test_selectResultNodePaths_empty(self):
|
|
self.app.SelectResultNodePaths([])
|
|
self.assertEqual(0,len(self.app.selected_dupes))
|
|
|
|
def test_selectResultNodePaths_after_sort(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
groups = self.groups[:] #To keep the old order in memory
|
|
app.sort_groups(0,False) #0 = Filename
|
|
#Now, the group order is supposed to be reversed
|
|
app.SelectResultNodePaths([[0,0],[1],[1,0]])
|
|
self.assertEqual(3,len(app.selected_dupes))
|
|
self.assert_(app.selected_dupes[0] is objects[4])
|
|
self.assert_(app.selected_dupes[1] is groups[0].ref)
|
|
self.assert_(app.selected_dupes[2] is objects[1])
|
|
|
|
def test_selectResultNodePaths_out_of_range(self):
|
|
app = self.app
|
|
app.SelectResultNodePaths([[0,0],[0,1],[1],[1,1],[2]])
|
|
self.assertEqual(3,len(app.selected_dupes))
|
|
|
|
def test_selected_powermarker_node_paths(self):
|
|
# app.selected_dupes is correctly converted into paths
|
|
app = self.app
|
|
objects = self.objects
|
|
paths = r2np([0, 1, 2])
|
|
app.SelectPowerMarkerNodePaths(paths)
|
|
eq_(app.selected_powermarker_node_paths(), paths)
|
|
|
|
def test_selected_powermarker_node_paths_after_deletion(self):
|
|
# cases where the selected dupes aren't there are correctly handled
|
|
app = self.app
|
|
objects = self.objects
|
|
paths = r2np([0, 1, 2])
|
|
app.SelectPowerMarkerNodePaths(paths)
|
|
app.RemoveSelected()
|
|
eq_(app.selected_powermarker_node_paths(), []) # no exception
|
|
|
|
def test_selectPowerMarkerRows(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
app.SelectPowerMarkerNodePaths(r2np([0,1,2]))
|
|
self.assertEqual(3,len(app.selected_dupes))
|
|
self.assert_(app.selected_dupes[0] is objects[1])
|
|
self.assert_(app.selected_dupes[1] is objects[2])
|
|
self.assert_(app.selected_dupes[2] is objects[4])
|
|
|
|
def test_selectPowerMarkerRows_empty(self):
|
|
self.app.SelectPowerMarkerNodePaths([])
|
|
self.assertEqual(0,len(self.app.selected_dupes))
|
|
|
|
def test_selectPowerMarkerRows_after_sort(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
app.sort_dupes(0,False) #0 = Filename
|
|
app.SelectPowerMarkerNodePaths(r2np([0,1,2]))
|
|
self.assertEqual(3,len(app.selected_dupes))
|
|
self.assert_(app.selected_dupes[0] is objects[4])
|
|
self.assert_(app.selected_dupes[1] is objects[2])
|
|
self.assert_(app.selected_dupes[2] is objects[1])
|
|
|
|
def test_selectPowerMarkerRows_out_of_range(self):
|
|
app = self.app
|
|
app.SelectPowerMarkerNodePaths(r2np([0,1,2,3]))
|
|
self.assertEqual(3,len(app.selected_dupes))
|
|
|
|
def test_toggleSelectedMark(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
app.ToggleSelectedMarkState()
|
|
self.assertEqual(0,app.results.mark_count)
|
|
app.SelectPowerMarkerNodePaths(r2np([0,2]))
|
|
app.ToggleSelectedMarkState()
|
|
self.assertEqual(2,app.results.mark_count)
|
|
self.assert_(not app.results.is_marked(objects[0]))
|
|
self.assert_(app.results.is_marked(objects[1]))
|
|
self.assert_(not app.results.is_marked(objects[2]))
|
|
self.assert_(not app.results.is_marked(objects[3]))
|
|
self.assert_(app.results.is_marked(objects[4]))
|
|
|
|
def test_refreshDetailsWithSelected(self):
|
|
def mock_refresh(dupe,group):
|
|
self.called = True
|
|
if self.app.selected_dupes:
|
|
self.assert_(dupe is self.app.selected_dupes[0])
|
|
self.assert_(group is self.app.results.get_group_of_duplicate(dupe))
|
|
else:
|
|
self.assert_(dupe is None)
|
|
self.assert_(group is None)
|
|
|
|
self.app.RefreshDetailsTable = mock_refresh
|
|
self.called = False
|
|
self.app.SelectPowerMarkerNodePaths(r2np([0,2]))
|
|
self.app.RefreshDetailsWithSelected()
|
|
self.assert_(self.called)
|
|
self.called = False
|
|
self.app.SelectPowerMarkerNodePaths([])
|
|
self.app.RefreshDetailsWithSelected()
|
|
self.assert_(self.called)
|
|
|
|
def test_makeSelectedReference(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
groups = self.groups
|
|
app.SelectPowerMarkerNodePaths(r2np([0,2]))
|
|
app.MakeSelectedReference()
|
|
self.assert_(groups[0].ref is objects[1])
|
|
self.assert_(groups[1].ref is objects[4])
|
|
|
|
def test_makeSelectedReference_by_selecting_two_dupes_in_the_same_group(self):
|
|
app = self.app
|
|
objects = self.objects
|
|
groups = self.groups
|
|
app.SelectPowerMarkerNodePaths(r2np([0,1,2]))
|
|
#Only 0 and 2 must go ref, not 1 because it is a part of the same group
|
|
app.MakeSelectedReference()
|
|
self.assert_(groups[0].ref is objects[1])
|
|
self.assert_(groups[1].ref is objects[4])
|
|
|
|
def test_removeSelected(self):
|
|
app = self.app
|
|
app.SelectPowerMarkerNodePaths(r2np([0,2]))
|
|
app.RemoveSelected()
|
|
self.assertEqual(1,len(app.results.dupes))
|
|
app.RemoveSelected()
|
|
self.assertEqual(1,len(app.results.dupes))
|
|
app.SelectPowerMarkerNodePaths(r2np([0,2]))
|
|
app.RemoveSelected()
|
|
self.assertEqual(0,len(app.results.dupes))
|
|
|
|
def test_addDirectory_simple(self):
|
|
# There's already a directory in self.app, so adding another once makes 2 of em
|
|
app = self.app
|
|
eq_(app.add_directory(self.datadirpath()), 0)
|
|
eq_(len(app.directories), 2)
|
|
|
|
def test_addDirectory_already_there(self):
|
|
app = self.app
|
|
self.assertEqual(0,app.add_directory(self.datadirpath()))
|
|
self.assertEqual(1,app.add_directory(self.datadirpath()))
|
|
|
|
def test_addDirectory_does_not_exist(self):
|
|
app = self.app
|
|
self.assertEqual(2,app.add_directory('/does_not_exist'))
|
|
|
|
def test_ignore(self):
|
|
app = self.app
|
|
app.SelectPowerMarkerNodePaths(r2np([2])) #The dupe of the second, 2 sized group
|
|
app.AddSelectedToIgnoreList()
|
|
self.assertEqual(1,len(app.scanner.ignore_list))
|
|
app.SelectPowerMarkerNodePaths(r2np([0])) #first dupe of the 3 dupes group
|
|
app.AddSelectedToIgnoreList()
|
|
#BOTH the ref and the other dupe should have been added
|
|
self.assertEqual(3,len(app.scanner.ignore_list))
|
|
|
|
def test_purgeIgnoreList(self):
|
|
app = self.app
|
|
p1 = self.filepath('zerofile')
|
|
p2 = self.filepath('zerofill')
|
|
dne = '/does_not_exist'
|
|
app.scanner.ignore_list.Ignore(dne,p1)
|
|
app.scanner.ignore_list.Ignore(p2,dne)
|
|
app.scanner.ignore_list.Ignore(p1,p2)
|
|
app.PurgeIgnoreList()
|
|
self.assertEqual(1,len(app.scanner.ignore_list))
|
|
self.assert_(app.scanner.ignore_list.AreIgnored(p1,p2))
|
|
self.assert_(not app.scanner.ignore_list.AreIgnored(dne,p1))
|
|
|
|
def test_only_unicode_is_added_to_ignore_list(self):
|
|
def FakeIgnore(first,second):
|
|
if not isinstance(first,unicode):
|
|
self.fail()
|
|
if not isinstance(second,unicode):
|
|
self.fail()
|
|
|
|
app = self.app
|
|
app.scanner.ignore_list.Ignore = FakeIgnore
|
|
app.SelectPowerMarkerNodePaths(r2np([2])) #The dupe of the second, 2 sized group
|
|
app.AddSelectedToIgnoreList()
|
|
|
|
def test_GetOutlineViewChildCounts_out_of_range(self):
|
|
# Out of range requests don't crash and return an empty value
|
|
app = self.app
|
|
# [0, 2] is out of range
|
|
eq_(app.GetOutlineViewChildCounts(1, [0, 2]), []) # no crash
|
|
|
|
def test_GetOutlineViewValues_out_of_range(self):
|
|
# Out of range requests don't crash and return an empty value
|
|
app = self.app
|
|
# [0, 2] is out of range
|
|
eq_(app.GetOutlineViewValues(1, [0, 2]), []) # no crash
|
|
|
|
|
|
class TCDupeGuru_renameSelected(TestCase):
|
|
def setUp(self):
|
|
p = Path(tempfile.mkdtemp())
|
|
fp = open(str(p + 'foo bar 1'),mode='w')
|
|
fp.close()
|
|
fp = open(str(p + 'foo bar 2'),mode='w')
|
|
fp.close()
|
|
fp = open(str(p + 'foo bar 3'),mode='w')
|
|
fp.close()
|
|
refdir = hsfs.phys.Directory(None,str(p))
|
|
matches = engine.MatchFactory().getmatches(refdir.files)
|
|
groups = engine.get_groups(matches)
|
|
g = groups[0]
|
|
g.prioritize(lambda x:x.name)
|
|
app = DupeGuru()
|
|
app.results.groups = groups
|
|
self.app = app
|
|
self.groups = groups
|
|
self.p = p
|
|
self.refdir = refdir
|
|
|
|
def tearDown(self):
|
|
shutil.rmtree(str(self.p))
|
|
|
|
def test_simple(self):
|
|
app = self.app
|
|
refdir = self.refdir
|
|
g = self.groups[0]
|
|
app.SelectPowerMarkerNodePaths(r2np([0]))
|
|
self.assert_(app.RenameSelected('renamed'))
|
|
self.assert_('renamed' in refdir)
|
|
self.assert_('foo bar 2' not in refdir)
|
|
self.assert_(g.dupes[0] is refdir['renamed'])
|
|
self.assert_(g.dupes[0] in refdir)
|
|
|
|
def test_none_selected(self):
|
|
app = self.app
|
|
refdir = self.refdir
|
|
g = self.groups[0]
|
|
app.SelectPowerMarkerNodePaths([])
|
|
self.mock(logging, 'warning', log_calls(lambda msg: None))
|
|
self.assert_(not app.RenameSelected('renamed'))
|
|
msg = logging.warning.calls[0]['msg']
|
|
self.assertEqual('dupeGuru Warning: list index out of range', msg)
|
|
self.assert_('renamed' not in refdir)
|
|
self.assert_('foo bar 2' in refdir)
|
|
self.assert_(g.dupes[0] is refdir['foo bar 2'])
|
|
|
|
def test_name_already_exists(self):
|
|
app = self.app
|
|
refdir = self.refdir
|
|
g = self.groups[0]
|
|
app.SelectPowerMarkerNodePaths(r2np([0]))
|
|
self.mock(logging, 'warning', log_calls(lambda msg: None))
|
|
self.assert_(not app.RenameSelected('foo bar 1'))
|
|
msg = logging.warning.calls[0]['msg']
|
|
self.assert_(msg.startswith('dupeGuru Warning: \'foo bar 2\' already exists in'))
|
|
self.assert_('foo bar 1' in refdir)
|
|
self.assert_('foo bar 2' in refdir)
|
|
self.assert_(g.dupes[0] is refdir['foo bar 2'])
|
|
|