mirror of https://github.com/CIRCL/PyCIRCLean
337 lines
13 KiB
Python
337 lines
13 KiB
Python
#!/usr/bin/env python
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import os
|
|
from pathlib import Path
|
|
import unittest.mock as mock
|
|
|
|
import pytest # type: ignore
|
|
|
|
from kittengroomer import FileBase, KittenGroomerBase
|
|
from kittengroomer.helpers import ImplementationRequired
|
|
|
|
skip = pytest.mark.skip
|
|
xfail = pytest.mark.xfail
|
|
fixture = pytest.fixture
|
|
|
|
|
|
class TestFileBase:
|
|
|
|
@fixture(scope='class')
|
|
def src_dir_path(self, tmp_path_factory):
|
|
return tmp_path_factory.mktemp('src')
|
|
|
|
@fixture(scope='class')
|
|
def dest_dir_path(self, tmp_path_factory):
|
|
return tmp_path_factory.mktemp('dest')
|
|
|
|
@fixture(scope='class')
|
|
def tmpfile_path(self, src_dir_path):
|
|
path_src_file = src_dir_path / 'test.txt'
|
|
with path_src_file.open('w') as f:
|
|
f.write('testing')
|
|
return path_src_file
|
|
|
|
@fixture(scope='class')
|
|
def symlink_file_path(self, src_dir_path, tmpfile_path):
|
|
symlink_path = src_dir_path / 'symlinked'
|
|
symlink_path.symlink_to(tmpfile_path)
|
|
return symlink_path
|
|
|
|
@fixture
|
|
def text_file(self, tmpfile_path, dest_dir_path):
|
|
with mock.patch(
|
|
'kittengroomer.helpers.magic.from_file',
|
|
return_value='text/plain'
|
|
):
|
|
dst_path = dest_dir_path / 'test.txt'
|
|
file = FileBase(tmpfile_path, dst_path)
|
|
return file
|
|
|
|
# Constructor behavior
|
|
|
|
@mock.patch('kittengroomer.helpers.magic')
|
|
def test_init_identify_filename(self, mock_libmagic):
|
|
"""Init should identify the filename correctly for src_path."""
|
|
src_path = Path('src/test.txt')
|
|
dst_path = Path('dst/test.txt')
|
|
file = FileBase(src_path, dst_path)
|
|
assert file.filename == 'test.txt'
|
|
|
|
@mock.patch('kittengroomer.helpers.magic')
|
|
def test_init_identify_extension(self, mock_libmagic):
|
|
"""Init should identify the extension for src_path."""
|
|
src_path = Path('src/test.txt')
|
|
dst_path = Path('dst/test.txt')
|
|
file = FileBase(src_path, dst_path)
|
|
assert file.extension == '.txt'
|
|
|
|
@mock.patch('kittengroomer.helpers.magic')
|
|
def test_init_uppercase_extension(self, mock_libmagic):
|
|
"""Init should coerce uppercase extension to lowercase"""
|
|
src_path = Path('src/test.txt')
|
|
dst_path = Path('dst/test.txt')
|
|
file = FileBase(src_path, dst_path)
|
|
assert file.extension == '.txt'
|
|
|
|
@mock.patch('kittengroomer.helpers.magic')
|
|
def test_has_extension_true(self, mock_libmagic):
|
|
"""If the file has an extension, has_extension should == True."""
|
|
src_path = Path('src/test.txt')
|
|
dst_path = Path('dst/test.txt')
|
|
file = FileBase(src_path, dst_path)
|
|
assert file.has_extension is True
|
|
|
|
@mock.patch('kittengroomer.helpers.magic')
|
|
def test_has_extension_false(self, mock_libmagic):
|
|
"""If the file has no extension, has_extensions should == False."""
|
|
src_path = Path('src/test')
|
|
dst_path = Path('dst/test')
|
|
file = FileBase(src_path, dst_path)
|
|
assert file.has_extension is False
|
|
|
|
def test_init_file_doesnt_exist(self):
|
|
"""Init should raise an exception if the file doesn't exist."""
|
|
with pytest.raises(FileNotFoundError):
|
|
FileBase(Path('non_existent'), Path('non_existent'))
|
|
|
|
def test_init_srcpath_is_directory(self, tmpdir):
|
|
"""Init should raise an exception if given a path to a directory."""
|
|
with pytest.raises(IsADirectoryError):
|
|
FileBase(Path(tmpdir.strpath), Path(tmpdir.strpath))
|
|
|
|
@mock.patch('kittengroomer.helpers.magic')
|
|
def test_init_symlink(self, mock_libmagic, symlink_file_path, tmpdir):
|
|
"""Init should properly identify symlinks."""
|
|
file = FileBase(symlink_file_path, Path(tmpdir.strpath))
|
|
assert file.mimetype == 'inode/symlink'
|
|
|
|
@mock.patch('kittengroomer.helpers.magic')
|
|
def test_is_symlink_attribute(self, mock_libmagic, symlink_file_path, tmpdir):
|
|
"""If a file is a symlink, is_symlink should return True."""
|
|
file = FileBase(symlink_file_path, Path(tmpdir.strpath))
|
|
assert file.is_symlink is True
|
|
|
|
def test_init_mimetype_attribute_assigned_correctly(self):
|
|
"""When libmagic returns a given mimetype, the mimetype should be
|
|
assigned properly."""
|
|
with mock.patch('kittengroomer.helpers.magic.from_file',
|
|
return_value='text/plain'):
|
|
file = FileBase(Path('non_existent'), Path('non_existent'))
|
|
assert file.mimetype == 'text/plain'
|
|
|
|
def test_maintype_and_subtype_attributes(self):
|
|
"""If a file has a full mimetype, maintype and subtype should ==
|
|
the appropriate values."""
|
|
with mock.patch('kittengroomer.helpers.magic.from_file',
|
|
return_value='text/plain'):
|
|
file = FileBase(Path('non_existent'), Path('non_existent'))
|
|
assert file.maintype == 'text'
|
|
assert file.subtype == 'plain'
|
|
|
|
def test_has_mimetype_no_full_type(self):
|
|
"""If a file doesn't have a full mimetype has_mimetype should == False."""
|
|
with mock.patch('kittengroomer.helpers.magic.from_file',
|
|
return_value='data'):
|
|
file = FileBase(Path('non_existent'), Path('non_existent'))
|
|
assert file.has_mimetype is False
|
|
|
|
def test_has_mimetype_mimetype_is_none(self):
|
|
"""If a file doesn't have a full mimetype has_mimetype should == False."""
|
|
with mock.patch('kittengroomer.helpers.FileBase._determine_mimetype',
|
|
return_value=None):
|
|
file = FileBase(Path('non_existent'), Path('non_existent'))
|
|
assert file.has_mimetype is False
|
|
|
|
# File properties
|
|
|
|
def get_property_doesnt_exist(self, text_file):
|
|
"""Trying to get a property that doesn't exist should return None."""
|
|
assert text_file.get_property('thing') is None
|
|
|
|
def get_property_builtin(self, text_file):
|
|
"""Getting a property that's been set should return that property."""
|
|
assert text_file.get_property('is_dangerous') is False
|
|
|
|
def get_property_user_defined(self, text_file):
|
|
"""Getting a user defined property should return that property."""
|
|
text_file._user_defined = {'thing': True}
|
|
assert text_file.get_property('thing') is True
|
|
|
|
def set_property_user_defined(self, text_file):
|
|
"""Setting a non-default property should make it available for
|
|
get_property."""
|
|
text_file.set_property('thing', True)
|
|
assert text_file.get_property('thing') is True
|
|
|
|
def set_property_builtin(self, text_file):
|
|
"""Setting a builtin property should assign that property."""
|
|
text_file.set_property('is_dangerous', True)
|
|
assert text_file.get_property('is_dangerous') is True
|
|
|
|
def test_add_new_description(self, text_file):
|
|
"""Adding a new description should add it to the list of description strings."""
|
|
text_file.add_description('thing')
|
|
assert text_file.get_property('description_string') == 'thing'
|
|
|
|
def test_add_description_exists(self, text_file):
|
|
"""Adding a description that already exists shouldn't duplicate it."""
|
|
text_file.add_description('thing')
|
|
text_file.add_description('thing')
|
|
assert text_file.get_property('description_string') == 'thing'
|
|
|
|
def test_add_multiple_descriptions(self, text_file):
|
|
text_file.add_description('thing')
|
|
text_file.add_description('foo')
|
|
assert text_file.get_property('description_string') == 'thing, foo'
|
|
|
|
def test_add_description_not_string(self, text_file):
|
|
"""Adding a description that isn't a string should raise an error."""
|
|
with pytest.raises(TypeError):
|
|
text_file.add_description(123)
|
|
|
|
def test_add_new_error(self, text_file):
|
|
"""Adding a new error should add it to the dict of errors."""
|
|
text_file.add_error(Exception, 'thing')
|
|
assert text_file.get_property('_errors') == {Exception: 'thing'}
|
|
|
|
def test_normal_file_mark_dangerous(self, text_file):
|
|
"""Marking a file dangerous should identify it as dangerous."""
|
|
text_file.make_dangerous()
|
|
assert text_file.is_dangerous is True
|
|
|
|
def test_normal_file_mark_dangerous_filename_change(self, text_file):
|
|
"""Marking a file dangerous should mangle the filename."""
|
|
filename = text_file.filename
|
|
text_file.make_dangerous()
|
|
assert text_file.filename == 'DANGEROUS_{}_DANGEROUS'.format(filename)
|
|
|
|
def test_normal_file_mark_dangerous_add_description(self, text_file):
|
|
"""Marking a file as dangerous and passing in a description should add
|
|
that description to the file."""
|
|
text_file.make_dangerous('thing')
|
|
assert text_file.get_property('description_string') == 'thing'
|
|
|
|
def test_dangerous_file_mark_dangerous(self, text_file):
|
|
"""Marking a dangerous file as dangerous should do nothing, and the
|
|
file should remain dangerous."""
|
|
text_file.make_dangerous()
|
|
text_file.make_dangerous()
|
|
assert text_file.is_dangerous is True
|
|
|
|
def test_force_ext_change_filepath(self, text_file):
|
|
"""Force_ext should modify the path of the file to end in the
|
|
new extension."""
|
|
text_file.force_ext('.test')
|
|
assert text_file.dst_path.name.endswith('.test')
|
|
|
|
def test_force_ext_add_dot(self, text_file):
|
|
"""Force_ext should add a dot to an extension given without one."""
|
|
text_file.force_ext('test')
|
|
assert text_file.dst_path.name.endswith('.test')
|
|
|
|
def test_force_ext_change_extension_attr(self, text_file):
|
|
"""Force_ext should only modify the extension of the destination file"""
|
|
text_file.force_ext('.thing')
|
|
assert text_file.extension == '.txt'
|
|
|
|
def test_force_ext_no_change(self, text_file):
|
|
"""Force_ext should do nothing if the current extension is the same
|
|
as the new extension."""
|
|
text_file.force_ext('.txt')
|
|
assert text_file.extension == '.txt'
|
|
assert '.txt.txt' not in text_file.dst_path.name
|
|
|
|
def test_safe_copy_calls_copy(self, src_dir_path, dest_dir_path):
|
|
"""Calling safe_copy should copy the file from the correct path to
|
|
the correct destination path."""
|
|
file_path = src_dir_path / 'test.txt'
|
|
with open(file_path, 'w+') as file:
|
|
file.write('')
|
|
dst_path = dest_dir_path / 'test.txt'
|
|
with mock.patch('kittengroomer.helpers.magic.from_file',
|
|
return_value='text/plain'):
|
|
file = FileBase(file_path, dst_path)
|
|
with mock.patch('kittengroomer.helpers.shutil.copy') as mock_copy:
|
|
file.safe_copy()
|
|
mock_copy.assert_called_once_with(file_path, dst_path)
|
|
|
|
def test_safe_copy_removes_exec_perms(self):
|
|
"""`safe_copy` should create a file that doesn't have any of the
|
|
executable bits set."""
|
|
pass
|
|
|
|
def test_safe_copy_makedir_doesnt_exist(self):
|
|
"""Calling safe_copy should create intermediate directories in the path
|
|
if they don't exist."""
|
|
pass
|
|
|
|
def test_safe_copy_makedir_exists(self):
|
|
"""Calling safe_copy when some intermediate directories exist should
|
|
result in the creation of the full path and the file."""
|
|
pass
|
|
|
|
def test_create_metadata_file_new(self):
|
|
pass
|
|
|
|
def test_create_metadata_file_already_exists(self):
|
|
pass
|
|
|
|
|
|
class TestLogging:
|
|
|
|
def test_computehash(self):
|
|
"""Computehash should return the correct sha256 hash of a given file."""
|
|
pass
|
|
|
|
|
|
class TestKittenGroomerBase:
|
|
|
|
@fixture(scope='class')
|
|
def src_dir_path(self, tmpdir_factory):
|
|
return Path(tmpdir_factory.mktemp('src').strpath)
|
|
|
|
@fixture(scope='class')
|
|
def dest_dir_path(self, tmpdir_factory):
|
|
return Path(tmpdir_factory.mktemp('dest').strpath)
|
|
|
|
@fixture(scope='class')
|
|
def tmpfile_path(self, src_dir_path):
|
|
path_src_file = src_dir_path / 'test.txt'
|
|
with path_src_file.open('w') as f:
|
|
f.write('testing')
|
|
return path_src_file
|
|
|
|
@fixture
|
|
def groomer(self, src_dir_path, dest_dir_path):
|
|
return KittenGroomerBase(src_dir_path, dest_dir_path)
|
|
|
|
def test_list_all_files_includes_file(self, src_dir_path, tmpfile_path, groomer):
|
|
"""Calling list_all_files should include files in the given path."""
|
|
files = groomer.list_all_files(src_dir_path)
|
|
assert tmpfile_path in files
|
|
|
|
def test_list_all_files_excludes_dir(self, tmpdir, groomer):
|
|
"""Calling list_all_files shouldn't include directories in the given
|
|
path."""
|
|
testdir = tmpdir.join('testdir')
|
|
os.mkdir(testdir.strpath)
|
|
files = groomer.list_all_files(tmpdir.strpath)
|
|
assert testdir.strpath not in files
|
|
|
|
def test_safe_remove(self, groomer, src_dir_path):
|
|
"""Calling safe_remove should not raise an Exception if trying to
|
|
remove a file that doesn't exist."""
|
|
groomer.safe_remove(src_dir_path / 'thing')
|
|
|
|
def test_safe_mkdir_file_exists(self, groomer, dest_dir_path):
|
|
"""Calling safe_mkdir should not overwrite an existing directory."""
|
|
filepath = dest_dir_path / 'thing'
|
|
filepath.mkdir()
|
|
groomer.safe_mkdir(filepath)
|
|
|
|
def test_processdir_not_implemented(self, groomer):
|
|
"""Calling processdir should raise an Implementation Required error."""
|
|
with pytest.raises(ImplementationRequired):
|
|
groomer.processdir('.', '.')
|