mirror of
https://github.com/arsenetar/dupeguru.git
synced 2024-11-16 20:29:02 +00:00
d1f460b091
--HG-- rename : py/__init__.py => base/py/__init__.py rename : py/app.py => base/py/app.py rename : py/app_cocoa.py => base/py/app_cocoa.py rename : py/app_me_cocoa.py => base/py/app_me_cocoa.py rename : py/app_pe_cocoa.py => base/py/app_pe_cocoa.py rename : py/app_se_cocoa.py => base/py/app_se_cocoa.py rename : py/data.py => base/py/data.py rename : py/data_me.py => base/py/data_me.py rename : py/data_pe.py => base/py/data_pe.py rename : py/directories.py => base/py/directories.py rename : py/engine.py => base/py/engine.py rename : py/export.py => base/py/export.py rename : py/gen.py => base/py/gen.py rename : py/ignore.py => base/py/ignore.py rename : py/modules/block/block.pyx => base/py/modules/block/block.pyx rename : py/modules/block/setup.py => base/py/modules/block/setup.py rename : py/modules/cache/cache.pyx => base/py/modules/cache/cache.pyx rename : py/modules/cache/setup.py => base/py/modules/cache/setup.py rename : py/picture/__init__.py => base/py/picture/__init__.py rename : py/picture/block.py => base/py/picture/block.py rename : py/picture/cache.py => base/py/picture/cache.py rename : py/picture/matchbase.py => base/py/picture/matchbase.py rename : py/results.py => base/py/results.py rename : py/scanner.py => base/py/scanner.py rename : py/tests/__init__.py => base/py/tests/__init__.py rename : py/tests/app_cocoa_test.py => base/py/tests/app_cocoa_test.py rename : py/tests/app_test.py => base/py/tests/app_test.py rename : py/tests/block_test.py => base/py/tests/block_test.py rename : py/tests/cache_test.py => base/py/tests/cache_test.py rename : py/tests/directories_test.py => base/py/tests/directories_test.py rename : py/tests/engine_test.py => base/py/tests/engine_test.py rename : py/tests/export_test.py => base/py/tests/export_test.py rename : py/tests/ignore_test.py => base/py/tests/ignore_test.py rename : py/tests/results_test.py => base/py/tests/results_test.py rename : py/tests/scanner_test.py => base/py/tests/scanner_test.py extra : convert_revision : svn%3Ac306627e-7827-47d3-bdf0-9a457c9553a1/trunk%4074
351 lines
13 KiB
Python
351 lines
13 KiB
Python
# Unit Name: dupeguru.tests.app_cocoa_test
|
|
# Created By: Virgil Dupras
|
|
# Created On: 2006/11/11
|
|
# $Id$
|
|
# Copyright 2009 Hardcoded Software (http://www.hardcoded.net)
|
|
|
|
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
|
|
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
|
|
|
|
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):
|
|
app = self.app
|
|
self.assertEqual(0,app.add_directory(self.datadirpath()))
|
|
self.assertEqual(1,len(app.directories))
|
|
|
|
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()
|
|
|
|
|
|
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'])
|
|
|