Beispiel #1
0
  def test_filter_files_by_patterns(self):
    #Assuming <../tests/foo> is <../User/>
    base_path = Helper.join_path((self.base_path, 'foo'))

    os.makedirs(Helper.join_path((self.base_path, 'foo', 'bar')))
    open(Helper.join_path((base_path, 'foo.txt')), 'a').close()
    open(Helper.join_path((base_path, 'bar.rb')), 'a').close()
    open(Helper.join_path((base_path, 'bar', 'foo.txt')), 'a').close()
    open(Helper.join_path((base_path, 'bar', 'foo.py')), 'a').close()


    files = Helper.get_files(base_path)
    patterns = Helper.parse_patterns(['.rb', '.py'], base_path)
    expected = sorted([
      Helper.join_path((base_path, 'bar.rb')),
      Helper.join_path((base_path, 'bar', 'foo.py'))
    ])
    filtered_files = sorted(Helper.filter_files_by_patterns(files, patterns))

    self.assertEqual(len(filtered_files), 2)
    self.assertListEqual(filtered_files, expected)

    patterns = Helper.parse_patterns(['bar/foo.txt'], base_path)
    expected = [Helper.join_path((base_path, 'bar', 'foo.txt'))]
    filtered_files = sorted(Helper.filter_files_by_patterns(files, patterns))

    self.assertEqual(len(filtered_files), 1)
    self.assertListEqual(filtered_files, expected)

    shutil.rmtree(Helper.join_path((self.base_path, 'foo')))
Beispiel #2
0
    def test_filter_files_by_patterns(self):
        #Assuming <../tests/foo> is <../User/>
        base_path = Helper.join_path((self.base_path, 'foo'))

        os.makedirs(Helper.join_path((self.base_path, 'foo', 'bar')))
        open(Helper.join_path((base_path, 'foo.txt')), 'a').close()
        open(Helper.join_path((base_path, 'bar.rb')), 'a').close()
        open(Helper.join_path((base_path, 'bar', 'foo.txt')), 'a').close()
        open(Helper.join_path((base_path, 'bar', 'foo.py')), 'a').close()

        files = Helper.get_files(base_path)
        patterns = Helper.parse_patterns(['.rb', '.py'], base_path)
        expected = sorted([
            Helper.join_path((base_path, 'bar.rb')),
            Helper.join_path((base_path, 'bar', 'foo.py'))
        ])
        filtered_files = sorted(
            Helper.filter_files_by_patterns(files, patterns))

        self.assertEqual(len(filtered_files), 2)
        self.assertListEqual(filtered_files, expected)

        patterns = Helper.parse_patterns(['bar/foo.txt'], base_path)
        expected = [Helper.join_path((base_path, 'bar', 'foo.txt'))]
        filtered_files = sorted(
            Helper.filter_files_by_patterns(files, patterns))

        self.assertEqual(len(filtered_files), 1)
        self.assertListEqual(filtered_files, expected)

        shutil.rmtree(Helper.join_path((self.base_path, 'foo')))
Beispiel #3
0
    def test_get_files(self):
        with self.assertRaises(TypeError):
            Helper.get_files()
        self.assertListEqual(Helper.get_files('t'), [])
        self.assertListEqual(Helper.get_files(1234), [])
        self.assertListEqual(Helper.get_files(1234), [])
        self.assertGreater(len(Helper.get_files(self.base_path)), 0)

        #Create a test folder structure
        os.makedirs(Helper.join_path((self.base_path, 'hello', 'world')))
        open(Helper.join_path((self.base_path, 'hello', 'foo.txt')),
             'a').close()
        open(Helper.join_path((self.base_path, 'hello', 'bar.txt')),
             'a').close()
        open(Helper.join_path((self.base_path, 'hello', 'world', 'foo.txt')),
             'a').close()
        allFiles = sorted([
            Helper.join_path((self.base_path, 'hello', 'bar.txt')),
            Helper.join_path((self.base_path, 'hello', 'foo.txt')),
            Helper.join_path((self.base_path, 'hello', 'world', 'foo.txt'))
        ])
        files = sorted(
            Helper.get_files(Helper.join_path((self.base_path, 'hello'))))
        self.assertEqual(len(files), 3)
        self.assertListEqual(files, allFiles)
        shutil.rmtree(Helper.join_path((self.base_path, 'hello')))
Beispiel #4
0
  def test_get_files(self):
    with self.assertRaises(TypeError): Helper.get_files()
    self.assertListEqual(Helper.get_files('t'), [])
    self.assertListEqual(Helper.get_files(1234), [])
    self.assertListEqual(Helper.get_files(1234), [])
    self.assertGreater(len(Helper.get_files(self.base_path)), 0)

    #Create a test folder structure
    os.makedirs(Helper.join_path((self.base_path, 'hello', 'world')))
    open(Helper.join_path((self.base_path, 'hello', 'foo.txt')), 'a').close()
    open(Helper.join_path((self.base_path, 'hello', 'bar.txt')), 'a').close()
    open(Helper.join_path((self.base_path, 'hello', 'world', 'foo.txt')), 'a').close()
    allFiles = sorted([
      Helper.join_path((self.base_path, 'hello', 'bar.txt')),
      Helper.join_path((self.base_path, 'hello', 'foo.txt')),
      Helper.join_path((self.base_path, 'hello', 'world', 'foo.txt'))
    ])
    files = sorted(Helper.get_files(Helper.join_path((self.base_path, 'hello'))))
    self.assertEqual(len(files), 3)
    self.assertListEqual(files, allFiles)
    shutil.rmtree(Helper.join_path((self.base_path, 'hello')))
Beispiel #5
0
  def test_exclude_files_by_patterns(self):
    #Assuming <../tests/foo> is <../User/>
    os.makedirs(Helper.join_path((self.base_path, 'foo', 'bar')))
    open(Helper.join_path((self.base_path, 'foo', 'foo.txt')), 'a').close()
    open(Helper.join_path((self.base_path, 'foo', 'bar.txt')), 'a').close()
    open(Helper.join_path((self.base_path, 'foo', 'bar', 'foo.txt')), 'a').close()
    open(Helper.join_path((self.base_path, 'foo', 'bar', 'foo.py')), 'a').close()

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

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

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

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

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

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

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

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

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

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

    shutil.rmtree(Helper.join_path((self.base_path, 'foo')))
Beispiel #6
0
    def test_exclude_files_by_patterns(self):
        #Assuming <../tests/foo> is <../User/>
        os.makedirs(Helper.join_path((self.base_path, 'foo', 'bar')))
        open(Helper.join_path((self.base_path, 'foo', 'foo.txt')), 'a').close()
        open(Helper.join_path((self.base_path, 'foo', 'bar.txt')), 'a').close()
        open(Helper.join_path((self.base_path, 'foo', 'bar', 'foo.txt')),
             'a').close()
        open(Helper.join_path((self.base_path, 'foo', 'bar', 'foo.py')),
             'a').close()

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

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

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

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

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

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

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

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

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

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

        shutil.rmtree(Helper.join_path((self.base_path, 'foo')))