Remove oauth2client._helpers dependency (#493)
diff --git a/tests/test__helpers.py b/tests/test__helpers.py
new file mode 100644
index 0000000..e33ea71
--- /dev/null
+++ b/tests/test__helpers.py
@@ -0,0 +1,161 @@
+# Copyright 2015 Google Inc. 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.
+
+"""Unit tests for googleapiclient._helpers."""
+
+import unittest
+
+import mock
+
+import six
+from six.moves import urllib
+
+from googleapiclient import _helpers
+
+
+class PositionalTests(unittest.TestCase):
+
+ def test_usage(self):
+ _helpers.positional_parameters_enforcement = (
+ _helpers.POSITIONAL_EXCEPTION)
+
+ # 1 positional arg, 1 keyword-only arg.
+ @_helpers.positional(1)
+ def function(pos, kwonly=None):
+ return True
+
+ self.assertTrue(function(1))
+ self.assertTrue(function(1, kwonly=2))
+ with self.assertRaises(TypeError):
+ function(1, 2)
+
+ # No positional, but a required keyword arg.
+ @_helpers.positional(0)
+ def function2(required_kw):
+ return True
+
+ self.assertTrue(function2(required_kw=1))
+ with self.assertRaises(TypeError):
+ function2(1)
+
+ # Unspecified positional, should automatically figure out 1 positional
+ # 1 keyword-only (same as first case above).
+ @_helpers.positional
+ def function3(pos, kwonly=None):
+ return True
+
+ self.assertTrue(function3(1))
+ self.assertTrue(function3(1, kwonly=2))
+ with self.assertRaises(TypeError):
+ function3(1, 2)
+
+ @mock.patch('googleapiclient._helpers.logger')
+ def test_enforcement_warning(self, mock_logger):
+ _helpers.positional_parameters_enforcement = (
+ _helpers.POSITIONAL_WARNING)
+
+ @_helpers.positional(1)
+ def function(pos, kwonly=None):
+ return True
+
+ self.assertTrue(function(1, 2))
+ self.assertTrue(mock_logger.warning.called)
+
+ @mock.patch('googleapiclient._helpers.logger')
+ def test_enforcement_ignore(self, mock_logger):
+ _helpers.positional_parameters_enforcement = _helpers.POSITIONAL_IGNORE
+
+ @_helpers.positional(1)
+ def function(pos, kwonly=None):
+ return True
+
+ self.assertTrue(function(1, 2))
+ self.assertFalse(mock_logger.warning.called)
+
+
+class AddQueryParameterTests(unittest.TestCase):
+
+ def test__add_query_parameter(self):
+ self.assertEqual(
+ _helpers._add_query_parameter('/action', 'a', None),
+ '/action')
+ self.assertEqual(
+ _helpers._add_query_parameter('/action', 'a', 'b'),
+ '/action?a=b')
+ self.assertEqual(
+ _helpers._add_query_parameter('/action?a=b', 'a', 'c'),
+ '/action?a=c')
+ # Order is non-deterministic.
+ self.assertIn(
+ _helpers._add_query_parameter('/action?a=b', 'c', 'd'),
+ ['/action?a=b&c=d', '/action?c=d&a=b'])
+ self.assertEqual(
+ _helpers._add_query_parameter('/action', 'a', ' ='),
+ '/action?a=+%3D')
+
+
+def assertUrisEqual(testcase, expected, actual):
+ """Test that URIs are the same, up to reordering of query parameters."""
+ expected = urllib.parse.urlparse(expected)
+ actual = urllib.parse.urlparse(actual)
+ testcase.assertEqual(expected.scheme, actual.scheme)
+ testcase.assertEqual(expected.netloc, actual.netloc)
+ testcase.assertEqual(expected.path, actual.path)
+ testcase.assertEqual(expected.params, actual.params)
+ testcase.assertEqual(expected.fragment, actual.fragment)
+ expected_query = urllib.parse.parse_qs(expected.query)
+ actual_query = urllib.parse.parse_qs(actual.query)
+ for name in expected_query.keys():
+ testcase.assertEqual(expected_query[name], actual_query[name])
+ for name in actual_query.keys():
+ testcase.assertEqual(expected_query[name], actual_query[name])
+
+
+class Test_update_query_params(unittest.TestCase):
+
+ def test_update_query_params_no_params(self):
+ uri = 'http://www.google.com'
+ updated = _helpers.update_query_params(uri, {'a': 'b'})
+ self.assertEqual(updated, uri + '?a=b')
+
+ def test_update_query_params_existing_params(self):
+ uri = 'http://www.google.com?x=y'
+ updated = _helpers.update_query_params(uri, {'a': 'b', 'c': 'd&'})
+ hardcoded_update = uri + '&a=b&c=d%26'
+ assertUrisEqual(self, updated, hardcoded_update)
+
+ def test_update_query_params_replace_param(self):
+ base_uri = 'http://www.google.com'
+ uri = base_uri + '?x=a'
+ updated = _helpers.update_query_params(uri, {'x': 'b', 'y': 'c'})
+ hardcoded_update = base_uri + '?x=b&y=c'
+ assertUrisEqual(self, updated, hardcoded_update)
+
+ def test_update_query_params_repeated_params(self):
+ uri = 'http://www.google.com?x=a&x=b'
+ with self.assertRaises(ValueError):
+ _helpers.update_query_params(uri, {'a': 'c'})
+
+
+class Test_parse_unique_urlencoded(unittest.TestCase):
+
+ def test_without_repeats(self):
+ content = 'a=b&c=d'
+ result = _helpers.parse_unique_urlencoded(content)
+ self.assertEqual(result, {'a': 'b', 'c': 'd'})
+
+ def test_with_repeats(self):
+ content = 'a=b&a=d'
+ with self.assertRaises(ValueError):
+ _helpers.parse_unique_urlencoded(content)