Example #1
0
 def run_trashput(self, *argv):
     cmd = TrashPutCmd(stdout=self.out,
                       stderr=self.err,
                       environ=self.environ,
                       fstab=self.fstab)
     self.exit_code = cmd.run(list(argv))
     self.stderr = self.err.getvalue()
 def run_trash_put(self, *arg):
     self.stderr = StringIO()
     self.stdout = StringIO()
     args = ['trash-put'] + list(arg)
     cmd = TrashPutCmd(self.stdout, self.stderr, None, None, None, None,
                       None, None, None)
     self._collect_exit_code(lambda: cmd.run(args))
Example #3
0
 def setUp(self):
     parent_path = lambda _: None
     volume_of = lambda _: '/'
     self.try_trash_file_using_candidates = Mock()
     self.cmd = TrashPutCmd(None, None, {'XDG_DATA_HOME': '~/xdh'},
                            volume_of, parent_path, None, None, None, None)
     self.cmd.getuid = lambda: '123'
     self.cmd.try_trash_file_using_candidates = self.try_trash_file_using_candidates
    def test_trash_put_last_line(self):
        from trashcli.put import TrashPutCmd

        cmd = TrashPutCmd(self.out, StringIO(), None, None, None, None, None,
                          None, None)
        cmd.run(['', '--help'])

        self.assert_last_line_of_output_is(
            'Report bugs to https://github.com/andreafrancia/trash-cli/issues')
Example #5
0
 def run_trashput(self, *argv):
     cmd = TrashPutCmd(stdout=self.out,
                       stderr=self.err,
                       environ=self.environ,
                       volume_of=self.fstab.volume_of,
                       parent_path=os.path.dirname,
                       realpath=lambda x: x)
     self.exit_code = cmd.run(list(argv))
     self.stderr = self.err.getvalue()
    def setUp(self):
        parent_path = lambda _: None

        class MyVolumes:
            def volume_of(self, path):
                return '/'

        volumes = MyVolumes()
        self.try_trash_file_using_candidates = Mock()
        self.cmd = TrashPutCmd(None, None, {'XDG_DATA_HOME': '~/xdh'}, volumes,
                               parent_path, None, None, lambda: '123', None)
        self.cmd.try_trash_file_using_candidates = self.try_trash_file_using_candidates
Example #7
0
 def run_trashput(self, *argv):
     cmd = TrashPutCmd(stdout=self.out,
                       stderr=self.err,
                       environ=self.environ,
                       volume_of=self.fstab.volume_of,
                       parent_path=os.path.dirname,
                       realpath=lambda x: x,
                       fs=RealFs(),
                       getuid=lambda: None,
                       now=datetime.now)
     self.exit_code = cmd.run(list(argv))
     self.stderr = self.err.getvalue()
 def run_trashput(self, *argv):
     self.environ = {'XDG_DATA_HOME': self.temp_dir / 'XDG_DATA_HOME'}
     self.out = StringIO()
     self.err = StringIO()
     cmd = TrashPutCmd(stdout=self.out,
                       stderr=self.err,
                       environ=self.environ,
                       volumes=self.volumes,
                       parent_path=os.path.dirname,
                       realpath=lambda x: x,
                       fs=RealFs(),
                       getuid=lambda: None,
                       now=datetime.now)
     self.exit_code = cmd.run(list(argv))
     self.stdout = self.out.getvalue()
     self.stderr = self.err.getvalue()
Example #9
0
 def setUp(self):
     self.reporter = Mock()
     mount_points = ['/', 'sandbox/other_partition']
     self.fs = Mock()
     self.trashcan = TrashPutCmd(
         stdout=None,
         stderr=None,
         getuid=lambda: 123,
         volumes=create_fake_volume_of(mount_points),
         now=datetime.now,
         environ=dict(),
         fs=self.fs,
         parent_path=os.path.dirname,
         realpath=lambda x: x)
     self.trashcan.reporter = self.reporter
     self.trashcan.logger = Mock()
     self.trashcan.ignore_missing = False
Example #10
0
    def setUp(self):
        self.reporter = Mock()
        self.fs = Mock()
        self.volumes = Mock()
        self.volumes.volume_of.return_value = '/'

        self.trashcan = TrashPutCmd(stdout=None,
                                    stderr=None,
                                    volumes=self.volumes,
                                    getuid=lambda: 123,
                                    now=datetime.now,
                                    environ=dict(),
                                    fs=self.fs,
                                    parent_path=os.path.dirname,
                                    realpath=lambda x: x)
        self.trashcan.reporter = self.reporter
        self.trashcan.logger = Mock()
        self.trashcan.ignore_missing = False
 def test(self):
     parent_path = lambda _:None
     class MyVolumes:
         def volume_of(self, _path):
             return '/volume'
     volumes = MyVolumes()
     realpath = lambda _: None
     fs = Mock(['move',
                'atomic_write',
                'remove_file',
                'ensure_dir',
                'isdir',
                'islink',
                'has_sticky_bit'])
     fs.islink.side_effect = lambda path: {
                                             '/volume/.Trash':False
                                          }[path]
     fs.has_sticky_bit.side_effect = lambda path: {
                                             '/volume/.Trash':False
                                          }[path]
     reporter = Mock(['volume_of_file',
                      'found_unsecure_trash_dir_unsticky',
                      'trash_dir_with_volume',
                      'file_has_been_trashed_in_as'])
     trashcan = TrashPutCmd(stdout=None,
                            stderr=None,
                            environ={},
                            volumes=volumes,
                            fs=fs,
                            getuid=lambda: 'uid',
                            now=datetime.now,
                            parent_path=parent_path,
                            realpath=realpath)
     trashcan.reporter = reporter
     trashcan.ignore_missing = False
     trashcan.logger = Mock()
     trashcan.trash('')
     assert [
         call('', '/volume/.Trash-uid')
         ] == reporter.file_has_been_trashed_in_as.mock_calls