| #!/usr/bin/env python |
| # |
| # Copyright 2007 Google Inc. |
| # |
| # 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. |
| # |
| """Unit tests for the api_config_manager module.""" |
| |
| |
| |
| import json |
| import re |
| import unittest |
| |
| from google.appengine.tools.devappserver2.endpoints import api_config_manager |
| |
| |
| class ApiConfigManagerTest(unittest.TestCase): |
| |
| def setUp(self): |
| """Make ApiConfigManager with a few helpful fakes.""" |
| self.config_manager = api_config_manager.ApiConfigManager() |
| |
| def test_parse_api_config_empty_response(self): |
| self.config_manager.parse_api_config_response('') |
| actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get', |
| 'v1') |
| self.assertEqual(None, actual_method) |
| |
| def test_parse_api_config_invalid_response(self): |
| self.config_manager.parse_api_config_response('{"name": "foo"}') |
| actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get', |
| 'v1') |
| self.assertEqual(None, actual_method) |
| |
| def test_parse_api_config(self): |
| fake_method = {'httpMethod': 'GET', |
| 'path': 'greetings/{gid}', |
| 'rosyMethod': 'baz.bim'} |
| config = json.dumps({'name': 'guestbook_api', |
| 'version': 'X', |
| 'methods': {'guestbook_api.foo.bar': fake_method}}) |
| self.config_manager.parse_api_config_response( |
| json.dumps({'items': [config]})) |
| actual_method = self.config_manager.lookup_rpc_method( |
| 'guestbook_api.foo.bar', 'X') |
| self.assertEqual(fake_method, actual_method) |
| |
| def test_parse_api_config_order_length(self): |
| test_method_info = ( |
| ('guestbook_api.foo.bar', 'greetings/{gid}', 'baz.bim'), |
| ('guestbook_api.list', 'greetings', 'greetings.list'), |
| ('guestbook_api.f3', 'greetings/{gid}/sender/property/blah', |
| 'greetings.f3'), |
| ('guestbook_api.shortgreet', 'greet', 'greetings.short_greeting')) |
| methods = {} |
| for method_name, path, rosy_method in test_method_info: |
| method = {'httpMethod': 'GET', |
| 'path': path, |
| 'rosyMethod': rosy_method} |
| methods[method_name] = method |
| config = json.dumps({'name': 'guestbook_api', |
| 'version': 'X', |
| 'methods': methods}) |
| self.config_manager.parse_api_config_response( |
| json.dumps({'items': [config]})) |
| # Make sure all methods appear in the result. |
| for method_name, _, _ in test_method_info: |
| self.assertIsNotNone( |
| self.config_manager.lookup_rpc_method(method_name, 'X')) |
| # Make sure paths and partial paths return the right methods. |
| self.assertEqual( |
| self.config_manager.lookup_rest_method( |
| 'guestbook_api/X/greetings', 'GET')[0], |
| 'guestbook_api.list') |
| self.assertEqual( |
| self.config_manager.lookup_rest_method( |
| 'guestbook_api/X/greetings/1', 'GET')[0], |
| 'guestbook_api.foo.bar') |
| self.assertEqual( |
| self.config_manager.lookup_rest_method( |
| 'guestbook_api/X/greetings/2/sender/property/blah', 'GET')[0], |
| 'guestbook_api.f3') |
| self.assertEqual( |
| self.config_manager.lookup_rest_method( |
| 'guestbook_api/X/greet', 'GET')[0], |
| 'guestbook_api.shortgreet') |
| |
| def test_get_sorted_methods1(self): |
| test_method_info = ( |
| ('name1', 'greetings', 'POST'), |
| ('name2', 'greetings', 'GET'), |
| ('name3', 'short/but/many/constants', 'GET'), |
| ('name4', 'greetings', ''), |
| ('name5', 'greetings/{gid}', 'GET'), |
| ('name6', 'greetings/{gid}', 'PUT'), |
| ('name7', 'a/b/{var}/{var2}', 'GET')) |
| methods = {} |
| for method_name, path, http_method in test_method_info: |
| method = {'httpMethod': http_method, |
| 'path': path} |
| methods[method_name] = method |
| sorted_methods = self.config_manager._get_sorted_methods(methods) |
| |
| expected_data = [ |
| ('name3', 'short/but/many/constants', 'GET'), |
| ('name7', 'a/b/{var}/{var2}', 'GET'), |
| ('name4', 'greetings', ''), |
| ('name2', 'greetings', 'GET'), |
| ('name1', 'greetings', 'POST'), |
| ('name5', 'greetings/{gid}', 'GET'), |
| ('name6', 'greetings/{gid}', 'PUT')] |
| expected_methods = [(name, {'httpMethod': http_method, 'path': path}) |
| for name, path, http_method in expected_data] |
| self.assertEqual(expected_methods, sorted_methods) |
| |
| def test_get_sorted_methods2(self): |
| test_method_info = ( |
| ('name1', 'abcdefghi', 'GET'), |
| ('name2', 'foo', 'GET'), |
| ('name3', 'greetings', 'GET'), |
| ('name4', 'bar', 'POST'), |
| ('name5', 'baz', 'GET'), |
| ('name6', 'baz', 'PUT'), |
| ('name7', 'baz', 'DELETE')) |
| methods = {} |
| for method_name, path, http_method in test_method_info: |
| method = {'httpMethod': http_method, |
| 'path': path} |
| methods[method_name] = method |
| sorted_methods = self.config_manager._get_sorted_methods(methods) |
| |
| # Single-part paths should be sorted by path name, http_method. |
| expected_data = [ |
| ('name1', 'abcdefghi', 'GET'), |
| ('name4', 'bar', 'POST'), |
| ('name7', 'baz', 'DELETE'), |
| ('name5', 'baz', 'GET'), |
| ('name6', 'baz', 'PUT'), |
| ('name2', 'foo', 'GET'), |
| ('name3', 'greetings', 'GET')] |
| expected_methods = [(name, {'httpMethod': http_method, 'path': path}) |
| for name, path, http_method in expected_data] |
| self.assertEqual(expected_methods, sorted_methods) |
| |
| def test_parse_api_config_invalid_api_config(self): |
| fake_method = {'httpMethod': 'GET', |
| 'path': 'greetings/{gid}', |
| 'rosyMethod': 'baz.bim'} |
| config = json.dumps({'name': 'guestbook_api', |
| 'version': 'X', |
| 'methods': {'guestbook_api.foo.bar': fake_method}}) |
| # Invalid Json |
| config2 = '{' |
| self.config_manager.parse_api_config_response( |
| json.dumps({'items': [config, config2]})) |
| actual_method = self.config_manager.lookup_rpc_method( |
| 'guestbook_api.foo.bar', 'X') |
| self.assertEqual(fake_method, actual_method) |
| |
| def test_parse_api_config_convert_https(self): |
| """Test that the parsed API config has switched HTTPS to HTTP.""" |
| config = json.dumps({'name': 'guestbook_api', |
| 'version': 'X', |
| 'adapter': {'bns': 'https://localhost/_ah/spi', |
| 'type': 'lily'}, |
| 'root': 'https://localhost/_ah/api', |
| 'methods': {}}) |
| self.config_manager.parse_api_config_response( |
| json.dumps({'items': [config]})) |
| |
| self.assertEqual( |
| 'http://localhost/_ah/spi', |
| self.config_manager.configs[('guestbook_api', 'X')]['adapter']['bns']) |
| self.assertEqual( |
| 'http://localhost/_ah/api', |
| self.config_manager.configs[('guestbook_api', 'X')]['root']) |
| |
| def test_convert_https_to_http(self): |
| """Test that the _convert_https_to_http function works.""" |
| config = {'name': 'guestbook_api', |
| 'version': 'X', |
| 'adapter': {'bns': 'https://tictactoe.appspot.com/_ah/spi', |
| 'type': 'lily'}, |
| 'root': 'https://tictactoe.appspot.com/_ah/api', |
| 'methods': {}} |
| self.config_manager._convert_https_to_http(config) |
| |
| self.assertEqual('http://tictactoe.appspot.com/_ah/spi', |
| config['adapter']['bns']) |
| self.assertEqual('http://tictactoe.appspot.com/_ah/api', config['root']) |
| |
| def test_dont_convert_non_https_to_http(self): |
| """Verify that we don't change non-HTTPS URLs.""" |
| config = {'name': 'guestbook_api', |
| 'version': 'X', |
| 'adapter': {'bns': 'http://https.appspot.com/_ah/spi', |
| 'type': 'lily'}, |
| 'root': 'ios://https.appspot.com/_ah/api', |
| 'methods': {}} |
| self.config_manager._convert_https_to_http(config) |
| |
| self.assertEqual('http://https.appspot.com/_ah/spi', |
| config['adapter']['bns']) |
| self.assertEqual('ios://https.appspot.com/_ah/api', config['root']) |
| |
| def test_save_lookup_rpc_method(self): |
| # First attempt, guestbook.get does not exist |
| actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get', |
| 'v1') |
| self.assertEqual(None, actual_method) |
| |
| # Now we manually save it, and should find it |
| fake_method = {'some': 'object'} |
| self.config_manager._save_rpc_method('guestbook_api.get', 'v1', fake_method) |
| actual_method = self.config_manager.lookup_rpc_method('guestbook_api.get', |
| 'v1') |
| self.assertEqual(fake_method, actual_method) |
| |
| def test_save_lookup_rest_method(self): |
| # First attempt, guestbook.get does not exist |
| method_spec = self.config_manager.lookup_rest_method( |
| 'guestbook_api/v1/greetings/i', 'GET') |
| self.assertEqual((None, None, None), method_spec) |
| |
| # Now we manually save it, and should find it |
| fake_method = {'httpMethod': 'GET', |
| 'path': 'greetings/{id}'} |
| self.config_manager._save_rest_method('guestbook_api.get', 'guestbook_api', |
| 'v1', fake_method) |
| method_name, method_spec, params = self.config_manager.lookup_rest_method( |
| 'guestbook_api/v1/greetings/i', 'GET') |
| self.assertEqual('guestbook_api.get', method_name) |
| self.assertEqual(fake_method, method_spec) |
| self.assertEqual({'id': 'i'}, params) |
| |
| def test_trailing_slash_optional(self): |
| # Create a typical get resource URL. |
| fake_method = {'httpMethod': 'GET', 'path': 'trailingslash'} |
| self.config_manager._save_rest_method('guestbook_api.trailingslash', |
| 'guestbook_api', 'v1', fake_method) |
| |
| # Make sure we get this method when we query without a slash. |
| method_name, method_spec, params = self.config_manager.lookup_rest_method( |
| 'guestbook_api/v1/trailingslash', 'GET') |
| self.assertEqual('guestbook_api.trailingslash', method_name) |
| self.assertEqual(fake_method, method_spec) |
| self.assertEqual({}, params) |
| |
| # Make sure we get this method when we query with a slash. |
| method_name, method_spec, params = self.config_manager.lookup_rest_method( |
| 'guestbook_api/v1/trailingslash/', 'GET') |
| self.assertEqual('guestbook_api.trailingslash', method_name) |
| self.assertEqual(fake_method, method_spec) |
| self.assertEqual({}, params) |
| |
| |
| class ParameterizedPathTest(unittest.TestCase): |
| |
| |
| def test_invalid_variable_name_leading_digit(self): |
| self.assertEqual( |
| None, re.match(api_config_manager._PATH_VARIABLE_PATTERN, '1abc')) |
| |
| # Ensure users can not add variables starting with ! |
| # This is used for reserved variables (e.g. !name and !version) |
| def test_invalid_var_name_leading_exclamation(self): |
| self.assertEqual( |
| None, re.match(api_config_manager._PATH_VARIABLE_PATTERN, '!abc')) |
| |
| def test_valid_variable_name(self): |
| self.assertEqual( |
| 'AbC1', re.match(api_config_manager._PATH_VARIABLE_PATTERN, |
| 'AbC1').group(0)) |
| |
| def assert_no_match(self, path, param_path): |
| """Assert that the given path does not match param_path pattern. |
| |
| For example, /xyz/123 does not match /abc/{x}. |
| |
| Args: |
| path: A string, the inbound request path. |
| param_path: A string, the parameterized path pattern to match against |
| this path. |
| """ |
| config_manager = api_config_manager.ApiConfigManager |
| params = config_manager._compile_path_pattern(param_path).match(path) |
| self.assertEqual(None, params) |
| |
| def test_prefix_no_match(self): |
| self.assert_no_match('/xyz/123', '/abc/{x}') |
| |
| def test_suffix_no_match(self): |
| self.assert_no_match('/abc/123', '/abc/{x}/456') |
| |
| def test_suffix_no_match_with_more_variables(self): |
| self.assert_no_match('/abc/456/123/789', '/abc/{x}/123/{y}/xyz') |
| |
| def test_no_match_collection_with_item(self): |
| self.assert_no_match('/api/v1/resources/123', '/{name}/{version}/resources') |
| |
| def assert_match(self, path, param_path, param_count): |
| """Assert that the given path does match param_path pattern. |
| |
| For example, /abc/123 does not match /abc/{x}. |
| |
| Args: |
| path: A string, the inbound request path. |
| param_path: A string, the parameterized path pattern to match against |
| this path. |
| param_count: An int, the expected number of parameters to match in |
| pattern. |
| |
| Returns: |
| Dict mapping path variable name to path variable value. |
| """ |
| config_manager = api_config_manager.ApiConfigManager |
| match = config_manager._compile_path_pattern(param_path).match(path) |
| self.assertTrue(match is not None) # Will be None if path was not matched |
| params = config_manager._get_path_params(match) |
| self.assertEquals(param_count, len(params)) |
| return params |
| |
| def test_one_variable_match(self): |
| params = self.assert_match('/abc/123', '/abc/{x}', 1) |
| self.assertEquals('123', params.get('x')) |
| |
| def test_two_variable_match(self): |
| params = self.assert_match('/abc/456/123/789', '/abc/{x}/123/{y}', 2) |
| self.assertEquals('456', params.get('x')) |
| self.assertEquals('789', params.get('y')) |
| |
| def test_message_variable_match(self): |
| params = self.assert_match('/abc/123', '/abc/{x.y}', 1) |
| self.assertEquals('123', params.get('x.y')) |
| |
| def test_message_and_simple_variable_match(self): |
| params = self.assert_match('/abc/123/456', '/abc/{x.y.z}/{t}', 2) |
| self.assertEquals('123', params.get('x.y.z')) |
| self.assertEquals('456', params.get('t')) |
| |
| def assert_invalid_value(self, value): |
| """Assert that the path parameter value is not valid. |
| |
| For example, /abc/3!:2 is invalid for /abc/{x}. |
| |
| Args: |
| value: A string containing a variable value to check for validity. |
| """ |
| param_path = '/abc/{x}' |
| path = '/abc/%s' % value |
| config_manager = api_config_manager.ApiConfigManager |
| params = config_manager._compile_path_pattern(param_path).match(path) |
| self.assertEqual(None, params) |
| |
| def test_invalid_values(self): |
| for reserved in [':', '?', '#', '[', ']', '{', '}']: |
| self.assert_invalid_value('123%s' % reserved) |
| |
| if __name__ == '__main__': |
| unittest.main() |
