f3d48000b1
autopep8 is a code formating tool that makes python code pep8 compliant without changing everything. Unlike black it will not radically change all code and the primary change to the existing codebase is adding a new line after class level doc strings. This change adds a new tox autopep8 env to manually run it on your code before you submit a patch, it also adds autopep8 to pre-commit so if you use pre-commit it will do it for you automatically. This change runs autopep8 in diff mode with --exit-code in the pep8 tox env so it will fail if autopep8 would modify your code if run in in-place mode. This allows use to gate on autopep8 not modifying patches that are submited. This will ensure authorship of patches is maintianed. The intent of this change is to save the large amount of time we spend on ensuring style guidlines are followed automatically to make it simpler for both new and old contibutors to work on nova and save time and effort for all involved. Change-Id: Idd618d634cc70ae8d58fab32f322e75bfabefb9d
433 lines
15 KiB
Python
433 lines
15 KiB
Python
# Copyright 2010 United States Government as represented by the
|
|
# Administrator of the National Aeronautics and Space Administration.
|
|
# All Rights Reserved.
|
|
#
|
|
# 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.
|
|
|
|
"""Tests for the testing base code."""
|
|
|
|
import os.path
|
|
import tempfile
|
|
import uuid
|
|
|
|
import mock
|
|
from oslo_log import log as logging
|
|
import oslo_messaging as messaging
|
|
|
|
import nova.conf
|
|
from nova import exception
|
|
from nova import rpc
|
|
from nova import test
|
|
from nova.tests import fixtures
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
CONF = nova.conf.CONF
|
|
|
|
|
|
class IsolationTestCase(test.TestCase):
|
|
"""Ensure that things are cleaned up after failed tests.
|
|
|
|
These tests don't really do much here, but if isolation fails a bunch
|
|
of other tests should fail.
|
|
|
|
"""
|
|
|
|
def test_service_isolation(self):
|
|
self.useFixture(fixtures.ServiceFixture('compute'))
|
|
|
|
def test_rpc_consumer_isolation(self):
|
|
class NeverCalled(object):
|
|
|
|
def __getattribute__(self, name):
|
|
if name == 'target' or name == 'oslo_rpc_server_ping':
|
|
# oslo.messaging 5.31.0 explicitly looks for 'target'
|
|
# on the endpoint and checks it's type, so we can't avoid
|
|
# it here, just ignore it if that's the case.
|
|
return
|
|
assert False, "I should never get called. name: %s" % name
|
|
|
|
server = rpc.get_server(messaging.Target(topic='compute',
|
|
server=CONF.host),
|
|
endpoints=[NeverCalled()])
|
|
server.start()
|
|
|
|
|
|
class JsonTestCase(test.NoDBTestCase):
|
|
def test_compare_dict_string(self):
|
|
expected = {
|
|
"employees": [
|
|
{"firstName": "Anna", "lastName": "Smith"},
|
|
{"firstName": "John", "lastName": "Doe"},
|
|
{"firstName": "Peter", "lastName": "Jones"}
|
|
],
|
|
"locations": set(['Boston', 'Mumbai', 'Beijing', 'Perth'])
|
|
}
|
|
actual = """{
|
|
"employees": [
|
|
{
|
|
"lastName": "Doe",
|
|
"firstName": "John"
|
|
},
|
|
{
|
|
"lastName": "Smith",
|
|
"firstName": "Anna"
|
|
},
|
|
{
|
|
"lastName": "Jones",
|
|
"firstName": "Peter"
|
|
}
|
|
],
|
|
"locations": [
|
|
"Perth",
|
|
"Boston",
|
|
"Mumbai",
|
|
"Beijing"
|
|
]
|
|
}"""
|
|
self.assertJsonEqual(expected, actual)
|
|
|
|
def test_fail_on_list_length(self):
|
|
expected = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': ['a', 'b', 'c']
|
|
}
|
|
}
|
|
}
|
|
actual = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': ['c', 'a', 'b', 'd']
|
|
}
|
|
}
|
|
}
|
|
try:
|
|
self.assertJsonEqual(expected, actual)
|
|
except Exception as e:
|
|
# error reported is going to be a cryptic length failure
|
|
# on the level2 structure.
|
|
self.assertEqual(
|
|
("3 != 4: path: root.top.l1.l2. Different list items\n"
|
|
"expected=['a', 'b', 'c']\n"
|
|
"observed=['a', 'b', 'c', 'd']\n"
|
|
"difference=['d']"),
|
|
e.difference)
|
|
self.assertIn(
|
|
"actual:\n{'top': {'l1': {'l2': ['c', 'a', 'b', 'd']}}}",
|
|
str(e))
|
|
self.assertIn(
|
|
"expected:\n{'top': {'l1': {'l2': ['a', 'b', 'c']}}}",
|
|
str(e))
|
|
else:
|
|
self.fail("This should have raised a mismatch exception")
|
|
|
|
def test_fail_on_dict_length(self):
|
|
expected = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': {'a': 1, 'b': 2, 'c': 3}
|
|
}
|
|
}
|
|
}
|
|
actual = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': {'a': 1, 'b': 2}
|
|
}
|
|
}
|
|
}
|
|
try:
|
|
self.assertJsonEqual(expected, actual)
|
|
except Exception as e:
|
|
self.assertEqual(
|
|
("3 != 2: path: root.top.l1.l2. Different dict key sets\n"
|
|
"expected=['a', 'b', 'c']\n"
|
|
"observed=['a', 'b']\n"
|
|
"difference=['c']"),
|
|
e.difference)
|
|
else:
|
|
self.fail("This should have raised a mismatch exception")
|
|
|
|
def test_fail_on_dict_keys(self):
|
|
expected = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': {'a': 1, 'b': 2, 'c': 3}
|
|
}
|
|
}
|
|
}
|
|
actual = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': {'a': 1, 'b': 2, 'd': 3}
|
|
}
|
|
}
|
|
}
|
|
try:
|
|
self.assertJsonEqual(expected, actual)
|
|
except Exception as e:
|
|
self.assertIn(
|
|
"path: root.top.l1.l2. Dict keys are not equal",
|
|
e.difference)
|
|
else:
|
|
self.fail("This should have raised a mismatch exception")
|
|
|
|
def test_fail_on_list_value(self):
|
|
expected = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': ['a', 'b', 'c']
|
|
}
|
|
}
|
|
}
|
|
actual = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': ['c', 'a', 'd']
|
|
}
|
|
}
|
|
}
|
|
try:
|
|
self.assertJsonEqual(expected, actual)
|
|
except Exception as e:
|
|
self.assertEqual(
|
|
"'b' != 'c': path: root.top.l1.l2[1]",
|
|
e.difference)
|
|
self.assertIn(
|
|
"actual:\n{'top': {'l1': {'l2': ['c', 'a', 'd']}}}",
|
|
str(e))
|
|
self.assertIn(
|
|
"expected:\n{'top': {'l1': {'l2': ['a', 'b', 'c']}}}",
|
|
str(e))
|
|
else:
|
|
self.fail("This should have raised a mismatch exception")
|
|
|
|
def test_fail_on_dict_value(self):
|
|
expected = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': {'a': 1, 'b': 2, 'c': 3}
|
|
}
|
|
}
|
|
}
|
|
actual = {
|
|
'top': {
|
|
'l1': {
|
|
'l2': {'a': 1, 'b': 2, 'c': 4}
|
|
}
|
|
}
|
|
}
|
|
try:
|
|
self.assertJsonEqual(expected, actual, 'test message')
|
|
except Exception as e:
|
|
self.assertEqual(
|
|
"3 != 4: path: root.top.l1.l2.c", e.difference)
|
|
self.assertIn("actual:\n{'top': {'l1': {'l2': {", str(e))
|
|
self.assertIn("expected:\n{'top': {'l1': {'l2': {", str(e))
|
|
self.assertIn("message: test message\n", str(e))
|
|
else:
|
|
self.fail("This should have raised a mismatch exception")
|
|
|
|
def test_compare_scalars(self):
|
|
with self.assertRaisesRegex(AssertionError, 'True != False'):
|
|
self.assertJsonEqual(True, False)
|
|
|
|
|
|
class BadLogTestCase(test.NoDBTestCase):
|
|
"""Make sure a mis-formatted debug log will get caught."""
|
|
|
|
def test_bad_debug_log(self):
|
|
self.assertRaises(KeyError,
|
|
LOG.debug, "this is a misformated %(log)s", {'nothing': 'nothing'})
|
|
|
|
|
|
class MatchTypeTestCase(test.NoDBTestCase):
|
|
|
|
def test_match_type_simple(self):
|
|
matcher = test.MatchType(dict)
|
|
|
|
self.assertEqual(matcher, {})
|
|
self.assertEqual(matcher, {"hello": "world"})
|
|
self.assertEqual(matcher, {"hello": ["world"]})
|
|
self.assertNotEqual(matcher, [])
|
|
self.assertNotEqual(matcher, [{"hello": "world"}])
|
|
self.assertNotEqual(matcher, 123)
|
|
self.assertNotEqual(matcher, "foo")
|
|
|
|
def test_match_type_object(self):
|
|
class Hello(object):
|
|
pass
|
|
|
|
class World(object):
|
|
pass
|
|
|
|
matcher = test.MatchType(Hello)
|
|
|
|
self.assertEqual(matcher, Hello())
|
|
self.assertNotEqual(matcher, World())
|
|
self.assertNotEqual(matcher, 123)
|
|
self.assertNotEqual(matcher, "foo")
|
|
|
|
|
|
class ContainKeyValueTestCase(test.NoDBTestCase):
|
|
|
|
def test_contain_key_value_normal(self):
|
|
matcher = test.ContainKeyValue('foo', 'bar')
|
|
|
|
self.assertEqual(matcher, {123: 'nova', 'foo': 'bar'})
|
|
self.assertNotEqual(matcher, {'foo': 123})
|
|
self.assertNotEqual(matcher, {})
|
|
|
|
def test_contain_key_value_exception(self):
|
|
matcher = test.ContainKeyValue('foo', 'bar')
|
|
|
|
# Raise TypeError
|
|
self.assertNotEqual(matcher, 123)
|
|
self.assertNotEqual(matcher, 'foo')
|
|
# Raise KeyError
|
|
self.assertNotEqual(matcher, {1: 2, '3': 4, 5: '6'})
|
|
self.assertNotEqual(matcher, {'bar': 'foo'})
|
|
|
|
|
|
class NovaExceptionReraiseFormatErrorTestCase(test.NoDBTestCase):
|
|
"""Test that format errors are reraised in tests."""
|
|
|
|
def test_format_error_in_nova_exception(self):
|
|
class FakeImageException(exception.NovaException):
|
|
msg_fmt = 'Image %(image_id)s has wrong type %(type)s.'
|
|
# wrong kwarg
|
|
ex = self.assertRaises(KeyError, FakeImageException,
|
|
bogus='wrongkwarg')
|
|
self.assertIn('image_id', str(ex))
|
|
# no kwarg
|
|
ex = self.assertRaises(KeyError, FakeImageException)
|
|
self.assertIn('image_id', str(ex))
|
|
# not enough kwargs
|
|
ex = self.assertRaises(KeyError, FakeImageException, image_id='image')
|
|
self.assertIn('type', str(ex))
|
|
|
|
|
|
class PatchExistsTestCase(test.NoDBTestCase):
|
|
def test_with_patch_exists_true(self):
|
|
"""Test that "with patch_exists" can fake the existence of a file
|
|
without changing other file existence checks, and that calls can
|
|
be asserted on the mocked method.
|
|
"""
|
|
self.assertFalse(os.path.exists('fake_file'))
|
|
with self.patch_exists('fake_file', True) as mock_exists:
|
|
self.assertTrue(os.path.exists('fake_file'))
|
|
self.assertTrue(os.path.exists(__file__))
|
|
self.assertFalse(os.path.exists('non-existent/file'))
|
|
self.assertIn(mock.call('fake_file'), mock_exists.mock_calls)
|
|
|
|
def test_with_patch_exists_false(self):
|
|
"""Test that "with patch_exists" can fake the non-existence of a file
|
|
without changing other file existence checks, and that calls can
|
|
be asserted on the mocked method.
|
|
"""
|
|
self.assertTrue(os.path.exists(__file__))
|
|
with self.patch_exists(__file__, False) as mock_exists:
|
|
self.assertFalse(os.path.exists(__file__))
|
|
self.assertTrue(os.path.exists(os.path.dirname(__file__)))
|
|
self.assertFalse(os.path.exists('non-existent/file'))
|
|
self.assertIn(mock.call(__file__), mock_exists.mock_calls)
|
|
|
|
@test.patch_exists('fake_file', True)
|
|
def test_patch_exists_decorator_true(self):
|
|
"""Test that @patch_exists can fake the existence of a file
|
|
without changing other file existence checks.
|
|
"""
|
|
self.assertTrue(os.path.exists('fake_file'))
|
|
self.assertTrue(os.path.exists(__file__))
|
|
self.assertFalse(os.path.exists('non-existent/file'))
|
|
|
|
@test.patch_exists(__file__, False)
|
|
def test_patch_exists_decorator_false(self):
|
|
"""Test that @patch_exists can fake the non-existence of a file
|
|
without changing other file existence checks.
|
|
"""
|
|
self.assertFalse(os.path.exists(__file__))
|
|
self.assertTrue(os.path.exists(os.path.dirname(__file__)))
|
|
self.assertFalse(os.path.exists('non-existent/file'))
|
|
|
|
@test.patch_exists('fake_file1', True)
|
|
@test.patch_exists('fake_file2', True)
|
|
@test.patch_exists(__file__, False)
|
|
def test_patch_exists_multiple_decorators(self):
|
|
"""Test that @patch_exists can be used multiple times on the
|
|
same method.
|
|
"""
|
|
self.assertTrue(os.path.exists('fake_file1'))
|
|
self.assertTrue(os.path.exists('fake_file2'))
|
|
self.assertFalse(os.path.exists(__file__))
|
|
|
|
# Check non-patched parameters
|
|
self.assertTrue(os.path.exists(os.path.dirname(__file__)))
|
|
self.assertFalse(os.path.exists('non-existent/file'))
|
|
|
|
|
|
class PatchOpenTestCase(test.NoDBTestCase):
|
|
fake_contents = "These file contents don't really exist"
|
|
|
|
def _test_patched_open(self):
|
|
"""Test that a selectively patched open can fake the contents of a
|
|
file while still allowing normal, real file operations.
|
|
"""
|
|
self.assertFalse(os.path.exists('fake_file'))
|
|
|
|
with open('fake_file') as f:
|
|
self.assertEqual(self.fake_contents, f.read())
|
|
|
|
# Test we can still open and read this file from within the
|
|
# same context. NOTE: We have to make sure we open the .py
|
|
# file not the corresponding .pyc file.
|
|
with open(__file__.rstrip('c')) as f:
|
|
this_file_contents = f.read()
|
|
self.assertIn("class %s(" % self.__class__.__name__,
|
|
this_file_contents)
|
|
self.assertNotIn("magic concatenated" "string",
|
|
this_file_contents)
|
|
|
|
# Test we can still create, write to, and then read from a
|
|
# temporary file, from within the same context.
|
|
tmp = tempfile.NamedTemporaryFile()
|
|
tmp_contents = str(uuid.uuid1())
|
|
with open(tmp.name, 'w') as f:
|
|
f.write(tmp_contents)
|
|
with open(tmp.name) as f:
|
|
self.assertEqual(tmp_contents, f.read())
|
|
|
|
return tmp.name
|
|
|
|
def test_with_patch_open(self):
|
|
"""Test that "with patch_open" can fake the contents of a file
|
|
without changing other file operations, and that calls can
|
|
be asserted on the mocked method.
|
|
"""
|
|
with self.patch_open('fake_file', self.fake_contents) as mock_open:
|
|
tmp_name = self._test_patched_open()
|
|
|
|
# Test we can make assertions about how the mock_open was called.
|
|
self.assertIn(mock.call('fake_file'), mock_open.mock_calls)
|
|
# The mock_open should get bypassed for non-patched path values:
|
|
self.assertNotIn(mock.call(__file__), mock_open.mock_calls)
|
|
self.assertNotIn(mock.call(tmp_name), mock_open.mock_calls)
|
|
|
|
@test.patch_open('fake_file', fake_contents)
|
|
def test_patch_open_decorator(self):
|
|
"""Test that @patch_open can fake the contents of a file
|
|
without changing other file operations.
|
|
"""
|
|
self._test_patched_open()
|