mirror of
https://github.com/deadc0de6/dotdrop.git
synced 2026-02-04 19:44:45 +00:00
308 lines
9.4 KiB
Python
308 lines
9.4 KiB
Python
"""
|
|
author: deadc0de6 (https://github.com/deadc0de6)
|
|
Copyright (c) 2023, deadc0de6
|
|
basic unittest for misc stuff
|
|
"""
|
|
|
|
# pylint: disable=R0903
|
|
# pylint: disable=W0231
|
|
# pylint: disable=W0212
|
|
|
|
import os
|
|
import sys
|
|
import unittest
|
|
from io import StringIO
|
|
from unittest.mock import patch
|
|
from jinja2 import TemplateNotFound
|
|
from dotdrop.profile import Profile
|
|
from dotdrop.importer import Importer
|
|
from dotdrop.linktypes import LinkTypes
|
|
from dotdrop.action import Cmd, Transform
|
|
from dotdrop.templategen import Templategen
|
|
from dotdrop.exceptions import UndefinedException, \
|
|
UnmetDependency
|
|
from dotdrop.utils import removepath, samefile, \
|
|
content_empty, _match_ignore_pattern, \
|
|
get_module_from_path, dependencies_met
|
|
from tests.helpers import create_random_file, \
|
|
get_tempdir, clean
|
|
|
|
|
|
class TestUtils(unittest.TestCase):
|
|
"""test case"""
|
|
|
|
def test_removepath(self):
|
|
"""test removepath"""
|
|
removepath('')
|
|
with self.assertRaises(OSError):
|
|
removepath('/abc')
|
|
with self.assertRaises(OSError):
|
|
removepath(os.path.expanduser('~'))
|
|
|
|
def test_misc(self):
|
|
"""misc test"""
|
|
self.assertFalse(samefile('', ''))
|
|
self.assertTrue(content_empty(b'\n'))
|
|
self.assertTrue(_match_ignore_pattern('', '', debug=True))
|
|
self.assertEqual(get_module_from_path(None), None)
|
|
|
|
def test_dependencies_met(self):
|
|
"""dependencies met"""
|
|
oimport = __import__
|
|
|
|
def prepare_import_mock(keywords):
|
|
def import_mock(name, *args):
|
|
if name in keywords:
|
|
raise ImportError
|
|
return oimport(name, *args)
|
|
return import_mock
|
|
|
|
# with self.assertRaises(UnmetDependency):
|
|
# with patch('builtins.__import__',
|
|
# side_effect=prepare_import_mock(
|
|
# ['magic', 'python-magic'])
|
|
# ):
|
|
# dependencies_met()
|
|
|
|
with self.assertRaises(UnmetDependency):
|
|
with patch('builtins.__import__',
|
|
side_effect=prepare_import_mock(['docopt'])):
|
|
dependencies_met()
|
|
|
|
with self.assertRaises(UnmetDependency):
|
|
with patch('builtins.__import__',
|
|
side_effect=prepare_import_mock(['jinja2'])):
|
|
dependencies_met()
|
|
|
|
with self.assertRaises(UnmetDependency):
|
|
with patch('builtins.__import__',
|
|
side_effect=prepare_import_mock(['ruamel.yaml'])):
|
|
dependencies_met()
|
|
|
|
orig = sys.version_info
|
|
sys.version_info = (3, 10)
|
|
with self.assertRaises(UnmetDependency):
|
|
with patch('builtins.__import__',
|
|
side_effect=prepare_import_mock(['tomli'])):
|
|
dependencies_met()
|
|
sys.version_info = orig
|
|
|
|
with self.assertRaises(UnmetDependency):
|
|
with patch('builtins.__import__',
|
|
side_effect=prepare_import_mock(['tomli_w'])):
|
|
dependencies_met()
|
|
|
|
with self.assertRaises(UnmetDependency):
|
|
with patch('builtins.__import__',
|
|
side_effect=prepare_import_mock(['distro'])):
|
|
dependencies_met()
|
|
|
|
|
|
class TestImporter(unittest.TestCase):
|
|
"""test case"""
|
|
|
|
@patch('sys.stdin', StringIO('y\n'))
|
|
def test_generic(self):
|
|
"""test importer"""
|
|
with self.assertRaises(UndefinedException):
|
|
Importer('', None, '', '', {})
|
|
|
|
imp = Importer('profile', None, '', '', {})
|
|
self.assertEqual(imp.import_path('/abc'), -1)
|
|
|
|
tmpdir = get_tempdir()
|
|
self.addCleanup(clean, tmpdir)
|
|
path1, _ = create_random_file(tmpdir, content='left')
|
|
path2, _ = create_random_file(tmpdir, content='right')
|
|
imp.safe = True
|
|
self.assertTrue(imp._check_existing_dotfile(path1, path2))
|
|
path2, _ = create_random_file(tmpdir, content='left')
|
|
self.assertTrue(imp._check_existing_dotfile(path1, path2))
|
|
|
|
def test_apply_trans(self):
|
|
"""test apply_trans"""
|
|
trans = Transform('key', 'value')
|
|
tmpdir = get_tempdir()
|
|
self.addCleanup(clean, tmpdir)
|
|
path, _ = create_random_file(tmpdir)
|
|
|
|
imp = Importer('profile', None, '', '', {})
|
|
self.assertEqual(imp._apply_trans_update(path, trans), None)
|
|
|
|
|
|
class TestActions(unittest.TestCase):
|
|
"""test case"""
|
|
|
|
def test_cmd(self):
|
|
"""test action"""
|
|
badstring = '{{@@ non-existing-var @@}}'
|
|
cmd = Cmd('key', badstring)
|
|
tmpl = Templategen()
|
|
self.assertFalse(cmd._get_action(tmpl, False))
|
|
|
|
cmd.args = [badstring]
|
|
self.assertFalse(cmd._get_args(tmpl))
|
|
|
|
def test_args(self):
|
|
"""test arg parameters"""
|
|
cmd = Cmd('key', '{0} {1}')
|
|
cmd.args = ['arg1']
|
|
self.assertFalse(cmd.execute())
|
|
|
|
cmd = Cmd('key', '{0}')
|
|
cmd.args = ['arg1', 'arg2']
|
|
self.assertFalse(cmd.execute())
|
|
|
|
def test_trans(self):
|
|
"""test trans"""
|
|
trans = Transform('key', 'value')
|
|
tmpdir = get_tempdir()
|
|
self.addCleanup(clean, tmpdir)
|
|
path, _ = create_random_file(tmpdir)
|
|
self.assertFalse(trans.transform('', path))
|
|
|
|
|
|
class TestTemplateGen(unittest.TestCase):
|
|
"""test case"""
|
|
|
|
def test_misc(self):
|
|
"""test misc"""
|
|
tmpl = Templategen()
|
|
self.assertFalse(tmpl.path_is_template('/abc'))
|
|
self.assertFalse(tmpl._is_template('/abc'))
|
|
tmpl._debug_dict('a', 'b')
|
|
|
|
def test_lodaer(self):
|
|
"""test loading template"""
|
|
tmpl = Templategen()
|
|
with self.assertRaises(TemplateNotFound):
|
|
tmpl._template_loader('/abc')
|
|
|
|
def test_is_text(self):
|
|
"""test is_text"""
|
|
self.assertTrue(Templategen._is_text('empty'))
|
|
self.assertTrue(Templategen._is_text('json'))
|
|
self.assertTrue(Templategen._is_text('javascript'))
|
|
self.assertTrue(Templategen._is_text('ecmascript'))
|
|
self.assertTrue(Templategen._is_text('text'))
|
|
self.assertFalse(Templategen._is_text('binary'))
|
|
|
|
def test_handle_bin_file(self):
|
|
"""test handle binary file"""
|
|
tmpl = Templategen()
|
|
|
|
tmpdir = get_tempdir()
|
|
self.addCleanup(clean, tmpdir)
|
|
content = b'abc'
|
|
path, _ = create_random_file(tmpdir, content=content, binary=True)
|
|
|
|
cont = tmpl._handle_file(path)
|
|
self.assertEqual(content, cont)
|
|
|
|
def test_filetype(self):
|
|
"""test using file instead of magic"""
|
|
oimport = __import__
|
|
|
|
def import_mock(name, *args):
|
|
if name == 'magic':
|
|
raise ImportError
|
|
return oimport(name, *args)
|
|
|
|
with patch('builtins.__import__',
|
|
side_effect=import_mock):
|
|
tmpdir = get_tempdir()
|
|
self.addCleanup(clean, tmpdir)
|
|
content = 'abc'
|
|
path, _ = create_random_file(tmpdir, content=content)
|
|
|
|
tmpl = Templategen()
|
|
self.assertTrue('text' in tmpl._get_filetype(path))
|
|
|
|
def test_generate(self):
|
|
"""test generate"""
|
|
tmpl = Templategen()
|
|
self.assertEqual(tmpl.generate('/abc'), '')
|
|
|
|
tmpdir = get_tempdir()
|
|
self.addCleanup(clean, tmpdir)
|
|
content = '{{@@ non-existing-var @@}}'
|
|
path, _ = create_random_file(tmpdir, content=content)
|
|
with self.assertRaises(UndefinedException):
|
|
tmpl.generate(path)
|
|
|
|
fakestring = None
|
|
self.assertEqual(tmpl.generate_string(fakestring), '')
|
|
fakestring = '{{@@ non-existing-var @@}}'
|
|
with self.assertRaises(UndefinedException):
|
|
tmpl.generate_string(fakestring)
|
|
|
|
fakedict = None
|
|
self.assertEqual(tmpl.generate_dict(fakedict), None)
|
|
fakedict = {'key': {
|
|
'subkey', fakestring,
|
|
}}
|
|
tmpl.generate_dict(fakedict)
|
|
|
|
with self.assertRaises(UndefinedException):
|
|
tmpl.generate_string_or_dict(2)
|
|
|
|
tmpdir2 = get_tempdir()
|
|
self.addCleanup(clean, tmpdir2)
|
|
adic = {}
|
|
path, _ = create_random_file(tmpdir, content='blah')
|
|
with self.assertRaises(NameError):
|
|
tmpl._load_path_to_dic(path, adic)
|
|
|
|
tmpl._load_funcs_to_dic(None, None)
|
|
|
|
|
|
class TestLinkTypes(unittest.TestCase):
|
|
"""test case"""
|
|
|
|
def test_exc(self):
|
|
"""test exception"""
|
|
with self.assertRaises(ValueError):
|
|
LinkTypes.get('whatever')
|
|
with self.assertRaises(ValueError):
|
|
LinkTypes.get('whatever', default="something-else")
|
|
|
|
|
|
class TestProfile(unittest.TestCase):
|
|
"""test case"""
|
|
|
|
def test_hash(self):
|
|
"""test profile hash"""
|
|
pro = Profile('some-profile')
|
|
self.assertIsNotNone(hash(pro))
|
|
|
|
def test_repr(self):
|
|
"""test profile repr"""
|
|
name = 'profile-name'
|
|
pro = Profile(name)
|
|
expected = f'profile(key:"{name}")'
|
|
self.assertEqual(repr(pro), expected)
|
|
|
|
def test_eq(self):
|
|
"""test profile eq"""
|
|
p1_name = 'profile-1'
|
|
pro1 = Profile(p1_name, dotfiles=['abc'])
|
|
p2_name = 'profile-2'
|
|
pro2 = Profile(p2_name)
|
|
p3_name = p1_name
|
|
pro3 = Profile(p3_name, dotfiles=['abc'])
|
|
p4_name = p1_name
|
|
pro4 = Profile(p4_name, dotfiles=['ab'])
|
|
self.assertNotEqual(pro1, pro2)
|
|
self.assertEqual(pro1, pro3)
|
|
self.assertNotEqual(pro1, pro4)
|
|
self.assertNotEqual(pro3, pro4)
|
|
|
|
|
|
def main():
|
|
"""entry point"""
|
|
unittest.main()
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|