From f7d45d9a5197bca8dfcb12a45e942de55a197758 Mon Sep 17 00:00:00 2001 From: Matt Prahl Date: Feb 10 2017 15:08:45 +0000 Subject: Prefex tests with 'test_' so they are easily discovered with testing tools --- diff --git a/modulemd/tests/basic.py b/modulemd/tests/basic.py deleted file mode 100644 index fde75f4..0000000 --- a/modulemd/tests/basic.py +++ /dev/null @@ -1,193 +0,0 @@ -#/usr/bin/python3 -# -*- coding: utf-8 -*- - - -# Copyright (c) 2016 Red Hat, Inc. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -# -# Written by Petr Šabata - -import unittest - -import os -import sys - -DIR = os.path.dirname(__file__) -sys.path.insert(0, os.path.join(DIR, "..")) - -from modulemd import ModuleMetadata -from modulemd import supported_mdversions -from modulemd.profile import ModuleProfile -from modulemd.components.module import ModuleComponentModule -from modulemd.components.rpm import ModuleComponentRPM - -class TestBasic(unittest.TestCase): - @classmethod - def setUpClass(cls): - m = ModuleMetadata() - m.name = "name" - m.stream = "stream" - m.version = 1 - m.summary = "summary" - m.description = "description" - m.module_licenses = set(["module1", "module2", "module3"]) - m.content_licenses = set(["content1", "content2", "content3"]) - m.xmd = { "key" : "value" } - m.buildrequires = { - "br1" : "br1stream", - "br2" : "br2stream", - "br3" : "br3stream" - } - m.requires = { - "r1" : "r1stream", - "r2" : "r2stream", - "r3" : "r3stream" - } - m.community = "community" - m.documentation = "documentation" - m.tracker = "tracker" - profile = ModuleProfile() - profile.description = "description" - profile.rpms = set(["prof1", "prof2", "prof3"]) - m.profiles = { "profile" : profile } - m.api.rpms = set(["api1", "api2", "api3"]) - m.filter.rpms = set(["filter1", "filter2", "filter3"]) - rpm = ModuleComponentRPM("rpm", "rationale", - buildorder=1, - repository="repository", - ref="ref", - cache="cache", - arches=set(["arch1", "arch2", "arch3"]), - multilib=set(["multi1", "multi2", "multi3"]) - ) - m.components.rpms = { "rpm" : rpm } - mod = ModuleComponentModule("mod", "rationale", - buildorder=2, - repository="repository", - ref="ref", - ) - m.components.modules = { "mod" : mod } - cls.mmd = m - - def test_mdversion(self): - self.assertIn(self.mmd.mdversion, supported_mdversions) - - def test_name(self): - self.assertEqual(self.mmd.name, "name") - - def test_stream(self): - self.assertEqual(self.mmd.stream, "stream") - - def test_version(self): - self.assertEqual(self.mmd.version, 1) - - def test_summary(self): - self.assertEqual(self.mmd.summary, "summary") - - def test_description(self): - self.assertEqual(self.mmd.description, "description") - - def test_module_licenses(self): - self.assertSetEqual( - self.mmd.module_licenses, - set(["module1", "module2", "module3"]) - ) - - def test_content_licenses(self): - self.assertSetEqual( - self.mmd.content_licenses, - set(["content1", "content2", "content3"]) - ) - - def test_xmd(self): - self.assertDictEqual(self.mmd.xmd, { "key" : "value" }) - - def test_buildrequires(self): - self.assertDictEqual( - self.mmd.buildrequires, - { - "br1" : "br1stream", - "br2" : "br2stream", - "br3" : "br3stream" - } - ) - - def test_requires(self): - self.assertDictEqual( - self.mmd.requires, - { - "r1" : "r1stream", - "r2" : "r2stream", - "r3" : "r3stream" - } - ) - - def test_community(self): - self.assertEqual(self.mmd.community, "community") - - def test_documentation(self): - self.assertEqual(self.mmd.documentation, "documentation") - - def test_tracker(self): - self.assertEqual(self.mmd.tracker, "tracker") - - def test_profiles(self): - self.assertEqual(list(self.mmd.profiles.keys()), ["profile"]) - self.assertEqual( - self.mmd.profiles["profile"].description, - "description" - ) - self.assertSetEqual( - self.mmd.profiles["profile"].rpms, - set(["prof1", "prof2", "prof3"]) - ) - - def test_api(self): - self.assertSetEqual( - self.mmd.api.rpms, - set(["api1", "api2", "api3"]) - ) - - def test_filter(self): - self.assertSetEqual( - self.mmd.filter.rpms, - set(["filter1", "filter2", "filter3"]) - ) - - def test_rpms(self): - self.assertEqual(list(self.mmd.components.rpms.keys()), ["rpm"]) - rpm = self.mmd.components.rpms["rpm"] - self.assertEqual(rpm.name, "rpm") - self.assertEqual(rpm.rationale, "rationale") - self.assertEqual(rpm.buildorder, 1) - self.assertEqual(rpm.repository, "repository") - self.assertEqual(rpm.ref, "ref") - self.assertEqual(rpm.cache, "cache") - self.assertSetEqual(rpm.arches, set(["arch1", "arch2", "arch3"])) - self.assertSetEqual(rpm.multilib, set(["multi1", "multi2", "multi3"])) - - def test_modules(self): - self.assertEqual(list(self.mmd.components.modules.keys()), ["mod"]) - mod = self.mmd.components.modules["mod"] - self.assertEqual(mod.name, "mod") - self.assertEqual(mod.rationale, "rationale") - self.assertEqual(mod.buildorder, 2) - self.assertEqual(mod.repository, "repository") - self.assertEqual(mod.ref, "ref") diff --git a/modulemd/tests/convenience.py b/modulemd/tests/convenience.py deleted file mode 100644 index 5696009..0000000 --- a/modulemd/tests/convenience.py +++ /dev/null @@ -1,233 +0,0 @@ -#/usr/bin/python3 -# -*- coding: utf-8 -*- - - -# Copyright (c) 2016 Red Hat, Inc. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -# -# Written by Petr Šabata - -import unittest - -import os -import sys - -DIR = os.path.dirname(__file__) -sys.path.insert(0, os.path.join(DIR, "..")) - -from modulemd import ModuleMetadata -from modulemd.profile import ModuleProfile -from modulemd.components.module import ModuleComponentModule -from modulemd.components.rpm import ModuleComponentRPM - -class TestConvenience(unittest.TestCase): - @classmethod - def setUpClass(cls): - cls.mmd = ModuleMetadata() - - def test_add_module_license(self): - self.assertSetEqual(self.mmd.module_licenses, set()) - self.mmd.add_module_license("test") - self.assertSetEqual(self.mmd.module_licenses, set(["test"])) - - def test_del_module_license(self): - self.mmd.module_licenses = set(["test"]) - self.mmd.del_module_license("test") - self.assertSetEqual(self.mmd.module_licenses, set()) - - def test_clear_module_licenses(self): - self.mmd.module_licenses = set(["test"]) - self.mmd.clear_module_licenses() - self.assertSetEqual(self.mmd.module_licenses, set()) - - def test_add_content_license(self): - self.assertSetEqual(self.mmd.content_licenses, set()) - self.mmd.add_content_license("test") - self.assertSetEqual(self.mmd.content_licenses, set(["test"])) - - def test_del_content_license(self): - self.mmd.content_licenses = set(["test"]) - self.mmd.del_content_license("test") - self.assertSetEqual(self.mmd.content_licenses, set()) - - def test_clear_content_licenses(self): - self.mmd.content_licenses = set(["test"]) - self.mmd.clear_content_licenses() - self.assertSetEqual(self.mmd.content_licenses, set()) - - def test_add_requires(self): - self.assertDictEqual(self.mmd.requires, dict()) - self.mmd.add_requires("key", "value") - self.assertDictEqual(self.mmd.requires, { "key" : "value" }) - - def test_update_requires(self): - self.assertDictEqual(self.mmd.requires, dict()) - self.mmd.update_requires("key", "value") - self.assertDictEqual(self.mmd.requires, { "key" : "value" }) - self.mmd.update_requires("key", "newvalue") - self.assertDictEqual(self.mmd.requires, { "key" : "newvalue" }) - - def test_del_requires(self): - self.mmd.requires = { "key" : "value" } - self.mmd.del_requires("key") - self.assertDictEqual(self.mmd.requires, dict()) - - def test_clear_requires(self): - self.mmd.requires = { "key" : "value" } - self.mmd.clear_requires() - self.assertDictEqual(self.mmd.requires, dict()) - - def test_add_buildrequires(self): - self.assertDictEqual(self.mmd.buildrequires, dict()) - self.mmd.add_buildrequires("key", "value") - self.assertDictEqual(self.mmd.buildrequires, { "key" : "value" }) - - def test_update_buildrequires(self): - self.assertDictEqual(self.mmd.buildrequires, dict()) - self.mmd.update_buildrequires("key", "value") - self.assertDictEqual(self.mmd.buildrequires, { "key" : "value" }) - self.mmd.update_buildrequires("key", "newvalue") - self.assertDictEqual(self.mmd.buildrequires, { "key" : "newvalue" }) - - def test_del_buildrequires(self): - self.mmd.buildrequires = { "key" : "value" } - self.mmd.del_buildrequires("key") - self.assertDictEqual(self.mmd.buildrequires, dict()) - - def test_clear_buildrequires(self): - self.mmd.buildrequires = { "key" : "value" } - self.mmd.clear_buildrequires() - self.assertDictEqual(self.mmd.buildrequires, dict()) - - def test_api_add_rpm(self): - self.assertSetEqual(self.mmd.api.rpms, set()) - self.mmd.api.add_rpm("test") - self.assertSetEqual(self.mmd.api.rpms, set(["test"])) - - def test_api_del_rpm(self): - self.mmd.api.rpms = set(["test"]) - self.mmd.api.del_rpm("test") - self.assertSetEqual(self.mmd.api.rpms, set()) - - def test_api_clear_rpms(self): - self.mmd.api.rpms = set(["test"]) - self.mmd.api.clear_rpms() - self.assertSetEqual(self.mmd.api.rpms, set()) - - def test_filter_add_rpm(self): - self.assertSetEqual(self.mmd.filter.rpms, set()) - self.mmd.filter.add_rpm("test") - self.assertSetEqual(self.mmd.filter.rpms, set(["test"])) - - def test_filter_del_rpm(self): - self.mmd.filter.rpms = set(["test"]) - self.mmd.filter.del_rpm("test") - self.assertSetEqual(self.mmd.filter.rpms, set()) - - def test_filter_clear_rpms(self): - self.mmd.filter.rpms = set(["test"]) - self.mmd.filter.clear_rpms() - self.assertSetEqual(self.mmd.filter.rpms, set()) - - def test_profile_add_rpm(self): - self.mmd.profiles = { "test" : ModuleProfile() } - self.assertSetEqual(self.mmd.profiles["test"].rpms, set()) - self.mmd.profiles["test"].add_rpm("test") - self.assertSetEqual(self.mmd.profiles["test"].rpms, set(["test"])) - - def test_profile_del_rpm(self): - self.mmd.profiles = { "test" : ModuleProfile() } - self.mmd.profiles["test"].rpms = set(["test"]) - self.mmd.profiles["test"].del_rpm("test") - self.assertSetEqual(self.mmd.profiles["test"].rpms, set()) - - def test_profile_clear_rpms(self): - self.mmd.profiles = { "test" : ModuleProfile() } - self.mmd.profiles["test"].rpms = set(["test"]) - self.mmd.profiles["test"].clear_rpms() - self.assertSetEqual(self.mmd.profiles["test"].rpms, set()) - - def test_components_all(self): - rpm = ModuleComponentRPM("rpm", "rationale") - mod = ModuleComponentModule("mod", "rationale") - self.mmd.components.rpms = { rpm.name : rpm } - self.mmd.components.modules = { mod.name : mod } - # XXX: It'd be nice if we could order these - self.assertListEqual(self.mmd.components.all, [rpm, mod]) - - def test_components_add_rpm(self): - self.assertDictEqual(self.mmd.components.rpms, dict()) - self.mmd.components.add_rpm("rpm", "rationale", buildorder=1, - repository="repository", ref="ref", cache="cache", - arches=set(["a1", "a2"]), multilib=set(["m1", "m2"])) - self.assertEqual(list(self.mmd.components.rpms.keys()), ["rpm"]) - self.assertIsInstance(self.mmd.components.rpms["rpm"], - ModuleComponentRPM) - self.assertEqual(self.mmd.components.rpms["rpm"].name, "rpm") - self.assertEqual(self.mmd.components.rpms["rpm"].rationale, "rationale") - self.assertEqual(self.mmd.components.rpms["rpm"].buildorder, 1) - self.assertEqual(self.mmd.components.rpms["rpm"].repository, "repository") - self.assertEqual(self.mmd.components.rpms["rpm"].ref, "ref") - self.assertEqual(self.mmd.components.rpms["rpm"].cache, "cache") - self.assertSetEqual(self.mmd.components.rpms["rpm"].arches, - set(["a1", "a2"])) - self.assertSetEqual(self.mmd.components.rpms["rpm"].multilib, - set(["m1", "m2"])) - - def test_components_del_rpm(self): - self.mmd.components.rpms = { - "rpm" : ModuleComponentRPM("rpm", "rationale") - } - self.mmd.components.del_rpm("rpm") - self.assertDictEqual(self.mmd.components.rpms, dict()) - - def test_components_clear_rpms(self): - self.mmd.components.rpms = { - "rpm" : ModuleComponentRPM("rpm", "rationale") - } - self.mmd.components.clear_rpms() - self.assertDictEqual(self.mmd.components.rpms, dict()) - - def test_components_add_module(self): - self.assertDictEqual(self.mmd.components.modules, dict()) - self.mmd.components.add_module("module", "rationale", buildorder=1, - repository="repository", ref="ref") - self.assertEqual(list(self.mmd.components.modules.keys()), ["module"]) - self.assertIsInstance(self.mmd.components.modules["module"], - ModuleComponentModule) - self.assertEqual(self.mmd.components.modules["module"].name, "module") - self.assertEqual(self.mmd.components.modules["module"].rationale, "rationale") - self.assertEqual(self.mmd.components.modules["module"].buildorder, 1) - self.assertEqual(self.mmd.components.modules["module"].repository, "repository") - self.assertEqual(self.mmd.components.modules["module"].ref, "ref") - - def test_components_del_module(self): - self.mmd.components.modules = { - "module" : ModuleComponentModule("module", "rationale") - } - self.mmd.components.del_module("module") - self.assertDictEqual(self.mmd.components.modules, dict()) - - def test_components_clear_modules(self): - self.mmd.components.modules = { - "module" : ModuleComponentModule("module", "rationale") - } - self.mmd.components.clear_modules() - self.assertDictEqual(self.mmd.components.modules, dict()) diff --git a/modulemd/tests/io.py b/modulemd/tests/io.py deleted file mode 100644 index 5f73b1e..0000000 --- a/modulemd/tests/io.py +++ /dev/null @@ -1,120 +0,0 @@ -#/usr/bin/python3 -# -*- coding: utf-8 -*- - - -# Copyright (c) 2016 Red Hat, Inc. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -# -# Written by Petr Šabata - -import unittest - -import os -import sys - -DIR = os.path.dirname(__file__) -sys.path.insert(0, os.path.join(DIR, "..")) - -from modulemd import ModuleMetadata - -class TestIO(unittest.TestCase): - - @classmethod - def setUpClass(cls): - cls.mmd = ModuleMetadata() - - def test_load_spec(self): - self.mmd.load("spec.yaml") - self.assertEqual(self.mmd.mdversion, 1) - self.assertEqual(self.mmd.name, "foo") - self.assertEqual(self.mmd.stream, "stream-name") - self.assertEqual(self.mmd.version, 20160927144203) - self.assertEqual(self.mmd.summary, "An example module") - self.assertEqual(self.mmd.description, "A module for the demonstration of the metadata format. Also, the obligatory lorem ipsum dolor sit amet goes right here.") - self.assertSetEqual(self.mmd.module_licenses, set(["MIT"])) - self.assertSetEqual(self.mmd.content_licenses, - set(["Beerware", "GPLv2+", "zlib"])) - self.assertEqual(self.mmd.xmd, {'some_key': 'some_data'}) - self.assertDictEqual(self.mmd.buildrequires, - { - "generational-core" : "and-its-stream-name", - "generational-core-build" : "and-its-stream-name-too" - }) - self.assertDictEqual(self.mmd.requires, - { - "generational-core" : "and-its-stream-name" - }) - self.assertEqual(self.mmd.community, "http://www.example.com/") - self.assertEqual(self.mmd.documentation, "http://www.example.com/") - self.assertEqual(self.mmd.tracker, "http://www.example.com/") - self.assertSetEqual(set(self.mmd.profiles.keys()), - set(["default", "minimal"])) - self.assertSetEqual(self.mmd.profiles["default"].rpms, - set(["bar", "bar-extras", "baz"])) - self.assertEqual(self.mmd.profiles["minimal"].description, - "Minimal profile installing only the bar package.") - self.assertSetEqual(self.mmd.profiles["minimal"].rpms, - set(["bar"])) - self.assertSetEqual(self.mmd.api.rpms, - set(["bar", "bar-extras", "baz", "xxx"])) - self.assertSetEqual(self.mmd.filter.rpms, - set(["baz-nonfoo"])) - self.assertSetEqual(set(self.mmd.components.rpms.keys()), - set(["bar", "baz", "xxx", "xyz"])) - self.assertEqual(self.mmd.components.rpms["bar"].rationale, - "We need this to demonstrate stuff.") - self.assertEqual(self.mmd.components.rpms["bar"].repository, - "https://pagure.io/bar.git") - self.assertEqual(self.mmd.components.rpms["bar"].ref, - "26ca0c0") - self.assertEqual(self.mmd.components.rpms["bar"].cache, - "https://example.com/cache") - self.assertEqual(self.mmd.components.rpms["baz"].rationale, - "This one is here to demonstrate other stuff.") - self.assertEqual(self.mmd.components.rpms["xxx"].rationale, - "xxx demonstrates arches and multilib.") - self.assertSetEqual(self.mmd.components.rpms["xxx"].arches, - set(["i686", "x86_64"])) - self.assertSetEqual(self.mmd.components.rpms["xxx"].multilib, - set(["x86_64"])) - self.assertEqual(self.mmd.components.rpms["xyz"].rationale, - "xyz is a bundled dependency of xxx.") - self.assertEqual(self.mmd.components.rpms["xyz"].buildorder, - 10) - self.assertSetEqual(set(self.mmd.components.modules), - set(["includedmodule"])) - self.assertEqual(self.mmd.components.modules["includedmodule"].rationale, - "Included in the stack, just because.") - self.assertEqual(self.mmd.components.modules["includedmodule"].repository, - "https://pagure.io/includedmodule.git") - self.assertEqual(self.mmd.components.modules["includedmodule"].ref, - "somecoolbranchname") - self.assertEqual(self.mmd.components.modules["includedmodule"].buildorder, - 100) - - def test_reload(self): - self.mmd.load("spec.yaml") - first = repr(self.mmd) - self.mmd.dump("testdump.yaml") - self.mmd = ModuleMetadata() - self.mmd.load("testdump.yaml") - second = repr(self.mmd) - self.assertEqual(first, second) - os.remove("testdump.yaml") diff --git a/modulemd/tests/test_basic.py b/modulemd/tests/test_basic.py new file mode 100644 index 0000000..fde75f4 --- /dev/null +++ b/modulemd/tests/test_basic.py @@ -0,0 +1,193 @@ +#/usr/bin/python3 +# -*- coding: utf-8 -*- + + +# Copyright (c) 2016 Red Hat, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# Written by Petr Šabata + +import unittest + +import os +import sys + +DIR = os.path.dirname(__file__) +sys.path.insert(0, os.path.join(DIR, "..")) + +from modulemd import ModuleMetadata +from modulemd import supported_mdversions +from modulemd.profile import ModuleProfile +from modulemd.components.module import ModuleComponentModule +from modulemd.components.rpm import ModuleComponentRPM + +class TestBasic(unittest.TestCase): + @classmethod + def setUpClass(cls): + m = ModuleMetadata() + m.name = "name" + m.stream = "stream" + m.version = 1 + m.summary = "summary" + m.description = "description" + m.module_licenses = set(["module1", "module2", "module3"]) + m.content_licenses = set(["content1", "content2", "content3"]) + m.xmd = { "key" : "value" } + m.buildrequires = { + "br1" : "br1stream", + "br2" : "br2stream", + "br3" : "br3stream" + } + m.requires = { + "r1" : "r1stream", + "r2" : "r2stream", + "r3" : "r3stream" + } + m.community = "community" + m.documentation = "documentation" + m.tracker = "tracker" + profile = ModuleProfile() + profile.description = "description" + profile.rpms = set(["prof1", "prof2", "prof3"]) + m.profiles = { "profile" : profile } + m.api.rpms = set(["api1", "api2", "api3"]) + m.filter.rpms = set(["filter1", "filter2", "filter3"]) + rpm = ModuleComponentRPM("rpm", "rationale", + buildorder=1, + repository="repository", + ref="ref", + cache="cache", + arches=set(["arch1", "arch2", "arch3"]), + multilib=set(["multi1", "multi2", "multi3"]) + ) + m.components.rpms = { "rpm" : rpm } + mod = ModuleComponentModule("mod", "rationale", + buildorder=2, + repository="repository", + ref="ref", + ) + m.components.modules = { "mod" : mod } + cls.mmd = m + + def test_mdversion(self): + self.assertIn(self.mmd.mdversion, supported_mdversions) + + def test_name(self): + self.assertEqual(self.mmd.name, "name") + + def test_stream(self): + self.assertEqual(self.mmd.stream, "stream") + + def test_version(self): + self.assertEqual(self.mmd.version, 1) + + def test_summary(self): + self.assertEqual(self.mmd.summary, "summary") + + def test_description(self): + self.assertEqual(self.mmd.description, "description") + + def test_module_licenses(self): + self.assertSetEqual( + self.mmd.module_licenses, + set(["module1", "module2", "module3"]) + ) + + def test_content_licenses(self): + self.assertSetEqual( + self.mmd.content_licenses, + set(["content1", "content2", "content3"]) + ) + + def test_xmd(self): + self.assertDictEqual(self.mmd.xmd, { "key" : "value" }) + + def test_buildrequires(self): + self.assertDictEqual( + self.mmd.buildrequires, + { + "br1" : "br1stream", + "br2" : "br2stream", + "br3" : "br3stream" + } + ) + + def test_requires(self): + self.assertDictEqual( + self.mmd.requires, + { + "r1" : "r1stream", + "r2" : "r2stream", + "r3" : "r3stream" + } + ) + + def test_community(self): + self.assertEqual(self.mmd.community, "community") + + def test_documentation(self): + self.assertEqual(self.mmd.documentation, "documentation") + + def test_tracker(self): + self.assertEqual(self.mmd.tracker, "tracker") + + def test_profiles(self): + self.assertEqual(list(self.mmd.profiles.keys()), ["profile"]) + self.assertEqual( + self.mmd.profiles["profile"].description, + "description" + ) + self.assertSetEqual( + self.mmd.profiles["profile"].rpms, + set(["prof1", "prof2", "prof3"]) + ) + + def test_api(self): + self.assertSetEqual( + self.mmd.api.rpms, + set(["api1", "api2", "api3"]) + ) + + def test_filter(self): + self.assertSetEqual( + self.mmd.filter.rpms, + set(["filter1", "filter2", "filter3"]) + ) + + def test_rpms(self): + self.assertEqual(list(self.mmd.components.rpms.keys()), ["rpm"]) + rpm = self.mmd.components.rpms["rpm"] + self.assertEqual(rpm.name, "rpm") + self.assertEqual(rpm.rationale, "rationale") + self.assertEqual(rpm.buildorder, 1) + self.assertEqual(rpm.repository, "repository") + self.assertEqual(rpm.ref, "ref") + self.assertEqual(rpm.cache, "cache") + self.assertSetEqual(rpm.arches, set(["arch1", "arch2", "arch3"])) + self.assertSetEqual(rpm.multilib, set(["multi1", "multi2", "multi3"])) + + def test_modules(self): + self.assertEqual(list(self.mmd.components.modules.keys()), ["mod"]) + mod = self.mmd.components.modules["mod"] + self.assertEqual(mod.name, "mod") + self.assertEqual(mod.rationale, "rationale") + self.assertEqual(mod.buildorder, 2) + self.assertEqual(mod.repository, "repository") + self.assertEqual(mod.ref, "ref") diff --git a/modulemd/tests/test_convenience.py b/modulemd/tests/test_convenience.py new file mode 100644 index 0000000..5696009 --- /dev/null +++ b/modulemd/tests/test_convenience.py @@ -0,0 +1,233 @@ +#/usr/bin/python3 +# -*- coding: utf-8 -*- + + +# Copyright (c) 2016 Red Hat, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# Written by Petr Šabata + +import unittest + +import os +import sys + +DIR = os.path.dirname(__file__) +sys.path.insert(0, os.path.join(DIR, "..")) + +from modulemd import ModuleMetadata +from modulemd.profile import ModuleProfile +from modulemd.components.module import ModuleComponentModule +from modulemd.components.rpm import ModuleComponentRPM + +class TestConvenience(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.mmd = ModuleMetadata() + + def test_add_module_license(self): + self.assertSetEqual(self.mmd.module_licenses, set()) + self.mmd.add_module_license("test") + self.assertSetEqual(self.mmd.module_licenses, set(["test"])) + + def test_del_module_license(self): + self.mmd.module_licenses = set(["test"]) + self.mmd.del_module_license("test") + self.assertSetEqual(self.mmd.module_licenses, set()) + + def test_clear_module_licenses(self): + self.mmd.module_licenses = set(["test"]) + self.mmd.clear_module_licenses() + self.assertSetEqual(self.mmd.module_licenses, set()) + + def test_add_content_license(self): + self.assertSetEqual(self.mmd.content_licenses, set()) + self.mmd.add_content_license("test") + self.assertSetEqual(self.mmd.content_licenses, set(["test"])) + + def test_del_content_license(self): + self.mmd.content_licenses = set(["test"]) + self.mmd.del_content_license("test") + self.assertSetEqual(self.mmd.content_licenses, set()) + + def test_clear_content_licenses(self): + self.mmd.content_licenses = set(["test"]) + self.mmd.clear_content_licenses() + self.assertSetEqual(self.mmd.content_licenses, set()) + + def test_add_requires(self): + self.assertDictEqual(self.mmd.requires, dict()) + self.mmd.add_requires("key", "value") + self.assertDictEqual(self.mmd.requires, { "key" : "value" }) + + def test_update_requires(self): + self.assertDictEqual(self.mmd.requires, dict()) + self.mmd.update_requires("key", "value") + self.assertDictEqual(self.mmd.requires, { "key" : "value" }) + self.mmd.update_requires("key", "newvalue") + self.assertDictEqual(self.mmd.requires, { "key" : "newvalue" }) + + def test_del_requires(self): + self.mmd.requires = { "key" : "value" } + self.mmd.del_requires("key") + self.assertDictEqual(self.mmd.requires, dict()) + + def test_clear_requires(self): + self.mmd.requires = { "key" : "value" } + self.mmd.clear_requires() + self.assertDictEqual(self.mmd.requires, dict()) + + def test_add_buildrequires(self): + self.assertDictEqual(self.mmd.buildrequires, dict()) + self.mmd.add_buildrequires("key", "value") + self.assertDictEqual(self.mmd.buildrequires, { "key" : "value" }) + + def test_update_buildrequires(self): + self.assertDictEqual(self.mmd.buildrequires, dict()) + self.mmd.update_buildrequires("key", "value") + self.assertDictEqual(self.mmd.buildrequires, { "key" : "value" }) + self.mmd.update_buildrequires("key", "newvalue") + self.assertDictEqual(self.mmd.buildrequires, { "key" : "newvalue" }) + + def test_del_buildrequires(self): + self.mmd.buildrequires = { "key" : "value" } + self.mmd.del_buildrequires("key") + self.assertDictEqual(self.mmd.buildrequires, dict()) + + def test_clear_buildrequires(self): + self.mmd.buildrequires = { "key" : "value" } + self.mmd.clear_buildrequires() + self.assertDictEqual(self.mmd.buildrequires, dict()) + + def test_api_add_rpm(self): + self.assertSetEqual(self.mmd.api.rpms, set()) + self.mmd.api.add_rpm("test") + self.assertSetEqual(self.mmd.api.rpms, set(["test"])) + + def test_api_del_rpm(self): + self.mmd.api.rpms = set(["test"]) + self.mmd.api.del_rpm("test") + self.assertSetEqual(self.mmd.api.rpms, set()) + + def test_api_clear_rpms(self): + self.mmd.api.rpms = set(["test"]) + self.mmd.api.clear_rpms() + self.assertSetEqual(self.mmd.api.rpms, set()) + + def test_filter_add_rpm(self): + self.assertSetEqual(self.mmd.filter.rpms, set()) + self.mmd.filter.add_rpm("test") + self.assertSetEqual(self.mmd.filter.rpms, set(["test"])) + + def test_filter_del_rpm(self): + self.mmd.filter.rpms = set(["test"]) + self.mmd.filter.del_rpm("test") + self.assertSetEqual(self.mmd.filter.rpms, set()) + + def test_filter_clear_rpms(self): + self.mmd.filter.rpms = set(["test"]) + self.mmd.filter.clear_rpms() + self.assertSetEqual(self.mmd.filter.rpms, set()) + + def test_profile_add_rpm(self): + self.mmd.profiles = { "test" : ModuleProfile() } + self.assertSetEqual(self.mmd.profiles["test"].rpms, set()) + self.mmd.profiles["test"].add_rpm("test") + self.assertSetEqual(self.mmd.profiles["test"].rpms, set(["test"])) + + def test_profile_del_rpm(self): + self.mmd.profiles = { "test" : ModuleProfile() } + self.mmd.profiles["test"].rpms = set(["test"]) + self.mmd.profiles["test"].del_rpm("test") + self.assertSetEqual(self.mmd.profiles["test"].rpms, set()) + + def test_profile_clear_rpms(self): + self.mmd.profiles = { "test" : ModuleProfile() } + self.mmd.profiles["test"].rpms = set(["test"]) + self.mmd.profiles["test"].clear_rpms() + self.assertSetEqual(self.mmd.profiles["test"].rpms, set()) + + def test_components_all(self): + rpm = ModuleComponentRPM("rpm", "rationale") + mod = ModuleComponentModule("mod", "rationale") + self.mmd.components.rpms = { rpm.name : rpm } + self.mmd.components.modules = { mod.name : mod } + # XXX: It'd be nice if we could order these + self.assertListEqual(self.mmd.components.all, [rpm, mod]) + + def test_components_add_rpm(self): + self.assertDictEqual(self.mmd.components.rpms, dict()) + self.mmd.components.add_rpm("rpm", "rationale", buildorder=1, + repository="repository", ref="ref", cache="cache", + arches=set(["a1", "a2"]), multilib=set(["m1", "m2"])) + self.assertEqual(list(self.mmd.components.rpms.keys()), ["rpm"]) + self.assertIsInstance(self.mmd.components.rpms["rpm"], + ModuleComponentRPM) + self.assertEqual(self.mmd.components.rpms["rpm"].name, "rpm") + self.assertEqual(self.mmd.components.rpms["rpm"].rationale, "rationale") + self.assertEqual(self.mmd.components.rpms["rpm"].buildorder, 1) + self.assertEqual(self.mmd.components.rpms["rpm"].repository, "repository") + self.assertEqual(self.mmd.components.rpms["rpm"].ref, "ref") + self.assertEqual(self.mmd.components.rpms["rpm"].cache, "cache") + self.assertSetEqual(self.mmd.components.rpms["rpm"].arches, + set(["a1", "a2"])) + self.assertSetEqual(self.mmd.components.rpms["rpm"].multilib, + set(["m1", "m2"])) + + def test_components_del_rpm(self): + self.mmd.components.rpms = { + "rpm" : ModuleComponentRPM("rpm", "rationale") + } + self.mmd.components.del_rpm("rpm") + self.assertDictEqual(self.mmd.components.rpms, dict()) + + def test_components_clear_rpms(self): + self.mmd.components.rpms = { + "rpm" : ModuleComponentRPM("rpm", "rationale") + } + self.mmd.components.clear_rpms() + self.assertDictEqual(self.mmd.components.rpms, dict()) + + def test_components_add_module(self): + self.assertDictEqual(self.mmd.components.modules, dict()) + self.mmd.components.add_module("module", "rationale", buildorder=1, + repository="repository", ref="ref") + self.assertEqual(list(self.mmd.components.modules.keys()), ["module"]) + self.assertIsInstance(self.mmd.components.modules["module"], + ModuleComponentModule) + self.assertEqual(self.mmd.components.modules["module"].name, "module") + self.assertEqual(self.mmd.components.modules["module"].rationale, "rationale") + self.assertEqual(self.mmd.components.modules["module"].buildorder, 1) + self.assertEqual(self.mmd.components.modules["module"].repository, "repository") + self.assertEqual(self.mmd.components.modules["module"].ref, "ref") + + def test_components_del_module(self): + self.mmd.components.modules = { + "module" : ModuleComponentModule("module", "rationale") + } + self.mmd.components.del_module("module") + self.assertDictEqual(self.mmd.components.modules, dict()) + + def test_components_clear_modules(self): + self.mmd.components.modules = { + "module" : ModuleComponentModule("module", "rationale") + } + self.mmd.components.clear_modules() + self.assertDictEqual(self.mmd.components.modules, dict()) diff --git a/modulemd/tests/test_io.py b/modulemd/tests/test_io.py new file mode 100644 index 0000000..5f73b1e --- /dev/null +++ b/modulemd/tests/test_io.py @@ -0,0 +1,120 @@ +#/usr/bin/python3 +# -*- coding: utf-8 -*- + + +# Copyright (c) 2016 Red Hat, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# Written by Petr Šabata + +import unittest + +import os +import sys + +DIR = os.path.dirname(__file__) +sys.path.insert(0, os.path.join(DIR, "..")) + +from modulemd import ModuleMetadata + +class TestIO(unittest.TestCase): + + @classmethod + def setUpClass(cls): + cls.mmd = ModuleMetadata() + + def test_load_spec(self): + self.mmd.load("spec.yaml") + self.assertEqual(self.mmd.mdversion, 1) + self.assertEqual(self.mmd.name, "foo") + self.assertEqual(self.mmd.stream, "stream-name") + self.assertEqual(self.mmd.version, 20160927144203) + self.assertEqual(self.mmd.summary, "An example module") + self.assertEqual(self.mmd.description, "A module for the demonstration of the metadata format. Also, the obligatory lorem ipsum dolor sit amet goes right here.") + self.assertSetEqual(self.mmd.module_licenses, set(["MIT"])) + self.assertSetEqual(self.mmd.content_licenses, + set(["Beerware", "GPLv2+", "zlib"])) + self.assertEqual(self.mmd.xmd, {'some_key': 'some_data'}) + self.assertDictEqual(self.mmd.buildrequires, + { + "generational-core" : "and-its-stream-name", + "generational-core-build" : "and-its-stream-name-too" + }) + self.assertDictEqual(self.mmd.requires, + { + "generational-core" : "and-its-stream-name" + }) + self.assertEqual(self.mmd.community, "http://www.example.com/") + self.assertEqual(self.mmd.documentation, "http://www.example.com/") + self.assertEqual(self.mmd.tracker, "http://www.example.com/") + self.assertSetEqual(set(self.mmd.profiles.keys()), + set(["default", "minimal"])) + self.assertSetEqual(self.mmd.profiles["default"].rpms, + set(["bar", "bar-extras", "baz"])) + self.assertEqual(self.mmd.profiles["minimal"].description, + "Minimal profile installing only the bar package.") + self.assertSetEqual(self.mmd.profiles["minimal"].rpms, + set(["bar"])) + self.assertSetEqual(self.mmd.api.rpms, + set(["bar", "bar-extras", "baz", "xxx"])) + self.assertSetEqual(self.mmd.filter.rpms, + set(["baz-nonfoo"])) + self.assertSetEqual(set(self.mmd.components.rpms.keys()), + set(["bar", "baz", "xxx", "xyz"])) + self.assertEqual(self.mmd.components.rpms["bar"].rationale, + "We need this to demonstrate stuff.") + self.assertEqual(self.mmd.components.rpms["bar"].repository, + "https://pagure.io/bar.git") + self.assertEqual(self.mmd.components.rpms["bar"].ref, + "26ca0c0") + self.assertEqual(self.mmd.components.rpms["bar"].cache, + "https://example.com/cache") + self.assertEqual(self.mmd.components.rpms["baz"].rationale, + "This one is here to demonstrate other stuff.") + self.assertEqual(self.mmd.components.rpms["xxx"].rationale, + "xxx demonstrates arches and multilib.") + self.assertSetEqual(self.mmd.components.rpms["xxx"].arches, + set(["i686", "x86_64"])) + self.assertSetEqual(self.mmd.components.rpms["xxx"].multilib, + set(["x86_64"])) + self.assertEqual(self.mmd.components.rpms["xyz"].rationale, + "xyz is a bundled dependency of xxx.") + self.assertEqual(self.mmd.components.rpms["xyz"].buildorder, + 10) + self.assertSetEqual(set(self.mmd.components.modules), + set(["includedmodule"])) + self.assertEqual(self.mmd.components.modules["includedmodule"].rationale, + "Included in the stack, just because.") + self.assertEqual(self.mmd.components.modules["includedmodule"].repository, + "https://pagure.io/includedmodule.git") + self.assertEqual(self.mmd.components.modules["includedmodule"].ref, + "somecoolbranchname") + self.assertEqual(self.mmd.components.modules["includedmodule"].buildorder, + 100) + + def test_reload(self): + self.mmd.load("spec.yaml") + first = repr(self.mmd) + self.mmd.dump("testdump.yaml") + self.mmd = ModuleMetadata() + self.mmd.load("testdump.yaml") + second = repr(self.mmd) + self.assertEqual(first, second) + os.remove("testdump.yaml") diff --git a/modulemd/tests/test_validation.py b/modulemd/tests/test_validation.py new file mode 100644 index 0000000..b5fad2c --- /dev/null +++ b/modulemd/tests/test_validation.py @@ -0,0 +1,260 @@ +#/usr/bin/python3 +# -*- coding: utf-8 -*- + + +# Copyright (c) 2016 Red Hat, Inc. +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. +# +# Written by Petr Šabata + +import unittest + +import os +import sys + +DIR = os.path.dirname(__file__) +sys.path.insert(0, os.path.join(DIR, "..")) + +from modulemd import ModuleMetadata +from modulemd import supported_mdversions +from modulemd.profile import ModuleProfile +from modulemd.components.base import ModuleComponentBase +from modulemd.components.module import ModuleComponentModule +from modulemd.components.rpm import ModuleComponentRPM + +class TestValidation(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.mmd = ModuleMetadata() + + def test_mdversion_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "mdversion", "") + + def test_mdversion_value(self): + self.assertRaises(ValueError, setattr, self.mmd, "mdversion", -1) + + def test_name_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "name", 0) + + def test_stream_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "stream", 0) + + def test_version_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "version", "") + + def test_version_value(self): + self.assertRaises(ValueError, setattr, self.mmd, "version", -1) + + def test_summary_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "summary", 0) + + def test_description_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "description", 0) + + def test_module_license_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "module_licenses", 0) + + def test_module_license_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd, "module_licenses", + set([1, 2, 3])) + + def test_content_license_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "content_licenses", 0) + + def test_content_license_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd, "content_licenses", + set([1, 2, 3])) + + def test_xmd_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "xmd", 0) + + def test_buildrequires_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", 0) + + def test_buildrequires_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", + { "key" : 0 } ) + self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", + { 0 : "value" } ) + self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", + { 0 : 0 } ) + + def test_requires_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "requires", 0) + + def test_requires_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd, "requires", + { "key" : 0 } ) + self.assertRaises(TypeError, setattr, self.mmd, "requires", + { 0 : "value" } ) + self.assertRaises(TypeError, setattr, self.mmd, "requires", + { 0 : 0 } ) + + def test_community_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "community", 0) + + def test_documentation_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "documentation", 0) + + def test_tracker_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "tracker", 0) + + def test_profiles_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "profiles", 0) + + def test_profiles_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd, "profiles", + { "key" : 0 } ) + self.assertRaises(TypeError, setattr, self.mmd, "profiles", + { 0 : ModuleProfile() } ) + self.assertRaises(TypeError, setattr, self.mmd, "profiles", + { 0 : 0 } ) + + def test_profile_description_type(self): + self.mmd.profiles = { "test" : ModuleProfile() } + self.assertRaises(TypeError, setattr, self.mmd.profiles["test"], + "description", 0) + + def test_profile_rpms_type(self): + self.mmd.profiles = { "test" : ModuleProfile() } + self.assertRaises(TypeError, setattr, self.mmd.profiles["test"], + "rpms", 0) + + def test_profile_rpms_type_deep(self): + self.mmd.profiles = { "test" : ModuleProfile() } + self.assertRaises(TypeError, setattr, self.mmd.profiles["test"], + "rpms", set([1, 2, 3])) + + def test_api_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "api", 0) + + def test_api_rpms_type(self): + self.assertRaises(TypeError, setattr, self.mmd.api, "rpms", 0) + + def test_api_rpms_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd.api, "rpms", + set([1, 2, 3])) + + def test_filter_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "filter", 0) + + def test_filter_rpms_type(self): + self.assertRaises(TypeError, setattr, self.mmd.filter, "rpms", 0) + + def test_filter_rpms_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd.filter, "rpms", + set([1, 2, 3])) + + def test_components_type(self): + self.assertRaises(TypeError, setattr, self.mmd, "components", 0) + + def test_components_rpms_type(self): + self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", 0) + + def test_components_rpms_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", + { "key" : 0 } ) + self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", + { 0 : ModuleComponentRPM("name", "rationale") } ) + self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", + { 0 : 0 } ) + + def test_components_modules_type(self): + self.assertRaises(TypeError, setattr, self.mmd.components, "modules", 0) + + def test_components_modules_type_deep(self): + self.assertRaises(TypeError, setattr, self.mmd.components, "modules", + { "key" : 0 } ) + self.assertRaises(TypeError, setattr, self.mmd.components, "modules", + { 0 : ModuleComponentModule("name", "rationale") } ) + self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", + { 0 : 0 } ) + + def test_component_base_name_type(self): + c = ModuleComponentBase("name", "rationale") + self.assertRaises(TypeError, setattr, c, "name", 0) + + def test_component_base_rationale_type(self): + c = ModuleComponentBase("name", "rationale") + self.assertRaises(TypeError, setattr, c, "rationale", 0) + + def test_component_base_buildorder_type(self): + c = ModuleComponentBase("name", "rationale") + self.assertRaises(TypeError, setattr, c, "buildorder", "") + + def test_component_rpm_name_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "name", 0) + + def test_component_rpm_rationale_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "rationale", 0) + + def test_component_rpm_buildorder_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "buildorder", "") + + def test_component_rpm_repository_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "repository", 0) + + def test_component_rpm_ref_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "ref", 0) + + def test_component_rpm_cache_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "cache", 0) + + def test_component_rpm_arches_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "arches", 0) + + def test_component_rpm_arches_type_deep(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "arches", set([1, 2, 3])) + + def test_component_rpm_multilib_type(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "multilib", 0) + + def test_component_rpm_multilib_type_deep(self): + c = ModuleComponentRPM("name", "rationale") + self.assertRaises(TypeError, setattr, c, "multilib", set([1, 2, 3])) + + def test_component_module_name_type(self): + c = ModuleComponentModule("name", "rationale") + self.assertRaises(TypeError, setattr, c, "name", 0) + + def test_component_module_rationale_type(self): + c = ModuleComponentModule("name", "rationale") + self.assertRaises(TypeError, setattr, c, "rationale", 0) + + def test_component_module_buildorder_type(self): + c = ModuleComponentModule("name", "rationale") + self.assertRaises(TypeError, setattr, c, "buildorder", "") + + def test_component_module_repository_type(self): + c = ModuleComponentModule("name", "rationale") + self.assertRaises(TypeError, setattr, c, "repository", 0) + + def test_component_module_ref_type(self): + c = ModuleComponentModule("name", "rationale") + self.assertRaises(TypeError, setattr, c, "ref", 0) diff --git a/modulemd/tests/validation.py b/modulemd/tests/validation.py deleted file mode 100644 index b5fad2c..0000000 --- a/modulemd/tests/validation.py +++ /dev/null @@ -1,260 +0,0 @@ -#/usr/bin/python3 -# -*- coding: utf-8 -*- - - -# Copyright (c) 2016 Red Hat, Inc. -# -# Permission is hereby granted, free of charge, to any person obtaining a copy -# of this software and associated documentation files (the "Software"), to deal -# in the Software without restriction, including without limitation the rights -# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -# copies of the Software, and to permit persons to whom the Software is -# furnished to do so, subject to the following conditions: -# -# The above copyright notice and this permission notice shall be included in all -# copies or substantial portions of the Software. -# -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -# SOFTWARE. -# -# Written by Petr Šabata - -import unittest - -import os -import sys - -DIR = os.path.dirname(__file__) -sys.path.insert(0, os.path.join(DIR, "..")) - -from modulemd import ModuleMetadata -from modulemd import supported_mdversions -from modulemd.profile import ModuleProfile -from modulemd.components.base import ModuleComponentBase -from modulemd.components.module import ModuleComponentModule -from modulemd.components.rpm import ModuleComponentRPM - -class TestValidation(unittest.TestCase): - @classmethod - def setUpClass(cls): - cls.mmd = ModuleMetadata() - - def test_mdversion_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "mdversion", "") - - def test_mdversion_value(self): - self.assertRaises(ValueError, setattr, self.mmd, "mdversion", -1) - - def test_name_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "name", 0) - - def test_stream_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "stream", 0) - - def test_version_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "version", "") - - def test_version_value(self): - self.assertRaises(ValueError, setattr, self.mmd, "version", -1) - - def test_summary_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "summary", 0) - - def test_description_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "description", 0) - - def test_module_license_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "module_licenses", 0) - - def test_module_license_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd, "module_licenses", - set([1, 2, 3])) - - def test_content_license_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "content_licenses", 0) - - def test_content_license_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd, "content_licenses", - set([1, 2, 3])) - - def test_xmd_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "xmd", 0) - - def test_buildrequires_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", 0) - - def test_buildrequires_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", - { "key" : 0 } ) - self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", - { 0 : "value" } ) - self.assertRaises(TypeError, setattr, self.mmd, "buildrequires", - { 0 : 0 } ) - - def test_requires_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "requires", 0) - - def test_requires_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd, "requires", - { "key" : 0 } ) - self.assertRaises(TypeError, setattr, self.mmd, "requires", - { 0 : "value" } ) - self.assertRaises(TypeError, setattr, self.mmd, "requires", - { 0 : 0 } ) - - def test_community_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "community", 0) - - def test_documentation_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "documentation", 0) - - def test_tracker_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "tracker", 0) - - def test_profiles_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "profiles", 0) - - def test_profiles_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd, "profiles", - { "key" : 0 } ) - self.assertRaises(TypeError, setattr, self.mmd, "profiles", - { 0 : ModuleProfile() } ) - self.assertRaises(TypeError, setattr, self.mmd, "profiles", - { 0 : 0 } ) - - def test_profile_description_type(self): - self.mmd.profiles = { "test" : ModuleProfile() } - self.assertRaises(TypeError, setattr, self.mmd.profiles["test"], - "description", 0) - - def test_profile_rpms_type(self): - self.mmd.profiles = { "test" : ModuleProfile() } - self.assertRaises(TypeError, setattr, self.mmd.profiles["test"], - "rpms", 0) - - def test_profile_rpms_type_deep(self): - self.mmd.profiles = { "test" : ModuleProfile() } - self.assertRaises(TypeError, setattr, self.mmd.profiles["test"], - "rpms", set([1, 2, 3])) - - def test_api_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "api", 0) - - def test_api_rpms_type(self): - self.assertRaises(TypeError, setattr, self.mmd.api, "rpms", 0) - - def test_api_rpms_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd.api, "rpms", - set([1, 2, 3])) - - def test_filter_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "filter", 0) - - def test_filter_rpms_type(self): - self.assertRaises(TypeError, setattr, self.mmd.filter, "rpms", 0) - - def test_filter_rpms_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd.filter, "rpms", - set([1, 2, 3])) - - def test_components_type(self): - self.assertRaises(TypeError, setattr, self.mmd, "components", 0) - - def test_components_rpms_type(self): - self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", 0) - - def test_components_rpms_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", - { "key" : 0 } ) - self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", - { 0 : ModuleComponentRPM("name", "rationale") } ) - self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", - { 0 : 0 } ) - - def test_components_modules_type(self): - self.assertRaises(TypeError, setattr, self.mmd.components, "modules", 0) - - def test_components_modules_type_deep(self): - self.assertRaises(TypeError, setattr, self.mmd.components, "modules", - { "key" : 0 } ) - self.assertRaises(TypeError, setattr, self.mmd.components, "modules", - { 0 : ModuleComponentModule("name", "rationale") } ) - self.assertRaises(TypeError, setattr, self.mmd.components, "rpms", - { 0 : 0 } ) - - def test_component_base_name_type(self): - c = ModuleComponentBase("name", "rationale") - self.assertRaises(TypeError, setattr, c, "name", 0) - - def test_component_base_rationale_type(self): - c = ModuleComponentBase("name", "rationale") - self.assertRaises(TypeError, setattr, c, "rationale", 0) - - def test_component_base_buildorder_type(self): - c = ModuleComponentBase("name", "rationale") - self.assertRaises(TypeError, setattr, c, "buildorder", "") - - def test_component_rpm_name_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "name", 0) - - def test_component_rpm_rationale_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "rationale", 0) - - def test_component_rpm_buildorder_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "buildorder", "") - - def test_component_rpm_repository_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "repository", 0) - - def test_component_rpm_ref_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "ref", 0) - - def test_component_rpm_cache_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "cache", 0) - - def test_component_rpm_arches_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "arches", 0) - - def test_component_rpm_arches_type_deep(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "arches", set([1, 2, 3])) - - def test_component_rpm_multilib_type(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "multilib", 0) - - def test_component_rpm_multilib_type_deep(self): - c = ModuleComponentRPM("name", "rationale") - self.assertRaises(TypeError, setattr, c, "multilib", set([1, 2, 3])) - - def test_component_module_name_type(self): - c = ModuleComponentModule("name", "rationale") - self.assertRaises(TypeError, setattr, c, "name", 0) - - def test_component_module_rationale_type(self): - c = ModuleComponentModule("name", "rationale") - self.assertRaises(TypeError, setattr, c, "rationale", 0) - - def test_component_module_buildorder_type(self): - c = ModuleComponentModule("name", "rationale") - self.assertRaises(TypeError, setattr, c, "buildorder", "") - - def test_component_module_repository_type(self): - c = ModuleComponentModule("name", "rationale") - self.assertRaises(TypeError, setattr, c, "repository", 0) - - def test_component_module_ref_type(self): - c = ModuleComponentModule("name", "rationale") - self.assertRaises(TypeError, setattr, c, "ref", 0)