Add google-endpoints to third_party/.

third_party/google-endpoints/apitools/base/protorpclite/util_test.py

+#!/usr/bin/env python
+#
+# Copyright 2010 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.
+#
+
+"""Tests for apitools.base.protorpclite.util."""
+import datetime
+import sys
+import types
+import unittest
+
+import six
+
+from apitools.base.protorpclite import test_util
+from apitools.base.protorpclite import util
+
+
+class ModuleInterfaceTest(test_util.ModuleInterfaceTest,
+                          test_util.TestCase):
+
+    MODULE = util
+
+
+class UtilTest(test_util.TestCase):
+
+    def testDecoratedFunction_LengthZero(self):
+        @util.positional(0)
+        def fn(kwonly=1):
+            return [kwonly]
+        self.assertEquals([1], fn())
+        self.assertEquals([2], fn(kwonly=2))
+        self.assertRaisesWithRegexpMatch(TypeError,
+                                         r'fn\(\) takes at most 0 positional '
+                                         r'arguments \(1 given\)',
+                                         fn, 1)
+
+    def testDecoratedFunction_LengthOne(self):
+        @util.positional(1)
+        def fn(pos, kwonly=1):
+            return [pos, kwonly]
+        self.assertEquals([1, 1], fn(1))
+        self.assertEquals([2, 2], fn(2, kwonly=2))
+        self.assertRaisesWithRegexpMatch(TypeError,
+                                         r'fn\(\) takes at most 1 positional '
+                                         r'argument \(2 given\)',
+                                         fn, 2, 3)
+
+    def testDecoratedFunction_LengthTwoWithDefault(self):
+        @util.positional(2)
+        def fn(pos1, pos2=1, kwonly=1):
+            return [pos1, pos2, kwonly]
+        self.assertEquals([1, 1, 1], fn(1))
+        self.assertEquals([2, 2, 1], fn(2, 2))
+        self.assertEquals([2, 3, 4], fn(2, 3, kwonly=4))
+        self.assertRaisesWithRegexpMatch(TypeError,
+                                         r'fn\(\) takes at most 2 positional '
+                                         r'arguments \(3 given\)',
+                                         fn, 2, 3, 4)
+
+    def testDecoratedMethod(self):
+        class MyClass(object):
+
+            @util.positional(2)
+            def meth(self, pos1, kwonly=1):
+                return [pos1, kwonly]
+        self.assertEquals([1, 1], MyClass().meth(1))
+        self.assertEquals([2, 2], MyClass().meth(2, kwonly=2))
+        self.assertRaisesWithRegexpMatch(
+            TypeError,
+            r'meth\(\) takes at most 2 positional arguments \(3 given\)',
+            MyClass().meth, 2, 3)
+
+    def testDefaultDecoration(self):
+        @util.positional
+        def fn(a, b, c=None):
+            return a, b, c
+        self.assertEquals((1, 2, 3), fn(1, 2, c=3))
+        self.assertEquals((3, 4, None), fn(3, b=4))
+        self.assertRaisesWithRegexpMatch(TypeError,
+                                         r'fn\(\) takes at most 2 positional '
+                                         r'arguments \(3 given\)',
+                                         fn, 2, 3, 4)
+
+    def testDefaultDecorationNoKwdsFails(self):
+        def fn(a):
+            return a
+        self.assertRaisesRegexp(
+            ValueError,
+            ('Functions with no keyword arguments must specify '
+             'max_positional_args'),
+            util.positional, fn)
+
+    def testDecoratedFunctionDocstring(self):
+        @util.positional(0)
+        def fn(kwonly=1):
+            """fn docstring."""
+            return [kwonly]
+        self.assertEquals('fn docstring.', fn.__doc__)
+
+
+class GetPackageForModuleTest(test_util.TestCase):
+
+    def setUp(self):
+        self.original_modules = dict(sys.modules)
+
+    def tearDown(self):
+        sys.modules.clear()
+        sys.modules.update(self.original_modules)
+
+    def CreateModule(self, name, file_name=None):
+        if file_name is None:
+            file_name = '%s.py' % name
+        module = types.ModuleType(name)
+        sys.modules[name] = module
+        return module
+
+    def assertPackageEquals(self, expected, actual):
+        self.assertEquals(expected, actual)
+        if actual is not None:
+            self.assertTrue(isinstance(actual, six.text_type))
+
+    def testByString(self):
+        module = self.CreateModule('service_module')
+        module.package = 'my_package'
+        self.assertPackageEquals('my_package',
+                                 util.get_package_for_module('service_module'))
+
+    def testModuleNameNotInSys(self):
+        self.assertPackageEquals(None,
+                                 util.get_package_for_module('service_module'))
+
+    def testHasPackage(self):
+        module = self.CreateModule('service_module')
+        module.package = 'my_package'
+        self.assertPackageEquals(
+            'my_package', util.get_package_for_module(module))
+
+    def testHasModuleName(self):
+        module = self.CreateModule('service_module')
+        self.assertPackageEquals('service_module',
+                                 util.get_package_for_module(module))
+
+    def testIsMain(self):
+        module = self.CreateModule('__main__')
+        module.__file__ = '/bing/blam/bloom/blarm/my_file.py'
+        self.assertPackageEquals(
+            'my_file', util.get_package_for_module(module))
+
+    def testIsMainCompiled(self):
+        module = self.CreateModule('__main__')
+        module.__file__ = '/bing/blam/bloom/blarm/my_file.pyc'
+        self.assertPackageEquals(
+            'my_file', util.get_package_for_module(module))
+
+    def testNoExtension(self):
+        module = self.CreateModule('__main__')
+        module.__file__ = '/bing/blam/bloom/blarm/my_file'
+        self.assertPackageEquals(
+            'my_file', util.get_package_for_module(module))
+
+    def testNoPackageAtAll(self):
+        module = self.CreateModule('__main__')
+        self.assertPackageEquals(
+            '__main__', util.get_package_for_module(module))
+
+
+class DateTimeTests(test_util.TestCase):
+
+    def testDecodeDateTime(self):
+        """Test that a RFC 3339 datetime string is decoded properly."""
+        for datetime_string, datetime_vals in (
+                ('2012-09-30T15:31:50.262', (2012, 9, 30, 15, 31, 50, 262000)),
+                ('2012-09-30T15:31:50', (2012, 9, 30, 15, 31, 50, 0))):
+            decoded = util.decode_datetime(datetime_string)
+            expected = datetime.datetime(*datetime_vals)
+            self.assertEquals(expected, decoded)
+
+    def testDateTimeTimeZones(self):
+        """Test that a datetime string with a timezone is decoded correctly."""
+        tests = (
+            ('2012-09-30T15:31:50.262-06:00',
+             (2012, 9, 30, 15, 31, 50, 262000, util.TimeZoneOffset(-360))),
+            ('2012-09-30T15:31:50.262+01:30',
+             (2012, 9, 30, 15, 31, 50, 262000, util.TimeZoneOffset(90))),
+            ('2012-09-30T15:31:50+00:05',
+             (2012, 9, 30, 15, 31, 50, 0, util.TimeZoneOffset(5))),
+            ('2012-09-30T15:31:50+00:00',
+             (2012, 9, 30, 15, 31, 50, 0, util.TimeZoneOffset(0))),
+            ('2012-09-30t15:31:50-00:00',
+             (2012, 9, 30, 15, 31, 50, 0, util.TimeZoneOffset(0))),
+            ('2012-09-30t15:31:50z',
+             (2012, 9, 30, 15, 31, 50, 0, util.TimeZoneOffset(0))),
+            ('2012-09-30T15:31:50-23:00',
+             (2012, 9, 30, 15, 31, 50, 0, util.TimeZoneOffset(-1380))))
+        for datetime_string, datetime_vals in tests:
+            decoded = util.decode_datetime(datetime_string)
+            expected = datetime.datetime(*datetime_vals)
+            self.assertEquals(expected, decoded)
+
+    def testDecodeDateTimeInvalid(self):
+        """Test that decoding malformed datetime strings raises execptions."""
+        for datetime_string in ('invalid',
+                                '2012-09-30T15:31:50.',
+                                '-08:00 2012-09-30T15:31:50.262',
+                                '2012-09-30T15:31',
+                                '2012-09-30T15:31Z',
+                                '2012-09-30T15:31:50ZZ',
+                                '2012-09-30T15:31:50.262 blah blah -08:00',
+                                '1000-99-99T25:99:99.999-99:99'):
+            self.assertRaises(
+                ValueError, util.decode_datetime, datetime_string)
+
+    def testTimeZoneOffsetDelta(self):
+        """Test that delta works with TimeZoneOffset."""
+        time_zone = util.TimeZoneOffset(datetime.timedelta(minutes=3))
+        epoch = time_zone.utcoffset(datetime.datetime.utcfromtimestamp(0))
+        self.assertEqual(180, util.total_seconds(epoch))
+
+
+def main():
+    unittest.main()
+
+
+if __name__ == '__main__':
+    main()