Merge pull request #127 from yilei/push_up_to_286008946

Push up to 286008946

Author: yilei

absl/BUILD

@@ -1,9 +1,9 @@
+load(":_build_defs.bzl", "py2and3_test", "py2py3_test_binary")
+
 licenses(["notice"])  # Apache 2.0
 
 exports_files(["LICENSE"])
 
-load(":_build_defs.bzl", "py2py3_test_binary", "py2and3_test")
-
 py_library(
     name = "app",
     srcs = [

absl/CHANGELOG.md

@@ -8,6 +8,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com).
 
 Nothing notable unreleased.
 
+## 0.9.0 (2019-12-17)
+
+### Added
+
+*   (testing) `TestCase.enter_context`: Allows using context managers in setUp
+    and having them automatically exited when a test finishes.
+
+### Fixed
+
+*   #126: calling `logging.debug(msg, stack_info=...)` no longer throws an
+    exception in Python 3.8.
+
 ## 0.8.1 (2019-10-08)
 
 ### Fixed

absl/flags/tests/flags_test.py

@@ -626,7 +626,7 @@ def args_list():
         '--stderrthreshold fatal',
         '--test1',
         '--test_random_seed 301',
-        '--test_randomize_ordering_seed None',
+        '--test_randomize_ordering_seed ',
         '--testcomma_list []',
         '--testget1',
         '--testget4 None',
@@ -694,7 +694,7 @@ def args_list():
         '--stderrthreshold fatal',
         '--test1',
         '--test_random_seed 301',
-        '--test_randomize_ordering_seed None',
+        '--test_randomize_ordering_seed ',
         '--testcomma_list []',
         '--testget1',
         '--testget4 None',

absl/logging/BUILD

@@ -1,9 +1,9 @@
+load("//absl:_build_defs.bzl", "py2and3_test", "py2py3_test_binary")
+
 licenses(["notice"])  # Apache 2.0
 
 exports_files(["LICENSE"])
 
-load("//absl:_build_defs.bzl", "py2py3_test_binary", "py2and3_test")
-
 py_library(
     name = "logging",
     srcs = ["__init__.py"],

absl/testing/BUILD

@@ -1,8 +1,29 @@
+load("//absl:_build_defs.bzl", "py2and3_test", "py2py3_test_binary")
+
 licenses(["notice"])  # Apache 2.0
 
 exports_files(["LICENSE"])
 
-load("//absl:_build_defs.bzl", "py2py3_test_binary", "py2and3_test")
+config_setting(
+    name = "osx",
+    constraint_values = ["//third_party/bazel_platforms/os:osx"],
+)
+
+config_setting(
+    name = "ios",
+    flag_values = {"//tools/cpp:cc_target_os": "apple"},
+)
+
+_absl_test_platform_deps = select({
+    ":osx": [],
+    ":ios": [],
+    # TODO(b/75911467): Remove after :osx works in host mode
+    "//tools/cc_target_os:platform_macos": [],
+    "//conditions:default": [
+        "//third_party/py/faulthandler",
+        "//third_party/py/readline",  # Enables arrow keys and tab-completion in (pdb).
+    ],
+})
 
 py_library(
     name = "absltest",

absl/testing/absltest.py

@@ -70,7 +70,7 @@
 try:
   # pylint: disable=unused-import
   import typing
-  from typing import AnyStr, Callable, Text, Optional, ContextManager, TextIO, BinaryIO, Union, Type, Tuple, Any, MutableSequence, Sequence, Mapping, MutableMapping, IO, List
+  from typing import Any, AnyStr, BinaryIO, Callable, ContextManager, IO, Iterator, List, Mapping, MutableMapping, MutableSequence, Optional, Sequence, Text, TextIO, Tuple, Type, Union
   # pylint: enable=unused-import
 except ImportError:
   pass
@@ -207,11 +207,8 @@ def _get_default_randomize_ordering_seed():
     ValueError: Raised when the flag or env value is not one of the options
         above.
   """
-  if FLAGS.test_randomize_ordering_seed is not None:
-    randomize = FLAGS.test_randomize_ordering_seed
-  else:
-    randomize = os.environ.get('TEST_RANDOMIZE_ORDERING_SEED')
-  if randomize is None:
+  randomize = FLAGS.test_randomize_ordering_seed
+  if not randomize:
     return 0
   if randomize == 'random':
     return random.Random().randint(1, 4294967295)
@@ -239,12 +236,14 @@ def _get_default_randomize_ordering_seed():
 flags.DEFINE_string('test_tmpdir', get_default_test_tmpdir(),
                     'Directory for temporary testing files',
                     allow_override_cpp=True)
-flags.DEFINE_string('test_randomize_ordering_seed', None,
+flags.DEFINE_string('test_randomize_ordering_seed',
+                    os.environ.get('TEST_RANDOMIZE_ORDERING_SEED', ''),
                     'If positive, use this as a seed to randomize the '
                     'execution order for test cases. If "random", pick a '
                     'random seed to use. If 0 or not set, do not randomize '
                     'test case execution order. This flag also overrides '
-                    'the TEST_RANDOMIZE_ORDERING_SEED environment variable.')
+                    'the TEST_RANDOMIZE_ORDERING_SEED environment variable.',
+                    allow_override_cpp=True)
 flags.DEFINE_string('xml_output_file', '',
                     'File to store XML test results')
 
@@ -485,7 +484,8 @@ def open_text(self, mode='rt', encoding='utf8', errors='strict'):
                        'file in text mode'.format(mode))
     if 't' not in mode:
       mode += 't'
-    return self._open(mode, encoding, errors)
+    cm = self._open(mode, encoding, errors)  # type: ContextManager[TextIO]
+    return cm
 
   def open_bytes(self, mode='rb'):
     # type: (Text) -> ContextManager[BinaryIO]
@@ -506,11 +506,15 @@ def open_bytes(self, mode='rb'):
                        'file in binary mode'.format(mode))
     if 'b' not in mode:
       mode += 'b'
-    return self._open(mode, encoding=None, errors=None)
+    cm = self._open(mode, encoding=None, errors=None)  # type: ContextManager[BinaryIO]
+    return cm
 
+  # TODO(b/123775699): Once pytype supports typing.Literal, use overload and
+  # Literal to express more precise return types and remove the type comments in
+  # open_text and open_bytes.
   @contextlib.contextmanager
   def _open(self, mode, encoding='utf8', errors='strict'):
-    # type: (Text, Text, Text) -> Union[TextIO, BinaryIO]
+    # type: (Text, Text, Text) -> Iterator[Union[IO[Text], IO[bytes]]]
     with io.open(
         self.full_path, mode=mode, encoding=encoding, errors=errors) as fp:
       yield fp
@@ -534,6 +538,15 @@ def __init__(self, *args, **kwargs):
     super(TestCase, self).__init__(*args, **kwargs)
     # This is to work around missing type stubs in unittest.pyi
     self._outcome = getattr(self, '_outcome')  # type: Optional[_OutcomeType]
+    # This is re-initialized by setUp().
+    self._exit_stack = None
+
+  def setUp(self):
+    super(TestCase, self).setUp()
+    # NOTE: Only Py3 contextlib has ExitStack
+    if hasattr(contextlib, 'ExitStack'):
+      self._exit_stack = contextlib.ExitStack()
+      self.addCleanup(self._exit_stack.close)
 
   def create_tempdir(self, name=None, cleanup=None):
     # type: (Optional[Text], Optional[TempFileCleanup]) -> _TempDir
@@ -625,6 +638,32 @@ def create_tempfile(self, file_path=None, content=None, mode='w',
     self._maybe_add_temp_path_cleanup(cleanup_path, cleanup)
     return tf
 
+  def enter_context(self, manager):
+    """Returns the CM's value after registering it with the exit stack.
+
+    Entering a context pushes it onto a stack of contexts. The context is exited
+    when the test completes. Contexts are are exited in the reverse order of
+    entering. They will always be exited, regardless of test failure/success.
+    The context stack is specific to the test being run.
+
+    This is useful to eliminate per-test boilerplate when context managers
+    are used. For example, instead of decorating every test with `@mock.patch`,
+    simply do `self.foo = self.enter_context(mock.patch(...))' in `setUp()`.
+
+    NOTE: The context managers will always be exited without any error
+    information. This is an unfortunate implementation detail due to some
+    internals of how unittest runs tests.
+
+    Args:
+      manager: The context manager to enter.
+    """
+    # type: (ContextManager[_T]) -> _T
+    if not self._exit_stack:
+      raise AssertionError(
+          'self._exit_stack is not set: enter_context is Py3-only; also make '
+          'sure that AbslTest.setUp() is called.')
+    return self._exit_stack.enter_context(manager)
+
   @classmethod
   def _get_tempdir_path_cls(cls):
     # type: () -> Text

absl/testing/parameterized.py

@@ -281,6 +281,10 @@ def bound_param_test(self):
           testcase_params = {k: v for k, v in six.iteritems(testcase_params)
                              if k != _NAMED_DICT_KEY}
         elif _non_string_or_bytes_iterable(testcase_params):
+          if not isinstance(testcase_params[0], six.string_types):
+            raise RuntimeError(
+                'The first element of named test parameters is the test name '
+                'suffix and must be a string')
           testcase_name = testcase_params[0]
           testcase_params = testcase_params[1:]
         else:

absl/testing/tests/absltest_test.py

@@ -19,6 +19,7 @@
 from __future__ import print_function
 
 import collections
+import contextlib
 import io
 import os
 import re
@@ -1466,6 +1467,37 @@ def test_stderr(self):
     self.assertRegex(stderr, 'No such file or directory')
 
 
+@absltest.skipIf(six.PY2, 'Python 2 does not have ExitStack')
+class EnterContextTest(absltest.TestCase):
+
+  def setUp(self):
+    self.cm_state = 'unset'
+    self.cm_value = 'unset'
+
+    def assert_cm_exited():
+      self.assertEqual(self.cm_state, 'exited')
+
+    # Because cleanup functions are run in reverse order, we have to add
+    # our assert-cleanup before the exit stack registers its own cleanup.
+    # This ensures we see state after the stack cleanup runs.
+    self.addCleanup(assert_cm_exited)
+
+    super(EnterContextTest, self).setUp()
+    self.cm_value = self.enter_context(self.cm_for_test())
+
+  @contextlib.contextmanager
+  def cm_for_test(self):
+    try:
+      self.cm_state = 'yielded'
+      yield 'value'
+    finally:
+      self.cm_state = 'exited'
+
+  def test_enter_context(self):
+    self.assertEqual(self.cm_value, 'value')
+    self.assertEqual(self.cm_state, 'yielded')
+
+
 class EqualityAssertionTest(absltest.TestCase):
   """This test verifies that absltest.failIfEqual actually tests __ne__.
 

absl/testing/tests/parameterized_test.py

@@ -677,6 +677,28 @@ class _(parameterized.TestCase):
         def test_mixed_something(self, unused_obj):
           pass
 
+  def test_named_test_with_no_name_fails(self):
+    with self.assertRaises(RuntimeError):
+
+      class _(parameterized.TestCase):
+
+        @parameterized.named_parameters(
+            (0,),
+        )
+        def test_something(self, unused_obj):
+          pass
+
+  def test_named_test_dict_with_no_name_fails(self):
+    with self.assertRaises(RuntimeError):
+
+      class _(parameterized.TestCase):
+
+        @parameterized.named_parameters(
+            {'unused_obj': 0},
+        )
+        def test_something(self, unused_obj):
+          pass
+
   def test_parameterized_test_iter_has_testcases_property(self):
     @parameterized.parameters(1, 2, 3, 4, 5, 6)
     def test_something(unused_self, unused_obj):  # pylint: disable=invalid-name