# -*- coding: utf-8 -*- # Copyright 2014 Deutsche Telekom AG # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import logging import os import unittest from unittest import mock import fixtures import six import testtools from oslotest import base class TestBaseTestCase(testtools.TestCase): class FakeTestCase(base.BaseTestCase): def test_fake_test(self): pass @mock.patch('os.environ.get') @mock.patch('oslotest.timeout.Timeout.useFixture') @mock.patch('fixtures.Timeout') def test_timeout(self, fixture_timeout_mock, fixture_mock, env_get_mock): env_get_mock.return_value = 1 tc = self.FakeTestCase("test_fake_test") tc._set_timeout() env_get_mock.assert_called_once_with('OS_TEST_TIMEOUT', 0) fixture_timeout_mock.assert_called_once_with(1, gentle=True) self.assertEqual(1, fixture_mock.call_count) @mock.patch('os.environ.get') def test_fake_logs_default(self, env_get_mock): # without debug and log capture env_get_mock.side_effect = lambda value, default=None: { 'OS_DEBUG': 0, 'OS_LOG_CAPTURE': 0}.get(value, default) tc = self.FakeTestCase("test_fake_test") tc.setUp() env_get_mock.assert_any_call('OS_LOG_CAPTURE') env_get_mock.assert_any_call('OS_DEBUG') self.assertFalse(tc.log_fixture.capture_logs) self.assertIsNone(tc.log_fixture.logger) @mock.patch('os.environ.get') @mock.patch('logging.basicConfig') def test_fake_logs_with_debug(self, basic_logger_mock, env_get_mock): env_get_mock.side_effect = lambda value, default=None: { 'OS_DEBUG': 'True', 'OS_LOG_CAPTURE': 0}.get(value, default) tc = self.FakeTestCase("test_fake_test") tc.setUp() env_get_mock.assert_any_call('OS_LOG_CAPTURE') env_get_mock.assert_any_call('OS_DEBUG') basic_logger_mock.assert_called_once_with(format=base._LOG_FORMAT, level=logging.DEBUG) @mock.patch('os.environ.get') @mock.patch.object(FakeTestCase, 'useFixture') def test_fake_logs_with_log_cap(self, fixture_mock, env_get_mock): env_get_mock.side_effect = lambda value: {'OS_DEBUG': 0, 'OS_LOG_CAPTURE': 'True' }.get(value) tc = self.FakeTestCase("test_fake_test") tc.setUp() env_get_mock.assert_any_call('OS_LOG_CAPTURE') env_get_mock.assert_any_call('OS_DEBUG') self.assertEqual(5, fixture_mock.call_count) def test_mock_patch_cleanup_on_teardown(self): # create an object and save its reference class Sub(object): pass obj = Sub() obj.value = obj.backup = object() # patch the object mock.patch.object(obj, 'value').start() self.assertNotEqual(obj.backup, obj.value) # run a test case loader = unittest.defaultTestLoader suite = loader.loadTestsFromTestCase(self.FakeTestCase) suite.run(unittest.TestResult()) # check that mock patches are cleaned up self.assertEqual(obj.backup, obj.value) @mock.patch('os.environ') def test_capture_output_disabled(self, mock_env): mock_env.get.return_value = '' tc = self.FakeTestCase("test_fake_test") tc.setUp() self.assertIsNone(tc.output_fixture.stdout) self.assertIsNone(tc.output_fixture.stderr) @mock.patch('os.environ') def test_enabled(self, mock_env): mock_env.get.return_value = 'True' tc = self.FakeTestCase("test_fake_test") tc.setUp() self.assertIsNotNone(tc.output_fixture.stdout) self.assertIsNotNone(tc.output_fixture.stderr) class TestManualMock(base.BaseTestCase): def setUp(self): # Create a cleanup to undo a patch() call *before* calling the # base class version of setup(). patcher = mock.patch('os.environ.keys') patcher.start() self.addCleanup(patcher.stop) super(TestManualMock, self).setUp() self.useFixture(fixtures.MockPatch('fixtures.Timeout')) def test_mock_patch_manually(self): # Verify that if a test instance creates its own mock and # calls start/stop itself we don't get an error. patcher = mock.patch('os.environ.get') patcher.start() self.addCleanup(patcher.stop) class TestTempFiles(base.BaseTestCase): def test_create_unicode_files(self): files = [["no_approve", u'ಠ_ಠ']] temps = self.create_tempfiles(files) self.assertEqual(1, len(temps)) with open(temps[0], 'rb') as f: contents = f.read() self.assertEqual(u'ಠ_ಠ', six.text_type(contents, encoding='utf-8')) def test_create_unicode_files_encoding(self): files = [["embarrassed", u'⊙﹏⊙', 'utf-8']] temps = self.create_tempfiles(files) self.assertEqual(1, len(temps)) with open(temps[0], 'rb') as f: contents = f.read() self.assertEqual(u'⊙﹏⊙', six.text_type(contents, encoding='utf-8')) def test_create_unicode_files_multi_encoding(self): files = [ ["embarrassed", u'⊙﹏⊙', 'utf-8'], ['abc', 'abc', 'ascii'], ] temps = self.create_tempfiles(files) self.assertEqual(2, len(temps)) for i, (basename, raw_contents, raw_encoding) in enumerate(files): with open(temps[i], 'rb') as f: contents = f.read() if not isinstance(raw_contents, six.text_type): raw_contents = six.text_type(raw_contents, encoding=raw_encoding) self.assertEqual(six.text_type(contents, encoding=raw_encoding), raw_contents) def test_create_bad_encoding(self): files = [["hrm", u'ಠ~ಠ', 'ascii']] self.assertRaises(UnicodeError, self.create_tempfiles, files) def test_prefix(self): files = [["testing", '']] temps = self.create_tempfiles(files) self.assertEqual(1, len(temps)) basename = os.path.basename(temps[0]) self.assertTrue(basename.startswith('testing')) def test_wrong_length(self): files = [["testing"]] self.assertRaises(ValueError, self.create_tempfiles, files)