Пример #1
0
 def test_home_path(self):
   home_path = os.path.expanduser('~')
   self.assertEqual(Utils.join_path(home_path, 'foo'), Utils.get_home_path('foo'))
   self.assertEqual(home_path, Utils.get_home_path())
   #Wrong Cases
   self.assertEqual(home_path, Utils.get_home_path(None))
   self.assertEqual(home_path, Utils.get_home_path(1234))
Пример #2
0
  def test_decode_path(self):
    self.assertIsNone(Utils.decode_path(""))
    with self.assertRaises(TypeError): Utils.decode_path()

    path = '/some/path with spaces/to/file.txt'
    encoded_path = '%2Fsome%2Fpath%20with%20spaces%2Fto%2Ffile.txt'
    self.assertEqual(Utils.decode_path(encoded_path), path.replace('/', Utils.os_separator()))
Пример #3
0
  def test_encode_path(self):
    self.assertIsNone(Utils.encode_path(""))
    with self.assertRaises(TypeError): Utils.encode_path()

    path = '/some/path with spaces/to/file.txt'
    encoded_path = '%2Fsome%2Fpath%20with%20spaces%2Fto%2Ffile.txt'
    self.assertNotEqual(Utils.encode_path(path), '/some/path%20with%20spaces/to/file.txt')
    self.assertEqual(Utils.encode_path(path), encoded_path)
Пример #4
0
 def test_home_path(self):
     home_path = os.path.expanduser('~')
     self.assertEqual(Utils.join_path(home_path, 'foo'),
                      Utils.get_home_path('foo'))
     self.assertEqual(home_path, Utils.get_home_path())
     #Wrong Cases
     self.assertEqual(home_path, Utils.get_home_path(None))
     self.assertEqual(home_path, Utils.get_home_path(1234))
Пример #5
0
  def test_create_empty_file(self):
    test_path = Utils.join_path(os.getcwd(), 'empty_file.txt')

    self.assertFalse(os.path.exists(test_path))
    Utils.create_empty_file(test_path)
    self.assertTrue(os.path.exists(test_path))
    self.assertEqual(os.path.getsize(test_path), 0)
    os.remove(test_path)
    self.assertFalse(os.path.exists(test_path))
Пример #6
0
    def test_decode_path(self):
        self.assertIsNone(Utils.decode_path(""))
        with self.assertRaises(TypeError):
            Utils.decode_path()

        path = '/some/path with spaces/to/file.txt'
        encoded_path = '%2Fsome%2Fpath%20with%20spaces%2Fto%2Ffile.txt'
        self.assertEqual(Utils.decode_path(encoded_path),
                         path.replace('/', Utils.os_separator()))
Пример #7
0
    def test_parse_to_os(self):
        paths = ['something/path\\to/test', 'another\\something/path\\to/test']
        expected_paths = [
            Utils.join_path('something', 'path', 'to', 'test'),
            Utils.join_path('another', 'something', 'path', 'to', 'test')
        ]

        result = Utils.parse_to_os(paths)
        self.assertEqual(result, expected_paths)
Пример #8
0
    def test_create_empty_file(self):
        test_path = Utils.join_path(os.getcwd(), 'empty_file.txt')

        self.assertFalse(os.path.exists(test_path))
        Utils.create_empty_file(test_path)
        self.assertTrue(os.path.exists(test_path))
        self.assertEqual(os.path.getsize(test_path), 0)
        os.remove(test_path)
        self.assertFalse(os.path.exists(test_path))
Пример #9
0
    def test_encode_path(self):
        self.assertIsNone(Utils.encode_path(""))
        with self.assertRaises(TypeError):
            Utils.encode_path()

        path = '/some/path with spaces/to/file.txt'
        encoded_path = '%2Fsome%2Fpath%20with%20spaces%2Fto%2Ffile.txt'
        self.assertNotEqual(Utils.encode_path(path),
                            '/some/path%20with%20spaces/to/file.txt')
        self.assertEqual(Utils.encode_path(path), encoded_path)
Пример #10
0
  def test_parse_to_os(self):
    paths = [
      'something/path\\to/test',
      'another\\something/path\\to/test'
    ]
    expected_paths = [
      Utils.join_path('something', 'path', 'to', 'test'),
      Utils.join_path('another', 'something', 'path', 'to', 'test')
    ]

    result = Utils.parse_to_os(paths)
    self.assertEqual(result, expected_paths)
Пример #11
0
 def test_exists_path(self):
   self.assertFalse(Utils.exists_path(test_file_path, True))
   with self.assertRaises(TypeError): Utils.exists_path()
   with self.assertRaises(TypeError): Utils.exists_path(isFolder=True)
   self.assertFalse(Utils.exists_path(self.base_path))
   self.assertTrue(Utils.exists_path(test_file_path))
   self.assertTrue(Utils.exists_path(self.base_path, True))
Пример #12
0
    def test_is_file_extension(self):
        success_cases = [
            '.DStore', '.DStore?', '.jpg', '.png', '.txt', '.Trashes'
        ]

        wrong_cases = [
            'SublimeLinter', 'SublieCodeIntel', 'file.jpg', 'file.file.png',
            '_.txt'
        ]

        for s in success_cases:
            self.assertTrue(Utils.is_file_extension(s))

        for w in wrong_cases:
            self.assertFalse(Utils.is_file_extension(w))
Пример #13
0
 def test_exists_path(self):
     self.assertFalse(Utils.exists_path(test_file_path, True))
     with self.assertRaises(TypeError):
         Utils.exists_path()
     with self.assertRaises(TypeError):
         Utils.exists_path(isFolder=True)
     self.assertFalse(Utils.exists_path(self.base_path))
     self.assertTrue(Utils.exists_path(test_file_path))
     self.assertTrue(Utils.exists_path(self.base_path, True))
Пример #14
0
    def test_parse_patterns(self):
        patterns = ['.txt', '.py', 'foo', 'bar.py']
        expected = sorted([
            '.txt', '.py',
            Utils.join_path(self.base_path, 'foo'),
            Utils.join_path(self.base_path, 'bar.py')
        ])

        result = sorted(Utils.parse_patterns(patterns, self.base_path))
        self.assertListEqual(result, expected)

        patterns = sorted(['.foo', '.DStore', '.file.name'])
        expected = sorted(
            ['.foo', '.DStore',
             Utils.join_path(self.base_path, '.file.name')])
        result = sorted(Utils.parse_patterns(patterns, self.base_path))
        self.assertListEqual(result, expected)
Пример #15
0
    def test_merge_lists(self):
        base_list = ['a', 'b']
        update_list = ['b', 'c']

        result = Utils.merge_lists([], [])
        self.assertListEqual(result, [])

        result = Utils.merge_lists(sorted(base_list), [])
        self.assertListEqual(sorted(result), sorted(base_list))

        result = Utils.merge_lists([], sorted(base_list))
        self.assertListEqual(sorted(result), sorted(base_list))

        result = Utils.merge_lists(sorted(base_list), sorted(update_list))
        self.assertListEqual(sorted(result), ['a', 'b', 'c'])

        result = Utils.merge_lists([], ['a'], ['b'], ['c'], ['d'])
        self.assertListEqual(sorted(result), ['a', 'b', 'c', 'd'])
Пример #16
0
  def test_merge_objects(self):
    base_object = {'a': 'b', 'b': 'a'}
    update_object = {'a': 'a', 'b': 'b', 'c': 'c'}

    result = Utils.merge_objects({}, {})
    self.assertDictEqual(result, {})

    result = Utils.merge_objects(base_object, {})
    self.assertDictEqual(result, base_object)

    result = Utils.merge_objects({}, base_object)
    self.assertDictEqual(result, base_object)

    result = Utils.merge_objects(base_object, update_object)
    self.assertDictEqual(result, update_object)

    result = Utils.merge_objects({}, {'a': 1}, {'b': 2}, {'c': 3})
    self.assertDictEqual(result, {'a': 1, 'b': 2, 'c': 3})
Пример #17
0
  def test_merge_lists(self):
    base_list = ['a', 'b']
    update_list = ['b', 'c']

    result = Utils.merge_lists([], [])
    self.assertListEqual(result, [])

    result = Utils.merge_lists(sorted(base_list), [])
    self.assertListEqual(sorted(result), sorted(base_list))

    result = Utils.merge_lists([], sorted(base_list))
    self.assertListEqual(sorted(result), sorted(base_list))

    result = Utils.merge_lists(sorted(base_list), sorted(update_list))
    self.assertListEqual(sorted(result), ['a', 'b', 'c'])

    result = Utils.merge_lists([], ['a'], ['b'], ['c'], ['d'])
    self.assertListEqual(sorted(result), ['a', 'b', 'c', 'd'])
Пример #18
0
    def test_merge_objects(self):
        base_object = {'a': 'b', 'b': 'a'}
        update_object = {'a': 'a', 'b': 'b', 'c': 'c'}

        result = Utils.merge_objects({}, {})
        self.assertDictEqual(result, {})

        result = Utils.merge_objects(base_object, {})
        self.assertDictEqual(result, base_object)

        result = Utils.merge_objects({}, base_object)
        self.assertDictEqual(result, base_object)

        result = Utils.merge_objects(base_object, update_object)
        self.assertDictEqual(result, update_object)

        result = Utils.merge_objects({}, {'a': 1}, {'b': 2}, {'c': 3})
        self.assertDictEqual(result, {'a': 1, 'b': 2, 'c': 3})
Пример #19
0
  def test_is_file_extension(self):
    success_cases = [
      '.DStore',
      '.DStore?',
      '.jpg',
      '.png',
      '.txt',
      '.Trashes'
    ]

    wrong_cases = [
      'SublimeLinter',
      'SublieCodeIntel',
      'file.jpg',
      'file.file.png',
      '_.txt'
    ]

    for s in success_cases:
      self.assertTrue(Utils.is_file_extension(s))

    for w in wrong_cases:
      self.assertFalse(Utils.is_file_extension(w))
Пример #20
0
  def test_match_with_filename(self):
    success_case = Utils.join_path(self.base_path, 'hello', 'world', 'file.foo')
    file_path = success_case

    wrong_cases = [
      Utils.join_path(self.base_path, 'hello', 'file.foo'),
      Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
      Utils.join_path(self.base_path, 'hello', '.txt'),
      Utils.join_path(self.base_path, 'hello', 'any_name', 'file.foo'),
      Utils.join_path(self.base_path, 'hello', 'world', 'file', '.foo')
    ]

    self.assertTrue(Utils.match_with_filename(success_case, file_path))

    for w in wrong_cases:
      self.assertFalse(Utils.match_with_filename(w, file_path))
Пример #21
0
    def test_match_with_filename(self):
        success_case = Utils.join_path(self.base_path, 'hello', 'world',
                                       'file.foo')
        file_path = success_case

        wrong_cases = [
            Utils.join_path(self.base_path, 'hello', 'file.foo'),
            Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', '.txt'),
            Utils.join_path(self.base_path, 'hello', 'any_name', 'file.foo'),
            Utils.join_path(self.base_path, 'hello', 'world', 'file', '.foo')
        ]

        self.assertTrue(Utils.match_with_filename(success_case, file_path))

        for w in wrong_cases:
            self.assertFalse(Utils.match_with_filename(w, file_path))
Пример #22
0
    def test_get_file_content(self):
        test_path = Utils.join_path(os.getcwd(), 'empty_file.json')

        Utils.create_empty_file(test_path)
        Utils.write_to_file(test_path, 'Some content')
        file_content = Utils.get_file_content(test_path)

        self.assertEqual(file_content, 'Some content')

        os.remove(test_path)
        self.assertFalse(os.path.exists(test_path))
Пример #23
0
  def test_get_file_content(self):
    test_path = Utils.join_path(os.getcwd(), 'empty_file.json')

    Utils.create_empty_file(test_path)
    Utils.write_to_file(test_path,'Some content')
    file_content = Utils.get_file_content(test_path)

    self.assertEqual(file_content, 'Some content')

    os.remove(test_path)
    self.assertFalse(os.path.exists(test_path))
Пример #24
0
  def test_parse_patterns(self):
    patterns = ['.txt', '.py', 'foo', 'bar.py', '*.go']
    expected = sorted([
      '.txt',
      '.py',
      Utils.join_path(self.base_path, 'foo'),
      Utils.join_path(self.base_path, 'bar.py'),
      Utils.join_path(self.base_path, '*.go')
    ])

    result = sorted(Utils.parse_patterns(patterns, self.base_path))
    self.assertListEqual(result, expected)

    patterns = sorted(['.foo', '.DStore', '.file.name', '**/*.txt'])
    expected = sorted([
      '.foo',
      '.DStore',
      Utils.join_path(self.base_path, '.file.name'),
      Utils.join_path(self.base_path, '**/*.txt')
    ])
    result = sorted(Utils.parse_patterns(patterns, self.base_path))
    self.assertListEqual(result, expected)
Пример #25
0
  def test_match_with_willcard(self):
    pattern = Utils.join_path(self.base_path, 'packages', 'Package Control.cache*')
    success_cases = [
      Utils.join_path(self.base_path, 'packages', 'Package Control.cache123123'),
      Utils.join_path(self.base_path, 'packages', 'Package Control.cache'),
      Utils.join_path(self.base_path, 'packages', 'Package Control.cached'),
      Utils.join_path(self.base_path, 'packages', 'Package Control.cache-any-pattern')
    ]

    wrong_cases = [
      Utils.join_path(self.base_path, 'packages', 'Package Cntrol.cache123123'),
      Utils.join_path(self.base_path, 'packages', 'Package Control.cach123123'),
      Utils.join_path(self.base_path, 'packages', 'Package.cache'),
      Utils.join_path(self.base_path, 'packages', 'Package', '.cache'),
      Utils.join_path(self.base_path, 'packages', 'Package', ' Control', '.cache'),
      Utils.join_path(self.base_path, 'packages', 'any', 'directory', 'Package Control.cache')
    ]

    for w in wrong_cases:
      self.assertFalse(Utils.match_with_willcard(w, pattern))

    for s in success_cases:
      self.assertTrue(Utils.match_with_willcard(s, pattern))
Пример #26
0
    def test_write_to_file(self):
        test_filename = 'empty_file.txt'
        message = 'file content'
        file_path = Utils.join_path(os.getcwd(), test_filename)

        self.assertFalse(Utils.exists_path(file_path))
        Utils.write_to_file(file_path, message)

        self.assertTrue(os.path.exists(file_path))

        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8').find(message), 0)

        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        file_path = Utils.join_path(os.getcwd(), 'some_path', 'sub_path',
                                    test_filename)

        Utils.write_to_file(file_path, message)
        self.assertTrue(os.path.exists(file_path))
        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8').find(message), 0)
        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        self.create_folder(Utils.join_path(os.getcwd(), 'some_path'))

        file_path = Utils.join_path(os.getcwd(), 'some_path', 'sub_path',
                                    test_filename)

        Utils.write_to_file(file_path, message)
        self.assertTrue(os.path.exists(file_path))
        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8').find(message), 0)
        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        Utils.write_to_file(file_path, {"some": "content"},
                            action='a+',
                            as_json=True)
        self.assertTrue(os.path.exists(file_path))
        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8'), '{"some": "content"}')

        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        self.delete_folder(Utils.join_path(os.getcwd(), 'some_path'))
Пример #27
0
  def test_match_with_extension(self):
    pattern = '.py'

    success_cases = [
      Utils.join_path(self.base_path, 'hello', '____foo', 'other', '.py'),
      Utils.join_path(self.base_path, 'hello', 'file.py'),
      Utils.join_path(self.base_path, 'hello', '.py'),
      Utils.join_path(self.base_path, 'hello', '...', 'another.python', 'file.py'),
      Utils.join_path(self.base_path, 'hello', '_file.python.___.__.py'),
      Utils.join_path(self.base_path, 'hello', 'other', 'folder', 'dot', 'py.py')
    ]

    wrong_cases = [
      Utils.join_path(self.base_path, 'hello', 'file.foo'),
      Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
      Utils.join_path(self.base_path, 'hello', '.txt'),
      Utils.join_path(self.base_path, 'hello', 'file.pypy'),
      Utils.join_path(self.base_path, 'hello', 'file.python'),
      Utils.join_path(self.base_path, 'hello', 'file.otherpy'),
      Utils.join_path(self.base_path, 'hello', '_.py', 'file.otherpy')
    ]

    for s in success_cases:
      self.assertTrue(Utils.match_with_extension(s, pattern))

    for w in wrong_cases:
      self.assertFalse(Utils.match_with_extension(w, pattern))
Пример #28
0
  def test_write_to_file(self):
    test_filename = 'empty_file.txt'
    message = 'file content'
    file_path = Utils.join_path(os.getcwd(), test_filename)

    self.assertFalse(Utils.exists_path(file_path))
    Utils.write_to_file(file_path, message)

    self.assertTrue(os.path.exists(file_path))

    with open(file_path, 'rb') as f:
      self.assertEqual(f.read().decode('utf-8').find(message), 0)

    os.remove(file_path)
    self.assertFalse(os.path.exists(file_path))

    file_path = Utils.join_path(os.getcwd(), 'some_path', 'sub_path', test_filename)

    Utils.write_to_file(file_path, message)
    self.assertTrue(os.path.exists(file_path))
    with open(file_path, 'rb') as f:
      self.assertEqual(f.read().decode('utf-8').find(message), 0)
    os.remove(file_path)
    self.assertFalse(os.path.exists(file_path))

    self.create_folder(Utils.join_path(os.getcwd(), 'some_path'))

    file_path = Utils.join_path(os.getcwd(), 'some_path', 'sub_path', test_filename)

    Utils.write_to_file(file_path, message)
    self.assertTrue(os.path.exists(file_path))
    with open(file_path, 'rb') as f:
      self.assertEqual(f.read().decode('utf-8').find(message), 0)
    os.remove(file_path)
    self.assertFalse(os.path.exists(file_path))

    Utils.write_to_file(file_path, {"some": "content"}, action='a+', as_json=True)
    self.assertTrue(os.path.exists(file_path))
    with open(file_path, 'rb') as f:
      self.assertEqual(f.read().decode('utf-8'), '{"some": "content"}')

    os.remove(file_path)
    self.assertFalse(os.path.exists(file_path))

    self.delete_folder(Utils.join_path(os.getcwd(), 'some_path'))
Пример #29
0
    def test_match_with_folder(self):
        success_cases = [
            Utils.join_path(self.base_path, 'hello', 'foo.txt'),
            Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', 'world', 'anything.py'),
            Utils.join_path(self.base_path, 'hello', '.txt'),
            Utils.join_path(self.base_path, 'hello', '.py')
        ]

        wrong_cases = [
            Utils.join_path(self.base_path, 'hello2', 'foo.txt'),
            Utils.join_path(self.base_path, 'hello2', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello2', 'world', 'anything.py'),
            Utils.join_path(self.base_path, 'hello2', '.txt'),
            Utils.join_path(self.base_path, 'hello2', '.py')
        ]

        self.assertFalse(
            Utils.match_with_folder(self.base_path, self.base_path))

        for s in success_cases:
            self.assertTrue(
                Utils.match_with_folder(
                    s, Utils.join_path(self.base_path, 'hello')))

        for w in wrong_cases:
            self.assertFalse(
                Utils.match_with_folder(
                    w, Utils.join_path(self.base_path, 'hello')))
Пример #30
0
 def test_os_separator(self):
     self.assertNotEqual(os.sep, '')
     self.assertEqual(os.sep, Utils.os_separator())
Пример #31
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'))
Пример #32
0
 def test_difference(self):
     l = Utils.get_difference([1, 2, 3, 4], [1, 2, 3])
     self.assertEqual(len(l), 1)
     self.assertEqual(l[0], 4)
Пример #33
0
    def test_match_with_extension(self):
        pattern = '.py'

        success_cases = [
            Utils.join_path(self.base_path, 'hello', '____foo', 'other',
                            '.py'),
            Utils.join_path(self.base_path, 'hello', 'file.py'),
            Utils.join_path(self.base_path, 'hello', '.py'),
            Utils.join_path(self.base_path, 'hello', '...', 'another.python',
                            'file.py'),
            Utils.join_path(self.base_path, 'hello', '_file.python.___.__.py'),
            Utils.join_path(self.base_path, 'hello', 'other', 'folder', 'dot',
                            'py.py')
        ]

        wrong_cases = [
            Utils.join_path(self.base_path, 'hello', 'file.foo'),
            Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', '.txt'),
            Utils.join_path(self.base_path, 'hello', 'file.pypy'),
            Utils.join_path(self.base_path, 'hello', 'file.python'),
            Utils.join_path(self.base_path, 'hello', 'file.otherpy'),
            Utils.join_path(self.base_path, 'hello', '_.py', 'file.otherpy')
        ]

        for s in success_cases:
            self.assertTrue(Utils.match_with_extension(s, pattern))

        for w in wrong_cases:
            self.assertFalse(Utils.match_with_extension(w, pattern))
Пример #34
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'))
Пример #35
0
  def test_filter_files_by_patterns(self):
    #Assuming <../tests/foo> is <../User/>
    base_path = Utils.join_path(self.base_path, 'foo')

    self.create_folder(Utils.join_path(self.base_path, 'foo', 'bar'))
    open(Utils.join_path(base_path, 'foo.txt'), 'a').close()
    open(Utils.join_path(base_path, 'bar.rb'), 'a').close()
    open(Utils.join_path(base_path, 'bar', 'foo.txt'), 'a').close()
    open(Utils.join_path(base_path, 'bar', 'foo.py'), 'a').close()
    open(Utils.join_path(base_path, 'bar', 'main.go'), 'a').close()
    open(Utils.join_path(base_path, 'bar', 'other.go'), 'a').close()

    files = Utils.get_files(base_path)
    patterns = Utils.parse_patterns([
      '.rb',
      '.py',
      Utils.join_path('bar', '*.go')
    ], base_path)

    expected = sorted([
      Utils.join_path(base_path, 'bar.rb'),
      Utils.join_path(base_path, 'bar', 'foo.py'),
      Utils.join_path(base_path, 'bar', 'main.go'),
      Utils.join_path(base_path, 'bar', 'other.go')
    ])

    filtered_files = sorted(Utils.filter_files_by_patterns(files, patterns))

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

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

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

    self.delete_folder(Utils.join_path(self.base_path, 'foo'))
Пример #36
0
    def test_match_with_willcard(self):
        pattern = Utils.join_path(self.base_path, 'packages',
                                  'Package Control.cache*')
        success_cases = [
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cache123123'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cache'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cached'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cache-any-pattern')
        ]

        wrong_cases = [
            Utils.join_path(self.base_path, 'packages',
                            'Package Cntrol.cache123123'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cach123123'),
            Utils.join_path(self.base_path, 'packages', 'Package.cache'),
            Utils.join_path(self.base_path, 'packages', 'Package', '.cache'),
            Utils.join_path(self.base_path, 'packages', 'Package', ' Control',
                            '.cache'),
            Utils.join_path(self.base_path, 'packages', 'any', 'directory',
                            'Package Control.cache')
        ]

        for w in wrong_cases:
            self.assertFalse(Utils.match_with_willcard(w, pattern))

        for s in success_cases:
            self.assertTrue(Utils.match_with_willcard(s, pattern))
Пример #37
0
 def test_join_path(self):
     self.assertIsNotNone(Utils.join_path(''))
     self.assertIsNotNone(Utils.join_path('123', '1234'))
Пример #38
0
    def test_filter_files_by_patterns(self):
        #Assuming <../tests/foo> is <../User/>
        base_path = Utils.join_path(self.base_path, 'foo')

        self.create_folder(Utils.join_path(self.base_path, 'foo', 'bar'))
        open(Utils.join_path(base_path, 'foo.txt'), 'a').close()
        open(Utils.join_path(base_path, 'bar.rb'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'foo.txt'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'foo.py'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'main.go'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'other.go'), 'a').close()

        files = Utils.get_files(base_path)
        patterns = Utils.parse_patterns(
            ['.rb', '.py', Utils.join_path('bar', '*.go')], base_path)

        expected = sorted([
            Utils.join_path(base_path, 'bar.rb'),
            Utils.join_path(base_path, 'bar', 'foo.py'),
            Utils.join_path(base_path, 'bar', 'main.go'),
            Utils.join_path(base_path, 'bar', 'other.go')
        ])

        filtered_files = sorted(Utils.filter_files_by_patterns(
            files, patterns))

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

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

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

        self.delete_folder(Utils.join_path(self.base_path, 'foo'))
Пример #39
0
 def test_os_separator(self):
   self.assertNotEqual(os.sep, '')
   self.assertEqual(os.sep, Utils.os_separator())
Пример #40
0
 def test_difference(self):
   l = Utils.get_difference([1, 2, 3, 4], [1, 2, 3])
   self.assertEqual(len(l), 1)
   self.assertEqual(l[0], 4)
Пример #41
0
 def test_join_path(self):
   self.assertIsNotNone(Utils.join_path(''))
   self.assertIsNotNone(Utils.join_path('123', '1234'))
Пример #42
0
  def test_get_files(self):
    with self.assertRaises(TypeError): Utils.get_files()
    self.assertListEqual(Utils.get_files('t'), [])
    self.assertListEqual(Utils.get_files(1234), [])
    self.assertListEqual(Utils.get_files(1234), [])
    self.assertGreater(len(Utils.get_files(self.base_path)), 0)

    #Create a test folder structure
    self.create_folder(Utils.join_path(self.base_path, 'hello', 'world'))
    open(Utils.join_path(self.base_path, 'hello', 'foo.txt'), 'a').close()
    open(Utils.join_path(self.base_path, 'hello', 'bar.txt'), 'a').close()
    open(Utils.join_path(self.base_path, 'hello', 'world', 'foo.txt'), 'a').close()
    allFiles = sorted([
      Utils.join_path(self.base_path, 'hello', 'bar.txt'),
      Utils.join_path(self.base_path, 'hello', 'foo.txt'),
      Utils.join_path(self.base_path, 'hello', 'world', 'foo.txt')
    ])
    files = sorted(Utils.get_files(Utils.join_path(self.base_path, 'hello')))
    self.assertEqual(len(files), 3)
    self.assertListEqual(files, allFiles)
    self.delete_folder(Utils.join_path(self.base_path, 'hello'))
Пример #43
0
    def test_filter_files_by_patterns(self):
        #Assuming <../tests/foo> is <../User/>
        base_path = Utils.join_path(self.base_path, 'foo')

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

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

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

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

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

        shutil.rmtree(Utils.join_path(self.base_path, 'foo'))
Пример #44
0
class TestUtils(TestCase):
    base_path = Utils.join_path(os.getcwd(), 'tests')

    def create_folder(self, path):
        self.delete_folder(path)
        os.makedirs(path)

    def delete_folder(self, path):
        if os.path.exists(path):
            shutil.rmtree(path)

    def test_merge_objects(self):
        base_object = {'a': 'b', 'b': 'a'}
        update_object = {'a': 'a', 'b': 'b', 'c': 'c'}

        result = Utils.merge_objects({}, {})
        self.assertDictEqual(result, {})

        result = Utils.merge_objects(base_object, {})
        self.assertDictEqual(result, base_object)

        result = Utils.merge_objects({}, base_object)
        self.assertDictEqual(result, base_object)

        result = Utils.merge_objects(base_object, update_object)
        self.assertDictEqual(result, update_object)

        result = Utils.merge_objects({}, {'a': 1}, {'b': 2}, {'c': 3})
        self.assertDictEqual(result, {'a': 1, 'b': 2, 'c': 3})

    def test_merge_lists(self):
        base_list = ['a', 'b']
        update_list = ['b', 'c']

        result = Utils.merge_lists([], [])
        self.assertListEqual(result, [])

        result = Utils.merge_lists(sorted(base_list), [])
        self.assertListEqual(sorted(result), sorted(base_list))

        result = Utils.merge_lists([], sorted(base_list))
        self.assertListEqual(sorted(result), sorted(base_list))

        result = Utils.merge_lists(sorted(base_list), sorted(update_list))
        self.assertListEqual(sorted(result), ['a', 'b', 'c'])

        result = Utils.merge_lists([], ['a'], ['b'], ['c'], ['d'])
        self.assertListEqual(sorted(result), ['a', 'b', 'c', 'd'])

    def test_difference(self):
        l = Utils.get_difference([1, 2, 3, 4], [1, 2, 3])
        self.assertEqual(len(l), 1)
        self.assertEqual(l[0], 4)

    def test_home_path(self):
        home_path = os.path.expanduser('~')
        self.assertEqual(Utils.join_path(home_path, 'foo'),
                         Utils.get_home_path('foo'))
        self.assertEqual(home_path, Utils.get_home_path())
        #Wrong Cases
        self.assertEqual(home_path, Utils.get_home_path(None))
        self.assertEqual(home_path, Utils.get_home_path(1234))

    def test_exists_path(self):
        self.assertFalse(Utils.exists_path(test_file_path, True))
        with self.assertRaises(TypeError):
            Utils.exists_path()
        with self.assertRaises(TypeError):
            Utils.exists_path(isFolder=True)
        self.assertFalse(Utils.exists_path(self.base_path))
        self.assertTrue(Utils.exists_path(test_file_path))
        self.assertTrue(Utils.exists_path(self.base_path, True))

    def test_join_path(self):
        self.assertIsNotNone(Utils.join_path(''))
        self.assertIsNotNone(Utils.join_path('123', '1234'))

    def test_get_files(self):
        with self.assertRaises(TypeError):
            Utils.get_files()
        self.assertListEqual(Utils.get_files('t'), [])
        self.assertListEqual(Utils.get_files(1234), [])
        self.assertListEqual(Utils.get_files(1234), [])
        self.assertGreater(len(Utils.get_files(self.base_path)), 0)

        #Create a test folder structure
        self.create_folder(Utils.join_path(self.base_path, 'hello', 'world'))
        open(Utils.join_path(self.base_path, 'hello', 'foo.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'hello', 'bar.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'hello', 'world', 'foo.txt'),
             'a').close()
        allFiles = sorted([
            Utils.join_path(self.base_path, 'hello', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', 'foo.txt'),
            Utils.join_path(self.base_path, 'hello', 'world', 'foo.txt')
        ])
        files = sorted(
            Utils.get_files(Utils.join_path(self.base_path, 'hello')))
        self.assertEqual(len(files), 3)
        self.assertListEqual(files, allFiles)
        self.delete_folder(Utils.join_path(self.base_path, 'hello'))

    def test_match_with_folder(self):
        success_cases = [
            Utils.join_path(self.base_path, 'hello', 'foo.txt'),
            Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', 'world', 'anything.py'),
            Utils.join_path(self.base_path, 'hello', '.txt'),
            Utils.join_path(self.base_path, 'hello', '.py')
        ]

        wrong_cases = [
            Utils.join_path(self.base_path, 'hello2', 'foo.txt'),
            Utils.join_path(self.base_path, 'hello2', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello2', 'world', 'anything.py'),
            Utils.join_path(self.base_path, 'hello2', '.txt'),
            Utils.join_path(self.base_path, 'hello2', '.py')
        ]

        self.assertFalse(
            Utils.match_with_folder(self.base_path, self.base_path))

        for s in success_cases:
            self.assertTrue(
                Utils.match_with_folder(
                    s, Utils.join_path(self.base_path, 'hello')))

        for w in wrong_cases:
            self.assertFalse(
                Utils.match_with_folder(
                    w, Utils.join_path(self.base_path, 'hello')))

    def test_match_with_filename(self):
        success_case = Utils.join_path(self.base_path, 'hello', 'world',
                                       'file.foo')
        file_path = success_case

        wrong_cases = [
            Utils.join_path(self.base_path, 'hello', 'file.foo'),
            Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', '.txt'),
            Utils.join_path(self.base_path, 'hello', 'any_name', 'file.foo'),
            Utils.join_path(self.base_path, 'hello', 'world', 'file', '.foo')
        ]

        self.assertTrue(Utils.match_with_filename(success_case, file_path))

        for w in wrong_cases:
            self.assertFalse(Utils.match_with_filename(w, file_path))

    def test_match_with_willcard(self):
        pattern = Utils.join_path(self.base_path, 'packages',
                                  'Package Control.cache*')
        success_cases = [
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cache123123'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cache'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cached'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cache-any-pattern')
        ]

        wrong_cases = [
            Utils.join_path(self.base_path, 'packages',
                            'Package Cntrol.cache123123'),
            Utils.join_path(self.base_path, 'packages',
                            'Package Control.cach123123'),
            Utils.join_path(self.base_path, 'packages', 'Package.cache'),
            Utils.join_path(self.base_path, 'packages', 'Package', '.cache'),
            Utils.join_path(self.base_path, 'packages', 'Package', ' Control',
                            '.cache'),
            Utils.join_path(self.base_path, 'packages', 'any', 'directory',
                            'Package Control.cache')
        ]

        for w in wrong_cases:
            self.assertFalse(Utils.match_with_willcard(w, pattern))

        for s in success_cases:
            self.assertTrue(Utils.match_with_willcard(s, pattern))

    def test_match_with_extension(self):
        pattern = '.py'

        success_cases = [
            Utils.join_path(self.base_path, 'hello', '____foo', 'other',
                            '.py'),
            Utils.join_path(self.base_path, 'hello', 'file.py'),
            Utils.join_path(self.base_path, 'hello', '.py'),
            Utils.join_path(self.base_path, 'hello', '...', 'another.python',
                            'file.py'),
            Utils.join_path(self.base_path, 'hello', '_file.python.___.__.py'),
            Utils.join_path(self.base_path, 'hello', 'other', 'folder', 'dot',
                            'py.py')
        ]

        wrong_cases = [
            Utils.join_path(self.base_path, 'hello', 'file.foo'),
            Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', '.txt'),
            Utils.join_path(self.base_path, 'hello', 'file.pypy'),
            Utils.join_path(self.base_path, 'hello', 'file.python'),
            Utils.join_path(self.base_path, 'hello', 'file.otherpy'),
            Utils.join_path(self.base_path, 'hello', '_.py', 'file.otherpy')
        ]

        for s in success_cases:
            self.assertTrue(Utils.match_with_extension(s, pattern))

        for w in wrong_cases:
            self.assertFalse(Utils.match_with_extension(w, pattern))

    def test_is_file_extension(self):
        success_cases = [
            '.DStore', '.DStore?', '.jpg', '.png', '.txt', '.Trashes'
        ]

        wrong_cases = [
            'SublimeLinter', 'SublieCodeIntel', 'file.jpg', 'file.file.png',
            '_.txt'
        ]

        for s in success_cases:
            self.assertTrue(Utils.is_file_extension(s))

        for w in wrong_cases:
            self.assertFalse(Utils.is_file_extension(w))

    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'))

    def test_encode_path(self):
        self.assertIsNone(Utils.encode_path(""))
        with self.assertRaises(TypeError):
            Utils.encode_path()

        path = '/some/path with spaces/to/file.txt'
        encoded_path = '%2Fsome%2Fpath%20with%20spaces%2Fto%2Ffile.txt'
        self.assertNotEqual(Utils.encode_path(path),
                            '/some/path%20with%20spaces/to/file.txt')
        self.assertEqual(Utils.encode_path(path), encoded_path)

    def test_decode_path(self):
        self.assertIsNone(Utils.decode_path(""))
        with self.assertRaises(TypeError):
            Utils.decode_path()

        path = '/some/path with spaces/to/file.txt'
        encoded_path = '%2Fsome%2Fpath%20with%20spaces%2Fto%2Ffile.txt'
        self.assertEqual(Utils.decode_path(encoded_path),
                         path.replace('/', Utils.os_separator()))

    def test_os_separator(self):
        self.assertNotEqual(os.sep, '')
        self.assertEqual(os.sep, Utils.os_separator())

    def test_parse_to_os(self):
        paths = ['something/path\\to/test', 'another\\something/path\\to/test']
        expected_paths = [
            Utils.join_path('something', 'path', 'to', 'test'),
            Utils.join_path('another', 'something', 'path', 'to', 'test')
        ]

        result = Utils.parse_to_os(paths)
        self.assertEqual(result, expected_paths)

    def test_create_empty_file(self):
        test_path = Utils.join_path(os.getcwd(), 'empty_file.txt')

        self.assertFalse(os.path.exists(test_path))
        Utils.create_empty_file(test_path)
        self.assertTrue(os.path.exists(test_path))
        self.assertEqual(os.path.getsize(test_path), 0)
        os.remove(test_path)
        self.assertFalse(os.path.exists(test_path))

    def test_write_to_file(self):
        test_filename = 'empty_file.txt'
        message = 'file content'
        file_path = Utils.join_path(os.getcwd(), test_filename)

        self.assertFalse(Utils.exists_path(file_path))
        Utils.write_to_file(file_path, message)

        self.assertTrue(os.path.exists(file_path))

        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8').find(message), 0)

        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        file_path = Utils.join_path(os.getcwd(), 'some_path', 'sub_path',
                                    test_filename)

        Utils.write_to_file(file_path, message)
        self.assertTrue(os.path.exists(file_path))
        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8').find(message), 0)
        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        self.create_folder(Utils.join_path(os.getcwd(), 'some_path'))

        file_path = Utils.join_path(os.getcwd(), 'some_path', 'sub_path',
                                    test_filename)

        Utils.write_to_file(file_path, message)
        self.assertTrue(os.path.exists(file_path))
        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8').find(message), 0)
        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        Utils.write_to_file(file_path, {"some": "content"},
                            action='a+',
                            as_json=True)
        self.assertTrue(os.path.exists(file_path))
        with open(file_path, 'rb') as f:
            self.assertEqual(f.read().decode('utf-8'), '{"some": "content"}')

        os.remove(file_path)
        self.assertFalse(os.path.exists(file_path))

        self.delete_folder(Utils.join_path(os.getcwd(), 'some_path'))

    def test_parse_patterns(self):
        patterns = ['.txt', '.py', 'foo', 'bar.py', '*.go']
        expected = sorted([
            '.txt', '.py',
            Utils.join_path(self.base_path, 'foo'),
            Utils.join_path(self.base_path, 'bar.py'),
            Utils.join_path(self.base_path, '*.go')
        ])

        result = sorted(Utils.parse_patterns(patterns, self.base_path))
        self.assertListEqual(result, expected)

        patterns = sorted(['.foo', '.DStore', '.file.name', '**/*.txt'])
        expected = sorted([
            '.foo', '.DStore',
            Utils.join_path(self.base_path, '.file.name'),
            Utils.join_path(self.base_path, '**/*.txt')
        ])
        result = sorted(Utils.parse_patterns(patterns, self.base_path))
        self.assertListEqual(result, expected)

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

        self.create_folder(Utils.join_path(self.base_path, 'foo', 'bar'))
        open(Utils.join_path(base_path, 'foo.txt'), 'a').close()
        open(Utils.join_path(base_path, 'bar.rb'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'foo.txt'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'foo.py'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'main.go'), 'a').close()
        open(Utils.join_path(base_path, 'bar', 'other.go'), 'a').close()

        files = Utils.get_files(base_path)
        patterns = Utils.parse_patterns(
            ['.rb', '.py', Utils.join_path('bar', '*.go')], base_path)

        expected = sorted([
            Utils.join_path(base_path, 'bar.rb'),
            Utils.join_path(base_path, 'bar', 'foo.py'),
            Utils.join_path(base_path, 'bar', 'main.go'),
            Utils.join_path(base_path, 'bar', 'other.go')
        ])

        filtered_files = sorted(Utils.filter_files_by_patterns(
            files, patterns))

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

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

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

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

    def test_get_file_content(self):
        test_path = Utils.join_path(os.getcwd(), 'empty_file.json')

        Utils.create_empty_file(test_path)
        Utils.write_to_file(test_path, 'Some content')
        file_content = Utils.get_file_content(test_path)

        self.assertEqual(file_content, 'Some content')

        os.remove(test_path)
        self.assertFalse(os.path.exists(test_path))
Пример #45
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'))
Пример #46
0
    def test_get_files(self):
        with self.assertRaises(TypeError):
            Utils.get_files()
        self.assertListEqual(Utils.get_files('t'), [])
        self.assertListEqual(Utils.get_files(1234), [])
        self.assertListEqual(Utils.get_files(1234), [])
        self.assertGreater(len(Utils.get_files(self.base_path)), 0)

        #Create a test folder structure
        self.create_folder(Utils.join_path(self.base_path, 'hello', 'world'))
        open(Utils.join_path(self.base_path, 'hello', 'foo.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'hello', 'bar.txt'), 'a').close()
        open(Utils.join_path(self.base_path, 'hello', 'world', 'foo.txt'),
             'a').close()
        allFiles = sorted([
            Utils.join_path(self.base_path, 'hello', 'bar.txt'),
            Utils.join_path(self.base_path, 'hello', 'foo.txt'),
            Utils.join_path(self.base_path, 'hello', 'world', 'foo.txt')
        ])
        files = sorted(
            Utils.get_files(Utils.join_path(self.base_path, 'hello')))
        self.assertEqual(len(files), 3)
        self.assertListEqual(files, allFiles)
        self.delete_folder(Utils.join_path(self.base_path, 'hello'))
Пример #47
0
  def test_match_with_folder(self):
    success_cases = [
      Utils.join_path(self.base_path, 'hello', 'foo.txt'),
      Utils.join_path(self.base_path, 'hello', 'world', 'bar.txt'),
      Utils.join_path(self.base_path, 'hello', 'world', 'anything.py'),
      Utils.join_path(self.base_path, 'hello', '.txt'),
      Utils.join_path(self.base_path, 'hello', '.py')
    ]

    wrong_cases = [
      Utils.join_path(self.base_path, 'hello2', 'foo.txt'),
      Utils.join_path(self.base_path, 'hello2', 'world', 'bar.txt'),
      Utils.join_path(self.base_path, 'hello2', 'world', 'anything.py'),
      Utils.join_path(self.base_path, 'hello2', '.txt'),
      Utils.join_path(self.base_path, 'hello2', '.py')
    ]

    self.assertFalse(Utils.match_with_folder(self.base_path, self.base_path))

    for s in success_cases:
      self.assertTrue(Utils.match_with_folder(s, Utils.join_path(
        self.base_path, 'hello'
      )))

    for w in wrong_cases:
      self.assertFalse(Utils.match_with_folder(w, Utils.join_path(
        self.base_path, 'hello'
      )))