From 09e9d225c61ecae1c27e4dcfb1cda0d374535ba6 Mon Sep 17 00:00:00 2001 From: Mike Milner Date: Tue, 21 Feb 2012 14:26:48 -0400 Subject: Added tests for adding handlers. --- tests/unittests/test__init__.py | 91 +++++++++++ .../test_handler/test_handler_ca_certs.py | 178 +++++++++++++++++++++ tests/unittests/test_handler_ca_certs.py | 178 --------------------- 3 files changed, 269 insertions(+), 178 deletions(-) create mode 100644 tests/unittests/test__init__.py create mode 100644 tests/unittests/test_handler/test_handler_ca_certs.py delete mode 100644 tests/unittests/test_handler_ca_certs.py (limited to 'tests') diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py new file mode 100644 index 00000000..f18e39b8 --- /dev/null +++ b/tests/unittests/test__init__.py @@ -0,0 +1,91 @@ +from unittest import TestCase +from mocker import MockerTestCase, ANY, ARGS, KWARGS +from tempfile import mkdtemp +from shutil import rmtree +import os +import stat +import sys + +from cloudinit import partwalker_handle_handler, handler_handle_part, handler_register +from cloudinit.util import write_file, logexc + + +class TestPartwalkerHandleHandler(MockerTestCase): + def setUp(self): + self.data = { + "handlercount": 0, + "frequency": "?", + "handlerdir": "?", + "handlers": [], + "data": None} + + self.expected_module_name = "part-handler-%03d" % self.data["handlercount"] + expected_file_name = "%s.py" % self.expected_module_name + expected_file_fullname = os.path.join(self.data["handlerdir"], expected_file_name) + self.module_fake = "fake module handle" + self.ctype = None + self.filename = None + self.payload = "dummy payload" + + # Mock the write_file function + write_file_mock = self.mocker.replace(write_file, passthrough=False) + write_file_mock(expected_file_fullname, self.payload, 0600) + + def test_no_errors(self): + """Payload gets written to file and added to C{pdata}.""" + # Mock the __import__ builtin + import_mock = self.mocker.replace("__builtin__.__import__") + import_mock(self.expected_module_name) + self.mocker.result(self.module_fake) + # Mock the handle_register function + handle_reg_mock = self.mocker.replace(handler_register, passthrough=False) + handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"]) + # Activate mocks + self.mocker.replay() + + partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + + self.assertEqual(1, self.data["handlercount"]) + + def test_import_error(self): + """Payload gets written to file and added to C{pdata}.""" + # Mock the __import__ builtin + import_mock = self.mocker.replace("__builtin__.__import__") + import_mock(self.expected_module_name) + self.mocker.throw(ImportError()) + # Mock log function + logexc_mock = self.mocker.replace(logexc, passthrough=False) + logexc_mock(ANY) + # Mock the print_exc function + print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False) + print_exc_mock(ARGS, KWARGS) + # Activate mocks + self.mocker.replay() + + partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + + def test_attribute_error(self): + """Payload gets written to file and added to C{pdata}.""" + # Mock the __import__ builtin + import_mock = self.mocker.replace("__builtin__.__import__") + import_mock(self.expected_module_name) + self.mocker.result(self.module_fake) + # Mock the handle_register function + handle_reg_mock = self.mocker.replace(handler_register, passthrough=False) + handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"]) + self.mocker.throw(AttributeError()) + # Mock log function + logexc_mock = self.mocker.replace(logexc, passthrough=False) + logexc_mock(ANY) + # Mock the print_exc function + print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False) + print_exc_mock(ARGS, KWARGS) + # Activate mocks + self.mocker.replay() + + partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + + +class TestHandlerHandlePart(TestCase): + def test_dummy(self): + self.assertTrue(False) diff --git a/tests/unittests/test_handler/test_handler_ca_certs.py b/tests/unittests/test_handler/test_handler_ca_certs.py new file mode 100644 index 00000000..d6513b5b --- /dev/null +++ b/tests/unittests/test_handler/test_handler_ca_certs.py @@ -0,0 +1,178 @@ +from mocker import MockerTestCase + +from cloudinit.util import write_file, delete_dir_contents +from cloudinit.CloudConfig.cc_ca_certs import ( + handle, update_ca_certs, add_ca_certs, remove_default_ca_certs) +from logging import getLogger + + +class TestNoConfig(MockerTestCase): + def setUp(self): + super(TestNoConfig, self).setUp() + self.name = "ca-certs" + self.cloud_init = None + self.log = getLogger("TestNoConfig") + self.args = [] + + def test_no_config(self): + """ + Test that nothing is done if no ca-certs configuration is provided. + """ + config = {"unknown-key": "value"} + + self.mocker.replace(write_file, passthrough=False) + self.mocker.replace(update_ca_certs, passthrough=False) + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + +class TestConfig(MockerTestCase): + def setUp(self): + super(TestConfig, self).setUp() + self.name = "ca-certs" + self.cloud_init = None + self.log = getLogger("TestNoConfig") + self.args = [] + + # Mock out the functions that actually modify the system + self.mock_add = self.mocker.replace(add_ca_certs, passthrough=False) + self.mock_update = self.mocker.replace(update_ca_certs, + passthrough=False) + self.mock_remove = self.mocker.replace(remove_default_ca_certs, + passthrough=False) + # Order must be correct + self.mocker.order() + + def test_no_trusted_list(self): + """ + Test that no certificates are written if the 'trusted' key is not + present. + """ + config = {"ca-certs": {}} + + # No functions should be called + self.mock_update() + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + def test_empty_trusted_list(self): + """Test that no certificate are written if 'trusted' list is empty""" + config = {"ca-certs": {"trusted": []}} + + # No functions should be called + self.mock_update() + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + def test_single_trusted(self): + """Test that a single cert gets passed to add_ca_certs""" + config = {"ca-certs": {"trusted": ["CERT1"]}} + + self.mock_add(["CERT1"]) + self.mock_update() + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + def test_multiple_trusted(self): + """Test that multiple certs get passed to add_ca_certs""" + config = {"ca-certs": {"trusted": ["CERT1", "CERT2"]}} + + self.mock_add(["CERT1", "CERT2"]) + self.mock_update() + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + def test_remove_default_ca_certs(self): + """Test remove_defaults works as expected""" + config = {"ca-certs": {"remove-defaults": True}} + + self.mock_remove() + self.mock_update() + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + def test_no_remove_defaults_if_false(self): + """Test remove_defaults is not called when config value is False""" + config = {"ca-certs": {"remove-defaults": False}} + + self.mock_update() + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + def test_correct_order_for_remove_then_add(self): + """Test remove_defaults is not called when config value is False""" + config = {"ca-certs": {"remove-defaults": True, "trusted": ["CERT1"]}} + + self.mock_remove() + self.mock_add(["CERT1"]) + self.mock_update() + self.mocker.replay() + + handle(self.name, config, self.cloud_init, self.log, self.args) + + +class TestAddCaCerts(MockerTestCase): + def test_no_certs_in_list(self): + """Test that no certificate are written if not provided.""" + self.mocker.replace(write_file, passthrough=False) + self.mocker.replay() + + add_ca_certs([]) + + def test_single_cert(self): + """Test adding a single certificate to the trusted CAs""" + cert = "CERT1\nLINE2\nLINE3" + + mock_write = self.mocker.replace(write_file, passthrough=False) + mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt", + cert, mode=0644) + mock_write("/etc/ca-certificates.conf", + "\ncloud-init-ca-certs.crt", omode="a") + self.mocker.replay() + + add_ca_certs([cert]) + + def test_multiple_certs(self): + """Test adding multiple certificates to the trusted CAs""" + certs = ["CERT1\nLINE2\nLINE3", "CERT2\nLINE2\nLINE3"] + expected_cert_file = "\n".join(certs) + + mock_write = self.mocker.replace(write_file, passthrough=False) + mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt", + expected_cert_file, mode=0644) + mock_write("/etc/ca-certificates.conf", + "\ncloud-init-ca-certs.crt", omode="a") + self.mocker.replay() + + add_ca_certs(certs) + + +class TestUpdateCaCerts(MockerTestCase): + def test_commands(self): + mock_check_call = self.mocker.replace("subprocess.check_call", + passthrough=False) + mock_check_call(["update-ca-certificates"]) + self.mocker.replay() + + update_ca_certs() + + +class TestRemoveDefaultCaCerts(MockerTestCase): + def test_commands(self): + mock_delete_dir_contents = self.mocker.replace(delete_dir_contents, + passthrough=False) + mock_write = self.mocker.replace(write_file, passthrough=False) + + mock_delete_dir_contents("/usr/share/ca-certificates/") + mock_delete_dir_contents("/etc/ssl/certs/") + mock_write("/etc/ca-certificates.conf", "", mode=0644) + self.mocker.replay() + + remove_default_ca_certs() diff --git a/tests/unittests/test_handler_ca_certs.py b/tests/unittests/test_handler_ca_certs.py deleted file mode 100644 index d6513b5b..00000000 --- a/tests/unittests/test_handler_ca_certs.py +++ /dev/null @@ -1,178 +0,0 @@ -from mocker import MockerTestCase - -from cloudinit.util import write_file, delete_dir_contents -from cloudinit.CloudConfig.cc_ca_certs import ( - handle, update_ca_certs, add_ca_certs, remove_default_ca_certs) -from logging import getLogger - - -class TestNoConfig(MockerTestCase): - def setUp(self): - super(TestNoConfig, self).setUp() - self.name = "ca-certs" - self.cloud_init = None - self.log = getLogger("TestNoConfig") - self.args = [] - - def test_no_config(self): - """ - Test that nothing is done if no ca-certs configuration is provided. - """ - config = {"unknown-key": "value"} - - self.mocker.replace(write_file, passthrough=False) - self.mocker.replace(update_ca_certs, passthrough=False) - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - -class TestConfig(MockerTestCase): - def setUp(self): - super(TestConfig, self).setUp() - self.name = "ca-certs" - self.cloud_init = None - self.log = getLogger("TestNoConfig") - self.args = [] - - # Mock out the functions that actually modify the system - self.mock_add = self.mocker.replace(add_ca_certs, passthrough=False) - self.mock_update = self.mocker.replace(update_ca_certs, - passthrough=False) - self.mock_remove = self.mocker.replace(remove_default_ca_certs, - passthrough=False) - # Order must be correct - self.mocker.order() - - def test_no_trusted_list(self): - """ - Test that no certificates are written if the 'trusted' key is not - present. - """ - config = {"ca-certs": {}} - - # No functions should be called - self.mock_update() - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - def test_empty_trusted_list(self): - """Test that no certificate are written if 'trusted' list is empty""" - config = {"ca-certs": {"trusted": []}} - - # No functions should be called - self.mock_update() - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - def test_single_trusted(self): - """Test that a single cert gets passed to add_ca_certs""" - config = {"ca-certs": {"trusted": ["CERT1"]}} - - self.mock_add(["CERT1"]) - self.mock_update() - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - def test_multiple_trusted(self): - """Test that multiple certs get passed to add_ca_certs""" - config = {"ca-certs": {"trusted": ["CERT1", "CERT2"]}} - - self.mock_add(["CERT1", "CERT2"]) - self.mock_update() - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - def test_remove_default_ca_certs(self): - """Test remove_defaults works as expected""" - config = {"ca-certs": {"remove-defaults": True}} - - self.mock_remove() - self.mock_update() - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - def test_no_remove_defaults_if_false(self): - """Test remove_defaults is not called when config value is False""" - config = {"ca-certs": {"remove-defaults": False}} - - self.mock_update() - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - def test_correct_order_for_remove_then_add(self): - """Test remove_defaults is not called when config value is False""" - config = {"ca-certs": {"remove-defaults": True, "trusted": ["CERT1"]}} - - self.mock_remove() - self.mock_add(["CERT1"]) - self.mock_update() - self.mocker.replay() - - handle(self.name, config, self.cloud_init, self.log, self.args) - - -class TestAddCaCerts(MockerTestCase): - def test_no_certs_in_list(self): - """Test that no certificate are written if not provided.""" - self.mocker.replace(write_file, passthrough=False) - self.mocker.replay() - - add_ca_certs([]) - - def test_single_cert(self): - """Test adding a single certificate to the trusted CAs""" - cert = "CERT1\nLINE2\nLINE3" - - mock_write = self.mocker.replace(write_file, passthrough=False) - mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt", - cert, mode=0644) - mock_write("/etc/ca-certificates.conf", - "\ncloud-init-ca-certs.crt", omode="a") - self.mocker.replay() - - add_ca_certs([cert]) - - def test_multiple_certs(self): - """Test adding multiple certificates to the trusted CAs""" - certs = ["CERT1\nLINE2\nLINE3", "CERT2\nLINE2\nLINE3"] - expected_cert_file = "\n".join(certs) - - mock_write = self.mocker.replace(write_file, passthrough=False) - mock_write("/usr/share/ca-certificates/cloud-init-ca-certs.crt", - expected_cert_file, mode=0644) - mock_write("/etc/ca-certificates.conf", - "\ncloud-init-ca-certs.crt", omode="a") - self.mocker.replay() - - add_ca_certs(certs) - - -class TestUpdateCaCerts(MockerTestCase): - def test_commands(self): - mock_check_call = self.mocker.replace("subprocess.check_call", - passthrough=False) - mock_check_call(["update-ca-certificates"]) - self.mocker.replay() - - update_ca_certs() - - -class TestRemoveDefaultCaCerts(MockerTestCase): - def test_commands(self): - mock_delete_dir_contents = self.mocker.replace(delete_dir_contents, - passthrough=False) - mock_write = self.mocker.replace(write_file, passthrough=False) - - mock_delete_dir_contents("/usr/share/ca-certificates/") - mock_delete_dir_contents("/etc/ssl/certs/") - mock_write("/etc/ca-certificates.conf", "", mode=0644) - self.mocker.replay() - - remove_default_ca_certs() -- cgit v1.2.3 From 149e58e715dba9c6c332ac12ddc4cca6609cbb41 Mon Sep 17 00:00:00 2001 From: Mike Milner Date: Tue, 21 Feb 2012 15:17:02 -0400 Subject: Add tests for various frequencies. --- tests/unittests/test__init__.py | 61 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 58 insertions(+), 3 deletions(-) (limited to 'tests') diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py index f18e39b8..79df8e72 100644 --- a/tests/unittests/test__init__.py +++ b/tests/unittests/test__init__.py @@ -86,6 +86,61 @@ class TestPartwalkerHandleHandler(MockerTestCase): partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) -class TestHandlerHandlePart(TestCase): - def test_dummy(self): - self.assertTrue(False) +class TestHandlerHandlePart(MockerTestCase): + def setUp(self): + self.data = "fake data" + self.ctype = "fake ctype" + self.filename = "fake filename" + self.payload = "fake payload" + self.frequency = "once-per-instance" + + def test_normal_version_1(self): + """C{handle_part} is called without frequency for C{handler_version} == 1""" + # Build a mock part-handler module + mod_mock = self.mocker.mock() + getattr(mod_mock, "frequency") + self.mocker.result("once-per-instance") + getattr(mod_mock, "handler_version") + self.mocker.result(1) + mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload) + self.mocker.replay() + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + def test_normal_version_2(self): + """C{handle_part} is called with frequency for C{handler_version} == 2""" + # Build a mock part-handler module + mod_mock = self.mocker.mock() + getattr(mod_mock, "frequency") + self.mocker.result("once-per-instance") + getattr(mod_mock, "handler_version") + self.mocker.result(2) + mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency) + self.mocker.replay() + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + def test_modfreq_per_always(self): + """C{handle_part} is called regardless of frequency if nofreq is always.""" + self.frequency = "once" + # Build a mock part-handler module + mod_mock = self.mocker.mock() + getattr(mod_mock, "frequency") + self.mocker.result("always") + getattr(mod_mock, "handler_version") + self.mocker.result(2) + mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency) + self.mocker.replay() + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + def test_no_handle_when_modfreq_once(self): + """C{handle_part} is not called if frequency is once""" + self.frequency = "once" + # Build a mock part-handler module + mod_mock = self.mocker.mock() + getattr(mod_mock, "frequency") + self.mocker.result("once-per-instance") + self.mocker.replay() + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) -- cgit v1.2.3 From 8b17caade46cf84050961e24a0006386dbe96669 Mon Sep 17 00:00:00 2001 From: Mike Milner Date: Tue, 21 Feb 2012 15:26:08 -0400 Subject: Add test and fix for catching exceptions. --- cloudinit/__init__.py | 13 ++++++++----- tests/unittests/test__init__.py | 20 ++++++++++++++++++++ 2 files changed, 28 insertions(+), 5 deletions(-) (limited to 'tests') diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py index 7a34e053..4338b46f 100644 --- a/cloudinit/__init__.py +++ b/cloudinit/__init__.py @@ -572,10 +572,14 @@ def handler_handle_part(mod, data, ctype, filename, payload, frequency): if not (modfreq == per_always or (frequency == per_instance and modfreq == per_instance)): return - if mod.handler_version == 1: - mod.handle_part(data, ctype, filename, payload) - else: - mod.handle_part(data, ctype, filename, payload, frequency) + try: + if mod.handler_version == 1: + mod.handle_part(data, ctype, filename, payload) + else: + mod.handle_part(data, ctype, filename, payload, frequency) + except: + util.logexc(log) + traceback.print_exc(file=sys.stderr) def partwalker_handle_handler(pdata, _ctype, _filename, payload): @@ -594,7 +598,6 @@ def partwalker_handle_handler(pdata, _ctype, _filename, payload): except: util.logexc(log) traceback.print_exc(file=sys.stderr) - return def partwalker_callback(pdata, ctype, filename, payload): diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py index 79df8e72..f1818e9c 100644 --- a/tests/unittests/test__init__.py +++ b/tests/unittests/test__init__.py @@ -144,3 +144,23 @@ class TestHandlerHandlePart(MockerTestCase): self.mocker.replay() handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + def test_exception_is_caught(self): + """Exceptions within C{handle_part} are caught and logged.""" + # Build a mock part-handler module + mod_mock = self.mocker.mock() + getattr(mod_mock, "frequency") + self.mocker.result("once-per-instance") + getattr(mod_mock, "handler_version") + self.mocker.result(1) + mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload) + self.mocker.throw(Exception()) + # Mock log function + logexc_mock = self.mocker.replace(logexc, passthrough=False) + logexc_mock(ANY) + # Mock the print_exc function + print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False) + print_exc_mock(ARGS, KWARGS) + self.mocker.replay() + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) -- cgit v1.2.3 From e8a3e39c1a6356460418d45f5b24f29b3fe6f20b Mon Sep 17 00:00:00 2001 From: Mike Milner Date: Tue, 21 Feb 2012 15:35:04 -0400 Subject: Lint fixes. --- cloudinit/__init__.py | 1 - tests/unittests/test__init__.py | 95 ++++++++++++++++++++++++++--------------- 2 files changed, 60 insertions(+), 36 deletions(-) (limited to 'tests') diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py index 4338b46f..82390eeb 100644 --- a/cloudinit/__init__.py +++ b/cloudinit/__init__.py @@ -60,7 +60,6 @@ import cPickle import sys import os.path import errno -import pwd import subprocess import yaml import logging diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py index f1818e9c..d273748a 100644 --- a/tests/unittests/test__init__.py +++ b/tests/unittests/test__init__.py @@ -1,12 +1,8 @@ -from unittest import TestCase from mocker import MockerTestCase, ANY, ARGS, KWARGS -from tempfile import mkdtemp -from shutil import rmtree import os -import stat -import sys -from cloudinit import partwalker_handle_handler, handler_handle_part, handler_register +from cloudinit import (partwalker_handle_handler, handler_handle_part, + handler_register) from cloudinit.util import write_file, logexc @@ -19,9 +15,11 @@ class TestPartwalkerHandleHandler(MockerTestCase): "handlers": [], "data": None} - self.expected_module_name = "part-handler-%03d" % self.data["handlercount"] + self.expected_module_name = "part-handler-%03d" % ( + self.data["handlercount"],) expected_file_name = "%s.py" % self.expected_module_name - expected_file_fullname = os.path.join(self.data["handlerdir"], expected_file_name) + expected_file_fullname = os.path.join(self.data["handlerdir"], + expected_file_name) self.module_fake = "fake module handle" self.ctype = None self.filename = None @@ -38,12 +36,15 @@ class TestPartwalkerHandleHandler(MockerTestCase): import_mock(self.expected_module_name) self.mocker.result(self.module_fake) # Mock the handle_register function - handle_reg_mock = self.mocker.replace(handler_register, passthrough=False) - handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"]) + handle_reg_mock = self.mocker.replace(handler_register, + passthrough=False) + handle_reg_mock(self.module_fake, self.data["handlers"], + self.data["data"], self.data["frequency"]) # Activate mocks self.mocker.replay() - partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + partwalker_handle_handler(self.data, self.ctype, self.filename, + self.payload) self.assertEqual(1, self.data["handlercount"]) @@ -57,12 +58,14 @@ class TestPartwalkerHandleHandler(MockerTestCase): logexc_mock = self.mocker.replace(logexc, passthrough=False) logexc_mock(ANY) # Mock the print_exc function - print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False) + print_exc_mock = self.mocker.replace("traceback.print_exc", + passthrough=False) print_exc_mock(ARGS, KWARGS) # Activate mocks self.mocker.replay() - partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + partwalker_handle_handler(self.data, self.ctype, self.filename, + self.payload) def test_attribute_error(self): """Payload gets written to file and added to C{pdata}.""" @@ -71,19 +74,23 @@ class TestPartwalkerHandleHandler(MockerTestCase): import_mock(self.expected_module_name) self.mocker.result(self.module_fake) # Mock the handle_register function - handle_reg_mock = self.mocker.replace(handler_register, passthrough=False) - handle_reg_mock(self.module_fake, self.data["handlers"], self.data["data"], self.data["frequency"]) + handle_reg_mock = self.mocker.replace(handler_register, + passthrough=False) + handle_reg_mock(self.module_fake, self.data["handlers"], + self.data["data"], self.data["frequency"]) self.mocker.throw(AttributeError()) # Mock log function logexc_mock = self.mocker.replace(logexc, passthrough=False) logexc_mock(ANY) # Mock the print_exc function - print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False) + print_exc_mock = self.mocker.replace("traceback.print_exc", + passthrough=False) print_exc_mock(ARGS, KWARGS) # Activate mocks self.mocker.replay() - partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + partwalker_handle_handler(self.data, self.ctype, self.filename, + self.payload) class TestHandlerHandlePart(MockerTestCase): @@ -95,33 +102,45 @@ class TestHandlerHandlePart(MockerTestCase): self.frequency = "once-per-instance" def test_normal_version_1(self): - """C{handle_part} is called without frequency for C{handler_version} == 1""" + """ + C{handle_part} is called without C{frequency} for + C{handler_version} == 1. + """ # Build a mock part-handler module mod_mock = self.mocker.mock() getattr(mod_mock, "frequency") self.mocker.result("once-per-instance") getattr(mod_mock, "handler_version") self.mocker.result(1) - mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload) + mod_mock.handle_part(self.data, self.ctype, self.filename, + self.payload) self.mocker.replay() - - handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, + self.payload, self.frequency) def test_normal_version_2(self): - """C{handle_part} is called with frequency for C{handler_version} == 2""" + """ + C{handle_part} is called with C{frequency} for + C{handler_version} == 2. + """ # Build a mock part-handler module mod_mock = self.mocker.mock() getattr(mod_mock, "frequency") self.mocker.result("once-per-instance") getattr(mod_mock, "handler_version") self.mocker.result(2) - mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency) + mod_mock.handle_part(self.data, self.ctype, self.filename, + self.payload, self.frequency) self.mocker.replay() - - handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, + self.payload, self.frequency) def test_modfreq_per_always(self): - """C{handle_part} is called regardless of frequency if nofreq is always.""" + """ + C{handle_part} is called regardless of frequency if nofreq is always. + """ self.frequency = "once" # Build a mock part-handler module mod_mock = self.mocker.mock() @@ -129,10 +148,12 @@ class TestHandlerHandlePart(MockerTestCase): self.mocker.result("always") getattr(mod_mock, "handler_version") self.mocker.result(2) - mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload, self.frequency) + mod_mock.handle_part(self.data, self.ctype, self.filename, + self.payload, self.frequency) self.mocker.replay() - - handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, + self.payload, self.frequency) def test_no_handle_when_modfreq_once(self): """C{handle_part} is not called if frequency is once""" @@ -142,8 +163,9 @@ class TestHandlerHandlePart(MockerTestCase): getattr(mod_mock, "frequency") self.mocker.result("once-per-instance") self.mocker.replay() - - handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, + self.payload, self.frequency) def test_exception_is_caught(self): """Exceptions within C{handle_part} are caught and logged.""" @@ -153,14 +175,17 @@ class TestHandlerHandlePart(MockerTestCase): self.mocker.result("once-per-instance") getattr(mod_mock, "handler_version") self.mocker.result(1) - mod_mock.handle_part(self.data, self.ctype, self.filename, self.payload) + mod_mock.handle_part(self.data, self.ctype, self.filename, + self.payload) self.mocker.throw(Exception()) # Mock log function logexc_mock = self.mocker.replace(logexc, passthrough=False) logexc_mock(ANY) # Mock the print_exc function - print_exc_mock = self.mocker.replace("traceback.print_exc", passthrough=False) + print_exc_mock = self.mocker.replace("traceback.print_exc", + passthrough=False) print_exc_mock(ARGS, KWARGS) self.mocker.replay() - - handler_handle_part(mod_mock, self.data, self.ctype, self.filename, self.payload, self.frequency) + + handler_handle_part(mod_mock, self.data, self.ctype, self.filename, + self.payload, self.frequency) -- cgit v1.2.3 From f54e9394e9d9dd0496d8084f9ca9ff5abee5f41c Mon Sep 17 00:00:00 2001 From: Mike Milner Date: Tue, 21 Feb 2012 15:43:53 -0400 Subject: Cleanups. --- cloudinit/__init__.py | 3 +-- tests/unittests/test__init__.py | 12 ++++++++---- 2 files changed, 9 insertions(+), 6 deletions(-) (limited to 'tests') diff --git a/cloudinit/__init__.py b/cloudinit/__init__.py index 82390eeb..f3541ee5 100644 --- a/cloudinit/__init__.py +++ b/cloudinit/__init__.py @@ -589,11 +589,10 @@ def partwalker_handle_handler(pdata, _ctype, _filename, payload): modfname = modname + ".py" util.write_file("%s/%s" % (pdata['handlerdir'], modfname), payload, 0600) - pdata['handlercount'] = curcount + 1 - try: mod = __import__(modname) handler_register(mod, pdata['handlers'], pdata['data'], frequency) + pdata['handlercount'] = curcount + 1 except: util.logexc(log) traceback.print_exc(file=sys.stderr) diff --git a/tests/unittests/test__init__.py b/tests/unittests/test__init__.py index d273748a..e157fa77 100644 --- a/tests/unittests/test__init__.py +++ b/tests/unittests/test__init__.py @@ -49,7 +49,7 @@ class TestPartwalkerHandleHandler(MockerTestCase): self.assertEqual(1, self.data["handlercount"]) def test_import_error(self): - """Payload gets written to file and added to C{pdata}.""" + """Module import errors are logged. No handler added to C{pdata}""" # Mock the __import__ builtin import_mock = self.mocker.replace("__builtin__.__import__") import_mock(self.expected_module_name) @@ -67,8 +67,10 @@ class TestPartwalkerHandleHandler(MockerTestCase): partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + self.assertEqual(0, self.data["handlercount"]) + def test_attribute_error(self): - """Payload gets written to file and added to C{pdata}.""" + """Attribute errors are logged. No handler added to C{pdata}""" # Mock the __import__ builtin import_mock = self.mocker.replace("__builtin__.__import__") import_mock(self.expected_module_name) @@ -92,6 +94,8 @@ class TestPartwalkerHandleHandler(MockerTestCase): partwalker_handle_handler(self.data, self.ctype, self.filename, self.payload) + self.assertEqual(0, self.data["handlercount"]) + class TestHandlerHandlePart(MockerTestCase): def setUp(self): @@ -147,9 +151,9 @@ class TestHandlerHandlePart(MockerTestCase): getattr(mod_mock, "frequency") self.mocker.result("always") getattr(mod_mock, "handler_version") - self.mocker.result(2) + self.mocker.result(1) mod_mock.handle_part(self.data, self.ctype, self.filename, - self.payload, self.frequency) + self.payload) self.mocker.replay() handler_handle_part(mod_mock, self.data, self.ctype, self.filename, -- cgit v1.2.3