class TestSettings:
@pytest.mark.parametrize("test_name,test_value,expected_exception,expected_result", [
("server", "127.0.0.1", does_not_raise(), "127.0.0.1"),
("manage_forward_zones", True, pytest.raises(AttributeError), []),
("does_not_exist", None, pytest.raises(KeyError), None)
])
def test_set(self, test_name, test_value, expected_exception, expected_result):
# Arrange
test_settings = Settings()
# Act
with expected_exception:
test_settings.set(test_name, test_value)
# Assert
assert test_settings.__dict__[test_name] == expected_result
def test_to_string(self):
# Arrange
test_settings = Settings()
# Act
result = test_settings.to_string()
# Assert
result_list = result.split("\n")
assert len(result_list) == 3
assert result_list[1] == "kernel options : {}"
def test_to_dict(self):
# Arrange
test_settings = Settings()
# Act
result = test_settings.to_dict()
# Assert
assert result == test_settings.__dict__
@pytest.mark.parametrize("parameter,expected_exception,expected_result", [
({}, does_not_raise(), "127.0.0.1"),
(None, does_not_raise(), "127.0.0.1")
])
def test_from_dict(self, parameter, expected_exception, expected_result):
# Arrange
test_settings = Settings()
# Act
with expected_exception:
test_settings.from_dict(parameter)
# Assert
assert test_settings.server == expected_result
class TestSettings:
def test_to_string(self):
# Arrange
test_settings = Settings()
# Act
result = test_settings.to_string()
# Assert
result_list = result.split("\n")
assert len(result_list) == 3
assert result_list[1] == "kernel options : {}"
def test_to_dict(self):
# Arrange
test_settings = Settings()
# Act
result = test_settings.to_dict()
# Assert
assert result == test_settings.__dict__
@pytest.mark.parametrize("parameter,expected_exception,expected_result",
[({}, does_not_raise(), "127.0.0.1"),
(None, does_not_raise(), "127.0.0.1")])
def test_from_dict(self, parameter, expected_exception, expected_result):
# Arrange
test_settings = Settings()
# Act
with expected_exception:
test_settings.from_dict(parameter)
# Assert
assert test_settings.server == expected_result
def test_boot_loaders():
# Arrange
test_api = CobblerAPI()
system = System(test_api)
# Act
system.boot_loaders = []
# Assert
assert system.boot_loaders == []
@pytest.mark.parametrize("value,expected", [
(0, does_not_raise()),
(0.0, pytest.raises(TypeError)),
("", does_not_raise()),
("Test", does_not_raise()),
([], pytest.raises(TypeError)),
({}, pytest.raises(TypeError)),
(None, pytest.raises(TypeError)),
(False, does_not_raise()),
(True, does_not_raise())
])
def test_enable_ipxe(value, expected):
# Arrange
test_api = CobblerAPI()
distro = System(test_api)
# Act
from cobbler.api import CobblerAPI
from tests.conftest import does_not_raise
# TODO: Extend the fillup and add more testcases
@pytest.fixture
def find_fillup():
test_api = CobblerAPI()
return test_api
@pytest.mark.parametrize(
"what,criteria,name,return_list,no_errors,expected_exception,expected_result",
[("", None, "test", False, False, does_not_raise(), None),
("", None, "", False, False, pytest.raises(ValueError), None),
("distro", {}, "test", False, False, does_not_raise(), None),
("distro", {}, "", False, False, pytest.raises(ValueError), None)])
def test_find_items(find_fillup, what, criteria, name, return_list, no_errors,
expected_exception, expected_result):
# Arrange
test_api = find_fillup
# Act
with expected_exception:
result = test_api.find_items(what, criteria, name, return_list,
no_errors)
# Assert
if expected_result is None:
class TestIndexFileStudentDataAccess:
@pytest.mark.parametrize(
'students, expected_index',
((
[
(Student(record_id=PrimaryKey(1),
first_name='first',
last_name='last',
birthday_date='2020-03-03'), 11),
(Student(record_id=PrimaryKey(3),
first_name='das',
last_name='das',
birthday_date='2020-03-03'), 22),
(Student(record_id=PrimaryKey(8),
first_name='cccc',
last_name='aaa',
birthday_date='2020-03-03'), 33),
],
[
None, 11, None, 22, None, None, None, None, 33, None, None,
None, None, None
],
), ),
)
def test_create_index(self, students, expected_index):
file_client = MagicMock()
file_client.iter_read.return_value = students
dao = IndexFileStudentDataAccess(file_client)
assert dao._index_array == expected_index
@pytest.mark.parametrize(
'current_index, record_id, expected_index, expected_exception',
(
([], PrimaryKey(3), [
None, None, None, None, None, None, None, None
], does_not_raise()),
([None, 123], PrimaryKey(1), [None, 123
], pytest.raises(DuplicateRecordId)),
),
)
def test_validate_record_id(self, current_index, record_id, expected_index,
expected_exception):
file_client = MagicMock()
file_client.iter_read.return_value = ()
dao = IndexFileStudentDataAccess(file_client)
dao._index_array = current_index
with expected_exception:
dao._validate_record_id(record_id)
assert dao._index_array == expected_index
@pytest.mark.parametrize(
'key, current_index, expected_result, expected_exception',
((PrimaryKey(2), [None, None, 12], 12, does_not_raise()),
(PrimaryKey(1), [None, None, 12
], None, pytest.raises(RecordNotFound)),
(PrimaryKey(10), [None, None, 12
], None, pytest.raises(RecordNotFound))),
)
def test_get_position_by_key(self, key, current_index, expected_result,
expected_exception):
file_client = MagicMock()
file_client.iter_read.return_value = ()
dao = IndexFileStudentDataAccess(file_client)
dao._index_array = current_index
with expected_exception:
result = dao._get_position_by_key(key)
assert result == expected_result
@pytest.mark.parametrize(
'record_id, current_index, position, expected_index, expected_exception',
(
(PrimaryKey(2), [], 123, [None, None, 123, None, None, None
], does_not_raise()),
(PrimaryKey(1), [None, 222], 123, [None, 222],
pytest.raises(DuplicateRecordId)),
),
)
def test_add_student(self, record_id, current_index, position,
expected_index, expected_exception):
file_client = MagicMock()
file_client.iter_read.return_value = ()
file_client.write.return_value = position
dao = IndexFileStudentDataAccess(file_client)
dao._index_array = current_index
student = Student(record_id=record_id,
first_name='123',
last_name='123',
birthday_date='123')
with expected_exception:
dao.add_student(student)
assert dao._index_array == expected_index
)
def test_home_data_homes_by_id(home_data, home_id, expected):
assert home_data.homes[home_id]["name"] == expected
def test_home_data_get_selected_schedule(home_data):
assert (home_data._get_selected_schedule("91763b24c43d3e344f424e8b")
["name"] == "Default")
assert home_data._get_selected_schedule("Unknown") == {}
@pytest.mark.parametrize(
"t_home_id, t_sched_id, expected",
[
("91763b24c43d3e344f424e8b", "591b54a2764ff4d50d8b5795",
does_not_raise()),
(
"91763b24c43d3e344f424e8b",
"123456789abcdefg12345678",
pytest.raises(pyatmo.NoSchedule),
),
],
)
def test_home_data_switch_home_schedule(
home_data,
requests_mock,
t_home_id,
t_sched_id,
expected,
):
with open("fixtures/status_ok.json") as json_file:
import pytest
from unittest.mock import Mock, MagicMock, create_autospec, PropertyMock
import cobbler.actions.sync
import cobbler.modules.managers.bind
import cobbler.modules.managers.isc
from cobbler.api import CobblerAPI
from tests.conftest import does_not_raise
@pytest.mark.parametrize("input_verbose,input_what,expected_exception",
[(None, None, does_not_raise()),
(True, [], does_not_raise()),
(False, [], does_not_raise()),
(True, ["dhcp"], does_not_raise()),
(True, ["dns"], does_not_raise()),
(True, ["dns", "dhcp"], does_not_raise())])
def test_sync(input_verbose, input_what, expected_exception, mocker):
# Arrange
stub = create_autospec(spec=cobbler.actions.sync.CobblerSync)
stub_dhcp = mocker.stub()
stub_dns = mocker.stub()
mocker.patch.object(CobblerAPI, "get_sync", return_value=stub)
mocker.patch.object(CobblerAPI, "sync_dhcp", new=stub_dhcp)
mocker.patch.object(CobblerAPI, "sync_dns", new=stub_dns)
test_api = CobblerAPI()
# Act
with expected_exception:
test_api.sync(input_verbose, input_what)
@pytest.mark.parametrize("test_input,expected_result",
[("<<inherit>>", "<<inherit>>"), ("delete", [])])
def test_input_string_or_list(test_input, expected_result):
# Arrange
# Act
result = utils.input_string_or_list(test_input)
# Assert
assert expected_result == result
@pytest.mark.parametrize("testinput,expected_result,possible_exception",
[("<<inherit>>", (True, {}), does_not_raise()),
([""], None, pytest.raises(CX)),
("a b=10 c=abc", (True, {
"a": None,
"b": '10',
"c": "abc"
}), does_not_raise()),
({
"ab": 0
}, (True, {
"ab": 0
}), does_not_raise()), (0, None, pytest.raises(CX))])
def test_input_string_or_dict(testinput, expected_result, possible_exception):
# Arrange
# Act
# ("sync_post_wingen")
])
def test_get_module_by_name(module_name):
# Arrange -> Done in fixtures
# Act
returned_module = module_loader.get_module_by_name(module_name)
# Assert
assert isinstance(returned_module.register(), str)
@pytest.mark.usefixtures("reset_modules", "load_modules")
@pytest.mark.parametrize(
"module_section,fallback_name,expected_result,expected_exception",
[("authentication", "", "authentication.configfile", does_not_raise()),
("authorization", "", "authorization.allowall", does_not_raise()),
("dns", "", "managers.bind", does_not_raise()),
("dhcp", "", "managers.isc", does_not_raise()),
("tftpd", "", "managers.in_tftpd", does_not_raise()),
("wrong_section", None, "", pytest.raises(CX)),
("wrong_section", "authentication.configfile",
"authentication.configfile", does_not_raise())])
def test_get_module_name(module_section, fallback_name, expected_result,
expected_exception):
# Arrange -> Done in fixtures
# Act
with expected_exception:
result_name = module_loader.get_module_name(module_section, "module",
fallback_name)
def test_make_clone():
# Arrange
test_api = CobblerAPI()
file = File(test_api)
# Act
clone = file.make_clone()
# Assert
assert clone != file
# Properties Tests
@pytest.mark.parametrize("value,expected_exception",
[(False, does_not_raise())])
def test_is_dir(value, expected_exception):
# Arrange
test_api = CobblerAPI()
file = File(test_api)
# Act
with expected_exception:
file.is_dir = value
# Assert
assert file.is_dir is value
def test_set_virt_file_size():
# Arrange
# Act
# TODO: Test multiple disks via comma separation
result = validate.validate_virt_file_size("8")
# Assert
assert isinstance(result, float)
assert result == 8
@pytest.mark.parametrize("test_autoboot,expectation",
[(True, does_not_raise()), (False, does_not_raise()),
(0, does_not_raise()), (1, does_not_raise()),
(2, does_not_raise()), ("Test", does_not_raise())])
def test_set_virt_auto_boot(test_autoboot, expectation):
# Arrange
# Act
with expectation:
result = validate.validate_virt_auto_boot(test_autoboot)
# Assert
assert isinstance(result, bool)
assert result is True or result is False
@pytest.mark.parametrize("test_input,expected_exception",
import pytest
from cobbler import enums, utils, validate
from cobbler.api import CobblerAPI
from tests.conftest import does_not_raise
@pytest.mark.parametrize("test_architecture,test_raise",
[(enums.Archs.X86_64, does_not_raise()),
("x86_64", does_not_raise()),
("abc", pytest.raises(ValueError)),
(0, pytest.raises(TypeError))])
def test_validate_arch(test_architecture, test_raise):
# Arrange
# Act
with test_raise:
result = validate.validate_arch(test_architecture)
# Assert
if isinstance(test_architecture, str):
assert result.value == test_architecture
elif isinstance(test_architecture, enums.Archs):
assert result == test_architecture
else:
raise TypeError("result had a non expected result")
def test_validate_os_version():
# Arrange
utils.load_signatures("/var/lib/cobbler/distro_signatures.json")
(True),
(False)
])
def test_is_uefi_system(os_path_return, mocker):
# Arrange
mocker.patch("os.path.exists", return_value=os_path_return)
# Act
result = utils.is_uefi_system()
# Assert
assert result is os_path_return
@pytest.mark.parametrize("shutil_which_return,expected_exception", [
("/usr/bin/grub2-mkrelpath", does_not_raise()),
(None, pytest.raises(RuntimeError))
])
def test_get_grub2_mkrelpath_executable(shutil_which_return, expected_exception, mocker):
# Arrange
mocker.patch("shutil.which", return_value=shutil_which_return)
# Act
with expected_exception:
result = utils.get_grub2_mkrelpath_executable()
# Assert
assert result == shutil_which_return
@pytest.mark.parametrize("mocked_process_result,mocked_os_path_exists,expected_exception", [
from libcobblersignatures.models.osversion import Osversion
from tests.conftest import does_not_raise
def test_new_osversion():
Osversion()
def test_osversion_equality():
assert Osversion() == Osversion()
@pytest.mark.parametrize("param,result,raises",
[({"RedHat/RPMS", "CentOS/RPMS"},
{"RedHat/RPMS", "CentOS/RPMS"}, does_not_raise()),
("", set(), pytest.raises(TypeError))])
def test_signatures(param, result, raises):
# Arrange
version = Osversion()
# Act
with raises:
version.signatures = param
# Assert
assert version.signatures == result
def test_signatures_del():
# Arrange
titem = Distro(test_api)
# Act
result = titem.to_dict()
# Assert
assert isinstance(result, dict)
assert "autoinstall_meta" in result
assert "ks_meta" in result
# TODO check more fields
# Properties Tests
@pytest.mark.parametrize("value,expected", [
(0, does_not_raise()),
(0.0, does_not_raise()),
("", pytest.raises(TypeError)),
("Test", pytest.raises(TypeError)),
([], pytest.raises(TypeError)),
({}, pytest.raises(TypeError)),
(None, pytest.raises(TypeError))
])
def test_tree_build_time(value, expected):
# Arrange
test_api = CobblerAPI()
distro = Distro(test_api)
# Act
with expected:
distro.tree_build_time = value
import pytest
from cobbler import grub
from tests.conftest import does_not_raise
@pytest.mark.parametrize(
"input_file_location,expected_output,expected_exception", [
(None, None, pytest.raises(TypeError)),
("ftp://testuri", None, does_not_raise()),
("http://testuri", None, pytest.raises(ValueError)),
("tftp://testuri", None, pytest.raises(ValueError)),
("wss://testuri", None, does_not_raise()),
("http://10.0.0.1", "(http,10.0.0.1)/", does_not_raise()),
("tftp://10.0.0.1", "(tftp,10.0.0.1)/", does_not_raise()),
("tftp://10.0.0.1/testpath/testpath/",
"(tftp,10.0.0.1)/testpath/testpath/", does_not_raise()),
])
def test_parse_grub_remote_file(input_file_location, expected_output,
expected_exception):
# Arrange & Act
with expected_exception:
result = grub.parse_grub_remote_file(input_file_location)
# Assert
assert result == expected_output
@pytest.mark.parametrize("test_input,expected_result", [
("<<inherit>>", "<<inherit>>"),
("delete", [])
])
def test_input_string_or_list(test_input, expected_result):
# Arrange
# Act
result = utils.input_string_or_list(test_input)
# Assert
assert expected_result == result
@pytest.mark.parametrize("testinput,expected_result,possible_exception", [
("<<inherit>>", (True, {}), does_not_raise()),
([""], None, pytest.raises(CX)),
("a b=10 c=abc", (True, {"a": None, "b": '10', "c": "abc"}), does_not_raise()),
({"ab": 0}, (True, {"ab": 0}), does_not_raise()),
(0, None, pytest.raises(CX))
])
def test_input_string_or_dict(testinput, expected_result, possible_exception):
# Arrange
# Act
with possible_exception:
result = utils.input_string_or_dict(testinput)
# Assert
assert expected_result == result
assert system.autoinstall == ""
def test_boot_loaders():
# Arrange
test_api = CobblerAPI()
system = System(test_api)
# Act
system.boot_loaders = []
# Assert
assert system.boot_loaders == []
@pytest.mark.parametrize("value,expected", [(0, does_not_raise()),
(0.0, pytest.raises(TypeError)),
("", does_not_raise()),
("Test", does_not_raise()),
([], pytest.raises(TypeError)),
({}, pytest.raises(TypeError)),
(None, pytest.raises(TypeError)),
(False, does_not_raise()),
(True, does_not_raise())])
def test_enable_ipxe(value, expected):
# Arrange
test_api = CobblerAPI()
distro = System(test_api)
# Act
with expected:
titem = Distro(test_api)
# Act
result = titem.to_dict()
# Assert
assert isinstance(result, dict)
assert "autoinstall_meta" in result
assert "ks_meta" in result
# TODO check more fields
# Properties Tests
@pytest.mark.parametrize("value,expected", [(0, does_not_raise()),
(0.0, does_not_raise()),
("", pytest.raises(TypeError)),
("Test", pytest.raises(TypeError)),
([], pytest.raises(TypeError)),
({}, pytest.raises(TypeError)),
(None, pytest.raises(TypeError))])
def test_tree_build_time(value, expected):
# Arrange
test_api = CobblerAPI()
distro = Distro(test_api)
# Act
with expected:
distro.tree_build_time = value
class TestBuildiso:
"""Since BuildIso needs the collection manager and thus the api, as well as other information this test will
require greater setup, although only this class shall be tested. Mocks are hard to program and we will try to
avoid them.
"""
@pytest.mark.parametrize(
"input_arch,result_binary_name,expected_exception",
[
(enums.Archs.X86_64, "grubx86.efi", does_not_raise()),
(enums.Archs.PPC, "grub.ppc64le", does_not_raise()),
(enums.Archs.PPC64, "grub.ppc64le", does_not_raise()),
(enums.Archs.PPC64EL, "grub.ppc64le", does_not_raise()),
(enums.Archs.PPC64LE, "grub.ppc64le", does_not_raise()),
(enums.Archs.AARCH64, "grubaa64.efi", does_not_raise()),
(enums.Archs.ARM, "bootarm.efi", does_not_raise()),
(enums.Archs.I386, "bootia32.efi", does_not_raise()),
(enums.Archs.IA64, "bootia64.efi", does_not_raise()),
],
)
def test_calculate_grub_name(self, input_arch, result_binary_name,
expected_exception, api):
# Arrange
test_builder = buildiso.BuildIso(api)
test_distro = Distro(api)
test_distro.name = "testdistro"
test_distro.arch = input_arch
# Act
with expected_exception:
result = test_builder.calculate_grub_name(test_distro)
# Assert
assert result == result_binary_name
@pytest.mark.parametrize(
"input_kopts_dict,exepcted_output",
[
({}, ""),
({
"test": 1
}, " test=1"),
({
"test": None
}, " test"),
({
"test": '"test"'
}, ' test="test"'),
({
"test": "test test test"
}, ' test="test test test"'),
({
"test": 'test "test" test'
}, ' test="test "test" test"'),
({
"test": ['"test"']
}, ' test="test"'),
({
"test": ['"test"', "test"]
}, ' test="test" test=test'),
],
)
def test_add_remaining_kopts(self, input_kopts_dict, exepcted_output):
# Arrange (missing)
# Act
output = buildiso.add_remaining_kopts(input_kopts_dict)
# Assert
assert output == exepcted_output
def test_make_shorter(self, api):
# Arrange
build_iso = NetbootBuildiso(api)
distroname = "Testdistro"
# Act
result = build_iso.make_shorter(distroname)
# Assert
assert type(result) == str
assert distroname in build_iso.distmap
assert result == "1"
def test_copy_boot_files(self, api, create_kernel_initrd, fk_kernel,
fk_initrd, tmpdir):
# Arrange
target_folder = tmpdir.mkdir("target")
folder = create_kernel_initrd(fk_kernel, fk_initrd)
kernel_path = os.path.join(folder, fk_kernel)
initrd_path = os.path.join(folder, fk_initrd)
build_iso = buildiso.BuildIso(api)
testdistro = Distro(api)
testdistro.name = "testdistro"
testdistro.kernel = kernel_path
testdistro.initrd = initrd_path
# Act
build_iso.copy_boot_files(testdistro, target_folder)
# Assert
assert len(os.listdir(target_folder)) == 2
def test_filter_system(self, api, create_kernel_initrd, fk_kernel,
fk_initrd):
# Arrange
folder = create_kernel_initrd(fk_kernel, fk_initrd)
kernel_path = os.path.join(folder, fk_kernel)
initrd_path = os.path.join(folder, fk_initrd)
test_distro = Distro(api)
test_distro.name = "testdistro"
test_distro.kernel = kernel_path
test_distro.initrd = initrd_path
api.add_distro(test_distro)
test_profile = Profile(api)
test_profile.name = "testprofile"
test_profile.distro = test_distro.name
api.add_profile(test_profile)
test_system = System(api)
test_system.name = "testsystem"
test_system.profile = test_profile.name
api.add_system(test_system)
itemlist = [test_system.name]
build_iso = NetbootBuildiso(api)
expected_result = [test_system]
# Act
result = build_iso.filter_systems(itemlist)
# Assert
assert expected_result == result
def test_filter_profile(self, api, create_kernel_initrd, fk_kernel,
fk_initrd, cleanup_items):
# Arrange
folder = create_kernel_initrd(fk_kernel, fk_initrd)
kernel_path = os.path.join(folder, fk_kernel)
initrd_path = os.path.join(folder, fk_initrd)
test_distro = Distro(api)
test_distro.name = "testdistro"
test_distro.kernel = kernel_path
test_distro.initrd = initrd_path
api.add_distro(test_distro)
test_profile = Profile(api)
test_profile.name = "testprofile"
test_profile.distro = test_distro.name
api.add_profile(test_profile)
itemlist = [test_profile.name]
build_iso = buildiso.BuildIso(api)
expected_result = [test_profile]
# Act
result = build_iso.filter_profiles(itemlist)
# Assert
assert expected_result == result
def test_netboot_run(
self,
api,
create_kernel_initrd,
fk_kernel,
fk_initrd,
cleanup_items,
create_loaders,
tmpdir,
):
# Arrange
folder = create_kernel_initrd(fk_kernel, fk_initrd)
kernel_path = os.path.join(folder, fk_kernel)
initrd_path = os.path.join(folder, fk_initrd)
test_distro = Distro(api)
test_distro.name = "testdistro"
test_distro.kernel = kernel_path
test_distro.initrd = initrd_path
api.add_distro(test_distro)
build_iso = NetbootBuildiso(api)
iso_location = tmpdir.join("autoinst.iso")
# Act
build_iso.run(iso=str(iso_location), distro_name=test_distro.name)
# Assert
assert iso_location.exists()
def test_standalone_run(
self,
api,
create_kernel_initrd,
fk_kernel,
fk_initrd,
create_loaders,
tmpdir_factory,
cleanup_items,
):
# Arrange
iso_directory = tmpdir_factory.mktemp("isodir")
iso_source = tmpdir_factory.mktemp("isosource")
iso_location = iso_directory.join("autoinst.iso")
folder = create_kernel_initrd(fk_kernel, fk_initrd)
kernel_path = os.path.join(folder, fk_kernel)
initrd_path = os.path.join(folder, fk_initrd)
test_distro = Distro(api)
test_distro.name = "testdistro"
test_distro.kernel = kernel_path
test_distro.initrd = initrd_path
api.add_distro(test_distro)
build_iso = StandaloneBuildiso(api)
# Act
build_iso.run(iso=str(iso_location),
distro_name=test_distro.name,
source=str(iso_source))
# Assert
assert iso_location.exists()
@pytest.mark.parametrize("test_input,expected_result", [
("<<inherit>>", "<<inherit>>"),
("delete", [])
])
def test_input_string_or_list(test_input, expected_result):
# Arrange
# Act
result = utils.input_string_or_list(test_input)
# Assert
assert expected_result == result
@pytest.mark.parametrize("testinput,expected_result,possible_exception", [
("<<inherit>>", (True, {}), does_not_raise()),
([""], None, pytest.raises(TypeError)),
("a b=10 c=abc", (True, {"a": None, "b": '10', "c": "abc"}), does_not_raise()),
({"ab": 0}, (True, {"ab": 0}), does_not_raise()),
(0, None, pytest.raises(TypeError))
])
def test_input_string_or_dict(testinput, expected_result, possible_exception):
# Arrange
# Act
with possible_exception:
result = utils.input_string_or_dict(testinput)
# Assert
assert expected_result == result
@pytest.mark.parametrize("test_input,expected_result",
[("<<inherit>>", "<<inherit>>"), ("delete", [])])
def test_input_string_or_list(test_input, expected_result):
# Arrange
# Act
result = utils.input_string_or_list(test_input)
# Assert
assert expected_result == result
@pytest.mark.parametrize("testinput,expected_result,possible_exception",
[("<<inherit>>", (True, {}), does_not_raise()),
([""], None, pytest.raises(TypeError)),
("a b=10 c=abc", (True, {
"a": None,
"b": '10',
"c": "abc"
}), does_not_raise()),
({
"ab": 0
}, (True, {
"ab": 0
}), does_not_raise()),
(0, None, pytest.raises(TypeError))])
def test_input_string_or_dict(testinput, expected_result, possible_exception):
# Arrange
def test_proxy():
# Arrange
test_api = CobblerAPI()
profile = Profile(test_api)
# Act
profile.proxy = ""
# Assert
assert profile.proxy == ""
@pytest.mark.parametrize("value,expected_exception", [
(False, does_not_raise())
])
def test_enable_ipxe(value, expected_exception):
# Arrange
test_api = CobblerAPI()
profile = Profile(test_api)
# Act
with expected_exception:
profile.enable_ipxe = value
# Assert
assert profile.enable_ipxe is value
@pytest.mark.parametrize("value,expected_exception", [
import pytest
from unittest.mock import Mock, MagicMock, create_autospec, PropertyMock
import cobbler.actions.sync
import cobbler.modules.managers.bind
import cobbler.modules.managers.isc
from cobbler.api import CobblerAPI
from tests.conftest import does_not_raise
@pytest.mark.parametrize("input_verbose,input_what,expected_exception",
[(None, None, does_not_raise()),
(True, [], does_not_raise()),
(False, [], does_not_raise()),
(True, ["dhcp"], does_not_raise()),
(True, ["dns"], does_not_raise()),
(True, ["dns", "dhcp"], does_not_raise())])
def test_sync(input_verbose, input_what, expected_exception, mocker):
# Arrange
stub = create_autospec(spec=cobbler.actions.sync.CobblerSync)
stub_dhcp = mocker.stub()
stub_dns = mocker.stub()
mocker.patch.object(CobblerAPI, "get_sync", return_value=stub)
mocker.patch.object(CobblerAPI, "sync_dhcp", new=stub_dhcp)
mocker.patch.object(CobblerAPI, "sync_dns", new=stub_dns)
test_api = CobblerAPI()
# Act
with expected_exception:
test_api.sync(input_verbose, input_what)
class TestFileStudentDataAccess:
def test_add_student(self):
file_client = MagicMock()
dao = FileStudentDataAccess(file_client)
student = Student(record_id=PrimaryKey(1),
first_name='first',
last_name='last',
birthday_date='2020-03-03')
dao.add_student(student)
file_client.write.assert_called_once_with(student)
@pytest.mark.parametrize(
'students, record_id_to_find, expected_result, expected_exception',
(
(
[
(Student(record_id=PrimaryKey(1),
first_name='first',
last_name='last',
birthday_date='2020-03-03'), 0),
(Student(record_id=PrimaryKey(2),
first_name='das',
last_name='das',
birthday_date='2020-03-03'), 1),
(Student(record_id=PrimaryKey(3),
first_name='cccc',
last_name='aaa',
birthday_date='2020-03-03'), 2),
],
PrimaryKey(2),
Student(record_id=PrimaryKey(2),
first_name='das',
last_name='das',
birthday_date='2020-03-03'),
does_not_raise(),
),
(
[
(Student(record_id=PrimaryKey(1),
first_name='first',
last_name='last',
birthday_date='2020-03-03'), 0),
(Student(record_id=PrimaryKey(2),
first_name='das',
last_name='das',
birthday_date='2020-03-03'), 1),
],
PrimaryKey(3),
None,
pytest.raises(RecordNotFound),
),
),
)
def test_get_student(self, students, record_id_to_find, expected_result,
expected_exception):
file_client = MagicMock()
file_client.iter_read.return_value = students
dao = FileStudentDataAccess(file_client)
with expected_exception:
result = dao.get_student(record_id_to_find)
assert result == expected_result
import pytest
from cobbler import enums
from tests.conftest import does_not_raise
@pytest.mark.parametrize(
"test_architecture,test_raise",
[
(enums.Archs.X86_64, does_not_raise()),
("x86_64", does_not_raise()),
("abc", pytest.raises(ValueError)),
(0, pytest.raises(TypeError)),
],
)
def test_validate_arch(test_architecture, test_raise):
# Arrange
# Act
with test_raise:
result = enums.Archs.to_enum(test_architecture)
# Assert
if isinstance(test_architecture, str):
assert result.value == test_architecture
elif isinstance(test_architecture, enums.Archs):
assert result == test_architecture
else:
raise TypeError("result had a non expected result")
assert False
@pytest.mark.skip
def test_set_ctime():
# Arrange
titem = Item()
# Act
titem.set_ctime()
# Assert
assert False
@pytest.mark.parametrize("value,expected_exception",
[(0.0, does_not_raise()),
(0, pytest.raises(TypeError)),
("", pytest.raises(TypeError))])
def test_mtime(value, expected_exception):
# Arrange
test_api = CobblerAPI()
titem = Item(test_api)
# Act
with expected_exception:
titem.mtime = value
# Assert
assert titem.mtime == value
assert expected == result
def test_exportsignatures_unkown():
# Arrange
os_signatures = Signatures()
os_signatures.importsignatures(ImportTypes.STRING, "{\"breeds\": {}}")
# Act & Assert
with pytest.raises(ValueError):
os_signatures.exportsignatures(100)
@pytest.mark.parametrize("input_data,result,raises", [
("{\"breeds; {}}", {}, pytest.raises(JSONDecodeError)),
("{\"breeds\": {}}", {"breeds": {}}, does_not_raise())
])
def test_signaturesjson(input_data, result, raises):
# Arrange
os_signatures = Signatures()
with raises:
os_signatures.importsignatures(ImportTypes.STRING, input_data)
# Act
os_signatures.signaturesjson = input_data
# Assert
assert result == os_signatures.signaturesjson
@pytest.mark.parametrize("input_data,expected_data", [
