def test_skip_weird_exts(self):
fr = FileRecognizer(skip_exts=set())
self.assertEqual(self._recognize_file("text#", fr), "text")
self.assertEqual(self._recognize_file("foo.bar.baz", fr), "text")
fr = FileRecognizer(skip_exts=set(["#", ".bar.baz"]))
self.assertEqual(self._recognize_file("text#", fr), "skip")
self.assertEqual(self._recognize_file("foo.bar.baz", fr), "skip")
def test_binary_middle():
fr = FileRecognizer(binary_bytes=100)
assert not fr.is_binary(b"binary_middle")
assert fr.recognize_file(b"binary_middle") == "text"
assert fr.recognize(b"binary_middle") == "text"
fr = FileRecognizer(binary_bytes=101)
assert fr.is_binary(b"binary_middle")
assert fr.recognize_file(b"binary_middle") == "binary"
assert fr.recognize(b"binary_middle") == "binary"
def test_binary_middle():
fr = FileRecognizer(binary_bytes=100)
assert not fr.is_binary('binary_middle')
assert fr.recognize_file('binary_middle') == 'text'
assert fr.recognize('binary_middle') == 'text'
fr = FileRecognizer(binary_bytes=101)
assert fr.is_binary('binary_middle')
assert fr.recognize_file('binary_middle') == 'binary'
assert fr.recognize('binary_middle') == 'binary'
def test_binary_middle():
fr = FileRecognizer(binary_bytes=100)
nt.assert_false(fr.is_binary('binary_middle'))
nt.assert_equal(fr.recognize_file('binary_middle'), 'text')
nt.assert_equal(fr.recognize('binary_middle'), 'text')
fr = FileRecognizer(binary_bytes=101)
nt.assert_true(fr.is_binary('binary_middle'))
nt.assert_equal(fr.recognize_file('binary_middle'), 'binary')
nt.assert_equal(fr.recognize('binary_middle'), 'binary')
def test_skip_ext():
fr = FileRecognizer(skip_exts=set(['.skip_ext']))
nt.assert_equal(fr.recognize('text.skip_ext'), 'skip')
nt.assert_equal(fr.recognize_file('text.skip_ext'), 'skip')
nt.assert_equal(fr.recognize('text'), 'text')
nt.assert_equal(fr.recognize_file('text'), 'text')
nt.assert_equal(fr.recognize('text.dont_skip_ext'), 'text')
nt.assert_equal(fr.recognize_file('text.dont_skip_ext'), 'text')
nt.assert_equal(fr.recognize('dir.skip_ext'), 'directory')
nt.assert_equal(fr.recognize_directory('dir.skip_ext'), 'directory')
def test_lack_of_permissions():
fr = FileRecognizer()
assert fr.recognize(b"unreadable_file") == "unreadable"
assert fr.recognize_file(b"unreadable_file") == "unreadable"
assert fr.recognize(b"unreadable_dir") == "directory"
assert fr.recognize_directory(b"unreadable_dir") == "directory"
assert fr.recognize(b"unexecutable_dir") == "directory"
assert fr.recognize_directory(b"unexecutable_dir") == "directory"
assert fr.recognize(b"totally_unusable_dir") == "directory"
assert fr.recognize_directory(b"totally_unusable_dir") == "directory"
def test_skip_ext():
fr = FileRecognizer(skip_exts=set(['.skip_ext']))
assert fr.recognize('text.skip_ext') == 'skip'
assert fr.recognize_file('text.skip_ext') == 'skip'
assert fr.recognize('text') == 'text'
assert fr.recognize_file('text') == 'text'
assert fr.recognize('text.dont_skip_ext') == 'text'
assert fr.recognize_file('text.dont_skip_ext') == 'text'
assert fr.recognize('dir.skip_ext') == 'directory'
assert fr.recognize_directory('dir.skip_ext') == 'directory'
def test_symlink_src_unreadable():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
assert fr.recognize('unreadable_file_link') == 'unreadable'
assert fr.recognize_file('unreadable_file_link') == 'unreadable'
assert fr.recognize('unreadable_dir_link') == 'directory'
assert fr.recognize_directory('unreadable_dir_link') == 'directory'
assert fr.recognize('unexecutable_dir_link') == 'directory'
assert fr.recognize_directory('unexecutable_dir_link') == 'directory'
assert fr.recognize('totally_unusable_dir_link') == 'directory'
assert fr.recognize_directory('totally_unusable_dir_link') == 'directory'
def test_lack_of_permissions():
fr = FileRecognizer()
assert fr.recognize('unreadable_file') == 'unreadable'
assert fr.recognize_file('unreadable_file') == 'unreadable'
assert fr.recognize('unreadable_dir') == 'directory'
assert fr.recognize_directory('unreadable_dir') == 'directory'
assert fr.recognize('unexecutable_dir') == 'directory'
assert fr.recognize_directory('unexecutable_dir') == 'directory'
assert fr.recognize('totally_unusable_dir') == 'directory'
assert fr.recognize_directory('totally_unusable_dir') == 'directory'
def test_symlink_src_unreadable():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
assert fr.recognize(b"unreadable_file_link") == "unreadable"
assert fr.recognize_file(b"unreadable_file_link") == "unreadable"
assert fr.recognize(b"unreadable_dir_link") == "directory"
assert fr.recognize_directory(b"unreadable_dir_link") == "directory"
assert fr.recognize(b"unexecutable_dir_link") == "directory"
assert fr.recognize_directory(b"unexecutable_dir_link") == "directory"
assert fr.recognize(b"totally_unusable_dir_link") == "directory"
assert fr.recognize_directory(b"totally_unusable_dir_link") == "directory"
def test_skip_ext():
fr = FileRecognizer(skip_exts=set([b".skip_ext"]))
assert fr.recognize(b"text.skip_ext") == "skip"
assert fr.recognize_file(b"text.skip_ext") == "skip"
assert fr.recognize(b"text") == "text"
assert fr.recognize_file(b"text") == "text"
assert fr.recognize(b"text.dont_skip_ext") == "text"
assert fr.recognize_file(b"text.dont_skip_ext") == "text"
assert fr.recognize(b"dir.skip_ext") == "directory"
assert fr.recognize_directory(b"dir.skip_ext") == "directory"
def test_gzipped():
fr = FileRecognizer()
assert fr.is_binary('text.gz')
assert fr.recognize_file('text.gz') == 'gzip'
assert fr.recognize('text.gz') == 'gzip'
assert fr.is_binary('binary.gz')
assert fr.recognize_file('binary.gz') == 'binary'
assert fr.recognize('binary.gz') == 'binary'
assert fr.is_binary('fake.gz')
assert fr.recognize_file('fake.gz') == 'binary'
assert fr.recognize('fake.gz') == 'binary'
def test_lack_of_permissions():
fr = FileRecognizer()
nt.assert_equal(fr.recognize('unreadable_file'), 'unreadable')
nt.assert_equal(fr.recognize_file('unreadable_file'), 'unreadable')
nt.assert_equal(fr.recognize('unreadable_dir'), 'directory')
nt.assert_equal(fr.recognize_directory('unreadable_dir'), 'directory')
nt.assert_equal(fr.recognize('unexecutable_dir'), 'directory')
nt.assert_equal(fr.recognize_directory('unexecutable_dir'), 'directory')
nt.assert_equal(fr.recognize('totally_unusable_dir'), 'directory')
nt.assert_equal(fr.recognize_directory('totally_unusable_dir'),
'directory')
def test_gzipped(self):
fr = FileRecognizer()
self.assertTrue(fr.is_binary("text.gz"))
self.assertEqual(self._recognize_file("text.gz", fr), "gzip")
self.assertEqual(self._recognize("text.gz", fr), "gzip")
self.assertTrue(fr.is_binary("binary.gz"))
self.assertEqual(self._recognize_file("binary.gz", fr), "binary")
self.assertEqual(self._recognize("binary.gz", fr), "binary")
self.assertTrue(fr.is_binary("fake.gz"))
self.assertEqual(self._recognize_file("fake.gz", fr), "binary")
self.assertEqual(self._recognize("fake.gz", fr), "binary")
def test_symlink_src_unreadable():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
nt.assert_equal(fr.recognize('unreadable_file_link'), 'unreadable')
nt.assert_equal(fr.recognize_file('unreadable_file_link'), 'unreadable')
nt.assert_equal(fr.recognize('unreadable_dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('unreadable_dir_link'), 'directory')
nt.assert_equal(fr.recognize('unexecutable_dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('unexecutable_dir_link'),
'directory')
nt.assert_equal(fr.recognize('totally_unusable_dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('totally_unusable_dir_link'),
'directory')
def test_dot_dot():
fr = FileRecognizer(skip_hidden_files=True, skip_hidden_dirs=True,
skip_exts=set(['.skip_ext']),skip_dirs=set(['skip_dir']))
truth = [
('../binary', 'binary'),
('../dir.skip_ext/text', 'text'),
('../dir/subdir/text', 'text'),
('../dir/text', 'text'),
('../text', 'text'),
('../text.dont_skip_ext', 'text'),
]
result = sorted(fr.walk('..'))
assert result == truth
def test_gzipped():
fr = FileRecognizer()
nt.assert_true(fr.is_binary('text.gz'))
nt.assert_equal(fr.recognize_file('text.gz'), 'gzip')
nt.assert_equal(fr.recognize('text.gz'), 'gzip')
nt.assert_true(fr.is_binary('binary.gz'))
nt.assert_equal(fr.recognize_file('binary.gz'), 'binary')
nt.assert_equal(fr.recognize('binary.gz'), 'binary')
nt.assert_true(fr.is_binary('fake.gz'))
nt.assert_equal(fr.recognize_file('fake.gz'), 'binary')
nt.assert_equal(fr.recognize('fake.gz'), 'binary')
def test_dot_dot():
fr = FileRecognizer(skip_hidden_files=True, skip_hidden_dirs=True,
skip_exts=set(['.skip_ext']),skip_dirs=set(['skip_dir']))
truth = [
('../binary', 'binary'),
('../dir.skip_ext/text', 'text'),
('../dir/subdir/text', 'text'),
('../dir/text', 'text'),
('../text', 'text'),
('../text.dont_skip_ext', 'text'),
]
result = sorted(fr.walk('..'))
assert result == truth
def test_lack_of_permissions():
fr = FileRecognizer()
assert fr.recognize('unreadable_file') == 'unreadable'
assert fr.recognize_file('unreadable_file') == 'unreadable'
assert fr.recognize('unreadable_dir') == 'directory'
assert fr.recognize_directory('unreadable_dir') == 'directory'
assert fr.recognize('unexecutable_dir') == 'directory'
assert fr.recognize_directory('unexecutable_dir') == 'directory'
assert fr.recognize('totally_unusable_dir') == 'directory'
assert fr.recognize_directory('totally_unusable_dir') == 'directory'
def test_skip_ext():
fr = FileRecognizer(skip_exts=set(['.skip_ext']))
nt.assert_equal(fr.recognize('text.skip_ext'), 'skip')
nt.assert_equal(fr.recognize_file('text.skip_ext'), 'skip')
nt.assert_equal(fr.recognize('text'), 'text')
nt.assert_equal(fr.recognize_file('text'), 'text')
nt.assert_equal(fr.recognize('text.dont_skip_ext'), 'text')
nt.assert_equal(fr.recognize_file('text.dont_skip_ext'), 'text')
nt.assert_equal(fr.recognize('dir.skip_ext'), 'directory')
nt.assert_equal(fr.recognize_directory('dir.skip_ext'), 'directory')
def test_symlink_src_unreadable():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
assert fr.recognize('unreadable_file_link') == 'unreadable'
assert fr.recognize_file('unreadable_file_link') == 'unreadable'
assert fr.recognize('unreadable_dir_link') == 'directory'
assert fr.recognize_directory('unreadable_dir_link') == 'directory'
assert fr.recognize('unexecutable_dir_link') == 'directory'
assert fr.recognize_directory('unexecutable_dir_link') == 'directory'
assert fr.recognize('totally_unusable_dir_link') == 'directory'
assert fr.recognize_directory('totally_unusable_dir_link') == 'directory'
def test_skip_ext():
fr = FileRecognizer(skip_exts=set(['.skip_ext']))
assert fr.recognize('text.skip_ext') == 'skip'
assert fr.recognize_file('text.skip_ext') == 'skip'
assert fr.recognize('text') == 'text'
assert fr.recognize_file('text') == 'text'
assert fr.recognize('text.dont_skip_ext') == 'text'
assert fr.recognize_file('text.dont_skip_ext') == 'text'
assert fr.recognize('dir.skip_ext') == 'directory'
assert fr.recognize_directory('dir.skip_ext') == 'directory'
def test_skip_weird_exts():
fr = FileRecognizer(skip_exts=set())
assert fr.recognize_file('text#') == 'text'
assert fr.recognize_file('foo.bar.baz') == 'text'
fr = FileRecognizer(skip_exts=set(['#', '.bar.baz']))
assert fr.recognize_file('text#') == 'skip'
assert fr.recognize_file('foo.bar.baz') == 'skip'
def test_skip_weird_exts():
fr = FileRecognizer(skip_exts=set())
assert fr.recognize_file(b"text#") == "text"
assert fr.recognize_file(b"foo.bar.baz") == "text"
fr = FileRecognizer(skip_exts=set([b"#", b".bar.baz"]))
assert fr.recognize_file(b"text#") == "skip"
assert fr.recognize_file(b"foo.bar.baz") == "skip"
def test_skip_weird_exts():
fr = FileRecognizer(skip_exts=set())
nt.assert_equal(fr.recognize_file('text#'), 'text')
nt.assert_equal(fr.recognize_file('foo.bar.baz'), 'text')
fr = FileRecognizer(skip_exts=set(['#', '.bar.baz']))
nt.assert_equal(fr.recognize_file('text#'), 'skip')
nt.assert_equal(fr.recognize_file('foo.bar.baz'), 'skip')
def test_dot_dot():
fr = FileRecognizer(skip_hidden_files=True, skip_hidden_dirs=True,
skip_exts=set(['.skip_ext']),
skip_dirs=set(['skip_dir']))
truth = [
(os.path.join(os.curdir, 'binary'), 'binary'),
(os.path.join(os.curdir, 'dir.skip_ext', 'text'), 'text'),
(os.path.join(os.curdir, 'dir', 'subdir', 'text'), 'text'),
(os.path.join(os.curdir, 'dir', 'text'), 'text'),
(os.path.join(os.curdir, 'text'), 'text'),
(os.path.join(os.curdir, 'text.dont_skip_ext'), 'text'),
]
result = sorted(fr.walk(os.pardir))
nt.assert_equal(result, truth)
def test_walking():
fr = FileRecognizer(skip_hidden_files=True, skip_hidden_dirs=True,
skip_exts=set(['.skip_ext']),
skip_dirs=set(['skip_dir']))
truth = [
('tree/binary', 'binary'),
('tree/dir.skip_ext/text', 'text'),
('tree/dir/subdir/text', 'text'),
('tree/dir/text', 'text'),
('tree/text', 'text'),
('tree/text.dont_skip_ext', 'text'),
]
result = sorted(fr.walk('tree'))
nt.assert_equal(result, truth)
def test_lack_of_permissions():
fr = FileRecognizer()
nt.assert_equal(fr.recognize('unreadable_file'), 'unreadable')
nt.assert_equal(fr.recognize_file('unreadable_file'), 'unreadable')
nt.assert_equal(fr.recognize('unreadable_dir'), 'directory')
nt.assert_equal(fr.recognize_directory('unreadable_dir'), 'directory')
nt.assert_equal(fr.recognize('unexecutable_dir'), 'directory')
nt.assert_equal(fr.recognize_directory('unexecutable_dir'), 'directory')
nt.assert_equal(fr.recognize('totally_unusable_dir'), 'directory')
nt.assert_equal(fr.recognize_directory('totally_unusable_dir'),
'directory')
def test_walking():
fr = FileRecognizer(skip_hidden_files=True,
skip_hidden_dirs=True,
skip_exts=set(['.skip_ext']),
skip_dirs=set(['skip_dir']))
truth = [
('tree/binary', 'binary'),
('tree/dir.skip_ext/text', 'text'),
('tree/dir/subdir/text', 'text'),
('tree/dir/text', 'text'),
('tree/text', 'text'),
('tree/text.dont_skip_ext', 'text'),
]
result = sorted(fr.walk('tree'))
nt.assert_equal(result, truth)
def test_dot_dot():
fr = FileRecognizer(skip_hidden_files=True,
skip_hidden_dirs=True,
skip_exts=set(['.skip_ext']),
skip_dirs=set(['skip_dir']))
truth = [
(os.path.join(os.curdir, 'binary'), 'binary'),
(os.path.join(os.curdir, 'dir.skip_ext', 'text'), 'text'),
(os.path.join(os.curdir, 'dir', 'subdir', 'text'), 'text'),
(os.path.join(os.curdir, 'dir', 'text'), 'text'),
(os.path.join(os.curdir, 'text'), 'text'),
(os.path.join(os.curdir, 'text.dont_skip_ext'), 'text'),
]
result = sorted(fr.walk(os.pardir))
nt.assert_equal(result, truth)
def test_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=True, skip_symlink_dirs=True)
assert fr.recognize(b"binary_link") == "link"
assert fr.recognize_file(b"binary_link") == "link"
assert fr.recognize(b"text_link") == "link"
assert fr.recognize_file(b"text_link") == "link"
assert fr.recognize(b"dir_link") == "link"
assert fr.recognize_directory(b"dir_link") == "link"
def test_do_not_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
assert fr.recognize(b"binary_link") == "binary"
assert fr.recognize_file(b"binary_link") == "binary"
assert fr.recognize(b"text_link") == "text"
assert fr.recognize_file(b"text_link") == "text"
assert fr.recognize(b"dir_link") == "directory"
assert fr.recognize_directory(b"dir_link") == "directory"
def test_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=True, skip_symlink_dirs=True)
assert fr.recognize('binary_link') == 'link'
assert fr.recognize_file('binary_link') == 'link'
assert fr.recognize('text_link') == 'link'
assert fr.recognize_file('text_link') == 'link'
assert fr.recognize('dir_link') == 'link'
assert fr.recognize_directory('dir_link') == 'link'
def test_do_not_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
assert fr.recognize('binary_link') == 'binary'
assert fr.recognize_file('binary_link') == 'binary'
assert fr.recognize('text_link') == 'text'
assert fr.recognize_file('text_link') == 'text'
assert fr.recognize('dir_link') == 'directory'
assert fr.recognize_directory('dir_link') == 'directory'
def test_do_not_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
nt.assert_equal(fr.recognize('binary_link'), 'binary')
nt.assert_equal(fr.recognize_file('binary_link'), 'binary')
nt.assert_equal(fr.recognize('text_link'), 'text')
nt.assert_equal(fr.recognize_file('text_link'), 'text')
nt.assert_equal(fr.recognize('dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('dir_link'), 'directory')
def test_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=True, skip_symlink_dirs=True)
nt.assert_equal(fr.recognize('binary_link'), 'link')
nt.assert_equal(fr.recognize_file('binary_link'), 'link')
nt.assert_equal(fr.recognize('text_link'), 'link')
nt.assert_equal(fr.recognize_file('text_link'), 'link')
nt.assert_equal(fr.recognize('dir_link'), 'link')
nt.assert_equal(fr.recognize_directory('dir_link'), 'link')
def test_symlink_src_unreadable():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
nt.assert_equal(fr.recognize('unreadable_file_link'), 'unreadable')
nt.assert_equal(fr.recognize_file('unreadable_file_link'), 'unreadable')
nt.assert_equal(fr.recognize('unreadable_dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('unreadable_dir_link'), 'directory')
nt.assert_equal(fr.recognize('unexecutable_dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('unexecutable_dir_link'),
'directory')
nt.assert_equal(fr.recognize('totally_unusable_dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('totally_unusable_dir_link'),
'directory')
def test_binary_middle():
fr = FileRecognizer(binary_bytes=100)
assert not fr.is_binary('binary_middle')
assert fr.recognize_file('binary_middle') == 'text'
assert fr.recognize('binary_middle') == 'text'
fr = FileRecognizer(binary_bytes=101)
assert fr.is_binary('binary_middle')
assert fr.recognize_file('binary_middle') == 'binary'
assert fr.recognize('binary_middle') == 'binary'
def test_binary_middle():
fr = FileRecognizer(binary_bytes=100)
nt.assert_false(fr.is_binary('binary_middle'))
nt.assert_equal(fr.recognize_file('binary_middle'), 'text')
nt.assert_equal(fr.recognize('binary_middle'), 'text')
fr = FileRecognizer(binary_bytes=101)
nt.assert_true(fr.is_binary('binary_middle'))
nt.assert_equal(fr.recognize_file('binary_middle'), 'binary')
nt.assert_equal(fr.recognize('binary_middle'), 'binary')
def test_skip_symlinks(self):
fr = FileRecognizer(skip_symlink_files=True, skip_symlink_dirs=True)
self.assertEqual(self._recognize("binary_link", fr), "link")
self.assertEqual(self._recognize_file("binary_link", fr), "link")
self.assertEqual(self._recognize("text_link", fr), "link")
self.assertEqual(self._recognize_file("text_link", fr), "link")
self.assertEqual(self._recognize("dir_link", fr), "link")
self.assertEqual(self._recognize_directory("dir_link", fr), "link")
def test_dot_dot():
fr = FileRecognizer(
skip_hidden_files=True,
skip_hidden_dirs=True,
skip_exts=set([b".skip_ext"]),
skip_dirs=set([b"skip_dir"]),
)
truth = [
(b"../binary", "binary"),
(b"../dir.skip_ext/text", "text"),
(b"../dir/subdir/text", "text"),
(b"../dir/text", "text"),
(b"../text", "text"),
(b"../text.dont_skip_ext", "text"),
]
result = sorted(fr.walk(b".."))
assert result == truth
def test_walking(self):
fr = FileRecognizer(
skip_hidden_files=True,
skip_hidden_dirs=True,
skip_exts=set([".skip_ext"]),
skip_dirs=set(["skip_dir"]),
)
truth = [
("tree/binary", "binary"),
("tree/dir.skip_ext/text", "text"),
("tree/dir/subdir/text", "text"),
("tree/dir/text", "text"),
("tree/text", "text"),
("tree/text.dont_skip_ext", "text"),
]
result = sorted(fr.walk("tree"))
self.assertEqual(result, truth)
def test_do_not_skip_symlinks(self):
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
self.assertEqual(self._recognize("binary_link", fr), "binary")
self.assertEqual(self._recognize_file("binary_link", fr), "binary")
self.assertEqual(self._recognize("text_link", fr), "text")
self.assertEqual(self._recognize_file("text_link", fr), "text")
self.assertEqual(self._recognize("dir_link", fr), "directory")
self.assertEqual(self._recognize_directory("dir_link", fr), "directory")
def test_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=True, skip_symlink_dirs=True)
assert fr.recognize('binary_link') == 'link'
assert fr.recognize_file('binary_link') == 'link'
assert fr.recognize('text_link') == 'link'
assert fr.recognize_file('text_link') == 'link'
assert fr.recognize('dir_link') == 'link'
assert fr.recognize_directory('dir_link') == 'link'
def test_do_not_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
nt.assert_equal(fr.recognize('binary_link'), 'binary')
nt.assert_equal(fr.recognize_file('binary_link'), 'binary')
nt.assert_equal(fr.recognize('text_link'), 'text')
nt.assert_equal(fr.recognize_file('text_link'), 'text')
nt.assert_equal(fr.recognize('dir_link'), 'directory')
nt.assert_equal(fr.recognize_directory('dir_link'), 'directory')
def test_do_not_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=False, skip_symlink_dirs=False)
assert fr.recognize('binary_link') == 'binary'
assert fr.recognize_file('binary_link') == 'binary'
assert fr.recognize('text_link') == 'text'
assert fr.recognize_file('text_link') == 'text'
assert fr.recognize('dir_link') == 'directory'
assert fr.recognize_directory('dir_link') == 'directory'
def test_skip_symlinks():
fr = FileRecognizer(skip_symlink_files=True, skip_symlink_dirs=True)
nt.assert_equal(fr.recognize('binary_link'), 'link')
nt.assert_equal(fr.recognize_file('binary_link'), 'link')
nt.assert_equal(fr.recognize('text_link'), 'link')
nt.assert_equal(fr.recognize_file('text_link'), 'link')
nt.assert_equal(fr.recognize('dir_link'), 'link')
nt.assert_equal(fr.recognize_directory('dir_link'), 'link')
def test_skip_weird_exts():
fr = FileRecognizer(skip_exts=set())
assert fr.recognize_file('text#') == 'text'
assert fr.recognize_file('foo.bar.baz') == 'text'
fr = FileRecognizer(skip_exts=set(['#', '.bar.baz']))
assert fr.recognize_file('text#') == 'skip'
assert fr.recognize_file('foo.bar.baz') == 'skip'
def test_skip_weird_exts():
fr = FileRecognizer(skip_exts=set())
nt.assert_equal(fr.recognize_file('text#'), 'text')
nt.assert_equal(fr.recognize_file('foo.bar.baz'), 'text')
fr = FileRecognizer(skip_exts=set(['#', '.bar.baz']))
nt.assert_equal(fr.recognize_file('text#'), 'skip')
nt.assert_equal(fr.recognize_file('foo.bar.baz'), 'skip')
def test_skip_dir():
fr = FileRecognizer(skip_dirs=set(['skip_dir', 'fake_skip_dir']))
nt.assert_equal(fr.recognize('skip_dir'), 'skip')
nt.assert_equal(fr.recognize_directory('skip_dir'), 'skip')
nt.assert_equal(fr.recognize('fake_skip_dir'), 'text')
nt.assert_equal(fr.recognize_file('fake_skip_dir'), 'text')
def test_binary():
fr = FileRecognizer()
nt.assert_true(fr.is_binary('binary'))
nt.assert_equal(fr.recognize_file('binary'), 'binary')
nt.assert_equal(fr.recognize('binary'), 'binary')
def test_skip_dir():
fr = FileRecognizer(skip_dirs=set(['skip_dir', 'fake_skip_dir']))
assert fr.recognize('skip_dir') == 'skip'
assert fr.recognize_directory('skip_dir') == 'skip'
assert fr.recognize('fake_skip_dir') == 'text'
assert fr.recognize_file('fake_skip_dir') == 'text'
def test_do_not_skip_hidden_but_skip_symlinks():
fr = FileRecognizer(skip_hidden_files=False, skip_hidden_dirs=False,
skip_symlink_dirs=True, skip_symlink_files=True)
nt.assert_equal(fr.recognize('.binary'), 'binary')
nt.assert_equal(fr.recognize_file('.binary'), 'binary')
nt.assert_equal(fr.recognize('.text'), 'text')
nt.assert_equal(fr.recognize_file('.text'), 'text')
nt.assert_equal(fr.recognize('.dir'), 'directory')
nt.assert_equal(fr.recognize_directory('.dir'), 'directory')
nt.assert_equal(fr.recognize('.binary_link'), 'link')
nt.assert_equal(fr.recognize_file('.binary_link'), 'link')
nt.assert_equal(fr.recognize('.text_link'), 'link')
nt.assert_equal(fr.recognize_file('.text_link'), 'link')
nt.assert_equal(fr.recognize('.dir_link'), 'link')
nt.assert_equal(fr.recognize_directory('.dir_link'), 'link')
nt.assert_equal(fr.recognize('.text.gz'), 'gzip')
nt.assert_equal(fr.recognize_file('.text.gz'), 'gzip')
nt.assert_equal(fr.recognize('.binary.gz'), 'binary')
nt.assert_equal(fr.recognize_file('.binary.gz'), 'binary')
def test_do_not_skip_backup():
fr = FileRecognizer(skip_backup_files=False)
nt.assert_equal(fr.recognize_file('text~'), 'text')
def test_skip_backup():
fr = FileRecognizer(skip_backup_files=True)
nt.assert_equal(fr.recognize_file('text~'), 'skip')
def test_text():
fr = FileRecognizer()
nt.assert_false(fr.is_binary('text'))
nt.assert_equal(fr.recognize_file('text'), 'text')
nt.assert_equal(fr.recognize('text'), 'text')
def test_dir():
fr = FileRecognizer()
nt.assert_equal(fr.recognize_directory('dir'), 'directory')
nt.assert_equal(fr.recognize('dir'), 'directory')
def test_socket():
fr = FileRecognizer()
nt.assert_equal(fr.recognize('socket_test'), 'skip')
def test_do_not_skip_hidden_but_skip_symlinks():
fr = FileRecognizer(skip_hidden_files=False, skip_hidden_dirs=False,
skip_symlink_dirs=True, skip_symlink_files=True)
assert fr.recognize('.binary') == 'binary'
assert fr.recognize_file('.binary') == 'binary'
assert fr.recognize('.text') == 'text'
assert fr.recognize_file('.text') == 'text'
assert fr.recognize('.dir') == 'directory'
assert fr.recognize_directory('.dir') == 'directory'
assert fr.recognize('.binary_link') == 'link'
assert fr.recognize_file('.binary_link') == 'link'
assert fr.recognize('.text_link') == 'link'
assert fr.recognize_file('.text_link') == 'link'
assert fr.recognize('.dir_link') == 'link'
assert fr.recognize_directory('.dir_link') == 'link'
assert fr.recognize('.text.gz') == 'gzip'
assert fr.recognize_file('.text.gz') == 'gzip'
assert fr.recognize('.binary.gz') == 'binary'
assert fr.recognize_file('.binary.gz') == 'binary'
def test_skip_hidden():
fr = FileRecognizer(skip_hidden_files=True, skip_hidden_dirs=True)
nt.assert_equal(fr.recognize('.binary'), 'skip')
nt.assert_equal(fr.recognize_file('.binary'), 'skip')
nt.assert_equal(fr.recognize('.text'), 'skip')
nt.assert_equal(fr.recognize_file('.text'), 'skip')
nt.assert_equal(fr.recognize('.dir'), 'skip')
nt.assert_equal(fr.recognize_directory('.dir'), 'skip')
nt.assert_equal(fr.recognize('.binary_link'), 'skip')
nt.assert_equal(fr.recognize_file('.binary_link'), 'skip')
nt.assert_equal(fr.recognize('.text_link'), 'skip')
nt.assert_equal(fr.recognize_file('.text_link'), 'skip')
nt.assert_equal(fr.recognize('.dir_link'), 'skip')
nt.assert_equal(fr.recognize_directory('.dir_link'), 'skip')
nt.assert_equal(fr.recognize('.text.gz'), 'skip')
nt.assert_equal(fr.recognize_file('.text.gz'), 'skip')
nt.assert_equal(fr.recognize('.binary.gz'), 'skip')
nt.assert_equal(fr.recognize_file('.binary.gz'), 'skip')