Add files using upload-large-folder tool

testbed/boto__botocore/.codecov.yml

@@ -0,0 +1,2 @@
+ignore:
+  - "botocore/vendored"

testbed/boto__botocore/.coveragerc

@@ -0,0 +1,10 @@
+[run]
+branch = True
+omit =
+    botocore/vendored/*
+
+[report]
+exclude_lines =
+    raise NotImplementedError.*
+include =
+    botocore/*

testbed/boto__botocore/.git-blame-ignore-revs

@@ -0,0 +1,17 @@
+# You can configure git to automatically use this file with the following config:
+# git config --global blame.ignoreRevsFile .git-blame-ignore-revs
+
+# Reformat using isort
+e34b6a36ae0c1571bcb5fd7034e817d3b397e283
+
+# Add Black and Pyupgrade to botocore directory
+321ed9bb9345f05528e61a9edccb811012f7dc2a
+
+# Cleanup pyupgrade misses
+a2c2fe68a2f9ae259dd1d72b172d41c7c81808cd
+
+# Run Black and PyUpgrade over tests directory
+10747e5e2f2f97a9493b91b5c886bda71678e3be
+
+# Update to black 23
+459a6a370ea1a4ab52b792f3d6e8311bc774b583

testbed/boto__botocore/.gitignore

@@ -0,0 +1,42 @@
+.DS_Store
+*.py[co]
+
+# Packages
+*.egg
+*.egg-info
+dist
+build
+eggs
+parts
+var
+sdist
+develop-eggs
+.installed.cfg
+
+# Installer logs
+pip-log.txt
+
+# Unit test / coverage reports
+.coverage
+.tox
+
+#Translations
+*.mo
+
+#Mr Developer
+.mr.developer.cfg
+
+# Emacs backup files
+*~
+
+# IDEA / PyCharm IDE
+.idea/
+
+# Virtualenvs
+env
+env2
+env3
+
+docs/source/reference/services
+tests/coverage.xml
+tests/nosetests.xml

testbed/boto__botocore/.pre-commit-config.yaml

@@ -0,0 +1,31 @@
+exclude: "\
+    ^(\
+    .github|\
+    .changes|\
+    botocore/data|\
+    botocore/vendored|\
+    botocore/compat.py|\
+    docs/|\
+    tests/functional/endpoint-rules|\
+    tests/unit/auth/aws4_testsuite|\
+    tests/unit/data/endpoints/|\
+    tests/unit/response_parsing/xml|\
+    CHANGELOG.rst\
+    )"
+repos:
+  - repo: 'https://github.com/pre-commit/pre-commit-hooks'
+    rev: v4.5.0
+    hooks:
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+  - repo: 'https://github.com/PyCQA/isort'
+    rev: 5.12.0
+    hooks:
+      - id: isort
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.4.8
+    hooks:
+      - id: ruff
+        args: [ --fix ]
+      - id: ruff-format

testbed/boto__botocore/CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+## Code of Conduct
+This project has adopted the [Amazon Open Source Code of Conduct](https://aws.github.io/code-of-conduct).
+For more information see the [Code of Conduct FAQ](https://aws.github.io/code-of-conduct-faq) or contact
+opensource-codeofconduct@amazon.com with any additional questions or comments.

testbed/boto__botocore/CONTRIBUTING.rst

@@ -0,0 +1,95 @@
+Contributing
+============
+
+We work hard to provide a high-quality and useful SDK, and we greatly value
+feedback and contributions from our community. Whether it's a new feature,
+correction, or additional documentation, we welcome your pull requests. Please
+submit any `issues <https://github.com/boto/botocore/issues>`__
+or `pull requests <https://github.com/boto/botocore/pulls>`__ through GitHub.
+
+This document contains guidelines for contributing code and filing issues.
+
+Contributing Code
+-----------------
+
+The list below are guidelines to use when submitting pull requests.
+These are the same set of guidelines that the core contributors use
+when submitting changes, and we ask the same of all community
+contributions as well:
+
+* The SDK is released under the
+  `Apache license <http://aws.amazon.com/apache2.0/>`__.
+  Any code you submit will be released under that license.
+* We maintain a high percentage of code coverage in our unit tests.  As
+  a general rule of thumb, code changes should not lower the overall
+  code coverage percentage for the project.  To help with this,
+  we use `coveralls <https://coveralls.io/r/boto/botocore>`__, which will
+  comment on changes in code coverage for every pull request.
+  In practice, this means that every bug fix and feature addition should
+  include unit tests.
+* If you identify an issue with the JSON service descriptions,
+  such as ``botocore/data/aws/s3/2006-03-01/service-2.json``, please submit an
+  `issue <https://github.com/boto/botocore/issues>`__ so we can get it
+  fixed upstream.
+* Changes to paginators, waiters, and endpoints are also generated upstream based on our internal knowledge of the AWS services.
+  These include any of the  following files in ``botocore/data/``:
+
+  * ``_endpoints.json``
+  * ``*.paginators-1.json``
+  * ``*.waiters-2.json``
+
+  If you identify an issue with these files, such as a missing paginator or waiter, please submit an
+  `issue <https://github.com/boto/botocore/issues>`__ so we can get it fixed upstream.
+* We do accept, and encourage, changes to the ``botocore/data/_retry.json`` file.
+* Code should follow the guidelines listed in the Codestyle section below.
+* Code must work on all versions of Python supported by Botocore.
+* Botocore is cross platform and code must work on at least linux, Windows,
+  and Mac OS X.
+* If you would like to implement support for a significant feature that is not
+  yet available in botocore, please talk to us beforehand to avoid any duplication
+  of effort.  You can file an
+  `issue <https://github.com/boto/botocore/issues>`__
+  to discuss the feature request further.
+
+Reporting An Issue/Feature
+--------------------------
+
+*  Check to see if there's an existing issue/pull request for the
+   bug/feature. All issues are at
+   https://github.com/boto/botocore/issues and pull reqs are at
+   https://github.com/boto/botocore/pulls.
+*  If there isn't an existing issue there, please file an issue. The
+   ideal report includes:
+
+   * A description of the problem/suggestion.
+   * A code sample that demonstrates the issue.
+   * Including the versions of your:
+
+     * python interpreter
+     * OS
+     * botocore (accessible via ``botocore.__version__``)
+     * optionally any other python dependencies involved
+
+Codestyle
+---------
+This project uses `ruff <https://github.com/astral-sh/ruff>`__ to enforce
+codstyle requirements. We've codified this process using a tool called
+`pre-commit <https://pre-commit.com/>`__. pre-commit allows us to specify a
+config file with all tools required for code linting, and surfaces either a
+git commit hook, or single command, for enforcing these.
+
+To validate your PR prior to publishing, you can use the following
+`installation guide <https://pre-commit.com/#install>`__ to setup pre-commit.
+
+If you don't want to use the git commit hook, you can run the below command
+to automatically perform the codestyle validation:
+
+.. code-block:: bash
+
+    $ pre-commit run
+
+This will automatically perform simple updates (such as white space clean up)
+and provide a list of any failing checks. After these are addressed,
+you can commit the changes prior to publishing the PR.
+These checks are also included in our CI setup under the "Lint" workflow which
+will provide output on Github for anything missed locally.

testbed/boto__botocore/LICENSE.txt

@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS

testbed/boto__botocore/MANIFEST.in

@@ -0,0 +1,11 @@
+include README.rst
+include LICENSE.txt
+include requirements.txt
+include requirements-dev.txt
+include botocore/cacert.pem
+include botocore/vendored/requests/cacert.pem
+recursive-include botocore/data *.json
+recursive-include botocore/data *.json.gz
+graft docs
+prune docs/build
+graft tests

testbed/boto__botocore/NOTICE

@@ -0,0 +1,60 @@
+Botocore
+Copyright 2012-2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+----
+
+Botocore includes vendorized parts of the requests python library for backwards compatibility.
+
+Requests License
+================
+
+Copyright 2013 Kenneth Reitz
+
+   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.
+
+Botocore includes vendorized parts of the urllib3 library for backwards compatibility.
+
+Urllib3 License
+===============
+
+This is the MIT license: http://www.opensource.org/licenses/mit-license.php
+
+Copyright 2008-2011 Andrey Petrov and contributors (see CONTRIBUTORS.txt),
+Modifications copyright 2012 Kenneth Reitz.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+Bundle of CA Root Certificates
+==============================
+
+***** BEGIN LICENSE BLOCK *****
+This Source Code Form is subject to the terms of the
+Mozilla Public License, v. 2.0. If a copy of the MPL
+was not distributed with this file, You can obtain
+one at http://mozilla.org/MPL/2.0/.
+
+***** END LICENSE BLOCK *****

testbed/boto__botocore/README.rst

@@ -0,0 +1,116 @@
+botocore
+========
+
+|Version| |Python| |License|
+
+A low-level interface to a growing number of Amazon Web Services. The
+botocore package is the foundation for the
+`AWS CLI <https://github.com/aws/aws-cli>`__ as well as
+`boto3 <https://github.com/boto/boto3>`__.
+
+Botocore is maintained and published by `Amazon Web Services`_.
+
+Notices
+-------
+
+On 2023-12-13, support was dropped for Python 3.7. This follows the
+Python Software Foundation `end of support <https://www.python.org/dev/peps/pep-0537/#lifespan>`__
+for the runtime which occurred on 2023-06-27.
+For more information, see this `blog post <https://aws.amazon.com/blogs/developer/python-support-policy-updates-for-aws-sdks-and-tools/>`__.
+
+.. _`Amazon Web Services`: https://aws.amazon.com/what-is-aws/
+.. |Python| image:: https://img.shields.io/pypi/pyversions/botocore.svg?style=flat
+    :target: https://pypi.python.org/pypi/botocore/
+    :alt: Python Versions
+.. |Version| image:: http://img.shields.io/pypi/v/botocore.svg?style=flat
+    :target: https://pypi.python.org/pypi/botocore/
+    :alt: Package Version
+.. |License| image:: http://img.shields.io/pypi/l/botocore.svg?style=flat
+    :target: https://github.com/boto/botocore/blob/develop/LICENSE.txt
+    :alt: License
+
+Getting Started
+---------------
+Assuming that you have Python and ``virtualenv`` installed, set up your environment and install the required dependencies like this or you can install the library using ``pip``:
+
+.. code-block:: sh
+
+    $ git clone https://github.com/boto/botocore.git
+    $ cd botocore
+    $ virtualenv venv
+    ...
+    $ . venv/bin/activate
+    $ pip install -r requirements.txt
+    $ pip install -e .
+
+.. code-block:: sh
+
+    $ pip install botocore
+
+Using Botocore
+~~~~~~~~~~~~~~
+After installing botocore
+
+Next, set up credentials (in e.g. ``~/.aws/credentials``):
+
+.. code-block:: ini
+
+    [default]
+    aws_access_key_id = YOUR_KEY
+    aws_secret_access_key = YOUR_SECRET
+
+Then, set up a default region (in e.g. ``~/.aws/config``):
+
+.. code-block:: ini
+
+   [default]
+   region=us-east-1
+
+Other credentials configuration method can be found `here <https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html>`__
+
+Then, from a Python interpreter:
+
+.. code-block:: python
+
+    >>> import botocore.session
+    >>> session = botocore.session.get_session()
+    >>> client = session.create_client('ec2')
+    >>> print(client.describe_instances())
+
+
+Getting Help
+------------
+
+We use GitHub issues for tracking bugs and feature requests and have limited
+bandwidth to address them. Please use these community resources for getting
+help. Please note many of the same resources available for ``boto3`` are
+applicable for ``botocore``:
+
+* Ask a question on `Stack Overflow <https://stackoverflow.com/>`__ and tag it with `boto3 <https://stackoverflow.com/questions/tagged/boto3>`__
+* Open a support ticket with `AWS Support <https://console.aws.amazon.com/support/home#/>`__
+* If it turns out that you may have found a bug, please `open an issue <https://github.com/boto/botocore/issues/new/choose>`__
+
+
+Contributing
+------------
+
+We value feedback and contributions from our community. Whether it's a bug report, new feature, correction, or additional documentation, we welcome your issues and pull requests. Please read through this `CONTRIBUTING <https://github.com/boto/botocore/blob/develop/CONTRIBUTING.rst>`__ document before submitting any issues or pull requests to ensure we have all the necessary information to effectively respond to your contribution.
+
+
+Maintenance and Support for SDK Major Versions
+----------------------------------------------
+
+Botocore was made generally available on 06/22/2015 and is currently in the full support phase of the availability life cycle.
+
+For information about maintenance and support for SDK major versions and their underlying dependencies, see the following in the AWS SDKs and Tools Reference Guide:
+
+* `AWS SDKs and Tools Maintenance Policy <https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html>`__
+* `AWS SDKs and Tools Version Support Matrix <https://docs.aws.amazon.com/sdkref/latest/guide/version-support-matrix.html>`__
+
+
+More Resources
+--------------
+
+* `NOTICE <https://github.com/boto/botocore/blob/develop/NOTICE>`__
+* `Changelog <https://github.com/boto/botocore/blob/develop/CHANGELOG.rst>`__
+* `License <https://github.com/boto/botocore/blob/develop/LICENSE.txt>`__

testbed/boto__botocore/pyproject.toml

@@ -0,0 +1,72 @@
+[tool.pytest.ini_options]
+markers = [
+    "slow: marks tests as slow",
+    "validates_models: marks tests as one which validates service models",
+]
+
+[tool.isort]
+profile = "black"
+line_length = 79
+honor_noqa = true
+src_paths = ["botocore", "tests"]
+
+[tool.ruff]
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".git-rewrite",
+    ".hg",
+    ".ipynb_checkpoints",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".pyenv",
+    ".pytest_cache",
+    ".pytype",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    ".vscode",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "site-packages",
+    "venv",
+]
+
+# Format same as Black.
+line-length = 79
+indent-width = 4
+
+target-version = "py38"
+
+[tool.ruff.lint]
+# Enable Pyflakes (`F`) and a subset of the pycodestyle (`E`)  codes by default.
+# Unlike Flake8, Ruff doesn't enable pycodestyle warnings (`W`) or
+# McCabe complexity (`C901`) by default.
+select = ["E4", "E7", "E9", "F", "UP"]
+ignore = []
+
+# Allow fix for all enabled rules (when `--fix`) is provided.
+fixable = ["ALL"]
+unfixable = []
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+[tool.ruff.format]
+# Like Black, use double quotes for strings, spaces for indents
+# and trailing commas.
+quote-style = "preserve"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+docstring-code-format = false
+docstring-code-line-length = "dynamic"

testbed/boto__botocore/requirements-dev-lock.txt

@@ -0,0 +1,285 @@
+#
+# This file is autogenerated by pip-compile with Python 3.8
+# by the following command:
+#
+#    pip-compile --allow-unsafe --generate-hashes --output-file=requirements-dev-lock.txt requirements-dev.txt
+#
+atomicwrites==1.4.1 \
+    --hash=sha256:81b2c9071a49367a7f770170e5eec8cb66567cfbbc8c73d20ce5ca4a8d71cf11
+    # via -r requirements-dev.txt
+attrs==23.2.0 \
+    --hash=sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30 \
+    --hash=sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1
+    # via
+    #   jsonschema
+    #   referencing
+behave==1.2.5 \
+    --hash=sha256:07c741f30497b6f9361a9bc74c68418507cd17e70d6f586faa3bff57684a2ec8 \
+    --hash=sha256:81b731ac5187e31e4aad2594944fa914943683a9818320846d037c5ebd6d5d0b \
+    --hash=sha256:89238a5e4b11ff607e8ebc6b4b1fb1a0b1f3d794fba80e1fb4b6b3652979c927 \
+    --hash=sha256:8c182feece4a519c5ffc11e1ab3682d25d5a390dd5f4573bb1296443beb9d7c7
+    # via -r requirements-dev.txt
+colorama==0.4.6 \
+    --hash=sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44 \
+    --hash=sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6
+    # via -r requirements-dev.txt
+coverage[toml]==7.2.7 \
+    --hash=sha256:06a9a2be0b5b576c3f18f1a241f0473575c4a26021b52b2a85263a00f034d51f \
+    --hash=sha256:06fb182e69f33f6cd1d39a6c597294cff3143554b64b9825d1dc69d18cc2fff2 \
+    --hash=sha256:0a5f9e1dbd7fbe30196578ca36f3fba75376fb99888c395c5880b355e2875f8a \
+    --hash=sha256:0e1f928eaf5469c11e886fe0885ad2bf1ec606434e79842a879277895a50942a \
+    --hash=sha256:171717c7cb6b453aebac9a2ef603699da237f341b38eebfee9be75d27dc38e01 \
+    --hash=sha256:1e9d683426464e4a252bf70c3498756055016f99ddaec3774bf368e76bbe02b6 \
+    --hash=sha256:201e7389591af40950a6480bd9edfa8ed04346ff80002cec1a66cac4549c1ad7 \
+    --hash=sha256:245167dd26180ab4c91d5e1496a30be4cd721a5cf2abf52974f965f10f11419f \
+    --hash=sha256:2aee274c46590717f38ae5e4650988d1af340fe06167546cc32fe2f58ed05b02 \
+    --hash=sha256:2e07b54284e381531c87f785f613b833569c14ecacdcb85d56b25c4622c16c3c \
+    --hash=sha256:31563e97dae5598556600466ad9beea39fb04e0229e61c12eaa206e0aa202063 \
+    --hash=sha256:33d6d3ea29d5b3a1a632b3c4e4f4ecae24ef170b0b9ee493883f2df10039959a \
+    --hash=sha256:3d376df58cc111dc8e21e3b6e24606b5bb5dee6024f46a5abca99124b2229ef5 \
+    --hash=sha256:419bfd2caae268623dd469eff96d510a920c90928b60f2073d79f8fe2bbc5959 \
+    --hash=sha256:48c19d2159d433ccc99e729ceae7d5293fbffa0bdb94952d3579983d1c8c9d97 \
+    --hash=sha256:49969a9f7ffa086d973d91cec8d2e31080436ef0fb4a359cae927e742abfaaa6 \
+    --hash=sha256:52edc1a60c0d34afa421c9c37078817b2e67a392cab17d97283b64c5833f427f \
+    --hash=sha256:537891ae8ce59ef63d0123f7ac9e2ae0fc8b72c7ccbe5296fec45fd68967b6c9 \
+    --hash=sha256:54b896376ab563bd38453cecb813c295cf347cf5906e8b41d340b0321a5433e5 \
+    --hash=sha256:58c2ccc2f00ecb51253cbe5d8d7122a34590fac9646a960d1430d5b15321d95f \
+    --hash=sha256:5b7540161790b2f28143191f5f8ec02fb132660ff175b7747b95dcb77ac26562 \
+    --hash=sha256:5baa06420f837184130752b7c5ea0808762083bf3487b5038d68b012e5937dbe \
+    --hash=sha256:5e330fc79bd7207e46c7d7fd2bb4af2963f5f635703925543a70b99574b0fea9 \
+    --hash=sha256:61b9a528fb348373c433e8966535074b802c7a5d7f23c4f421e6c6e2f1697a6f \
+    --hash=sha256:63426706118b7f5cf6bb6c895dc215d8a418d5952544042c8a2d9fe87fcf09cb \
+    --hash=sha256:6d040ef7c9859bb11dfeb056ff5b3872436e3b5e401817d87a31e1750b9ae2fb \
+    --hash=sha256:6f48351d66575f535669306aa7d6d6f71bc43372473b54a832222803eb956fd1 \
+    --hash=sha256:7ee7d9d4822c8acc74a5e26c50604dff824710bc8de424904c0982e25c39c6cb \
+    --hash=sha256:81c13a1fc7468c40f13420732805a4c38a105d89848b7c10af65a90beff25250 \
+    --hash=sha256:8d13c64ee2d33eccf7437961b6ea7ad8673e2be040b4f7fd4fd4d4d28d9ccb1e \
+    --hash=sha256:8de8bb0e5ad103888d65abef8bca41ab93721647590a3f740100cd65c3b00511 \
+    --hash=sha256:8fa03bce9bfbeeef9f3b160a8bed39a221d82308b4152b27d82d8daa7041fee5 \
+    --hash=sha256:924d94291ca674905fe9481f12294eb11f2d3d3fd1adb20314ba89e94f44ed59 \
+    --hash=sha256:975d70ab7e3c80a3fe86001d8751f6778905ec723f5b110aed1e450da9d4b7f2 \
+    --hash=sha256:976b9c42fb2a43ebf304fa7d4a310e5f16cc99992f33eced91ef6f908bd8f33d \
+    --hash=sha256:9e31cb64d7de6b6f09702bb27c02d1904b3aebfca610c12772452c4e6c21a0d3 \
+    --hash=sha256:a342242fe22407f3c17f4b499276a02b01e80f861f1682ad1d95b04018e0c0d4 \
+    --hash=sha256:a3d33a6b3eae87ceaefa91ffdc130b5e8536182cd6dfdbfc1aa56b46ff8c86de \
+    --hash=sha256:a895fcc7b15c3fc72beb43cdcbdf0ddb7d2ebc959edac9cef390b0d14f39f8a9 \
+    --hash=sha256:afb17f84d56068a7c29f5fa37bfd38d5aba69e3304af08ee94da8ed5b0865833 \
+    --hash=sha256:b1c546aca0ca4d028901d825015dc8e4d56aac4b541877690eb76490f1dc8ed0 \
+    --hash=sha256:b29019c76039dc3c0fd815c41392a044ce555d9bcdd38b0fb60fb4cd8e475ba9 \
+    --hash=sha256:b46517c02ccd08092f4fa99f24c3b83d8f92f739b4657b0f146246a0ca6a831d \
+    --hash=sha256:b7aa5f8a41217360e600da646004f878250a0d6738bcdc11a0a39928d7dc2050 \
+    --hash=sha256:b7b4c971f05e6ae490fef852c218b0e79d4e52f79ef0c8475566584a8fb3e01d \
+    --hash=sha256:ba90a9563ba44a72fda2e85302c3abc71c5589cea608ca16c22b9804262aaeb6 \
+    --hash=sha256:cb017fd1b2603ef59e374ba2063f593abe0fc45f2ad9abdde5b4d83bd922a353 \
+    --hash=sha256:d22656368f0e6189e24722214ed8d66b8022db19d182927b9a248a2a8a2f67eb \
+    --hash=sha256:d2c2db7fd82e9b72937969bceac4d6ca89660db0a0967614ce2481e81a0b771e \
+    --hash=sha256:d39b5b4f2a66ccae8b7263ac3c8170994b65266797fb96cbbfd3fb5b23921db8 \
+    --hash=sha256:d62a5c7dad11015c66fbb9d881bc4caa5b12f16292f857842d9d1871595f4495 \
+    --hash=sha256:e7d9405291c6928619403db1d10bd07888888ec1abcbd9748fdaa971d7d661b2 \
+    --hash=sha256:e84606b74eb7de6ff581a7915e2dab7a28a0517fbe1c9239eb227e1354064dcd \
+    --hash=sha256:eb393e5ebc85245347950143969b241d08b52b88a3dc39479822e073a1a8eb27 \
+    --hash=sha256:ebba1cd308ef115925421d3e6a586e655ca5a77b5bf41e02eb0e4562a111f2d1 \
+    --hash=sha256:ee57190f24fba796e36bb6d3aa8a8783c643d8fa9760c89f7a98ab5455fbf818 \
+    --hash=sha256:f2f67fe12b22cd130d34d0ef79206061bfb5eda52feb6ce0dba0644e20a03cf4 \
+    --hash=sha256:f6951407391b639504e3b3be51b7ba5f3528adbf1a8ac3302b687ecababf929e \
+    --hash=sha256:f75f7168ab25dd93110c8a8117a22450c19976afbc44234cbf71481094c1b850 \
+    --hash=sha256:fdec9e8cbf13a5bf63290fc6013d216a4c7232efb51548594ca3631a7f13c3a3
+    # via
+    #   -r requirements-dev.txt
+    #   pytest-cov
+exceptiongroup==1.2.2 \
+    --hash=sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b \
+    --hash=sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc
+    # via pytest
+execnet==2.1.1 \
+    --hash=sha256:26dee51f1b80cebd6d0ca8e74dd8745419761d3bef34163928cbebbdc4749fdc \
+    --hash=sha256:5189b52c6121c24feae288166ab41b32549c7e2348652736540b9e6e7d4e72e3
+    # via pytest-xdist
+importlib-resources==6.4.0 \
+    --hash=sha256:50d10f043df931902d4194ea07ec57960f66a80449ff867bfe782b4c486ba78c \
+    --hash=sha256:cdb2b453b8046ca4e3798eb1d84f3cce1446a0e8e7b5ef4efb600f19fc398145
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+iniconfig==2.0.0 \
+    --hash=sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3 \
+    --hash=sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374
+    # via pytest
+jsonschema==4.21.1 \
+    --hash=sha256:7996507afae316306f9e2290407761157c6f78002dcf7419acb99822143d1c6f \
+    --hash=sha256:85727c00279f5fa6bedbe6238d2aa6403bedd8b4864ab11207d07df3cc1b2ee5
+    # via -r requirements-dev.txt
+jsonschema-specifications==2023.12.1 \
+    --hash=sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc \
+    --hash=sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c
+    # via jsonschema
+packaging==24.1 \
+    --hash=sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002 \
+    --hash=sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124
+    # via pytest
+parse==1.20.2 \
+    --hash=sha256:967095588cb802add9177d0c0b6133b5ba33b1ea9007ca800e526f42a85af558 \
+    --hash=sha256:b41d604d16503c79d81af5165155c0b20f6c8d6c559efa66b4b695c3e5a0a0ce
+    # via
+    #   behave
+    #   parse-type
+parse-type==0.6.2 \
+    --hash=sha256:06d39a8b70fde873eb2a131141a0e79bb34a432941fb3d66fad247abafc9766c \
+    --hash=sha256:79b1f2497060d0928bc46016793f1fca1057c4aacdf15ef876aa48d75a73a355
+    # via behave
+pkgutil-resolve-name==1.3.10 \
+    --hash=sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174 \
+    --hash=sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e
+    # via jsonschema
+pluggy==1.5.0 \
+    --hash=sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1 \
+    --hash=sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669
+    # via pytest
+pytest==8.1.1 \
+    --hash=sha256:2a8386cfc11fa9d2c50ee7b2a57e7d898ef90470a7a34c4b949ff59662bb78b7 \
+    --hash=sha256:ac978141a75948948817d360297b7aae0fcb9d6ff6bc9ec6d514b85d5a65c044
+    # via
+    #   -r requirements-dev.txt
+    #   pytest-cov
+    #   pytest-xdist
+pytest-cov==5.0.0 \
+    --hash=sha256:4f0764a1219df53214206bf1feea4633c3b558a2925c8b59f144f682861ce652 \
+    --hash=sha256:5837b58e9f6ebd335b0f8060eecce69b662415b16dc503883a02f45dfeb14857
+    # via -r requirements-dev.txt
+pytest-xdist==3.5.0 \
+    --hash=sha256:cbb36f3d67e0c478baa57fa4edc8843887e0f6cfc42d677530a36d7472b32d8a \
+    --hash=sha256:d075629c7e00b611df89f490a5063944bee7a4362a5ff11c7cc7824a03dfce24
+    # via -r requirements-dev.txt
+referencing==0.35.1 \
+    --hash=sha256:25b42124a6c8b632a425174f24087783efb348a6f1e0008e63cd4466fedf703c \
+    --hash=sha256:eda6d3234d62814d1c64e305c1331c9a3a6132da475ab6382eaa997b21ee75de
+    # via
+    #   jsonschema
+    #   jsonschema-specifications
+rpds-py==0.19.1 \
+    --hash=sha256:01227f8b3e6c8961490d869aa65c99653df80d2f0a7fde8c64ebddab2b9b02fd \
+    --hash=sha256:08ce9c95a0b093b7aec75676b356a27879901488abc27e9d029273d280438505 \
+    --hash=sha256:0b02dd77a2de6e49078c8937aadabe933ceac04b41c5dde5eca13a69f3cf144e \
+    --hash=sha256:0d4b52811dcbc1aba08fd88d475f75b4f6db0984ba12275d9bed1a04b2cae9b5 \
+    --hash=sha256:13e6d4840897d4e4e6b2aa1443e3a8eca92b0402182aafc5f4ca1f5e24f9270a \
+    --hash=sha256:1a129c02b42d46758c87faeea21a9f574e1c858b9f358b6dd0bbd71d17713175 \
+    --hash=sha256:1a8dfa125b60ec00c7c9baef945bb04abf8ac772d8ebefd79dae2a5f316d7850 \
+    --hash=sha256:1c32e41de995f39b6b315d66c27dea3ef7f7c937c06caab4c6a79a5e09e2c415 \
+    --hash=sha256:1d494887d40dc4dd0d5a71e9d07324e5c09c4383d93942d391727e7a40ff810b \
+    --hash=sha256:1d4af2eb520d759f48f1073ad3caef997d1bfd910dc34e41261a595d3f038a94 \
+    --hash=sha256:1fb93d3486f793d54a094e2bfd9cd97031f63fcb5bc18faeb3dd4b49a1c06523 \
+    --hash=sha256:24f8ae92c7fae7c28d0fae9b52829235df83f34847aa8160a47eb229d9666c7b \
+    --hash=sha256:24fc5a84777cb61692d17988989690d6f34f7f95968ac81398d67c0d0994a897 \
+    --hash=sha256:26ab43b6d65d25b1a333c8d1b1c2f8399385ff683a35ab5e274ba7b8bb7dc61c \
+    --hash=sha256:271accf41b02687cef26367c775ab220372ee0f4925591c6796e7c148c50cab5 \
+    --hash=sha256:2ddd50f18ebc05ec29a0d9271e9dbe93997536da3546677f8ca00b76d477680c \
+    --hash=sha256:31dd5794837f00b46f4096aa8ccaa5972f73a938982e32ed817bb520c465e520 \
+    --hash=sha256:31e450840f2f27699d014cfc8865cc747184286b26d945bcea6042bb6aa4d26e \
+    --hash=sha256:32e0db3d6e4f45601b58e4ac75c6f24afbf99818c647cc2066f3e4b192dabb1f \
+    --hash=sha256:346557f5b1d8fd9966059b7a748fd79ac59f5752cd0e9498d6a40e3ac1c1875f \
+    --hash=sha256:34bca66e2e3eabc8a19e9afe0d3e77789733c702c7c43cd008e953d5d1463fde \
+    --hash=sha256:3511f6baf8438326e351097cecd137eb45c5f019944fe0fd0ae2fea2fd26be39 \
+    --hash=sha256:35af5e4d5448fa179fd7fff0bba0fba51f876cd55212f96c8bbcecc5c684ae5c \
+    --hash=sha256:3837c63dd6918a24de6c526277910e3766d8c2b1627c500b155f3eecad8fad65 \
+    --hash=sha256:39d67896f7235b2c886fb1ee77b1491b77049dcef6fbf0f401e7b4cbed86bbd4 \
+    --hash=sha256:3b823be829407393d84ee56dc849dbe3b31b6a326f388e171555b262e8456cc1 \
+    --hash=sha256:3c73254c256081704dba0a333457e2fb815364018788f9b501efe7c5e0ada401 \
+    --hash=sha256:3ddab996807c6b4227967fe1587febade4e48ac47bb0e2d3e7858bc621b1cace \
+    --hash=sha256:3e1dc59a5e7bc7f44bd0c048681f5e05356e479c50be4f2c1a7089103f1621d5 \
+    --hash=sha256:4383beb4a29935b8fa28aca8fa84c956bf545cb0c46307b091b8d312a9150e6a \
+    --hash=sha256:4cc4bc73e53af8e7a42c8fd7923bbe35babacfa7394ae9240b3430b5dcf16b2a \
+    --hash=sha256:4dd02e29c8cbed21a1875330b07246b71121a1c08e29f0ee3db5b4cfe16980c4 \
+    --hash=sha256:4f580ae79d0b861dfd912494ab9d477bea535bfb4756a2269130b6607a21802e \
+    --hash=sha256:53dbc35808c6faa2ce3e48571f8f74ef70802218554884787b86a30947842a14 \
+    --hash=sha256:56313be667a837ff1ea3508cebb1ef6681d418fa2913a0635386cf29cff35165 \
+    --hash=sha256:57863d16187995c10fe9cf911b897ed443ac68189179541734502353af33e693 \
+    --hash=sha256:5953391af1405f968eb5701ebbb577ebc5ced8d0041406f9052638bafe52209d \
+    --hash=sha256:5beffdbe766cfe4fb04f30644d822a1080b5359df7db3a63d30fa928375b2720 \
+    --hash=sha256:5e360188b72f8080fefa3adfdcf3618604cc8173651c9754f189fece068d2a45 \
+    --hash=sha256:5e58b61dcbb483a442c6239c3836696b79f2cd8e7eec11e12155d3f6f2d886d1 \
+    --hash=sha256:69084fd29bfeff14816666c93a466e85414fe6b7d236cfc108a9c11afa6f7301 \
+    --hash=sha256:6d1d7539043b2b31307f2c6c72957a97c839a88b2629a348ebabe5aa8b626d6b \
+    --hash=sha256:6d8b735c4d162dc7d86a9cf3d717f14b6c73637a1f9cd57fe7e61002d9cb1972 \
+    --hash=sha256:6ea961a674172ed2235d990d7edf85d15d8dfa23ab8575e48306371c070cda67 \
+    --hash=sha256:71157f9db7f6bc6599a852852f3389343bea34315b4e6f109e5cbc97c1fb2963 \
+    --hash=sha256:720f3108fb1bfa32e51db58b832898372eb5891e8472a8093008010911e324c5 \
+    --hash=sha256:74129d5ffc4cde992d89d345f7f7d6758320e5d44a369d74d83493429dad2de5 \
+    --hash=sha256:747251e428406b05fc86fee3904ee19550c4d2d19258cef274e2151f31ae9d38 \
+    --hash=sha256:75130df05aae7a7ac171b3b5b24714cffeabd054ad2ebc18870b3aa4526eba23 \
+    --hash=sha256:7b3661e6d4ba63a094138032c1356d557de5b3ea6fd3cca62a195f623e381c76 \
+    --hash=sha256:7d5c7e32f3ee42f77d8ff1a10384b5cdcc2d37035e2e3320ded909aa192d32c3 \
+    --hash=sha256:8124101e92c56827bebef084ff106e8ea11c743256149a95b9fd860d3a4f331f \
+    --hash=sha256:81db2e7282cc0487f500d4db203edc57da81acde9e35f061d69ed983228ffe3b \
+    --hash=sha256:840e18c38098221ea6201f091fc5d4de6128961d2930fbbc96806fb43f69aec1 \
+    --hash=sha256:89cc8921a4a5028d6dd388c399fcd2eef232e7040345af3d5b16c04b91cf3c7e \
+    --hash=sha256:8b32cd4ab6db50c875001ba4f5a6b30c0f42151aa1fbf9c2e7e3674893fb1dc4 \
+    --hash=sha256:8df1c283e57c9cb4d271fdc1875f4a58a143a2d1698eb0d6b7c0d7d5f49c53a1 \
+    --hash=sha256:902cf4739458852fe917104365ec0efbea7d29a15e4276c96a8d33e6ed8ec137 \
+    --hash=sha256:97fbb77eaeb97591efdc654b8b5f3ccc066406ccfb3175b41382f221ecc216e8 \
+    --hash=sha256:9c7042488165f7251dc7894cd533a875d2875af6d3b0e09eda9c4b334627ad1c \
+    --hash=sha256:9e318e6786b1e750a62f90c6f7fa8b542102bdcf97c7c4de2a48b50b61bd36ec \
+    --hash=sha256:a9421b23c85f361a133aa7c5e8ec757668f70343f4ed8fdb5a4a14abd5437244 \
+    --hash=sha256:aaf71f95b21f9dc708123335df22e5a2fef6307e3e6f9ed773b2e0938cc4d491 \
+    --hash=sha256:afedc35fe4b9e30ab240b208bb9dc8938cb4afe9187589e8d8d085e1aacb8309 \
+    --hash=sha256:b5e28e56143750808c1c79c70a16519e9bc0a68b623197b96292b21b62d6055c \
+    --hash=sha256:b82c9514c6d74b89a370c4060bdb80d2299bc6857e462e4a215b4ef7aa7b090e \
+    --hash=sha256:b8f78398e67a7227aefa95f876481485403eb974b29e9dc38b307bb6eb2315ea \
+    --hash=sha256:bbda75f245caecff8faa7e32ee94dfaa8312a3367397975527f29654cd17a6ed \
+    --hash=sha256:bca34e913d27401bda2a6f390d0614049f5a95b3b11cd8eff80fe4ec340a1208 \
+    --hash=sha256:bd04d8cab16cab5b0a9ffc7d10f0779cf1120ab16c3925404428f74a0a43205a \
+    --hash=sha256:c149a652aeac4902ecff2dd93c3b2681c608bd5208c793c4a99404b3e1afc87c \
+    --hash=sha256:c2087dbb76a87ec2c619253e021e4fb20d1a72580feeaa6892b0b3d955175a71 \
+    --hash=sha256:c34f751bf67cab69638564eee34023909380ba3e0d8ee7f6fe473079bf93f09b \
+    --hash=sha256:c6d20c8896c00775e6f62d8373aba32956aa0b850d02b5ec493f486c88e12859 \
+    --hash=sha256:c7af6f7b80f687b33a4cdb0a785a5d4de1fb027a44c9a049d8eb67d5bfe8a687 \
+    --hash=sha256:c7b07959866a6afb019abb9564d8a55046feb7a84506c74a6f197cbcdf8a208e \
+    --hash=sha256:ca0dda0c5715efe2ab35bb83f813f681ebcd2840d8b1b92bfc6fe3ab382fae4a \
+    --hash=sha256:cdb7eb3cf3deb3dd9e7b8749323b5d970052711f9e1e9f36364163627f96da58 \
+    --hash=sha256:ce757c7c90d35719b38fa3d4ca55654a76a40716ee299b0865f2de21c146801c \
+    --hash=sha256:d1fa67ef839bad3815124f5f57e48cd50ff392f4911a9f3cf449d66fa3df62a5 \
+    --hash=sha256:d2dbd8f4990d4788cb122f63bf000357533f34860d269c1a8e90ae362090ff3a \
+    --hash=sha256:d4ec0046facab83012d821b33cead742a35b54575c4edfb7ed7445f63441835f \
+    --hash=sha256:dbceedcf4a9329cc665452db1aaf0845b85c666e4885b92ee0cddb1dbf7e052a \
+    --hash=sha256:dc733d35f861f8d78abfaf54035461e10423422999b360966bf1c443cbc42705 \
+    --hash=sha256:dd635c2c4043222d80d80ca1ac4530a633102a9f2ad12252183bcf338c1b9474 \
+    --hash=sha256:de1f7cd5b6b351e1afd7568bdab94934d656abe273d66cda0ceea43bbc02a0c2 \
+    --hash=sha256:df7c841813f6265e636fe548a49664c77af31ddfa0085515326342a751a6ba51 \
+    --hash=sha256:e0f9d268b19e8f61bf42a1da48276bcd05f7ab5560311f541d22557f8227b866 \
+    --hash=sha256:e2d66eb41ffca6cc3c91d8387509d27ba73ad28371ef90255c50cb51f8953301 \
+    --hash=sha256:e429fc517a1c5e2a70d576077231538a98d59a45dfc552d1ac45a132844e6dfb \
+    --hash=sha256:e4d2b88efe65544a7d5121b0c3b003ebba92bfede2ea3577ce548b69c5235185 \
+    --hash=sha256:e76c902d229a3aa9d5ceb813e1cbcc69bf5bda44c80d574ff1ac1fa3136dea71 \
+    --hash=sha256:ef07a0a1d254eeb16455d839cef6e8c2ed127f47f014bbda64a58b5482b6c836 \
+    --hash=sha256:f09529d2332264a902688031a83c19de8fda5eb5881e44233286b9c9ec91856d \
+    --hash=sha256:f0a6d4a93d2a05daec7cb885157c97bbb0be4da739d6f9dfb02e101eb40921cd \
+    --hash=sha256:f0cf2a0dbb5987da4bd92a7ca727eadb225581dd9681365beba9accbe5308f7d \
+    --hash=sha256:f2671cb47e50a97f419a02cd1e0c339b31de017b033186358db92f4d8e2e17d8 \
+    --hash=sha256:f35b34a5184d5e0cc360b61664c1c06e866aab077b5a7c538a3e20c8fcdbf90b \
+    --hash=sha256:f3d73022990ab0c8b172cce57c69fd9a89c24fd473a5e79cbce92df87e3d9c48 \
+    --hash=sha256:f5b8353ea1a4d7dfb59a7f45c04df66ecfd363bb5b35f33b11ea579111d4655f \
+    --hash=sha256:f809a17cc78bd331e137caa25262b507225854073fd319e987bd216bed911b7c \
+    --hash=sha256:f9bc4161bd3b970cd6a6fcda70583ad4afd10f2750609fb1f3ca9505050d4ef3 \
+    --hash=sha256:fdf4890cda3b59170009d012fca3294c00140e7f2abe1910e6a730809d0f3f9b
+    # via
+    #   jsonschema
+    #   referencing
+six==1.16.0 \
+    --hash=sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926 \
+    --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254
+    # via
+    #   behave
+    #   parse-type
+tomli==2.0.1 \
+    --hash=sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc \
+    --hash=sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f
+    # via
+    #   coverage
+    #   pytest
+wheel==0.43.0 \
+    --hash=sha256:465ef92c69fa5c5da2d1cf8ac40559a8c940886afcef87dcf14b9470862f1d85 \
+    --hash=sha256:55c570405f142630c6b9f72fe09d9b67cf1477fcf543ae5b8dcb1f5b7377da81
+    # via -r requirements-dev.txt
+zipp==3.19.2 \
+    --hash=sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19 \
+    --hash=sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c
+    # via importlib-resources

testbed/boto__botocore/requirements-dev.txt

@@ -0,0 +1,13 @@
+wheel==0.43.0
+behave==1.2.5
+jsonschema==4.21.1
+coverage==7.2.7
+setuptools==71.1.0;python_version>="3.12"
+packaging==24.1;python_version>="3.12"  # Requirement for setuptools>=71
+
+# Pytest specific deps
+pytest==8.1.1
+pytest-cov==5.0.0
+pytest-xdist==3.5.0
+atomicwrites>=1.0 # Windows requirement
+colorama>0.3.0 # Windows requirement

testbed/boto__botocore/requirements-docs-lock.txt

@@ -0,0 +1,281 @@
+#
+# This file is autogenerated by pip-compile with Python 3.8
+# by the following command:
+#
+#    pip-compile --allow-unsafe --generate-hashes --output-file=requirements-docs-lock.txt requirements-docs.txt
+#
+alabaster==0.7.13 \
+    --hash=sha256:1ee19aca801bbabb5ba3f5f258e4422dfa86f82f3e9cefb0859b283cdd7f62a3 \
+    --hash=sha256:a27a4a084d5e690e16e01e03ad2b2e552c61a65469419b907243193de1a84ae2
+    # via sphinx
+babel==2.15.0 \
+    --hash=sha256:08706bdad8d0a3413266ab61bd6c34d0c28d6e1e7badf40a2cebe67644e2e1fb \
+    --hash=sha256:8daf0e265d05768bc6c7a314cf1321e9a123afc328cc635c18622a2f30a04413
+    # via sphinx
+beautifulsoup4==4.12.3 \
+    --hash=sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051 \
+    --hash=sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed
+    # via furo
+certifi==2024.7.4 \
+    --hash=sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b \
+    --hash=sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90
+    # via requests
+charset-normalizer==3.3.2 \
+    --hash=sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027 \
+    --hash=sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087 \
+    --hash=sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786 \
+    --hash=sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8 \
+    --hash=sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09 \
+    --hash=sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185 \
+    --hash=sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574 \
+    --hash=sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e \
+    --hash=sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519 \
+    --hash=sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898 \
+    --hash=sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269 \
+    --hash=sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3 \
+    --hash=sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f \
+    --hash=sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6 \
+    --hash=sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8 \
+    --hash=sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a \
+    --hash=sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73 \
+    --hash=sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc \
+    --hash=sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714 \
+    --hash=sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2 \
+    --hash=sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc \
+    --hash=sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce \
+    --hash=sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d \
+    --hash=sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e \
+    --hash=sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6 \
+    --hash=sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269 \
+    --hash=sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96 \
+    --hash=sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d \
+    --hash=sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a \
+    --hash=sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4 \
+    --hash=sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77 \
+    --hash=sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d \
+    --hash=sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0 \
+    --hash=sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed \
+    --hash=sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068 \
+    --hash=sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac \
+    --hash=sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25 \
+    --hash=sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8 \
+    --hash=sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab \
+    --hash=sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26 \
+    --hash=sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2 \
+    --hash=sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db \
+    --hash=sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f \
+    --hash=sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5 \
+    --hash=sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99 \
+    --hash=sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c \
+    --hash=sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d \
+    --hash=sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811 \
+    --hash=sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa \
+    --hash=sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a \
+    --hash=sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03 \
+    --hash=sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b \
+    --hash=sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04 \
+    --hash=sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c \
+    --hash=sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001 \
+    --hash=sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458 \
+    --hash=sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389 \
+    --hash=sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99 \
+    --hash=sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985 \
+    --hash=sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537 \
+    --hash=sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238 \
+    --hash=sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f \
+    --hash=sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d \
+    --hash=sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796 \
+    --hash=sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a \
+    --hash=sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143 \
+    --hash=sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8 \
+    --hash=sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c \
+    --hash=sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5 \
+    --hash=sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5 \
+    --hash=sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711 \
+    --hash=sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4 \
+    --hash=sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6 \
+    --hash=sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c \
+    --hash=sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7 \
+    --hash=sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4 \
+    --hash=sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b \
+    --hash=sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae \
+    --hash=sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12 \
+    --hash=sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c \
+    --hash=sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae \
+    --hash=sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8 \
+    --hash=sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887 \
+    --hash=sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b \
+    --hash=sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4 \
+    --hash=sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f \
+    --hash=sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5 \
+    --hash=sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33 \
+    --hash=sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519 \
+    --hash=sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561
+    # via requests
+docutils==0.19 \
+    --hash=sha256:33995a6753c30b7f577febfc2c50411fec6aac7f7ffeb7c4cfe5991072dcf9e6 \
+    --hash=sha256:5e1de4d849fee02c63b040a4a3fd567f4ab104defd8a5511fbbc24a8a017efbc
+    # via sphinx
+furo==2022.12.7 \
+    --hash=sha256:7cb76c12a25ef65db85ab0743df907573d03027a33631f17d267e598ebb191f7 \
+    --hash=sha256:d8008f8efbe7587a97ba533c8b2df1f9c21ee9b3e5cad0d27f61193d38b1a986
+    # via -r requirements-docs.txt
+idna==3.7 \
+    --hash=sha256:028ff3aadf0609c1fd278d8ea3089299412a7a8b9bd005dd08b9f8285bcb5cfc \
+    --hash=sha256:82fee1fc78add43492d3a1898bfa6d8a904cc97d8427f683ed8e798d07761aa0
+    # via requests
+imagesize==1.4.1 \
+    --hash=sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b \
+    --hash=sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a
+    # via sphinx
+importlib-metadata==8.0.0 \
+    --hash=sha256:15584cf2b1bf449d98ff8a6ff1abef57bf20f3ac6454f431736cd3e660921b2f \
+    --hash=sha256:188bd24e4c346d3f0a933f275c2fec67050326a856b9a359881d7c2a697e8812
+    # via sphinx
+jinja2==3.1.4 \
+    --hash=sha256:4a3aee7acbbe7303aede8e9648d13b8bf88a429282aa6122a993f0ac800cb369 \
+    --hash=sha256:bc5dd2abb727a5319567b7a813e6a2e7318c39f4f487cfe6c89c6f9c7d25197d
+    # via sphinx
+markupsafe==2.1.5 \
+    --hash=sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf \
+    --hash=sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff \
+    --hash=sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f \
+    --hash=sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3 \
+    --hash=sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532 \
+    --hash=sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f \
+    --hash=sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617 \
+    --hash=sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df \
+    --hash=sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4 \
+    --hash=sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906 \
+    --hash=sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f \
+    --hash=sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4 \
+    --hash=sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8 \
+    --hash=sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371 \
+    --hash=sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2 \
+    --hash=sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465 \
+    --hash=sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52 \
+    --hash=sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6 \
+    --hash=sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169 \
+    --hash=sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad \
+    --hash=sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2 \
+    --hash=sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0 \
+    --hash=sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029 \
+    --hash=sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f \
+    --hash=sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a \
+    --hash=sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced \
+    --hash=sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5 \
+    --hash=sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c \
+    --hash=sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf \
+    --hash=sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9 \
+    --hash=sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb \
+    --hash=sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad \
+    --hash=sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3 \
+    --hash=sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1 \
+    --hash=sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46 \
+    --hash=sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc \
+    --hash=sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a \
+    --hash=sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee \
+    --hash=sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900 \
+    --hash=sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5 \
+    --hash=sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea \
+    --hash=sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f \
+    --hash=sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5 \
+    --hash=sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e \
+    --hash=sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a \
+    --hash=sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f \
+    --hash=sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50 \
+    --hash=sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a \
+    --hash=sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b \
+    --hash=sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4 \
+    --hash=sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff \
+    --hash=sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2 \
+    --hash=sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46 \
+    --hash=sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b \
+    --hash=sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf \
+    --hash=sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5 \
+    --hash=sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5 \
+    --hash=sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab \
+    --hash=sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd \
+    --hash=sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68
+    # via jinja2
+packaging==24.1 \
+    --hash=sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002 \
+    --hash=sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124
+    # via sphinx
+pygments==2.18.0 \
+    --hash=sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199 \
+    --hash=sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a
+    # via
+    #   furo
+    #   sphinx
+pytz==2024.1 \
+    --hash=sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812 \
+    --hash=sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319
+    # via babel
+requests==2.32.3 \
+    --hash=sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760 \
+    --hash=sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6
+    # via sphinx
+snowballstemmer==2.2.0 \
+    --hash=sha256:09b16deb8547d3412ad7b590689584cd0fe25ec8db3be37788be3810cbf19cb1 \
+    --hash=sha256:c8e1716e83cc398ae16824e5572ae04e0d9fc2c6b985fb0f900f5f0c96ecba1a
+    # via sphinx
+soupsieve==2.5 \
+    --hash=sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690 \
+    --hash=sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7
+    # via beautifulsoup4
+sphinx==5.3.0 \
+    --hash=sha256:060ca5c9f7ba57a08a1219e547b269fadf125ae25b06b9fa7f66768efb652d6d \
+    --hash=sha256:51026de0a9ff9fc13c05d74913ad66047e104f56a129ff73e174eb5c3ee794b5
+    # via
+    #   -r requirements-docs.txt
+    #   furo
+    #   sphinx-basic-ng
+    #   sphinx-copybutton
+    #   sphinx-remove-toctrees
+sphinx-basic-ng==1.0.0b2 \
+    --hash=sha256:9ec55a47c90c8c002b5960c57492ec3021f5193cb26cebc2dc4ea226848651c9 \
+    --hash=sha256:eb09aedbabfb650607e9b4b68c9d240b90b1e1be221d6ad71d61c52e29f7932b
+    # via furo
+sphinx-copybutton==0.5.1 \
+    --hash=sha256:0842851b5955087a7ec7fc870b622cb168618ad408dee42692e9a5c97d071da8 \
+    --hash=sha256:366251e28a6f6041514bfb5439425210418d6c750e98d3a695b73e56866a677a
+    # via -r requirements-docs.txt
+sphinx-remove-toctrees==0.0.3 \
+    --hash=sha256:1077ebc00652f8a896ce27404d31cb5bdde9eeaefc80ada72d95a7a0a7b99a9d \
+    --hash=sha256:e4792cc4e5d25ceb1a44dd1490c45d578e6b36f1b1e385ede659e4c324b98cba
+    # via -r requirements-docs.txt
+sphinxcontrib-applehelp==1.0.4 \
+    --hash=sha256:29d341f67fb0f6f586b23ad80e072c8e6ad0b48417db2bde114a4c9746feb228 \
+    --hash=sha256:828f867945bbe39817c210a1abfd1bc4895c8b73fcaade56d45357a348a07d7e
+    # via sphinx
+sphinxcontrib-devhelp==1.0.2 \
+    --hash=sha256:8165223f9a335cc1af7ffe1ed31d2871f325254c0423bc0c4c7cd1c1e4734a2e \
+    --hash=sha256:ff7f1afa7b9642e7060379360a67e9c41e8f3121f2ce9164266f61b9f4b338e4
+    # via sphinx
+sphinxcontrib-htmlhelp==2.0.1 \
+    --hash=sha256:0cbdd302815330058422b98a113195c9249825d681e18f11e8b1f78a2f11efff \
+    --hash=sha256:c38cb46dccf316c79de6e5515e1770414b797162b23cd3d06e67020e1d2a6903
+    # via sphinx
+sphinxcontrib-jsmath==1.0.1 \
+    --hash=sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178 \
+    --hash=sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8
+    # via sphinx
+sphinxcontrib-qthelp==1.0.3 \
+    --hash=sha256:4c33767ee058b70dba89a6fc5c1892c0d57a54be67ddd3e7875a18d14cba5a72 \
+    --hash=sha256:bd9fc24bcb748a8d51fd4ecaade681350aa63009a347a8c14e637895444dfab6
+    # via sphinx
+sphinxcontrib-serializinghtml==1.1.5 \
+    --hash=sha256:352a9a00ae864471d3a7ead8d7d79f5fc0b57e8b3f95e9867eb9eb28999b92fd \
+    --hash=sha256:aa5f6de5dfdf809ef505c4895e51ef5c9eac17d0f287933eb49ec495280b6952
+    # via sphinx
+urllib3==1.26.19 ; python_version < "3.10" \
+    --hash=sha256:37a0344459b199fce0e80b0d3569837ec6b6937435c5244e7fd73fa6006830f3 \
+    --hash=sha256:3e3d753a8618b86d7de333b4223005f68720bcd6a7d2bcb9fbd2229ec7c1e429
+    # via
+    #   -r requirements-docs.txt
+    #   requests
+zipp==3.19.2 \
+    --hash=sha256:bf1dcf6450f873a13e952a29504887c89e6de7506209e5b1bcc3460135d4de19 \
+    --hash=sha256:f091755f667055f2d02b32c53771a7a6c8b47e1fdbc4b72a8b9072b3eef8015c
+    # via importlib-metadata

testbed/boto__botocore/requirements-docs.txt

@@ -0,0 +1,6 @@
+sphinx==5.3.0
+furo==2022.12.7
+sphinx_copybutton==0.5.1
+sphinx-remove-toctrees==0.0.3
+# Avoid urllib3 2.x below Python 3.10
+urllib3<2.0 ; python_version < "3.10"

testbed/boto__botocore/requirements.txt

@@ -0,0 +1 @@
+-r requirements-dev.txt

testbed/boto__botocore/setup.cfg

@@ -0,0 +1,12 @@
+[bdist_wheel]
+universal = 0
+
+[metadata]
+requires_dist =
+    jmespath>=0.7.1,<2.0.0
+    python-dateutil>=2.1,<3.0.0
+    urllib3>=1.25.4,<1.27; python_version<"3.10"
+    urllib3>=1.25.4,!=2.2.0,<3; python_version>="3.10"
+
+[options.extras_require]
+crt = awscrt==0.21.5

testbed/boto__botocore/setup.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+import codecs
+import os.path
+import re
+
+from setuptools import find_packages, setup
+
+here = os.path.abspath(os.path.dirname(__file__))
+
+
+def read(*parts):
+    return codecs.open(os.path.join(here, *parts), 'r').read()
+
+
+def find_version(*file_paths):
+    version_file = read(*file_paths)
+    version_match = re.search(
+        r"^__version__ = ['\"]([^'\"]*)['\"]", version_file, re.M
+    )
+    if version_match:
+        return version_match.group(1)
+    raise RuntimeError("Unable to find version string.")
+
+
+requires = [
+    'jmespath>=0.7.1,<2.0.0',
+    'python-dateutil>=2.1,<3.0.0',
+    # Prior to Python 3.10, Python doesn't require openssl 1.1.1
+    # but urllib3 2.0+ does. This means all botocore users will be
+    # broken by default on Amazon Linux 2 and AWS Lambda without this pin.
+    'urllib3>=1.25.4,<1.27 ; python_version < "3.10"',
+    'urllib3>=1.25.4,!=2.2.0,<3 ; python_version >= "3.10"',
+]
+
+extras_require = {
+    'crt': ['awscrt==0.21.5'],
+}
+
+setup(
+    name='botocore',
+    version=find_version("botocore", "__init__.py"),
+    description='Low-level, data-driven core of boto 3.',
+    long_description=open('README.rst').read(),
+    author='Amazon Web Services',
+    url='https://github.com/boto/botocore',
+    scripts=[],
+    packages=find_packages(exclude=['tests*']),
+    package_data={
+        'botocore': ['cacert.pem', 'data/*.json', 'data/*/*.json'],
+        'botocore.vendored.requests': ['*.pem'],
+    },
+    include_package_data=True,
+    install_requires=requires,
+    extras_require=extras_require,
+    license="Apache License 2.0",
+    python_requires=">= 3.8",
+    classifiers=[
+        'Development Status :: 5 - Production/Stable',
+        'Intended Audience :: Developers',
+        'Intended Audience :: System Administrators',
+        'Natural Language :: English',
+        'License :: OSI Approved :: Apache Software License',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3 :: Only',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+    ],
+)

testbed/boto__botocore/tests/__init__.py

@@ -0,0 +1,599 @@
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+import binascii
+import contextlib
+import datetime
+import os
+import platform
+import random
+import select
+import shutil
+import sys
+import tempfile
+import time
+import unittest
+from contextlib import ContextDecorator
+from io import BytesIO
+from subprocess import PIPE, Popen
+from unittest import mock
+
+from dateutil.tz import tzlocal
+
+import botocore.loaders
+import botocore.session
+from botocore import credentials, utils
+from botocore.awsrequest import AWSResponse
+from botocore.compat import HAS_CRT, parse_qs, urlparse
+from botocore.stub import Stubber
+
+_LOADER = botocore.loaders.Loader()
+
+
+def _all_services():
+    session = botocore.session.Session()
+    service_names = session.get_available_services()
+    return [session.get_service_model(name) for name in service_names]
+
+
+# Only compute our service models once
+ALL_SERVICES = _all_services()
+
+
+def skip_unless_has_memory_collection(cls):
+    """Class decorator to skip tests that require memory collection.
+
+    Any test that uses memory collection (such as the resource leak tests)
+    can decorate their class with skip_unless_has_memory_collection to
+    indicate that if the platform does not support memory collection
+    the tests should be skipped.
+    """
+    if platform.system() not in ['Darwin', 'Linux']:
+        return unittest.skip('Memory tests only supported on mac/linux.')(cls)
+    return cls
+
+
+def skip_if_windows(reason):
+    """Decorator to skip tests that should not be run on windows.
+    Example usage:
+        @skip_if_windows("Not valid")
+        def test_some_non_windows_stuff(self):
+            self.assertEqual(...)
+    """
+
+    def decorator(func):
+        return unittest.skipIf(
+            platform.system() not in ['Darwin', 'Linux'], reason
+        )(func)
+
+    return decorator
+
+
+def requires_crt(reason=None):
+    if reason is None:
+        reason = "Test requires awscrt to be installed"
+
+    def decorator(func):
+        return unittest.skipIf(not HAS_CRT, reason)(func)
+
+    return decorator
+
+
+def random_chars(num_chars):
+    """Returns random hex characters.
+
+    Useful for creating resources with random names.
+
+    """
+    return binascii.hexlify(os.urandom(int(num_chars / 2))).decode('ascii')
+
+
+def create_session(**kwargs):
+    # Create a Session object.  By default,
+    # the _LOADER object is used as the loader
+    # so that we reused the same models across tests.
+    session = botocore.session.Session(**kwargs)
+    session.register_component('data_loader', _LOADER)
+    session.set_config_variable('credentials_file', 'noexist/foo/botocore')
+    return session
+
+
+@contextlib.contextmanager
+def temporary_file(mode):
+    """This is a cross platform temporary file creation.
+
+    tempfile.NamedTemporary file on windows creates a secure temp file
+    that can't be read by other processes and can't be opened a second time.
+
+    For tests, we generally *want* them to be read multiple times.
+    The test fixture writes the temp file contents, the test reads the
+    temp file.
+
+    """
+    temporary_directory = tempfile.mkdtemp()
+    basename = f'tmpfile-{int(time.time())}-{random.randint(1, 1000)}'
+    full_filename = os.path.join(temporary_directory, basename)
+    open(full_filename, 'w').close()
+    try:
+        with open(full_filename, mode) as f:
+            yield f
+    finally:
+        shutil.rmtree(temporary_directory)
+
+
+class BaseEnvVar(unittest.TestCase):
+    def setUp(self):
+        # Automatically patches out os.environ for you
+        # and gives you a self.environ attribute that simulates
+        # the environment.  Also will automatically restore state
+        # for you in tearDown()
+        self.environ = {}
+        self.environ_patch = mock.patch('os.environ', self.environ)
+        self.environ_patch.start()
+
+    def tearDown(self):
+        self.environ_patch.stop()
+
+
+class BaseSessionTest(BaseEnvVar):
+    """Base class used to provide credentials.
+
+    This class can be used as a base class that want to use a real
+    session class but want to be completely isolated from the
+    external environment (including environment variables).
+
+    This class will also set credential vars so you can make fake
+    requests to services.
+
+    """
+
+    def setUp(self, **environ):
+        super().setUp()
+        self.environ['AWS_ACCESS_KEY_ID'] = 'access_key'
+        self.environ['AWS_SECRET_ACCESS_KEY'] = 'secret_key'
+        self.environ['AWS_CONFIG_FILE'] = 'no-exist-foo'
+        self.environ.update(environ)
+        self.session = create_session()
+        self.session.config_filename = 'no-exist-foo'
+
+
+@skip_unless_has_memory_collection
+class BaseClientDriverTest(unittest.TestCase):
+    INJECT_DUMMY_CREDS = False
+
+    def setUp(self):
+        self.driver = ClientDriver()
+        env = None
+        if self.INJECT_DUMMY_CREDS:
+            env = {'AWS_ACCESS_KEY_ID': 'foo', 'AWS_SECRET_ACCESS_KEY': 'bar'}
+        self.driver.start(env=env)
+
+    def cmd(self, *args):
+        self.driver.cmd(*args)
+
+    def send_cmd(self, *args):
+        self.driver.send_cmd(*args)
+
+    def record_memory(self):
+        self.driver.record_memory()
+
+    @property
+    def memory_samples(self):
+        return self.driver.memory_samples
+
+    def tearDown(self):
+        self.driver.stop()
+
+
+class ClientDriver:
+    CLIENT_SERVER = os.path.join(
+        os.path.dirname(os.path.abspath(__file__)), 'cmd-runner'
+    )
+
+    def __init__(self):
+        self._popen = None
+        self.memory_samples = []
+
+    def _get_memory_with_ps(self, pid):
+        # It would be better to eventually switch to psutil,
+        # which should allow us to test on windows, but for now
+        # we'll just use ps and run on POSIX platforms.
+        command_list = ['ps', '-p', str(pid), '-o', 'rss']
+        p = Popen(command_list, stdout=PIPE)
+        stdout = p.communicate()[0]
+        if not p.returncode == 0:
+            raise RuntimeError("Could not retrieve memory")
+        else:
+            # Get the RSS from output that looks like this:
+            # RSS
+            # 4496
+            return int(stdout.splitlines()[1].split()[0]) * 1024
+
+    def record_memory(self):
+        mem = self._get_memory_with_ps(self._popen.pid)
+        self.memory_samples.append(mem)
+
+    def start(self, env=None):
+        """Start up the command runner process."""
+        self._popen = Popen(
+            [sys.executable, self.CLIENT_SERVER],
+            stdout=PIPE,
+            stdin=PIPE,
+            env=env,
+        )
+
+    def stop(self):
+        """Shutdown the command runner process."""
+        self.cmd('exit')
+        self._popen.wait()
+
+    def send_cmd(self, *cmd):
+        """Send a command and return immediately.
+
+        This is a lower level method than cmd().
+        This method will instruct the cmd-runner process
+        to execute a command, but this method will
+        immediately return.  You will need to use
+        ``is_cmd_finished()`` to check that the command
+        is finished.
+
+        This method is useful if you want to record attributes
+        about the process while an operation is occurring.  For
+        example, if you want to instruct the cmd-runner process
+        to upload a 1GB file to S3 and you'd like to record
+        the memory during the upload process, you can use
+        send_cmd() instead of cmd().
+
+        """
+        cmd_str = ' '.join(cmd) + '\n'
+        cmd_bytes = cmd_str.encode('utf-8')
+        self._popen.stdin.write(cmd_bytes)
+        self._popen.stdin.flush()
+
+    def is_cmd_finished(self):
+        rlist = [self._popen.stdout.fileno()]
+        result = select.select(rlist, [], [], 0.01)
+        if result[0]:
+            return True
+        return False
+
+    def cmd(self, *cmd):
+        """Send a command and block until it finishes.
+
+        This method will send a command to the cmd-runner process
+        to run.  It will block until the cmd-runner process is
+        finished executing the command and sends back a status
+        response.
+
+        """
+        self.send_cmd(*cmd)
+        result = self._popen.stdout.readline().strip()
+        if result != b'OK':
+            raise RuntimeError(f"Error from command '{cmd}': {result}")
+
+
+# This is added to this file because it's used in both
+# the functional and unit tests for cred refresh.
+class IntegerRefresher(credentials.RefreshableCredentials):
+    """Refreshable credentials to help with testing.
+
+    This class makes testing refreshable credentials easier.
+    It has the following functionality:
+
+        * A counter, self.refresh_counter, to indicate how many
+          times refresh was called.
+        * A way to specify how many seconds to make credentials
+          valid.
+        * Configurable advisory/mandatory refresh.
+        * An easy way to check consistency.  Each time creds are
+          refreshed, all the cred values are set to the next
+          incrementing integer.  Frozen credentials should always
+          have this value.
+    """
+
+    _advisory_refresh_timeout = 2
+    _mandatory_refresh_timeout = 1
+    _credentials_expire = 3
+
+    def __init__(
+        self,
+        creds_last_for=_credentials_expire,
+        advisory_refresh=_advisory_refresh_timeout,
+        mandatory_refresh=_mandatory_refresh_timeout,
+        refresh_function=None,
+    ):
+        expires_in = self._current_datetime() + datetime.timedelta(
+            seconds=creds_last_for
+        )
+        if refresh_function is None:
+            refresh_function = self._do_refresh
+        super().__init__(
+            '0', '0', '0', expires_in, refresh_function, 'INTREFRESH'
+        )
+        self.creds_last_for = creds_last_for
+        self.refresh_counter = 0
+        self._advisory_refresh_timeout = advisory_refresh
+        self._mandatory_refresh_timeout = mandatory_refresh
+
+    def _do_refresh(self):
+        self.refresh_counter += 1
+        current = int(self._access_key)
+        next_id = str(current + 1)
+
+        return {
+            'access_key': next_id,
+            'secret_key': next_id,
+            'token': next_id,
+            'expiry_time': self._seconds_later(self.creds_last_for),
+        }
+
+    def _seconds_later(self, num_seconds):
+        # We need to guarantee at *least* num_seconds.
+        # Because this doesn't handle subsecond precision
+        # we'll round up to the next second.
+        num_seconds += 1
+        t = self._current_datetime() + datetime.timedelta(seconds=num_seconds)
+        return self._to_timestamp(t)
+
+    def _to_timestamp(self, datetime_obj):
+        obj = utils.parse_to_aware_datetime(datetime_obj)
+        return obj.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    def _current_timestamp(self):
+        return self._to_timestamp(self._current_datetime())
+
+    def _current_datetime(self):
+        return datetime.datetime.now(tzlocal())
+
+
+def _urlparse(url):
+    if isinstance(url, bytes):
+        # Not really necessary, but it helps to reduce noise on Python 2.x
+        url = url.decode('utf8')
+    return urlparse(url)
+
+
+def assert_url_equal(url1, url2):
+    parts1 = _urlparse(url1)
+    parts2 = _urlparse(url2)
+
+    # Because the query string ordering isn't relevant, we have to parse
+    # every single part manually and then handle the query string.
+    assert parts1.scheme == parts2.scheme
+    assert parts1.netloc == parts2.netloc
+    assert parts1.path == parts2.path
+    assert parts1.params == parts2.params
+    assert parts1.fragment == parts2.fragment
+    assert parts1.username == parts2.username
+    assert parts1.password == parts2.password
+    assert parts1.hostname == parts2.hostname
+    assert parts1.port == parts2.port
+    assert parse_qs(parts1.query) == parse_qs(parts2.query)
+
+
+class HTTPStubberException(Exception):
+    pass
+
+
+class RawResponse(BytesIO):
+    # TODO: There's a few objects similar to this in various tests, let's
+    # try and consolidate to this one in a future commit.
+    def stream(self, **kwargs):
+        contents = self.read()
+        while contents:
+            yield contents
+            contents = self.read()
+
+
+class BaseHTTPStubber:
+    def __init__(self, obj_with_event_emitter, strict=True):
+        self.reset()
+        self._strict = strict
+        self._obj_with_event_emitter = obj_with_event_emitter
+
+    def reset(self):
+        self.requests = []
+        self.responses = []
+
+    def add_response(
+        self, url='https://example.com', status=200, headers=None, body=b''
+    ):
+        if headers is None:
+            headers = {}
+
+        raw = RawResponse(body)
+        response = AWSResponse(url, status, headers, raw)
+        self.responses.append(response)
+
+    @property
+    def _events(self):
+        raise NotImplementedError('_events')
+
+    def start(self):
+        self._events.register('before-send', self)
+
+    def stop(self):
+        self._events.unregister('before-send', self)
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.stop()
+
+    def __call__(self, request, **kwargs):
+        self.requests.append(request)
+        if self.responses:
+            response = self.responses.pop(0)
+            if isinstance(response, Exception):
+                raise response
+            else:
+                return response
+        elif self._strict:
+            raise HTTPStubberException('Insufficient responses')
+        else:
+            return None
+
+
+class ClientHTTPStubber(BaseHTTPStubber):
+    @property
+    def _events(self):
+        return self._obj_with_event_emitter.meta.events
+
+
+class SessionHTTPStubber(BaseHTTPStubber):
+    @property
+    def _events(self):
+        return self._obj_with_event_emitter.get_component('event_emitter')
+
+
+class ConsistencyWaiterException(Exception):
+    pass
+
+
+class ConsistencyWaiter:
+    """
+    A waiter class for some check to reach a consistent state.
+
+    :type min_successes: int
+    :param min_successes: The minimum number of successful check calls to
+    treat the check as stable. Default of 1 success.
+
+    :type max_attempts: int
+    :param min_successes: The maximum number of times to attempt calling
+    the check. Default of 20 attempts.
+
+    :type delay: int
+    :param delay: The number of seconds to delay the next API call after a
+    failed check call. Default of 5 seconds.
+    """
+
+    def __init__(
+        self,
+        min_successes=1,
+        max_attempts=20,
+        delay=5,
+        delay_initial_poll=False,
+    ):
+        self.min_successes = min_successes
+        self.max_attempts = max_attempts
+        self.delay = delay
+        self.delay_initial_poll = delay_initial_poll
+
+    def wait(self, check, *args, **kwargs):
+        """
+        Wait until the check succeeds the configured number of times
+
+        :type check: callable
+        :param check: A callable that returns True or False to indicate
+        if the check succeeded or failed.
+
+        :type args: list
+        :param args: Any ordered arguments to be passed to the check.
+
+        :type kwargs: dict
+        :param kwargs: Any keyword arguments to be passed to the check.
+        """
+        attempts = 0
+        successes = 0
+        if self.delay_initial_poll:
+            time.sleep(self.delay)
+        while attempts < self.max_attempts:
+            attempts += 1
+            if check(*args, **kwargs):
+                successes += 1
+                if successes >= self.min_successes:
+                    return
+            else:
+                time.sleep(self.delay)
+        fail_msg = self._fail_message(attempts, successes)
+        raise ConsistencyWaiterException(fail_msg)
+
+    def _fail_message(self, attempts, successes):
+        return (
+            f'Failed after {attempts} attempts, only had {successes} successes'
+        )
+
+
+class StubbedSession(botocore.session.Session):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._cached_clients = {}
+        self._client_stubs = {}
+
+    def create_client(self, service_name, *args, **kwargs):
+        if service_name not in self._cached_clients:
+            client = self._create_stubbed_client(service_name, *args, **kwargs)
+            self._cached_clients[service_name] = client
+        return self._cached_clients[service_name]
+
+    def _create_stubbed_client(self, service_name, *args, **kwargs):
+        client = super().create_client(service_name, *args, **kwargs)
+        stubber = Stubber(client)
+        self._client_stubs[service_name] = stubber
+        return client
+
+    def stub(self, service_name, *args, **kwargs):
+        if service_name not in self._client_stubs:
+            self.create_client(service_name, *args, **kwargs)
+        return self._client_stubs[service_name]
+
+    def activate_stubs(self):
+        for stub in self._client_stubs.values():
+            stub.activate()
+
+    def verify_stubs(self):
+        for stub in self._client_stubs.values():
+            stub.assert_no_pending_responses()
+
+
+class FreezeTime(ContextDecorator):
+    """
+    Context manager for mocking out datetime in arbitrary modules when creating
+    performing actions like signing which require point in time specificity.
+
+    :type module: module
+    :param module: reference to imported module to patch (e.g. botocore.auth.datetime)
+
+    :type date: datetime.datetime
+    :param date: datetime object specifying the output for utcnow()
+    """
+
+    def __init__(self, module, date=None):
+        if date is None:
+            date = datetime.datetime.utcnow()
+        self.date = date
+        self.datetime_patcher = mock.patch.object(
+            module, 'datetime', mock.Mock(wraps=datetime.datetime)
+        )
+
+    def __enter__(self, *args, **kwargs):
+        mock = self.datetime_patcher.start()
+        mock.utcnow.return_value = self.date
+
+    def __exit__(self, *args, **kwargs):
+        self.datetime_patcher.stop()
+
+
+def patch_load_service_model(
+    session, monkeypatch, service_model_json, ruleset_json
+):
+    def mock_load_service_model(service_name, type_name, api_version=None):
+        if type_name == 'service-2':
+            return service_model_json
+        if type_name == 'endpoint-rule-set-1':
+            return ruleset_json
+
+    loader = session.get_component('data_loader')
+    monkeypatch.setattr(loader, 'load_service_model', mock_load_service_model)

testbed/boto__botocore/tests/cmd-runner

@@ -0,0 +1,220 @@
+#!/usr/bin/env python
+# Copyright 2015 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+"""Driver for client scripts.
+
+How it Works
+============
+
+This script is part of the infrastructure used for resource leak tests.
+At a high level, we're trying to verify that specific types of operations
+don't leak memory.  For example:
+
+* Creating 100 clients in a loop doesn't leak memory within reason
+* Making 100 API calls doesn't leak memory
+* Streaming uploads/downloads to/from S3 have O(1) memory usage.
+
+In order to do this, these tests are written to utilize two separate
+processes: a driver and a runner.  The driver sends commands to the
+runner which performs the actual commands.  While the runner is
+running commands the driver can record various attributes about
+the runner process.  So far this is just memory usage.
+
+There's a BaseClientDriverTest test that implements the driver part
+of the tests.  These should read like normal functional/integration tests.
+
+This script (cmd-runner) implements the runner.  It listens for commands
+from the driver and runs the commands.
+
+The driver and runner communicate via a basic text protocol.  Commands
+are line separated with arguments separated by spaces.  Commands
+are sent to the runner via stdin.
+
+On success, the runner response through stdout with "OK".
+
+Here's an example::
+
+    +--------+                                     +-------+
+    | Driver |                                     |Runner |
+    +--------+                                     +-------+
+
+         create_client s3
+         -------------------------------------------->
+               OK
+         <-------------------------------------------
+
+         make_aws_request 100 ec2 describe_instances
+         -------------------------------------------->
+               OK
+         <-------------------------------------------
+
+         stream_s3_upload bucket key /tmp/foo.txt
+         -------------------------------------------->
+               OK
+         <-------------------------------------------
+
+         exit
+         -------------------------------------------->
+               OK
+         <-------------------------------------------
+
+"""
+import botocore.session
+import sys
+
+
+class CommandRunner(object):
+    DEFAULT_REGION = 'us-west-2'
+
+    def __init__(self):
+        self._session = botocore.session.get_session()
+        self._clients = []
+        self._waiters = []
+        self._paginators = []
+
+    def run(self):
+        while True:
+            line = sys.stdin.readline()
+            parts = line.strip().split()
+            if not parts:
+                break
+            elif parts[0] == 'exit':
+                sys.stdout.write('OK\n')
+                sys.stdout.flush()
+                break
+            else:
+                getattr(self, '_do_%s' % parts[0])(parts[1:])
+                sys.stdout.write('OK\n')
+                sys.stdout.flush()
+
+    def _do_create_client(self, args):
+        # The args provided by the user map directly to the args
+        # passed to create_client.  At the least you need
+        # to provide the service name.
+        self._clients.append(self._session.create_client(*args))
+
+    def _do_create_multiple_clients(self, args):
+        # Args:
+        # * num_clients - Number of clients to create in a loop
+        # * client_args - Variable number of args to pass to create_client
+        num_clients = args[0]
+        client_args = args[1:]
+        for _ in range(int(num_clients)):
+            self._clients.append(self._session.create_client(*client_args))
+
+    def _do_free_clients(self, args):
+        # Frees the memory associated with all clients.
+        self._clients = []
+
+    def _do_create_waiter(self, args):
+        # Args:
+        # [0] client name used in its instantiation
+        # [1] waiter name used in its instantiation
+        client = self._create_client(args[0])
+        self._waiters.append(client.get_waiter(args[1]))
+
+    def _do_create_multiple_waiters(self, args):
+        # Args:
+        # [0] num_waiters - Number of clients to create in a loop
+        # [1] client name used in its instantiation
+        # [2] waiter name used in its instantiation
+        num_waiters = args[0]
+        client = self._create_client(args[1])
+        for _ in range(int(num_waiters)):
+            self._waiters.append(client.get_waiter(args[2]))
+
+    def _do_free_waiters(self, args):
+        # Frees the memory associated with all of the waiters.
+        self._waiters = []
+
+    def _do_create_paginator(self, args):
+        # Args:
+        # [0] client name used in its instantiation
+        # [1] paginator name used in its instantiation
+        client = self._create_client(args[0])
+        self._paginators.append(client.get_paginator(args[1]))
+
+    def _do_create_multiple_paginators(self, args):
+        # Args:
+        # [0] num_paginators - Number of paginators to create in a loop
+        # [1] client name used in its instantiation
+        # [2] paginator name used in its instantiation
+        num_paginators = args[0]
+        client = self._create_client(args[1])
+        for _ in range(int(num_paginators)):
+            self._paginators.append(client.get_paginator(args[2]))
+
+    def _do_free_paginators(self, args):
+        # Frees the memory associated with all of the waiters.
+        self._paginators = []
+
+    def _do_make_aws_request(self, args):
+        # Create a client and make a number of AWS requests.
+        # Args:
+        # * num_requests   - The number of requests to create in a loop
+        # * service_name   - The name of the AWS service
+        # * operation_name - The name of the service, snake_cased
+        # * oepration_args - Variable args, kwargs to pass to the API call,
+        #                    in the format Kwarg1:Val1 Kwarg2:Val2
+        num_requests = int(args[0])
+        service_name = args[1]
+        operation_name = args[2]
+        kwargs = dict([v.split(':', 1) for v in args[3:]])
+        client = self._create_client(service_name)
+        method = getattr(client, operation_name)
+        for _ in range(num_requests):
+            method(**kwargs)
+
+    def _do_stream_s3_upload(self, args):
+        # Stream an upload to S3 from a local file.
+        # This does *not* create an S3 bucket.  You need to create this
+        # before running this command.  You will also need to create
+        # the local file to upload before calling this command.
+        # Args:
+        # * bucket   - The name of the S3 bucket
+        # * key      - The name of the S3 key
+        # * filename - The name of the local filename to upload
+        bucket, key, local_filename = args
+        client = self._create_client('s3')
+        with open(local_filename, 'rb') as f:
+            client.put_object(Bucket=bucket, Key=key, Body=f)
+
+    def _do_stream_s3_download(self, args):
+        # Stream a download to S3 from a local file.
+        # Before calling this command you'll need to create the S3 bucket
+        # as well as the S3 object.  Also, the directory where the
+        # file will be downloaded must already exist.
+        # Args:
+        # * bucket   - The name of the S3 bucket
+        # * key      - The name of the S3 key
+        # * filename - The local filename where the object will be downloaded
+        bucket, key, local_filename = args
+        client = self._create_client('s3')
+        response = client.get_object(Bucket=bucket, Key=key)
+        body_stream = response['Body']
+        with open(local_filename, 'wb') as f:
+            for chunk in iter(lambda: body_stream.read(64 * 1024), b''):
+                f.write(chunk)
+
+    def _create_client(self, service_name):
+        # Create a client using the provided service name.
+        # It will also inject a region name of self.DEFAULT_REGION.
+        return self._session.create_client(service_name,
+                                           region_name=self.DEFAULT_REGION)
+
+
+def run():
+    CommandRunner().run()
+
+
+run()

testbed/boto__botocore/tests/unit/__init__.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2012-2013 Mitch Garnaat http://garnaat.org/
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import copy
+
+from tests import unittest
+
+
+class BaseResponseTest(unittest.TestCase):
+    def assert_response_with_subset_metadata(
+        self, actual_response, expected_response
+    ):
+        """
+        Compares two parsed service responses. For ResponseMetadata, it will
+        only assert that the expected is a proper subset of the actual. This
+        is useful so that when new keys are added to the metadata, tests don't
+        break.
+        """
+        actual = copy.copy(actual_response)
+        expected = copy.copy(expected_response)
+
+        actual_metadata = actual.pop('ResponseMetadata', {})
+        expected_metadata = expected.pop('ResponseMetadata', {})
+
+        self.assertEqual(actual, expected)
+        self.assert_dict_is_proper_subset(actual_metadata, expected_metadata)
+
+    def assert_dict_is_proper_subset(self, superset, subset):
+        """
+        Asserts that a dictionary is a proper subset of another.
+        """
+        self.assertTrue(
+            all(
+                (k in superset and superset[k] == v) for k, v in subset.items()
+            )
+        )

testbed/boto__botocore/tests/unit/put_object_data

@@ -0,0 +1 @@
+This is a test of PutObject.

testbed/boto__botocore/tests/unit/response_parsing/README.rst

@@ -0,0 +1,34 @@
+======================
+Response Parsing Tests
+======================
+
+The purpose of this collection of tests it to determine whether the XML
+responses from the services are being correctly parsed and transformed
+into Python data structures.
+
+Within the ``data`` directory you will find pairs of files, an XML file
+and a JSON file using a naming convention of::
+
+    <service_name>-<operation_name>.[xml|json]
+
+Each pair of files represents one test.  The XML file contains the
+response sent from the server for that particular request and the JSON
+file contains the expected Python data structure created from the XML
+response.
+
+The main test is contained in ``test_response_parser.py`` and is
+implemented as a nose generator.  Each time through the loop an XML
+file is read and passed to a ``botocore.response.XmlResponse``
+object.  The corresponding JSON file is then parsed and compared to
+the value created by the parser.  If the are equal, the test passes.  If
+they are not equal, both the expected result and the actual result are
+pretty-printed to stdout and the tests continue.
+
+-----------------
+Adding More Tests
+-----------------
+
+You can add more tests by simply placing appropriately named XML and JSON
+files into the data directory.  Make sure you follow the naming convention
+shown above as that is how the generator determines which service and
+operation to call.

testbed/boto__botocore/tests/unit/response_parsing/test_response_parsing.py

@@ -0,0 +1,195 @@
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+import difflib
+import glob
+import json
+import logging
+import os
+import pprint
+
+import pytest
+
+import botocore.session
+from botocore import parsers, xform_name
+from tests import create_session
+
+log = logging.getLogger(__name__)
+
+
+SPECIAL_CASES = [
+    'iam-get-user-policy.xml',  # Needs the JSON decode from handlers.py
+    'iam-list-roles.xml',  # Needs the JSON decode from handlers.py for the policy
+    's3-get-bucket-location.xml',  # Confirmed, this will need a special handler
+    # 's3-list-multipart-uploads.xml',  # Bug in model, missing delimeter
+    'cloudformation-get-template.xml',  # Need to JSON decode the template body.
+]
+
+
+def _get_expected_parsed_result(filename):
+    dirname, filename = os.path.split(filename)
+    basename = os.path.splitext(filename)[0]
+    jsonfile = os.path.join(dirname, basename + '.json')
+    with open(jsonfile) as f:
+        return json.load(f)
+
+
+def _get_raw_response_body(xmlfile):
+    with open(xmlfile, 'rb') as f:
+        return f.read()
+
+
+def _get_operation_model(service_model, filename):
+    dirname, filename = os.path.split(filename)
+    basename = os.path.splitext(filename)[0]
+    sn, opname = basename.split('-', 1)
+    # In order to have multiple tests for the same
+    # operation a '#' char is used to separate
+    # operation names from some other suffix so that
+    # the tests have a different filename, e.g
+    # my-operation#1.xml, my-operation#2.xml.
+    opname = opname.split('#')[0]
+    operation_names = service_model.operation_names
+    for operation_name in operation_names:
+        if xform_name(operation_name) == opname.replace('-', '_'):
+            return service_model.operation_model(operation_name)
+
+
+def _test_parsed_response(xmlfile, operation_model, expected):
+    response_body = _get_raw_response_body(xmlfile)
+    response = {'body': response_body, 'status_code': 200, 'headers': {}}
+    for case in SPECIAL_CASES:
+        if case in xmlfile:
+            print(f"SKIP: {xmlfile}")
+            return
+    if 'errors' in xmlfile:
+        response['status_code'] = 400
+    # Handle the special cased __headers__ key if it exists.
+    if b'__headers__' in response_body:
+        loaded = json.loads(response_body.decode('utf-8'))
+        response['headers'] = loaded.pop('__headers__')
+        response['body'] = json.dumps(loaded).encode('utf-8')
+
+    protocol = operation_model.service_model.protocol
+    parser_cls = parsers.PROTOCOL_PARSERS[protocol]
+    parser = parser_cls(timestamp_parser=lambda x: x)
+    parsed = parser.parse(response, operation_model.output_shape)
+    parsed = _convert_bytes_to_str(parsed)
+    expected['ResponseMetadata']['HTTPStatusCode'] = response['status_code']
+    expected['ResponseMetadata']['HTTPHeaders'] = response['headers']
+
+    d2 = parsed
+    d1 = expected
+
+    if d1 != d2:
+        log.debug('-' * 40)
+        log.debug("XML FILE:\n" + xmlfile)
+        log.debug('-' * 40)
+        log.debug("ACTUAL:\n" + pprint.pformat(parsed))
+        log.debug('-' * 40)
+        log.debug("EXPECTED:\n" + pprint.pformat(expected))
+    if not d1 == d2:
+        # Borrowed from assertDictEqual, though this doesn't
+        # handle the case when unicode literals are used in one
+        # dict but not in the other (and we want to consider them
+        # as being equal).
+        print(d1)
+        print()
+        print(d2)
+        pretty_d1 = pprint.pformat(d1, width=1).splitlines()
+        pretty_d2 = pprint.pformat(d2, width=1).splitlines()
+        diff = '\n' + '\n'.join(difflib.ndiff(pretty_d1, pretty_d2))
+        raise AssertionError(f"Dicts are not equal:\n{diff}")
+
+
+def _convert_bytes_to_str(parsed):
+    if isinstance(parsed, dict):
+        new_dict = {}
+        for key, value in parsed.items():
+            new_dict[key] = _convert_bytes_to_str(value)
+        return new_dict
+    elif isinstance(parsed, bytes):
+        return parsed.decode('utf-8')
+    elif isinstance(parsed, list):
+        new_list = []
+        for item in parsed:
+            new_list.append(_convert_bytes_to_str(item))
+        return new_list
+    else:
+        return parsed
+
+
+def _xml_test_cases():
+    session = create_session()
+    test_cases = []
+    for dp in ['responses', 'errors']:
+        data_path = os.path.join(os.path.dirname(__file__), 'xml')
+        data_path = os.path.join(data_path, dp)
+        xml_files = glob.glob(f'{data_path}/*.xml')
+        service_names = set()
+        for fn in xml_files:
+            service_names.add(os.path.split(fn)[1].split('-')[0])
+        for service_name in service_names:
+            service_model = session.get_service_model(service_name)
+            service_xml_files = glob.glob(f'{data_path}/{service_name}-*.xml')
+            for xmlfile in service_xml_files:
+                expected = _get_expected_parsed_result(xmlfile)
+                operation_model = _get_operation_model(service_model, xmlfile)
+                test_cases.append((xmlfile, operation_model, expected))
+    return sorted(test_cases)
+
+
+@pytest.mark.parametrize(
+    "xmlfile, operation_model, expected", _xml_test_cases()
+)
+def test_xml_parsing(xmlfile, operation_model, expected):
+    _test_parsed_response(xmlfile, operation_model, expected)
+
+
+def _json_test_cases():
+    # The outputs/ directory has sample output responses
+    # For each file in outputs/ there's a corresponding file
+    # in expected/ that has the expected parsed response.
+    base_dir = os.path.join(os.path.dirname(__file__), 'json')
+    json_responses_dir = os.path.join(base_dir, 'errors')
+    expected_parsed_dir = os.path.join(base_dir, 'expected')
+    session = botocore.session.get_session()
+    json_test_cases = []
+    for json_response_file in os.listdir(json_responses_dir):
+        # Files look like: 'datapipeline-create-pipeline.json'
+        service_name, operation_name = os.path.splitext(json_response_file)[
+            0
+        ].split('-', 1)
+        expected_parsed_response = os.path.join(
+            expected_parsed_dir, json_response_file
+        )
+        raw_response_file = os.path.join(
+            json_responses_dir, json_response_file
+        )
+        with open(expected_parsed_response) as f:
+            expected = json.load(f)
+        service_model = session.get_service_model(service_name)
+        operation_names = service_model.operation_names
+        operation_model = None
+        for op_name in operation_names:
+            if xform_name(op_name) == operation_name.replace('-', '_'):
+                operation_model = service_model.operation_model(op_name)
+        json_test_cases.append((raw_response_file, operation_model, expected))
+    return sorted(json_test_cases)
+
+
+@pytest.mark.parametrize(
+    "raw_response_file, operation_model, expected", _json_test_cases()
+)
+def test_json_errors_parsing(raw_response_file, operation_model, expected):
+    _test_parsed_response(raw_response_file, operation_model, expected)

testbed/boto__botocore/tests/unit/response_parsing/xml/responses/cloudwatch-describe-alarm-history.json

@@ -0,0 +1,6 @@
+{
+    "AlarmHistoryItems": [], 
+    "ResponseMetadata": {
+        "RequestId": "ac265b36-9167-11e2-bf7e-91c14e278742"
+    }
+}

testbed/boto__botocore/tests/unit/response_parsing/xml/responses/cloudwatch-describe-alarm-history.xml

@@ -0,0 +1,8 @@
+<DescribeAlarmHistoryResponse xmlns="http://monitoring.amazonaws.com/doc/2010-08-01/">
+  <DescribeAlarmHistoryResult>
+    <AlarmHistoryItems/>
+  </DescribeAlarmHistoryResult>
+  <ResponseMetadata>
+    <RequestId>ac265b36-9167-11e2-bf7e-91c14e278742</RequestId>
+  </ResponseMetadata>
+</DescribeAlarmHistoryResponse>

testbed/boto__botocore/tests/unit/response_parsing/xml/responses/cloudwatch-list-metrics.xml

@@ -0,0 +1,819 @@
+<ListMetricsResponse xmlns="http://monitoring.amazonaws.com/doc/2010-08-01/">
+  <ListMetricsResult>
+    <Metrics>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeIdleTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>QueueName</Name>
+            <Value>foobar</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NumberOfEmptyReceives</MetricName>
+        <Namespace>AWS/SQS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkOut</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>QueueName</Name>
+            <Value>foobar</Value>
+          </member>
+        </Dimensions>
+        <MetricName>ApproximateNumberOfMessagesNotVisible</MetricName>
+        <Namespace>AWS/SQS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalReadTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_Instance</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>QueueName</Name>
+            <Value>foobar</Value>
+          </member>
+        </Dimensions>
+        <MetricName>ApproximateNumberOfMessagesDelayed</MetricName>
+        <Namespace>AWS/SQS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>CPUUtilization</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalWriteTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>CPUUtilization</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeQueueLength</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalReadTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>CPUUtilization</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_Instance</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>CPUUtilization</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeIdleTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeQueueLength</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeIdleTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>QueueName</Name>
+            <Value>foobar</Value>
+          </member>
+        </Dimensions>
+        <MetricName>ApproximateNumberOfMessagesVisible</MetricName>
+        <Namespace>AWS/SQS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_Instance</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalWriteTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_System</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkOut</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalWriteTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeQueueLength</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeIdleTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>QueueName</Name>
+            <Value>foobar</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NumberOfMessagesSent</MetricName>
+        <Namespace>AWS/SQS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeQueueLength</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-267b761f</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>TableName</Name>
+            <Value>fromcli</Value>
+          </member>
+        </Dimensions>
+        <MetricName>ProvisionedReadCapacityUnits</MetricName>
+        <Namespace>AWS/DynamoDB</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_System</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>QueueName</Name>
+            <Value>foobar</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NumberOfMessagesDeleted</MetricName>
+        <Namespace>AWS/SQS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkOut</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_System</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkOut</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkIn</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>QueueName</Name>
+            <Value>foobar</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NumberOfMessagesReceived</MetricName>
+        <Namespace>AWS/SQS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeReadOps</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-203b3919</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalReadTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>TableName</Name>
+            <Value>fromcli</Value>
+          </member>
+        </Dimensions>
+        <MetricName>ProvisionedWriteCapacityUnits</MetricName>
+        <Namespace>AWS/DynamoDB</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalWriteTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-a8d2e991</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeTotalReadTime</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>VolumeId</Name>
+            <Value>vol-04c7c53d</Value>
+          </member>
+        </Dimensions>
+        <MetricName>VolumeWriteBytes</MetricName>
+        <Namespace>AWS/EBS</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-20277712</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_Instance</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkIn</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkIn</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-70d08042</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskReadOps</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-d63c6ce4</Value>
+          </member>
+        </Dimensions>
+        <MetricName>NetworkIn</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>StatusCheckFailed_System</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+      <member>
+        <Dimensions>
+          <member>
+            <Name>InstanceId</Name>
+            <Value>i-78f1b94a</Value>
+          </member>
+        </Dimensions>
+        <MetricName>DiskWriteBytes</MetricName>
+        <Namespace>AWS/EC2</Namespace>
+      </member>
+    </Metrics>
+  </ListMetricsResult>
+  <ResponseMetadata>
+    <RequestId>abea8add-9167-11e2-91d1-9b4c7751b290</RequestId>
+  </ResponseMetadata>
+</ListMetricsResponse>

testbed/boto__botocore/tests/unit/response_parsing/xml/responses/sqs-change-message-visibility-batch.json

@@ -0,0 +1,13 @@
+{
+    "Successful": [
+        {
+            "Id": "change_visibility_msg_2"
+        }, 
+        {
+            "Id": "change_visibility_msg_3"
+        }
+    ], 
+    "ResponseMetadata": {
+        "RequestId": "ca9668f7-ab1b-4f7a-8859-f15747ab17a7"
+    }
+}

testbed/boto__botocore/tests/unit/response_parsing/xml/responses/sqs-list-queues.json

@@ -0,0 +1,9 @@
+{
+    "QueueUrls": [
+        "https://us-west-2.queue.amazonaws.com/123456789012/foobar",
+        "https://us-west-2.queue.amazonaws.com/123456789012/fiebaz"
+    ],
+    "ResponseMetadata": {
+        "RequestId": "517c6371-751f-5711-9ebc-2ab2b1a92268"
+    }
+}

testbed/boto__botocore/tests/unit/response_parsing/xml/responses/sts-get-session-token.xml

@@ -0,0 +1,16 @@
+<GetSessionTokenResponse xmlns="https://sts.amazonaws.com/doc/2011-06-15/">
+  <GetSessionTokenResult>
+    <Credentials>
+      <SessionToken>AQoEXAMPLEH4aoAH0gNCAPyJxz4BlCFFxWNE1OPTgk5TthT+FvwqnKwRcOIfrRh3c/L
+       To6UDdyJwOOvEVPvLXCrrrUtdnniCEXAMPLE/IvU1dYUg2RVAJBanLiHb4IgRmpRV3z
+       rkuWJOgQs8IZZaIv2BXIa2R4OlgkBN9bkUDNCJiBeb/AXlzBBko7b15fjrBs2+cTQtp
+       Z3CYWFXG8C5zqx37wnOE49mRl/+OtkIKGO7fAE</SessionToken>
+      <SecretAccessKey>wJalrXUtnFEMI/K7MDENG/bPxRfiCYzEXAMPLEKEY</SecretAccessKey>
+      <Expiration>2011-07-11T19:55:29.611Z</Expiration>
+      <AccessKeyId>AKIAIOSFODNN7EXAMPLE</AccessKeyId>
+    </Credentials>
+  </GetSessionTokenResult>
+  <ResponseMetadata>
+    <RequestId>58c5dbae-abef-11e0-8cfe-09039844ac7d</RequestId>
+  </ResponseMetadata>
+</GetSessionTokenResponse>

testbed/boto__botocore/tests/unit/retries/test_adaptive.py

@@ -0,0 +1,167 @@
+from botocore.retries import adaptive, bucket, standard, throttling
+from tests import mock, unittest
+
+
+class FakeClock(bucket.Clock):
+    def __init__(self, timestamp_sequences):
+        self.timestamp_sequences = timestamp_sequences
+        self.sleep_call_amounts = []
+
+    def sleep(self, amount):
+        self.sleep_call_amounts.append(amount)
+
+    def current_time(self):
+        return self.timestamp_sequences.pop(0)
+
+
+class TestCanCreateRetryHandler(unittest.TestCase):
+    def test_can_register_retry_handler(self):
+        client = mock.Mock()
+        limiter = adaptive.register_retry_handler(client)
+        self.assertEqual(
+            client.meta.events.register.call_args_list,
+            [
+                mock.call('before-send', limiter.on_sending_request),
+                mock.call('needs-retry', limiter.on_receiving_response),
+            ],
+        )
+
+
+class TestClientRateLimiter(unittest.TestCase):
+    def setUp(self):
+        self.timestamp_sequences = [0]
+        self.clock = FakeClock(self.timestamp_sequences)
+        self.token_bucket = mock.Mock(spec=bucket.TokenBucket)
+        self.rate_adjustor = mock.Mock(spec=throttling.CubicCalculator)
+        self.rate_clocker = mock.Mock(spec=adaptive.RateClocker)
+        self.throttling_detector = mock.Mock(
+            spec=standard.ThrottlingErrorDetector
+        )
+
+    def create_client_limiter(self):
+        rate_limiter = adaptive.ClientRateLimiter(
+            rate_adjustor=self.rate_adjustor,
+            rate_clocker=self.rate_clocker,
+            token_bucket=self.token_bucket,
+            throttling_detector=self.throttling_detector,
+            clock=self.clock,
+        )
+        return rate_limiter
+
+    def test_bucket_bucket_acquisition_only_if_enabled(self):
+        rate_limiter = self.create_client_limiter()
+        rate_limiter.on_sending_request(request=mock.sentinel.request)
+        self.assertFalse(self.token_bucket.acquire.called)
+
+    def test_token_bucket_enabled_on_throttling_error(self):
+        rate_limiter = self.create_client_limiter()
+        self.throttling_detector.is_throttling_error.return_value = True
+        self.rate_clocker.record.return_value = 21
+        self.rate_adjustor.error_received.return_value = 17
+        rate_limiter.on_receiving_response()
+        # Now if we call on_receiving_response we should try to acquire
+        # token.
+        self.timestamp_sequences.append(1)
+        rate_limiter.on_sending_request(request=mock.sentinel.request)
+        self.assertTrue(self.token_bucket.acquire.called)
+
+    def test_max_rate_updated_on_success_response(self):
+        rate_limiter = self.create_client_limiter()
+        self.throttling_detector.is_throttling_error.return_value = False
+        self.rate_adjustor.success_received.return_value = 20
+        self.rate_clocker.record.return_value = 21
+        rate_limiter.on_receiving_response()
+        self.assertEqual(self.token_bucket.max_rate, 20)
+
+    def test_max_rate_cant_exceed_20_percent_max(self):
+        rate_limiter = self.create_client_limiter()
+        self.throttling_detector.is_throttling_error.return_value = False
+        # So if our actual measured sending rate is 20 TPS
+        self.rate_clocker.record.return_value = 20
+        # But the rate adjustor is telling us to go up to 100 TPS
+        self.rate_adjustor.success_received.return_value = 100
+
+        # The most we should go up is 2.0 * 20
+        rate_limiter.on_receiving_response()
+        self.assertEqual(self.token_bucket.max_rate, 2.0 * 20)
+
+
+class TestRateClocker(unittest.TestCase):
+    def setUp(self):
+        self.timestamp_sequences = [0]
+        self.clock = FakeClock(self.timestamp_sequences)
+        self.rate_measure = adaptive.RateClocker(self.clock)
+        self.smoothing = 0.8
+
+    def test_initial_rate_is_0(self):
+        self.assertEqual(self.rate_measure.measured_rate, 0)
+
+    def test_time_updates_if_after_bucket_range(self):
+        self.timestamp_sequences.append(1)
+        # This should be 1 * 0.8 + 0 * 0.2, or just 0.8
+        self.assertEqual(self.rate_measure.record(), 0.8)
+
+    def test_can_measure_constant_rate(self):
+        # Timestamps of 1 every second indicate a rate of 1 TPS.
+        self.timestamp_sequences.extend(range(1, 21))
+        for _ in range(20):
+            self.rate_measure.record()
+        self.assertAlmostEqual(self.rate_measure.measured_rate, 1)
+
+    def test_uses_smoothing_to_favor_recent_weights(self):
+        self.timestamp_sequences.extend(
+            [
+                1,
+                1.5,
+                2,
+                2.5,
+                3,
+                3.5,
+                4,
+                # If we now wait 10 seconds (.1 TPS),
+                # our rate is somewhere between 2 TPS and .1 TPS.
+                14,
+            ]
+        )
+        for _ in range(7):
+            self.rate_measure.record()
+        # We should almost be at 2.0 but not quite.
+        self.assertGreaterEqual(self.rate_measure.measured_rate, 1.99)
+        self.assertLessEqual(self.rate_measure.measured_rate, 2.0)
+        # With our last recording we now drop down between 0.1 and 2
+        # depending on our smoothing factor.
+        self.rate_measure.record()
+        self.assertGreaterEqual(self.rate_measure.measured_rate, 0.1)
+        self.assertLessEqual(self.rate_measure.measured_rate, 2.0)
+
+    def test_noop_when_delta_t_is_0(self):
+        self.timestamp_sequences.extend([1, 1, 1, 2, 3])
+        for _ in range(5):
+            self.rate_measure.record()
+        self.assertGreaterEqual(self.rate_measure.measured_rate, 1.0)
+
+    def test_times_are_grouped_per_time_bucket(self):
+        # Using our default of 0.5 time buckets, we have:
+        self.timestamp_sequences.extend(
+            [
+                0.1,
+                0.2,
+                0.3,
+                0.4,
+                0.49,
+            ]
+        )
+        for _ in range(len(self.timestamp_sequences)):
+            self.rate_measure.record()
+        # This is showing the tradeoff we're making with measuring rates.
+        # we're currently in the window from 0 <= x < 0.5, which means
+        # we use the rate from the previous bucket, which is 0:
+        self.assertEqual(self.rate_measure.measured_rate, 0)
+        # However if we now add a new measurement that's in the next
+        # time bucket  0.5 <= x < 1.0
+        # we'll use the range from the previous bucket:
+        self.timestamp_sequences.append(0.5)
+        self.rate_measure.record()
+        # And our previous bucket will be:
+        # 12 * 0.8 + 0.2 * 0
+        self.assertEqual(self.rate_measure.measured_rate, 12 * 0.8)

testbed/boto__botocore/tests/unit/retries/test_special.py

@@ -0,0 +1,143 @@
+from botocore.awsrequest import AWSResponse
+from botocore.retries import special, standard
+from tests import mock, unittest
+
+
+def create_fake_op_model(service_name):
+    model = mock.Mock()
+    model.service_model.service_name = service_name
+    return model
+
+
+class TestRetryIDPCommunicationError(unittest.TestCase):
+    def setUp(self):
+        self.checker = special.RetryIDPCommunicationError()
+
+    def test_only_retries_error_for_sts(self):
+        context = standard.RetryContext(
+            attempt_number=1,
+            operation_model=create_fake_op_model('s3'),
+            parsed_response={
+                'Error': {
+                    'Code': 'IDPCommunicationError',
+                    'Message': 'message',
+                }
+            },
+            http_response=AWSResponse(
+                status_code=400, raw=None, headers={}, url='https://foo'
+            ),
+            caught_exception=None,
+        )
+        self.assertFalse(self.checker.is_retryable(context))
+
+    def test_can_retry_idp_communication_error(self):
+        context = standard.RetryContext(
+            attempt_number=1,
+            operation_model=create_fake_op_model('sts'),
+            parsed_response={
+                'Error': {
+                    'Code': 'IDPCommunicationError',
+                    'Message': 'message',
+                }
+            },
+            http_response=AWSResponse(
+                status_code=400, raw=None, headers={}, url='https://foo'
+            ),
+            caught_exception=None,
+        )
+        self.assertTrue(self.checker.is_retryable(context))
+
+    def test_not_idp_communication_error(self):
+        context = standard.RetryContext(
+            attempt_number=1,
+            operation_model=create_fake_op_model('sts'),
+            parsed_response={
+                'Error': {
+                    'Code': 'NotIDPCommunicationError',
+                    'Message': 'message',
+                }
+            },
+            http_response=AWSResponse(
+                status_code=400, raw=None, headers={}, url='https://foo'
+            ),
+            caught_exception=None,
+        )
+        self.assertFalse(self.checker.is_retryable(context))
+
+
+class TestRetryDDBChecksumError(unittest.TestCase):
+    def setUp(self):
+        self.checker = special.RetryDDBChecksumError()
+
+    def raw_stream(self, contents):
+        raw = mock.Mock()
+        raw.stream.return_value = [contents]
+        return raw
+
+    def test_checksum_not_in_header(self):
+        context = standard.RetryContext(
+            attempt_number=1,
+            operation_model=create_fake_op_model('dynamodb'),
+            parsed_response={
+                'Anything': ["foo"],
+            },
+            http_response=AWSResponse(
+                status_code=200,
+                raw=self.raw_stream(b'foo'),
+                headers={},
+                url='https://foo',
+            ),
+            caught_exception=None,
+        )
+        self.assertFalse(self.checker.is_retryable(context))
+
+    def test_checksum_matches(self):
+        context = standard.RetryContext(
+            attempt_number=1,
+            operation_model=create_fake_op_model('dynamodb'),
+            parsed_response={
+                'Anything': ["foo"],
+            },
+            http_response=AWSResponse(
+                status_code=200,
+                raw=self.raw_stream(b'foo'),
+                headers={'x-amz-crc32': '2356372769'},
+                url='https://foo',
+            ),
+            caught_exception=None,
+        )
+        self.assertFalse(self.checker.is_retryable(context))
+
+    def test_checksum_not_matches(self):
+        context = standard.RetryContext(
+            attempt_number=1,
+            operation_model=create_fake_op_model('dynamodb'),
+            parsed_response={
+                'Anything': ["foo"],
+            },
+            http_response=AWSResponse(
+                status_code=200,
+                raw=self.raw_stream(b'foo'),
+                headers={'x-amz-crc32': '2356372768'},
+                url='https://foo',
+            ),
+            caught_exception=None,
+        )
+        self.assertTrue(self.checker.is_retryable(context))
+
+    def test_checksum_check_only_for_dynamodb(self):
+        context = standard.RetryContext(
+            attempt_number=1,
+            operation_model=create_fake_op_model('s3'),
+            parsed_response={
+                'Anything': ["foo"],
+            },
+            http_response=AWSResponse(
+                status_code=200,
+                raw=self.raw_stream(b'foo'),
+                headers={'x-amz-crc32': '2356372768'},
+                url='https://foo',
+            ),
+            caught_exception=None,
+        )
+        self.assertFalse(self.checker.is_retryable(context))

testbed/boto__botocore/tests/unit/test_args.py

@@ -0,0 +1,844 @@
+#!/usr/bin/env
+# Copyright 2016 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import socket
+
+from botocore import args, exceptions
+from botocore.client import ClientEndpointBridge
+from botocore.config import Config
+from botocore.configprovider import ConfigValueStore
+from botocore.hooks import HierarchicalEmitter
+from botocore.model import ServiceModel
+from botocore.useragent import UserAgentString
+from tests import mock, unittest
+
+
+class TestCreateClientArgs(unittest.TestCase):
+    def setUp(self):
+        self.event_emitter = mock.Mock(HierarchicalEmitter)
+        self.config_store = ConfigValueStore()
+        user_agent_creator = UserAgentString(
+            platform_name=None,
+            platform_version=None,
+            platform_machine=None,
+            python_version=None,
+            python_implementation=None,
+            execution_env=None,
+            crt_version=None,
+        )
+        self.args_create = args.ClientArgsCreator(
+            event_emitter=self.event_emitter,
+            user_agent=None,
+            response_parser_factory=None,
+            loader=None,
+            exceptions_factory=None,
+            config_store=self.config_store,
+            user_agent_creator=user_agent_creator,
+        )
+        self.service_name = 'ec2'
+        self.region = 'us-west-2'
+        self.endpoint_url = 'https://ec2/'
+        self.service_model = self._get_service_model()
+        self.bridge = mock.Mock(ClientEndpointBridge)
+        self._set_endpoint_bridge_resolve()
+        self._set_resolver_uses_builtin()
+        self.default_socket_options = [
+            (socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        ]
+
+    def _get_service_model(self, service_name=None):
+        if service_name is None:
+            service_name = self.service_name
+        service_model = mock.Mock(ServiceModel)
+        service_model.service_name = service_name
+        service_model.endpoint_prefix = service_name
+        service_model.metadata = {
+            'serviceFullName': 'MyService',
+            'protocol': 'query',
+        }
+        service_model.operation_names = []
+        return service_model
+
+    def _set_endpoint_bridge_resolve(self, **override_kwargs):
+        ret_val = {
+            'region_name': self.region,
+            'signature_version': 'v4',
+            'endpoint_url': self.endpoint_url,
+            'signing_name': self.service_name,
+            'signing_region': self.region,
+            'metadata': {},
+        }
+        ret_val.update(**override_kwargs)
+        self.bridge.resolve.return_value = ret_val
+
+    def _set_resolver_uses_builtin(self, uses_builtin=True):
+        self.bridge.resolver_uses_builtin_data.return_value = uses_builtin
+
+    def call_get_client_args(self, **override_kwargs):
+        call_kwargs = {
+            'service_model': self.service_model,
+            'region_name': self.region,
+            'is_secure': True,
+            'endpoint_url': self.endpoint_url,
+            'verify': True,
+            'credentials': None,
+            'scoped_config': {},
+            'client_config': None,
+            'endpoint_bridge': self.bridge,
+            'endpoints_ruleset_data': {
+                'version': '1.0',
+                'parameters': {},
+                'rules': [],
+            },
+            'partition_data': {},
+        }
+        call_kwargs.update(**override_kwargs)
+        return self.args_create.get_client_args(**call_kwargs)
+
+    def assert_create_endpoint_call(self, mock_endpoint, **override_kwargs):
+        call_kwargs = {
+            'endpoint_url': self.endpoint_url,
+            'region_name': self.region,
+            'response_parser_factory': None,
+            'timeout': (60, 60),
+            'verify': True,
+            'max_pool_connections': 10,
+            'proxies': None,
+            'proxies_config': None,
+            'socket_options': self.default_socket_options,
+            'client_cert': None,
+        }
+        call_kwargs.update(**override_kwargs)
+        mock_endpoint.return_value.create_endpoint.assert_called_with(
+            self.service_model, **call_kwargs
+        )
+
+    def test_compute_s3_configuration(self):
+        self.assertIsNone(self.args_create.compute_s3_config(None))
+
+    def test_compute_s3_config_only_config_store(self):
+        self.config_store.set_config_variable(
+            's3', {'use_accelerate_endpoint': True}
+        )
+        self.assertEqual(
+            self.args_create.compute_s3_config(None),
+            {'use_accelerate_endpoint': True},
+        )
+
+    def test_client_s3_accelerate_from_client_config(self):
+        self.assertEqual(
+            self.args_create.compute_s3_config(
+                client_config=Config(s3={'use_accelerate_endpoint': True})
+            ),
+            {'use_accelerate_endpoint': True},
+        )
+
+    def test_client_s3_accelerate_client_config_overrides_config_store(self):
+        self.config_store.set_config_variable(
+            's3', {'use_accelerate_endpoint': False}
+        )
+        self.assertEqual(
+            self.args_create.compute_s3_config(
+                client_config=Config(s3={'use_accelerate_endpoint': True})
+            ),
+            # client_config beats scoped_config
+            {'use_accelerate_endpoint': True},
+        )
+
+    def test_max_pool_from_client_config_forwarded_to_endpoint_creator(self):
+        config = Config(max_pool_connections=20)
+        with mock.patch('botocore.args.EndpointCreator') as m:
+            self.call_get_client_args(client_config=config)
+            self.assert_create_endpoint_call(m, max_pool_connections=20)
+
+    def test_proxies_from_client_config_forwarded_to_endpoint_creator(self):
+        proxies = {
+            'http': 'http://foo.bar:1234',
+            'https': 'https://foo.bar:4321',
+        }
+        config = Config(proxies=proxies)
+        with mock.patch('botocore.args.EndpointCreator') as m:
+            self.call_get_client_args(client_config=config)
+            self.assert_create_endpoint_call(m, proxies=proxies)
+
+    def test_s3_with_endpoint_url_still_resolves_region(self):
+        self.service_model.endpoint_prefix = 's3'
+        self.service_model.metadata = {'protocol': 'rest-xml'}
+        self.bridge.resolve.side_effect = [
+            {
+                'region_name': None,
+                'signature_version': 's3v4',
+                'endpoint_url': 'http://other.com/',
+                'signing_name': 's3',
+                'signing_region': None,
+                'metadata': {},
+            },
+            {
+                'region_name': 'us-west-2',
+                'signature_version': 's3v4',
+                'endpoint_url': 'https://s3-us-west-2.amazonaws.com',
+                'signing_name': 's3',
+                'signing_region': 'us-west-2',
+                'metadata': {},
+            },
+        ]
+        client_args = self.call_get_client_args(
+            endpoint_url='http://other.com/'
+        )
+        self.assertEqual(client_args['client_config'].region_name, 'us-west-2')
+
+    def test_region_does_not_resolve_if_not_s3_and_endpoint_url_provided(self):
+        self.service_model.endpoint_prefix = 'ec2'
+        self.service_model.metadata = {'protocol': 'query'}
+        self.bridge.resolve.side_effect = [
+            {
+                'region_name': None,
+                'signature_version': 'v4',
+                'endpoint_url': 'http://other.com/',
+                'signing_name': 'ec2',
+                'signing_region': None,
+                'metadata': {},
+            }
+        ]
+        client_args = self.call_get_client_args(
+            endpoint_url='http://other.com/'
+        )
+        self.assertEqual(client_args['client_config'].region_name, None)
+
+    def test_tcp_keepalive_enabled_scoped_config(self):
+        scoped_config = {'tcp_keepalive': 'true'}
+        with mock.patch('botocore.args.EndpointCreator') as m:
+            self.call_get_client_args(scoped_config=scoped_config)
+            self.assert_create_endpoint_call(
+                m,
+                socket_options=self.default_socket_options
+                + [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)],
+            )
+
+    def test_tcp_keepalive_not_specified(self):
+        with mock.patch('botocore.args.EndpointCreator') as m:
+            self.call_get_client_args(scoped_config={}, client_config=None)
+            self.assert_create_endpoint_call(
+                m, socket_options=self.default_socket_options
+            )
+            self.call_get_client_args(
+                scoped_config=None, client_config=Config()
+            )
+            self.assert_create_endpoint_call(
+                m, socket_options=self.default_socket_options
+            )
+
+    def test_tcp_keepalive_enabled_if_set_anywhere(self):
+        with mock.patch('botocore.args.EndpointCreator') as m:
+            self.call_get_client_args(
+                scoped_config={'tcp_keepalive': 'true'},
+                client_config=Config(tcp_keepalive=False),
+            )
+            self.assert_create_endpoint_call(
+                m,
+                socket_options=self.default_socket_options
+                + [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)],
+            )
+            self.call_get_client_args(
+                scoped_config={'tcp_keepalive': 'false'},
+                client_config=Config(tcp_keepalive=True),
+            )
+            self.assert_create_endpoint_call(
+                m,
+                socket_options=self.default_socket_options
+                + [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)],
+            )
+
+    def test_tcp_keepalive_explicitly_disabled(self):
+        scoped_config = {'tcp_keepalive': 'false'}
+        with mock.patch('botocore.args.EndpointCreator') as m:
+            self.call_get_client_args(scoped_config=scoped_config)
+            self.assert_create_endpoint_call(
+                m, socket_options=self.default_socket_options
+            )
+
+    def test_tcp_keepalive_enabled_case_insensitive(self):
+        scoped_config = {'tcp_keepalive': 'True'}
+        with mock.patch('botocore.args.EndpointCreator') as m:
+            self.call_get_client_args(scoped_config=scoped_config)
+            self.assert_create_endpoint_call(
+                m,
+                socket_options=self.default_socket_options
+                + [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)],
+            )
+
+    def test_client_config_has_use_dualstack_endpoint_flag(self):
+        self._set_endpoint_bridge_resolve(metadata={'tags': ['dualstack']})
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('ec2'),
+        )
+        self.assertTrue(client_args['client_config'].use_dualstack_endpoint)
+
+    def test_client_config_has_use_fips_endpoint_flag(self):
+        self._set_endpoint_bridge_resolve(metadata={'tags': ['fips']})
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('ec2'),
+        )
+        self.assertTrue(client_args['client_config'].use_fips_endpoint)
+
+    def test_client_config_has_both_use_fips_and_use_dualstack__endpoint_flags(
+        self,
+    ):
+        self._set_endpoint_bridge_resolve(
+            metadata={'tags': ['fips', 'dualstack']}
+        )
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('ec2'),
+        )
+        self.assertTrue(client_args['client_config'].use_fips_endpoint)
+        self.assertTrue(client_args['client_config'].use_dualstack_endpoint)
+
+    def test_s3_override_use_dualstack_endpoint_flag(self):
+        self._set_endpoint_bridge_resolve(metadata={'tags': ['dualstack']})
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('s3'),
+        )
+        self.assertTrue(
+            client_args['client_config'].s3['use_dualstack_endpoint']
+        )
+
+    def test_sts_override_resolved_endpoint_for_legacy_region(self):
+        self.config_store.set_config_variable(
+            'sts_regional_endpoints', 'legacy'
+        )
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('sts'),
+            region_name='us-west-2',
+            endpoint_url=None,
+        )
+        self.assertEqual(
+            client_args['endpoint'].host, 'https://sts.amazonaws.com'
+        )
+        self.assertEqual(
+            client_args['request_signer'].region_name, 'us-east-1'
+        )
+
+    def test_sts_use_resolved_endpoint_for_nonlegacy_region(self):
+        resolved_endpoint = 'https://resolved-endpoint'
+        resolved_region = 'resolved-region'
+        self._set_endpoint_bridge_resolve(
+            endpoint_url=resolved_endpoint, signing_region=resolved_region
+        )
+        self.config_store.set_config_variable(
+            'sts_regional_endpoints', 'legacy'
+        )
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('sts'),
+            region_name='ap-east-1',
+            endpoint_url=None,
+        )
+        self.assertEqual(client_args['endpoint'].host, resolved_endpoint)
+        self.assertEqual(
+            client_args['request_signer'].region_name, resolved_region
+        )
+
+    def test_sts_use_resolved_endpoint_for_regional_configuration(self):
+        resolved_endpoint = 'https://resolved-endpoint'
+        resolved_region = 'resolved-region'
+        self._set_endpoint_bridge_resolve(
+            endpoint_url=resolved_endpoint, signing_region=resolved_region
+        )
+        self.config_store.set_config_variable(
+            'sts_regional_endpoints', 'regional'
+        )
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('sts'),
+            region_name='us-west-2',
+            endpoint_url=None,
+        )
+        self.assertEqual(client_args['endpoint'].host, resolved_endpoint)
+        self.assertEqual(
+            client_args['request_signer'].region_name, resolved_region
+        )
+
+    def test_sts_with_endpoint_override_and_legacy_configured(self):
+        override_endpoint = 'https://override-endpoint'
+        self._set_endpoint_bridge_resolve(endpoint_url=override_endpoint)
+        self.config_store.set_config_variable(
+            'sts_regional_endpoints', 'legacy'
+        )
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('sts'),
+            region_name='us-west-2',
+            endpoint_url=override_endpoint,
+        )
+        self.assertEqual(client_args['endpoint'].host, override_endpoint)
+
+    def test_sts_http_scheme_for_override_endpoint(self):
+        self.config_store.set_config_variable(
+            'sts_regional_endpoints', 'legacy'
+        )
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('sts'),
+            region_name='us-west-2',
+            endpoint_url=None,
+            is_secure=False,
+        )
+        self.assertEqual(
+            client_args['endpoint'].host, 'http://sts.amazonaws.com'
+        )
+
+    def test_sts_regional_endpoints_defaults_to_legacy_if_not_set(self):
+        self.config_store.set_config_variable('sts_regional_endpoints', None)
+        client_args = self.call_get_client_args(
+            service_model=self._get_service_model('sts'),
+            region_name='us-west-2',
+            endpoint_url=None,
+        )
+        self.assertEqual(
+            client_args['endpoint'].host, 'https://sts.amazonaws.com'
+        )
+        self.assertEqual(
+            client_args['request_signer'].region_name, 'us-east-1'
+        )
+
+    def test_invalid_sts_regional_endpoints(self):
+        self.config_store.set_config_variable(
+            'sts_regional_endpoints', 'invalid'
+        )
+        with self.assertRaises(
+            exceptions.InvalidSTSRegionalEndpointsConfigError
+        ):
+            self.call_get_client_args(
+                service_model=self._get_service_model('sts'),
+                region_name='us-west-2',
+                endpoint_url=None,
+            )
+
+    def test_provides_total_max_attempts(self):
+        config = Config(retries={'total_max_attempts': 10})
+        client_args = self.call_get_client_args(client_config=config)
+        self.assertEqual(
+            client_args['client_config'].retries['total_max_attempts'], 10
+        )
+
+    def test_provides_total_max_attempts_has_precedence(self):
+        config = Config(retries={'total_max_attempts': 10, 'max_attempts': 5})
+        client_args = self.call_get_client_args(client_config=config)
+        self.assertEqual(
+            client_args['client_config'].retries['total_max_attempts'], 10
+        )
+        self.assertNotIn('max_attempts', client_args['client_config'].retries)
+
+    def test_provide_retry_config_maps_total_max_attempts(self):
+        config = Config(retries={'max_attempts': 10})
+        client_args = self.call_get_client_args(client_config=config)
+        self.assertEqual(
+            client_args['client_config'].retries['total_max_attempts'], 11
+        )
+        self.assertNotIn('max_attempts', client_args['client_config'].retries)
+
+    def test_can_merge_max_attempts(self):
+        self.config_store.set_config_variable('max_attempts', 4)
+        config = self.call_get_client_args()['client_config']
+        self.assertEqual(config.retries['total_max_attempts'], 4)
+
+    def test_uses_config_value_if_present_for_max_attempts(self):
+        config = self.call_get_client_args(
+            client_config=Config(retries={'max_attempts': 2})
+        )['client_config']
+        self.assertEqual(config.retries['total_max_attempts'], 3)
+
+    def test_uses_client_config_over_config_store_max_attempts(self):
+        self.config_store.set_config_variable('max_attempts', 4)
+        config = self.call_get_client_args(
+            client_config=Config(retries={'max_attempts': 2})
+        )['client_config']
+        self.assertEqual(config.retries['total_max_attempts'], 3)
+
+    def test_uses_client_config_total_over_config_store_max_attempts(self):
+        self.config_store.set_config_variable('max_attempts', 4)
+        config = self.call_get_client_args(
+            client_config=Config(retries={'total_max_attempts': 2})
+        )['client_config']
+        self.assertEqual(config.retries['total_max_attempts'], 2)
+
+    def test_max_attempts_unset_if_retries_is_none(self):
+        config = self.call_get_client_args(client_config=Config(retries=None))[
+            'client_config'
+        ]
+        self.assertEqual(config.retries, {'mode': 'legacy'})
+
+    def test_retry_mode_set_on_config_store(self):
+        self.config_store.set_config_variable('retry_mode', 'standard')
+        config = self.call_get_client_args()['client_config']
+        self.assertEqual(config.retries['mode'], 'standard')
+
+    def test_retry_mode_set_on_client_config(self):
+        config = self.call_get_client_args(
+            client_config=Config(retries={'mode': 'standard'})
+        )['client_config']
+        self.assertEqual(config.retries['mode'], 'standard')
+
+    def test_connect_timeout_set_on_config_store(self):
+        self.config_store.set_config_variable('connect_timeout', 10)
+        config = self.call_get_client_args(
+            client_config=Config(defaults_mode='standard')
+        )['client_config']
+        self.assertEqual(config.connect_timeout, 10)
+
+    def test_connnect_timeout_set_on_client_config(self):
+        config = self.call_get_client_args(
+            client_config=Config(connect_timeout=10)
+        )['client_config']
+        self.assertEqual(config.connect_timeout, 10)
+
+    def test_connnect_timeout_set_to_client_config_default(self):
+        config = self.call_get_client_args()['client_config']
+        self.assertEqual(config.connect_timeout, 60)
+
+    def test_client_config_beats_config_store(self):
+        self.config_store.set_config_variable('retry_mode', 'adaptive')
+        config = self.call_get_client_args(
+            client_config=Config(retries={'mode': 'standard'})
+        )['client_config']
+        self.assertEqual(config.retries['mode'], 'standard')
+
+    def test_creates_ruleset_resolver_if_given_data(self):
+        with mock.patch('botocore.args.EndpointRulesetResolver') as m:
+            self.call_get_client_args(
+                service_model=self._get_service_model('s3'),
+                endpoints_ruleset_data={
+                    'version': '1.0',
+                    'parameters': {},
+                    'rules': [],
+                },
+            )
+            m.assert_called_once()
+
+    def test_doesnt_create_ruleset_resolver_if_not_given_data(self):
+        with mock.patch('botocore.args.EndpointRulesetResolver') as m:
+            self.call_get_client_args(
+                service_model=self._get_service_model('s3'),
+                endpoints_ruleset_data=None,
+            )
+            m.assert_not_called()
+
+    def test_request_compression_client_config(self):
+        input_config = Config(
+            disable_request_compression=True,
+            request_min_compression_size_bytes=100,
+        )
+        client_args = self.call_get_client_args(client_config=input_config)
+        config = client_args['client_config']
+        self.assertEqual(config.request_min_compression_size_bytes, 100)
+        self.assertTrue(config.disable_request_compression)
+
+    def test_request_compression_config_store(self):
+        self.config_store.set_config_variable(
+            'request_min_compression_size_bytes', 100
+        )
+        self.config_store.set_config_variable(
+            'disable_request_compression', True
+        )
+        config = self.call_get_client_args()['client_config']
+        self.assertEqual(config.request_min_compression_size_bytes, 100)
+        self.assertTrue(config.disable_request_compression)
+
+    def test_request_compression_client_config_overrides_config_store(self):
+        self.config_store.set_config_variable(
+            'request_min_compression_size_bytes', 100
+        )
+        self.config_store.set_config_variable(
+            'disable_request_compression', True
+        )
+        input_config = Config(
+            disable_request_compression=False,
+            request_min_compression_size_bytes=1,
+        )
+        client_args = self.call_get_client_args(client_config=input_config)
+        config = client_args['client_config']
+        self.assertEqual(config.request_min_compression_size_bytes, 1)
+        self.assertFalse(config.disable_request_compression)
+
+    def test_coercible_value_request_min_compression_size_bytes(self):
+        config = Config(request_min_compression_size_bytes='100')
+        client_args = self.call_get_client_args(client_config=config)
+        config = client_args['client_config']
+        self.assertEqual(config.request_min_compression_size_bytes, 100)
+
+    def test_coercible_value_disable_request_compression(self):
+        config = Config(disable_request_compression='true')
+        client_args = self.call_get_client_args(client_config=config)
+        config = client_args['client_config']
+        self.assertTrue(config.disable_request_compression)
+
+    def test_bad_type_request_min_compression_size_bytes(self):
+        with self.assertRaises(exceptions.InvalidConfigError):
+            config = Config(request_min_compression_size_bytes='foo')
+            self.call_get_client_args(client_config=config)
+        self.config_store.set_config_variable(
+            'request_min_compression_size_bytes', 'foo'
+        )
+        with self.assertRaises(exceptions.InvalidConfigError):
+            self.call_get_client_args()
+
+    def test_low_min_request_min_compression_size_bytes(self):
+        with self.assertRaises(exceptions.InvalidConfigError):
+            config = Config(request_min_compression_size_bytes=0)
+            self.call_get_client_args(client_config=config)
+        self.config_store.set_config_variable(
+            'request_min_compression_size_bytes', 0
+        )
+        with self.assertRaises(exceptions.InvalidConfigError):
+            self.call_get_client_args()
+
+    def test_high_max_request_min_compression_size_bytes(self):
+        with self.assertRaises(exceptions.InvalidConfigError):
+            config = Config(request_min_compression_size_bytes=9999999)
+            self.call_get_client_args(client_config=config)
+        self.config_store.set_config_variable(
+            'request_min_compression_size_bytes', 9999999
+        )
+        with self.assertRaises(exceptions.InvalidConfigError):
+            self.call_get_client_args()
+
+    def test_bad_value_disable_request_compression(self):
+        input_config = Config(disable_request_compression='foo')
+        client_args = self.call_get_client_args(client_config=input_config)
+        config = client_args['client_config']
+        self.assertFalse(config.disable_request_compression)
+
+
+class TestEndpointResolverBuiltins(unittest.TestCase):
+    def setUp(self):
+        event_emitter = mock.Mock(HierarchicalEmitter)
+        self.config_store = ConfigValueStore()
+        user_agent_creator = UserAgentString(
+            platform_name=None,
+            platform_version=None,
+            platform_machine=None,
+            python_version=None,
+            python_implementation=None,
+            execution_env=None,
+            crt_version=None,
+        )
+        self.args_create = args.ClientArgsCreator(
+            event_emitter=event_emitter,
+            user_agent=None,
+            response_parser_factory=None,
+            loader=None,
+            exceptions_factory=None,
+            config_store=self.config_store,
+            user_agent_creator=user_agent_creator,
+        )
+        self.bridge = ClientEndpointBridge(
+            endpoint_resolver=mock.Mock(),
+            scoped_config=None,
+            client_config=Config(),
+            default_endpoint=None,
+            service_signing_name=None,
+            config_store=self.config_store,
+        )
+        # assume a legacy endpoint resolver that uses the builtin
+        # endpoints.json file
+        self.bridge.endpoint_resolver.uses_builtin_data = True
+
+    def call_compute_endpoint_resolver_builtin_defaults(self, **overrides):
+        defaults = {
+            'region_name': 'ca-central-1',
+            'service_name': 'fooservice',
+            's3_config': {},
+            'endpoint_bridge': self.bridge,
+            'client_endpoint_url': None,
+            'legacy_endpoint_url': 'https://my.legacy.endpoint.com',
+        }
+        kwargs = {**defaults, **overrides}
+        return self.args_create.compute_endpoint_resolver_builtin_defaults(
+            **kwargs
+        )
+
+    def test_builtins_defaults(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults()
+
+        self.assertEqual(bins['AWS::Region'], 'ca-central-1')
+        self.assertEqual(bins['AWS::UseFIPS'], False)
+        self.assertEqual(bins['AWS::UseDualStack'], False)
+        self.assertEqual(bins['AWS::STS::UseGlobalEndpoint'], True)
+        self.assertEqual(bins['AWS::S3::UseGlobalEndpoint'], False)
+        self.assertEqual(bins['AWS::S3::Accelerate'], False)
+        self.assertEqual(bins['AWS::S3::ForcePathStyle'], False)
+        self.assertEqual(bins['AWS::S3::UseArnRegion'], True)
+        self.assertEqual(bins['AWS::S3Control::UseArnRegion'], False)
+        self.assertEqual(
+            bins['AWS::S3::DisableMultiRegionAccessPoints'], False
+        )
+        self.assertEqual(bins['SDK::Endpoint'], None)
+
+    def test_aws_region(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            region_name='my-region-1',
+        )
+        self.assertEqual(bins['AWS::Region'], 'my-region-1')
+
+    def test_aws_use_fips_when_config_is_set_true(self):
+        self.config_store.set_config_variable('use_fips_endpoint', True)
+        bins = self.call_compute_endpoint_resolver_builtin_defaults()
+        self.assertEqual(bins['AWS::UseFIPS'], True)
+
+    def test_aws_use_fips_when_config_is_set_false(self):
+        self.config_store.set_config_variable('use_fips_endpoint', False)
+        bins = self.call_compute_endpoint_resolver_builtin_defaults()
+        self.assertEqual(bins['AWS::UseFIPS'], False)
+
+    def test_aws_use_dualstack_when_config_is_set_true(self):
+        self.bridge.client_config = Config(s3={'use_dualstack_endpoint': True})
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            service_name='s3-control'
+        )
+        self.assertEqual(bins['AWS::UseDualStack'], True)
+
+    def test_aws_use_dualstack_when_config_is_set_false(self):
+        self.bridge.client_config = Config(
+            s3={'use_dualstack_endpoint': False}
+        )
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            service_name='s3-control'
+        )
+        self.assertEqual(bins['AWS::UseDualStack'], False)
+
+    def test_aws_use_dualstack_when_non_dualstack_service(self):
+        self.bridge.client_config = Config(s3={'use_dualstack_endpoint': True})
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            service_name='other-service'
+        )
+        self.assertEqual(bins['AWS::UseDualStack'], False)
+
+    def test_aws_sts_global_endpoint_with_default_and_legacy_region(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            region_name='us-west-2',
+        )
+        self.assertEqual(bins['AWS::STS::UseGlobalEndpoint'], True)
+
+    def test_aws_sts_global_endpoint_with_default_and_nonlegacy_region(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            region_name='eu-south-1',
+        )
+        self.assertEqual(bins['AWS::STS::UseGlobalEndpoint'], False)
+
+    def test_aws_sts_global_endpoint_with_nondefault_config(self):
+        self.config_store.set_config_variable(
+            'sts_regional_endpoints', 'regional'
+        )
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            region_name='us-west-2',
+        )
+        self.assertEqual(bins['AWS::STS::UseGlobalEndpoint'], False)
+
+    def test_s3_global_endpoint(self):
+        # The only reason for this builtin to not have the default value
+        # (False) is that the ``_should_force_s3_global`` method
+        # returns True.
+        self.args_create._should_force_s3_global = mock.Mock(return_value=True)
+        bins = self.call_compute_endpoint_resolver_builtin_defaults()
+        self.assertTrue(bins['AWS::S3::UseGlobalEndpoint'])
+        self.args_create._should_force_s3_global.assert_called_once()
+
+    def test_s3_accelerate_with_config_set_true(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'use_accelerate_endpoint': True},
+        )
+        self.assertEqual(bins['AWS::S3::Accelerate'], True)
+
+    def test_s3_accelerate_with_config_set_false(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'use_accelerate_endpoint': False},
+        )
+        self.assertEqual(bins['AWS::S3::Accelerate'], False)
+
+    def test_force_path_style_with_config_set_to_path(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'addressing_style': 'path'},
+        )
+        self.assertEqual(bins['AWS::S3::ForcePathStyle'], True)
+
+    def test_force_path_style_with_config_set_to_auto(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'addressing_style': 'auto'},
+        )
+        self.assertEqual(bins['AWS::S3::ForcePathStyle'], False)
+
+    def test_force_path_style_with_config_set_to_virtual(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'addressing_style': 'virtual'},
+        )
+        self.assertEqual(bins['AWS::S3::ForcePathStyle'], False)
+
+    def test_use_arn_region_with_config_set_false(self):
+        # These two builtins both take their value from the ``use_arn_region``
+        # in the S3 configuration, but have different default values.
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'use_arn_region': False},
+        )
+        self.assertEqual(bins['AWS::S3::UseArnRegion'], False)
+        self.assertEqual(bins['AWS::S3Control::UseArnRegion'], False)
+
+    def test_use_arn_region_with_config_set_true(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'use_arn_region': True},
+        )
+        self.assertEqual(bins['AWS::S3::UseArnRegion'], True)
+        self.assertEqual(bins['AWS::S3Control::UseArnRegion'], True)
+
+    def test_disable_mrap_with_config_set_true(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'s3_disable_multiregion_access_points': True},
+        )
+        self.assertEqual(bins['AWS::S3::DisableMultiRegionAccessPoints'], True)
+
+    def test_disable_mrap_with_config_set_false(self):
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            s3_config={'s3_disable_multiregion_access_points': False},
+        )
+        self.assertEqual(
+            bins['AWS::S3::DisableMultiRegionAccessPoints'], False
+        )
+
+    def test_sdk_endpoint_both_inputs_set(self):
+        # assume a legacy endpoint resolver that uses a customized
+        # endpoints.json file
+        self.bridge.endpoint_resolver.uses_builtin_data = False
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            client_endpoint_url='https://my.client.endpoint.com',
+            legacy_endpoint_url='https://my.legacy.endpoint.com',
+        )
+        self.assertEqual(
+            bins['SDK::Endpoint'], 'https://my.client.endpoint.com'
+        )
+
+    def test_sdk_endpoint_legacy_set_with_builtin_data(self):
+        # assume a legacy endpoint resolver that uses a customized
+        # endpoints.json file
+        self.bridge.endpoint_resolver.uses_builtin_data = False
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            client_endpoint_url=None,
+            legacy_endpoint_url='https://my.legacy.endpoint.com',
+        )
+        self.assertEqual(
+            bins['SDK::Endpoint'], 'https://my.legacy.endpoint.com'
+        )
+
+    def test_sdk_endpoint_legacy_set_without_builtin_data(self):
+        # assume a legacy endpoint resolver that uses the builtin
+        # endpoints.json file
+        self.bridge.endpoint_resolver.uses_builtin_data = True
+        bins = self.call_compute_endpoint_resolver_builtin_defaults(
+            client_endpoint_url=None,
+            legacy_endpoint_url='https://my.legacy.endpoint.com',
+        )
+        self.assertEqual(bins['SDK::Endpoint'], None)

testbed/boto__botocore/tests/unit/test_auth_bearer.py

@@ -0,0 +1,72 @@
+# Copyright 2022 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import pytest
+
+from botocore.auth import BearerAuth
+from botocore.awsrequest import AWSRequest
+from botocore.exceptions import NoAuthTokenError
+from botocore.tokens import FrozenAuthToken
+
+cases = [
+    {
+        "documentation": "Minimal bearer auth case",
+        "headers": {},
+        "token": "mF_9.B5f-4.1JqM",
+        "expectedHeaders": {"Authorization": "Bearer mF_9.B5f-4.1JqM"},
+    },
+    {
+        "documentation": "Longer token case",
+        "headers": {},
+        "token": "eW91J3JlIG5vdCBzdXBwb3NlZCB0byBkZWNvZGUgdGhpcyE=",
+        "expectedHeaders": {
+            "Authorization": "Bearer eW91J3JlIG5vdCBzdXBwb3NlZCB0byBkZWNvZGUgdGhpcyE="
+        },
+    },
+    {
+        "documentation": "Signer should override existing header",
+        "headers": {"Authorization": "Bearer foo"},
+        "token": "mF_9.B5f-4.1JqM",
+        "expectedHeaders": {"Authorization": "Bearer mF_9.B5f-4.1JqM"},
+    },
+    {
+        "documentation": "Signer requires a token",
+        "headers": {},
+        "token": None,
+        "expectedException": NoAuthTokenError,
+    },
+]
+
+
+@pytest.mark.parametrize("test_case", cases)
+def test_bearer_auth(test_case):
+    url = "https://example.com"
+    headers = test_case.get("headers", {})
+    request = AWSRequest(method="GET", url=url, headers=headers)
+
+    auth_token = None
+    raw_token = test_case["token"]
+    if raw_token:
+        auth_token = FrozenAuthToken(test_case["token"], expiration=None)
+
+    bearer_auth = BearerAuth(auth_token)
+    expected_headers = test_case.get("expectedHeaders")
+    expected_exception = test_case.get("expectedException")
+    if expected_headers:
+        bearer_auth.add_auth(request)
+        for name in expected_headers:
+            actual_header = request.headers[name]
+            expected_header = expected_headers[name]
+            assert actual_header == expected_header
+    elif expected_exception:
+        with pytest.raises(expected_exception):
+            bearer_auth.add_auth(request)

testbed/boto__botocore/tests/unit/test_auth_sigv4.py

@@ -0,0 +1,53 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+from botocore.auth import SigV4Auth
+from botocore.awsrequest import AWSRequest
+from botocore.credentials import Credentials
+from tests import unittest
+
+SECRET_KEY = "wJalrXUtnFEMI/K7MDENG+bPxRfiCYEXAMPLEKEY"
+ACCESS_KEY = 'AKIDEXAMPLE'
+
+
+class TestSigV4Auth(unittest.TestCase):
+    def setUp(self):
+        self.credentials = Credentials(ACCESS_KEY, SECRET_KEY)
+        self.sigv4 = SigV4Auth(self.credentials, 'host', 'us-weast-1')
+
+    def test_signed_host_is_lowercase(self):
+        endpoint = 'https://S5.Us-WeAsT-2.AmAZonAwS.com'
+        expected_host = 's5.us-weast-2.amazonaws.com'
+        request = AWSRequest(method='GET', url=endpoint)
+        headers_to_sign = self.sigv4.headers_to_sign(request)
+        self.assertEqual(expected_host, headers_to_sign.get('host'))
+
+    def test_signed_host_is_ipv6_without_port(self):
+        endpoint = 'http://[::1]'
+        expected_host = '[::1]'
+        request = AWSRequest(method='GET', url=endpoint)
+        headers_to_sign = self.sigv4.headers_to_sign(request)
+        self.assertEqual(expected_host, headers_to_sign.get('host'))
+
+    def test_signed_host_is_ipv6_with_default_port(self):
+        endpoint = 'http://[::1]:80'
+        expected_host = '[::1]'
+        request = AWSRequest(method='GET', url=endpoint)
+        headers_to_sign = self.sigv4.headers_to_sign(request)
+        self.assertEqual(expected_host, headers_to_sign.get('host'))
+
+    def test_signed_host_is_ipv6_with_explicit_port(self):
+        endpoint = 'http://[::1]:6789'
+        expected_host = '[::1]:6789'
+        request = AWSRequest(method='GET', url=endpoint)
+        headers_to_sign = self.sigv4.headers_to_sign(request)
+        self.assertEqual(expected_host, headers_to_sign.get('host'))

testbed/boto__botocore/tests/unit/test_awsrequest.py

@@ -0,0 +1,802 @@
+#!/usr/bin/env
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+import io
+import os
+import shutil
+import socket
+import tempfile
+
+import pytest
+from urllib3.connectionpool import HTTPConnectionPool, HTTPSConnectionPool
+
+from botocore.awsrequest import (
+    AWSHTTPConnection,
+    AWSHTTPSConnection,
+    AWSRequest,
+    AWSResponse,
+    HeadersDict,
+    create_request_object,
+    prepare_request_dict,
+)
+from botocore.compat import file_type
+from botocore.exceptions import UnseekableStreamError
+from tests import mock, unittest
+
+
+class IgnoreCloseBytesIO(io.BytesIO):
+    def close(self):
+        pass
+
+
+class FakeSocket:
+    def __init__(self, read_data, fileclass=IgnoreCloseBytesIO):
+        self.sent_data = b''
+        self.read_data = read_data
+        self.fileclass = fileclass
+        self._fp_object = None
+
+    def sendall(self, data):
+        self.sent_data += data
+
+    def makefile(self, mode, bufsize=None):
+        if self._fp_object is None:
+            self._fp_object = self.fileclass(self.read_data)
+        return self._fp_object
+
+    def close(self):
+        pass
+
+    def settimeout(self, value):
+        pass
+
+
+class BytesIOWithLen(io.BytesIO):
+    def __len__(self):
+        return len(self.getvalue())
+
+
+class Unseekable(file_type):
+    def __init__(self, stream):
+        self._stream = stream
+
+    def read(self):
+        return self._stream.read()
+
+    def seek(self, offset, whence):
+        # This is a case where seek() exists as part of the object's interface,
+        # but it doesn't actually work (for example socket.makefile(), which
+        # will raise an io.* error on python3).
+        raise ValueError("Underlying stream does not support seeking.")
+
+
+class Seekable:
+    """This class represents a bare-bones,seekable file-like object
+
+    Note it does not include some of the other attributes of other
+    file-like objects such as StringIO's getvalue() and file object's fileno
+    property. If the file-like object does not have either of these attributes
+    requests will not calculate the content length even though it is still
+    possible to calculate it.
+    """
+
+    def __init__(self, stream):
+        self._stream = stream
+
+    def __iter__(self):
+        return iter(self._stream)
+
+    def read(self):
+        return self._stream.read()
+
+    def seek(self, offset, whence=0):
+        self._stream.seek(offset, whence)
+
+    def tell(self):
+        return self._stream.tell()
+
+
+class TestAWSRequest(unittest.TestCase):
+    def setUp(self):
+        self.tempdir = tempfile.mkdtemp()
+        self.filename = os.path.join(self.tempdir, 'foo')
+        self.request = AWSRequest(method='GET', url='http://example.com')
+        self.prepared_request = self.request.prepare()
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+
+    def test_prepared_request_repr(self):
+        expected_repr = (
+            '<AWSPreparedRequest stream_output=False, method=GET, '
+            'url=http://example.com, headers={}>'
+        )
+        request_repr = repr(self.prepared_request)
+        self.assertEqual(request_repr, expected_repr)
+
+    def test_can_prepare_url_params(self):
+        request = AWSRequest(url='http://example.com/', params={'foo': 'bar'})
+        prepared_request = request.prepare()
+        self.assertEqual(prepared_request.url, 'http://example.com/?foo=bar')
+
+    def test_can_prepare_url_params_with_existing_query(self):
+        request = AWSRequest(
+            url='http://example.com/?bar=foo', params={'foo': 'bar'}
+        )
+        prepared_request = request.prepare()
+        self.assertEqual(
+            prepared_request.url, 'http://example.com/?bar=foo&foo=bar'
+        )
+
+    def test_can_prepare_dict_body(self):
+        body = {'dead': 'beef'}
+        request = AWSRequest(url='http://example.com/', data=body)
+        prepared_request = request.prepare()
+        self.assertEqual(prepared_request.body, 'dead=beef')
+
+    def test_can_prepare_dict_body_unicode_values(self):
+        body = {'Text': '\u30c6\u30b9\u30c8 string'}
+        expected_body = 'Text=%E3%83%86%E3%82%B9%E3%83%88+string'
+        request = AWSRequest(url='http://example.com/', data=body)
+        prepared_request = request.prepare()
+        self.assertEqual(prepared_request.body, expected_body)
+
+    def test_can_prepare_dict_body_unicode_keys(self):
+        body = {'\u30c6\u30b9\u30c8': 'string'}
+        expected_body = '%E3%83%86%E3%82%B9%E3%83%88=string'
+        request = AWSRequest(url='http://example.com/', data=body)
+        prepared_request = request.prepare()
+        self.assertEqual(prepared_request.body, expected_body)
+
+    def test_can_prepare_empty_body(self):
+        request = AWSRequest(url='http://example.com/', data=b'')
+        prepared_request = request.prepare()
+        self.assertEqual(prepared_request.body, None)
+        content_length = prepared_request.headers.get('content-length')
+        self.assertEqual(content_length, '0')
+
+    def test_request_body_is_prepared(self):
+        request = AWSRequest(url='http://example.com/', data='body')
+        self.assertEqual(request.body, b'body')
+
+    def test_prepare_body_content_adds_content_length(self):
+        content = b'foobarbaz'
+        expected_len = str(len(content))
+        with open(self.filename, 'wb') as f:
+            f.write(content)
+        with open(self.filename, 'rb') as f:
+            data = Seekable(f)
+            self.request.data = data
+            self.request.method = 'POST'
+            prepared_request = self.request.prepare()
+            calculated_len = prepared_request.headers['Content-Length']
+            self.assertEqual(calculated_len, expected_len)
+
+    def test_prepare_body_doesnt_override_content_length(self):
+        self.request.method = 'PUT'
+        self.request.headers['Content-Length'] = '20'
+        self.request.data = b'asdf'
+        prepared_request = self.request.prepare()
+        self.assertEqual(prepared_request.headers['Content-Length'], '20')
+
+    def test_prepare_body_doesnt_set_content_length_head(self):
+        self.request.method = 'HEAD'
+        self.request.data = b'thisshouldntbehere'
+        prepared_request = self.request.prepare()
+        self.assertEqual(prepared_request.headers.get('Content-Length'), None)
+
+    def test_prepare_body_doesnt_set_content_length_get(self):
+        self.request.method = 'GET'
+        self.request.data = b'thisshouldntbehere'
+        prepared_request = self.request.prepare()
+        self.assertEqual(prepared_request.headers.get('Content-Length'), None)
+
+    def test_prepare_body_doesnt_set_content_length_options(self):
+        self.request.method = 'OPTIONS'
+        self.request.data = b'thisshouldntbehere'
+        prepared_request = self.request.prepare()
+        self.assertEqual(prepared_request.headers.get('Content-Length'), None)
+
+    def test_can_reset_stream_handles_binary(self):
+        contents = b'notastream'
+        self.prepared_request.body = contents
+        self.prepared_request.reset_stream()
+        # assert the request body doesn't change after reset_stream is called
+        self.assertEqual(self.prepared_request.body, contents)
+
+    def test_can_reset_stream_handles_bytearray(self):
+        contents = bytearray(b'notastream')
+        self.prepared_request.body = contents
+        self.prepared_request.reset_stream()
+        # assert the request body doesn't change after reset_stream is called
+        self.assertEqual(self.prepared_request.body, contents)
+
+    def test_can_reset_stream(self):
+        contents = b'foobarbaz'
+        with open(self.filename, 'wb') as f:
+            f.write(contents)
+        with open(self.filename, 'rb') as body:
+            self.prepared_request.body = body
+            # pretend the request body was partially sent
+            body.read()
+            self.assertNotEqual(body.tell(), 0)
+            # have the prepared request reset its stream
+            self.prepared_request.reset_stream()
+            # the stream should be reset
+            self.assertEqual(body.tell(), 0)
+
+    def test_cannot_reset_stream_raises_error(self):
+        contents = b'foobarbaz'
+        with open(self.filename, 'wb') as f:
+            f.write(contents)
+        with open(self.filename, 'rb') as body:
+            self.prepared_request.body = Unseekable(body)
+            # pretend the request body was partially sent
+            body.read()
+            self.assertNotEqual(body.tell(), 0)
+            # reset stream should fail
+            with self.assertRaises(UnseekableStreamError):
+                self.prepared_request.reset_stream()
+
+    def test_duck_type_for_file_check(self):
+        # As part of determining whether or not we can rewind a stream
+        # we first need to determine if the thing is a file like object.
+        # We should not be using an isinstance check.  Instead, we should
+        # be using duck type checks.
+
+        class LooksLikeFile:
+            def __init__(self):
+                self.seek_called = False
+
+            def read(self, amount=None):
+                pass
+
+            def seek(self, where):
+                self.seek_called = True
+
+        looks_like_file = LooksLikeFile()
+        self.prepared_request.body = looks_like_file
+        self.prepared_request.reset_stream()
+        # The stream should now be reset.
+        self.assertTrue(looks_like_file.seek_called)
+
+
+@pytest.mark.parametrize(
+    "test_input,expected_output",
+    [
+        ([('foo', None)], 'http://example.com/?foo=None'),
+        ([(None, None)], 'http://example.com/?None=None'),
+        (
+            [('foo', 'bar'), ('foo', 'baz'), ('fizz', 'buzz')],
+            'http://example.com/?foo=bar&foo=baz&fizz=buzz',
+        ),
+        (
+            [('foo', 'bar'), ('foo', None)],
+            'http://example.com/?foo=bar&foo=None',
+        ),
+        ([('foo', 'bar')], 'http://example.com/?foo=bar'),
+        (
+            [('foo', 'bar'), ('foo', 'bar'), ('fizz', 'buzz')],
+            'http://example.com/?foo=bar&foo=bar&fizz=buzz',
+        ),
+        ([('', 'bar')], 'http://example.com/?=bar'),
+        ([(1, 'bar')], 'http://example.com/?1=bar'),
+    ],
+)
+def test_can_use_list_tuples_for_params(test_input, expected_output):
+    request = AWSRequest(url='http://example.com/', params=test_input)
+    prepared_request = request.prepare()
+    assert prepared_request.url == expected_output
+
+
+def test_empty_list_tuples_value_error_for_params():
+    request = AWSRequest(url='http://example.com/', params=[()])
+    with pytest.raises(ValueError):
+        request.prepare()
+
+
+class TestAWSResponse(unittest.TestCase):
+    def setUp(self):
+        self.response = AWSResponse('http://url.com', 200, HeadersDict(), None)
+        self.response.raw = mock.Mock()
+
+    def set_raw_stream(self, blobs):
+        def stream(*args, **kwargs):
+            yield from blobs
+
+        self.response.raw.stream.return_value = stream()
+
+    def test_content_property(self):
+        self.set_raw_stream([b'some', b'data'])
+        self.assertEqual(self.response.content, b'somedata')
+        self.assertEqual(self.response.content, b'somedata')
+        # assert that stream was not called more than once
+        self.assertEqual(self.response.raw.stream.call_count, 1)
+
+    def test_text_property(self):
+        self.set_raw_stream([b'\xe3\x82\xb8\xe3\x83\xa7\xe3\x82\xb0'])
+        self.response.headers['content-type'] = 'text/plain; charset=utf-8'
+        self.assertEqual(self.response.text, '\u30b8\u30e7\u30b0')
+
+    def test_text_property_defaults_utf8(self):
+        self.set_raw_stream([b'\xe3\x82\xb8\xe3\x83\xa7\xe3\x82\xb0'])
+        self.assertEqual(self.response.text, '\u30b8\u30e7\u30b0')
+
+
+class TestAWSHTTPConnection(unittest.TestCase):
+    def create_tunneled_connection(self, url, port, response):
+        s = FakeSocket(response)
+        conn = AWSHTTPConnection(url, port)
+        conn.sock = s
+        conn._tunnel_host = url
+        conn._tunnel_port = port
+        conn._tunnel_headers = {'key': 'value'}
+
+        # Create a mock response.
+        self.mock_response = mock.Mock()
+        self.mock_response.fp = mock.Mock()
+
+        # Imitate readline function by creating a list to be sent as
+        # a side effect of the mocked readline to be able to track how the
+        # response is processed in ``_tunnel()``.
+        delimeter = b'\r\n'
+        side_effect = []
+        response_components = response.split(delimeter)
+        for i in range(len(response_components)):
+            new_component = response_components[i]
+            # Only add the delimeter on if it is not the last component
+            # which should be an empty string.
+            if i != len(response_components) - 1:
+                new_component += delimeter
+            side_effect.append(new_component)
+
+        self.mock_response.fp.readline.side_effect = side_effect
+
+        response_components = response.split(b' ')
+        self.mock_response._read_status.return_value = (
+            response_components[0],
+            int(response_components[1]),
+            response_components[2],
+        )
+        conn.response_class = mock.Mock()
+        conn.response_class.return_value = self.mock_response
+        return conn
+
+    def test_expect_100_continue_returned(self):
+        with mock.patch('urllib3.util.wait_for_read') as wait_mock:
+            # Shows the server first sending a 100 continue response
+            # then a 200 ok response.
+            s = FakeSocket(b'HTTP/1.1 100 Continue\r\n\r\nHTTP/1.1 200 OK\r\n')
+            conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+            conn.sock = s
+            wait_mock.return_value = True
+            conn.request(
+                'GET', '/bucket/foo', b'body', {'Expect': b'100-continue'}
+            )
+            response = conn.getresponse()
+            # Assert that we waited for the 100-continue response
+            self.assertEqual(wait_mock.call_count, 1)
+            # Now we should verify that our final response is the 200 OK
+            self.assertEqual(response.status, 200)
+
+    def test_handles_expect_100_with_different_reason_phrase(self):
+        with mock.patch('urllib3.util.wait_for_read') as wait_mock:
+            # Shows the server first sending a 100 continue response
+            # then a 200 ok response.
+            s = FakeSocket(
+                b'HTTP/1.1 100 (Continue)\r\n\r\nHTTP/1.1 200 OK\r\n'
+            )
+            conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+            conn.sock = s
+            wait_mock.return_value = True
+            conn.request(
+                'GET',
+                '/bucket/foo',
+                io.BytesIO(b'body'),
+                {'Expect': b'100-continue', 'Content-Length': b'4'},
+            )
+            response = conn.getresponse()
+            # Now we should verify that our final response is the 200 OK.
+            self.assertEqual(response.status, 200)
+            # Assert that we waited for the 100-continue response
+            self.assertEqual(wait_mock.call_count, 1)
+            # Verify that we went the request body because we got a 100
+            # continue.
+            self.assertIn(b'body', s.sent_data)
+
+    def test_expect_100_sends_connection_header(self):
+        # When using squid as an HTTP proxy, it will also send
+        # a Connection: keep-alive header back with the 100 continue
+        # response.  We need to ensure we handle this case.
+        with mock.patch('urllib3.util.wait_for_read') as wait_mock:
+            # Shows the server first sending a 100 continue response
+            # then a 500 response.  We're picking 500 to confirm we
+            # actually parse the response instead of getting the
+            # default status of 200 which happens when we can't parse
+            # the response.
+            s = FakeSocket(
+                b'HTTP/1.1 100 Continue\r\n'
+                b'Connection: keep-alive\r\n'
+                b'\r\n'
+                b'HTTP/1.1 500 Internal Service Error\r\n'
+            )
+            conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+            conn.sock = s
+            wait_mock.return_value = True
+            conn.request(
+                'GET', '/bucket/foo', b'body', {'Expect': b'100-continue'}
+            )
+            # Assert that we waited for the 100-continue response
+            self.assertEqual(wait_mock.call_count, 1)
+            response = conn.getresponse()
+            self.assertEqual(response.status, 500)
+
+    def test_expect_100_continue_sends_307(self):
+        # This is the case where we send a 100 continue and the server
+        # immediately sends a 307
+        with mock.patch('urllib3.util.wait_for_read') as wait_mock:
+            # Shows the server first sending a 100 continue response
+            # then a 200 ok response.
+            s = FakeSocket(
+                b'HTTP/1.1 307 Temporary Redirect\r\n'
+                b'Location: http://example.org\r\n'
+            )
+            conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+            conn.sock = s
+            wait_mock.return_value = True
+            conn.request(
+                'GET', '/bucket/foo', b'body', {'Expect': b'100-continue'}
+            )
+            # Assert that we waited for the 100-continue response
+            self.assertEqual(wait_mock.call_count, 1)
+            response = conn.getresponse()
+            # Now we should verify that our final response is the 307.
+            self.assertEqual(response.status, 307)
+
+    def test_expect_100_continue_no_response_from_server(self):
+        with mock.patch('urllib3.util.wait_for_read') as wait_mock:
+            # Shows the server first sending a 100 continue response
+            # then a 200 ok response.
+            s = FakeSocket(
+                b'HTTP/1.1 307 Temporary Redirect\r\n'
+                b'Location: http://example.org\r\n'
+            )
+            conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+            conn.sock = s
+            # By settings wait_mock to return False, this indicates
+            # that the server did not send any response.  In this situation
+            # we should just send the request anyways.
+            wait_mock.return_value = False
+            conn.request(
+                'GET', '/bucket/foo', b'body', {'Expect': b'100-continue'}
+            )
+            # Assert that we waited for the 100-continue response
+            self.assertEqual(wait_mock.call_count, 1)
+            response = conn.getresponse()
+            self.assertEqual(response.status, 307)
+
+    def test_message_body_is_file_like_object(self):
+        # Shows the server first sending a 100 continue response
+        # then a 200 ok response.
+        body = BytesIOWithLen(b'body contents')
+        s = FakeSocket(b'HTTP/1.1 200 OK\r\n')
+        conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+        conn.sock = s
+        conn.request('GET', '/bucket/foo', body)
+        response = conn.getresponse()
+        self.assertEqual(response.status, 200)
+
+    def test_no_expect_header_set(self):
+        # Shows the server first sending a 100 continue response
+        # then a 200 ok response.
+        s = FakeSocket(b'HTTP/1.1 200 OK\r\n')
+        conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+        conn.sock = s
+        conn.request('GET', '/bucket/foo', b'body')
+        response = conn.getresponse()
+        self.assertEqual(response.status, 200)
+
+    def test_tunnel_readline_none_bugfix(self):
+        # Tests whether ``_tunnel`` function is able to work around the
+        # py26 bug of avoiding infinite while loop if nothing is returned.
+        conn = self.create_tunneled_connection(
+            url='s3.amazonaws.com',
+            port=443,
+            response=b'HTTP/1.1 200 OK\r\n',
+        )
+        conn._tunnel()
+        # Ensure proper amount of readline calls were made.
+        self.assertEqual(self.mock_response.fp.readline.call_count, 2)
+
+    def test_tunnel_readline_normal(self):
+        # Tests that ``_tunnel`` function behaves normally when it comes
+        # across the usual http ending.
+        conn = self.create_tunneled_connection(
+            url='s3.amazonaws.com',
+            port=443,
+            response=b'HTTP/1.1 200 OK\r\n\r\n',
+        )
+        conn._tunnel()
+        # Ensure proper amount of readline calls were made.
+        self.assertEqual(self.mock_response.fp.readline.call_count, 2)
+
+    def test_tunnel_raises_socket_error(self):
+        # Tests that ``_tunnel`` function throws appropriate error when
+        # not 200 status.
+        conn = self.create_tunneled_connection(
+            url='s3.amazonaws.com',
+            port=443,
+            response=b'HTTP/1.1 404 Not Found\r\n\r\n',
+        )
+        with self.assertRaises(socket.error):
+            conn._tunnel()
+
+    def test_tunnel_uses_std_lib(self):
+        s = FakeSocket(b'HTTP/1.1 200 OK\r\n')
+        conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+        conn.sock = s
+        # Test that the standard library method was used by patching out
+        # the ``_tunnel`` method and seeing if the std lib method was called.
+        with mock.patch(
+            'urllib3.connection.HTTPConnection._tunnel'
+        ) as mock_tunnel:
+            conn._tunnel()
+            self.assertTrue(mock_tunnel.called)
+
+    def test_encodes_unicode_method_line(self):
+        s = FakeSocket(b'HTTP/1.1 200 OK\r\n')
+        conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+        conn.sock = s
+        # Note the combination of unicode 'GET' and
+        # bytes 'Utf8-Header' value.
+        conn.request(
+            'GET',
+            '/bucket/foo',
+            b'body',
+            headers={"Utf8-Header": b"\xe5\xb0\x8f"},
+        )
+        response = conn.getresponse()
+        self.assertEqual(response.status, 200)
+
+    def test_state_reset_on_connection_close(self):
+        # This simulates what urllib3 does with connections
+        # in its connection pool logic.
+        with mock.patch('urllib3.util.wait_for_read') as wait_mock:
+            # First fast fail with a 500 response when we first
+            # send the expect header.
+            s = FakeSocket(b'HTTP/1.1 500 Internal Server Error\r\n')
+            conn = AWSHTTPConnection('s3.amazonaws.com', 443)
+            conn.sock = s
+            wait_mock.return_value = True
+
+            conn.request(
+                'GET', '/bucket/foo', b'body', {'Expect': b'100-continue'}
+            )
+            self.assertEqual(wait_mock.call_count, 1)
+            response = conn.getresponse()
+            self.assertEqual(response.status, 500)
+
+            # Now what happens in urllib3 is that when the next
+            # request comes along and this conection gets checked
+            # out.  We see that the connection needs to be
+            # reset.  So first the connection is closed.
+            conn.close()
+
+            # And then a new connection is established.
+            new_conn = FakeSocket(
+                b'HTTP/1.1 100 (Continue)\r\n\r\nHTTP/1.1 200 OK\r\n'
+            )
+            conn.sock = new_conn
+
+            # And we make a request, we should see the 200 response
+            # that was sent back.
+            wait_mock.return_value = True
+
+            conn.request(
+                'GET', '/bucket/foo', b'body', {'Expect': b'100-continue'}
+            )
+            # Assert that we waited for the 100-continue response
+            self.assertEqual(wait_mock.call_count, 2)
+            response = conn.getresponse()
+            # This should be 200.  If it's a 500 then
+            # the prior response was leaking into our
+            # current response.,
+            self.assertEqual(response.status, 200)
+
+
+class TestAWSHTTPConnectionPool(unittest.TestCase):
+    def test_global_urllib3_pool_is_unchanged(self):
+        http_connection_class = HTTPConnectionPool.ConnectionCls
+        self.assertIsNot(http_connection_class, AWSHTTPConnection)
+        https_connection_class = HTTPSConnectionPool.ConnectionCls
+        self.assertIsNot(https_connection_class, AWSHTTPSConnection)
+
+
+class TestPrepareRequestDict(unittest.TestCase):
+    def setUp(self):
+        self.user_agent = 'botocore/1.0'
+        self.endpoint_url = 'https://s3.amazonaws.com'
+        self.base_request_dict = {
+            'body': '',
+            'headers': {},
+            'method': 'GET',
+            'query_string': '',
+            'url_path': '/',
+            'context': {},
+        }
+
+    def prepare_base_request_dict(
+        self, request_dict, endpoint_url=None, user_agent=None, context=None
+    ):
+        self.base_request_dict.update(request_dict)
+        context = context or {}
+        if user_agent is None:
+            user_agent = self.user_agent
+        if endpoint_url is None:
+            endpoint_url = self.endpoint_url
+        prepare_request_dict(
+            self.base_request_dict,
+            endpoint_url=endpoint_url,
+            user_agent=user_agent,
+            context=context,
+        )
+
+    def test_prepare_request_dict_for_get(self):
+        request_dict = {'method': 'GET', 'url_path': '/'}
+        self.prepare_base_request_dict(
+            request_dict, endpoint_url='https://s3.amazonaws.com'
+        )
+        self.assertEqual(self.base_request_dict['method'], 'GET')
+        self.assertEqual(
+            self.base_request_dict['url'], 'https://s3.amazonaws.com/'
+        )
+        self.assertEqual(
+            self.base_request_dict['headers']['User-Agent'], self.user_agent
+        )
+
+    def test_prepare_request_dict_for_get_no_user_agent(self):
+        self.user_agent = None
+        request_dict = {'method': 'GET', 'url_path': '/'}
+        self.prepare_base_request_dict(
+            request_dict, endpoint_url='https://s3.amazonaws.com'
+        )
+        self.assertNotIn('User-Agent', self.base_request_dict['headers'])
+
+    def test_prepare_request_dict_with_context(self):
+        context = {'foo': 'bar'}
+        self.prepare_base_request_dict({}, context=context)
+        self.assertEqual(self.base_request_dict['context'], context)
+
+    def test_query_string_serialized_to_url(self):
+        request_dict = {
+            'method': 'GET',
+            'query_string': {'prefix': 'foo'},
+            'url_path': '/mybucket',
+        }
+        self.prepare_base_request_dict(request_dict)
+        self.assertEqual(
+            self.base_request_dict['url'],
+            'https://s3.amazonaws.com/mybucket?prefix=foo',
+        )
+
+    def test_url_path_combined_with_endpoint_url(self):
+        # This checks the case where a user specifies and
+        # endpoint_url that has a path component, and the
+        # serializer gives us a request_dict that has a url
+        # component as well (say from a rest-* service).
+        request_dict = {
+            'query_string': {'prefix': 'foo'},
+            'url_path': '/mybucket',
+        }
+        endpoint_url = 'https://custom.endpoint/foo/bar'
+        self.prepare_base_request_dict(request_dict, endpoint_url)
+        self.assertEqual(
+            self.base_request_dict['url'],
+            'https://custom.endpoint/foo/bar/mybucket?prefix=foo',
+        )
+
+    def test_url_path_with_trailing_slash(self):
+        self.prepare_base_request_dict(
+            {'url_path': '/mybucket'},
+            endpoint_url='https://custom.endpoint/foo/bar/',
+        )
+
+        self.assertEqual(
+            self.base_request_dict['url'],
+            'https://custom.endpoint/foo/bar/mybucket',
+        )
+
+    def test_url_path_is_slash(self):
+        self.prepare_base_request_dict(
+            {'url_path': '/'}, endpoint_url='https://custom.endpoint/foo/bar/'
+        )
+
+        self.assertEqual(
+            self.base_request_dict['url'], 'https://custom.endpoint/foo/bar/'
+        )
+
+    def test_url_path_is_slash_with_endpoint_url_no_slash(self):
+        self.prepare_base_request_dict(
+            {'url_path': '/'}, endpoint_url='https://custom.endpoint/foo/bar'
+        )
+
+        self.assertEqual(
+            self.base_request_dict['url'], 'https://custom.endpoint/foo/bar'
+        )
+
+    def test_custom_endpoint_with_query_string(self):
+        self.prepare_base_request_dict(
+            {'url_path': '/baz', 'query_string': {'x': 'y'}},
+            endpoint_url='https://custom.endpoint/foo/bar?foo=bar',
+        )
+
+        self.assertEqual(
+            self.base_request_dict['url'],
+            'https://custom.endpoint/foo/bar/baz?foo=bar&x=y',
+        )
+
+
+class TestCreateRequestObject(unittest.TestCase):
+    def setUp(self):
+        self.request_dict = {
+            'method': 'GET',
+            'query_string': {'prefix': 'foo'},
+            'url_path': '/mybucket',
+            'headers': {'User-Agent': 'my-agent'},
+            'body': 'my body',
+            'url': 'https://s3.amazonaws.com/mybucket?prefix=foo',
+            'context': {'signing': {'region': 'us-west-2'}},
+        }
+
+    def test_create_request_object(self):
+        request = create_request_object(self.request_dict)
+        self.assertEqual(request.method, self.request_dict['method'])
+        self.assertEqual(request.url, self.request_dict['url'])
+        self.assertEqual(request.data, self.request_dict['body'])
+        self.assertEqual(request.context, self.request_dict['context'])
+        self.assertIn('User-Agent', request.headers)
+
+
+class TestHeadersDict(unittest.TestCase):
+    def setUp(self):
+        self.headers = HeadersDict()
+
+    def test_get_insensitive(self):
+        self.headers['foo'] = 'bar'
+        self.assertEqual(self.headers['FOO'], 'bar')
+
+    def test_set_insensitive(self):
+        self.headers['foo'] = 'bar'
+        self.headers['FOO'] = 'baz'
+        self.assertEqual(self.headers['foo'], 'baz')
+
+    def test_del_insensitive(self):
+        self.headers['foo'] = 'bar'
+        self.assertEqual(self.headers['FOO'], 'bar')
+        del self.headers['FoO']
+        with self.assertRaises(KeyError):
+            self.headers['foo']
+
+    def test_iteration(self):
+        self.headers['FOO'] = 'bar'
+        self.headers['dead'] = 'beef'
+        self.assertIn('FOO', list(self.headers))
+        self.assertIn('dead', list(self.headers))
+        headers_items = list(self.headers.items())
+        self.assertIn(('FOO', 'bar'), headers_items)
+        self.assertIn(('dead', 'beef'), headers_items)
+
+
+if __name__ == "__main__":
+    unittest.main()

testbed/boto__botocore/tests/unit/test_client.py

@@ -0,0 +1,2368 @@
+# Copyright 2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import io
+from contextlib import closing
+
+import botocore
+import botocore.config
+from botocore import client, exceptions, hooks
+from botocore.auth import AUTH_TYPE_MAPS, BaseSigner
+from botocore.client import ClientEndpointBridge
+from botocore.configprovider import (
+    ChainProvider,
+    ConfigValueStore,
+    EnvironmentProvider,
+)
+from botocore.credentials import Credentials
+from botocore.endpoint import DEFAULT_TIMEOUT
+from botocore.errorfactory import ClientExceptionsFactory
+from botocore.exceptions import (
+    InvalidMaxRetryAttemptsError,
+    InvalidRetryConfigurationError,
+    InvalidRetryModeError,
+    InvalidS3AddressingStyleError,
+    ParamValidationError,
+    UnknownSignatureVersionError,
+)
+from botocore.stub import Stubber
+from botocore.useragent import UserAgentString
+from tests import mock, unittest
+
+
+class TestAutoGeneratedClient(unittest.TestCase):
+    def setUp(self):
+        self.service_description = {
+            'metadata': {
+                'serviceFullName': 'AWS MyService',
+                'apiVersion': '2014-01-01',
+                'endpointPrefix': 'myservice',
+                'signatureVersion': 'v4',
+                'protocol': 'query',
+                'serviceId': 'MyService',
+            },
+            'operations': {
+                'TestOperation': {
+                    'name': 'TestOperation',
+                    'http': {
+                        'method': 'POST',
+                        'requestUri': '/',
+                    },
+                    'input': {'shape': 'TestOperationRequest'},
+                    'errors': [{'shape': 'TestOperationException'}],
+                    'documentation': 'Documents TestOperation',
+                }
+            },
+            'shapes': {
+                'TestOperationRequest': {
+                    'type': 'structure',
+                    'required': ['Foo'],
+                    'members': {
+                        'Foo': {
+                            'shape': 'StringType',
+                            'documentation': 'Documents Foo',
+                        },
+                        'Bar': {
+                            'shape': 'StringType',
+                            'documentation': 'Documents Bar',
+                        },
+                    },
+                },
+                "TestOperationException": {
+                    'type': 'structure',
+                    'exception': True,
+                    'error': {'code': 'TestOperationErrorCode'},
+                },
+                'StringType': {'type': 'string'},
+            },
+        }
+        self.endpoint_ruleset = {
+            "version": "1.0",
+            "parameters": {},
+            "rules": [
+                {
+                    "conditions": [],
+                    "type": "endpoint",
+                    "endpoint": {
+                        "url": "https://foo.bar",
+                        "properties": {},
+                        "headers": {},
+                    },
+                }
+            ],
+        }
+        self.retry_config = {
+            "retry": {
+                "__default__": {
+                    "max_attempts": 5,
+                    "delay": {
+                        "type": "exponential",
+                        "base": "rand",
+                        "growth_factor": 2,
+                    },
+                    "policies": {},
+                }
+            }
+        }
+
+        def load_service_mock(*args, **kwargs):
+            if args[1] == "service-2":
+                return self.service_description
+
+        self.loader = mock.Mock()
+        self.loader.load_service_model.side_effect = load_service_mock
+        self.loader.load_data.return_value = self.retry_config
+
+        self.credentials = Credentials('access-key', 'secret-key')
+
+        self.endpoint_creator_patch = mock.patch(
+            'botocore.args.EndpointCreator'
+        )
+        self.endpoint_creator_cls = self.endpoint_creator_patch.start()
+        self.endpoint_creator = self.endpoint_creator_cls.return_value
+
+        self.endpoint = mock.Mock()
+        self.endpoint.host = 'https://myservice.amazonaws.com'
+        self.endpoint.make_request.return_value = (
+            mock.Mock(status_code=200),
+            {},
+        )
+        self.endpoint_creator.create_endpoint.return_value = self.endpoint
+
+        self.resolver = mock.Mock()
+        self.endpoint_data = {
+            'partition': 'aws',
+            'hostname': 'foo',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['v4'],
+        }
+        self.resolver.construct_endpoint.return_value = self.endpoint_data
+        self.resolver.get_available_endpoints.return_value = ['us-west-2']
+        self.config_store = ConfigValueStore()
+
+    def tearDown(self):
+        self.endpoint_creator_patch.stop()
+
+    def create_mock_emitter(self, responses=None):
+        if responses is None:
+            responses = []
+
+        emitter = mock.Mock()
+        emitter.emit.return_value = responses
+        return emitter
+
+    def create_client_creator(
+        self,
+        endpoint_creator=None,
+        event_emitter=None,
+        retry_handler_factory=None,
+        retry_config_translator=None,
+        response_parser_factory=None,
+        endpoint_prefix=None,
+        exceptions_factory=None,
+        config_store=None,
+        user_agent_creator=None,
+    ):
+        if event_emitter is None:
+            event_emitter = hooks.HierarchicalEmitter()
+        if retry_handler_factory is None:
+            retry_handler_factory = botocore.retryhandler
+        if retry_config_translator is None:
+            retry_config_translator = botocore.translate
+        if endpoint_prefix is not None:
+            self.service_description['metadata']['endpointPrefix'] = (
+                endpoint_prefix
+            )
+
+        if endpoint_creator is not None:
+            self.endpoint_creator_cls.return_value = endpoint_creator
+        if exceptions_factory is None:
+            exceptions_factory = ClientExceptionsFactory()
+        if config_store is None:
+            config_store = self.config_store
+        if user_agent_creator is None:
+            user_agent_creator = (
+                UserAgentString.from_environment().set_session_config(
+                    session_user_agent_name='MyUserAgent',
+                    session_user_agent_version='1.2.3-rc5',
+                    session_user_agent_extra=None,
+                )
+            )
+        creator = client.ClientCreator(
+            self.loader,
+            self.resolver,
+            'user-agent',
+            event_emitter,
+            retry_handler_factory,
+            retry_config_translator,
+            response_parser_factory,
+            exceptions_factory,
+            config_store,
+            user_agent_creator,
+        )
+        return creator
+
+    def assert_no_param_error_raised(self, client):
+        try:
+            self.make_api_call_with_missing_param(client)
+        except ParamValidationError:
+            self.fail(
+                "ParamValidationError shouldn't be raised "
+                "with validation disabled"
+            )
+
+    def make_api_call_with_missing_param(self, service_client):
+        # Missing required 'Foo' param.
+        service_client.test_operation(Bar='two')
+
+    def test_client_name(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(service_client.__class__.__name__, 'MyService')
+
+    def test_client_name_with_amazon(self):
+        self.service_description['metadata']['serviceFullName'] = (
+            'Amazon MyService'
+        )
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(service_client.__class__.__name__, 'MyService')
+
+    def test_client_name_using_abreviation(self):
+        self.service_description['metadata']['serviceAbbreviation'] = (
+            'Abbreviation'
+        )
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(service_client.__class__.__name__, 'Abbreviation')
+
+    def test_client_name_with_non_alphabet_characters(self):
+        self.service_description['metadata']['serviceFullName'] = (
+            'Amazon My-Service'
+        )
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(service_client.__class__.__name__, 'MyService')
+
+    def test_client_name_with_no_full_name_or_abbreviation(self):
+        del self.service_description['metadata']['serviceFullName']
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(service_client.__class__.__name__, 'myservice')
+
+    def test_client_generated_from_model(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(hasattr(service_client, 'test_operation'))
+
+    def test_client_with_nonstandard_signature_version(self):
+        self.service_description['metadata']['signatureVersion'] = 'foo'
+        creator = self.create_client_creator()
+        foo_signer = mock.Mock(spec=BaseSigner)
+
+        auth_types = AUTH_TYPE_MAPS.copy()
+        auth_types['foo'] = foo_signer
+
+        with mock.patch('botocore.client.AUTH_TYPE_MAPS', auth_types):
+            service_client = creator.create_client(
+                'myservice', 'us-west-2', credentials=self.credentials
+            )
+        assert service_client.meta.config.signature_version == 'foo'
+
+    def test_client_method_docstring(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        method_docstring = str(service_client.test_operation.__doc__)
+        ref_docstring_lines = [
+            'Documents TestOperation',
+            '**Request Syntax**',
+            '  response = client.test_operation(',
+            '      Bar=\'string\'',
+            '      Foo=\'string\'',
+            '  )',
+            ':type Bar: string',
+            ':param Bar: Documents Bar',
+            ':type Foo: string',
+            ':param Foo: **[REQUIRED]** Documents Foo',
+        ]
+        for line in ref_docstring_lines:
+            self.assertIn(line, method_docstring)
+
+    def test_client_method_help(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        with mock.patch('sys.stdout', io.StringIO()) as mock_stdout:
+            help(service_client.test_operation)
+        method_docstring = mock_stdout.getvalue()
+        ref_docstring_lines = [
+            'Documents TestOperation',
+            '**Request Syntax**',
+            '  response = client.test_operation(',
+            '      Bar=\'string\'',
+            '      Foo=\'string\'',
+            '  )',
+            ':type Bar: string',
+            ':param Bar: Documents Bar',
+            ':type Foo: string',
+            ':param Foo: **[REQUIRED]** Documents Foo',
+        ]
+        for line in ref_docstring_lines:
+            self.assertIn(line, method_docstring)
+
+    def test_client_create_unicode(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(hasattr(service_client, 'test_operation'))
+
+    def test_client_has_region_name_on_meta(self):
+        creator = self.create_client_creator()
+        region_name = 'us-west-2'
+        self.endpoint.region_name = region_name
+        service_client = creator.create_client(
+            'myservice', region_name, credentials=self.credentials
+        )
+        self.assertEqual(service_client.meta.region_name, region_name)
+
+    def test_client_has_endpoint_url_on_meta(self):
+        creator = self.create_client_creator()
+        self.endpoint.host = 'https://foo.bar'
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertEqual(service_client.meta.endpoint_url, 'https://foo.bar')
+
+    def test_client_has_standard_partition_on_meta(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertEqual(service_client.meta.partition, 'aws')
+
+    def test_client_has_non_standard_partition_on_meta(self):
+        creator = self.create_client_creator()
+        self.resolver.construct_endpoint.return_value = {
+            'partition': 'aws-cn',
+            'hostname': 'foo',
+            'endpointName': 'cn-north-1',
+            'signatureVersions': ['v4'],
+        }
+        service_client = creator.create_client(
+            'myservice', 'cn-north-1', credentials=self.credentials
+        )
+        self.assertEqual(service_client.meta.partition, 'aws-cn')
+
+    def test_client_has_exceptions_attribute(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(hasattr(service_client, 'exceptions'))
+
+    def test_client_has_modeled_exceptions(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertTrue(
+            issubclass(
+                service_client.exceptions.TestOperationException,
+                client.ClientError,
+            )
+        )
+
+    def test_client_fips_region_transformation(self):
+        creator = self.create_client_creator()
+        with self.assertLogs('botocore.client', level='WARNING') as log:
+            creator.create_client(
+                'myservice', 'fips-us-west-2', credentials=self.credentials
+            )
+            self.assertIn('fips-us-west-2 to us-west-2', log.output[0])
+
+    def test_api_version_is_passed_to_loader_if_provided(self):
+        creator = self.create_client_creator()
+        self.endpoint.host = 'https://foo.bar'
+        specific_api_version = '2014-03-01'
+        creator.create_client(
+            'myservice',
+            'us-west-2',
+            credentials=self.credentials,
+            api_version=specific_api_version,
+        )
+        calls = [
+            mock.call(
+                'myservice', 'service-2', api_version=specific_api_version
+            ),
+            mock.call(
+                'myservice',
+                'endpoint-rule-set-1',
+                api_version=specific_api_version,
+            ),
+        ]
+        self.loader.load_service_model.assert_has_calls(calls)
+
+    def test_create_client_class_creates_class(self):
+        creator = self.create_client_creator()
+        client_class = creator.create_client_class('myservice')
+        self.assertTrue(hasattr(client_class, 'test_operation'))
+
+    def test_create_client_class_forwards_api_version(self):
+        creator = self.create_client_creator()
+        specific_api_version = '2014-03-01'
+        creator.create_client_class(
+            'myservice', api_version=specific_api_version
+        )
+        self.loader.load_service_model.assert_called_with(
+            'myservice', 'service-2', api_version=specific_api_version
+        )
+
+    def test_signing_region_does_not_change_client_region(self):
+        with mock.patch('botocore.args.RequestSigner') as mock_signer:
+            credential_scope_region = 'us-east-1'
+            self.resolver.construct_endpoint.return_value = {
+                'partition': 'aws',
+                'hostname': 'endpoint.url',
+                'endpointName': 'us-west-2',
+                'signatureVersions': ['v4'],
+                'credentialScope': {'region': credential_scope_region},
+            }
+            creator = self.create_client_creator()
+            service_client = creator.create_client(
+                'myservice', 'us-west-2', credentials=self.credentials
+            )
+            self.assertEqual(service_client.meta.region_name, 'us-west-2')
+            call_args = mock_signer.call_args
+            self.assertEqual(credential_scope_region, call_args[0][1])
+
+    def test_client_uses_signing_region_from_credential_scope(self):
+        with mock.patch('botocore.args.RequestSigner') as mock_signer:
+            credential_scope_region = 'us-east-1'
+            self.resolver.construct_endpoint.return_value = {
+                'partition': 'aws',
+                'endpointName': 'us-west-2',
+                'hostname': 'endpoint.url',
+                'signatureVersions': ['v4'],
+                'credentialScope': {'region': credential_scope_region},
+            }
+            creator = self.create_client_creator()
+            service_client = creator.create_client(
+                service_name='myservice',
+                region_name='us-west-2',
+                credentials=self.credentials,
+            )
+            # Use the resolved region as the region value.
+            self.assertEqual(service_client.meta.region_name, 'us-west-2')
+            # Ensure that we use the credential scope region for signing,
+            # and not the resolved region name.
+            call_args = mock_signer.call_args
+            self.assertEqual(credential_scope_region, call_args[0][1])
+
+    def test_client_uses_signing_name_from_credential_scope(self):
+        with mock.patch('botocore.args.RequestSigner') as mock_signer:
+            self.resolver.construct_endpoint.return_value = {
+                'partition': 'aws',
+                'endpointName': 'us-west-2',
+                'hostname': 'endpoint.url',
+                'signatureVersions': ['v4'],
+                'credentialScope': {'service': 'override'},
+            }
+            creator = self.create_client_creator()
+            creator.create_client(
+                service_name='myservice',
+                region_name='us-west-2',
+                credentials=self.credentials,
+            )
+            call_args = mock_signer.call_args
+            self.assertEqual('MyService', call_args[0][0])
+            self.assertEqual('override', call_args[0][2])
+
+    def test_client_uses_given_region_name_and_endpoint_url_when_present(self):
+        with mock.patch('botocore.args.RequestSigner') as mock_signer:
+            credential_scope_region = 'us-east-1'
+            self.resolver.construct_endpoint.return_value = {
+                'partition': 'aws',
+                'endpointName': 'us-west-2',
+                'hostname': 'endpoint.url',
+                'signatureVersions': ['v4'],
+                'credentialScope': {'region': credential_scope_region},
+            }
+            creator = self.create_client_creator()
+            service_client = creator.create_client(
+                service_name='myservice',
+                region_name='us-west-2',
+                credentials=self.credentials,
+                endpoint_url='https://foo',
+            )
+            self.assertEqual(service_client.meta.region_name, 'us-west-2')
+            call_args = mock_signer.call_args
+            self.assertEqual('us-west-2', call_args[0][1])
+
+    def test_client_uses_signing_name_from_model_if_present_if_resolved(self):
+        self.service_description['metadata']['signingName'] = 'otherName'
+        with mock.patch('botocore.args.RequestSigner') as mock_signer:
+            self.resolver.construct_endpoint.return_value = {
+                'partition': 'aws',
+                'endpointName': 'us-west-2',
+                'hostname': 'endpoint.url',
+                'signatureVersions': ['v4'],
+            }
+            creator = self.create_client_creator()
+            service_client = creator.create_client(
+                service_name='myservice',
+                region_name='us-west-2',
+                credentials=self.credentials,
+                endpoint_url='https://foo',
+            )
+            self.assertEqual(service_client.meta.region_name, 'us-west-2')
+            call_args = mock_signer.call_args[0]
+            self.assertEqual('otherName', call_args[2])
+
+    def test_client_uses_signing_name_even_with_no_resolve(self):
+        self.service_description['metadata']['signingName'] = 'otherName'
+        with mock.patch('botocore.args.RequestSigner') as mock_signer:
+            self.resolver.construct_endpoint.return_value = {}
+            creator = self.create_client_creator()
+            service_client = creator.create_client(
+                service_name='myservice',
+                region_name='us-west-2',
+                credentials=self.credentials,
+                endpoint_url='https://foo',
+            )
+            self.assertEqual(service_client.meta.region_name, 'us-west-2')
+            call_args = mock_signer.call_args[0]
+            self.assertEqual('otherName', call_args[2])
+
+    @mock.patch('botocore.args.RequestSigner')
+    def test_client_signature_no_override(self, request_signer):
+        creator = self.create_client_creator()
+        creator.create_client(
+            'myservice',
+            'us-west-2',
+            credentials=self.credentials,
+            scoped_config={},
+        )
+        request_signer.assert_called_with(
+            mock.ANY,
+            mock.ANY,
+            mock.ANY,
+            'v4',
+            mock.ANY,
+            mock.ANY,
+            mock.ANY,
+        )
+
+    @mock.patch('botocore.args.RequestSigner')
+    def test_client_signature_override_config_file(self, request_signer):
+        creator = self.create_client_creator()
+        config = {'myservice': {'signature_version': 'foo'}}
+        creator.create_client(
+            'myservice',
+            'us-west-2',
+            credentials=self.credentials,
+            scoped_config=config,
+        )
+        request_signer.assert_called_with(
+            mock.ANY,
+            mock.ANY,
+            mock.ANY,
+            'foo',
+            mock.ANY,
+            mock.ANY,
+            mock.ANY,
+        )
+
+    @mock.patch('botocore.args.RequestSigner')
+    def test_client_signature_override_arg(self, request_signer):
+        creator = self.create_client_creator()
+        config = botocore.config.Config(signature_version='foo')
+        creator.create_client(
+            'myservice',
+            'us-west-2',
+            credentials=self.credentials,
+            client_config=config,
+        )
+        request_signer.assert_called_with(
+            mock.ANY,
+            mock.ANY,
+            mock.ANY,
+            'foo',
+            mock.ANY,
+            mock.ANY,
+            mock.ANY,
+        )
+
+    def test_client_method_to_api_mapping(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        self.assertEqual(
+            service_client.meta.method_to_api_mapping,
+            {'test_operation': 'TestOperation'},
+        )
+
+    def test_anonymous_client_request(self):
+        creator = self.create_client_creator()
+        config = botocore.config.Config(signature_version=botocore.UNSIGNED)
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', client_config=config
+        )
+
+        service_client.test_operation(Foo='one')
+
+        # Make sure a request has been attempted
+        self.assertTrue(self.endpoint.make_request.called)
+
+        # Make sure the request parameters do NOT include auth
+        # information. The service defined above for these tests
+        # uses sigv4 by default (which we disable).
+        params = {
+            k.lower(): v
+            for k, v in self.endpoint.make_request.call_args[0][1].items()
+        }
+        self.assertNotIn('authorization', params)
+        self.assertNotIn('x-amz-signature', params)
+
+    def test_client_user_agent_in_request(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+
+        service_client.test_operation(Foo='one')
+
+        self.assertTrue(self.endpoint.make_request.called)
+        params = {
+            k.lower(): v
+            for k, v in self.endpoint.make_request.call_args[0][1].items()
+        }
+        self.assertIn('MyUserAgent/1.2.3', params['headers']['User-Agent'])
+
+    def test_client_custom_user_agent_in_request(self):
+        creator = self.create_client_creator()
+        config = botocore.config.Config(user_agent='baz')
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', client_config=config
+        )
+
+        service_client.test_operation(Foo='one')
+
+        self.assertTrue(self.endpoint.make_request.called)
+        params = {
+            k.lower(): v
+            for k, v in self.endpoint.make_request.call_args[0][1].items()
+        }
+        self.assertEqual(params['headers']['User-Agent'], 'baz')
+
+    def test_client_custom_user_agent_extra_in_request(self):
+        creator = self.create_client_creator()
+        config = botocore.config.Config(user_agent_extra='extrastuff')
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', client_config=config
+        )
+        service_client.test_operation(Foo='one')
+        headers = self.endpoint.make_request.call_args[0][1]['headers']
+        self.assertTrue(headers['User-Agent'].endswith('extrastuff'))
+
+    def test_client_registers_request_created_handler(self):
+        event_emitter = self.create_mock_emitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+        creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertIn(
+            mock.call('request-created.myservice', mock.ANY),
+            event_emitter.register.call_args_list,
+        )
+
+    def test_client_makes_call(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        self.assertTrue(self.endpoint_creator.create_endpoint.called)
+
+        response = service_client.test_operation(Foo='one', Bar='two')
+        self.assertEqual(response, {})
+
+    def test_client_error_message_for_positional_args(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        with self.assertRaisesRegex(
+            TypeError, 'only accepts keyword arguments'
+        ):
+            service_client.test_operation('foo')
+
+    @mock.patch('botocore.args.RequestSigner.sign')
+    def test_client_signs_call(self, signer_mock):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        request = mock.Mock()
+
+        # Emit the request created event to see if it would be signed.
+        # We tested above to ensure this event is registered when
+        # a client is created. This prevents testing the entire client
+        # call logic.
+        service_client.meta.events.emit(
+            'request-created.myservice.test_operation',
+            request=request,
+            operation_name='test_operation',
+        )
+
+        signer_mock.assert_called_with('test_operation', request)
+
+    def test_client_validates_params_by_default(self):
+        creator = self.create_client_creator()
+
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        with self.assertRaises(ParamValidationError):
+            self.make_api_call_with_missing_param(service_client)
+
+    def test_client_doesnt_validate_params_when_validation_disabled(self):
+        creator = self.create_client_creator()
+
+        client_config = botocore.config.Config()
+        client_config.parameter_validation = False
+        service_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            credentials=self.credentials,
+            client_config=client_config,
+        )
+
+        self.assert_no_param_error_raised(service_client)
+
+    def test_can_disable_param_validation_from_scoped_config(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            credentials=self.credentials,
+            scoped_config={'parameter_validation': False},
+        )
+        self.assert_no_param_error_raised(service_client)
+
+    def test_client_config_trumps_scoped_config(self):
+        creator = self.create_client_creator()
+        scoped_config = {'parameter_validation': True}
+        client_config = botocore.config.Config(parameter_validation=False)
+        # Client config should win and param validation is disabled.
+        service_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            credentials=self.credentials,
+            scoped_config=scoped_config,
+            client_config=client_config,
+        )
+        self.assert_no_param_error_raised(service_client)
+
+    def test_client_with_custom_both_timeout(self):
+        self.create_client_creator().create_client(
+            'myservice',
+            'us-west-2',
+            client_config=botocore.config.Config(
+                connect_timeout=123, read_timeout=234
+            ),
+        )
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertEqual(call_kwargs['timeout'], (123, 234))
+
+    def test_client_with_custom_connect_timeout(self):
+        self.create_client_creator().create_client(
+            'myservice',
+            'us-west-2',
+            client_config=botocore.config.Config(connect_timeout=123),
+        )
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertEqual(call_kwargs['timeout'], (123, DEFAULT_TIMEOUT))
+
+    def test_client_with_custom_read_timeout(self):
+        self.create_client_creator().create_client(
+            'myservice',
+            'us-west-2',
+            client_config=botocore.config.Config(read_timeout=234),
+        )
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertEqual(call_kwargs['timeout'], (DEFAULT_TIMEOUT, 234))
+
+    def test_client_with_custom_neither_timeout(self):
+        self.create_client_creator().create_client('myservice', 'us-west-2')
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertEqual(
+            call_kwargs['timeout'], (DEFAULT_TIMEOUT, DEFAULT_TIMEOUT)
+        )
+
+    def test_client_with_custom_params(self):
+        creator = self.create_client_creator()
+        creator.create_client(
+            'myservice', 'us-west-2', is_secure=False, verify=False
+        )
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertFalse(call_kwargs['verify'])
+        self.assertNotIn('is_secure', call_kwargs)
+
+    def test_client_with_custom_proxy_config(self):
+        proxies_config = {
+            'proxy_ca_bundle': 'foo_ca_bundle',
+            'proxy_client_cert': 'foo_cert',
+            'proxy_use_forwarding_for_https': False,
+        }
+        self.create_client_creator().create_client(
+            'myservice',
+            'us-west-2',
+            client_config=botocore.config.Config(
+                proxies_config=proxies_config
+            ),
+        )
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertEqual(call_kwargs['proxies_config'], proxies_config)
+
+    def test_client_with_endpoint_url(self):
+        creator = self.create_client_creator()
+        creator.create_client(
+            'myservice', 'us-west-2', endpoint_url='http://custom.foo'
+        )
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertEqual(call_kwargs['endpoint_url'], 'http://custom.foo')
+
+    def test_client_can_use_guessed_endpoints(self):
+        # Ensure the resolver returns None (meaning a guess is made)
+        self.resolver.construct_endpoint.return_value = None
+        creator = self.create_client_creator()
+        client = creator.create_client('myservice', region_name='invalid')
+        self.assertEqual('invalid', client.meta.region_name)
+
+    def test_client_with_response_parser_factory(self):
+        factory = mock.Mock()
+        creator = self.create_client_creator(response_parser_factory=factory)
+        creator.create_client('myservice', 'us-west-2')
+        call_kwargs = self.endpoint_creator.create_endpoint.call_args[1]
+        self.assertEqual(call_kwargs['response_parser_factory'], factory)
+
+    def test_operation_cannot_paginate(self):
+        pagination_config = {
+            'pagination': {
+                # Note that there's no pagination config for
+                # 'TestOperation', indicating that TestOperation
+                # is not pageable.
+                'SomeOtherOperation': {
+                    "input_token": "Marker",
+                    "output_token": "Marker",
+                    "more_results": "IsTruncated",
+                    "limit_key": "MaxItems",
+                    "result_key": "Users",
+                }
+            }
+        }
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            pagination_config,
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        self.assertFalse(service_client.can_paginate('test_operation'))
+
+    def test_operation_can_paginate(self):
+        pagination_config = {
+            'pagination': {
+                'TestOperation': {
+                    "input_token": "Marker",
+                    "output_token": "Marker",
+                    "more_results": "IsTruncated",
+                    "limit_key": "MaxItems",
+                    "result_key": "Users",
+                }
+            }
+        }
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            pagination_config,
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        self.assertTrue(service_client.can_paginate('test_operation'))
+        # Also, the config is cached, but we want to make sure we get
+        # the same answer when we ask again.
+        self.assertTrue(service_client.can_paginate('test_operation'))
+
+    def test_service_has_no_pagination_configs(self):
+        # This is the case where there is an actual *.paginator.json, file,
+        # but the specific operation itself is not actually pageable.
+        # If the loader cannot load pagination configs, it communicates
+        # this by raising a DataNotFoundError.
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            exceptions.DataNotFoundError(data_path='/foo'),
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        self.assertFalse(service_client.can_paginate('test_operation'))
+
+    def test_waiter_config_uses_service_name_not_endpoint_prefix(self):
+        waiter_config = {'version': 2, 'waiters': {}}
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            waiter_config,
+        ]
+        creator = self.create_client_creator()
+        # We're going to verify that the loader loads a service called
+        # 'other-service-name', and even though the endpointPrefix is
+        # 'myservice', we use 'other-service-name' for waiters/paginators, etc.
+        service_client = creator.create_client(
+            'other-service-name', 'us-west-2'
+        )
+        self.assertEqual(service_client.waiter_names, [])
+        # Note we're using other-service-name, not
+        # 'myservice', which is the endpointPrefix.
+        self.loader.load_service_model.assert_called_with(
+            'other-service-name', 'waiters-2', '2014-01-01'
+        )
+
+    def test_service_has_waiter_configs(self):
+        waiter_config = {
+            'version': 2,
+            'waiters': {
+                "Waiter1": {
+                    'operation': 'TestOperation',
+                    'delay': 5,
+                    'maxAttempts': 20,
+                    'acceptors': [],
+                },
+                "Waiter2": {
+                    'operation': 'TestOperation',
+                    'delay': 5,
+                    'maxAttempts': 20,
+                    'acceptors': [],
+                },
+            },
+        }
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            waiter_config,
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        self.assertEqual(
+            sorted(service_client.waiter_names), sorted(['waiter1', 'waiter2'])
+        )
+        self.assertTrue(hasattr(service_client.get_waiter('waiter1'), 'wait'))
+
+    def test_service_has_no_waiter_configs(self):
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            exceptions.DataNotFoundError(data_path='/foo'),
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        self.assertEqual(service_client.waiter_names, [])
+        with self.assertRaises(ValueError):
+            service_client.get_waiter("unknown_waiter")
+
+    def test_service_has_retry_event(self):
+        # A retry event should be registered for the service.
+        event_emitter = self.create_mock_emitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+        creator.create_client('myservice', 'us-west-2')
+
+        event_emitter.register.assert_any_call(
+            'needs-retry.myservice',
+            mock.ANY,
+            unique_id='retry-config-myservice',
+        )
+
+    def test_service_creates_retryhandler(self):
+        # A retry handler with the expected configuration should be
+        # created when instantiating a client.
+        retry_handler_factory = mock.Mock()
+        creator = self.create_client_creator(
+            retry_handler_factory=retry_handler_factory
+        )
+        creator.create_client('myservice', 'us-west-2')
+
+        retry_handler_factory.create_retry_handler.assert_called_with(
+            {
+                '__default__': {
+                    'delay': {
+                        'growth_factor': 2,
+                        'base': 'rand',
+                        'type': 'exponential',
+                    },
+                    'policies': {},
+                    'max_attempts': 5,
+                }
+            },
+            'myservice',
+        )
+
+    def test_service_registers_retry_handler(self):
+        # The retry handler returned from ``create_retry_handler``
+        # that was tested above needs to be set as the handler for
+        # the event emitter.
+        retry_handler_factory = mock.Mock()
+        handler = mock.Mock()
+        event_emitter = self.create_mock_emitter()
+        retry_handler_factory.create_retry_handler.return_value = handler
+
+        creator = self.create_client_creator(
+            event_emitter=event_emitter,
+            retry_handler_factory=retry_handler_factory,
+        )
+        creator.create_client('myservice', 'us-west-2')
+
+        event_emitter.register.assert_any_call(
+            mock.ANY, handler, unique_id=mock.ANY
+        )
+
+    def test_service_retry_missing_config(self):
+        # No config means we should never see any retry events registered.
+        self.loader.load_data.return_value = {}
+
+        event_emitter = self.create_mock_emitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+        creator.create_client('myservice', 'us-west-2')
+
+        for call in event_emitter.register.call_args_list:
+            self.assertNotIn('needs-retry', call[0][0])
+
+    def test_emits_after_call_error(self):
+        event_emitter = hooks.HierarchicalEmitter()
+
+        recorded_kwargs = []
+
+        def record(event_name, **kwargs):
+            recorded_kwargs.append(kwargs)
+
+        event_emitter.register(
+            'after-call-error.myservice.TestOperation', record
+        )
+
+        raised_error = RuntimeError('Unexpected error')
+        self.endpoint.make_request.side_effect = raised_error
+        creator = self.create_client_creator(event_emitter=event_emitter)
+        client = creator.create_client('myservice', 'us-west-2')
+        with self.assertRaises(RuntimeError):
+            client.test_operation(Foo='one', Bar='two')
+        self.assertEqual(
+            recorded_kwargs, [{'exception': raised_error, 'context': mock.ANY}]
+        )
+
+    def test_can_override_max_attempts(self):
+        retry_handler_factory = mock.Mock(botocore.retryhandler)
+        creator = self.create_client_creator(
+            retry_handler_factory=retry_handler_factory
+        )
+        creator.create_client(
+            'myservice',
+            'us-west-2',
+            client_config=botocore.config.Config(
+                retries={'max_attempts': 9, 'mode': 'legacy'}
+            ),
+        )
+
+        retry_handler_factory.create_retry_handler.assert_called_with(
+            {
+                '__default__': {
+                    'delay': {
+                        'growth_factor': 2,
+                        'base': 'rand',
+                        'type': 'exponential',
+                    },
+                    'policies': {},
+                    'max_attempts': 10,
+                }
+            },
+            'myservice',
+        )
+
+    def test_can_register_standard_retry_mode(self):
+        with mock.patch('botocore.client.standard') as standard:
+            creator = self.create_client_creator()
+            creator.create_client(
+                'myservice',
+                'us-west-2',
+                client_config=botocore.config.Config(
+                    retries={'mode': 'standard'}
+                ),
+            )
+        self.assertTrue(standard.register_retry_handler.called)
+
+    def test_can_register_standard_retry_mode_from_config_store(self):
+        fake_env = {'AWS_RETRY_MODE': 'standard'}
+        config_store = ConfigValueStore(
+            mapping={
+                'retry_mode': ChainProvider(
+                    [
+                        EnvironmentProvider('AWS_RETRY_MODE', fake_env),
+                    ]
+                )
+            }
+        )
+        creator = self.create_client_creator(config_store=config_store)
+        with mock.patch('botocore.client.standard') as standard:
+            creator.create_client('myservice', 'us-west-2')
+        self.assertTrue(standard.register_retry_handler.called)
+
+    def test_try_to_paginate_non_paginated(self):
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            exceptions.DataNotFoundError(data_path='/foo'),
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        with self.assertRaises(exceptions.OperationNotPageableError):
+            service_client.get_paginator('test_operation')
+
+    def test_successful_pagination_object_created(self):
+        pagination_config = {
+            'pagination': {
+                'TestOperation': {
+                    "input_token": "Marker",
+                    "output_token": "Marker",
+                    "more_results": "IsTruncated",
+                    "limit_key": "MaxItems",
+                    "result_key": "Users",
+                }
+            }
+        }
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            pagination_config,
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        paginator = service_client.get_paginator('test_operation')
+        # The pagination logic itself is tested elsewhere (test_paginate.py),
+        # but we can at least make sure it looks like a paginator.
+        self.assertTrue(hasattr(paginator, 'paginate'))
+
+    def test_paginator_class_name_from_client(self):
+        pagination_config = {
+            'pagination': {
+                'TestOperation': {
+                    "input_token": "Marker",
+                    "output_token": "Marker",
+                    "more_results": "IsTruncated",
+                    "limit_key": "MaxItems",
+                    "result_key": "Users",
+                }
+            }
+        }
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            pagination_config,
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        paginator = service_client.get_paginator('test_operation')
+        self.assertEqual(
+            paginator.__class__.__name__, 'MyService.Paginator.TestOperation'
+        )
+
+    def test_paginator_help_from_client(self):
+        pagination_config = {
+            'pagination': {
+                'TestOperation': {
+                    "input_token": "Marker",
+                    "output_token": "Marker",
+                    "more_results": "IsTruncated",
+                    "limit_key": "MaxItems",
+                    "result_key": "Users",
+                }
+            }
+        }
+        self.loader.load_service_model.side_effect = [
+            self.service_description,
+            self.endpoint_ruleset,
+            pagination_config,
+        ]
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        paginator = service_client.get_paginator('test_operation')
+        with mock.patch('sys.stdout', io.StringIO()) as mock_stdout:
+            help(paginator.paginate)
+        contents = mock_stdout.getvalue()
+        lines = [
+            (
+                '    Creates an iterator that will paginate through responses '
+                'from :py:meth:`MyService.Client.test_operation`.'
+            ),
+            '    **Request Syntax**',
+            '    ::',
+            '      response_iterator = paginator.paginate(',
+            "          Foo='string',",
+            "          Bar='string',",
+            '          PaginationConfig={',
+            "              'MaxItems': 123,",
+            "              'PageSize': 123,",
+            "              'StartingToken': 'string'",
+            '          }',
+            '      )',
+            '    :type Foo: string',
+            '    :param Foo: **[REQUIRED]** Documents Foo',
+            '    :type Bar: string',
+            '    :param Bar: Documents Bar',
+            '    :type PaginationConfig: dict',
+            '    :param PaginationConfig:',
+            (
+                '      A dictionary that provides parameters to control '
+                'pagination.'
+            ),
+            '      - **MaxItems** *(integer) --*',
+            (
+                '        The total number of items to return. If the total '
+                'number of items available is more than the value specified '
+                'in max-items then a ``NextToken`` will be provided in the '
+                'output that you can use to resume pagination.'
+            ),
+            '      - **PageSize** *(integer) --*',
+            '        The size of each page.',
+            '      - **StartingToken** *(string) --*',
+            (
+                '        A token to specify where to start paginating. This is '
+                'the ``NextToken`` from a previous response.'
+            ),
+            '    :returns: None',
+        ]
+        for line in lines:
+            self.assertIn(line, contents)
+
+    def test_can_set_credentials_in_client_init(self):
+        creator = self.create_client_creator()
+        credentials = Credentials(
+            access_key='access_key',
+            secret_key='secret_key',
+            token='session_token',
+        )
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=credentials
+        )
+
+        # Verify that we create an endpoint with a credentials object
+        # matching our creds arguments.
+        self.assertEqual(client._request_signer._credentials, credentials)
+
+    def test_event_emitted_when_invoked(self):
+        event_emitter = hooks.HierarchicalEmitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+
+        calls = []
+
+        def handler(**kwargs):
+            return calls.append(kwargs)
+
+        event_emitter.register('before-call', handler)
+
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        service_client.test_operation(Foo='one', Bar='two')
+        self.assertEqual(len(calls), 1)
+
+    def test_events_are_per_client(self):
+        event_emitter = hooks.HierarchicalEmitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+
+        first_calls = []
+
+        def first_handler(**kwargs):
+            return first_calls.append(kwargs)
+
+        second_calls = []
+
+        def second_handler(**kwargs):
+            return second_calls.append(kwargs)
+
+        first_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        second_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        first_client.meta.events.register('before-call', first_handler)
+        second_client.meta.events.register('before-call', second_handler)
+
+        # Now, if we invoke an operation from either client, only
+        # the handlers registered with the specific client will be invoked.
+        # So if we invoke the first client.
+        first_client.test_operation(Foo='one', Bar='two')
+        # Only first_calls is populated, not second_calls.
+        self.assertEqual(len(first_calls), 1)
+        self.assertEqual(len(second_calls), 0)
+
+        # If we invoke an operation from the second client,
+        # only second_calls will be populated, not first_calls.
+        second_client.test_operation(Foo='one', Bar='two')
+        # first_calls == 1 from the previous first_client.test_operation()
+        # call.
+        self.assertEqual(len(first_calls), 1)
+        self.assertEqual(len(second_calls), 1)
+
+    def test_clients_inherit_handlers_from_session(self):
+        # Even though clients get their own event emitters, they still
+        # inherit any handlers that were registered on the event emitter
+        # at the time the client was created.
+        event_emitter = hooks.HierarchicalEmitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+
+        # So if an event handler is registered before any clients are created:
+
+        base_calls = []
+
+        def base_handler(**kwargs):
+            return base_calls.append(kwargs)
+
+        event_emitter.register('before-call', base_handler)
+
+        # Then any client created from this point forward from the
+        # event_emitter passed into the ClientCreator will have this
+        # handler.
+        first_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        first_client.test_operation(Foo='one', Bar='two')
+        self.assertEqual(len(base_calls), 1)
+
+        # Same thing if we create another client.
+        second_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        second_client.test_operation(Foo='one', Bar='two')
+        self.assertEqual(len(base_calls), 2)
+
+    def test_clients_inherit_only_at_create_time(self):
+        # If event handlers are added to the copied event emitter
+        # _after_ a client is created, we don't pick those up.
+        event_emitter = hooks.HierarchicalEmitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+
+        # 1. Create a client.
+        first_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        # 2. Now register an event handler from the originating event emitter.
+        base_calls = []
+
+        def base_handler(**kwargs):
+            return base_calls.append(kwargs)
+
+        event_emitter.register('before-call', base_handler)
+
+        # 3. The client will _not_ see this because it already has its
+        #    own copy of the event handlers.
+        first_client.test_operation(Foo='one', Bar='two')
+        self.assertEqual(len(base_calls), 0)
+
+    def test_clients_have_meta_object(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client('myservice', 'us-west-2')
+        self.assertTrue(hasattr(service_client, 'meta'))
+        self.assertTrue(hasattr(service_client.meta, 'events'))
+        # Sanity check the event emitter has an .emit() method.
+        self.assertTrue(hasattr(service_client.meta.events, 'emit'))
+
+    def test_client_register_seperate_unique_id_event(self):
+        event_emitter = hooks.HierarchicalEmitter()
+        creator = self.create_client_creator(event_emitter=event_emitter)
+
+        client1 = creator.create_client('myservice', 'us-west-2')
+        client2 = creator.create_client('myservice', 'us-west-2')
+
+        def ping(**kwargs):
+            return 'foo'
+
+        client1.meta.events.register('some-event', ping, 'my-unique-id')
+        client2.meta.events.register('some-event', ping, 'my-unique-id')
+
+        # Ensure both clients can register a function with an unique id
+        client1_responses = client1.meta.events.emit('some-event')
+        self.assertEqual(len(client1_responses), 1)
+        self.assertEqual(client1_responses[0][1], 'foo')
+
+        client2_responses = client2.meta.events.emit('some-event')
+        self.assertEqual(len(client2_responses), 1)
+        self.assertEqual(client2_responses[0][1], 'foo')
+
+        # Ensure when a client is unregistered the other client has
+        # the unique-id event still registered.
+        client1.meta.events.unregister('some-event', ping, 'my-unique-id')
+        client1_responses = client1.meta.events.emit('some-event')
+        self.assertEqual(len(client1_responses), 0)
+
+        client2_responses = client2.meta.events.emit('some-event')
+        self.assertEqual(len(client2_responses), 1)
+        self.assertEqual(client2_responses[0][1], 'foo')
+
+        # Ensure that the other client can unregister the event
+        client2.meta.events.unregister('some-event', ping, 'my-unique-id')
+        client2_responses = client2.meta.events.emit('some-event')
+        self.assertEqual(len(client2_responses), 0)
+
+    def test_client_created_emits_events(self):
+        called = []
+
+        def on_client_create(class_attributes, **kwargs):
+            called.append(class_attributes)
+
+        event_emitter = hooks.HierarchicalEmitter()
+        event_emitter.register('creating-client-class', on_client_create)
+
+        creator = self.create_client_creator(event_emitter=event_emitter)
+        creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        self.assertEqual(len(called), 1)
+        self.assertIn('test_operation', called[0])
+
+    def test_client_method_called_event(self):
+        event_emitter = hooks.HierarchicalEmitter()
+
+        def inject_params(params, **kwargs):
+            new_params = params.copy()
+            new_params['Foo'] = 'zero'
+            return new_params
+
+        event_emitter.register(
+            'provide-client-params.myservice.TestOperation', inject_params
+        )
+
+        wrapped_emitter = mock.Mock(wraps=event_emitter)
+        creator = self.create_client_creator(event_emitter=wrapped_emitter)
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        params = {'Foo': 'one', 'Bar': 'two'}
+        service_client.test_operation(**params)
+
+        # Ensure that the initial params were not modified in the handler
+        self.assertEqual(params, {'Foo': 'one', 'Bar': 'two'})
+
+        # Ensure the handler passed on the correct param values.
+        body = self.endpoint.make_request.call_args[0][1]['body']
+        self.assertEqual(body['Foo'], 'zero')
+
+    def test_client_default_for_s3_addressing_style(self):
+        creator = self.create_client_creator()
+        client = creator.create_client('myservice', 'us-west-2')
+        self.assertEqual(client.meta.config.s3, None)
+
+    def test_client_s3_addressing_style_with_config(self):
+        creator = self.create_client_creator()
+        my_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            client_config=botocore.config.Config(
+                s3={'addressing_style': 'auto'}
+            ),
+        )
+        self.assertEqual(my_client.meta.config.s3['addressing_style'], 'auto')
+
+    def test_client_s3_addressing_style_with_bad_value(self):
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            scoped_config={'s3': ''},
+        )
+        self.assertIsNone(client.meta.config.s3)
+
+    def test_client_s3_addressing_style_with_config_store(self):
+        self.config_store.set_config_variable(
+            's3', {'addressing_style': 'virtual'}
+        )
+        creator = self.create_client_creator()
+        client = creator.create_client('myservice', 'us-west-2')
+        self.assertEqual(client.meta.config.s3['addressing_style'], 'virtual')
+
+    def test_client_s3_addressing_style_with_incorrect_style(self):
+        with self.assertRaises(InvalidS3AddressingStyleError):
+            botocore.config.Config(s3={'addressing_style': 'foo'})
+
+    def test_client_s3_addressing_style_config_overrides_config_store(self):
+        self.config_store.set_config_variable(
+            's3', {'addressing_style': 'virtual'}
+        )
+        creator = self.create_client_creator()
+        my_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            client_config=botocore.config.Config(
+                s3={'addressing_style': 'auto'}
+            ),
+        )
+        self.assertEqual(my_client.meta.config.s3['addressing_style'], 'auto')
+
+    def test_client_payload_signing_from_config_store(self):
+        self.config_store.set_config_variable(
+            's3', {'payload_signing_enabled': True}
+        )
+        creator = self.create_client_creator()
+        my_client = creator.create_client('myservice', 'us-west-2')
+        self.assertEqual(
+            my_client.meta.config.s3['payload_signing_enabled'], True
+        )
+
+    def test_client_payload_signing_from_client_config(self):
+        creator = self.create_client_creator()
+        my_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            client_config=client.Config(s3={'payload_signing_enabled': True}),
+        )
+        self.assertEqual(
+            my_client.meta.config.s3['payload_signing_enabled'], True
+        )
+
+    def test_client_payload_signing_client_config_overrides_scoped(self):
+        creator = self.create_client_creator()
+        my_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            scoped_config={'s3': {'payload_signing_enabled': False}},
+            client_config=client.Config(s3={'payload_signing_enabled': True}),
+        )
+        self.assertEqual(
+            my_client.meta.config.s3['payload_signing_enabled'], True
+        )
+
+    def test_client_s3_accelerate_from_config_store(self):
+        self.config_store.set_config_variable(
+            's3', {'use_accelerate_endpoint': True}
+        )
+        creator = self.create_client_creator()
+        my_client = creator.create_client('myservice', 'us-west-2')
+        self.assertEqual(
+            my_client.meta.config.s3['use_accelerate_endpoint'], True
+        )
+
+    def test_client_s3_accelerate_from_client_config(self):
+        creator = self.create_client_creator()
+        my_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            client_config=client.Config(s3={'use_accelerate_endpoint': True}),
+        )
+        self.assertEqual(
+            my_client.meta.config.s3['use_accelerate_endpoint'], True
+        )
+
+    def test_client_s3_accelerate_client_config_overrides_config_store(self):
+        self.config_store.set_config_variable(
+            's3', {'use_accelerate_endpoint': False}
+        )
+        creator = self.create_client_creator()
+        my_client = creator.create_client(
+            'myservice',
+            'us-west-2',
+            client_config=client.Config(s3={'use_accelerate_endpoint': True}),
+        )
+        self.assertEqual(
+            my_client.meta.config.s3['use_accelerate_endpoint'], True
+        )
+
+    def test_before_call_short_circuits_request(self):
+        def return_mock_tuple(**kwargs):
+            http_mock = mock.Mock()
+            http_mock.status_code = 200
+            return http_mock, mock.Mock()
+
+        emitter = hooks.HierarchicalEmitter()
+        emitter.register_last('before-call.*.*', return_mock_tuple)
+        creator = self.create_client_creator(event_emitter=emitter)
+        service_client = creator.create_client('myservice', 'us-west-2')
+
+        service_client.test_operation(Foo='one')
+        self.assertFalse(self.endpoint.make_request.called)
+
+    def test_getattr_emits_event(self):
+        emitter = self.create_mock_emitter()
+        emitter.emit_until_response.return_value = (None, None)
+
+        creator = self.create_client_creator(event_emitter=emitter)
+        service_client = creator.create_client('myservice', 'us-west-2')
+
+        # Assert that the event hasn't fired yet
+        emitter.emit_until_response.assert_not_called()
+
+        with self.assertRaises(AttributeError):
+            service_client.attribute_that_does_not_exist
+
+        emitter.emit_until_response.assert_called_once_with(
+            'getattr.myservice.attribute_that_does_not_exist',
+            client=service_client,
+        )
+
+    def test_getattr_event_returns_response(self):
+        emitter = self.create_mock_emitter()
+        emitter.emit_until_response.return_value = (None, 'success')
+
+        creator = self.create_client_creator(event_emitter=emitter)
+        service_client = creator.create_client('myservice', 'us-west-2')
+
+        value = service_client.attribute_that_does_not_exist
+
+        self.assertEqual(value, 'success')
+
+    def _create_hostname_binding_client(self, *args, **kwargs):
+        test_operation = self.service_description['operations'][
+            'TestOperation'
+        ]
+        test_operation['endpoint'] = {'hostPrefix': '{Foo}.'}
+        test_shape = self.service_description['shapes']['TestOperationRequest']
+        test_shape['members']['Foo']['hostLabel'] = True
+
+        creator = self.create_client_creator()
+        return creator.create_client('myservice', *args, **kwargs)
+
+    def test_client_operation_hostname_binding(self):
+        client = self._create_hostname_binding_client('us-west-2')
+        client.test_operation(Foo='bound')
+
+        expected_url = 'https://bound.myservice.amazonaws.com/'
+        self.assertTrue(self.endpoint.make_request.called)
+        request_dict = self.endpoint.make_request.call_args[0][1]
+        self.assertEqual(request_dict['url'], expected_url)
+
+    def test_client_operation_hostname_binding_validation(self):
+        client = self._create_hostname_binding_client('us-west-2')
+        with self.assertRaises(ParamValidationError):
+            client.test_operation(Foo='')
+
+    def test_client_operation_hostname_binding_configuration(self):
+        config = botocore.config.Config(inject_host_prefix=False)
+        client = self._create_hostname_binding_client(
+            'us-west-2',
+            client_config=config,
+        )
+
+        client.test_operation(Foo='baz')
+        expected_url = 'https://myservice.amazonaws.com/'
+        self.assertTrue(self.endpoint.make_request.called)
+        request_dict = self.endpoint.make_request.call_args[0][1]
+        self.assertEqual(request_dict['url'], expected_url)
+
+    def test_client_close(self):
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        service_client.close()
+        self.endpoint.close.assert_called_once_with()
+
+    def test_client_close_context_manager(self):
+        creator = self.create_client_creator()
+        with closing(
+            creator.create_client(
+                'myservice', 'us-west-2', credentials=self.credentials
+            )
+        ) as service_client:
+            service_client.test_operation(Foo='baz')
+
+        self.endpoint.close.assert_called_once_with()
+
+    def test_client_internal_credential_shim(self):
+        """This test exercises the internal credential shim exposed on clients.
+        It's here to ensure we don't unintentionally regress behavior used with
+        our upload/download operations in s3transfer with the CRT.
+        """
+        creator = self.create_client_creator()
+        service_client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        self.assertEqual(service_client._get_credentials(), self.credentials)
+
+
+class TestClientErrors(TestAutoGeneratedClient):
+    def add_error_response(self, error_response):
+        self.endpoint.make_request.return_value = (
+            mock.Mock(status_code=400),
+            error_response,
+        )
+
+    def test_client_makes_call_with_error(self):
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        with Stubber(client) as stub:
+            stub.add_client_error(
+                'test_operation', 'TestOperationErrorCode', 'error occurred'
+            )
+            with self.assertRaises(client.exceptions.TestOperationException):
+                client.test_operation(Foo='one', Bar='two')
+
+    def test_error_with_no_wire_code(self):
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        with Stubber(client) as stub:
+            stub.add_client_error('test_operation', '404', 'Not Found')
+            try:
+                client.test_operation(Foo='one', Bar='two')
+            except client.exceptions.ClientError as e:
+                # This is needed becasue the error could be a subclass of
+                # ClientError.
+                # We explicitly want it to be a generic ClientError though
+                self.assertEqual(e.__class__, exceptions.ClientError)
+
+    def test_error_with_dot_separated_code(self):
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        with Stubber(client) as stub:
+            stub.add_client_error(
+                'test_operation', 'InvalidAddress.NotFound', 'Not Found'
+            )
+            try:
+                client.test_operation(Foo='one', Bar='two')
+            except client.exceptions.ClientError as e:
+                # This is needed becasue the error could be a subclass of
+                # ClientError.
+                # We explicitly want it to be a generic ClientError though
+                self.assertEqual(e.__class__, exceptions.ClientError)
+
+    def test_error_with_empty_message(self):
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        with Stubber(client) as stub:
+            stub.add_client_error('test_operation', 'TestOperationErrorCode')
+            with self.assertRaises(client.exceptions.TestOperationException):
+                client.test_operation(Foo='one', Bar='two')
+
+    def test_error_with_empty_code(self):
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        with Stubber(client) as stub:
+            stub.add_client_error('test_operation')
+            try:
+                client.test_operation(Foo='one', Bar='two')
+            except client.exceptions.ClientError as e:
+                # This is needed becasue the error could be a subclass of
+                # ClientError.
+                # We explicitly want it to be a generic ClientError though
+                self.assertEqual(e.__class__, exceptions.ClientError)
+
+    def test_error_with_missing_code(self):
+        error_response = {'Error': {'Message': 'error occurred'}}
+        # The stubber is not being used because it will always populate the
+        # the message and code.
+        self.endpoint.make_request.return_value = (
+            mock.Mock(status_code=400),
+            error_response,
+        )
+
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        try:
+            client.test_operation(Foo='one', Bar='two')
+        except client.exceptions.ClientError as e:
+            # This is needed becasue the error could be a subclass of
+            # ClientError.
+            # We explicitly want it to be a generic ClientError though
+            self.assertEqual(e.__class__, exceptions.ClientError)
+
+    def test_error_with_empty_contents(self):
+        error_response = {'Error': {}}
+        # The stubber is not being used because it will always populate the
+        # the message and code.
+        self.endpoint.make_request.return_value = (
+            mock.Mock(status_code=400),
+            error_response,
+        )
+
+        creator = self.create_client_creator()
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        try:
+            client.test_operation(Foo='one', Bar='two')
+        except client.exceptions.ClientError as e:
+            # This is needed becasue the error could be a subclass of
+            # ClientError.
+            # We explicitly want it to be a generic ClientError though
+            self.assertEqual(e.__class__, exceptions.ClientError)
+
+    def test_exception_classes_across_clients_are_the_same(self):
+        creator = self.create_client_creator(
+            exceptions_factory=ClientExceptionsFactory()
+        )
+        client = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+        client2 = creator.create_client(
+            'myservice', 'us-west-2', credentials=self.credentials
+        )
+
+        with Stubber(client) as stub:
+            stub.add_client_error(
+                'test_operation', 'TestOperationErrorCode', 'error occurred'
+            )
+            try:
+                client.test_operation(Foo='one', Bar='two')
+            except client2.exceptions.TestOperationException as e:
+                # Caught exception should as well be an instance of the
+                # other client's TestOperationException
+                self.assertIsInstance(
+                    e, client.exceptions.TestOperationException
+                )
+
+
+class TestConfig(unittest.TestCase):
+    def test_can_use_args_to_construct(self):
+        config = botocore.config.Config(
+            *botocore.config.Config.OPTION_DEFAULTS.values()
+        )
+        for (
+            option,
+            default_value,
+        ) in botocore.config.Config.OPTION_DEFAULTS.items():
+            self.assertTrue(hasattr(config, option))
+            self.assertEqual(getattr(config, option), default_value)
+
+    def test_can_use_kwargs_to_construct(self):
+        config = botocore.config.Config(
+            **botocore.config.Config.OPTION_DEFAULTS
+        )
+        for (
+            option,
+            default_value,
+        ) in botocore.config.Config.OPTION_DEFAULTS.items():
+            self.assertTrue(hasattr(config, option))
+            self.assertEqual(getattr(config, option), default_value)
+
+    def test_can_use_mix_of_args_and_kwargs(self):
+        config = botocore.config.Config('us-east-1', read_timeout=50)
+        self.assertEqual(config.region_name, 'us-east-1')
+        self.assertEqual(config.read_timeout, 50)
+
+    def test_invalid_kwargs(self):
+        with self.assertRaisesRegex(TypeError, 'Got unexpected keyword'):
+            botocore.config.Config(foo='foo')
+
+    def test_pass_invalid_length_of_args(self):
+        with self.assertRaisesRegex(TypeError, 'Takes at most'):
+            botocore.config.Config(
+                'foo', *botocore.config.Config.OPTION_DEFAULTS.values()
+            )
+
+    def test_create_with_multiple_kwargs(self):
+        with self.assertRaisesRegex(TypeError, 'Got multiple values'):
+            botocore.config.Config('us-east-1', region_name='us-east-1')
+
+    def test_merge_returns_new_config_object(self):
+        config = botocore.config.Config()
+        other_config = botocore.config.Config()
+        new_config = config.merge(other_config)
+        # Check the type is correct
+        self.assertIsInstance(new_config, botocore.config.Config)
+        # Make sure the new config is a brand new config object
+        self.assertIsNot(new_config, config)
+        self.assertIsNot(new_config, other_config)
+
+    def test_general_merge_keeps_default_values(self):
+        config = botocore.config.Config()
+        other_config = botocore.config.Config()
+        config_properties = vars(config)
+        new_config = config.merge(other_config)
+        # Ensure that the values all stayed the same in the new config
+        self.assertEqual(config_properties, vars(new_config))
+
+    def test_merge_overrides_values(self):
+        config = botocore.config.Config(region_name='us-east-1')
+        other_config = botocore.config.Config(region_name='us-west-2')
+        new_config = config.merge(other_config)
+        self.assertEqual(new_config.region_name, 'us-west-2')
+
+    def test_merge_overrides_values_even_when_using_default(self):
+        config = botocore.config.Config(region_name='us-east-1')
+        other_config = botocore.config.Config(region_name=None)
+        new_config = config.merge(other_config)
+        self.assertEqual(new_config.region_name, None)
+
+    def test_merge_overrides_values_even_when_using_default_timeout(self):
+        config = botocore.config.Config(read_timeout=30)
+        other_config = botocore.config.Config(read_timeout=DEFAULT_TIMEOUT)
+        new_config = config.merge(other_config)
+        self.assertEqual(new_config.read_timeout, DEFAULT_TIMEOUT)
+
+    def test_merge_overrides_only_when_user_provided_values(self):
+        config = botocore.config.Config(
+            region_name='us-east-1', signature_version='s3v4'
+        )
+        other_config = botocore.config.Config(region_name='us-west-2')
+        new_config = config.merge(other_config)
+        self.assertEqual(new_config.region_name, 'us-west-2')
+        self.assertEqual(new_config.signature_version, 's3v4')
+
+    def test_can_set_retry_max_attempts(self):
+        config = botocore.config.Config(retries={'max_attempts': 15})
+        self.assertEqual(config.retries['max_attempts'], 15)
+
+    def test_validates_retry_config(self):
+        with self.assertRaisesRegex(
+            InvalidRetryConfigurationError,
+            'Cannot provide retry configuration for "not-allowed"',
+        ):
+            botocore.config.Config(retries={'not-allowed': True})
+
+    def test_validates_max_retry_attempts(self):
+        with self.assertRaises(InvalidMaxRetryAttemptsError):
+            botocore.config.Config(retries={'max_attempts': -1})
+
+    def test_validates_total_max_attempts(self):
+        with self.assertRaises(InvalidMaxRetryAttemptsError):
+            botocore.config.Config(retries={'total_max_attempts': 0})
+
+    def test_validaties_retry_mode(self):
+        with self.assertRaises(InvalidRetryModeError):
+            botocore.config.Config(retries={'mode': 'turbo-mode'})
+
+
+class TestClientEndpointBridge(unittest.TestCase):
+    def setUp(self):
+        self.resolver = mock.Mock()
+        self.boilerplate_response = {
+            'endpointName': 'us-east-1',
+            'hostname': 's3.amazonaws.com',
+            'partition': 'aws',
+            'protocols': ['http', 'https'],
+            'dnsSuffix': 'amazonaws.com',
+            'signatureVersions': ['s3', 's3v4'],
+        }
+        self.resolver.construct_endpoint.return_value = (
+            self.boilerplate_response
+        )
+
+    def test_guesses_endpoint_as_last_resort(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = None
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('myservice', region_name='guess')
+        self.assertEqual('guess', resolved['region_name'])
+        self.assertEqual('guess', resolved['signing_region'])
+        self.assertEqual('myservice', resolved['signing_name'])
+        self.assertEqual('myservice', resolved['service_name'])
+        self.assertEqual('v4', resolved['signature_version'])
+        self.assertEqual(
+            'https://myservice.guess.amazonaws.com', resolved['endpoint_url']
+        )
+
+    def test_uses_us_east_1_by_default_for_s3(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 's3.amazonaws.com',
+            'endpointName': 'us-east-1',
+            'signatureVersions': ['s3', 's3v4'],
+            'protocols': ['https'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('s3')
+        self.assertEqual('us-east-1', resolved['region_name'])
+        self.assertEqual('us-east-1', resolved['signing_region'])
+        self.assertEqual('https://s3.amazonaws.com', resolved['endpoint_url'])
+
+    def test_uses_region_from_client_config_if_available(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = None
+        client_config = mock.Mock()
+        client_config.region_name = 'us-foo-bar'
+        bridge = ClientEndpointBridge(resolver, client_config=client_config)
+        resolved = bridge.resolve('test')
+        self.assertEqual('us-foo-bar', resolved['region_name'])
+        self.assertEqual('us-foo-bar', resolved['signing_region'])
+        self.assertEqual(
+            'https://test.us-foo-bar.amazonaws.com', resolved['endpoint_url']
+        )
+
+    def test_can_guess_endpoint_and_use_given_endpoint_url(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = None
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve(
+            'test', 'guess', endpoint_url='http://test.com'
+        )
+        self.assertEqual('guess', resolved['region_name'])
+        self.assertEqual('guess', resolved['signing_region'])
+        self.assertEqual('http://test.com', resolved['endpoint_url'])
+
+    def test_can_use_endpoint_url_with_resolved_endpoint(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'do-not-use-this',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['v2'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve(
+            'ec2', 'us-west-2', endpoint_url='https://foo'
+        )
+        self.assertEqual('us-west-2', resolved['region_name'])
+        self.assertEqual('us-west-2', resolved['signing_region'])
+        self.assertEqual('https://foo', resolved['endpoint_url'])
+        self.assertEqual('v2', resolved['signature_version'])
+
+    def test_can_create_http_urls(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'host.com',
+            'signatureVersions': ['v4'],
+            'endpointName': 'us-foo-baz',
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('myservice', 'us-foo-baz', is_secure=False)
+        self.assertEqual('http://host.com', resolved['endpoint_url'])
+
+    def test_credential_scope_overrides_signing_region(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'host.com',
+            'endpointName': 'us-foo-baz',
+            'signatureVersions': ['v4'],
+            'credentialScope': {'region': 'override'},
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('myservice', 'us-foo-baz')
+        self.assertEqual('us-foo-baz', resolved['region_name'])
+        self.assertEqual('override', resolved['signing_region'])
+
+    def test_cred_scope_does_not_override_signing_region_if_endpoint_url(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'will-not-use.com',
+            'endpointName': 'us-foo-baz',
+            'signatureVersions': ['v4'],
+            'credentialScope': {'region': 'override'},
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve(
+            'myservice', 'us-foo-baz', endpoint_url='https://override.com'
+        )
+        self.assertEqual('us-foo-baz', resolved['region_name'])
+        self.assertEqual('us-foo-baz', resolved['signing_region'])
+        self.assertEqual('https://override.com', resolved['endpoint_url'])
+
+    def test_resolved_region_overrides_region_when_no_endpoint_url(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'host.com',
+            'signatureVersions': ['v4'],
+            'endpointName': 'override',
+            'protocols': ['https'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('myservice', 'will-not-be-there')
+        self.assertEqual('override', resolved['region_name'])
+        self.assertEqual('override', resolved['signing_region'])
+        self.assertEqual('https://host.com', resolved['endpoint_url'])
+
+    def test_does_not_use_https_if_not_available(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'host.com',
+            'signatureVersions': ['v4'],
+            'endpointName': 'foo',
+            # Note: http, not https
+            'protocols': ['http'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('myservice')
+        # We should resolve to http://, not https://
+        self.assertEqual('http://host.com', resolved['endpoint_url'])
+
+    def test_uses_signature_version_from_client_config(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test.com',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['v2'],
+        }
+        client_config = mock.Mock()
+        client_config.signature_version = 's3'
+        bridge = ClientEndpointBridge(resolver, client_config=client_config)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('s3', resolved['signature_version'])
+
+    def test_uses_signature_version_from_client_config_when_guessing(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = None
+        client_config = mock.Mock()
+        client_config.signature_version = 's3v4'
+        bridge = ClientEndpointBridge(resolver, client_config=client_config)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('s3v4', resolved['signature_version'])
+
+    def test_uses_signature_version_from_scoped_config(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test.com',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['v2'],
+        }
+        scoped_config = mock.Mock()
+        scoped_config.get.return_value = {'signature_version': 's3'}
+        bridge = ClientEndpointBridge(resolver, scoped_config)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('s3', resolved['signature_version'])
+
+    def test_uses_s3v4_over_s3_for_s3(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test.com',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['s3v4', 's3'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('s3', 'us-west-2')
+        self.assertEqual('s3v4', resolved['signature_version'])
+
+    def test_uses_s3v4_over_others_for_s3(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test.com',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['s3v4', 'v4'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('s3', 'us-west-2')
+        self.assertEqual('s3v4', resolved['signature_version'])
+
+    def test_uses_v4_over_other_signers(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'signatureVersions': ['v2', 'v4'],
+            'endpointName': 'us-west-2',
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('v4', resolved['signature_version'])
+
+    def test_uses_known_signers_from_list_of_signature_versions(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'signatureVersions': ['foo', 'baz', 'v3https'],
+            'endpointName': 'us-west-2',
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('v3https', resolved['signature_version'])
+
+    def test_raises_when_signature_version_is_unknown(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['foo'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        with self.assertRaises(UnknownSignatureVersionError):
+            bridge.resolve('test', 'us-west-2')
+
+    def test_uses_first_known_signature_version(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['foo', 'bar', 'baz', 's3v4', 'v2'],
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('s3v4', resolved['signature_version'])
+
+    def test_raises_when_signature_version_is_not_found(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'endpointName': 'us-west-2',
+        }
+        bridge = ClientEndpointBridge(resolver)
+        with self.assertRaises(UnknownSignatureVersionError):
+            bridge.resolve('test', 'us-west-2')
+
+    def test_uses_service_name_as_signing_name(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'signatureVersions': ['v4'],
+            'endpointName': 'us-west-2',
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('test', resolved['signing_name'])
+
+    def test_uses_credential_scope_signing_name(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'endpointName': 'us-west-2',
+            'signatureVersions': ['v4'],
+            'credentialScope': {'service': 'override'},
+        }
+        bridge = ClientEndpointBridge(resolver)
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('override', resolved['signing_name'])
+
+    def test_uses_service_signing_name_when_present_and_no_cred_scope(self):
+        resolver = mock.Mock()
+        resolver.construct_endpoint.return_value = {
+            'partition': 'aws',
+            'hostname': 'test',
+            'signatureVersions': ['v4'],
+            'endpointName': 'us-west-2',
+        }
+        bridge = ClientEndpointBridge(resolver, service_signing_name='foo')
+        resolved = bridge.resolve('test', 'us-west-2')
+        self.assertEqual('foo', resolved['signing_name'])
+
+    def test_disable_dualstack_explicitly(self):
+        scoped_config = {'s3': {'use_dualstack_endpoint': True}}
+        config = botocore.config.Config(s3={'use_dualstack_endpoint': False})
+        bridge = ClientEndpointBridge(
+            self.resolver, scoped_config, client_config=config
+        )
+        resolved = bridge.resolve('s3', 'us-east-1')
+        self.assertEqual(resolved['endpoint_url'], 'https://s3.amazonaws.com')
+
+    def test_use_dualstack_endpoint(self):
+        config = botocore.config.Config(use_dualstack_endpoint=True)
+        bridge = ClientEndpointBridge(self.resolver, client_config=config)
+        bridge.resolve('ec2', 'us-west-2')
+        self.resolver.construct_endpoint.assert_called_with(
+            'ec2',
+            'us-west-2',
+            use_dualstack_endpoint=True,
+            use_fips_endpoint=False,
+        )
+
+    def test_use_fips_endpoint(self):
+        config = botocore.config.Config(use_fips_endpoint=True)
+        bridge = ClientEndpointBridge(self.resolver, client_config=config)
+        bridge.resolve('ec2', 'us-west-2')
+        self.resolver.construct_endpoint.assert_called_with(
+            'ec2',
+            'us-west-2',
+            use_dualstack_endpoint=False,
+            use_fips_endpoint=True,
+        )
+
+    def test_use_dualstack_endpoint_omits_s3(self):
+        config = botocore.config.Config(
+            use_dualstack_endpoint=True, s3={'use_dualstack_endpoint': False}
+        )
+        bridge = ClientEndpointBridge(self.resolver, client_config=config)
+        bridge.resolve('s3', 'us-west-2')
+        self.resolver.construct_endpoint.assert_called_with(
+            's3',
+            'us-west-2',
+            use_dualstack_endpoint=False,
+            use_fips_endpoint=False,
+        )
+
+    def test_modeled_endpoint_variants_client_config_trumps_scoped_config(
+        self,
+    ):
+        scoped_config = {
+            'use_dualstack_endpoint': True,
+            'use_fips_endpoint': True,
+        }
+        config = botocore.config.Config(
+            use_dualstack_endpoint=False, use_fips_endpoint=False
+        )
+        bridge = ClientEndpointBridge(
+            self.resolver, scoped_config, client_config=config
+        )
+        bridge.resolve('ec2', 'us-west-2')
+        self.resolver.construct_endpoint.assert_called_with(
+            'ec2',
+            'us-west-2',
+            use_dualstack_endpoint=False,
+            use_fips_endpoint=False,
+        )
+
+    def test_modeled_endpoint_variants_tags_using_config_store(self):
+        config_store = mock.Mock()
+        config_store.get_config_variable.return_value = True
+        bridge = ClientEndpointBridge(self.resolver, config_store=config_store)
+        bridge.resolve('ec2', 'us-west-2')
+        self.resolver.construct_endpoint.assert_called_with(
+            'ec2',
+            'us-west-2',
+            use_dualstack_endpoint=True,
+            use_fips_endpoint=True,
+        )

testbed/boto__botocore/tests/unit/test_compress.py

@@ -0,0 +1,322 @@
+# Copyright 2023 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import gzip
+import io
+import sys
+
+import pytest
+
+import botocore
+from botocore.compress import COMPRESSION_MAPPING, maybe_compress_request
+from botocore.config import Config
+from tests import mock
+
+
+def _make_op(
+    request_compression=None,
+    has_streaming_input=False,
+    streaming_metadata=None,
+):
+    op = mock.Mock()
+    op.request_compression = request_compression
+    op.has_streaming_input = has_streaming_input
+    if streaming_metadata is not None:
+        streaming_shape = mock.Mock()
+        streaming_shape.metadata = streaming_metadata
+        op.get_streaming_input.return_value = streaming_shape
+    return op
+
+
+OP_NO_COMPRESSION = _make_op()
+OP_WITH_COMPRESSION = _make_op({'encodings': ['gzip']})
+OP_UNKNOWN_COMPRESSION = _make_op({'encodings': ['foo']})
+OP_MULTIPLE_COMPRESSIONS = _make_op({'encodings': ['gzip', 'foo']})
+STREAMING_OP_WITH_COMPRESSION = _make_op(
+    {'encodings': ['gzip']},
+    True,
+    {},
+)
+STREAMING_OP_WITH_COMPRESSION_REQUIRES_LENGTH = _make_op(
+    {'encodings': ['gzip']},
+    True,
+    {'requiresLength': True},
+)
+
+
+REQUEST_BODY = (
+    b'Action=PutMetricData&Version=2010-08-01&Namespace=Namespace'
+    b'&MetricData.member.1.MetricName=metric&MetricData.member.1.Unit=Bytes'
+    b'&MetricData.member.1.Value=128'
+)
+REQUEST_BODY_COMPRESSED = (
+    b'\x1f\x8b\x08\x00\x01\x00\x00\x00\x02\xffsL.\xc9\xcc\xcf\xb3\r(-\xf1M-)'
+    b'\xcaLvI,IT\x0bK-*\x06\x89\x1a\x19\x18\x1a\xe8\x1aX\xe8\x1a\x18\xaa\xf9%'
+    b'\xe6\xa6\x16\x17$&\xa7\xda\xc2Yj\x08\x1dz\xb9\xa9\xb9I\xa9Ez\x86z\x101\x90'
+    b'\x1a\xdb\\0\x13\xab\xaa\xd0\xbc\xcc\x12[\xa7\xca\x92\xd4b\xac\xd2a\x899\xa5'
+    b'\xa9\xb6\x86F\x16\x00\x1e\xdd\t\xfd\x9e\x00\x00\x00'
+)
+
+
+COMPRESSION_CONFIG_128_BYTES = Config(
+    disable_request_compression=False,
+    request_min_compression_size_bytes=128,
+)
+COMPRESSION_CONFIG_1_BYTE = Config(
+    disable_request_compression=False,
+    request_min_compression_size_bytes=1,
+)
+
+
+class NonSeekableStream:
+    def __init__(self, buffer):
+        self._buffer = buffer
+
+    def read(self, size=None):
+        return self._buffer.read(size)
+
+
+def _request_dict(body=REQUEST_BODY, headers=None):
+    if headers is None:
+        headers = {}
+
+    return {
+        'body': body,
+        'headers': headers,
+    }
+
+
+def request_dict_non_seekable_text_stream():
+    stream = NonSeekableStream(io.StringIO(REQUEST_BODY.decode('utf-8')))
+    return _request_dict(stream)
+
+
+def request_dict_non_seekable_bytes_stream():
+    return _request_dict(NonSeekableStream(io.BytesIO(REQUEST_BODY)))
+
+
+class StaticGzipFile(gzip.GzipFile):
+    def __init__(self, *args, **kwargs):
+        kwargs['mtime'] = 1
+        super().__init__(*args, **kwargs)
+
+
+def static_compress(*args, **kwargs):
+    kwargs['mtime'] = 1
+    return gzip.compress(*args, **kwargs)
+
+
+def _bad_compression(body):
+    raise ValueError('Reached unintended compression algorithm "foo"')
+
+
+MOCK_COMPRESSION = {'foo': _bad_compression}
+MOCK_COMPRESSION.update(COMPRESSION_MAPPING)
+
+
+def _assert_compression_body(compressed_body, expected_body):
+    data = compressed_body
+    if hasattr(compressed_body, 'read'):
+        data = compressed_body.read()
+    assert data == expected_body
+
+
+def _assert_compression_header(headers, encoding='gzip'):
+    assert 'Content-Encoding' in headers
+    assert encoding in headers['Content-Encoding']
+
+
+def assert_request_compressed(request_dict, expected_body):
+    _assert_compression_body(request_dict['body'], expected_body)
+    _assert_compression_header(request_dict['headers'])
+
+
+@pytest.mark.parametrize(
+    'request_dict, operation_model',
+    [
+        (
+            _request_dict(),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            _request_dict(),
+            OP_MULTIPLE_COMPRESSIONS,
+        ),
+        (
+            _request_dict(),
+            STREAMING_OP_WITH_COMPRESSION,
+        ),
+        (
+            _request_dict(bytearray(REQUEST_BODY)),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            _request_dict(headers={'Content-Encoding': 'identity'}),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            _request_dict(REQUEST_BODY.decode('utf-8')),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            _request_dict(io.BytesIO(REQUEST_BODY)),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            _request_dict(io.StringIO(REQUEST_BODY.decode('utf-8'))),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            request_dict_non_seekable_bytes_stream(),
+            STREAMING_OP_WITH_COMPRESSION,
+        ),
+        (
+            request_dict_non_seekable_text_stream(),
+            STREAMING_OP_WITH_COMPRESSION,
+        ),
+    ],
+)
+@mock.patch.object(botocore.compress, 'GzipFile', StaticGzipFile)
+@mock.patch.object(botocore.compress, 'gzip_compress', static_compress)
+@pytest.mark.skipif(
+    sys.version_info < (3, 8), reason='requires python3.8 or higher'
+)
+def test_compression(request_dict, operation_model):
+    maybe_compress_request(
+        COMPRESSION_CONFIG_128_BYTES, request_dict, operation_model
+    )
+    assert_request_compressed(request_dict, REQUEST_BODY_COMPRESSED)
+
+
+@pytest.mark.parametrize(
+    'config, request_dict, operation_model',
+    [
+        (
+            Config(
+                disable_request_compression=True,
+                request_min_compression_size_bytes=1,
+            ),
+            _request_dict(),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            Config(
+                disable_request_compression=False,
+                request_min_compression_size_bytes=256,
+            ),
+            _request_dict(),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            Config(
+                disable_request_compression=False,
+                request_min_compression_size_bytes=1,
+                signature_version='v2',
+            ),
+            _request_dict(),
+            OP_WITH_COMPRESSION,
+        ),
+        (
+            COMPRESSION_CONFIG_128_BYTES,
+            _request_dict(),
+            STREAMING_OP_WITH_COMPRESSION_REQUIRES_LENGTH,
+        ),
+        (
+            COMPRESSION_CONFIG_128_BYTES,
+            _request_dict(),
+            OP_NO_COMPRESSION,
+        ),
+        (
+            COMPRESSION_CONFIG_128_BYTES,
+            _request_dict(),
+            OP_UNKNOWN_COMPRESSION,
+        ),
+        (
+            COMPRESSION_CONFIG_128_BYTES,
+            _request_dict(headers={'Content-Encoding': 'identity'}),
+            OP_UNKNOWN_COMPRESSION,
+        ),
+        (
+            COMPRESSION_CONFIG_128_BYTES,
+            request_dict_non_seekable_bytes_stream(),
+            OP_WITH_COMPRESSION,
+        ),
+    ],
+)
+def test_no_compression(config, request_dict, operation_model):
+    ce_header = request_dict['headers'].get('Content-Encoding')
+    original_body = request_dict['body']
+    maybe_compress_request(config, request_dict, operation_model)
+    assert request_dict['body'] == original_body
+    assert ce_header == request_dict['headers'].get('Content-Encoding')
+
+
+@pytest.mark.parametrize(
+    'operation_model, expected_body',
+    [
+        (
+            OP_WITH_COMPRESSION,
+            (
+                b'\x1f\x8b\x08\x00\x01\x00\x00\x00\x02\xffK\xcb'
+                b'\xcf\xb7MJ,\x02\x00v\x8e5\x1c\x07\x00\x00\x00'
+            ),
+        ),
+        (OP_NO_COMPRESSION, {'foo': 'bar'}),
+    ],
+)
+@mock.patch.object(botocore.compress, 'gzip_compress', static_compress)
+@pytest.mark.skipif(
+    sys.version_info < (3, 8), reason='requires python3.8 or higher'
+)
+def test_dict_compression(operation_model, expected_body):
+    request_dict = _request_dict({'foo': 'bar'})
+    maybe_compress_request(
+        COMPRESSION_CONFIG_1_BYTE, request_dict, operation_model
+    )
+    body = request_dict['body']
+    assert body == expected_body
+
+
+@pytest.mark.parametrize('body', [1, object(), True, 1.0])
+def test_maybe_compress_bad_types(body):
+    request_dict = _request_dict(body)
+    maybe_compress_request(
+        COMPRESSION_CONFIG_1_BYTE, request_dict, OP_WITH_COMPRESSION
+    )
+    assert request_dict['body'] == body
+
+
+@mock.patch.object(botocore.compress, 'GzipFile', StaticGzipFile)
+def test_body_streams_position_reset():
+    request_dict = _request_dict(io.BytesIO(REQUEST_BODY))
+    maybe_compress_request(
+        COMPRESSION_CONFIG_128_BYTES,
+        request_dict,
+        OP_WITH_COMPRESSION,
+    )
+    assert request_dict['body'].tell() == 0
+    assert_request_compressed(request_dict, REQUEST_BODY_COMPRESSED)
+
+
+@mock.patch.object(botocore.compress, 'gzip_compress', static_compress)
+@mock.patch.object(botocore.compress, 'COMPRESSION_MAPPING', MOCK_COMPRESSION)
+@pytest.mark.skipif(
+    sys.version_info < (3, 8), reason='requires python3.8 or higher'
+)
+def test_only_compress_once():
+    request_dict = _request_dict()
+    maybe_compress_request(
+        COMPRESSION_CONFIG_128_BYTES,
+        request_dict,
+        OP_MULTIPLE_COMPRESSIONS,
+    )
+    assert_request_compressed(request_dict, REQUEST_BODY_COMPRESSED)

testbed/boto__botocore/tests/unit/test_config_provider.py

@@ -0,0 +1,1148 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import copy
+import os
+
+import pytest
+
+import botocore.configprovider
+import botocore.session as session
+from botocore.configprovider import (
+    BaseProvider,
+    ChainProvider,
+    ConfigChainFactory,
+    ConfiguredEndpointProvider,
+    ConfigValueStore,
+    ConstantProvider,
+    DefaultConfigResolver,
+    EnvironmentProvider,
+    InstanceVarProvider,
+    ScopedConfigProvider,
+    SectionConfigProvider,
+    SmartDefaultsConfigStoreFactory,
+)
+from botocore.exceptions import ConnectTimeoutError
+from botocore.utils import IMDSRegionProvider
+from tests import mock, unittest
+
+
+class TestConfigChainFactory(unittest.TestCase):
+    def assert_chain_does_provide(
+        self,
+        instance_map,
+        environ_map,
+        scoped_config_map,
+        create_config_chain_args,
+        expected_value,
+    ):
+        fake_session = mock.Mock(spec=session.Session)
+        fake_session.get_scoped_config.return_value = scoped_config_map
+        fake_session.instance_variables.return_value = instance_map
+        builder = ConfigChainFactory(fake_session, environ=environ_map)
+        chain = builder.create_config_chain(**create_config_chain_args)
+        value = chain.provide()
+        self.assertEqual(value, expected_value)
+
+    def test_chain_builder_can_provide_instance(self):
+        self.assert_chain_does_provide(
+            instance_map={'instance_var': 'from-instance'},
+            environ_map={},
+            scoped_config_map={},
+            create_config_chain_args={
+                'instance_name': 'instance_var',
+            },
+            expected_value='from-instance',
+        )
+
+    def test_chain_builder_can_skip_instance(self):
+        self.assert_chain_does_provide(
+            instance_map={'wrong_instance_var': 'instance'},
+            environ_map={'ENV_VAR': 'env'},
+            scoped_config_map={},
+            create_config_chain_args={
+                'instance_name': 'instance_var',
+                'env_var_names': 'ENV_VAR',
+            },
+            expected_value='env',
+        )
+
+    def test_chain_builder_can_provide_env_var(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={'ENV_VAR': 'from-env'},
+            scoped_config_map={},
+            create_config_chain_args={
+                'env_var_names': 'ENV_VAR',
+            },
+            expected_value='from-env',
+        )
+
+    def test_does_provide_none_if_no_variable_exists_in_env_var_list(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={},
+            create_config_chain_args={
+                'env_var_names': ['FOO'],
+            },
+            expected_value=None,
+        )
+
+    def test_does_provide_value_if_variable_exists_in_env_var_list(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={'FOO': 'bar'},
+            scoped_config_map={},
+            create_config_chain_args={
+                'env_var_names': ['FOO'],
+            },
+            expected_value='bar',
+        )
+
+    def test_does_provide_first_non_none_value_first_in_env_var_list(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={'FOO': 'baz'},
+            scoped_config_map={},
+            create_config_chain_args={
+                'env_var_names': ['FOO', 'BAR'],
+            },
+            expected_value='baz',
+        )
+
+    def test_does_provide_first_non_none_value_second_in_env_var_list(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={'BAR': 'baz'},
+            scoped_config_map={},
+            create_config_chain_args={
+                'env_var_names': ['FOO', 'BAR'],
+            },
+            expected_value='baz',
+        )
+
+    def test_does_provide_none_if_all_list_env_vars_are_none(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={},
+            create_config_chain_args={
+                'env_var_names': ['FOO', 'BAR'],
+            },
+            expected_value=None,
+        )
+
+    def test_does_provide_first_value_when_both_env_vars_exist(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={'FOO': 'baz', 'BAR': 'buz'},
+            scoped_config_map={},
+            create_config_chain_args={
+                'env_var_names': ['FOO', 'BAR'],
+            },
+            expected_value='baz',
+        )
+
+    def test_chain_builder_can_provide_config_var(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={'config_var': 'from-config'},
+            create_config_chain_args={
+                'config_property_names': 'config_var',
+            },
+            expected_value='from-config',
+        )
+
+    def test_chain_builder_can_provide_nested_config_var(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={'config_var': {'nested-key': 'nested-val'}},
+            create_config_chain_args={
+                'config_property_names': ('config_var', 'nested-key'),
+            },
+            expected_value='nested-val',
+        )
+
+    def test_provide_value_from_config_list(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={'var': 'val'},
+            create_config_chain_args={
+                'config_property_names': ['var'],
+            },
+            expected_value='val',
+        )
+
+    def test_provide_value_from_config_list_looks_for_non_none_vals(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={'non_none_var': 'non_none_val'},
+            create_config_chain_args={
+                'config_property_names': ['none_var', 'non_none_var'],
+            },
+            expected_value='non_none_val',
+        )
+
+    def test_provide_value_from_config_list_retrieves_first_non_none_val(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={'first': 'first_val', 'second': 'second_val'},
+            create_config_chain_args={
+                'config_property_names': ['first', 'second'],
+            },
+            expected_value='first_val',
+        )
+
+    def test_provide_value_from_config_list_if_all_vars_are_none(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={},
+            create_config_chain_args={
+                'config_property_names': ['config1', 'config2'],
+            },
+            expected_value=None,
+        )
+
+    def test_provide_value_from_list_with_nested_var(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={'section': {'nested_var': 'nested_val'}},
+            create_config_chain_args={
+                'config_property_names': [('section', 'nested_var')],
+            },
+            expected_value='nested_val',
+        )
+
+    def test_chain_builder_can_provide_default(self):
+        self.assert_chain_does_provide(
+            instance_map={},
+            environ_map={},
+            scoped_config_map={},
+            create_config_chain_args={'default': 'from-default'},
+            expected_value='from-default',
+        )
+
+    def test_chain_provider_does_follow_priority_instance_var(self):
+        self.assert_chain_does_provide(
+            instance_map={'instance_var': 'from-instance'},
+            environ_map={'ENV_VAR': 'from-env'},
+            scoped_config_map={'config_var': 'from-config'},
+            create_config_chain_args={
+                'instance_name': 'instance_var',
+                'env_var_names': 'ENV_VAR',
+                'config_property_names': 'config_var',
+                'default': 'from-default',
+            },
+            expected_value='from-instance',
+        )
+
+    def test_chain_provider_does_follow_priority_env_var(self):
+        self.assert_chain_does_provide(
+            instance_map={'wrong_instance_var': 'from-instance'},
+            environ_map={'ENV_VAR': 'from-env'},
+            scoped_config_map={'config_var': 'from-confi'},
+            create_config_chain_args={
+                'instance_name': 'instance_var',
+                'env_var_names': 'ENV_VAR',
+                'config_property_names': 'config_var',
+                'default': 'from-default',
+            },
+            expected_value='from-env',
+        )
+
+    def test_chain_provider_does_follow_priority_config(self):
+        self.assert_chain_does_provide(
+            instance_map={'wrong_instance_var': 'from-instance'},
+            environ_map={'WRONG_ENV_VAR': 'from-env'},
+            scoped_config_map={'config_var': 'from-config'},
+            create_config_chain_args={
+                'instance_name': 'instance_var',
+                'env_var_names': 'ENV_VAR',
+                'config_property_names': 'config_var',
+                'default': 'from-default',
+            },
+            expected_value='from-config',
+        )
+
+    def test_chain_provider_does_follow_priority_default(self):
+        self.assert_chain_does_provide(
+            instance_map={'wrong_instance_var': 'from-instance'},
+            environ_map={'WRONG_ENV_VAR': 'from-env'},
+            scoped_config_map={'wrong_config_var': 'from-config'},
+            create_config_chain_args={
+                'instance_name': 'instance_var',
+                'env_var_names': 'ENV_VAR',
+                'config_property_names': 'config_var',
+                'default': 'from-default',
+            },
+            expected_value='from-default',
+        )
+
+
+class TestConfigValueStore(unittest.TestCase):
+    def test_does_provide_none_if_no_variable_exists(self):
+        provider = ConfigValueStore()
+        value = provider.get_config_variable('fake_variable')
+        self.assertIsNone(value)
+
+    def test_does_provide_value_if_variable_exists(self):
+        mock_value_provider = mock.Mock(spec=BaseProvider)
+        mock_value_provider.provide.return_value = 'foo'
+        provider = ConfigValueStore(
+            mapping={
+                'fake_variable': mock_value_provider,
+            }
+        )
+        value = provider.get_config_variable('fake_variable')
+        self.assertEqual(value, 'foo')
+
+    def test_can_set_variable(self):
+        provider = ConfigValueStore()
+        provider.set_config_variable('fake_variable', 'foo')
+        value = provider.get_config_variable('fake_variable')
+        self.assertEqual(value, 'foo')
+
+    def test_can_set_config_provider(self):
+        foo_value_provider = mock.Mock(spec=BaseProvider)
+        foo_value_provider.provide.return_value = 'foo'
+        provider = ConfigValueStore(
+            mapping={
+                'fake_variable': foo_value_provider,
+            }
+        )
+
+        value = provider.get_config_variable('fake_variable')
+        self.assertEqual(value, 'foo')
+
+        bar_value_provider = mock.Mock(spec=BaseProvider)
+        bar_value_provider.provide.return_value = 'bar'
+        provider.set_config_provider('fake_variable', bar_value_provider)
+
+        value = provider.get_config_variable('fake_variable')
+        self.assertEqual(value, 'bar')
+
+    def test_can_get_config_provider(self):
+        chain_provider = ChainProvider(
+            providers=[ConstantProvider(value='bar')]
+        )
+        config_value_store = ConfigValueStore(
+            mapping={
+                'fake_variable': chain_provider,
+            }
+        )
+        provider = config_value_store.get_config_provider('fake_variable')
+        value = config_value_store.get_config_variable('fake_variable')
+        self.assertIsInstance(provider, ChainProvider)
+        self.assertEqual(value, 'bar')
+
+    def test_can_get_config_provider_non_chain_provider(self):
+        constant_provider = ConstantProvider(value='bar')
+        config_value_store = ConfigValueStore(
+            mapping={
+                'fake_variable': constant_provider,
+            }
+        )
+        provider = config_value_store.get_config_provider('fake_variable')
+        value = config_value_store.get_config_variable('fake_variable')
+        self.assertIsInstance(provider, ConstantProvider)
+        self.assertEqual(value, 'bar')
+
+    def test_deepcopy_preserves_overrides(self):
+        provider = ConstantProvider(100)
+        config_store = ConfigValueStore(mapping={'fake_variable': provider})
+        config_store.set_config_variable('fake_variable', 'override-value')
+
+        config_store_deepcopy = copy.deepcopy(config_store)
+
+        value = config_store_deepcopy.get_config_variable('fake_variable')
+        self.assertEqual(value, 'override-value')
+
+    def test_copy_preserves_provider_identities(self):
+        fake_variable_provider = ConstantProvider(100)
+        config_store = ConfigValueStore(
+            mapping={
+                'fake_variable': fake_variable_provider,
+            }
+        )
+
+        config_store_copy = copy.copy(config_store)
+
+        self.assertIs(
+            config_store.get_config_provider('fake_variable'),
+            config_store_copy.get_config_provider('fake_variable'),
+        )
+
+    def test_copy_preserves_overrides(self):
+        provider = ConstantProvider(100)
+        config_store = ConfigValueStore(mapping={'fake_variable': provider})
+        config_store.set_config_variable('fake_variable', 'override-value')
+
+        config_store_copy = copy.copy(config_store)
+
+        value = config_store_copy.get_config_variable('fake_variable')
+        self.assertEqual(value, 'override-value')
+
+    def test_copy_update_does_not_mutate_source_config_store(self):
+        fake_variable_provider = ConstantProvider(100)
+        config_store = ConfigValueStore(
+            mapping={
+                'fake_variable': fake_variable_provider,
+            }
+        )
+
+        config_store_copy = copy.copy(config_store)
+
+        another_variable_provider = ConstantProvider('ABC')
+
+        config_store_copy.set_config_provider(
+            'fake_variable', another_variable_provider
+        )
+
+        assert config_store.get_config_variable('fake_variable') == 100
+        assert config_store_copy.get_config_variable('fake_variable') == 'ABC'
+
+
+class TestInstanceVarProvider(unittest.TestCase):
+    def assert_provides_value(self, name, instance_map, expected_value):
+        fake_session = mock.Mock(spec=session.Session)
+        fake_session.instance_variables.return_value = instance_map
+
+        provider = InstanceVarProvider(
+            instance_var=name,
+            session=fake_session,
+        )
+        value = provider.provide()
+        self.assertEqual(value, expected_value)
+
+    def test_can_provide_value(self):
+        self.assert_provides_value(
+            name='foo',
+            instance_map={'foo': 'bar'},
+            expected_value='bar',
+        )
+
+    def test_does_provide_none_if_value_not_in_dict(self):
+        self.assert_provides_value(
+            name='foo',
+            instance_map={},
+            expected_value=None,
+        )
+
+
+class TestEnvironmentProvider(unittest.TestCase):
+    def assert_does_provide(self, env, name, expected_value):
+        provider = EnvironmentProvider(name=name, env=env)
+        value = provider.provide()
+        self.assertEqual(value, expected_value)
+
+    def test_does_provide_none_if_no_variable_exists(self):
+        self.assert_does_provide(
+            name='FOO',
+            env={},
+            expected_value=None,
+        )
+
+    def test_does_provide_value_if_variable_exists(self):
+        self.assert_does_provide(
+            name='FOO',
+            env={
+                'FOO': 'bar',
+            },
+            expected_value='bar',
+        )
+
+
+class TestScopedConfigProvider(unittest.TestCase):
+    def assert_provides_value(
+        self, config_file_values, config_var_name, expected_value
+    ):
+        fake_session = mock.Mock(spec=session.Session)
+        fake_session.get_scoped_config.return_value = config_file_values
+        property_provider = ScopedConfigProvider(
+            config_var_name=config_var_name,
+            session=fake_session,
+        )
+        value = property_provider.provide()
+        self.assertEqual(value, expected_value)
+
+    def test_can_provide_value(self):
+        self.assert_provides_value(
+            config_file_values={'foo': 'bar'},
+            config_var_name='foo',
+            expected_value='bar',
+        )
+
+    def test_does_provide_none_if_var_not_in_config(self):
+        self.assert_provides_value(
+            config_file_values={'foo': 'bar'},
+            config_var_name='no_such_var',
+            expected_value=None,
+        )
+
+    def test_provide_nested_value(self):
+        self.assert_provides_value(
+            config_file_values={'section': {'nested_var': 'nested_val'}},
+            config_var_name=('section', 'nested_var'),
+            expected_value='nested_val',
+        )
+
+    def test_provide_nested_value_but_not_section(self):
+        self.assert_provides_value(
+            config_file_values={'section': 'not-nested'},
+            config_var_name=('section', 'nested_var'),
+            expected_value=None,
+        )
+
+
+def _make_provider_that_returns(return_value):
+    provider = mock.Mock(spec=BaseProvider)
+    provider.provide.return_value = return_value
+    return provider
+
+
+def _make_providers_that_return(return_values):
+    mocks = []
+    for return_value in return_values:
+        provider = _make_provider_that_returns(return_value)
+        mocks.append(provider)
+    return mocks
+
+
+def assert_chain_does_provide(providers, expected_value):
+    provider = ChainProvider(
+        providers=providers,
+    )
+    assert provider.provide() == expected_value
+
+
+@pytest.mark.parametrize(
+    'case',
+    (
+        (None, []),
+        (None, [None]),
+        ('foo', ['foo']),
+        ('foo', ['foo', 'bar']),
+        ('bar', [None, 'bar']),
+        ('foo', ['foo', None]),
+        ('baz', [None, None, 'baz']),
+        ('bar', [None, 'bar', None]),
+        ('foo', ['foo', 'bar', None]),
+        ('foo', ['foo', 'bar', 'baz']),
+    ),
+)
+def test_chain_provider(case):
+    # Each case is a tuple with the first element being the expected return
+    # value from the ChainProvider. The second value being a list of return
+    # values from the individual providers that are in the chain.
+    assert_chain_does_provide(_make_providers_that_return(case[1]), case[0])
+
+
+class TestChainProvider(unittest.TestCase):
+    def test_can_convert_provided_value(self):
+        chain_provider = ChainProvider(
+            providers=_make_providers_that_return(['1']),
+            conversion_func=int,
+        )
+        value = chain_provider.provide()
+        self.assertIsInstance(value, int)
+        self.assertEqual(value, 1)
+
+
+class TestConstantProvider(unittest.TestCase):
+    def test_can_provide_value(self):
+        provider = ConstantProvider(value='foo')
+        value = provider.provide()
+        self.assertEqual(value, 'foo')
+
+
+class TestSectionConfigProvider(unittest.TestCase):
+    def assert_provides_value(
+        self,
+        config_file_values,
+        section_name,
+        expected_value,
+        override_providers=None,
+    ):
+        fake_session = mock.Mock(spec=session.Session)
+        fake_session.get_scoped_config.return_value = config_file_values
+        provider = SectionConfigProvider(
+            section_name=section_name,
+            session=fake_session,
+            override_providers=override_providers,
+        )
+        value = provider.provide()
+        self.assertEqual(value, expected_value)
+
+    def test_provide_section_config(self):
+        self.assert_provides_value(
+            config_file_values={'mysection': {'section_var': 'section_val'}},
+            section_name='mysection',
+            expected_value={'section_var': 'section_val'},
+        )
+
+    def test_provide_service_config_missing_service(self):
+        self.assert_provides_value(
+            config_file_values={},
+            section_name='mysection',
+            expected_value=None,
+        )
+
+    def test_provide_service_config_not_a_section(self):
+        self.assert_provides_value(
+            config_file_values={'myservice': 'not-a-section'},
+            section_name='mysection',
+            expected_value=None,
+        )
+
+    def test_provide_section_config_with_overrides(self):
+        self.assert_provides_value(
+            config_file_values={
+                'mysection': {
+                    'override_var': 'from_config_file',
+                    'no_override_var': 'from_config_file',
+                }
+            },
+            section_name='mysection',
+            override_providers={'override_var': ConstantProvider('override')},
+            expected_value={
+                'override_var': 'override',
+                'no_override_var': 'from_config_file',
+            },
+        )
+
+    def test_provide_section_config_with_only_overrides(self):
+        self.assert_provides_value(
+            config_file_values={},
+            section_name='mysection',
+            override_providers={'override_var': ConstantProvider('override')},
+            expected_value={
+                'override_var': 'override',
+            },
+        )
+
+
+class TestSmartDefaults:
+    def _template(self):
+        return {
+            "base": {
+                "retryMode": "standard",
+                "stsRegionalEndpoints": "regional",
+                "s3UsEast1RegionalEndpoints": "regional",
+                "connectTimeoutInMillis": 1000,
+                "tlsNegotiationTimeoutInMillis": 1000,
+            },
+            "modes": {
+                "standard": {
+                    "connectTimeoutInMillis": {"multiply": 2},
+                    "tlsNegotiationTimeoutInMillis": {"multiply": 2},
+                },
+                "in-region": {
+                    "connectTimeoutInMillis": {"multiply": 1},
+                    "tlsNegotiationTimeoutInMillis": {"multiply": 1},
+                },
+                "cross-region": {
+                    "connectTimeoutInMillis": {"multiply": 2.8},
+                    "tlsNegotiationTimeoutInMillis": {"multiply": 2.8},
+                },
+                "mobile": {
+                    "connectTimeoutInMillis": {"override": 10000},
+                    "tlsNegotiationTimeoutInMillis": {"add": 10000},
+                    "retryMode": {"override": "adaptive"},
+                },
+            },
+        }
+
+    def _create_default_config_resolver(self):
+        return DefaultConfigResolver(self._template())
+
+    @pytest.fixture
+    def smart_defaults_factory(self):
+        fake_session = mock.Mock(spec=session.Session)
+        fake_session.get_scoped_config.return_value = {}
+        default_config_resolver = self._create_default_config_resolver()
+        return SmartDefaultsConfigStoreFactory(
+            default_config_resolver, imds_region_provider=mock.Mock()
+        )
+
+    @pytest.fixture
+    def fake_session(self):
+        fake_session = mock.Mock(spec=session.Session)
+        fake_session.get_scoped_config.return_value = {}
+        return fake_session
+
+    def _create_config_value_store(self, s3_mapping={}, **override_kwargs):
+        constant_provider = ConstantProvider(value='my_sts_regional_endpoint')
+        environment_provider = EnvironmentProvider(
+            name='AWS_RETRY_MODE', env={'AWS_RETRY_MODE': None}
+        )
+        fake_session = mock.Mock(spec=session.Session)
+        fake_session.get_scoped_config.return_value = {}
+        # Testing with three different providers to validate
+        # SmartDefaultsConfigStoreFactory._get_new_chain_provider
+        mapping = {
+            'sts_regional_endpoints': ChainProvider(
+                providers=[constant_provider]
+            ),
+            'retry_mode': ChainProvider(providers=[environment_provider]),
+            's3': SectionConfigProvider('s3', fake_session, s3_mapping),
+        }
+        mapping.update(**override_kwargs)
+        config_store = ConfigValueStore(mapping=mapping)
+        return config_store
+
+    def _create_os_environ_patcher(self):
+        return mock.patch.object(
+            botocore.configprovider.os, 'environ', mock.Mock(wraps=os.environ)
+        )
+
+    def test_config_store_deepcopy(self):
+        config_store = ConfigValueStore()
+        config_store.set_config_provider(
+            'constant_value', ConstantProvider('ABC')
+        )
+        config_store_copy = copy.deepcopy(config_store)
+        config_store_copy.set_config_provider(
+            'constant_value_copy', ConstantProvider('123')
+        )
+        assert config_store.get_config_variable('constant_value_copy') is None
+        assert config_store_copy.get_config_variable('constant_value') == 'ABC'
+
+    def _create_config_value_store_to_test_merge(self):
+        environment_provider = EnvironmentProvider(
+            name='AWS_S3_US_EAST_1_REGIONAL_ENDPOINT',
+            env={},
+        )
+
+        s3_mapping = {
+            'us_east_1_regional_endpoint': ChainProvider(
+                providers=[environment_provider]
+            )
+        }
+
+        override_kwargs = {'connect_timeout': ConstantProvider(value=None)}
+
+        config_value_store = self._create_config_value_store(
+            s3_mapping=s3_mapping, **override_kwargs
+        )
+
+        return config_value_store
+
+    @pytest.mark.parametrize(
+        'config_variable,expected_value_before,expected_value_after',
+        [
+            ['retry_mode', None, 'standard'],
+            ['sts_regional_endpoints', 'my_sts_regional_endpoint', 'regional'],
+            ['connect_timeout', None, 2],
+            ['s3', None, {'us_east_1_regional_endpoint': 'regional'}],
+        ],
+    )
+    def test_config_store_providers_not_mutated_after_merge(
+        self,
+        config_variable,
+        expected_value_before,
+        expected_value_after,
+        smart_defaults_factory,
+    ):
+        """Test uses the standard default mode from the template"""
+
+        config_value_store = self._create_config_value_store_to_test_merge()
+
+        provider = config_value_store.get_config_provider(config_variable)
+
+        smart_defaults_factory.merge_smart_defaults(
+            config_value_store, 'standard', 'some-region'
+        )
+
+        assert provider.provide() == expected_value_before
+
+        assert (
+            config_value_store.get_config_variable(config_variable)
+            == expected_value_after
+        )
+
+    @pytest.mark.parametrize(
+        'defaults_mode, retry_mode, sts_regional_endpoints,'
+        ' us_east_1_regional_endpoint, connect_timeout',
+        [
+            ('standard', 'standard', 'regional', 'regional', 2000),
+            ('in-region', 'standard', 'regional', 'regional', 1000),
+            ('cross-region', 'standard', 'regional', 'regional', 2800),
+            ('mobile', 'adaptive', 'regional', 'regional', 10000),
+        ],
+    )
+    def test_get_defualt_config_values(
+        self,
+        defaults_mode,
+        retry_mode,
+        sts_regional_endpoints,
+        us_east_1_regional_endpoint,
+        connect_timeout,
+    ):
+        default_config_resolver = self._create_default_config_resolver()
+        default_values = default_config_resolver.get_default_config_values(
+            defaults_mode
+        )
+        assert default_values['retryMode'] == retry_mode
+        assert default_values['stsRegionalEndpoints'] == sts_regional_endpoints
+        assert (
+            default_values['s3UsEast1RegionalEndpoints']
+            == us_east_1_regional_endpoint
+        )
+        assert default_values['connectTimeoutInMillis'] == connect_timeout
+
+    def test_resolve_default_values_on_config(
+        self, smart_defaults_factory, fake_session
+    ):
+        config_store = self._create_config_value_store()
+        smart_defaults_factory.merge_smart_defaults(
+            config_store, 'standard', 'foo'
+        )
+        s3_config = config_store.get_config_variable('s3')
+        assert s3_config['us_east_1_regional_endpoint'] == 'regional'
+        assert config_store.get_config_variable('retry_mode') == 'standard'
+        assert (
+            config_store.get_config_variable('sts_regional_endpoints')
+            == 'regional'
+        )
+        assert config_store.get_config_variable('connect_timeout') == 2
+
+    def test_no_resolve_default_s3_values_on_config(
+        self, smart_defaults_factory
+    ):
+        environment_provider = EnvironmentProvider(
+            name='AWS_S3_US_EAST_1_REGIONAL_ENDPOINT',
+            env={'AWS_S3_US_EAST_1_REGIONAL_ENDPOINT': 'legacy'},
+        )
+        s3_mapping = {
+            'us_east_1_regional_endpoint': ChainProvider(
+                providers=[environment_provider]
+            )
+        }
+        config_store = self._create_config_value_store(s3_mapping=s3_mapping)
+        smart_defaults_factory.merge_smart_defaults(
+            config_store, 'standard', 'foo'
+        )
+        s3_config = config_store.get_config_variable('s3')
+        assert s3_config['us_east_1_regional_endpoint'] == 'legacy'
+        assert config_store.get_config_variable('retry_mode') == 'standard'
+        assert (
+            config_store.get_config_variable('sts_regional_endpoints')
+            == 'regional'
+        )
+        assert config_store.get_config_variable('connect_timeout') == 2
+
+    def test_resolve_default_s3_values_on_config(
+        self, smart_defaults_factory, fake_session
+    ):
+        s3_mapping = {
+            'use_arn_region': ChainProvider(
+                providers=[ConstantProvider(value=False)]
+            )
+        }
+        config_store = self._create_config_value_store(s3_mapping=s3_mapping)
+        smart_defaults_factory.merge_smart_defaults(
+            config_store, 'standard', 'foo'
+        )
+        s3_config = config_store.get_config_variable('s3')
+        assert s3_config['us_east_1_regional_endpoint'] == 'regional'
+        assert config_store.get_config_variable('retry_mode') == 'standard'
+        assert (
+            config_store.get_config_variable('sts_regional_endpoints')
+            == 'regional'
+        )
+        assert config_store.get_config_variable('connect_timeout') == 2
+
+    @pytest.mark.parametrize(
+        'execution_env_var, region_env_var, default_region_env_var, '
+        'imds_region, client_region, resolved_mode',
+        [
+            (
+                'AWS_Lambda_python3.6',
+                'us-east-1',
+                None,
+                None,
+                'us-east-1',
+                'in-region',
+            ),
+            (
+                'AWS_Lambda_python3.6',
+                'us-west-2',
+                'us-west-2',
+                None,
+                'us-east-1',
+                'cross-region',
+            ),
+            (
+                'AWS_Lambda_python3.6',
+                None,
+                None,
+                'us-west-2',
+                'us-east-1',
+                'cross-region',
+            ),
+            (None, None, 'us-east-1', 'us-east-1', 'us-east-1', 'in-region'),
+            (None, None, None, 'us-west-2', 'us-east-1', 'cross-region'),
+            (None, None, None, None, 'us-west-2', 'standard'),
+        ],
+    )
+    def test_resolve_auto_mode(
+        self,
+        execution_env_var,
+        region_env_var,
+        default_region_env_var,
+        imds_region,
+        client_region,
+        resolved_mode,
+    ):
+        imds_region_provider = mock.Mock(spec=IMDSRegionProvider)
+        imds_region_provider.provide.return_value = imds_region
+        default_config_resolver = mock.Mock()
+        with mock.patch.object(
+            botocore.configprovider.os, 'environ', mock.Mock(wraps=os.environ)
+        ) as os_environ_patcher:
+            os_environ_patcher.get.side_effect = [
+                execution_env_var,
+                default_region_env_var,
+                region_env_var,
+            ]
+            smart_defaults_factory = SmartDefaultsConfigStoreFactory(
+                default_config_resolver, imds_region_provider
+            )
+            mode = smart_defaults_factory.resolve_auto_mode(client_region)
+            assert mode == resolved_mode
+
+    def test_resolve_auto_mode_imds_region_provider_connect_timeout(self):
+        imds_region_provider = mock.Mock(spec=IMDSRegionProvider)
+        imds_region_provider.provide.side_effect = ConnectTimeoutError(
+            endpoint_url='foo'
+        )
+        default_config_resolver = mock.Mock()
+        with mock.patch.object(
+            botocore.configprovider.os, 'environ', mock.Mock(wraps=os.environ)
+        ) as os_environ_patcher:
+            os_environ_patcher.get.side_effect = [None] * 3
+            smart_defaults_factory = SmartDefaultsConfigStoreFactory(
+                default_config_resolver, imds_region_provider
+            )
+            mode = smart_defaults_factory.resolve_auto_mode('us-west-2')
+            assert mode == 'standard'
+
+
+def create_cases():
+    service = 'batch'
+
+    return [
+        dict(
+            service=service,
+            environ_map={},
+            full_config_map={},
+            expected_value=None,
+        ),
+        dict(
+            service=service,
+            environ_map={'AWS_ENDPOINT_URL': 'global-from-env'},
+            full_config_map={},
+            expected_value='global-from-env',
+        ),
+        dict(
+            service=service,
+            environ_map={
+                f'AWS_ENDPOINT_URL_{service.upper()}': 'service-from-env',
+                'AWS_ENDPOINT_URL': 'global-from-env',
+            },
+            full_config_map={},
+            expected_value='service-from-env',
+        ),
+        dict(
+            service=service,
+            environ_map={
+                'AWS_ENDPOINT_URL': 'global-from-env',
+                'AWS_ENDPOINT_URL_S3': 's3-endpoint-url',
+            },
+            full_config_map={},
+            expected_value='global-from-env',
+        ),
+        dict(
+            service=service,
+            environ_map={},
+            full_config_map={
+                'profiles': {'default': {'endpoint_url': 'global-from-config'}}
+            },
+            expected_value='global-from-config',
+        ),
+        dict(
+            service=service,
+            environ_map={},
+            full_config_map={
+                'profiles': {
+                    'default': {
+                        'services': 'my-services',
+                    }
+                },
+                'services': {
+                    'my-services': {
+                        service: {'endpoint_url': "service-from-config"}
+                    }
+                },
+            },
+            expected_value='service-from-config',
+        ),
+        dict(
+            service=service,
+            environ_map={},
+            full_config_map={
+                'profiles': {
+                    'default': {
+                        'services': 'my-services',
+                        'endpoint_url': 'global-from-config',
+                    }
+                },
+                'services': {
+                    'my-services': {
+                        service: {'endpoint_url': "service-from-config"}
+                    }
+                },
+            },
+            expected_value='service-from-config',
+        ),
+        dict(
+            service=service,
+            environ_map={
+                'AWS_ENDPOINT_URL': 'global-from-env',
+            },
+            full_config_map={
+                'profiles': {
+                    'default': {
+                        'endpoint_url': 'global-from-config',
+                    }
+                },
+            },
+            expected_value='global-from-env',
+        ),
+        dict(
+            service=service,
+            environ_map={
+                f'AWS_ENDPOINT_URL_{service.upper()}': 'service-from-env',
+            },
+            full_config_map={
+                'profiles': {
+                    'default': {
+                        'endpoint_url': 'global-from-config',
+                    }
+                },
+            },
+            expected_value='service-from-env',
+        ),
+        dict(
+            service='s3',
+            environ_map={},
+            full_config_map={
+                'profiles': {
+                    'default': {
+                        'services': 'my-services',
+                        'endpoint_url': 'global-from-config',
+                    }
+                },
+                'services': {
+                    'my-services': {
+                        service: {'endpoint_url': "service-from-config"}
+                    }
+                },
+            },
+            expected_value='global-from-config',
+        ),
+        dict(
+            service='runtime.sagemaker',
+            environ_map={},
+            full_config_map={
+                'profiles': {
+                    'default': {
+                        'services': 'my-services',
+                    }
+                },
+                'services': {
+                    'my-services': {
+                        'sagemaker_runtime': {
+                            'endpoint_url': "service-from-config"
+                        }
+                    }
+                },
+            },
+            expected_value='service-from-config',
+        ),
+        dict(
+            service='apigateway',
+            environ_map={},
+            full_config_map={
+                'profiles': {
+                    'default': {
+                        'services': 'my-services',
+                    }
+                },
+                'services': {
+                    'my-services': {
+                        'api_gateway': {'endpoint_url': "service-from-config"}
+                    }
+                },
+            },
+            expected_value='service-from-config',
+        ),
+    ]
+
+
+class TestConfiguredEndpointProvider:
+    def assert_does_provide(
+        self,
+        service,
+        environ_map,
+        full_config_map,
+        expected_value,
+    ):
+        scoped_config_map = full_config_map.get('profiles', {}).get(
+            'default', {}
+        )
+
+        chain = ConfiguredEndpointProvider(
+            scoped_config=scoped_config_map,
+            full_config=full_config_map,
+            client_name=service,
+            environ=environ_map,
+        )
+        value = chain.provide()
+        assert value == expected_value
+
+    @pytest.mark.parametrize('test_case', create_cases())
+    def test_does_provide(self, test_case):
+        self.assert_does_provide(**test_case)
+
+    def test_is_deepcopyable(self):
+        env = {'AWS_ENDPOINT_URL_BATCH': 'https://endpoint-override'}
+        provider = ConfiguredEndpointProvider(
+            full_config={}, scoped_config={}, client_name='batch', environ=env
+        )
+
+        provider_deepcopy = copy.deepcopy(provider)
+        assert provider is not provider_deepcopy
+        assert provider.provide() == 'https://endpoint-override'
+        assert provider_deepcopy.provide() == 'https://endpoint-override'
+
+        env['AWS_ENDPOINT_URL_BATCH'] = 'https://another-new-endpoint-override'
+        assert provider.provide() == 'https://another-new-endpoint-override'
+        assert provider_deepcopy.provide() == 'https://endpoint-override'

testbed/boto__botocore/tests/unit/test_configloader.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env
+# Copyright (c) 2012-2013 Mitch Garnaat http://garnaat.org/
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import os
+import shutil
+import tempfile
+
+import botocore.exceptions
+from botocore.configloader import (
+    load_config,
+    multi_file_load_config,
+    raw_config_parse,
+)
+from tests import mock, unittest
+
+
+def path(filename):
+    directory = os.path.join(os.path.dirname(__file__), 'cfg')
+    if isinstance(filename, bytes):
+        directory = directory.encode('latin-1')
+    return os.path.join(directory, filename)
+
+
+class TestConfigLoader(unittest.TestCase):
+    def setUp(self):
+        self.tempdir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.tempdir)
+
+    def create_config_file(self, filename):
+        contents = (
+            '[default]\n'
+            'aws_access_key_id = foo\n'
+            'aws_secret_access_key = bar\n\n'
+            '[profile "personal"]\n'
+            'aws_access_key_id = fie\n'
+            'aws_secret_access_key = baz\n'
+            'aws_security_token = fiebaz\n'
+        )
+
+        directory = self.tempdir
+        if isinstance(filename, bytes):
+            directory = directory.encode('latin-1')
+        full_path = os.path.join(directory, filename)
+
+        with open(full_path, 'w') as f:
+            f.write(contents)
+        return full_path
+
+    def test_config_not_found(self):
+        with self.assertRaises(botocore.exceptions.ConfigNotFound):
+            raw_config_parse(path('aws_config_notfound'))
+
+    def test_config_parse_error(self):
+        filename = path('aws_config_bad')
+        with self.assertRaises(botocore.exceptions.ConfigParseError):
+            raw_config_parse(filename)
+
+    def test_config_parse_error_bad_unicode(self):
+        filename = path('aws_config_badbytes')
+        with self.assertRaises(botocore.exceptions.ConfigParseError):
+            raw_config_parse(filename)
+
+    def test_config_parse_error_filesystem_encoding_none(self):
+        filename = path('aws_config_bad')
+        with mock.patch('sys.getfilesystemencoding') as encoding:
+            encoding.return_value = None
+            with self.assertRaises(botocore.exceptions.ConfigParseError):
+                raw_config_parse(filename)
+
+    def test_config(self):
+        loaded_config = raw_config_parse(path('aws_config'))
+        self.assertIn('default', loaded_config)
+        self.assertIn('profile "personal"', loaded_config)
+
+    def test_profile_map_conversion(self):
+        loaded_config = load_config(path('aws_config'))
+        self.assertIn('profiles', loaded_config)
+        self.assertEqual(
+            sorted(loaded_config['profiles'].keys()), ['default', 'personal']
+        )
+
+    def test_bad_profiles_are_ignored(self):
+        filename = path('aws_bad_profile')
+        loaded_config = load_config(filename)
+        self.assertEqual(len(loaded_config['profiles']), 3)
+        profiles = loaded_config['profiles']
+        self.assertIn('my profile', profiles)
+        self.assertIn('personal1', profiles)
+        self.assertIn('default', profiles)
+
+    def test_nested_hierarchy_parsing(self):
+        filename = path('aws_config_nested')
+        loaded_config = load_config(filename)
+        config = loaded_config['profiles']['default']
+        self.assertEqual(config['aws_access_key_id'], 'foo')
+        self.assertEqual(config['region'], 'us-west-2')
+        self.assertEqual(config['s3']['signature_version'], 's3v4')
+        self.assertEqual(config['cloudwatch']['signature_version'], 'v4')
+
+    def test_nested_hierarchy_with_no_subsection_parsing(self):
+        filename = path('aws_config_nested')
+        raw_config = raw_config_parse(filename, False)['default']
+        self.assertEqual(raw_config['aws_access_key_id'], 'foo')
+        self.assertEqual(raw_config['region'], 'us-west-2')
+        # Specifying False for pase_subsections in raw_config_parse
+        # will make sure that indented sections such as singature_version
+        # will not be treated as another subsection but rather
+        # its literal value.
+        self.assertEqual(raw_config['cloudwatch'], '\nsignature_version = v4')
+        self.assertEqual(
+            raw_config['s3'],
+            '\nsignature_version = s3v4' '\naddressing_style = path',
+        )
+
+    def test_nested_bad_config(self):
+        filename = path('aws_config_nested_bad')
+        with self.assertRaises(botocore.exceptions.ConfigParseError):
+            load_config(filename)
+
+    def test_nested_bad_config_filesystem_encoding_none(self):
+        filename = path('aws_config_nested_bad')
+        with mock.patch('sys.getfilesystemencoding') as encoding:
+            encoding.return_value = None
+            with self.assertRaises(botocore.exceptions.ConfigParseError):
+                load_config(filename)
+
+    def test_multi_file_load(self):
+        filenames = [
+            path('aws_config_other'),
+            path('aws_config'),
+            path('aws_third_config'),
+            path('aws_config_notfound'),
+        ]
+        loaded_config = multi_file_load_config(*filenames)
+        config = loaded_config['profiles']['default']
+        self.assertEqual(config['aws_access_key_id'], 'other_foo')
+        self.assertEqual(config['aws_secret_access_key'], 'other_bar')
+        second_config = loaded_config['profiles']['personal']
+        self.assertEqual(second_config['aws_access_key_id'], 'fie')
+        self.assertEqual(second_config['aws_secret_access_key'], 'baz')
+        self.assertEqual(second_config['aws_security_token'], 'fiebaz')
+        third_config = loaded_config['profiles']['third']
+        self.assertEqual(third_config['aws_access_key_id'], 'third_fie')
+        self.assertEqual(third_config['aws_secret_access_key'], 'third_baz')
+        self.assertEqual(third_config['aws_security_token'], 'third_fiebaz')
+
+    def test_unicode_bytes_path_not_found(self):
+        with self.assertRaises(botocore.exceptions.ConfigNotFound):
+            with mock.patch('sys.getfilesystemencoding') as encoding:
+                encoding.return_value = 'utf-8'
+                load_config(path(b'\xe2\x9c\x93'))
+
+    def test_unicode_bytes_path_not_found_filesystem_encoding_none(self):
+        with mock.patch('sys.getfilesystemencoding') as encoding:
+            encoding.return_value = None
+            with self.assertRaises(botocore.exceptions.ConfigNotFound):
+                load_config(path(b'\xe2\x9c\x93'))
+
+    def test_unicode_bytes_path(self):
+        filename = self.create_config_file(b'aws_config_unicode\xe2\x9c\x93')
+        with mock.patch('sys.getfilesystemencoding') as encoding:
+            encoding.return_value = 'utf-8'
+            loaded_config = load_config(filename)
+        self.assertIn('default', loaded_config['profiles'])
+        self.assertIn('personal', loaded_config['profiles'])
+
+    def test_sso_session_config(self):
+        filename = path('aws_sso_session_config')
+        loaded_config = load_config(filename)
+        self.assertIn('profiles', loaded_config)
+        self.assertIn('default', loaded_config['profiles'])
+        self.assertIn('sso_sessions', loaded_config)
+        self.assertIn('sso', loaded_config['sso_sessions'])
+        sso_config = loaded_config['sso_sessions']['sso']
+        self.assertEqual(sso_config['sso_region'], 'us-east-1')
+        self.assertEqual(sso_config['sso_start_url'], 'https://example.com')
+
+    def test_services_config(self):
+        filename = path('aws_services_config')
+        loaded_config = load_config(filename)
+        self.assertIn('profiles', loaded_config)
+        self.assertIn('default', loaded_config['profiles'])
+        self.assertIn('services', loaded_config)
+        self.assertIn('my-services', loaded_config['services'])
+        services_config = loaded_config['services']['my-services']
+        self.assertIn('s3', services_config)
+        self.assertIn('dynamodb', services_config)
+        self.assertEqual(
+            services_config['s3']['endpoint_url'], 'https://localhost:5678/'
+        )
+        self.assertEqual(
+            services_config['dynamodb']['endpoint_url'],
+            'https://localhost:8888/',
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

testbed/boto__botocore/tests/unit/test_discovery.py

@@ -0,0 +1,495 @@
+import time
+
+from botocore.awsrequest import AWSRequest
+from botocore.client import ClientMeta
+from botocore.discovery import (
+    EndpointDiscoveryHandler,
+    EndpointDiscoveryManager,
+    EndpointDiscoveryRefreshFailed,
+    EndpointDiscoveryRequired,
+    block_endpoint_discovery_required_operations,
+)
+from botocore.exceptions import ConnectionError
+from botocore.handlers import inject_api_version_header_if_needed
+from botocore.hooks import HierarchicalEmitter
+from botocore.model import ServiceModel
+from tests import mock, unittest
+
+
+class BaseEndpointDiscoveryTest(unittest.TestCase):
+    def setUp(self):
+        self.service_description = {
+            'version': '2.0',
+            'metadata': {
+                'apiVersion': '2018-08-31',
+                'endpointPrefix': 'fooendpoint',
+                'jsonVersion': '1.1',
+                'protocol': 'json',
+                'serviceAbbreviation': 'FooService',
+                'serviceId': 'FooService',
+                'serviceFullName': 'AwsFooService',
+                'signatureVersion': 'v4',
+                'signingName': 'awsfooservice',
+                'targetPrefix': 'awsfooservice',
+            },
+            'operations': {
+                'DescribeEndpoints': {
+                    'name': 'DescribeEndpoints',
+                    'http': {'method': 'POST', 'requestUri': '/'},
+                    'input': {'shape': 'DescribeEndpointsRequest'},
+                    'output': {'shape': 'DescribeEndpointsResponse'},
+                    'endpointoperation': True,
+                },
+                'TestDiscoveryRequired': {
+                    'name': 'TestDiscoveryRequired',
+                    'http': {'method': 'POST', 'requestUri': '/'},
+                    'input': {'shape': 'TestDiscoveryIdsRequest'},
+                    'output': {'shape': 'EmptyStruct'},
+                    'endpointdiscovery': {'required': True},
+                },
+                'TestDiscoveryOptional': {
+                    'name': 'TestDiscoveryOptional',
+                    'http': {'method': 'POST', 'requestUri': '/'},
+                    'input': {'shape': 'TestDiscoveryIdsRequest'},
+                    'output': {'shape': 'EmptyStruct'},
+                    'endpointdiscovery': {},
+                },
+                'TestDiscovery': {
+                    'name': 'TestDiscovery',
+                    'http': {'method': 'POST', 'requestUri': '/'},
+                    'input': {'shape': 'EmptyStruct'},
+                    'output': {'shape': 'EmptyStruct'},
+                    'endpointdiscovery': {},
+                },
+            },
+            'shapes': {
+                'Boolean': {'type': 'boolean'},
+                'DescribeEndpointsRequest': {
+                    'type': 'structure',
+                    'members': {
+                        'Operation': {'shape': 'String'},
+                        'Identifiers': {'shape': 'Identifiers'},
+                    },
+                },
+                'DescribeEndpointsResponse': {
+                    'type': 'structure',
+                    'required': ['Endpoints'],
+                    'members': {'Endpoints': {'shape': 'Endpoints'}},
+                },
+                'Endpoint': {
+                    'type': 'structure',
+                    'required': ['Address', 'CachePeriodInMinutes'],
+                    'members': {
+                        'Address': {'shape': 'String'},
+                        'CachePeriodInMinutes': {'shape': 'Long'},
+                    },
+                },
+                'Endpoints': {'type': 'list', 'member': {'shape': 'Endpoint'}},
+                'Identifiers': {
+                    'type': 'map',
+                    'key': {'shape': 'String'},
+                    'value': {'shape': 'String'},
+                },
+                'Long': {'type': 'long'},
+                'String': {'type': 'string'},
+                'TestDiscoveryIdsRequest': {
+                    'type': 'structure',
+                    'required': ['Foo', 'Nested'],
+                    'members': {
+                        'Foo': {
+                            'shape': 'String',
+                            'endpointdiscoveryid': True,
+                        },
+                        'Baz': {'shape': 'String'},
+                        'Nested': {'shape': 'Nested'},
+                    },
+                },
+                'EmptyStruct': {'type': 'structure', 'members': {}},
+                'Nested': {
+                    'type': 'structure',
+                    'required': 'Bar',
+                    'members': {
+                        'Bar': {
+                            'shape': 'String',
+                            'endpointdiscoveryid': True,
+                        }
+                    },
+                },
+            },
+        }
+
+
+class TestEndpointDiscoveryManager(BaseEndpointDiscoveryTest):
+    def setUp(self):
+        super().setUp()
+        self.construct_manager()
+
+    def construct_manager(self, cache=None, time=None, side_effect=None):
+        self.service_model = ServiceModel(self.service_description)
+        self.meta = mock.Mock(spec=ClientMeta)
+        self.meta.service_model = self.service_model
+        self.client = mock.Mock()
+        if side_effect is None:
+            side_effect = [
+                {
+                    'Endpoints': [
+                        {
+                            'Address': 'new.com',
+                            'CachePeriodInMinutes': 2,
+                        }
+                    ]
+                }
+            ]
+        self.client.describe_endpoints.side_effect = side_effect
+        self.client.meta = self.meta
+        self.manager = EndpointDiscoveryManager(
+            self.client, cache=cache, current_time=time
+        )
+
+    def test_injects_api_version_if_endpoint_operation(self):
+        model = self.service_model.operation_model('DescribeEndpoints')
+        params = {'headers': {}}
+        inject_api_version_header_if_needed(model, params)
+        self.assertEqual(
+            params['headers'].get('x-amz-api-version'), '2018-08-31'
+        )
+
+    def test_no_inject_api_version_if_not_endpoint_operation(self):
+        model = self.service_model.operation_model('TestDiscoveryRequired')
+        params = {'headers': {}}
+        inject_api_version_header_if_needed(model, params)
+        self.assertNotIn('x-amz-api-version', params['headers'])
+
+    def test_gather_identifiers(self):
+        params = {'Foo': 'value1', 'Nested': {'Bar': 'value2'}}
+        operation = self.service_model.operation_model('TestDiscoveryRequired')
+        ids = self.manager.gather_identifiers(operation, params)
+        self.assertEqual(ids, {'Foo': 'value1', 'Bar': 'value2'})
+
+    def test_gather_identifiers_none(self):
+        operation = self.service_model.operation_model('TestDiscovery')
+        ids = self.manager.gather_identifiers(operation, {})
+        self.assertEqual(ids, {})
+
+    def test_describe_endpoint(self):
+        kwargs = {
+            'Operation': 'FooBar',
+            'Identifiers': {'Foo': 'value1', 'Bar': 'value2'},
+        }
+        self.manager.describe_endpoint(**kwargs)
+        self.client.describe_endpoints.assert_called_with(**kwargs)
+
+    def test_describe_endpoint_no_input(self):
+        describe = self.service_description['operations']['DescribeEndpoints']
+        del describe['input']
+        self.construct_manager()
+        self.manager.describe_endpoint(Operation='FooBar', Identifiers={})
+        self.client.describe_endpoints.assert_called_with()
+
+    def test_describe_endpoint_empty_input(self):
+        describe = self.service_description['operations']['DescribeEndpoints']
+        describe['input'] = {'shape': 'EmptyStruct'}
+        self.construct_manager()
+        self.manager.describe_endpoint(Operation='FooBar', Identifiers={})
+        self.client.describe_endpoints.assert_called_with()
+
+    def test_describe_endpoint_ids_and_operation(self):
+        cache = {}
+        self.construct_manager(cache=cache)
+        ids = {'Foo': 'value1', 'Bar': 'value2'}
+        kwargs = {
+            'Operation': 'TestDiscoveryRequired',
+            'Identifiers': ids,
+        }
+        self.manager.describe_endpoint(**kwargs)
+        self.client.describe_endpoints.assert_called_with(**kwargs)
+        key = ((('Bar', 'value2'), ('Foo', 'value1')), 'TestDiscoveryRequired')
+        self.assertIn(key, cache)
+        self.assertEqual(cache[key][0]['Address'], 'new.com')
+        self.manager.describe_endpoint(**kwargs)
+        call_count = self.client.describe_endpoints.call_count
+        self.assertEqual(call_count, 1)
+
+    def test_describe_endpoint_no_ids_or_operation(self):
+        cache = {}
+        describe = self.service_description['operations']['DescribeEndpoints']
+        describe['input'] = {'shape': 'EmptyStruct'}
+        self.construct_manager(cache=cache)
+        self.manager.describe_endpoint(
+            Operation='TestDiscoveryRequired', Identifiers={}
+        )
+        self.client.describe_endpoints.assert_called_with()
+        key = ()
+        self.assertIn(key, cache)
+        self.assertEqual(cache[key][0]['Address'], 'new.com')
+        self.manager.describe_endpoint(
+            Operation='TestDiscoveryRequired', Identifiers={}
+        )
+        call_count = self.client.describe_endpoints.call_count
+        self.assertEqual(call_count, 1)
+
+    def test_describe_endpoint_expired_entry(self):
+        current_time = time.time()
+        key = ()
+        cache = {
+            key: [{'Address': 'old.com', 'Expiration': current_time - 10}]
+        }
+        self.construct_manager(cache=cache)
+        kwargs = {
+            'Identifiers': {},
+            'Operation': 'TestDiscoveryRequired',
+        }
+        self.manager.describe_endpoint(**kwargs)
+        self.client.describe_endpoints.assert_called_with()
+        self.assertIn(key, cache)
+        self.assertEqual(cache[key][0]['Address'], 'new.com')
+        self.manager.describe_endpoint(**kwargs)
+        call_count = self.client.describe_endpoints.call_count
+        self.assertEqual(call_count, 1)
+
+    def test_describe_endpoint_cache_expiration(self):
+        def _time():
+            return float(0)
+
+        cache = {}
+        self.construct_manager(cache=cache, time=_time)
+        self.manager.describe_endpoint(
+            Operation='TestDiscoveryRequired', Identifiers={}
+        )
+        key = ()
+        self.assertIn(key, cache)
+        self.assertEqual(cache[key][0]['Expiration'], float(120))
+
+    def test_delete_endpoints_present(self):
+        key = ()
+        cache = {key: [{'Address': 'old.com', 'Expiration': 0}]}
+        self.construct_manager(cache=cache)
+        kwargs = {
+            'Identifiers': {},
+            'Operation': 'TestDiscoveryRequired',
+        }
+        self.manager.delete_endpoints(**kwargs)
+        self.assertEqual(cache, {})
+
+    def test_delete_endpoints_absent(self):
+        cache = {}
+        self.construct_manager(cache=cache)
+        kwargs = {
+            'Identifiers': {},
+            'Operation': 'TestDiscoveryRequired',
+        }
+        self.manager.delete_endpoints(**kwargs)
+        self.assertEqual(cache, {})
+
+    def test_describe_endpoint_optional_fails_no_cache(self):
+        side_effect = [ConnectionError(error=None)]
+        self.construct_manager(side_effect=side_effect)
+        kwargs = {'Operation': 'TestDiscoveryOptional'}
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertIsNone(endpoint)
+        # This second call should be blocked as we just failed
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertIsNone(endpoint)
+        self.client.describe_endpoints.call_args_list == [mock.call()]
+
+    def test_describe_endpoint_optional_fails_stale_cache(self):
+        key = ()
+        cache = {key: [{'Address': 'old.com', 'Expiration': 0}]}
+        side_effect = [ConnectionError(error=None)] * 2
+        self.construct_manager(cache=cache, side_effect=side_effect)
+        kwargs = {'Operation': 'TestDiscoveryOptional'}
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertEqual(endpoint, 'old.com')
+        # This second call shouldn't go through as we just failed
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertEqual(endpoint, 'old.com')
+        self.client.describe_endpoints.call_args_list == [mock.call()]
+
+    def test_describe_endpoint_required_fails_no_cache(self):
+        side_effect = [ConnectionError(error=None)] * 2
+        self.construct_manager(side_effect=side_effect)
+        kwargs = {'Operation': 'TestDiscoveryRequired'}
+        with self.assertRaises(EndpointDiscoveryRefreshFailed):
+            self.manager.describe_endpoint(**kwargs)
+        # This second call should go through, as we have no cache
+        with self.assertRaises(EndpointDiscoveryRefreshFailed):
+            self.manager.describe_endpoint(**kwargs)
+        describe_count = self.client.describe_endpoints.call_count
+        self.assertEqual(describe_count, 2)
+
+    def test_describe_endpoint_required_fails_stale_cache(self):
+        key = ()
+        cache = {key: [{'Address': 'old.com', 'Expiration': 0}]}
+        side_effect = [ConnectionError(error=None)] * 2
+        self.construct_manager(cache=cache, side_effect=side_effect)
+        kwargs = {'Operation': 'TestDiscoveryRequired'}
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertEqual(endpoint, 'old.com')
+        # We have a stale endpoint, so this shouldn't fail or force a refresh
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertEqual(endpoint, 'old.com')
+        self.client.describe_endpoints.call_args_list == [mock.call()]
+
+    def test_describe_endpoint_required_force_refresh_success(self):
+        side_effect = [
+            ConnectionError(error=None),
+            {
+                'Endpoints': [
+                    {
+                        'Address': 'new.com',
+                        'CachePeriodInMinutes': 2,
+                    }
+                ]
+            },
+        ]
+        self.construct_manager(side_effect=side_effect)
+        kwargs = {'Operation': 'TestDiscoveryRequired'}
+        # First call will fail
+        with self.assertRaises(EndpointDiscoveryRefreshFailed):
+            self.manager.describe_endpoint(**kwargs)
+        self.client.describe_endpoints.call_args_list == [mock.call()]
+        # Force a refresh if the cache is empty but discovery is required
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertEqual(endpoint, 'new.com')
+
+    def test_describe_endpoint_retries_after_failing(self):
+        fake_time = mock.Mock()
+        fake_time.side_effect = [0, 100, 200]
+        side_effect = [
+            ConnectionError(error=None),
+            {
+                'Endpoints': [
+                    {
+                        'Address': 'new.com',
+                        'CachePeriodInMinutes': 2,
+                    }
+                ]
+            },
+        ]
+        self.construct_manager(side_effect=side_effect, time=fake_time)
+        kwargs = {'Operation': 'TestDiscoveryOptional'}
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertIsNone(endpoint)
+        self.client.describe_endpoints.call_args_list == [mock.call()]
+        # Second time should try again as enough time has elapsed
+        endpoint = self.manager.describe_endpoint(**kwargs)
+        self.assertEqual(endpoint, 'new.com')
+
+
+class TestEndpointDiscoveryHandler(BaseEndpointDiscoveryTest):
+    def setUp(self):
+        super().setUp()
+        self.manager = mock.Mock(spec=EndpointDiscoveryManager)
+        self.handler = EndpointDiscoveryHandler(self.manager)
+        self.service_model = ServiceModel(self.service_description)
+
+    def test_register_handler(self):
+        events = mock.Mock(spec=HierarchicalEmitter)
+        self.handler.register(events, 'foo-bar')
+        events.register.assert_any_call(
+            'before-parameter-build.foo-bar', self.handler.gather_identifiers
+        )
+        events.register.assert_any_call(
+            'needs-retry.foo-bar', self.handler.handle_retries
+        )
+        events.register_first.assert_called_with(
+            'request-created.foo-bar', self.handler.discover_endpoint
+        )
+
+    def test_discover_endpoint(self):
+        request = AWSRequest()
+        request.context = {'discovery': {'identifiers': {}}}
+        self.manager.describe_endpoint.return_value = 'https://new.foo'
+        self.handler.discover_endpoint(request, 'TestOperation')
+        self.assertEqual(request.url, 'https://new.foo')
+        self.manager.describe_endpoint.assert_called_with(
+            Operation='TestOperation', Identifiers={}
+        )
+
+    def test_discover_endpoint_fails(self):
+        request = AWSRequest()
+        request.context = {'discovery': {'identifiers': {}}}
+        request.url = 'old.com'
+        self.manager.describe_endpoint.return_value = None
+        self.handler.discover_endpoint(request, 'TestOperation')
+        self.assertEqual(request.url, 'old.com')
+        self.manager.describe_endpoint.assert_called_with(
+            Operation='TestOperation', Identifiers={}
+        )
+
+    def test_discover_endpoint_no_protocol(self):
+        request = AWSRequest()
+        request.context = {'discovery': {'identifiers': {}}}
+        self.manager.describe_endpoint.return_value = 'new.foo'
+        self.handler.discover_endpoint(request, 'TestOperation')
+        self.assertEqual(request.url, 'https://new.foo')
+        self.manager.describe_endpoint.assert_called_with(
+            Operation='TestOperation', Identifiers={}
+        )
+
+    def test_inject_no_context(self):
+        request = AWSRequest(url='https://original.foo')
+        self.handler.discover_endpoint(request, 'TestOperation')
+        self.assertEqual(request.url, 'https://original.foo')
+        self.manager.describe_endpoint.assert_not_called()
+
+    def test_gather_identifiers(self):
+        context = {}
+        params = {'Foo': 'value1', 'Nested': {'Bar': 'value2'}}
+        ids = {'Foo': 'value1', 'Bar': 'value2'}
+        model = self.service_model.operation_model('TestDiscoveryRequired')
+        self.manager.gather_identifiers.return_value = ids
+        self.handler.gather_identifiers(params, model, context)
+        self.assertEqual(context['discovery']['identifiers'], ids)
+
+    def test_gather_identifiers_not_discoverable(self):
+        context = {}
+        model = self.service_model.operation_model('DescribeEndpoints')
+        self.handler.gather_identifiers({}, model, context)
+        self.assertEqual(context, {})
+
+    def test_discovery_disabled_but_required(self):
+        model = self.service_model.operation_model('TestDiscoveryRequired')
+        with self.assertRaises(EndpointDiscoveryRequired):
+            block_endpoint_discovery_required_operations(model)
+
+    def test_discovery_disabled_but_optional(self):
+        context = {}
+        model = self.service_model.operation_model('TestDiscoveryOptional')
+        block_endpoint_discovery_required_operations(model, context=context)
+        self.assertEqual(context, {})
+
+    def test_does_not_retry_no_response(self):
+        retry = self.handler.handle_retries(None, None, None)
+        self.assertIsNone(retry)
+
+    def test_does_not_retry_other_errors(self):
+        parsed_response = {'ResponseMetadata': {'HTTPStatusCode': 200}}
+        response = (None, parsed_response)
+        retry = self.handler.handle_retries(None, response, None)
+        self.assertIsNone(retry)
+
+    def test_does_not_retry_if_no_context(self):
+        request_dict = {'context': {}}
+        parsed_response = {'ResponseMetadata': {'HTTPStatusCode': 421}}
+        response = (None, parsed_response)
+        retry = self.handler.handle_retries(request_dict, response, None)
+        self.assertIsNone(retry)
+
+    def _assert_retries(self, parsed_response):
+        request_dict = {'context': {'discovery': {'identifiers': {}}}}
+        response = (None, parsed_response)
+        model = self.service_model.operation_model('TestDiscoveryOptional')
+        retry = self.handler.handle_retries(request_dict, response, model)
+        self.assertEqual(retry, 0)
+        self.manager.delete_endpoints.assert_called_with(
+            Operation='TestDiscoveryOptional', Identifiers={}
+        )
+
+    def test_retries_421_status_code(self):
+        parsed_response = {'ResponseMetadata': {'HTTPStatusCode': 421}}
+        self._assert_retries(parsed_response)
+
+    def test_retries_invalid_endpoint_exception(self):
+        parsed_response = {'Error': {'Code': 'InvalidEndpointException'}}
+        self._assert_retries(parsed_response)

testbed/boto__botocore/tests/unit/test_endpoint.py

@@ -0,0 +1,490 @@
+# Copyright 2012-2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import datetime
+import io
+import socket
+
+import pytest
+
+import botocore.endpoint
+from botocore.config import Config
+from botocore.endpoint import DEFAULT_TIMEOUT, Endpoint, EndpointCreator
+from botocore.exceptions import HTTPClientError
+from botocore.httpsession import URLLib3Session
+from botocore.model import (
+    OperationModel,
+    ServiceId,
+    ServiceModel,
+    StructureShape,
+)
+from tests import mock, unittest
+
+
+def request_dict(**kwargs):
+    base = {
+        'headers': {},
+        'body': '',
+        'url_path': '/',
+        'query_string': '',
+        'method': 'POST',
+        'url': 'https://example.com',
+        'context': {},
+    }
+    base.update(kwargs)
+    return base
+
+
+class RecordStreamResets(io.StringIO):
+    def __init__(self, value):
+        io.StringIO.__init__(self, value)
+        self.total_resets = 0
+
+    def seek(self, where, whence=0):
+        self.total_resets += 1
+        io.StringIO.seek(self, where, whence)
+
+
+class TestEndpointBase(unittest.TestCase):
+    def setUp(self):
+        self.op = mock.Mock()
+        self.op.has_streaming_output = False
+        self.op.has_event_stream_output = False
+        self.op.metadata = {'protocol': 'json'}
+        self.event_emitter = mock.Mock()
+        self.event_emitter.emit.return_value = []
+        self.factory_patch = mock.patch(
+            'botocore.parsers.ResponseParserFactory'
+        )
+        self.factory = self.factory_patch.start()
+        self.endpoint = Endpoint(
+            'https://ec2.us-west-2.amazonaws.com/',
+            endpoint_prefix='ec2',
+            event_emitter=self.event_emitter,
+        )
+        self.http_session = mock.Mock()
+        self.http_session.send.return_value = mock.Mock(
+            status_code=200,
+            headers={},
+            content=b'{"Foo": "bar"}',
+        )
+        self.endpoint.http_session = self.http_session
+
+    def tearDown(self):
+        self.factory_patch.stop()
+
+    def get_emitter_responses(self, num_retries=0, sleep_time=0, num_events=4):
+        emitter_responses = []
+        # We emit the following events:
+        # 1. request-created
+        # 2. before-send
+        # 3. before-parse (may not be emitted if certain errors are thrown)
+        # 4. response-received
+        response_request_emitter_responses = [
+            [(None, None)]  # emit() response for each emitted event
+        ] * num_events
+        for _ in range(num_retries):
+            emitter_responses.extend(response_request_emitter_responses)
+            # emit() response for retry for sleep time
+            emitter_responses.append([(None, sleep_time)])
+        emitter_responses.extend(response_request_emitter_responses)
+        # emit() response for no retry
+        emitter_responses.append([(None, None)])
+        return emitter_responses
+
+    def get_events_emitted(self, event_emitter):
+        return [
+            call_arg[0][0] for call_arg in event_emitter.emit.call_args_list
+        ]
+
+
+class TestEndpointFeatures(TestEndpointBase):
+    def test_make_request_with_no_auth(self):
+        self.endpoint.auth = None
+        self.endpoint.make_request(self.op, request_dict())
+
+        # http_session should be used to send the request.
+        self.assertTrue(self.http_session.send.called)
+        prepared_request = self.http_session.send.call_args[0][0]
+        self.assertNotIn('Authorization', prepared_request.headers)
+
+    def test_make_request_no_signature_version(self):
+        self.endpoint.make_request(self.op, request_dict())
+
+        # http_session should be used to send the request.
+        self.assertTrue(self.http_session.send.called)
+        prepared_request = self.http_session.send.call_args[0][0]
+        self.assertNotIn('Authorization', prepared_request.headers)
+
+    def test_make_request_with_context(self):
+        r = request_dict()
+        r['context'] = {'signing': {'region': 'us-west-2'}}
+        with mock.patch(
+            'botocore.endpoint.Endpoint.prepare_request'
+        ) as prepare:
+            self.endpoint.make_request(self.op, r)
+        request = prepare.call_args[0][0]
+        self.assertEqual(request.context['signing']['region'], 'us-west-2')
+
+    def test_make_request_sets_retries_config_in_context(self):
+        r = request_dict()
+        r['context'] = {'signing': {'region': 'us-west-2'}}
+        with mock.patch(
+            'botocore.endpoint.Endpoint.prepare_request'
+        ) as prepare:
+            self.endpoint.make_request(self.op, r)
+        request = prepare.call_args[0][0]
+        self.assertIn('retries', request.context)
+
+    def test_exception_caught_when_constructing_retries_context(self):
+        r = request_dict()
+        datetime_patcher = mock.patch.object(
+            botocore.endpoint.datetime,
+            'datetime',
+            mock.Mock(wraps=datetime.datetime),
+        )
+        r['context'] = {'signing': {'region': 'us-west-2'}}
+        with mock.patch(
+            'botocore.endpoint.Endpoint.prepare_request'
+        ) as prepare:
+            mocked_datetime = datetime_patcher.start()
+            mocked_datetime.side_effect = Exception()
+            self.endpoint.make_request(self.op, r)
+            datetime_patcher.stop()
+        request = prepare.call_args[0][0]
+        self.assertIn('retries', request.context)
+
+    def test_parses_modeled_exception_fields(self):
+        # Setup the service model to have exceptions to generate the mapping
+        self.service_model = mock.Mock(spec=ServiceModel)
+        self.op.service_model = self.service_model
+        self.exception_shape = mock.Mock(spec=StructureShape)
+        shape_for_error_code = self.service_model.shape_for_error_code
+        shape_for_error_code.return_value = self.exception_shape
+
+        r = request_dict()
+        self.http_session.send.return_value = mock.Mock(
+            status_code=400,
+            headers={},
+            content=b'',
+        )
+        parser = mock.Mock()
+        parser.parse.side_effect = [
+            {
+                'Error': {
+                    'Code': 'ExceptionShape',
+                    'Message': 'Some message',
+                }
+            },
+            {'SomeField': 'Foo'},
+        ]
+        self.factory.return_value.create_parser.return_value = parser
+        _, response = self.endpoint.make_request(self.op, r)
+        # The parser should be called twice, once for the original
+        # error parse and once again for the modeled exception parse
+        self.assertEqual(parser.parse.call_count, 2)
+        parse_calls = parser.parse.call_args_list
+        self.assertEqual(parse_calls[1][0][1], self.exception_shape)
+        self.assertEqual(parse_calls[0][0][1], self.op.output_shape)
+        expected_response = {
+            'Error': {
+                'Code': 'ExceptionShape',
+                'Message': 'Some message',
+            },
+            'SomeField': 'Foo',
+        }
+        self.assertEqual(response, expected_response)
+
+    def test_close(self):
+        self.endpoint.close()
+        self.endpoint.http_session.close.assert_called_once_with()
+
+
+class TestRetryInterface(TestEndpointBase):
+    def setUp(self):
+        super().setUp()
+        self.retried_on_exception = None
+        self._operation = mock.Mock(spec=OperationModel)
+        self._operation.name = 'DescribeInstances'
+        self._operation.metadata = {'protocol': 'query'}
+        self._operation.service_model.service_id = ServiceId('EC2')
+        self._operation.has_streaming_output = False
+        self._operation.has_event_stream_output = False
+
+    def assert_events_emitted(self, event_emitter, expected_events):
+        self.assertEqual(
+            self.get_events_emitted(event_emitter), expected_events
+        )
+
+    def test_retry_events_are_emitted(self):
+        self.endpoint.make_request(self._operation, request_dict())
+        call_args = self.event_emitter.emit.call_args
+        self.assertEqual(call_args[0][0], 'needs-retry.ec2.DescribeInstances')
+
+    def test_retry_events_can_alter_behavior(self):
+        self.event_emitter.emit.side_effect = self.get_emitter_responses(
+            num_retries=1
+        )
+        r = request_dict()
+        r['context']['client_config'] = Config()
+        self.endpoint.make_request(self._operation, r)
+        self.assert_events_emitted(
+            self.event_emitter,
+            expected_events=[
+                'request-created.ec2.DescribeInstances',
+                'before-send.ec2.DescribeInstances',
+                'before-parse.ec2.DescribeInstances',
+                'response-received.ec2.DescribeInstances',
+                'needs-retry.ec2.DescribeInstances',
+            ]
+            * 2,
+        )
+
+    def test_retry_on_socket_errors(self):
+        self.event_emitter.emit.side_effect = self.get_emitter_responses(
+            num_retries=1, num_events=3
+        )
+        self.http_session.send.side_effect = HTTPClientError(error='wrapped')
+        with self.assertRaises(HTTPClientError):
+            self.endpoint.make_request(self._operation, request_dict())
+        self.assert_events_emitted(
+            self.event_emitter,
+            expected_events=[
+                'request-created.ec2.DescribeInstances',
+                'before-send.ec2.DescribeInstances',
+                'response-received.ec2.DescribeInstances',
+                'needs-retry.ec2.DescribeInstances',
+            ]
+            * 2,
+        )
+
+    def test_retry_attempts_added_to_response_metadata(self):
+        self.event_emitter.emit.side_effect = self.get_emitter_responses(
+            num_retries=1
+        )
+        parser = mock.Mock()
+        parser.parse.return_value = {'ResponseMetadata': {}}
+        self.factory.return_value.create_parser.return_value = parser
+        r = request_dict()
+        r['context']['client_config'] = Config()
+        response = self.endpoint.make_request(self._operation, r)
+        self.assertEqual(response[1]['ResponseMetadata']['RetryAttempts'], 1)
+
+    def test_retry_attempts_is_zero_when_not_retried(self):
+        self.event_emitter.emit.side_effect = self.get_emitter_responses(
+            num_retries=0
+        )
+        parser = mock.Mock()
+        parser.parse.return_value = {'ResponseMetadata': {}}
+        self.factory.return_value.create_parser.return_value = parser
+        response = self.endpoint.make_request(self._operation, request_dict())
+        self.assertEqual(response[1]['ResponseMetadata']['RetryAttempts'], 0)
+
+
+class TestS3ResetStreamOnRetry(TestEndpointBase):
+    def setUp(self):
+        super().setUp()
+
+    def max_attempts_retry_handler(self, attempts, **kwargs):
+        # Simulate a max requests of 3.
+        self.total_calls += 1
+        if attempts == 3:
+            return None
+        else:
+            # Returning anything non-None will trigger a retry,
+            # but 0 here is so that time.sleep(0) happens.
+            return 0
+
+    def test_reset_stream_on_retry(self):
+        op = mock.Mock()
+        body = RecordStreamResets('foobar')
+        op.name = 'PutObject'
+        op.has_streaming_output = True
+        op.has_event_stream_output = False
+        op.metadata = {'protocol': 'rest-xml'}
+        request = request_dict()
+        request['body'] = body
+        request['context']['client_config'] = Config()
+        self.event_emitter.emit.side_effect = self.get_emitter_responses(
+            num_retries=2
+        )
+        self.endpoint.make_request(op, request)
+        # 2 seeks for the resets and 6 (2 per creation) for content-length
+        self.assertEqual(body.total_resets, 8)
+
+
+class TestEventStreamBody(TestEndpointBase):
+    def test_event_stream_body_is_streaming(self):
+        self.op.has_event_stream_output = True
+        request = request_dict()
+        self.endpoint.make_request(self.op, request)
+        sent_request = self.http_session.send.call_args[0][0]
+        self.assertTrue(sent_request.stream_output)
+
+
+class TestEndpointCreator(unittest.TestCase):
+    def setUp(self):
+        self.service_model = mock.Mock(
+            endpoint_prefix='ec2', signature_version='v2', signing_name='ec2'
+        )
+        self.environ = {}
+        self.environ_patch = mock.patch('os.environ', self.environ)
+        self.environ_patch.start()
+        self.creator = EndpointCreator(mock.Mock())
+        self.mock_session = mock.Mock(spec=URLLib3Session)
+
+    def tearDown(self):
+        self.environ_patch.stop()
+
+    def test_creates_endpoint_with_configured_url(self):
+        endpoint = self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-east-1',
+            endpoint_url='https://endpoint.url',
+        )
+        self.assertEqual(endpoint.host, 'https://endpoint.url')
+
+    def test_creates_endpoint_with_ipv4_url(self):
+        endpoint = self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-east-1',
+            endpoint_url='https://192.168.0.0',
+        )
+        self.assertEqual(endpoint.host, 'https://192.168.0.0')
+
+    def test_creates_endpoint_with_ipv6_url(self):
+        endpoint = self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-east-1',
+            endpoint_url='https://[100:0:2::61]:7480',
+        )
+        self.assertEqual(endpoint.host, 'https://[100:0:2::61]:7480')
+
+    def test_raises_error_with_invalid_url(self):
+        with pytest.raises(ValueError):
+            self.creator.create_endpoint(
+                self.service_model,
+                region_name='us-east-1',
+                endpoint_url='https://*.aws.amazon.com/',
+            )
+
+    def test_create_endpoint_with_default_timeout(self):
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertEqual(session_args.get('timeout'), DEFAULT_TIMEOUT)
+
+    def test_create_endpoint_with_customized_timeout(self):
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            timeout=123,
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertEqual(session_args.get('timeout'), 123)
+
+    def test_get_endpoint_default_verify_ssl(self):
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertTrue(session_args.get('verify'))
+
+    def test_verify_ssl_can_be_disabled(self):
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            verify=False,
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertFalse(session_args.get('verify'))
+
+    def test_verify_ssl_can_specify_cert_bundle(self):
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            verify='/path/cacerts.pem',
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertEqual(session_args.get('verify'), '/path/cacerts.pem')
+
+    def test_client_cert_can_specify_path(self):
+        client_cert = '/some/path/cert'
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            client_cert=client_cert,
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertEqual(session_args.get('client_cert'), '/some/path/cert')
+
+    def test_honor_cert_bundle_env_var(self):
+        self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem'
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertEqual(session_args.get('verify'), '/env/cacerts.pem')
+
+    def test_env_ignored_if_explicitly_passed(self):
+        self.environ['REQUESTS_CA_BUNDLE'] = '/env/cacerts.pem'
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            verify='/path/cacerts.pem',
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        # /path/cacerts.pem wins over the value from the env var.
+        self.assertEqual(session_args.get('verify'), '/path/cacerts.pem')
+
+    def test_can_specify_max_pool_conns(self):
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            max_pool_connections=100,
+            http_session_cls=self.mock_session,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertEqual(session_args.get('max_pool_connections'), 100)
+
+    def test_socket_options(self):
+        socket_options = [(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)]
+        self.creator.create_endpoint(
+            self.service_model,
+            region_name='us-west-2',
+            endpoint_url='https://example.com',
+            http_session_cls=self.mock_session,
+            socket_options=socket_options,
+        )
+        session_args = self.mock_session.call_args[1]
+        self.assertEqual(session_args.get('socket_options'), socket_options)

testbed/boto__botocore/tests/unit/test_endpoint_provider.py

@@ -0,0 +1,512 @@
+# Copyright 2012-2022 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+
+import json
+import logging
+import os
+from unittest.mock import Mock
+
+import pytest
+
+from botocore.endpoint_provider import (
+    EndpointProvider,
+    EndpointRule,
+    ErrorRule,
+    RuleCreator,
+    RuleSet,
+    RuleSetStandardLibrary,
+    TreeRule,
+)
+from botocore.exceptions import (
+    EndpointResolutionError,
+    MissingDependencyException,
+    UnknownSignatureVersionError,
+)
+from botocore.loaders import Loader
+from botocore.regions import EndpointRulesetResolver
+from tests import requires_crt
+
+REGION_TEMPLATE = "{Region}"
+REGION_REF = {"ref": "Region"}
+BUCKET_ARN_REF = {"ref": "bucketArn"}
+PARSE_ARN_FUNC = {
+    "fn": "aws.parseArn",
+    "argv": [{"ref": "Bucket"}],
+    "assign": "bucketArn",
+}
+STRING_EQUALS_FUNC = {
+    "fn": "stringEquals",
+    "argv": [
+        {
+            "fn": "getAttr",
+            "argv": [BUCKET_ARN_REF, "region"],
+            "assign": "bucketRegion",
+        },
+        "",
+    ],
+}
+DNS_SUFFIX_TEMPLATE = "{PartitionResults#dnsSuffix}"
+URL_TEMPLATE = (
+    f"https://{REGION_TEMPLATE}.myGreatService.{DNS_SUFFIX_TEMPLATE}"
+)
+ENDPOINT_DICT = {
+    "url": URL_TEMPLATE,
+    "properties": {
+        "authSchemes": [
+            {
+                "signingName": "s3",
+                "signingScope": REGION_TEMPLATE,
+                "name": "s3v4",
+            }
+        ],
+    },
+    "headers": {
+        "x-amz-region-set": [
+            REGION_REF,
+            {
+                "fn": "getAttr",
+                "argv": [BUCKET_ARN_REF, "region"],
+            },
+            "us-east-2",
+        ],
+    },
+}
+
+
+@pytest.fixture(scope="module")
+def loader():
+    return Loader()
+
+
+@pytest.fixture(scope="module")
+def partitions(loader):
+    return loader.load_data("partitions")
+
+
+@pytest.fixture(scope="module")
+def rule_lib(partitions):
+    return RuleSetStandardLibrary(partitions)
+
+
+@pytest.fixture(scope="module")
+def ruleset_dict():
+    path = os.path.join(
+        os.path.dirname(__file__),
+        "data",
+        "endpoints",
+        "valid-rules",
+        "deprecated-param.json",
+    )
+    with open(path) as f:
+        return json.load(f)
+
+
+@pytest.fixture(scope="module")
+def endpoint_provider(ruleset_dict, partitions):
+    return EndpointProvider(ruleset_dict, partitions)
+
+
+@pytest.fixture(scope="module")
+def endpoint_rule():
+    return EndpointRule(
+        endpoint=ENDPOINT_DICT,
+        conditions=[
+            PARSE_ARN_FUNC,
+            {
+                "fn": "not",
+                "argv": [STRING_EQUALS_FUNC],
+            },
+            {
+                "fn": "aws.partition",
+                "argv": [REGION_REF],
+                "assign": "PartitionResults",
+            },
+        ],
+    )
+
+
+def ruleset_testcases():
+    filenames = [
+        "aws-region",
+        "default-values",
+        "eventbridge",
+        "fns",
+        "headers",
+        "is-virtual-hostable-s3-bucket",
+        "local-region-override",
+        "parse-arn",
+        "parse-url",
+        "substring",
+        "uri-encode",
+        "valid-hostlabel",
+    ]
+    error_cases = []
+    endpoint_cases = []
+    base_path = os.path.join(os.path.dirname(__file__), "data", "endpoints")
+    for name in filenames:
+        with open(os.path.join(base_path, "valid-rules", f"{name}.json")) as f:
+            ruleset = json.load(f)
+        with open(os.path.join(base_path, "test-cases", f"{name}.json")) as f:
+            tests = json.load(f)
+
+        for test in tests["testCases"]:
+            input_params = test["params"]
+            expected_object = test["expect"]
+            if "error" in expected_object:
+                error_cases.append(
+                    (ruleset, input_params, expected_object["error"])
+                )
+            elif "endpoint" in expected_object:
+                endpoint_cases.append(
+                    (ruleset, input_params, expected_object["endpoint"])
+                )
+            else:
+                raise ValueError("Expected `error` or `endpoint` in test case")
+    return error_cases, endpoint_cases
+
+
+ERROR_TEST_CASES, ENDPOINT_TEST_CASES = ruleset_testcases()
+
+
+@pytest.mark.parametrize(
+    "ruleset,input_params,expected_error",
+    ERROR_TEST_CASES,
+)
+def test_endpoint_resolution_raises(
+    partitions, ruleset, input_params, expected_error
+):
+    endpoint_provider = EndpointProvider(ruleset, partitions)
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        endpoint_provider.resolve_endpoint(**input_params)
+    assert str(exc_info.value) == expected_error
+
+
+@pytest.mark.parametrize(
+    "ruleset,input_params,expected_endpoint",
+    ENDPOINT_TEST_CASES,
+)
+def test_endpoint_resolution(
+    partitions, ruleset, input_params, expected_endpoint
+):
+    endpoint_provider = EndpointProvider(ruleset, partitions)
+    endpoint = endpoint_provider.resolve_endpoint(**input_params)
+    assert endpoint.url == expected_endpoint["url"]
+    assert endpoint.properties == expected_endpoint.get("properties", {})
+    assert endpoint.headers == expected_endpoint.get("headers", {})
+
+
+def test_none_returns_default_partition(rule_lib):
+    partition_dict = rule_lib.aws_partition(None)
+    assert partition_dict['name'] == "aws"
+
+
+def test_no_match_region_returns_default_partition(rule_lib):
+    partition_dict = rule_lib.aws_partition("invalid-region-42")
+    assert partition_dict['name'] == "aws"
+
+
+def test_invalid_arn_returns_none(rule_lib):
+    assert rule_lib.aws_parse_arn("arn:aws:this-is-not-an-arn:foo") is None
+
+
+@pytest.mark.parametrize(
+    "arn, expected_resource_id",
+    [
+        (
+            "arn:aws:s3:::myBucket/key",
+            {
+                "partition": "aws",
+                "service": "s3",
+                "region": "",
+                "accountId": "",
+                "resourceId": ["myBucket", "key"],
+            },
+        ),
+        (
+            "arn:aws:kinesis:us-east-1:1234567890:stream/mystream:foo",
+            {
+                "partition": "aws",
+                "service": "kinesis",
+                "region": "us-east-1",
+                "accountId": "1234567890",
+                "resourceId": ["stream", "mystream", "foo"],
+            },
+        ),
+        (
+            "arn:aws:s3:::myBucket",
+            {
+                "partition": "aws",
+                "service": "s3",
+                "region": "",
+                "accountId": "",
+                "resourceId": ["myBucket"],
+            },
+        ),
+    ],
+)
+def test_parse_arn_delimiters(rule_lib, arn, expected_resource_id):
+    parsed_arn = rule_lib.aws_parse_arn(arn)
+    assert parsed_arn == expected_resource_id
+
+
+def test_uri_encode_none_returns_none(rule_lib):
+    assert rule_lib.uri_encode(None) is None
+
+
+def test_parse_url_none_return_none(rule_lib):
+    assert rule_lib.parse_url(None) is None
+
+
+def test_string_equals_wrong_type_raises(rule_lib):
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        rule_lib.string_equals(1, 2)
+    assert "Both values must be strings" in str(exc_info.value)
+
+
+def test_boolean_equals_wrong_type_raises(rule_lib):
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        rule_lib.boolean_equals(1, 2)
+    assert "Both arguments must be bools" in str(exc_info.value)
+
+
+def test_substring_wrong_type_raises(rule_lib):
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        rule_lib.substring(["h", "e", "l", "l", "o"], 0, 5, False)
+    assert "Input must be a string" in str(exc_info.value)
+
+
+def test_creator_unknown_type_raises():
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        RuleCreator.create(type="foo")
+    assert "Unknown rule type: foo." in str(exc_info.value)
+
+
+def test_parameter_wrong_type_raises(endpoint_provider):
+    param = endpoint_provider.ruleset.parameters["Region"]
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        param.validate_input(1)
+    assert "Value (Region) is the wrong type" in str(exc_info.value)
+
+
+def test_deprecated_parameter_logs(endpoint_provider, caplog):
+    caplog.set_level(logging.INFO)
+    param = endpoint_provider.ruleset.parameters["Region"]
+    param.validate_input("foo")
+    assert "Region has been deprecated." in caplog.text
+
+
+def test_no_endpoint_found_error(endpoint_provider):
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        endpoint_provider.resolve_endpoint(
+            **{"Endpoint": "mygreatendpoint.com", "Bucket": "mybucket"}
+        )
+    assert "No endpoint found for parameters" in str(exc_info.value)
+
+
+@pytest.mark.parametrize(
+    "rule_dict,expected_rule_type",
+    [
+        (
+            {
+                "type": "endpoint",
+                "conditions": [],
+                "endpoint": {
+                    "url": (
+                        "https://{Region}.myGreatService."
+                        "{PartitionResult#dualStackDnsSuffix}"
+                    ),
+                    "properties": {},
+                    "headers": {},
+                },
+            },
+            EndpointRule,
+        ),
+        (
+            {
+                "type": "error",
+                "conditions": [],
+                "error": (
+                    "Dualstack is enabled but this partition "
+                    "does not support DualStack"
+                ),
+            },
+            ErrorRule,
+        ),
+        ({"type": "tree", "conditions": [], "rules": []}, TreeRule),
+    ],
+)
+def test_rule_creation(rule_dict, expected_rule_type):
+    rule = RuleCreator.create(**rule_dict)
+    assert isinstance(rule, expected_rule_type)
+
+
+def test_assign_existing_scope_var_raises(rule_lib):
+    rule = EndpointRule(
+        conditions=[
+            {
+                'fn': 'aws.parseArn',
+                'argv': ['{Bucket}'],
+                'assign': 'bucketArn',
+            },
+            {
+                'fn': 'aws.parseArn',
+                'argv': ['{Bucket}'],
+                'assign': 'bucketArn',
+            },
+        ],
+        endpoint={'url': 'foo.bar'},
+    )
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        rule.evaluate_conditions(
+            scope_vars={
+                'Bucket': 'arn:aws:s3:us-east-1:123456789012:mybucket'
+            },
+            rule_lib=rule_lib,
+        )
+    assert str(exc_info.value) == (
+        "Assignment bucketArn already exists in "
+        "scoped variables and cannot be overwritten"
+    )
+
+
+def test_ruleset_unknown_parameter_type_raises(partitions):
+    with pytest.raises(EndpointResolutionError) as exc_info:
+        RuleSet(
+            version='1.0',
+            parameters={
+                'Bucket': {"type": "list"},
+            },
+            rules=[],
+            partitions=partitions,
+        )
+    assert "Unknown parameter type: list." in str(exc_info.value)
+
+
+@pytest.fixture()
+def empty_resolver():
+    return EndpointRulesetResolver(
+        endpoint_ruleset_data={
+            'version': '1.0',
+            'parameters': {},
+            'rules': [],
+        },
+        partition_data={},
+        service_model=None,
+        builtins={},
+        client_context=None,
+        event_emitter=None,
+        use_ssl=True,
+        requested_auth_scheme=None,
+    )
+
+
+def test_auth_schemes_conversion_sigv4(empty_resolver):
+    auth_schemes = [
+        {
+            'name': 'sigv4',
+            'signingName': 'dynamodb',
+            'signingRegion': 'my-region-1',
+            'disableDoubleEncoding': True,
+            'otherParameter': 'otherValue',
+        }
+    ]
+    at, sc = empty_resolver.auth_schemes_to_signing_ctx(auth_schemes)
+    assert at == 'v4'
+    assert sc == {
+        'region': 'my-region-1',
+        'signing_name': 'dynamodb',
+        'disableDoubleEncoding': True,
+    }
+
+
+@requires_crt()
+def test_auth_schemes_conversion_sigv4a_with_crt(monkeypatch, empty_resolver):
+    monkeypatch.setattr('botocore.regions.HAS_CRT', True)
+    auth_schemes = [
+        {'name': 'sigv4a', 'signingName': 's3', 'signingRegionSet': ['*']}
+    ]
+    at, sc = empty_resolver.auth_schemes_to_signing_ctx(auth_schemes)
+    assert at == 'v4a'
+    assert sc == {'region': '*', 'signing_name': 's3'}
+
+
+def test_auth_schemes_conversion_sigv4a_without_crt(
+    monkeypatch, empty_resolver
+):
+    monkeypatch.setattr('botocore.regions.HAS_CRT', False)
+    monkeypatch.setattr('botocore.regions.AUTH_TYPE_MAPS', {})
+    auth_schemes = [
+        {'name': 'sigv4a', 'signingName': 's3', 'signingRegionSet': ['*']}
+    ]
+    with pytest.raises(MissingDependencyException):
+        empty_resolver.auth_schemes_to_signing_ctx(auth_schemes)
+
+
+def test_auth_schemes_conversion_no_known_auth_types(empty_resolver):
+    auth_schemes = [
+        {'name': 'foo', 'signingName': 's3', 'signingRegion': 'ap-south-2'},
+        {'name': 'bar', 'otherParamKey': 'otherParamVal'},
+    ]
+    with pytest.raises(UnknownSignatureVersionError):
+        empty_resolver.auth_schemes_to_signing_ctx(auth_schemes)
+
+
+def test_auth_schemes_conversion_first_authtype_unknown(
+    monkeypatch, empty_resolver
+):
+    monkeypatch.setattr('botocore.regions.HAS_CRT', False)
+    monkeypatch.setattr('botocore.regions.AUTH_TYPE_MAPS', {'bar': None})
+    auth_schemes = [
+        {'name': 'foo', 'signingName': 's3', 'signingRegion': 'ap-south-1'},
+        {'name': 'bar', 'signingName': 's3', 'signingRegion': 'ap-south-2'},
+    ]
+    at, sc = empty_resolver.auth_schemes_to_signing_ctx(auth_schemes)
+    assert at == 'bar'
+    assert sc == {'region': 'ap-south-2', 'signing_name': 's3'}
+
+
+def test_endpoint_resolution_caches(endpoint_provider, monkeypatch):
+    mock_evaluate = Mock()
+    monkeypatch.setattr(RuleSet, "evaluate", mock_evaluate)
+    for _ in range(5):
+        endpoint_provider.resolve_endpoint(Region="us-east-2")
+    mock_evaluate.assert_called_once_with({"Region": "us-east-2"})
+
+
+def test_endpoint_reevaluates_result(endpoint_provider, monkeypatch):
+    regions = ["us-east-1", "us-west-2"]
+    mock_evaluate = Mock()
+    monkeypatch.setattr(RuleSet, "evaluate", mock_evaluate)
+    for region in regions:
+        endpoint_provider.resolve_endpoint(Region=region)
+    assert mock_evaluate.call_count == 2
+
+
+@pytest.mark.parametrize(
+    "bucket, expected_value",
+    [
+        ("mybucket", True),
+        ("ab", False),
+        ("a.b", True),
+        ("my.great.bucket.aws.com", True),
+        ("mY.GREAT.bucket.aws.com", False),
+        ("192.168.1.1", False),
+    ],
+)
+def test_aws_is_virtual_hostable_s3_bucket_allow_subdomains(
+    rule_lib, bucket, expected_value
+):
+    assert (
+        rule_lib.aws_is_virtual_hostable_s3_bucket(bucket, True)
+        == expected_value
+    )

testbed/boto__botocore/tests/unit/test_errorfactory.py

@@ -0,0 +1,139 @@
+# Copyright 2016 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+from botocore.errorfactory import BaseClientExceptions, ClientExceptionsFactory
+from botocore.exceptions import ClientError
+from botocore.model import ServiceModel
+from tests import unittest
+
+
+class TestBaseClientExceptions(unittest.TestCase):
+    def setUp(self):
+        self.code_to_exception = {}
+        self.exceptions = BaseClientExceptions(self.code_to_exception)
+
+    def test_has_client_error(self):
+        self.assertIs(self.exceptions.ClientError, ClientError)
+
+    def test_from_code(self):
+        exception_cls = type('MyException', (ClientError,), {})
+        self.code_to_exception['MyExceptionCode'] = exception_cls
+        self.assertIs(
+            self.exceptions.from_code('MyExceptionCode'), exception_cls
+        )
+
+    def test_from_code_nonmatch_defaults_to_client_error(self):
+        self.assertIs(
+            self.exceptions.from_code('SomeUnknownErrorCode'), ClientError
+        )
+
+    def test_gettattr_message(self):
+        exception_cls = type('MyException', (ClientError,), {})
+        self.code_to_exception['MyExceptionCode'] = exception_cls
+        with self.assertRaisesRegex(
+            AttributeError, 'Valid exceptions are: MyException'
+        ):
+            self.exceptions.SomeUnmodeledError
+
+
+class TestClientExceptionsFactory(unittest.TestCase):
+    def setUp(self):
+        self.model = {
+            "metadata": {
+                'endpointPrefix': 'myservice',
+                'serviceFullName': 'MyService',
+            },
+            'operations': {
+                'OperationName': {
+                    'name': 'OperationName',
+                    'errors': [
+                        {'shape': 'ExceptionMissingCode'},
+                        {'shape': 'ExceptionWithModeledCode'},
+                    ],
+                },
+                'AnotherOperationName': {
+                    'name': 'AnotherOperationName',
+                    'errors': [
+                        {'shape': 'ExceptionForAnotherOperation'},
+                        {'shape': 'ExceptionWithModeledCode'},
+                    ],
+                },
+            },
+            'shapes': {
+                'ExceptionWithModeledCode': {
+                    'type': 'structure',
+                    'members': {},
+                    'error': {'code': 'ModeledCode'},
+                    'exception': True,
+                },
+                'ExceptionMissingCode': {
+                    'type': 'structure',
+                    'members': {},
+                    'exception': True,
+                },
+                'ExceptionForAnotherOperation': {
+                    'type': 'structure',
+                    'members': {},
+                    'exception': True,
+                },
+            },
+        }
+        self.service_model = ServiceModel(self.model)
+        self.exceptions_factory = ClientExceptionsFactory()
+
+    def test_class_name(self):
+        exceptions = self.exceptions_factory.create_client_exceptions(
+            self.service_model
+        )
+        self.assertEqual(exceptions.__class__.__name__, 'MyServiceExceptions')
+
+    def test_creates_modeled_exception(self):
+        exceptions = self.exceptions_factory.create_client_exceptions(
+            self.service_model
+        )
+        self.assertTrue(hasattr(exceptions, 'ExceptionWithModeledCode'))
+        modeled_exception = exceptions.ExceptionWithModeledCode
+        self.assertEqual(
+            modeled_exception.__name__, 'ExceptionWithModeledCode'
+        )
+        self.assertTrue(issubclass(modeled_exception, ClientError))
+
+    def test_collects_modeled_exceptions_for_all_operations(self):
+        exceptions = self.exceptions_factory.create_client_exceptions(
+            self.service_model
+        )
+        # Make sure exceptions were added for all operations by checking
+        # an exception only found on an a different operation.
+        self.assertTrue(hasattr(exceptions, 'ExceptionForAnotherOperation'))
+        modeled_exception = exceptions.ExceptionForAnotherOperation
+        self.assertEqual(
+            modeled_exception.__name__, 'ExceptionForAnotherOperation'
+        )
+        self.assertTrue(issubclass(modeled_exception, ClientError))
+
+    def test_creates_modeled_exception_mapping_that_has_code(self):
+        exceptions = self.exceptions_factory.create_client_exceptions(
+            self.service_model
+        )
+        exception = exceptions.from_code('ModeledCode')
+        self.assertEqual(exception.__name__, 'ExceptionWithModeledCode')
+        self.assertTrue(issubclass(exception, ClientError))
+
+    def test_creates_modeled_exception_mapping_that_has_no_code(self):
+        exceptions = self.exceptions_factory.create_client_exceptions(
+            self.service_model
+        )
+        # For exceptions that do not have an explicit code associated to them,
+        # the code is the name of the exception.
+        exception = exceptions.from_code('ExceptionMissingCode')
+        self.assertEqual(exception.__name__, 'ExceptionMissingCode')
+        self.assertTrue(issubclass(exception, ClientError))

testbed/boto__botocore/tests/unit/test_eventstream.py

@@ -0,0 +1,568 @@
+# Copyright 2018 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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 binary event stream decoder."""
+
+import pytest
+
+from botocore.eventstream import (
+    ChecksumMismatch,
+    DecodeUtils,
+    DuplicateHeader,
+    EventStream,
+    EventStreamBuffer,
+    EventStreamHeaderParser,
+    EventStreamMessage,
+    InvalidHeadersLength,
+    InvalidPayloadLength,
+    MessagePrelude,
+    NoInitialResponseError,
+)
+from botocore.exceptions import EventStreamError
+from botocore.parsers import EventStreamXMLParser
+from tests import mock
+
+EMPTY_MESSAGE = (
+    b'\x00\x00\x00\x10\x00\x00\x00\x00\x05\xc2H\xeb}\x98\xc8\xff',
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x10,
+            headers_length=0,
+            crc=0x05C248EB,
+        ),
+        headers={},
+        payload=b'',
+        crc=0x7D98C8FF,
+    ),
+)
+
+INT8_HEADER = (
+    (
+        b"\x00\x00\x00\x17\x00\x00\x00\x07)\x86\x01X\x04"
+        b"byte\x02\xff\xc2\xf8i\xdc"
+    ),
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x17,
+            headers_length=0x7,
+            crc=0x29860158,
+        ),
+        headers={'byte': -1},
+        payload=b'',
+        crc=0xC2F869DC,
+    ),
+)
+
+INT16_HEADER = (
+    (
+        b"\x00\x00\x00\x19\x00\x00\x00\tq\x0e\x92>\x05"
+        b"short\x03\xff\xff\xb2|\xb6\xcc"
+    ),
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x19,
+            headers_length=0x9,
+            crc=0x710E923E,
+        ),
+        headers={'short': -1},
+        payload=b'',
+        crc=0xB27CB6CC,
+    ),
+)
+
+INT32_HEADER = (
+    (
+        b"\x00\x00\x00\x1d\x00\x00\x00\r\x83\xe3\xf0\xe7\x07"
+        b"integer\x04\xff\xff\xff\xff\x8b\x8e\x12\xeb"
+    ),
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x1D,
+            headers_length=0xD,
+            crc=0x83E3F0E7,
+        ),
+        headers={'integer': -1},
+        payload=b'',
+        crc=0x8B8E12EB,
+    ),
+)
+
+INT64_HEADER = (
+    (
+        b"\x00\x00\x00\x1e\x00\x00\x00\x0e]J\xdb\x8d\x04"
+        b"long\x05\xff\xff\xff\xff\xff\xff\xff\xffK\xc22\xda"
+    ),
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x1E,
+            headers_length=0xE,
+            crc=0x5D4ADB8D,
+        ),
+        headers={'long': -1},
+        payload=b'',
+        crc=0x4BC232DA,
+    ),
+)
+
+PAYLOAD_NO_HEADERS = (
+    b"\x00\x00\x00\x1d\x00\x00\x00\x00\xfdR\x8cZ{'foo':'bar'}\xc3e96",
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x1D,
+            headers_length=0,
+            crc=0xFD528C5A,
+        ),
+        headers={},
+        payload=b"{'foo':'bar'}",
+        crc=0xC3653936,
+    ),
+)
+
+PAYLOAD_ONE_STR_HEADER = (
+    (
+        b"\x00\x00\x00=\x00\x00\x00 \x07\xfd\x83\x96\x0ccontent-type\x07\x00\x10"
+        b"application/json{'foo':'bar'}\x8d\x9c\x08\xb1"
+    ),
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x3D,
+            headers_length=0x20,
+            crc=0x07FD8396,
+        ),
+        headers={'content-type': 'application/json'},
+        payload=b"{'foo':'bar'}",
+        crc=0x8D9C08B1,
+    ),
+)
+
+ALL_HEADERS_TYPES = (
+    (
+        b"\x00\x00\x00\x62\x00\x00\x00\x52\x03\xb5\xcb\x9c"
+        b"\x010\x00\x011\x01\x012\x02\x02\x013\x03\x00\x03"
+        b"\x014\x04\x00\x00\x00\x04\x015\x05\x00\x00\x00\x00\x00\x00\x00\x05"
+        b"\x016\x06\x00\x05bytes\x017\x07\x00\x04utf8"
+        b"\x018\x08\x00\x00\x00\x00\x00\x00\x00\x08\x019\x090123456789abcdef"
+        b"\x63\x35\x36\x71"
+    ),
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x62,
+            headers_length=0x52,
+            crc=0x03B5CB9C,
+        ),
+        headers={
+            '0': True,
+            '1': False,
+            '2': 0x02,
+            '3': 0x03,
+            '4': 0x04,
+            '5': 0x05,
+            '6': b'bytes',
+            '7': 'utf8',
+            '8': 0x08,
+            '9': b'0123456789abcdef',
+        },
+        payload=b"",
+        crc=0x63353671,
+    ),
+)
+
+ERROR_EVENT_MESSAGE = (
+    (
+        b"\x00\x00\x00\x52\x00\x00\x00\x42\xbf\x23\x63\x7e"
+        b"\x0d:message-type\x07\x00\x05error"
+        b"\x0b:error-code\x07\x00\x04code"
+        b"\x0e:error-message\x07\x00\x07message"
+        b"\x6b\x6c\xea\x3d"
+    ),
+    EventStreamMessage(
+        prelude=MessagePrelude(
+            total_length=0x52,
+            headers_length=0x42,
+            crc=0xBF23637E,
+        ),
+        headers={
+            ':message-type': 'error',
+            ':error-code': 'code',
+            ':error-message': 'message',
+        },
+        payload=b'',
+        crc=0x6B6CEA3D,
+    ),
+)
+
+# Tuples of encoded messages and their expected decoded output
+POSITIVE_CASES = [
+    EMPTY_MESSAGE,
+    INT8_HEADER,
+    INT16_HEADER,
+    INT32_HEADER,
+    INT64_HEADER,
+    PAYLOAD_NO_HEADERS,
+    PAYLOAD_ONE_STR_HEADER,
+    ALL_HEADERS_TYPES,
+    ERROR_EVENT_MESSAGE,
+]
+
+CORRUPTED_HEADER_LENGTH = (
+    (
+        b"\x00\x00\x00=\xff\x00\x01\x02\x07\xfd\x83\x96\x0ccontent-type\x07\x00"
+        b"\x10application/json{'foo':'bar'}\x8d\x9c\x08\xb1"
+    ),
+    ChecksumMismatch,
+)
+
+CORRUPTED_HEADERS = (
+    (
+        b"\x00\x00\x00=\x00\x00\x00 \x07\xfd\x83\x96\x0ccontent+type\x07\x00\x10"
+        b"application/json{'foo':'bar'}\x8d\x9c\x08\xb1"
+    ),
+    ChecksumMismatch,
+)
+
+CORRUPTED_LENGTH = (
+    b"\x01\x00\x00\x1d\x00\x00\x00\x00\xfdR\x8cZ{'foo':'bar'}\xc3e96",
+    ChecksumMismatch,
+)
+
+CORRUPTED_PAYLOAD = (
+    b"\x00\x00\x00\x1d\x00\x00\x00\x00\xfdR\x8cZ{'foo':'bar'\x8d\xc3e96",
+    ChecksumMismatch,
+)
+
+DUPLICATE_HEADER = (
+    (
+        b"\x00\x00\x00\x24\x00\x00\x00\x14\x4b\xb9\x82\xd0"
+        b"\x04test\x04asdf\x04test\x04asdf\xf3\xf4\x75\x63"
+    ),
+    DuplicateHeader,
+)
+
+# In contrast to the CORRUPTED_HEADERS case, this message is otherwise
+# well-formed - the checksums match.
+INVALID_HEADERS_LENGTH = (
+    (
+        b"\x00\x00\x00\x3d"  # total length
+        b"\xff\x00\x01\x02"  # headers length
+        b"\x15\x83\xf5\xc2"  # prelude crc
+        b"\x0ccontent-type\x07\x00\x10application/json"  # headers
+        b"{'foo':'bar'}"  # payload
+        b"\x2f\x37\x7f\x5d"  # message crc
+    ),
+    InvalidHeadersLength,
+)
+
+# In contrast to the CORRUPTED_PAYLOAD case, this message is otherwise
+# well-formed - the checksums match.
+INVALID_PAYLOAD_LENGTH = (
+    b"\x01\x00\x00\x11"  # total length
+    + b"\x00\x00\x00\x00"  # headers length
+    + b"\xf4\x08\x61\xc5"  # prelude crc
+    + b"0" * (16 * 1024**2 + 1)  # payload
+    + b"\x2a\xb4\xc5\xa5",  # message crc
+    InvalidPayloadLength,
+)
+
+# Tuples of encoded messages and their expected exception
+NEGATIVE_CASES = [
+    CORRUPTED_LENGTH,
+    CORRUPTED_PAYLOAD,
+    CORRUPTED_HEADERS,
+    CORRUPTED_HEADER_LENGTH,
+    DUPLICATE_HEADER,
+    INVALID_HEADERS_LENGTH,
+    INVALID_PAYLOAD_LENGTH,
+]
+
+
+def assert_message_equal(message_a, message_b):
+    """Asserts all fields for two messages are equal."""
+    assert message_a.prelude.total_length == message_b.prelude.total_length
+    assert message_a.prelude.headers_length == message_b.prelude.headers_length
+    assert message_a.prelude.crc == message_b.prelude.crc
+    assert message_a.headers == message_b.headers
+    assert message_a.payload == message_b.payload
+    assert message_a.crc == message_b.crc
+
+
+def test_partial_message():
+    """Ensure that we can receive partial payloads."""
+    data = EMPTY_MESSAGE[0]
+    event_buffer = EventStreamBuffer()
+    # This mid point is an arbitrary break in the middle of the headers
+    mid_point = 15
+    event_buffer.add_data(data[:mid_point])
+    messages = list(event_buffer)
+    assert messages == []
+    event_buffer.add_data(data[mid_point : len(data)])
+    for message in event_buffer:
+        assert_message_equal(message, EMPTY_MESSAGE[1])
+
+
+def check_message_decodes(encoded, decoded):
+    """Ensure the message decodes to what we expect."""
+    event_buffer = EventStreamBuffer()
+    event_buffer.add_data(encoded)
+    messages = list(event_buffer)
+    assert len(messages) == 1
+    assert_message_equal(messages[0], decoded)
+
+
+@pytest.mark.parametrize("encoded, decoded", POSITIVE_CASES)
+def test_positive_cases(encoded, decoded):
+    """Test that all positive cases decode how we expect."""
+    check_message_decodes(encoded, decoded)
+
+
+def test_all_positive_cases():
+    """Test all positive cases can be decoded on the same buffer."""
+    event_buffer = EventStreamBuffer()
+    # add all positive test cases to the same buffer
+    for encoded, _ in POSITIVE_CASES:
+        event_buffer.add_data(encoded)
+    # collect all of the expected messages
+    expected_messages = [decoded for (_, decoded) in POSITIVE_CASES]
+    # collect all of the decoded messages
+    decoded_messages = list(event_buffer)
+    # assert all messages match what we expect
+    for expected, decoded in zip(expected_messages, decoded_messages):
+        assert_message_equal(expected, decoded)
+
+
+@pytest.mark.parametrize(
+    "encoded, exception",
+    NEGATIVE_CASES,
+    ids=[
+        "corrupted-length",
+        "corrupted-payload",
+        "corrupted-headers",
+        "corrupted-headers-length",
+        "duplicate-headers",
+        "invalid-headers-length",
+        "invalid-payload-length",
+    ],
+)
+def test_negative_cases(encoded, exception):
+    """Test that all negative cases raise the expected exception."""
+    with pytest.raises(exception):
+        check_message_decodes(encoded, None)
+
+
+def test_header_parser():
+    """Test that the header parser supports all header types."""
+    headers_data = (
+        b"\x010\x00\x011\x01\x012\x02\x02\x013\x03\x00\x03"
+        b"\x014\x04\x00\x00\x00\x04\x015\x05\x00\x00\x00\x00\x00\x00\x00\x05"
+        b"\x016\x06\x00\x05bytes\x017\x07\x00\x04utf8"
+        b"\x018\x08\x00\x00\x00\x00\x00\x00\x00\x08\x019\x090123456789abcdef"
+    )
+
+    expected_headers = {
+        '0': True,
+        '1': False,
+        '2': 0x02,
+        '3': 0x03,
+        '4': 0x04,
+        '5': 0x05,
+        '6': b'bytes',
+        '7': 'utf8',
+        '8': 0x08,
+        '9': b'0123456789abcdef',
+    }
+
+    parser = EventStreamHeaderParser()
+    headers = parser.parse(headers_data)
+    assert headers == expected_headers
+
+
+def test_message_prelude_properties():
+    """Test that calculated properties from the payload are correct."""
+    # Total length: 40, Headers Length: 15, random crc
+    prelude = MessagePrelude(40, 15, 0x00000000)
+    assert prelude.payload_length == 9
+    assert prelude.headers_end == 27
+    assert prelude.payload_end == 36
+
+
+def test_message_to_response_dict():
+    response_dict = PAYLOAD_ONE_STR_HEADER[1].to_response_dict()
+    assert response_dict['status_code'] == 200
+
+    expected_headers = {'content-type': 'application/json'}
+    assert response_dict['headers'] == expected_headers
+    assert response_dict['body'] == b"{'foo':'bar'}"
+
+
+def test_message_to_response_dict_error():
+    response_dict = ERROR_EVENT_MESSAGE[1].to_response_dict()
+    assert response_dict['status_code'] == 400
+    headers = {
+        ':message-type': 'error',
+        ':error-code': 'code',
+        ':error-message': 'message',
+    }
+    assert response_dict['headers'] == headers
+    assert response_dict['body'] == b''
+
+
+def test_unpack_uint8():
+    (value, bytes_consumed) = DecodeUtils.unpack_uint8(b'\xde')
+    assert bytes_consumed == 1
+    assert value == 0xDE
+
+
+def test_unpack_uint32():
+    (value, bytes_consumed) = DecodeUtils.unpack_uint32(b'\xde\xad\xbe\xef')
+    assert bytes_consumed == 4
+    assert value == 0xDEADBEEF
+
+
+def test_unpack_int8():
+    (value, bytes_consumed) = DecodeUtils.unpack_int8(b'\xfe')
+    assert bytes_consumed == 1
+    assert value == -2
+
+
+def test_unpack_int16():
+    (value, bytes_consumed) = DecodeUtils.unpack_int16(b'\xff\xfe')
+    assert bytes_consumed == 2
+    assert value == -2
+
+
+def test_unpack_int32():
+    (value, bytes_consumed) = DecodeUtils.unpack_int32(b'\xff\xff\xff\xfe')
+    assert bytes_consumed == 4
+    assert value == -2
+
+
+def test_unpack_int64():
+    test_bytes = b'\xff\xff\xff\xff\xff\xff\xff\xfe'
+    (value, bytes_consumed) = DecodeUtils.unpack_int64(test_bytes)
+    assert bytes_consumed == 8
+    assert value == -2
+
+
+def test_unpack_array_short():
+    test_bytes = b'\x00\x10application/json'
+    (value, bytes_consumed) = DecodeUtils.unpack_byte_array(test_bytes)
+    assert bytes_consumed == 18
+    assert value == b'application/json'
+
+
+def test_unpack_byte_array_int():
+    (value, array_bytes_consumed) = DecodeUtils.unpack_byte_array(
+        b'\x00\x00\x00\x10application/json', length_byte_size=4
+    )
+    assert array_bytes_consumed == 20
+    assert value == b'application/json'
+
+
+def test_unpack_utf8_string():
+    length = b'\x00\x09'
+    utf8_string = b'\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e'
+    encoded = length + utf8_string
+    (value, bytes_consumed) = DecodeUtils.unpack_utf8_string(encoded)
+    assert bytes_consumed == 11
+    assert value == utf8_string.decode('utf-8')
+
+
+def test_unpack_prelude():
+    data = b'\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03'
+    prelude = DecodeUtils.unpack_prelude(data)
+    assert prelude == ((1, 2, 3), 12)
+
+
+def create_mock_raw_stream(*data):
+    raw_stream = mock.Mock()
+
+    def generator():
+        yield from data
+
+    raw_stream.stream = generator
+    return raw_stream
+
+
+def test_event_stream_wrapper_iteration():
+    raw_stream = create_mock_raw_stream(
+        b"\x00\x00\x00+\x00\x00\x00\x0e4\x8b\xec{\x08event-id\x04\x00",
+        b"\x00\xa0\x0c{'foo':'bar'}\xd3\x89\x02\x85",
+    )
+    parser = mock.Mock(spec=EventStreamXMLParser)
+    output_shape = mock.Mock()
+    event_stream = EventStream(raw_stream, output_shape, parser, '')
+    events = list(event_stream)
+    assert len(events) == 1
+
+    response_dict = {
+        'headers': {'event-id': 0x0000A00C},
+        'body': b"{'foo':'bar'}",
+        'status_code': 200,
+    }
+    parser.parse.assert_called_with(response_dict, output_shape)
+
+
+def test_eventstream_wrapper_iteration_error():
+    raw_stream = create_mock_raw_stream(ERROR_EVENT_MESSAGE[0])
+    parser = mock.Mock(spec=EventStreamXMLParser)
+    parser.parse.return_value = {}
+    output_shape = mock.Mock()
+    event_stream = EventStream(raw_stream, output_shape, parser, '')
+    with pytest.raises(EventStreamError):
+        list(event_stream)
+
+
+def test_event_stream_wrapper_close():
+    raw_stream = mock.Mock()
+    event_stream = EventStream(raw_stream, None, None, '')
+    event_stream.close()
+    raw_stream.close.assert_called_once_with()
+
+
+def test_event_stream_initial_response():
+    raw_stream = create_mock_raw_stream(
+        b'\x00\x00\x00~\x00\x00\x00O\xc5\xa3\xdd\xc6\r:message-type\x07\x00',
+        b'\x05event\x0b:event-type\x07\x00\x10initial-response\r:content-type',
+        b'\x07\x00\ttext/json{"InitialResponse": "sometext"}\xf6\x98$\x83',
+    )
+    parser = mock.Mock(spec=EventStreamXMLParser)
+    output_shape = mock.Mock()
+    event_stream = EventStream(raw_stream, output_shape, parser, '')
+    event = event_stream.get_initial_response()
+    headers = {
+        ':message-type': 'event',
+        ':event-type': 'initial-response',
+        ':content-type': 'text/json',
+    }
+    payload = b'{"InitialResponse": "sometext"}'
+    assert event.headers == headers
+    assert event.payload == payload
+
+
+def test_event_stream_initial_response_wrong_type():
+    raw_stream = create_mock_raw_stream(
+        b"\x00\x00\x00+\x00\x00\x00\x0e4\x8b\xec{\x08event-id\x04\x00",
+        b"\x00\xa0\x0c{'foo':'bar'}\xd3\x89\x02\x85",
+    )
+    parser = mock.Mock(spec=EventStreamXMLParser)
+    output_shape = mock.Mock()
+    event_stream = EventStream(raw_stream, output_shape, parser, '')
+    with pytest.raises(NoInitialResponseError):
+        event_stream.get_initial_response()
+
+
+def test_event_stream_initial_response_no_event():
+    raw_stream = create_mock_raw_stream(b'')
+    parser = mock.Mock(spec=EventStreamXMLParser)
+    output_shape = mock.Mock()
+    event_stream = EventStream(raw_stream, output_shape, parser, '')
+    with pytest.raises(NoInitialResponseError):
+        event_stream.get_initial_response()

testbed/boto__botocore/tests/unit/test_exceptions.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env
+# Copyright 2014 Amazon.com, Inc. or its affiliates. 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. A copy of
+# the License is located at
+#
+# http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file 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.
+import pickle
+
+import botocore.awsrequest
+import botocore.session
+from botocore import exceptions
+from tests import unittest
+
+
+def test_client_error_can_handle_missing_code_or_message():
+    response = {'Error': {}}
+    expect = 'An error occurred (Unknown) when calling the blackhole operation: Unknown'
+    assert str(exceptions.ClientError(response, 'blackhole')) == expect
+
+
+def test_client_error_has_operation_name_set():
+    response = {'Error': {}}
+    exception = exceptions.ClientError(response, 'blackhole')
+    assert hasattr(exception, 'operation_name')
+
+
+def test_client_error_set_correct_operation_name():
+    response = {'Error': {}}
+    exception = exceptions.ClientError(response, 'blackhole')
+    assert exception.operation_name == 'blackhole'
+
+
+def test_retry_info_added_when_present():
+    response = {
+        'Error': {},
+        'ResponseMetadata': {
+            'MaxAttemptsReached': True,
+            'RetryAttempts': 3,
+        },
+    }
+    error_msg = str(exceptions.ClientError(response, 'operation'))
+    if '(reached max retries: 3)' not in error_msg:
+        raise AssertionError(
+            "retry information not inject into error " f"message: {error_msg}"
+        )
+
+
+def test_retry_info_not_added_if_retry_attempts_not_present():
+    response = {
+        'Error': {},
+        'ResponseMetadata': {
+            'MaxAttemptsReached': True,
+        },
+    }
+    # Because RetryAttempts is missing, retry info is not
+    # in the error message.
+    error_msg = str(exceptions.ClientError(response, 'operation'))
+    if 'max retries' in error_msg:
+        raise AssertionError(
+            "Retry information should not be in exception "
+            "message when retry attempts not in response "
+            f"metadata: {error_msg}"
+        )
+
+
+def test_can_handle_when_response_missing_error_key():
+    response = {
+        'ResponseMetadata': {
+            'HTTPHeaders': {},
+            'HTTPStatusCode': 503,
+            'MaxAttemptsReached': True,
+            'RetryAttempts': 4,
+        }
+    }
+    e = exceptions.ClientError(response, 'SomeOperation')
+    if 'An error occurred (Unknown)' not in str(e):
+        raise AssertionError(
+            "Error code should default to 'Unknown' "
+            f"when missing error response, instead got: {str(e)}"
+        )
+
+
+class TestPickleExceptions(unittest.TestCase):
+    def test_single_kwarg_botocore_error(self):
+        exception = botocore.exceptions.DataNotFoundError(data_path='mypath')
+        unpickled_exception = pickle.loads(pickle.dumps(exception))
+        self.assertIsInstance(
+            unpickled_exception, botocore.exceptions.DataNotFoundError
+        )
+        self.assertEqual(str(unpickled_exception), str(exception))
+        self.assertEqual(unpickled_exception.kwargs, exception.kwargs)
+
+    def test_multiple_kwarg_botocore_error(self):
+        exception = botocore.exceptions.UnknownServiceError(
+            service_name='myservice', known_service_names=['s3']
+        )
+        unpickled_exception = pickle.loads(pickle.dumps(exception))
+        self.assertIsInstance(
+            unpickled_exception, botocore.exceptions.UnknownServiceError
+        )
+        self.assertEqual(str(unpickled_exception), str(exception))
+        self.assertEqual(unpickled_exception.kwargs, exception.kwargs)
+
+    def test_client_error(self):
+        exception = botocore.exceptions.ClientError(
+            error_response={
+                'Error': {'Code': 'MyCode', 'Message': 'MyMessage'}
+            },
+            operation_name='myoperation',
+        )
+        unpickled_exception = pickle.loads(pickle.dumps(exception))
+        self.assertIsInstance(
+            unpickled_exception, botocore.exceptions.ClientError
+        )
+        self.assertEqual(str(unpickled_exception), str(exception))
+        self.assertEqual(
+            unpickled_exception.operation_name, exception.operation_name
+        )
+        self.assertEqual(unpickled_exception.response, exception.response)
+
+    def test_dynamic_client_error(self):
+        session = botocore.session.Session()
+        client = session.create_client('s3', 'us-west-2')
+        exception = client.exceptions.NoSuchKey(
+            error_response={
+                'Error': {'Code': 'NoSuchKey', 'Message': 'Not Found'}
+            },
+            operation_name='myoperation',
+        )
+        unpickled_exception = pickle.loads(pickle.dumps(exception))
+        self.assertIsInstance(
+            unpickled_exception, botocore.exceptions.ClientError
+        )
+        self.assertEqual(str(unpickled_exception), str(exception))
+        self.assertEqual(
+            unpickled_exception.operation_name, exception.operation_name
+        )
+        self.assertEqual(unpickled_exception.response, exception.response)
+
+    def test_http_client_error(self):
+        exception = botocore.exceptions.HTTPClientError(
+            botocore.awsrequest.AWSRequest(),
+            botocore.awsrequest.AWSResponse(
+                url='https://foo.com', status_code=400, headers={}, raw=b''
+            ),
+            error='error',
+        )
+        unpickled_exception = pickle.loads(pickle.dumps(exception))
+        self.assertIsInstance(
+            unpickled_exception, botocore.exceptions.HTTPClientError
+        )
+        self.assertEqual(str(unpickled_exception), str(exception))
+        self.assertEqual(unpickled_exception.kwargs, exception.kwargs)
+        # The request/response properties on the HTTPClientError do not have
+        # __eq__ defined so we want to make sure properties are at least
+        # of the expected type
+        self.assertIsInstance(
+            unpickled_exception.request, botocore.awsrequest.AWSRequest
+        )
+        self.assertIsInstance(
+            unpickled_exception.response, botocore.awsrequest.AWSResponse
+        )