Exemple #1
0
    def test_exclude_files_by_patterns(self):
        #Assuming <../tests/foo> is <../User/>
        os.makedirs(Utils.join_path(self.base_path, 'foo', 'bar'))
        open(Utils.join_path(self.base_path, 'foo', 'foo.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
             'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
             'a').close()

        files = Utils.get_files(Utils.join_path(self.base_path, 'foo'))

        #Unfiltered
        self.assertEqual(len(files), 4)
        self.assertListEqual(Utils.exclude_files_by_patterns(files, []), files)
        self.assertListEqual(Utils.exclude_files_by_patterns(files, ['.boo']),
                             files)

        # By extension
        filteredFiles = Utils.exclude_files_by_patterns(files, ['.txt'])

        self.assertEqual(len(filteredFiles), 1)
        self.assertListEqual(
            filteredFiles,
            [Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py')])

        filteredFiles = sorted(Utils.exclude_files_by_patterns(files, ['.py']))
        self.assertEqual(len(filteredFiles), 3)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'bar.txt'),
                Utils.join_path(self.base_path, 'foo', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt')
            ]))

        # By Filename
        filteredFiles = sorted(
            Utils.exclude_files_by_patterns(
                files, [Utils.join_path(self.base_path, 'foo', 'bar.txt')]))

        self.assertEqual(len(filteredFiles), 3)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt')
            ]))

        filteredFiles = sorted(
            Utils.exclude_files_by_patterns(files, [
                Utils.join_path(self.base_path, 'foo', 'bar.txt'),
                Utils.join_path(self.base_path, 'foo', 'foo.txt')
            ]))

        self.assertEqual(len(filteredFiles), 2)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt')
            ]))

        # By folder
        filteredFiles = sorted(
            Utils.exclude_files_by_patterns(
                files, [Utils.join_path(self.base_path, 'foo', 'bar')]))
        self.assertEqual(len(filteredFiles), 2)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'bar.txt'),
                Utils.join_path(self.base_path, 'foo', 'foo.txt')
            ]))

        shutil.rmtree(Utils.join_path(self.base_path, 'foo'))
Exemple #2
0
    def test_exclude_files_by_patterns(self):
        #Assuming <../tests/foo> is <../User/>
        self.create_folder(Utils.join_path(self.base_path, 'foo', 'bar'))
        open(Utils.join_path(self.base_path, 'foo', 'foo.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
             'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
             'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
             'a').close()
        open(Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go'),
             'a').close()

        files = sorted(Utils.get_files(Utils.join_path(self.base_path, 'foo')))

        #Unfiltered
        self.assertEqual(len(files), 6)
        self.assertListEqual(
            sorted(Utils.exclude_files_by_patterns(files, [])), files)
        self.assertListEqual(
            sorted(Utils.exclude_files_by_patterns(files, ['.boo'])), files)

        # By extension
        filteredFiles = Utils.exclude_files_by_patterns(files, ['.txt'])

        self.assertEqual(len(filteredFiles), 3)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
            ]))

        filteredFiles = sorted(Utils.exclude_files_by_patterns(files, ['.py']))
        self.assertEqual(len(filteredFiles), 5)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'bar.txt'),
                Utils.join_path(self.base_path, 'foo', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
            ]))

        # By Filename
        filteredFiles = sorted(
            Utils.exclude_files_by_patterns(
                files, [Utils.join_path(self.base_path, 'foo', 'bar.txt')]))

        self.assertEqual(len(filteredFiles), 5)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
            ]))

        filteredFiles = sorted(
            Utils.exclude_files_by_patterns(files, [
                Utils.join_path(self.base_path, 'foo', 'bar.txt'),
                Utils.join_path(self.base_path, 'foo', 'foo.txt')
            ]))

        self.assertEqual(len(filteredFiles), 4)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
            ]))

        # By folder
        filteredFiles = sorted(
            Utils.exclude_files_by_patterns(
                files, [Utils.join_path(self.base_path, 'foo', 'bar')]))
        self.assertEqual(len(filteredFiles), 2)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'bar.txt'),
                Utils.join_path(self.base_path, 'foo', 'foo.txt'),
            ]))

        # By willcard
        filteredFiles = sorted(
            Utils.exclude_files_by_patterns(
                files, [Utils.join_path(self.base_path, 'foo', '**', '*.go')]))

        self.assertEqual(len(filteredFiles), 4)
        self.assertListEqual(
            filteredFiles,
            sorted([
                Utils.join_path(self.base_path, 'foo', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
                Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py')
            ]))

        self.delete_folder(Utils.join_path(self.base_path, 'foo'))
Exemple #3
0
  def test_exclude_files_by_patterns(self):
    #Assuming <../tests/foo> is <../User/>
    self.create_folder(Utils.join_path(self.base_path, 'foo', 'bar'))
    open(Utils.join_path(self.base_path, 'foo', 'foo.txt'), 'a').close()
    open(Utils.join_path(self.base_path, 'foo', 'bar.txt'), 'a').close()
    open(Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'), 'a').close()
    open(Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'), 'a').close()
    open(Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'), 'a').close()
    open(Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go'), 'a').close()

    files = sorted(Utils.get_files(Utils.join_path(self.base_path, 'foo')))

    #Unfiltered
    self.assertEqual(len(files), 6)
    self.assertListEqual(sorted(Utils.exclude_files_by_patterns(files, [])), files)
    self.assertListEqual(sorted(Utils.exclude_files_by_patterns(files, ['.boo'])), files)

    # By extension
    filteredFiles = Utils.exclude_files_by_patterns(files, ['.txt'])

    self.assertEqual(len(filteredFiles), 3)
    self.assertListEqual(filteredFiles, sorted([
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
    ]))

    filteredFiles = sorted(Utils.exclude_files_by_patterns(files, ['.py']))
    self.assertEqual(len(filteredFiles), 5)
    self.assertListEqual(filteredFiles, sorted([
      Utils.join_path(self.base_path, 'foo', 'bar.txt'),
      Utils.join_path(self.base_path, 'foo', 'foo.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
    ]))

    # By Filename
    filteredFiles = sorted(Utils.exclude_files_by_patterns(files, [
      Utils.join_path(self.base_path, 'foo', 'bar.txt')
    ]))

    self.assertEqual(len(filteredFiles), 5)
    self.assertListEqual(filteredFiles, sorted([
      Utils.join_path(self.base_path, 'foo', 'foo.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
    ]))

    filteredFiles = sorted(Utils.exclude_files_by_patterns(files, [
      Utils.join_path(self.base_path, 'foo', 'bar.txt'),
      Utils.join_path(self.base_path, 'foo', 'foo.txt')
    ]))

    self.assertEqual(len(filteredFiles), 4)
    self.assertListEqual(filteredFiles, sorted([
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'file.go'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'new_file.go')
    ]))

    # By folder
    filteredFiles = sorted(Utils.exclude_files_by_patterns(files, [
      Utils.join_path(self.base_path, 'foo', 'bar')
    ]))
    self.assertEqual(len(filteredFiles), 2)
    self.assertListEqual(filteredFiles, sorted([
      Utils.join_path(self.base_path, 'foo', 'bar.txt'),
      Utils.join_path(self.base_path, 'foo', 'foo.txt'),
    ]))

    # By willcard
    filteredFiles = sorted(Utils.exclude_files_by_patterns(files, [
      Utils.join_path(self.base_path, 'foo', '**', '*.go')
    ]))

    self.assertEqual(len(filteredFiles), 4)
    self.assertListEqual(filteredFiles, sorted([
      Utils.join_path(self.base_path, 'foo', 'foo.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.txt'),
      Utils.join_path(self.base_path, 'foo', 'bar', 'foo.py')
    ]))


    self.delete_folder(Utils.join_path(self.base_path, 'foo'))