class TestOpenApiEditor_add_path(TestCase):
def setUp(self):
self.original_openapi = {
"openapi": "3.0.1",
"paths": {
"/foo": {
"get": {
"a": "b"
}
},
"/bar": {},
"/badpath": "string value"
},
}
self.editor = OpenApiEditor(self.original_openapi)
@parameterized.expand([
param("/new", "get", "new path, new method"),
param("/foo", "new method", "existing path, new method"),
param("/bar", "get", "existing path, new method"),
])
def test_must_add_new_path_and_method(self, path, method, case):
self.assertFalse(self.editor.has_path(path, method))
self.editor.add_path(path, method)
self.assertTrue(self.editor.has_path(path, method),
"must add for " + case)
self.assertEqual(self.editor.openapi["paths"][path][method], {})
def test_must_raise_non_dict_path_values(self):
path = "/badpath"
method = "get"
with self.assertRaises(InvalidDocumentException):
self.editor.add_path(path, method)
def test_must_skip_existing_path(self):
"""
Given an existing path/method, this must
:return:
"""
path = "/foo"
method = "get"
original_value = copy.deepcopy(
self.original_openapi["paths"][path][method])
self.editor.add_path(path, method)
modified_openapi = self.editor.openapi
self.assertEqual(original_value,
modified_openapi["paths"][path][method])
class TestOpenApiEditor_has_path(TestCase):
def setUp(self):
self.openapi = {
"openapi": "3.0.1",
"paths": {
"/foo": {"get": {}, "somemethod": {}},
"/bar": {"post": {}, _X_ANY_METHOD: {}},
"badpath": "string value",
},
}
self.editor = OpenApiEditor(self.openapi)
def test_must_find_path_and_method(self):
self.assertTrue(self.editor.has_path("/foo"))
self.assertTrue(self.editor.has_path("/foo", "get"))
self.assertTrue(self.editor.has_path("/foo", "somemethod"))
self.assertTrue(self.editor.has_path("/bar"))
self.assertTrue(self.editor.has_path("/bar", "post"))
def test_must_find_with_method_case_insensitive(self):
self.assertTrue(self.editor.has_path("/foo", "GeT"))
self.assertTrue(self.editor.has_path("/bar", "POST"))
# Only Method is case insensitive. Path is case sensitive
self.assertFalse(self.editor.has_path("/FOO"))
def test_must_work_with_any_method(self):
"""
Method name "ANY" is special. It must be converted to the x-amazon style value before search
"""
self.assertTrue(self.editor.has_path("/bar", "any"))
self.assertTrue(self.editor.has_path("/bar", "AnY")) # Case insensitive
self.assertTrue(self.editor.has_path("/bar", _X_ANY_METHOD))
self.assertFalse(self.editor.has_path("/foo", "any"))
def test_must_not_find_path(self):
self.assertFalse(self.editor.has_path("/foo/other"))
self.assertFalse(self.editor.has_path("/bar/xyz"))
self.assertFalse(self.editor.has_path("/abc"))
def test_must_not_find_path_and_method(self):
self.assertFalse(self.editor.has_path("/foo", "post"))
self.assertFalse(self.editor.has_path("/foo", "abc"))
self.assertFalse(self.editor.has_path("/bar", "get"))
self.assertFalse(self.editor.has_path("/bar", "xyz"))
def test_must_not_fail_on_bad_path(self):
self.assertTrue(self.editor.has_path("badpath"))
self.assertFalse(self.editor.has_path("badpath", "somemethod"))
class TestOpenApiEditor_add_lambda_integration(TestCase):
def setUp(self):
self.original_openapi = {
"openapi": "3.0.1",
"paths": {
"/foo": {"post": {"a": [1, 2, "b"], "responses": {"something": "is already here"}}},
"/bar": {"get": {_X_INTEGRATION: {"a": "b"}}},
},
}
self.editor = OpenApiEditor(self.original_openapi)
def test_must_add_new_integration_to_new_path(self):
path = "/newpath"
method = "get"
integration_uri = "something"
expected = {
"responses": {},
_X_INTEGRATION: {
"type": "aws_proxy",
"httpMethod": "POST",
"payloadFormatVersion": "2.0",
"uri": integration_uri,
},
}
self.editor.add_lambda_integration(path, method, integration_uri)
self.assertTrue(self.editor.has_path(path, method))
actual = self.editor.openapi["paths"][path][method]
self.assertEqual(expected, actual)
def test_must_add_new_integration_with_conditions_to_new_path(self):
path = "/newpath"
method = "get"
integration_uri = "something"
condition = "condition"
expected = {
"Fn::If": [
"condition",
{
"responses": {},
_X_INTEGRATION: {
"type": "aws_proxy",
"httpMethod": "POST",
"payloadFormatVersion": "2.0",
"uri": {"Fn::If": ["condition", integration_uri, {"Ref": "AWS::NoValue"}]},
},
},
{"Ref": "AWS::NoValue"},
]
}
self.editor.add_lambda_integration(path, method, integration_uri, condition=condition)
self.assertTrue(self.editor.has_path(path, method))
actual = self.editor.openapi["paths"][path][method]
self.assertEqual(expected, actual)
def test_must_add_new_integration_to_existing_path(self):
path = "/foo"
method = "post"
integration_uri = "something"
expected = {
# Current values present in the dictionary *MUST* be preserved
"a": [1, 2, "b"],
# Responses key must be untouched
"responses": {"something": "is already here"},
# New values must be added
_X_INTEGRATION: {
"type": "aws_proxy",
"httpMethod": "POST",
"payloadFormatVersion": "2.0",
"uri": integration_uri,
},
}
# Just make sure test is working on an existing path
self.assertTrue(self.editor.has_path(path, method))
self.editor.add_lambda_integration(path, method, integration_uri)
actual = self.editor.openapi["paths"][path][method]
self.assertEqual(expected, actual)