PyCIRCLean/tests/test_kittengroomer.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os

import pytest

from kittengroomer import FileBase, KittenGroomerBase

skip = pytest.mark.skip
xfail = pytest.mark.xfail
fixture = pytest.fixture


class TestFileBase:

    @fixture
    def symlink_file(self, tmpdir):
        file_path = tmpdir.join('test.txt')
        file_path.write('testing')
        file_path = file_path.strpath
        symlink_path = tmpdir.join('symlinked.txt')
        symlink_path = symlink_path.strpath
        os.symlink(file_path, symlink_path)
        return FileBase(symlink_path, symlink_path)

    @fixture
    def temp_file(self, tmpdir):
        file_path = tmpdir.join('test.txt')
        file_path.write('testing')
        file_path = file_path.strpath
        return FileBase(file_path, file_path)

    @fixture
    def temp_file_no_ext(self, tmpdir):
        file_path = tmpdir.join('test')
        file_path.write('testing')
        file_path = file_path.strpath
        return FileBase(file_path, file_path)

    @fixture
    def file_marked_dangerous(self):
        pass

    # @fixture(params=[
    #     FileBase.make_dangerous,
    #     FileBase.make_unknown,
    #     FileBase.make_binary
    # ])
    # def file_marked_all_parameterized(self, request, generic_conf_file):
    #     request.param(generic_conf_file)
    #     return generic_conf_file

    def test_init_identify_filename(self):
        """Init should identify the filename correctly for src_path."""
        pass

    def test_init_identify_extension(self):
        """Init should identify the extension for src_path."""
        pass

    def test_init_file_doesnt_exist(self):
        """Init should raise an exception if the file doesn't exist."""
        pass

    def test_init_srcpath_is_directory(self):
        """Init should raise an exception if given a path to a directory."""

    def test_init_symlink(self):
        """Init should properly identify symlinks."""
        pass

    def test_create_broken(self, tmpdir):
        with pytest.raises(TypeError):
            FileBase()
        with pytest.raises(FileNotFoundError):
            FileBase('', '')
        with pytest.raises(IsADirectoryError):
            FileBase(tmpdir.strpath, tmpdir.strpath)
        # TODO: are there other cases here? path to a file that doesn't exist? permissions?

    def test_extension_uppercase(self, tmpdir):
        file_path = tmpdir.join('TEST.TXT')
        file_path.write('testing')
        file_path = file_path.strpath
        file = FileBase(file_path, file_path)
        assert file.extension == '.txt'

    def test_mimetypes(self, temp_file):
        assert temp_file.mimetype == 'text/plain'
        assert temp_file.maintype == 'text'
        assert temp_file.subtype == 'plain'
        assert temp_file.has_mimetype
        # Need to test something without a mimetype
        # Need to test something that's a directory
        # Need to test something that causes the unicode exception

    @skip
    def test_has_mimetype_no_main_type(self, generic_conf_file):
        generic_conf_file.maintype = ''
        assert generic_conf_file.has_mimetype is False

    @skip
    def test_has_mimetype_no_sub_type(self, generic_conf_file):
        generic_conf_file.sub_type = ''
        assert generic_conf_file.has_mimetype is False

    def test_has_extension(self, temp_file, temp_file_no_ext):
        assert temp_file.has_extension is True
        print(temp_file_no_ext.extension)
        assert temp_file_no_ext.has_extension is False

    def test_set_property(self, temp_file):
        temp_file.set_property('test', True)
        assert temp_file.get_property('test') is True
        # TODO: split asserts into two tests
        assert temp_file.get_property('wrong') is None

    @skip
    def test_marked_dangerous(self, file_marked_all_parameterized):
        file_marked_all_parameterized.make_dangerous()
        assert file_marked_all_parameterized.is_dangerous is True
        # Should work regardless of weird paths??
        # Should check file path alteration behavior as well

    @xfail
    def test_has_symlink(self, tmpdir):
        file_path = tmpdir.join('test.txt')
        file_path.write('testing')
        file_path = file_path.strpath
        symlink_path = tmpdir.join('symlinked.txt')
        symlink_path = symlink_path.strpath
        os.symlink(file_path, symlink_path)
        file = FileBase(file_path, file_path)
        symlink = FileBase(symlink_path, symlink_path)
        assert file.is_symlink is False
        assert symlink.is_symlink is True

    @xfail
    def test_has_symlink_fixture(self, symlink_file):
        assert symlink_file.is_symlink is True

    @skip
    def test_force_ext_change(self, generic_conf_file):
        assert generic_conf_file.has_extension
        assert generic_conf_file.get_property('extension') == '.conf'
        assert os.path.splitext(generic_conf_file.dst_path)[1] == '.conf'
        generic_conf_file.force_ext('.txt')
        assert os.path.splitext(generic_conf_file.dst_path)[1] == '.txt'
        assert generic_conf_file.get_property('extension') == '.txt'
        # should be able to handle weird paths

    @skip
    def test_force_ext_correct(self, generic_conf_file):
        assert generic_conf_file.has_extension
        assert generic_conf_file.get_property('extension') == '.conf'
        generic_conf_file.force_ext('.conf')
        assert os.path.splitext(generic_conf_file.dst_path)[1] == '.conf'
        assert generic_conf_file.get_property('force_ext') is None
        # shouldn't change a file's extension if it already is right

    @xfail
    def test_create_metadata_file(self, temp_file):
        metadata_file_path = temp_file.create_metadata_file('.metadata.txt')
        with open(metadata_file_path, 'w+') as metadata_file:
            metadata_file.write('Have some metadata!')
        # Shouldn't be able to make a metadata file with no extension
        assert temp_file.create_metadata_file('') is False
        # if metadata file already exists
        # if there is no metadata to write should this work?

    def test_safe_copy(self):
        pass


@skip
class TestKittenGroomerBase:

    @fixture
    def source_directory(self):
        return 'tests/dangerous'

    @fixture
    def dest_directory(self):
        return 'tests/dst'

    @fixture
    def generic_groomer(self, source_directory, dest_directory):
        return KittenGroomerBase(source_directory, dest_directory)

    def test_create(self, generic_groomer):
        assert generic_groomer

    def test_instantiation(self, source_directory, dest_directory):
        KittenGroomerBase(source_directory, dest_directory)

    def test_list_all_files(self, tmpdir):
        file = tmpdir.join('test.txt')
        file.write('testing')
        testdir = tmpdir.join('testdir')
        os.mkdir(testdir.strpath)
        simple_groomer = KittenGroomerBase(tmpdir.strpath, tmpdir.strpath)
        files = simple_groomer.list_all_files(simple_groomer.src_root_path)
        assert file.strpath in files
        assert testdir.strpath not in files