Initial commit

vendor/google/auth/.editorconfig

@@ -0,0 +1,18 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+charset = utf-8
+
+# Get rid of whitespace to avoid diffs with a bunch of EOL changes
+trim_trailing_whitespace = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+# PHP-Files
+[*.php]
+indent_style = space
+indent_size = 4

vendor/google/auth/.gitignore

@@ -0,0 +1,3 @@
+*~
+vendor
+composer.lock

vendor/google/auth/.php_cs

@@ -0,0 +1,54 @@
+<?php
+/**
+ * This file represents the configuration for Code Sniffing PSR-2-related
+ * automatic checks of coding guidelines
+ * Install @fabpot's great php-cs-fixer tool via
+ *
+ *  $ composer global require fabpot/php-cs-fixer
+ *
+ * And then simply run
+ *
+ *  $ php-cs-fixer fix --config-file .php_cs
+ *
+ * inside the root directory.
+ *
+ * 	 http://www.php-fig.org/psr/psr-2/
+ * 	 http://cs.sensiolabs.org
+ */
+
+if (PHP_SAPI !== 'cli') {
+    die('This script supports command line usage only. Please check your command.');
+}
+// Define in which folders to search and which folders to exclude
+// Exclude some directories that are excluded by Git anyways to speed up the sniffing
+$finder = Symfony\CS\Finder\DefaultFinder::create()
+    ->exclude('vendor')
+    ->in(__DIR__);
+
+// Return a Code Sniffing configuration using
+// all sniffers needed for PSR-2
+// and additionally:
+//  - Remove leading slashes in use clauses.
+//  - PHP single-line arrays should not have trailing comma.
+//  - Single-line whitespace before closing semicolon are prohibited.
+//  - Remove unused use statements in the PHP source code
+//  - Ensure Concatenation to have at least one whitespace around
+//  - Remove trailing whitespace at the end of blank lines.
+return Symfony\CS\Config\Config::create()
+    ->level(Symfony\CS\FixerInterface::PSR2_LEVEL)
+    ->fixers([
+        'remove_leading_slash_use',
+        'single_array_no_trailing_comma',
+        'spaces_before_semicolon',
+        'unused_use',
+        'concat_with_spaces',
+        'whitespacy_lines',
+        'ordered_use',
+        'single_quote',
+        'duplicate_semicolon',
+        'extra_empty_lines',
+        'phpdoc_no_package',
+        'phpdoc_scalar',
+        'no_empty_lines_after_phpdocs'
+    ])
+    ->finder($finder);

vendor/google/auth/.travis.yml

@@ -0,0 +1,31 @@
+language: php
+
+branches:
+  only: [master]
+
+sudo: false
+
+php:
+  - 5.4
+  - 5.5
+  - 5.6
+  - 7.0
+  - hhvm
+
+env:
+  - COMPOSER_CMD="composer install"
+  - COMPOSER_CMD="composer update --prefer-lowest"
+matrix:
+  include:
+    - php: "7.0"
+      env: RUN_CS_FIXER=true COMPOSER_CMD="composer install"
+
+before_script:
+  - $(echo $COMPOSER_CMD)
+
+script:
+  - if [ "${RUN_CS_FIXER}" = "true" ]; then
+      vendor/bin/php-cs-fixer fix --dry-run --diff --config-file=.php_cs .;
+    else
+      vendor/bin/phpunit;
+    fi

vendor/google/auth/CHANGELOG.md

@@ -0,0 +1,8 @@
+## 0.4.0 (23/04/2015)
+
+### Changes
+
+* Export callback function to update auth metadata ([@stanley-cheung][])
+* Adds an implementation of User Refresh Token auth ([@stanley-cheung][])
+
+[@stanley-cheung]: https://github.com/stanley-cheung

vendor/google/auth/CONTRIBUTING.md

@@ -0,0 +1,73 @@
+# How to become a contributor and submit your own code
+
+## Contributor License Agreements
+
+We'd love to accept your sample apps and patches! Before we can take them, we
+have to jump a couple of legal hurdles.
+
+Please fill out either the individual or corporate Contributor License Agreement
+(CLA).
+
+  * If you are an individual writing original source code and you're sure you
+    own the intellectual property, then you'll need to sign an [individual CLA]
+    (http://code.google.com/legal/individual-cla-v1.0.html).
+  * If you work for a company that wants to allow you to contribute your work,
+    then you'll need to sign a [corporate CLA]
+    (http://code.google.com/legal/corporate-cla-v1.0.html).
+
+Follow either of the two links above to access the appropriate CLA and
+instructions for how to sign and return it. Once we receive it, we'll be able to
+accept your pull requests.
+
+## Issue reporting
+
+* Check that the issue has not already been reported.
+* Check that the issue has not already been fixed in the latest code
+  (a.k.a. `master`).
+* Be clear, concise and precise in your description of the problem.
+* Open an issue with a descriptive title and a summary in grammatically correct,
+    complete sentences.
+* Include any relevant code to the issue summary.
+
+## Pull requests
+
+* Read [how to properly contribute to open source projects on Github][2].
+* Fork the project.
+* Use a topic/feature branch to easily amend a pull request later, if necessary.
+* Write [good commit messages][3].
+* Use the same coding conventions as the rest of the project.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it
+  in a future version unintentionally.
+* Add an entry to the [Changelog](CHANGELOG.md) accordingly. See [changelog entry format](#changelog-entry-format).
+* Please try not to mess with the Rakefile, version, or history. If you want to
+  have your own version, or is otherwise necessary, that is fine, but please
+  isolate to its own commit so I can cherry-pick around it.
+* Make sure the test suite is passing and the code you wrote doesn't produce
+  phpunit or phplint offenses.
+* [Squash related commits together][5].
+* Open a [pull request][4] that relates to *only* one subject with a clear title
+  and description in grammatically correct, complete sentences.
+
+### Changelog entry format
+
+Here are a few examples:
+
+```
+* ADC Support for User Refresh Tokens (@tbetbetbe[])
+* [#16](https://github.com/google/google-auth-library-php/issues/16): ADC Support for User Refresh Tokens ([@tbetbetbe][])
+```
+
+* Mark it up in [Markdown syntax][6].
+* The entry line should start with `* ` (an asterisk and a space).
+* If the change has a related GitHub issue (e.g. a bug fix for a reported issue), put a link to the issue as `[#16](https://github.com/google/google-auth-library-php/issues/16): `.
+* Describe the brief of the change. The sentence should end with a punctuation.
+* At the end of the entry, add an implicit link to your GitHub user page as `([@username][])`.
+* If this is your first contribution to google-auth-library-php project, add a link definition for the implicit link to the bottom of the changelog as `[@username]: https://github.com/username`.
+
+[1]: https://github.com/google/google-auth-php-library/issues
+[2]: http://gun.io/blog/how-to-github-fork-branch-and-pull-request
+[3]: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html
+[4]: https://help.github.com/articles/using-pull-requests
+[5]: http://gitready.com/advanced/2009/02/10/squashing-commits-with-rebase.html
+[6]: http://daringfireball.net/projects/markdown/syntax

vendor/google/auth/COPYING

@@ -0,0 +1,202 @@
+
+                                 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
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2015 Google Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

vendor/google/auth/LICENSE

@@ -0,0 +1,203 @@
+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
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include
+the brackets!) The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+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.
+
+

vendor/google/auth/README.md

@@ -0,0 +1,150 @@
+# Google Auth Library for PHP
+
+<dl>
+  <dt>Homepage</dt><dd><a href="http://www.github.com/google/google-auth-library-php">http://www.github.com/google/google-auth-library-php</a></dd>
+  <dt>Authors</dt>
+    <dd><a href="mailto:temiola@google.com">Tim Emiola</a></dd>
+    <dd><a href="mailto:stanleycheung@google.com">Stanley Cheung</a></dd>
+    <dd><a href="mailto:betterbrent@google.com">Brent Shaffer</a></dd>
+  <dt>Copyright</dt><dd>Copyright © 2015 Google, Inc.</dd>
+  <dt>License</dt><dd>Apache 2.0</dd>
+</dl>
+
+## Description
+
+This is Google's officially supported PHP client library for using OAuth 2.0
+authorization and authentication with Google APIs.
+
+### Installing via Composer
+
+The recommended way to install the google auth library is through
+[Composer](http://getcomposer.org).
+
+```bash
+# Install Composer
+curl -sS https://getcomposer.org/installer | php
+```
+
+Next, run the Composer command to install the latest stable version:
+
+```bash
+composer.phar require google/auth
+```
+
+## Application Default Credentials
+
+This library provides an implementation of
+[application default credentials][application default credentials] for PHP.
+
+The Application Default Credentials provide a simple way to get authorization
+credentials for use in calling Google APIs.
+
+They are best suited for cases when the call needs to have the same identity
+and authorization level for the application independent of the user. This is
+the recommended approach to authorize calls to Cloud APIs, particularly when
+you're building an application that uses Google Compute Engine.
+
+#### Download your Service Account Credentials JSON file
+
+To use `Application Default Credentials`, You first need to download a set of
+JSON credentials for your project. Go to **APIs & Auth** > **Credentials** in
+the [Google Developers Console][developer console] and select
+**Service account** from the **Add credentials** dropdown.
+
+> This file is your *only copy* of these credentials. It should never be
+> committed with your source code, and should be stored securely.
+
+Once downloaded, store the path to this file in the
+`GOOGLE_APPLICATION_CREDENTIALS` environment variable.
+
+```php
+putenv('GOOGLE_APPLICATION_CREDENTIALS=/path/to/my/credentials.json');
+```
+
+> PHP's `putenv` function is just one way to set an environment variable.
+> Consider using `.htaccess` or apache configuration files as well.
+
+#### Enable the API you want to use
+
+Before making your API call, you must be sure the API you're calling has been
+enabled. Go to **APIs & Auth** > **APIs** in the
+[Google Developers Console][developer console] and enable the APIs you'd like to
+call. For the example below, you must enable the `Drive API`.
+
+#### Call the APIs
+
+As long as you update the environment variable below to point to *your* JSON
+credentials file, the following code should output a list of your Drive files.
+
+```php
+use Google\Auth\ApplicationDefaultCredentials;
+use GuzzleHttp\Client;
+use GuzzleHttp\HandlerStack;
+
+// specify the path to your application credentials
+putenv('GOOGLE_APPLICATION_CREDENTIALS=/path/to/my/credentials.json');
+
+// define the scopes for your API call
+$scopes = ['https://www.googleapis.com/auth/drive.readonly'];
+
+// create middleware
+$middleware = ApplicationDefaultCredentials::getMiddleware($scopes);
+$stack = HandlerStack::create();
+$stack->push($middleware);
+
+// create the HTTP client
+$client = new Client([
+  'handler' => $stack,
+  'base_url' => 'https://www.googleapis.com',
+  'auth' => 'google_auth'  // authorize all requests
+]);
+
+// make the request
+$response = $client->get('drive/v2/files');
+
+// show the result!
+print_r((string) $response->getBody());
+```
+
+##### Guzzle 5 Compatibility
+
+If you are using [Guzzle 5][Guzzle 5], replace the `create middleware` and
+`create the HTTP Client` steps with the following:
+
+```php
+// create the HTTP client
+$client = new Client([
+  'base_url' => 'https://www.googleapis.com',
+  'auth' => 'google_auth'  // authorize all requests
+]);
+
+// create subscriber
+$subscriber = ApplicationDefaultCredentials::getSubscriber($scopes);
+$client->getEmitter()->attach($subscriber);
+
+```
+
+## License
+
+This library is licensed under Apache 2.0. Full license text is
+available in [COPYING][copying].
+
+## Contributing
+
+See [CONTRIBUTING][contributing].
+
+## Support
+
+Please
+[report bugs at the project on Github](https://github.com/google/google-auth-library-php/issues). Don't
+hesitate to
+[ask questions](http://stackoverflow.com/questions/tagged/google-auth-library-php)
+about the client or APIs on [StackOverflow](http://stackoverflow.com).
+
+[google-apis-php-client]: https://github.com/google/google-api-php-client
+[application default credentials]: https://developers.google.com/accounts/docs/application-default-credentials
+[contributing]: https://github.com/google/google-auth-library-php/tree/master/CONTRIBUTING.md
+[copying]: https://github.com/google/google-auth-library-php/tree/master/COPYING
+[Guzzle]: https://github.com/guzzle/guzzle
+[Guzzle 5]: http://docs.guzzlephp.org/en/5.3
+[developer console]: https://console.developers.google.com

vendor/google/auth/autoload.php

@@ -0,0 +1,34 @@
+<?php
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+function oauth2client_php_autoload($className)
+{
+    $classPath = explode('_', $className);
+    if ($classPath[0] != 'Google') {
+        return;
+    }
+    if (count($classPath) > 3) {
+        // Maximum class file path depth in this project is 3.
+    $classPath = array_slice($classPath, 0, 3);
+    }
+    $filePath = dirname(__FILE__) . '/src/' . implode('/', $classPath) . '.php';
+    if (file_exists($filePath)) {
+        require_once $filePath;
+    }
+}
+
+spl_autoload_register('oauth2client_php_autoload');

vendor/google/auth/composer.json

@@ -0,0 +1,28 @@
+{
+  "name": "google/auth",
+  "type": "library",
+  "description": "Google Auth Library for PHP",
+  "keywords": ["google", "oauth2", "authentication"],
+  "homepage": "http://github.com/google/google-auth-library-php",
+  "license": "Apache-2.0",
+  "require": {
+    "php": ">=5.4",
+    "firebase/php-jwt": "~2.0|~3.0|~4.0",
+    "guzzlehttp/guzzle": "~5.3|~6.0",
+    "guzzlehttp/psr7": "~1.2",
+    "psr/http-message": "^1.0",
+    "psr/cache": "^1.0"
+  },
+  "require-dev": {
+    "phpunit/phpunit": "3.7.*",
+    "friendsofphp/php-cs-fixer": "^1.11"
+  },
+  "autoload": {
+    "classmap": [
+      "src/"
+    ],
+    "psr-4": {
+      "Google\\Auth\\": "src"
+    }
+  }
+}

vendor/google/auth/phpunit.xml.dist

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="tests/bootstrap.php" colors="true">
+  <testsuites>
+    <testsuite name="google-auth-tests">
+      <directory suffix="Test.php">tests</directory>
+    </testsuite>
+  </testsuites>
+  <filter>
+    <whitelist>
+      <directory suffix=".php">src</directory>
+      <exclude>
+        <directory suffix="Interface.php">src/</directory>
+      </exclude>
+    </whitelist>
+  </filter>
+</phpunit>

vendor/google/auth/src/ApplicationDefaultCredentials.php

@@ -0,0 +1,173 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth;
+
+use DomainException;
+use Google\Auth\Credentials\AppIdentityCredentials;
+use Google\Auth\Credentials\GCECredentials;
+use Google\Auth\Middleware\AuthTokenMiddleware;
+use Google\Auth\Subscriber\AuthTokenSubscriber;
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+ * ApplicationDefaultCredentials obtains the default credentials for
+ * authorizing a request to a Google service.
+ *
+ * Application Default Credentials are described here:
+ * https://developers.google.com/accounts/docs/application-default-credentials
+ *
+ * This class implements the search for the application default credentials as
+ * described in the link.
+ *
+ * It provides three factory methods:
+ * - #get returns the computed credentials object
+ * - #getSubscriber returns an AuthTokenSubscriber built from the credentials object
+ * - #getMiddleware returns an AuthTokenMiddleware built from the credentials object
+ *
+ * This allows it to be used as follows with GuzzleHttp\Client:
+ *
+ *   use Google\Auth\ApplicationDefaultCredentials;
+ *   use GuzzleHttp\Client;
+ *   use GuzzleHttp\HandlerStack;
+ *
+ *   $middleware = ApplicationDefaultCredentials::getMiddleware(
+ *       'https://www.googleapis.com/auth/taskqueue'
+ *   );
+ *   $stack = HandlerStack::create();
+ *   $stack->push($middleware);
+ *
+ *   $client = new Client([
+ *       'handler' => $stack,
+ *       'base_uri' => 'https://www.googleapis.com/taskqueue/v1beta2/projects/',
+ *       'auth' => 'google_auth' // authorize all requests
+ *   ]);
+ *
+ *   $res = $client->get('myproject/taskqueues/myqueue');
+ */
+class ApplicationDefaultCredentials
+{
+    /**
+     * Obtains an AuthTokenSubscriber that uses the default FetchAuthTokenInterface
+     * implementation to use in this environment.
+     *
+     * If supplied, $scope is used to in creating the credentials instance if
+     * this does not fallback to the compute engine defaults.
+     *
+     * @param string|array scope the scope of the access request, expressed
+     *   either as an Array or as a space-delimited String.
+     * @param callable $httpHandler callback which delivers psr7 request
+     * @param array $cacheConfig configuration for the cache when it's present
+     * @param CacheItemPoolInterface $cache an implementation of CacheItemPoolInterface
+     *
+     * @return AuthTokenSubscriber
+     *
+     * @throws DomainException if no implementation can be obtained.
+     */
+    public static function getSubscriber(
+        $scope = null,
+        callable $httpHandler = null,
+        array $cacheConfig = null,
+        CacheItemPoolInterface $cache = null
+    ) {
+        $creds = self::getCredentials($scope, $httpHandler, $cacheConfig, $cache);
+
+        return new AuthTokenSubscriber($creds, $cacheConfig);
+    }
+
+    /**
+     * Obtains an AuthTokenMiddleware that uses the default FetchAuthTokenInterface
+     * implementation to use in this environment.
+     *
+     * If supplied, $scope is used to in creating the credentials instance if
+     * this does not fallback to the compute engine defaults.
+     *
+     * @param string|array scope the scope of the access request, expressed
+     *   either as an Array or as a space-delimited String.
+     * @param callable $httpHandler callback which delivers psr7 request
+     * @param array $cacheConfig configuration for the cache when it's present
+     * @param CacheItemPoolInterface $cache
+     *
+     * @return AuthTokenMiddleware
+     *
+     * @throws DomainException if no implementation can be obtained.
+     */
+    public static function getMiddleware(
+        $scope = null,
+        callable $httpHandler = null,
+        array $cacheConfig = null,
+        CacheItemPoolInterface $cache = null
+    ) {
+        $creds = self::getCredentials($scope, $httpHandler, $cacheConfig, $cache);
+
+        return new AuthTokenMiddleware($creds, $cacheConfig);
+    }
+
+    /**
+     * Obtains the default FetchAuthTokenInterface implementation to use
+     * in this environment.
+     *
+     * If supplied, $scope is used to in creating the credentials instance if
+     * this does not fallback to the Compute Engine defaults.
+     *
+     * @param string|array scope the scope of the access request, expressed
+     *   either as an Array or as a space-delimited String.
+     * @param callable $httpHandler callback which delivers psr7 request
+     * @param array $cacheConfig configuration for the cache when it's present
+     * @param CacheItemPoolInterface $cache
+     *
+     * @return CredentialsLoader
+     *
+     * @throws DomainException if no implementation can be obtained.
+     */
+    public static function getCredentials(
+        $scope = null,
+        callable $httpHandler = null,
+        array $cacheConfig = null,
+        CacheItemPoolInterface $cache = null
+    ) {
+        $creds = null;
+        $jsonKey = CredentialsLoader::fromEnv()
+            ?: CredentialsLoader::fromWellKnownFile();
+
+        if (!is_null($jsonKey)) {
+            $creds = CredentialsLoader::makeCredentials($scope, $jsonKey);
+        } elseif (AppIdentityCredentials::onAppEngine() && !GCECredentials::onAppEngineFlexible()) {
+            $creds = new AppIdentityCredentials($scope);
+        } elseif (GCECredentials::onGce($httpHandler)) {
+            $creds = new GCECredentials();
+        }
+
+        if (is_null($creds)) {
+            throw new \DomainException(self::notFound());
+        }
+        if (!is_null($cache)) {
+            $creds = new FetchAuthTokenCache($creds, $cacheConfig, $cache);
+        }
+        return $creds;
+    }
+
+    private static function notFound()
+    {
+        $msg = 'Could not load the default credentials. Browse to ';
+        $msg .= 'https://developers.google.com';
+        $msg .= '/accounts/docs/application-default-credentials';
+        $msg .= ' for more information';
+
+        return $msg;
+    }
+}

vendor/google/auth/src/Cache/InvalidArgumentException.php

@@ -0,0 +1,24 @@
+<?php
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Cache;
+
+use Psr\Cache\InvalidArgumentException as PsrInvalidArgumentException;
+
+class InvalidArgumentException extends \InvalidArgumentException implements PsrInvalidArgumentException
+{
+}

vendor/google/auth/src/Cache/Item.php

@@ -0,0 +1,185 @@
+<?php
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Cache;
+
+use Psr\Cache\CacheItemInterface;
+
+/**
+ * A cache item.
+ */
+final class Item implements CacheItemInterface
+{
+    /**
+     * @var string
+     */
+    private $key;
+
+    /**
+     * @var mixed
+     */
+    private $value;
+
+    /**
+     * @var \DateTime
+     */
+    private $expiration;
+
+    /**
+     * @var bool
+     */
+    private $isHit = false;
+
+    /**
+     * @param string $key
+     */
+    public function __construct($key)
+    {
+        $this->key = $key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getKey()
+    {
+        return $this->key;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function get()
+    {
+        return $this->isHit() ? $this->value : null;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function isHit()
+    {
+        if (!$this->isHit) {
+            return false;
+        }
+
+        if ($this->expiration === null) {
+            return true;
+        }
+
+        return new \DateTime() < $this->expiration;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function set($value)
+    {
+        $this->isHit = true;
+        $this->value = $value;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function expiresAt($expiration)
+    {
+        if ($this->isValidExpiration($expiration)) {
+            $this->expiration = $expiration;
+
+            return $this;
+        }
+
+        $implementationMessage = interface_exists('DateTimeInterface')
+            ? 'implement interface DateTimeInterface'
+            : 'be an instance of DateTime';
+
+        $error = sprintf(
+            'Argument 1 passed to %s::expiresAt() must %s, %s given',
+            get_class($this),
+            $implementationMessage,
+            gettype($expiration)
+        );
+
+        $this->handleError($error);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function expiresAfter($time)
+    {
+        if (is_int($time)) {
+            $this->expiration = new \DateTime("now + $time seconds");
+        } elseif ($time instanceof \DateInterval) {
+            $this->expiration = (new \DateTime())->add($time);
+        } elseif ($time === null) {
+            $this->expiration = $time;
+        } else {
+            $message = 'Argument 1 passed to %s::expiresAfter() must be an ' .
+                       'instance of DateInterval or of the type integer, %s given';
+            $error = sprintf($message, get_class($this), gettype($expiration));
+
+            $this->handleError($error);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Handles an error.
+     *
+     * @param string $error
+     * @throws \TypeError
+     */
+    private function handleError($error)
+    {
+        if (class_exists('TypeError')) {
+            throw new \TypeError($error);
+        }
+
+        trigger_error($error, E_USER_ERROR);
+    }
+
+    /**
+     * Determines if an expiration is valid based on the rules defined by PSR6.
+     *
+     * @param mixed $expiration
+     * @return bool
+     */
+    private function isValidExpiration($expiration)
+    {
+        if ($expiration === null) {
+            return true;
+        }
+
+        // We test for two types here due to the fact the DateTimeInterface
+        // was not introduced until PHP 5.5. Checking for the DateTime type as
+        // well allows us to support 5.4.
+        if ($expiration instanceof \DateTimeInterface) {
+            return true;
+        }
+
+        if ($expiration instanceof \DateTime) {
+            return true;
+        }
+
+        return false;
+    }
+}

vendor/google/auth/src/Cache/MemoryCacheItemPool.php

@@ -0,0 +1,155 @@
+<?php
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Cache;
+
+use Psr\Cache\CacheItemInterface;
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+ * Simple in-memory cache implementation.
+ */
+final class MemoryCacheItemPool implements CacheItemPoolInterface
+{
+    /**
+     * @var CacheItemInterface[]
+     */
+    private $items;
+
+    /**
+     * @var CacheItemInterface[]
+     */
+    private $deferredItems;
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getItem($key)
+    {
+        return current($this->getItems([$key]));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getItems(array $keys = [])
+    {
+        $items = [];
+
+        foreach ($keys as $key) {
+            $this->isValidKey($key);
+            $items[$key] = $this->hasItem($key) ? clone $this->items[$key] : new Item($key);
+        }
+
+        return $items;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function hasItem($key)
+    {
+        $this->isValidKey($key);
+
+        return isset($this->items[$key]) && $this->items[$key]->isHit();
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function clear()
+    {
+        $this->items = [];
+        $this->deferred = [];
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteItem($key)
+    {
+        return $this->deleteItems([$key]);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function deleteItems(array $keys)
+    {
+        array_walk($keys, [$this, 'isValidKey']);
+
+        foreach ($keys as $key) {
+            unset($this->items[$key]);
+        }
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function save(CacheItemInterface $item)
+    {
+        $this->items[$item->getKey()] = $item;
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function saveDeferred(CacheItemInterface $item)
+    {
+        $this->deferredItems[$item->getKey()] = $item;
+
+        return true;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function commit()
+    {
+        foreach ($this->deferredItems as $item) {
+            $this->save($item);
+        }
+
+        $this->deferredItems = [];
+
+        return true;
+    }
+
+    /**
+     * Determines if the provided key is valid.
+     *
+     * @param string $key
+     * @return bool
+     * @throws InvalidArgumentException
+     */
+    private function isValidKey($key)
+    {
+        $invalidCharacters = '{}()/\\\\@:';
+
+        if (!is_string($key) || preg_match("#[$invalidCharacters]#", $key)) {
+            throw new InvalidArgumentException('The provided key is not valid: ' . var_export($key, true));
+        }
+
+        return true;
+    }
+}

vendor/google/auth/src/CacheTrait.php

@@ -0,0 +1,72 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth;
+
+trait CacheTrait
+{
+    /**
+     * Gets the cached value if it is present in the cache when that is
+     * available.
+     */
+    private function getCachedValue($k)
+    {
+        if (is_null($this->cache)) {
+            return;
+        }
+
+        $key = $this->getFullCacheKey($k);
+        if (is_null($key)) {
+            return;
+        }
+
+        $cacheItem = $this->cache->getItem($key);
+        return $cacheItem->get();
+    }
+
+    /**
+     * Saves the value in the cache when that is available.
+     */
+    private function setCachedValue($k, $v)
+    {
+        if (is_null($this->cache)) {
+            return;
+        }
+
+        $key = $this->getFullCacheKey($k);
+        if (is_null($key)) {
+            return;
+        }
+
+        $cacheItem = $this->cache->getItem($key);
+        $cacheItem->set($v);
+        $cacheItem->expiresAfter($this->cacheConfig['lifetime']);
+        return $this->cache->save($cacheItem);
+    }
+
+    private function getFullCacheKey($key)
+    {
+        if (is_null($key)) {
+            return;
+        }
+
+        $key = $this->cacheConfig['prefix'] . $key;
+
+        // ensure we do not have illegal characters
+        return preg_replace('|[^a-zA-Z0-9_\.!]|', '', $key);
+    }
+}

vendor/google/auth/src/Credentials/AppIdentityCredentials.php

@@ -0,0 +1,149 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Credentials;
+
+/*
+ * The AppIdentityService class is automatically defined on App Engine,
+ * so including this dependency is not necessary, and will result in a
+ * PHP fatal error in the App Engine environment.
+ */
+use google\appengine\api\app_identity\AppIdentityService;
+use Google\Auth\CredentialsLoader;
+
+/**
+ * AppIdentityCredentials supports authorization on Google App Engine.
+ *
+ * It can be used to authorize requests using the AuthTokenMiddleware or
+ * AuthTokenSubscriber, but will only succeed if being run on App Engine:
+ *
+ *   use Google\Auth\Credentials\AppIdentityCredentials;
+ *   use Google\Auth\Middleware\AuthTokenMiddleware;
+ *   use GuzzleHttp\Client;
+ *   use GuzzleHttp\HandlerStack;
+ *
+ *   $gae = new AppIdentityCredentials('https://www.googleapis.com/auth/books');
+ *   $middleware = new AuthTokenMiddleware($gae);
+ *   $stack = HandlerStack::create();
+ *   $stack->push($middleware);
+ *
+ *   $client = new Client([
+ *       'handler' => $stack,
+ *       'base_uri' => 'https://www.googleapis.com/books/v1',
+ *       'auth' => 'google_auth'
+ *   ]);
+ *
+ *   $res = $client->get('volumes?q=Henry+David+Thoreau&country=US');
+ */
+class AppIdentityCredentials extends CredentialsLoader
+{
+    /**
+     * Result of fetchAuthToken.
+     *
+     * @array
+     */
+    protected $lastReceivedToken;
+
+    /**
+     * Array of OAuth2 scopes to be requested.
+     */
+    private $scope;
+
+    public function __construct($scope = array())
+    {
+        $this->scope = $scope;
+    }
+
+    /**
+     * Determines if this an App Engine instance, by accessing the SERVER_SOFTWARE
+     * environment variable.
+     *
+     * @return true if this an App Engine Instance, false otherwise
+     */
+    public static function onAppEngine()
+    {
+        return isset($_SERVER['SERVER_SOFTWARE']) &&
+        strpos($_SERVER['SERVER_SOFTWARE'], 'Google App Engine') !== false;
+    }
+
+    /**
+     * Implements FetchAuthTokenInterface#fetchAuthToken.
+     *
+     * Fetches the auth tokens using the AppIdentityService if available.
+     * As the AppIdentityService uses protobufs to fetch the access token,
+     * the GuzzleHttp\ClientInterface instance passed in will not be used.
+     *
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return array the auth metadata:
+     *  array(2) {
+     *   ["access_token"]=>
+     *   string(3) "xyz"
+     *   ["expiration_time"]=>
+     *   string(10) "1444339905"
+     *  }
+     *
+     * @throws \Exception
+     */
+    public function fetchAuthToken(callable $httpHandler = null)
+    {
+        if (!self::onAppEngine()) {
+            return array();
+        }
+
+        if (!class_exists('google\appengine\api\app_identity\AppIdentityService')) {
+            throw new \Exception(
+                'This class must be run in App Engine, or you must include the AppIdentityService '
+                . 'mock class defined in tests/mocks/AppIdentityService.php'
+            );
+        }
+
+        // AppIdentityService expects an array when multiple scopes are supplied
+        $scope = is_array($this->scope) ? $this->scope : explode(' ', $this->scope);
+
+        $token = AppIdentityService::getAccessToken($scope);
+        $this->lastReceivedToken = $token;
+
+        return $token;
+    }
+
+    /**
+     * @return array|null
+     */
+    public function getLastReceivedToken()
+    {
+        if ($this->lastReceivedToken) {
+            return [
+                'access_token' => $this->lastReceivedToken['access_token'],
+                'expires_at' => $this->lastReceivedToken['expiration_time'],
+            ];
+        }
+
+        return null;
+    }
+
+    /**
+     * Caching is handled by the underlying AppIdentityService, return empty string
+     * to prevent caching.
+     *
+     * @return string
+     */
+    public function getCacheKey()
+    {
+        return '';
+    }
+}

vendor/google/auth/src/Credentials/GCECredentials.php

@@ -0,0 +1,219 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Credentials;
+
+use Google\Auth\CredentialsLoader;
+use Google\Auth\HttpHandler\HttpHandlerFactory;
+use GuzzleHttp\Exception\ClientException;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Exception\ServerException;
+use GuzzleHttp\Psr7\Request;
+
+/**
+ * GCECredentials supports authorization on Google Compute Engine.
+ *
+ * It can be used to authorize requests using the AuthTokenMiddleware, but will
+ * only succeed if being run on GCE:
+ *
+ *   use Google\Auth\Credentials\GCECredentials;
+ *   use Google\Auth\Middleware\AuthTokenMiddleware;
+ *   use GuzzleHttp\Client;
+ *   use GuzzleHttp\HandlerStack;
+ *
+ *   $gce = new GCECredentials();
+ *   $middleware = new AuthTokenMiddleware($gce);
+ *   $stack = HandlerStack::create();
+ *   $stack->push($middleware);
+ *
+ *   $client = new Client([
+ *      'handler' => $stack,
+ *      'base_uri' => 'https://www.googleapis.com/taskqueue/v1beta2/projects/',
+ *      'auth' => 'google_auth'
+ *   ]);
+ *
+ *   $res = $client->get('myproject/taskqueues/myqueue');
+ */
+class GCECredentials extends CredentialsLoader
+{
+    const cacheKey = 'GOOGLE_AUTH_PHP_GCE';
+    /**
+     * The metadata IP address on appengine instances.
+     *
+     * The IP is used instead of the domain 'metadata' to avoid slow responses
+     * when not on Compute Engine.
+     */
+    const METADATA_IP = '169.254.169.254';
+
+    /**
+     * The metadata path of the default token.
+     */
+    const TOKEN_URI_PATH = 'v1/instance/service-accounts/default/token';
+
+    /**
+     * The header whose presence indicates GCE presence.
+     */
+    const FLAVOR_HEADER = 'Metadata-Flavor';
+
+    /**
+     * Flag used to ensure that the onGCE test is only done once;.
+     *
+     * @var bool
+     */
+    private $hasCheckedOnGce = false;
+
+    /**
+     * Flag that stores the value of the onGCE check.
+     *
+     * @var bool
+     */
+    private $isOnGce = false;
+
+    /**
+     * Result of fetchAuthToken.
+     */
+    protected $lastReceivedToken;
+
+    /**
+     * The full uri for accessing the default token.
+     *
+     * @return string
+     */
+    public static function getTokenUri()
+    {
+        $base = 'http://' . self::METADATA_IP . '/computeMetadata/';
+
+        return $base . self::TOKEN_URI_PATH;
+    }
+
+    /**
+     * Determines if this an App Engine Flexible instance, by accessing the
+     * GAE_VM environment variable.
+     *
+     * @return true if this an App Engine Flexible Instance, false otherwise
+     */
+    public static function onAppEngineFlexible()
+    {
+        return isset($_SERVER['GAE_VM']) && 'true' === $_SERVER['GAE_VM'];
+    }
+
+    /**
+     * Determines if this a GCE instance, by accessing the expected metadata
+     * host.
+     * If $httpHandler is not specified a the default HttpHandler is used.
+     *
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return true if this a GCEInstance false otherwise
+     */
+    public static function onGce(callable $httpHandler = null)
+    {
+        if (is_null($httpHandler)) {
+            $httpHandler = HttpHandlerFactory::build();
+        }
+        $checkUri = 'http://' . self::METADATA_IP;
+        try {
+            // Comment from: oauth2client/client.py
+            //
+            // Note: the explicit `timeout` below is a workaround. The underlying
+            // issue is that resolving an unknown host on some networks will take
+            // 20-30 seconds; making this timeout short fixes the issue, but
+            // could lead to false negatives in the event that we are on GCE, but
+            // the metadata resolution was particularly slow. The latter case is
+            // "unlikely".
+            $resp = $httpHandler(
+                new Request('GET', $checkUri),
+                ['timeout' => 0.3]
+            );
+
+            return $resp->getHeaderLine(self::FLAVOR_HEADER) == 'Google';
+        } catch (ClientException $e) {
+            return false;
+        } catch (ServerException $e) {
+            return false;
+        } catch (RequestException $e) {
+            return false;
+        }
+    }
+
+    /**
+     * Implements FetchAuthTokenInterface#fetchAuthToken.
+     *
+     * Fetches the auth tokens from the GCE metadata host if it is available.
+     * If $httpHandler is not specified a the default HttpHandler is used.
+     *
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return array the response
+     *
+     * @throws \Exception
+     */
+    public function fetchAuthToken(callable $httpHandler = null)
+    {
+        if (is_null($httpHandler)) {
+            $httpHandler = HttpHandlerFactory::build();
+        }
+        if (!$this->hasCheckedOnGce) {
+            $this->isOnGce = self::onGce($httpHandler);
+        }
+        if (!$this->isOnGce) {
+            return array();  // return an empty array with no access token
+        }
+        $resp = $httpHandler(
+            new Request(
+                'GET',
+                self::getTokenUri(),
+                [self::FLAVOR_HEADER => 'Google']
+            )
+        );
+        $body = (string)$resp->getBody();
+
+        // Assume it's JSON; if it's not throw an exception
+        if (null === $json = json_decode($body, true)) {
+            throw new \Exception('Invalid JSON response');
+        }
+
+        // store this so we can retrieve it later
+        $this->lastReceivedToken = $json;
+        $this->lastReceivedToken['expires_at'] = time() + $json['expires_in'];
+
+        return $json;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCacheKey()
+    {
+        return self::cacheKey;
+    }
+
+    /**
+     * @return array|null
+     */
+    public function getLastReceivedToken()
+    {
+        if ($this->lastReceivedToken) {
+            return [
+                'access_token' => $this->lastReceivedToken['access_token'],
+                'expires_at' => $this->lastReceivedToken['expires_at'],
+            ];
+        }
+
+        return null;
+    }
+}

vendor/google/auth/src/Credentials/IAMCredentials.php

@@ -0,0 +1,89 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Credentials;
+
+/**
+ * Authenticates requests using IAM credentials.
+ */
+class IAMCredentials
+{
+    const SELECTOR_KEY = 'x-goog-iam-authority-selector';
+    const TOKEN_KEY = 'x-goog-iam-authorization-token';
+
+    /**
+     * @var string
+     */
+    private $selector;
+
+    /**
+     * @var string
+     */
+    private $token;
+
+    /**
+     * @param $selector string the IAM selector
+     * @param $token string the IAM token
+     */
+    public function __construct($selector, $token)
+    {
+        if (!is_string($selector)) {
+            throw new \InvalidArgumentException(
+                'selector must be a string');
+        }
+        if (!is_string($token)) {
+            throw new \InvalidArgumentException(
+                'token must be a string');
+        }
+
+        $this->selector = $selector;
+        $this->token = $token;
+    }
+
+    /**
+     * export a callback function which updates runtime metadata.
+     *
+     * @return array updateMetadata function
+     */
+    public function getUpdateMetadataFunc()
+    {
+        return array($this, 'updateMetadata');
+    }
+
+    /**
+     * Updates metadata with the appropriate header metadata.
+     *
+     * @param array $metadata metadata hashmap
+     * @param string $unusedAuthUri optional auth uri
+     * @param callable $httpHandler callback which delivers psr7 request
+     *        Note: this param is unused here, only included here for
+     *        consistency with other credentials class
+     *
+     * @return array updated metadata hashmap
+     */
+    public function updateMetadata(
+        $metadata,
+        $unusedAuthUri = null,
+        callable $httpHandler = null
+    ) {
+        $metadata_copy = $metadata;
+        $metadata_copy[self::SELECTOR_KEY] = $this->selector;
+        $metadata_copy[self::TOKEN_KEY] = $this->token;
+
+        return $metadata_copy;
+    }
+}

vendor/google/auth/src/Credentials/ServiceAccountCredentials.php

@@ -0,0 +1,177 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Credentials;
+
+use Google\Auth\CredentialsLoader;
+use Google\Auth\OAuth2;
+
+/**
+ * ServiceAccountCredentials supports authorization using a Google service
+ * account.
+ *
+ * (cf https://developers.google.com/accounts/docs/OAuth2ServiceAccount)
+ *
+ * It's initialized using the json key file that's downloadable from developer
+ * console, which should contain a private_key and client_email fields that it
+ * uses.
+ *
+ * Use it with AuthTokenMiddleware to authorize http requests:
+ *
+ *   use Google\Auth\Credentials\ServiceAccountCredentials;
+ *   use Google\Auth\Middleware\AuthTokenMiddleware;
+ *   use GuzzleHttp\Client;
+ *   use GuzzleHttp\HandlerStack;
+ *
+ *   $sa = new ServiceAccountCredentials(
+ *       'https://www.googleapis.com/auth/taskqueue',
+ *       '/path/to/your/json/key_file.json'
+ *   );
+ *   $middleware = new AuthTokenMiddleware($sa);
+ *   $stack = HandlerStack::create();
+ *   $stack->push($middleware);
+ *
+ *   $client = new Client([
+ *       'handler' => $stack,
+ *       'base_uri' => 'https://www.googleapis.com/taskqueue/v1beta2/projects/',
+ *       'auth' => 'google_auth' // authorize all requests
+ *   ]);
+ *
+ *   $res = $client->get('myproject/taskqueues/myqueue');
+ */
+class ServiceAccountCredentials extends CredentialsLoader
+{
+    /**
+     * The OAuth2 instance used to conduct authorization.
+     *
+     * @var OAuth2
+     */
+    protected $auth;
+
+    /**
+     * Create a new ServiceAccountCredentials.
+     *
+     * @param string|array $scope the scope of the access request, expressed
+     *   either as an Array or as a space-delimited String.
+     * @param string|array $jsonKey JSON credential file path or JSON credentials
+     *   as an associative array
+     * @param string $sub an email address account to impersonate, in situations when
+     *   the service account has been delegated domain wide access.
+     */
+    public function __construct(
+        $scope,
+        $jsonKey,
+        $sub = null
+    ) {
+        if (is_string($jsonKey)) {
+            if (!file_exists($jsonKey)) {
+                throw new \InvalidArgumentException('file does not exist');
+            }
+            $jsonKeyStream = file_get_contents($jsonKey);
+            if (!$jsonKey = json_decode($jsonKeyStream, true)) {
+                throw new \LogicException('invalid json for auth config');
+            }
+        }
+        if (!array_key_exists('client_email', $jsonKey)) {
+            throw new \InvalidArgumentException(
+                'json key is missing the client_email field');
+        }
+        if (!array_key_exists('private_key', $jsonKey)) {
+            throw new \InvalidArgumentException(
+                'json key is missing the private_key field');
+        }
+        $this->auth = new OAuth2([
+            'audience' => self::TOKEN_CREDENTIAL_URI,
+            'issuer' => $jsonKey['client_email'],
+            'scope' => $scope,
+            'signingAlgorithm' => 'RS256',
+            'signingKey' => $jsonKey['private_key'],
+            'sub' => $sub,
+            'tokenCredentialUri' => self::TOKEN_CREDENTIAL_URI,
+        ]);
+    }
+
+    /**
+     * @param callable $httpHandler
+     *
+     * @return array
+     */
+    public function fetchAuthToken(callable $httpHandler = null)
+    {
+        return $this->auth->fetchAuthToken($httpHandler);
+    }
+
+    /**
+     * @return string
+     */
+    public function getCacheKey()
+    {
+        $key = $this->auth->getIssuer() . ':' . $this->auth->getCacheKey();
+        if ($sub = $this->auth->getSub()) {
+            $key .= ':' . $sub;
+        }
+
+        return $key;
+    }
+
+    /**
+     * @return array
+     */
+    public function getLastReceivedToken()
+    {
+        return $this->auth->getLastReceivedToken();
+    }
+
+    /**
+     * Updates metadata with the authorization token.
+     *
+     * @param array $metadata metadata hashmap
+     * @param string $authUri optional auth uri
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return array updated metadata hashmap
+     */
+    public function updateMetadata(
+        $metadata,
+        $authUri = null,
+        callable $httpHandler = null
+    ) {
+        // scope exists. use oauth implementation
+        $scope = $this->auth->getScope();
+        if (!is_null($scope)) {
+            return parent::updateMetadata($metadata, $authUri, $httpHandler);
+        }
+
+        // no scope found. create jwt with the auth uri
+        $credJson = array(
+            'private_key' => $this->auth->getSigningKey(),
+            'client_email' => $this->auth->getIssuer(),
+        );
+        $jwtCreds = new ServiceAccountJwtAccessCredentials($credJson);
+
+        return $jwtCreds->updateMetadata($metadata, $authUri, $httpHandler);
+    }
+
+    /**
+     * @param string $sub an email address account to impersonate, in situations when
+     *   the service account has been delegated domain wide access.
+     */
+    public function setSub($sub)
+    {
+        $this->auth->setSub($sub);
+    }
+}

vendor/google/auth/src/Credentials/ServiceAccountJwtAccessCredentials.php

@@ -0,0 +1,131 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Credentials;
+
+use Google\Auth\CredentialsLoader;
+use Google\Auth\OAuth2;
+
+/**
+ * Authenticates requests using Google's Service Account credentials via
+ * JWT Access.
+ *
+ * This class allows authorizing requests for service accounts directly
+ * from credentials from a json key file downloaded from the developer
+ * console (via 'Generate new Json Key').  It is not part of any OAuth2
+ * flow, rather it creates a JWT and sends that as a credential.
+ */
+class ServiceAccountJwtAccessCredentials extends CredentialsLoader
+{
+    /**
+     * The OAuth2 instance used to conduct authorization.
+     *
+     * @var OAuth2
+     */
+    protected $auth;
+
+    /**
+     * Create a new ServiceAccountJwtAccessCredentials.
+     *
+     * @param string|array $jsonKey JSON credential file path or JSON credentials
+     *   as an associative array
+     */
+    public function __construct($jsonKey)
+    {
+        if (is_string($jsonKey)) {
+            if (!file_exists($jsonKey)) {
+                throw new \InvalidArgumentException('file does not exist');
+            }
+            $jsonKeyStream = file_get_contents($jsonKey);
+            if (!$jsonKey = json_decode($jsonKeyStream, true)) {
+                throw new \LogicException('invalid json for auth config');
+            }
+        }
+        if (!array_key_exists('client_email', $jsonKey)) {
+            throw new \InvalidArgumentException(
+                'json key is missing the client_email field');
+        }
+        if (!array_key_exists('private_key', $jsonKey)) {
+            throw new \InvalidArgumentException(
+                'json key is missing the private_key field');
+        }
+        $this->auth = new OAuth2([
+            'issuer' => $jsonKey['client_email'],
+            'sub' => $jsonKey['client_email'],
+            'signingAlgorithm' => 'RS256',
+            'signingKey' => $jsonKey['private_key'],
+        ]);
+    }
+
+    /**
+     * Updates metadata with the authorization token.
+     *
+     * @param array $metadata metadata hashmap
+     * @param string $authUri optional auth uri
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return array updated metadata hashmap
+     */
+    public function updateMetadata(
+        $metadata,
+        $authUri = null,
+        callable $httpHandler = null
+    ) {
+        if (empty($authUri)) {
+            return $metadata;
+        }
+
+        $this->auth->setAudience($authUri);
+
+        return parent::updateMetadata($metadata, $authUri, $httpHandler);
+    }
+
+    /**
+     * Implements FetchAuthTokenInterface#fetchAuthToken.
+     *
+     * @param callable $httpHandler
+     *
+     * @return array|void
+     */
+    public function fetchAuthToken(callable $httpHandler = null)
+    {
+        $audience = $this->auth->getAudience();
+        if (empty($audience)) {
+            return null;
+        }
+
+        $access_token = $this->auth->toJwt();
+
+        return array('access_token' => $access_token);
+    }
+
+    /**
+     * @return string
+     */
+    public function getCacheKey()
+    {
+        return $this->auth->getCacheKey();
+    }
+
+    /**
+     * @return array
+     */
+    public function getLastReceivedToken()
+    {
+        return $this->auth->getLastReceivedToken();
+    }
+}

vendor/google/auth/src/Credentials/UserRefreshCredentials.php

@@ -0,0 +1,110 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Credentials;
+
+use Google\Auth\CredentialsLoader;
+use Google\Auth\OAuth2;
+
+/**
+ * Authenticates requests using User Refresh credentials.
+ *
+ * This class allows authorizing requests from user refresh tokens.
+ *
+ * This the end of the result of a 3LO flow.  E.g, the end result of
+ * 'gcloud auth login' saves a file with these contents in well known
+ * location
+ *
+ * @see [Application Default Credentials](http://goo.gl/mkAHpZ)
+ */
+class UserRefreshCredentials extends CredentialsLoader
+{
+    /**
+     * The OAuth2 instance used to conduct authorization.
+     *
+     * @var OAuth2
+     */
+    protected $auth;
+
+    /**
+     * Create a new UserRefreshCredentials.
+     *
+     * @param string|array $scope the scope of the access request, expressed
+     *   either as an Array or as a space-delimited String.
+     * @param string|array $jsonKey JSON credential file path or JSON credentials
+     *   as an associative array
+     */
+    public function __construct(
+        $scope,
+        $jsonKey
+    ) {
+        if (is_string($jsonKey)) {
+            if (!file_exists($jsonKey)) {
+                throw new \InvalidArgumentException('file does not exist');
+            }
+            $jsonKeyStream = file_get_contents($jsonKey);
+            if (!$jsonKey = json_decode($jsonKeyStream, true)) {
+                throw new \LogicException('invalid json for auth config');
+            }
+        }
+        if (!array_key_exists('client_id', $jsonKey)) {
+            throw new \InvalidArgumentException(
+                'json key is missing the client_id field');
+        }
+        if (!array_key_exists('client_secret', $jsonKey)) {
+            throw new \InvalidArgumentException(
+                'json key is missing the client_secret field');
+        }
+        if (!array_key_exists('refresh_token', $jsonKey)) {
+            throw new \InvalidArgumentException(
+                'json key is missing the refresh_token field');
+        }
+        $this->auth = new OAuth2([
+            'clientId' => $jsonKey['client_id'],
+            'clientSecret' => $jsonKey['client_secret'],
+            'refresh_token' => $jsonKey['refresh_token'],
+            'scope' => $scope,
+            'tokenCredentialUri' => self::TOKEN_CREDENTIAL_URI,
+        ]);
+    }
+
+    /**
+     * @param callable $httpHandler
+     *
+     * @return array
+     */
+    public function fetchAuthToken(callable $httpHandler = null)
+    {
+        return $this->auth->fetchAuthToken($httpHandler);
+    }
+
+    /**
+     * @return string
+     */
+    public function getCacheKey()
+    {
+        return $this->auth->getClientId() . ':' . $this->auth->getCacheKey();
+    }
+
+    /**
+     * @return array
+     */
+    public function getLastReceivedToken()
+    {
+        return $this->auth->getLastReceivedToken();
+    }
+}

vendor/google/auth/src/CredentialsLoader.php

@@ -0,0 +1,163 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth;
+
+use Google\Auth\Credentials\ServiceAccountCredentials;
+use Google\Auth\Credentials\UserRefreshCredentials;
+
+/**
+ * CredentialsLoader contains the behaviour used to locate and find default
+ * credentials files on the file system.
+ */
+abstract class CredentialsLoader implements FetchAuthTokenInterface
+{
+    const TOKEN_CREDENTIAL_URI = 'https://www.googleapis.com/oauth2/v4/token';
+    const ENV_VAR = 'GOOGLE_APPLICATION_CREDENTIALS';
+    const WELL_KNOWN_PATH = 'gcloud/application_default_credentials.json';
+    const NON_WINDOWS_WELL_KNOWN_PATH_BASE = '.config';
+    const AUTH_METADATA_KEY = 'Authorization';
+
+    /**
+     * @param string $cause
+     * @return string
+     */
+    private static function unableToReadEnv($cause)
+    {
+        $msg = 'Unable to read the credential file specified by ';
+        $msg .= ' GOOGLE_APPLICATION_CREDENTIALS: ';
+        $msg .= $cause;
+
+        return $msg;
+    }
+
+    /**
+     * @return bool
+     */
+    private static function isOnWindows()
+    {
+        return strtoupper(substr(PHP_OS, 0, 3)) === 'WIN';
+    }
+
+    /**
+     * Load a JSON key from the path specified in the environment.
+     *
+     * Load a JSON key from the path specified in the environment
+     * variable GOOGLE_APPLICATION_CREDENTIALS. Return null if
+     * GOOGLE_APPLICATION_CREDENTIALS is not specified.
+     *
+     * @return array JSON key | null
+     */
+    public static function fromEnv()
+    {
+        $path = getenv(self::ENV_VAR);
+        if (empty($path)) {
+            return;
+        }
+        if (!file_exists($path)) {
+            $cause = 'file ' . $path . ' does not exist';
+            throw new \DomainException(self::unableToReadEnv($cause));
+        }
+        $jsonKey = file_get_contents($path);
+        return json_decode($jsonKey, true);
+    }
+
+    /**
+     * Load a JSON key from a well known path.
+     *
+     * The well known path is OS dependent:
+     * - windows: %APPDATA%/gcloud/application_default_credentials.json
+     * - others: $HOME/.config/gcloud/application_default_credentials.json
+     *
+     * If the file does not exists, this returns null.
+     *
+     * @return array JSON key | null
+     */
+    public static function fromWellKnownFile()
+    {
+        $rootEnv = self::isOnWindows() ? 'APPDATA' : 'HOME';
+        $path = [getenv($rootEnv)];
+        if (!self::isOnWindows()) {
+            $path[] = self::NON_WINDOWS_WELL_KNOWN_PATH_BASE;
+        }
+        $path[] = self::WELL_KNOWN_PATH;
+        $path = implode(DIRECTORY_SEPARATOR, $path);
+        if (!file_exists($path)) {
+            return;
+        }
+        $jsonKey = file_get_contents($path);
+        return json_decode($jsonKey, true);
+    }
+
+    /**
+     * Create a new Credentials instance.
+     *
+     * @param string|array scope the scope of the access request, expressed
+     *   either as an Array or as a space-delimited String.
+     * @param array $jsonKey the JSON credentials.
+     *
+     * @return ServiceAccountCredentials|UserRefreshCredentials
+     */
+    public static function makeCredentials($scope, array $jsonKey)
+    {
+        if (!array_key_exists('type', $jsonKey)) {
+            throw new \InvalidArgumentException('json key is missing the type field');
+        }
+
+        if ($jsonKey['type'] == 'service_account') {
+            return new ServiceAccountCredentials($scope, $jsonKey);
+        } elseif ($jsonKey['type'] == 'authorized_user') {
+            return new UserRefreshCredentials($scope, $jsonKey);
+        } else {
+            throw new \InvalidArgumentException('invalid value in the type field');
+        }
+    }
+
+    /**
+     * export a callback function which updates runtime metadata.
+     *
+     * @return array updateMetadata function
+     */
+    public function getUpdateMetadataFunc()
+    {
+        return array($this, 'updateMetadata');
+    }
+
+    /**
+     * Updates metadata with the authorization token.
+     *
+     * @param array $metadata metadata hashmap
+     * @param string $authUri optional auth uri
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return array updated metadata hashmap
+     */
+    public function updateMetadata(
+        $metadata,
+        $authUri = null,
+        callable $httpHandler = null
+    ) {
+        $result = $this->fetchAuthToken($httpHandler);
+        if (!isset($result['access_token'])) {
+            return $metadata;
+        }
+        $metadata_copy = $metadata;
+        $metadata_copy[self::AUTH_METADATA_KEY] = array('Bearer ' . $result['access_token']);
+
+        return $metadata_copy;
+    }
+}

vendor/google/auth/src/FetchAuthTokenCache.php

@@ -0,0 +1,108 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth;
+
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+ * A class to implement caching for any object implementing
+ * FetchAuthTokenInterface
+ */
+class FetchAuthTokenCache implements FetchAuthTokenInterface
+{
+    use CacheTrait;
+
+    /**
+     * @var FetchAuthTokenInterface
+     */
+    private $fetcher;
+
+    /**
+     * @var array
+     */
+    private $cacheConfig;
+
+    /**
+     * @var CacheItemPoolInterface
+     */
+    private $cache;
+
+    public function __construct(
+        FetchAuthTokenInterface $fetcher,
+        array $cacheConfig = null,
+        CacheItemPoolInterface $cache
+    ) {
+        $this->fetcher = $fetcher;
+        $this->cache = $cache;
+        $this->cacheConfig = array_merge([
+            'lifetime' => 1500,
+            'prefix' => '',
+        ], (array) $cacheConfig);
+    }
+
+    /**
+     * Implements FetchAuthTokenInterface#fetchAuthToken.
+     *
+     * Checks the cache for a valid auth token and fetches the auth tokens
+     * from the supplied fetcher.
+     *
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return array the response
+     *
+     * @throws \Exception
+     */
+    public function fetchAuthToken(callable $httpHandler = null)
+    {
+        // Use the cached value if its available.
+        //
+        // TODO: correct caching; update the call to setCachedValue to set the expiry
+        // to the value returned with the auth token.
+        //
+        // TODO: correct caching; enable the cache to be cleared.
+        $cacheKey = $this->fetcher->getCacheKey();
+        $cached = $this->getCachedValue($cacheKey);
+        if (!empty($cached)) {
+            return ['access_token' => $cached];
+        }
+
+        $auth_token = $this->fetcher->fetchAuthToken($httpHandler);
+
+        if (isset($auth_token['access_token'])) {
+            $this->setCachedValue($cacheKey, $auth_token['access_token']);
+        }
+
+        return $auth_token;
+    }
+
+    /**
+     * @return string
+     */
+    public function getCacheKey()
+    {
+        return $this->getFullCacheKey($this->fetcher->getCacheKey());
+    }
+
+    /**
+     * @return array|null
+     */
+    public function getLastReceivedToken()
+    {
+        return $this->fetcher->getLastReceivedToken();
+    }
+}

vendor/google/auth/src/FetchAuthTokenInterface.php

@@ -0,0 +1,55 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth;
+
+/**
+ * An interface implemented by objects that can fetch auth tokens.
+ */
+interface FetchAuthTokenInterface
+{
+    /**
+     * Fetches the auth tokens based on the current state.
+     *
+     * @param callable $httpHandler callback which delivers psr7 request
+     *
+     * @return array a hash of auth tokens
+     */
+    public function fetchAuthToken(callable $httpHandler = null);
+
+    /**
+     * Obtains a key that can used to cache the results of #fetchAuthToken.
+     *
+     * If the value is empty, the auth token is not cached.
+     *
+     * @return string a key that may be used to cache the auth token.
+     */
+    public function getCacheKey();
+
+    /**
+     * Returns an associative array with the token and
+     * expiration time.
+     *
+     * @return null|array {
+     *      The last received access token.
+     *
+     * @var string $access_token The access token string.
+     * @var int $expires_at The time the token expires as a UNIX timestamp.
+     * }
+     */
+    public function getLastReceivedToken();
+}

vendor/google/auth/src/HttpHandler/Guzzle5HttpHandler.php

@@ -0,0 +1,68 @@
+<?php
+/**
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+namespace Google\Auth\HttpHandler;
+
+use GuzzleHttp\ClientInterface;
+use GuzzleHttp\Psr7\Response;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+class Guzzle5HttpHandler
+{
+    /**
+     * @var ClientInterface
+     */
+    private $client;
+
+    /**
+     * @param ClientInterface $client
+     */
+    public function __construct(ClientInterface $client)
+    {
+        $this->client = $client;
+    }
+
+    /**
+     * Accepts a PSR-7 Request and an array of options and returns a PSR-7 response.
+     *
+     * @param RequestInterface $request
+     * @param array $options
+     *
+     * @return ResponseInterface
+     */
+    public function __invoke(RequestInterface $request, array $options = [])
+    {
+        $request = $this->client->createRequest(
+            $request->getMethod(),
+            $request->getUri(),
+            array_merge([
+                'headers' => $request->getHeaders(),
+                'body' => $request->getBody(),
+            ], $options)
+        );
+
+        $response = $this->client->send($request);
+
+        return new Response(
+            $response->getStatusCode(),
+            $response->getHeaders() ?: [],
+            $response->getBody(),
+            $response->getProtocolVersion(),
+            $response->getReasonPhrase()
+        );
+    }
+}

vendor/google/auth/src/HttpHandler/Guzzle6HttpHandler.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace Google\Auth\HttpHandler;
+
+use GuzzleHttp\ClientInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+class Guzzle6HttpHandler
+{
+    /**
+     * @var ClientInterface
+     */
+    private $client;
+
+    /**
+     * @param ClientInterface $client
+     */
+    public function __construct(ClientInterface $client)
+    {
+        $this->client = $client;
+    }
+
+    /**
+     * Accepts a PSR-7 request and an array of options and returns a PSR-7 response.
+     *
+     * @param RequestInterface $request
+     * @param array $options
+     *
+     * @return ResponseInterface
+     */
+    public function __invoke(RequestInterface $request, array $options = [])
+    {
+        return $this->client->send($request, $options);
+    }
+}

vendor/google/auth/src/HttpHandler/HttpHandlerFactory.php

@@ -0,0 +1,47 @@
+<?php
+/**
+ * Copyright 2015 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+namespace Google\Auth\HttpHandler;
+
+use GuzzleHttp\Client;
+use GuzzleHttp\ClientInterface;
+
+class HttpHandlerFactory
+{
+    /**
+     * Builds out a default http handler for the installed version of guzzle.
+     *
+     * @param ClientInterface $client
+     *
+     * @return Guzzle5HttpHandler|Guzzle6HttpHandler
+     *
+     * @throws \Exception
+     */
+    public static function build(ClientInterface $client = null)
+    {
+        $version = ClientInterface::VERSION;
+        $client = $client ?: new Client();
+
+        switch ($version[0]) {
+            case '5':
+                return new Guzzle5HttpHandler($client);
+            case '6':
+                return new Guzzle6HttpHandler($client);
+            default:
+                throw new \Exception('Version not supported');
+        }
+    }
+}

vendor/google/auth/src/Middleware/AuthTokenMiddleware.php

@@ -0,0 +1,126 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Middleware;
+
+use Google\Auth\FetchAuthTokenInterface;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * AuthTokenMiddleware is a Guzzle Middleware that adds an Authorization header
+ * provided by an object implementing FetchAuthTokenInterface.
+ *
+ * The FetchAuthTokenInterface#fetchAuthToken is used to obtain a hash; one of
+ * the values value in that hash is added as the authorization header.
+ *
+ * Requests will be accessed with the authorization header:
+ *
+ * 'Authorization' 'Bearer <value of auth_token>'
+ */
+class AuthTokenMiddleware
+{
+    /**
+     * @var callback
+     */
+    private $httpHandler;
+
+    /**
+     * @var FetchAuthTokenInterface
+     */
+    private $fetcher;
+
+    /**
+     * @var callable
+     */
+    private $tokenCallback;
+
+    /**
+     * Creates a new AuthTokenMiddleware.
+     *
+     * @param FetchAuthTokenInterface $fetcher is used to fetch the auth token
+     * @param callable $httpHandler (optional) callback which delivers psr7 request
+     * @param callable $tokenCallback (optional) function to be called when a new token is fetched.
+     */
+    public function __construct(
+        FetchAuthTokenInterface $fetcher,
+        callable $httpHandler = null,
+        callable $tokenCallback = null
+    ) {
+        $this->fetcher = $fetcher;
+        $this->httpHandler = $httpHandler;
+        $this->tokenCallback = $tokenCallback;
+    }
+
+    /**
+     * Updates the request with an Authorization header when auth is 'google_auth'.
+     *
+     *   use Google\Auth\Middleware\AuthTokenMiddleware;
+     *   use Google\Auth\OAuth2;
+     *   use GuzzleHttp\Client;
+     *   use GuzzleHttp\HandlerStack;
+     *
+     *   $config = [..<oauth config param>.];
+     *   $oauth2 = new OAuth2($config)
+     *   $middleware = new AuthTokenMiddleware($oauth2);
+     *   $stack = HandlerStack::create();
+     *   $stack->push($middleware);
+     *
+     *   $client = new Client([
+     *       'handler' => $stack,
+     *       'base_uri' => 'https://www.googleapis.com/taskqueue/v1beta2/projects/',
+     *       'auth' => 'google_auth' // authorize all requests
+     *   ]);
+     *
+     *   $res = $client->get('myproject/taskqueues/myqueue');
+     *
+     * @param callable $handler
+     *
+     * @return \Closure
+     */
+    public function __invoke(callable $handler)
+    {
+        return function (RequestInterface $request, array $options) use ($handler) {
+            // Requests using "auth"="google_auth" will be authorized.
+            if (!isset($options['auth']) || $options['auth'] !== 'google_auth') {
+                return $handler($request, $options);
+            }
+
+            $request = $request->withHeader('Authorization', 'Bearer ' . $this->fetchToken());
+
+            return $handler($request, $options);
+        };
+    }
+
+    /**
+     * Call fetcher to fetch the token.
+     *
+     * @return string
+     */
+    private function fetchToken()
+    {
+        $auth_tokens = $this->fetcher->fetchAuthToken($this->httpHandler);
+
+        if (array_key_exists('access_token', $auth_tokens)) {
+            // notify the callback if applicable
+            if ($this->tokenCallback) {
+                call_user_func($this->tokenCallback, $this->fetcher->getCacheKey(), $auth_tokens['access_token']);
+            }
+
+            return $auth_tokens['access_token'];
+        }
+    }
+}

vendor/google/auth/src/Middleware/ScopedAccessTokenMiddleware.php

@@ -0,0 +1,175 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Middleware;
+
+use Google\Auth\CacheTrait;
+use Psr\Cache\CacheItemPoolInterface;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * ScopedAccessTokenMiddleware is a Guzzle Middleware that adds an Authorization
+ * header provided by a closure.
+ *
+ * The closure returns an access token, taking the scope, either a single
+ * string or an array of strings, as its value.  If provided, a cache will be
+ * used to preserve the access token for a given lifetime.
+ *
+ * Requests will be accessed with the authorization header:
+ *
+ * 'Authorization' 'Bearer <value of auth_token>'
+ */
+class ScopedAccessTokenMiddleware
+{
+    use CacheTrait;
+
+    const DEFAULT_CACHE_LIFETIME = 1500;
+
+    /**
+     * @var CacheItemPoolInterface
+     */
+    private $cache;
+
+    /**
+     * @var array configuration
+     */
+    private $cacheConfig;
+
+    /**
+     * @var callable
+     */
+    private $tokenFunc;
+
+    /**
+     * @var array|string
+     */
+    private $scopes;
+
+    /**
+     * Creates a new ScopedAccessTokenMiddleware.
+     *
+     * @param callable $tokenFunc a token generator function
+     * @param array|string $scopes the token authentication scopes
+     * @param array $cacheConfig configuration for the cache when it's present
+     * @param CacheItemPoolInterface $cache an implementation of CacheItemPoolInterface
+     */
+    public function __construct(
+        callable $tokenFunc,
+        $scopes,
+        array $cacheConfig = null,
+        CacheItemPoolInterface $cache = null
+    ) {
+        $this->tokenFunc = $tokenFunc;
+        if (!(is_string($scopes) || is_array($scopes))) {
+            throw new \InvalidArgumentException(
+                'wants scope should be string or array');
+        }
+        $this->scopes = $scopes;
+
+        if (!is_null($cache)) {
+            $this->cache = $cache;
+            $this->cacheConfig = array_merge([
+                'lifetime' => self::DEFAULT_CACHE_LIFETIME,
+                'prefix' => '',
+            ], $cacheConfig);
+        }
+    }
+
+    /**
+     * Updates the request with an Authorization header when auth is 'scoped'.
+     *
+     *   E.g this could be used to authenticate using the AppEngine
+     *   AppIdentityService.
+     *
+     *   use google\appengine\api\app_identity\AppIdentityService;
+     *   use Google\Auth\Middleware\ScopedAccessTokenMiddleware;
+     *   use GuzzleHttp\Client;
+     *   use GuzzleHttp\HandlerStack;
+     *
+     *   $scope = 'https://www.googleapis.com/auth/taskqueue'
+     *   $middleware = new ScopedAccessTokenMiddleware(
+     *       'AppIdentityService::getAccessToken',
+     *       $scope,
+     *       [ 'prefix' => 'Google\Auth\ScopedAccessToken::' ],
+     *       $cache = new Memcache()
+     *   );
+     *   $stack = HandlerStack::create();
+     *   $stack->push($middleware);
+     *
+     *   $client = new Client([
+     *       'handler' => $stack,
+     *       'base_url' => 'https://www.googleapis.com/taskqueue/v1beta2/projects/',
+     *       'auth' => 'google_auth' // authorize all requests
+     *   ]);
+     *
+     *   $res = $client->get('myproject/taskqueues/myqueue');
+     *
+     * @param callable $handler
+     *
+     * @return \Closure
+     */
+    public function __invoke(callable $handler)
+    {
+        return function (RequestInterface $request, array $options) use ($handler) {
+            // Requests using "auth"="scoped" will be authorized.
+            if (!isset($options['auth']) || $options['auth'] !== 'scoped') {
+                return $handler($request, $options);
+            }
+
+            $request = $request->withHeader('Authorization', 'Bearer ' . $this->fetchToken());
+
+            return $handler($request, $options);
+        };
+    }
+
+    /**
+     * @return string
+     */
+    private function getCacheKey()
+    {
+        $key = null;
+
+        if (is_string($this->scopes)) {
+            $key .= $this->scopes;
+        } elseif (is_array($this->scopes)) {
+            $key .= implode(':', $this->scopes);
+        }
+
+        return $key;
+    }
+
+    /**
+     * Determine if token is available in the cache, if not call tokenFunc to
+     * fetch it.
+     *
+     * @return string
+     */
+    private function fetchToken()
+    {
+        $cacheKey = $this->getCacheKey();
+        $cached = $this->getCachedValue($cacheKey);
+
+        if (!empty($cached)) {
+            return $cached;
+        }
+
+        $token = call_user_func($this->tokenFunc, $this->scopes);
+        $this->setCachedValue($cacheKey, $token);
+
+        return $token;
+    }
+}

vendor/google/auth/src/Middleware/SimpleMiddleware.php

@@ -0,0 +1,93 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Middleware;
+
+use GuzzleHttp\Psr7;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * SimpleMiddleware is a Guzzle Middleware that implements Google's Simple API
+ * access.
+ *
+ * Requests are accessed using the Simple API access developer key.
+ */
+class SimpleMiddleware
+{
+    /**
+     * @var array
+     */
+    private $config;
+
+    /**
+     * Create a new Simple plugin.
+     *
+     * The configuration array expects one option
+     * - key: required, otherwise InvalidArgumentException is thrown
+     *
+     * @param array $config Configuration array
+     */
+    public function __construct(array $config)
+    {
+        if (!isset($config['key'])) {
+            throw new \InvalidArgumentException('requires a key to have been set');
+        }
+
+        $this->config = array_merge(['key' => null], $config);
+    }
+
+    /**
+     * Updates the request query with the developer key if auth is set to simple.
+     *
+     *   use Google\Auth\Middleware\SimpleMiddleware;
+     *   use GuzzleHttp\Client;
+     *   use GuzzleHttp\HandlerStack;
+     *
+     *   $my_key = 'is not the same as yours';
+     *   $middleware = new SimpleMiddleware(['key' => $my_key]);
+     *   $stack = HandlerStack::create();
+     *   $stack->push($middleware);
+     *
+     *   $client = new Client([
+     *       'handler' => $stack,
+     *       'base_uri' => 'https://www.googleapis.com/discovery/v1/',
+     *       'auth' => 'simple'
+     *   ]);
+     *
+     *   $res = $client->get('drive/v2/rest');
+     *
+     * @param callable $handler
+     *
+     * @return \Closure
+     */
+    public function __invoke(callable $handler)
+    {
+        return function (RequestInterface $request, array $options) use ($handler) {
+            // Requests using "auth"="scoped" will be authorized.
+            if (!isset($options['auth']) || $options['auth'] !== 'simple') {
+                return $handler($request, $options);
+            }
+
+            $query = Psr7\parse_query($request->getUri()->getQuery());
+            $params = array_merge($query, $this->config);
+            $uri = $request->getUri()->withQuery(Psr7\build_query($params));
+            $request = $request->withUri($uri);
+
+            return $handler($request, $options);
+        };
+    }
+}

vendor/google/auth/src/Subscriber/AuthTokenSubscriber.php

@@ -0,0 +1,118 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Subscriber;
+
+use Google\Auth\FetchAuthTokenInterface;
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Event\RequestEvents;
+use GuzzleHttp\Event\SubscriberInterface;
+
+/**
+ * AuthTokenSubscriber is a Guzzle Subscriber that adds an Authorization header
+ * provided by an object implementing FetchAuthTokenInterface.
+ *
+ * The FetchAuthTokenInterface#fetchAuthToken is used to obtain a hash; one of
+ * the values value in that hash is added as the authorization header.
+ *
+ * Requests will be accessed with the authorization header:
+ *
+ * 'Authorization' 'Bearer <value of auth_token>'
+ */
+class AuthTokenSubscriber implements SubscriberInterface
+{
+    /**
+     * @var callable
+     */
+    private $httpHandler;
+
+    /**
+     * @var FetchAuthTokenInterface
+     */
+    private $fetcher;
+
+    /**
+     * @var callable
+     */
+    private $tokenCallback;
+
+    /**
+     * Creates a new AuthTokenSubscriber.
+     *
+     * @param FetchAuthTokenInterface $fetcher is used to fetch the auth token
+     * @param callable $httpHandler (optional) http client to fetch the token.
+     * @param callable $tokenCallback (optional) function to be called when a new token is fetched.
+     */
+    public function __construct(
+        FetchAuthTokenInterface $fetcher,
+        callable $httpHandler = null,
+        callable $tokenCallback = null
+    ) {
+        $this->fetcher = $fetcher;
+        $this->httpHandler = $httpHandler;
+        $this->tokenCallback = $tokenCallback;
+    }
+
+    /**
+     * @return array
+     */
+    public function getEvents()
+    {
+        return ['before' => ['onBefore', RequestEvents::SIGN_REQUEST]];
+    }
+
+    /**
+     * Updates the request with an Authorization header when auth is 'fetched_auth_token'.
+     *
+     *   use GuzzleHttp\Client;
+     *   use Google\Auth\OAuth2;
+     *   use Google\Auth\Subscriber\AuthTokenSubscriber;
+     *
+     *   $config = [..<oauth config param>.];
+     *   $oauth2 = new OAuth2($config)
+     *   $subscriber = new AuthTokenSubscriber($oauth2);
+     *
+     *   $client = new Client([
+     *      'base_url' => 'https://www.googleapis.com/taskqueue/v1beta2/projects/',
+     *      'defaults' => ['auth' => 'google_auth']
+     *   ]);
+     *   $client->getEmitter()->attach($subscriber);
+     *
+     *   $res = $client->get('myproject/taskqueues/myqueue');
+     *
+     * @param BeforeEvent $event
+     */
+    public function onBefore(BeforeEvent $event)
+    {
+        // Requests using "auth"="google_auth" will be authorized.
+        $request = $event->getRequest();
+        if ($request->getConfig()['auth'] != 'google_auth') {
+            return;
+        }
+
+        // Fetch the auth token.
+        $auth_tokens = $this->fetcher->fetchAuthToken($this->httpHandler);
+        if (array_key_exists('access_token', $auth_tokens)) {
+            $request->setHeader('Authorization', 'Bearer ' . $auth_tokens['access_token']);
+
+            // notify the callback if applicable
+            if ($this->tokenCallback) {
+                call_user_func($this->tokenCallback, $this->fetcher->getCacheKey(), $auth_tokens['access_token']);
+            }
+        }
+    }
+}

vendor/google/auth/src/Subscriber/ScopedAccessTokenSubscriber.php

@@ -0,0 +1,177 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Subscriber;
+
+use Google\Auth\CacheTrait;
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Event\RequestEvents;
+use GuzzleHttp\Event\SubscriberInterface;
+use Psr\Cache\CacheItemPoolInterface;
+
+/**
+ * ScopedAccessTokenSubscriber is a Guzzle Subscriber that adds an Authorization
+ * header provided by a closure.
+ *
+ * The closure returns an access token, taking the scope, either a single
+ * string or an array of strings, as its value.  If provided, a cache will be
+ * used to preserve the access token for a given lifetime.
+ *
+ * Requests will be accessed with the authorization header:
+ *
+ * 'Authorization' 'Bearer <access token obtained from the closure>'
+ */
+class ScopedAccessTokenSubscriber implements SubscriberInterface
+{
+    use CacheTrait;
+
+    const DEFAULT_CACHE_LIFETIME = 1500;
+
+    /**
+     * @var CacheItemPoolInterface
+     */
+    private $cache;
+
+    /**
+     * @var callable The access token generator function
+     */
+    private $tokenFunc;
+
+    /**
+     * @var array|string The scopes used to generate the token
+     */
+    private $scopes;
+
+    /**
+     * @var array
+     */
+    private $cacheConfig;
+
+    /**
+     * Creates a new ScopedAccessTokenSubscriber.
+     *
+     * @param callable $tokenFunc a token generator function
+     * @param array|string $scopes the token authentication scopes
+     * @param array $cacheConfig configuration for the cache when it's present
+     * @param CacheItemPoolInterface $cache an implementation of CacheItemPoolInterface
+     */
+    public function __construct(
+        callable $tokenFunc,
+        $scopes,
+        array $cacheConfig = null,
+        CacheItemPoolInterface $cache = null
+    ) {
+        $this->tokenFunc = $tokenFunc;
+        if (!(is_string($scopes) || is_array($scopes))) {
+            throw new \InvalidArgumentException(
+                'wants scope should be string or array');
+        }
+        $this->scopes = $scopes;
+
+        if (!is_null($cache)) {
+            $this->cache = $cache;
+            $this->cacheConfig = array_merge([
+                'lifetime' => self::DEFAULT_CACHE_LIFETIME,
+                'prefix' => '',
+            ], $cacheConfig);
+        }
+    }
+
+    /**
+     * @return array
+     */
+    public function getEvents()
+    {
+        return ['before' => ['onBefore', RequestEvents::SIGN_REQUEST]];
+    }
+
+    /**
+     * Updates the request with an Authorization header when auth is 'scoped'.
+     *
+     *   E.g this could be used to authenticate using the AppEngine
+     *   AppIdentityService.
+     *
+     *   use google\appengine\api\app_identity\AppIdentityService;
+     *   use Google\Auth\Subscriber\ScopedAccessTokenSubscriber;
+     *   use GuzzleHttp\Client;
+     *
+     *   $scope = 'https://www.googleapis.com/auth/taskqueue'
+     *   $subscriber = new ScopedAccessToken(
+     *       'AppIdentityService::getAccessToken',
+     *       $scope,
+     *       ['prefix' => 'Google\Auth\ScopedAccessToken::'],
+     *       $cache = new Memcache()
+     *   );
+     *
+     *   $client = new Client([
+     *       'base_url' => 'https://www.googleapis.com/taskqueue/v1beta2/projects/',
+     *       'defaults' => ['auth' => 'scoped']
+     *   ]);
+     *   $client->getEmitter()->attach($subscriber);
+     *
+     *   $res = $client->get('myproject/taskqueues/myqueue');
+     *
+     * @param BeforeEvent $event
+     */
+    public function onBefore(BeforeEvent $event)
+    {
+        // Requests using "auth"="scoped" will be authorized.
+        $request = $event->getRequest();
+        if ($request->getConfig()['auth'] != 'scoped') {
+            return;
+        }
+        $auth_header = 'Bearer ' . $this->fetchToken();
+        $request->setHeader('Authorization', $auth_header);
+    }
+
+    /**
+     * @return string
+     */
+    private function getCacheKey()
+    {
+        $key = null;
+
+        if (is_string($this->scopes)) {
+            $key .= $this->scopes;
+        } elseif (is_array($this->scopes)) {
+            $key .= implode(':', $this->scopes);
+        }
+
+        return $key;
+    }
+
+    /**
+     * Determine if token is available in the cache, if not call tokenFunc to
+     * fetch it.
+     *
+     * @return string
+     */
+    private function fetchToken()
+    {
+        $cacheKey = $this->getCacheKey();
+        $cached = $this->getCachedValue($cacheKey);
+
+        if (!empty($cached)) {
+            return $cached;
+        }
+
+        $token = call_user_func($this->tokenFunc, $this->scopes);
+        $this->setCachedValue($cacheKey, $token);
+
+        return $token;
+    }
+}

vendor/google/auth/src/Subscriber/SimpleSubscriber.php

@@ -0,0 +1,90 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Subscriber;
+
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Event\RequestEvents;
+use GuzzleHttp\Event\SubscriberInterface;
+
+/**
+ * SimpleSubscriber is a Guzzle Subscriber that implements Google's Simple API
+ * access.
+ *
+ * Requests are accessed using the Simple API access developer key.
+ */
+class SimpleSubscriber implements SubscriberInterface
+{
+    /**
+     * @var array
+     */
+    private $config;
+
+    /**
+     * Create a new Simple plugin.
+     *
+     * The configuration array expects one option
+     * - key: required, otherwise InvalidArgumentException is thrown
+     *
+     * @param array $config Configuration array
+     */
+    public function __construct(array $config)
+    {
+        if (!isset($config['key'])) {
+            throw new \InvalidArgumentException('requires a key to have been set');
+        }
+
+        $this->config = array_merge([], $config);
+    }
+
+    /**
+     * @return array
+     */
+    public function getEvents()
+    {
+        return ['before' => ['onBefore', RequestEvents::SIGN_REQUEST]];
+    }
+
+    /**
+     * Updates the request query with the developer key if auth is set to simple.
+     *
+     *   use Google\Auth\Subscriber\SimpleSubscriber;
+     *   use GuzzleHttp\Client;
+     *
+     *   $my_key = 'is not the same as yours';
+     *   $subscriber = new SimpleSubscriber(['key' => $my_key]);
+     *
+     *   $client = new Client([
+     *      'base_url' => 'https://www.googleapis.com/discovery/v1/',
+     *      'defaults' => ['auth' => 'simple']
+     *   ]);
+     *   $client->getEmitter()->attach($subscriber);
+     *
+     *   $res = $client->get('drive/v2/rest');
+     *
+     * @param BeforeEvent $event
+     */
+    public function onBefore(BeforeEvent $event)
+    {
+        // Requests using "auth"="simple" with the developer key.
+        $request = $event->getRequest();
+        if ($request->getConfig()['auth'] != 'simple') {
+            return;
+        }
+        $request->getQuery()->overwriteWith($this->config);
+    }
+}

vendor/google/auth/tests/ApplicationDefaultCredentialsTest.php

@@ -0,0 +1,299 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\ApplicationDefaultCredentials;
+use Google\Auth\Credentials\GCECredentials;
+use Google\Auth\Credentials\ServiceAccountCredentials;
+use GuzzleHttp\Psr7;
+
+class ADCGetTest extends \PHPUnit_Framework_TestCase
+{
+    private $originalHome;
+
+    protected function setUp()
+    {
+        $this->originalHome = getenv('HOME');
+    }
+
+    protected function tearDown()
+    {
+        if ($this->originalHome != getenv('HOME')) {
+            putenv('HOME=' . $this->originalHome);
+        }
+        putenv(ServiceAccountCredentials::ENV_VAR);  // removes it from
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testIsFailsEnvSpecifiesNonExistentFile()
+    {
+        $keyFile = __DIR__ . '/fixtures' . '/does-not-exist-private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        ApplicationDefaultCredentials::getCredentials('a scope');
+    }
+
+    public function testLoadsOKIfEnvSpecifiedIsValid()
+    {
+        $keyFile = __DIR__ . '/fixtures' . '/private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        $this->assertNotNull(
+            ApplicationDefaultCredentials::getCredentials('a scope')
+        );
+    }
+
+    public function testLoadsDefaultFileIfPresentAndEnvVarIsNotSet()
+    {
+        putenv('HOME=' . __DIR__ . '/fixtures');
+        $this->assertNotNull(
+            ApplicationDefaultCredentials::getCredentials('a scope')
+        );
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfNotOnGceAndNoDefaultFileFound()
+    {
+        putenv('HOME=' . __DIR__ . '/not_exist_fixtures');
+        // simulate not being GCE by return 500
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+
+        ApplicationDefaultCredentials::getCredentials('a scope', $httpHandler);
+    }
+
+    public function testSuccedsIfNoDefaultFilesButIsOnGCE()
+    {
+        $wantedTokens = [
+            'access_token' => '1/abdef1234567890',
+            'expires_in' => '57',
+            'token_type' => 'Bearer',
+        ];
+        $jsonTokens = json_encode($wantedTokens);
+
+        // simulate the response from GCE.
+        $httpHandler = getHandler([
+            buildResponse(200, [GCECredentials::FLAVOR_HEADER => 'Google']),
+            buildResponse(200, [], Psr7\stream_for($jsonTokens)),
+        ]);
+
+        $this->assertNotNull(
+            ApplicationDefaultCredentials::getCredentials('a scope', $httpHandler)
+        );
+    }
+}
+
+class ADCGetMiddlewareTest extends \PHPUnit_Framework_TestCase
+{
+    private $originalHome;
+
+    protected function setUp()
+    {
+        $this->originalHome = getenv('HOME');
+    }
+
+    protected function tearDown()
+    {
+        if ($this->originalHome != getenv('HOME')) {
+            putenv('HOME=' . $this->originalHome);
+        }
+        putenv(ServiceAccountCredentials::ENV_VAR);  // removes it if assigned
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testIsFailsEnvSpecifiesNonExistentFile()
+    {
+        $keyFile = __DIR__ . '/fixtures' . '/does-not-exist-private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        ApplicationDefaultCredentials::getMiddleware('a scope');
+    }
+
+    public function testLoadsOKIfEnvSpecifiedIsValid()
+    {
+        $keyFile = __DIR__ . '/fixtures' . '/private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        $this->assertNotNull(ApplicationDefaultCredentials::getMiddleware('a scope'));
+    }
+
+    public function testLoadsDefaultFileIfPresentAndEnvVarIsNotSet()
+    {
+        putenv('HOME=' . __DIR__ . '/fixtures');
+        $this->assertNotNull(ApplicationDefaultCredentials::getMiddleware('a scope'));
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfNotOnGceAndNoDefaultFileFound()
+    {
+        putenv('HOME=' . __DIR__ . '/not_exist_fixtures');
+
+        // simulate not being GCE by return 500
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+
+        ApplicationDefaultCredentials::getMiddleware('a scope', $httpHandler);
+    }
+
+    public function testSuccedsIfNoDefaultFilesButIsOnGCE()
+    {
+        $wantedTokens = [
+            'access_token' => '1/abdef1234567890',
+            'expires_in' => '57',
+            'token_type' => 'Bearer',
+        ];
+        $jsonTokens = json_encode($wantedTokens);
+
+        // simulate the response from GCE.
+        $httpHandler = getHandler([
+            buildResponse(200, [GCECredentials::FLAVOR_HEADER => 'Google']),
+            buildResponse(200, [], Psr7\stream_for($jsonTokens)),
+        ]);
+
+        $this->assertNotNull(ApplicationDefaultCredentials::getMiddleware('a scope', $httpHandler));
+    }
+}
+
+class ADCGetCredentialsAppEngineTest extends BaseTest
+{
+    private $originalHome;
+    private $originalServiceAccount;
+
+    protected function setUp()
+    {
+        // set home to be somewhere else
+        $this->originalHome = getenv('HOME');
+        putenv('HOME=' . __DIR__ . '/not_exist_fixtures');
+
+        // remove service account path
+        $this->originalServiceAccount = getenv(ServiceAccountCredentials::ENV_VAR);
+        putenv(ServiceAccountCredentials::ENV_VAR);
+    }
+
+    protected function tearDown()
+    {
+        // removes it if assigned
+        putenv('HOME=' . $this->originalHome);
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $this->originalServiceAccount);
+    }
+
+    public function testAppEngineStandard()
+    {
+        $_SERVER['SERVER_SOFTWARE'] = 'Google App Engine';
+        $this->assertInstanceOf(
+            'Google\Auth\Credentials\AppIdentityCredentials',
+            ApplicationDefaultCredentials::getCredentials()
+        );
+    }
+
+    public function testAppEngineFlexible()
+    {
+        $_SERVER['SERVER_SOFTWARE'] = 'Google App Engine';
+        $_SERVER['GAE_VM'] = 'true';
+        $httpHandler = getHandler([
+            buildResponse(200, [GCECredentials::FLAVOR_HEADER => 'Google']),
+        ]);
+        $this->assertInstanceOf(
+            'Google\Auth\Credentials\GCECredentials',
+            ApplicationDefaultCredentials::getCredentials(null, $httpHandler)
+        );
+    }
+}
+
+// @todo consider a way to DRY this and above class up
+class ADCGetSubscriberTest extends BaseTest
+{
+    private $originalHome;
+
+    protected function setUp()
+    {
+        $this->onlyGuzzle5();
+
+        $this->originalHome = getenv('HOME');
+    }
+
+    protected function tearDown()
+    {
+        if ($this->originalHome != getenv('HOME')) {
+            putenv('HOME=' . $this->originalHome);
+        }
+        putenv(ServiceAccountCredentials::ENV_VAR);  // removes it if assigned
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testIsFailsEnvSpecifiesNonExistentFile()
+    {
+        $keyFile = __DIR__ . '/fixtures' . '/does-not-exist-private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        ApplicationDefaultCredentials::getSubscriber('a scope');
+    }
+
+    public function testLoadsOKIfEnvSpecifiedIsValid()
+    {
+        $keyFile = __DIR__ . '/fixtures' . '/private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        $this->assertNotNull(ApplicationDefaultCredentials::getSubscriber('a scope'));
+    }
+
+    public function testLoadsDefaultFileIfPresentAndEnvVarIsNotSet()
+    {
+        putenv('HOME=' . __DIR__ . '/fixtures');
+        $this->assertNotNull(ApplicationDefaultCredentials::getSubscriber('a scope'));
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfNotOnGceAndNoDefaultFileFound()
+    {
+        putenv('HOME=' . __DIR__ . '/not_exist_fixtures');
+
+        // simulate not being GCE by return 500
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+
+        ApplicationDefaultCredentials::getSubscriber('a scope', $httpHandler);
+    }
+
+    public function testSuccedsIfNoDefaultFilesButIsOnGCE()
+    {
+        $wantedTokens = [
+            'access_token' => '1/abdef1234567890',
+            'expires_in' => '57',
+            'token_type' => 'Bearer',
+        ];
+        $jsonTokens = json_encode($wantedTokens);
+
+        // simulate the response from GCE.
+        $httpHandler = getHandler([
+            buildResponse(200, [GCECredentials::FLAVOR_HEADER => 'Google']),
+            buildResponse(200, [], Psr7\stream_for($jsonTokens)),
+        ]);
+
+        $this->assertNotNull(ApplicationDefaultCredentials::getSubscriber('a scope', $httpHandler));
+    }
+}

vendor/google/auth/tests/BaseTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Google\Auth\tests;
+
+use GuzzleHttp\ClientInterface;
+
+abstract class BaseTest extends \PHPUnit_Framework_TestCase
+{
+    public function onlyGuzzle6()
+    {
+        $version = ClientInterface::VERSION;
+        if ('6' !== $version[0]) {
+            $this->markTestSkipped('Guzzle 6 only');
+        }
+    }
+
+    public function onlyGuzzle5()
+    {
+        $version = ClientInterface::VERSION;
+        if ('5' !== $version[0]) {
+            $this->markTestSkipped('Guzzle 5 only');
+        }
+    }
+
+    /**
+     * @see Google\Auth\$this->getValidKeyName
+     */
+    public function getValidKeyName($key)
+    {
+        return preg_replace('|[^a-zA-Z0-9_\.! ]|', '', $key);
+    }
+}

vendor/google/auth/tests/Cache/ItemTest.php

@@ -0,0 +1,125 @@
+<?php
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\Cache\Item;
+
+class ItemTest extends \PHPUnit_Framework_TestCase
+{
+    public function getItem($key)
+    {
+        return new Item($key);
+    }
+
+    public function testGetsKey()
+    {
+        $key = 'item';
+
+        $this->assertEquals($key, $this->getItem($key)->getKey());
+    }
+
+    public function testGetsNull()
+    {
+        $item = $this->getItem('item');
+
+        $this->assertNull($item->get());
+        $this->assertFalse($item->isHit());
+    }
+
+    public function testGetsValue()
+    {
+        $value = 'value';
+        $item = $this->getItem('item');
+        $item->set($value);
+
+        $this->assertEquals('value', $item->get());
+    }
+
+    /**
+     * @dataProvider values
+     */
+    public function testSetsValue($value)
+    {
+        $item = $this->getItem('item');
+        $item->set($value);
+
+        $this->assertEquals($value, $item->get());
+    }
+
+    public function values()
+    {
+        return [
+            [1],
+            [1.5],
+            [true],
+            [null],
+            [new \DateTime()],
+            [['test']],
+            ['value']
+        ];
+    }
+
+    public function testIsHit()
+    {
+        $item = $this->getItem('item');
+
+        $this->assertFalse($item->isHit());
+
+        $item->set('value');
+
+        $this->assertTrue($item->isHit());
+    }
+
+    public function testExpiresAt()
+    {
+        $item = $this->getItem('item');
+        $item->set('value');
+        $item->expiresAt(new \DateTime('now + 1 hour'));
+
+        $this->assertTrue($item->isHit());
+
+        $item->expiresAt(null);
+
+        $this->assertTrue($item->isHit());
+
+        $item->expiresAt(new \DateTime('yesterday'));
+
+        $this->assertFalse($item->isHit());
+    }
+
+    public function testExpiresAfter()
+    {
+        $item = $this->getItem('item');
+        $item->set('value');
+        $item->expiresAfter(30);
+
+        $this->assertTrue($item->isHit());
+
+        $item->expiresAfter(0);
+
+        $this->assertFalse($item->isHit());
+
+        $item->expiresAfter(new \DateInterval('PT30S'));
+
+        $this->assertTrue($item->isHit());
+
+        $item->expiresAfter(null);
+
+        $this->assertTrue($item->isHit());
+    }
+}

vendor/google/auth/tests/Cache/MemoryCacheItemPoolTest.php

@@ -0,0 +1,189 @@
+<?php
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\Cache\MemoryCacheItemPool;
+use Psr\Cache\InvalidArgumentException;
+
+class MemoryCacheItemPoolTest extends \PHPUnit_Framework_TestCase
+{
+    private $pool;
+
+    public function setUp()
+    {
+        $this->pool = new MemoryCacheItemPool();
+    }
+
+    public function saveItem($key, $value)
+    {
+        $item = $this->pool->getItem($key);
+        $item->set($value);
+        $this->assertTrue($this->pool->save($item));
+
+        return $item;
+    }
+
+    public function testGetsFreshItem()
+    {
+        $item = $this->pool->getItem('item');
+
+        $this->assertInstanceOf('Google\Auth\Cache\Item', $item);
+        $this->assertNull($item->get());
+        $this->assertFalse($item->isHit());
+    }
+
+    public function testGetsExistingItem()
+    {
+        $key = 'item';
+        $value = 'value';
+        $this->saveItem($key, $value);
+        $item = $this->pool->getItem($key);
+
+        $this->assertInstanceOf('Google\Auth\Cache\Item', $item);
+        $this->assertEquals($value, $item->get());
+        $this->assertTrue($item->isHit());
+    }
+
+    public function testGetsMultipleItems()
+    {
+        $keys = ['item1', 'item2'];
+        $items = $this->pool->getItems($keys);
+
+        $this->assertEquals($keys, array_keys($items));
+        $this->assertContainsOnlyInstancesOf('Google\Auth\Cache\Item', $items);
+    }
+
+    public function testHasItem()
+    {
+        $existsKey = 'does-exist';
+        $this->saveItem($existsKey, 'value');
+
+        $this->assertTrue($this->pool->hasItem($existsKey));
+        $this->assertFalse($this->pool->hasItem('does-not-exist'));
+    }
+
+    public function testClear()
+    {
+        $key = 'item';
+        $this->saveItem($key, 'value');
+
+        $this->assertTrue($this->pool->hasItem($key));
+        $this->assertTrue($this->pool->clear());
+        $this->assertFalse($this->pool->hasItem($key));
+    }
+
+    public function testDeletesItem()
+    {
+        $key = 'item';
+        $this->saveItem($key, 'value');
+
+        $this->assertTrue($this->pool->deleteItem($key));
+        $this->assertFalse($this->pool->hasItem($key));
+    }
+
+    public function testDeletesItems()
+    {
+        $keys = ['item1', 'item2'];
+
+        foreach ($keys as $key) {
+            $this->saveItem($key, 'value');
+        }
+
+        $this->assertTrue($this->pool->deleteItems($keys));
+        $this->assertFalse($this->pool->hasItem($keys[0]));
+        $this->assertFalse($this->pool->hasItem($keys[1]));
+    }
+
+    public function testDoesNotDeleteItemsWithInvalidKey()
+    {
+        $keys = ['item1', '{item2}', 'item3'];
+        $value = 'value';
+        $this->saveItem($keys[0], $value);
+        $this->saveItem($keys[2], $value);
+
+        try {
+            $this->pool->deleteItems($keys);
+        } catch (InvalidArgumentException $ex) {
+            // continue execution
+        }
+
+        $this->assertTrue($this->pool->hasItem($keys[0]));
+        $this->assertTrue($this->pool->hasItem($keys[2]));
+    }
+
+    public function testSavesItem()
+    {
+        $key = 'item';
+        $this->saveItem($key, 'value');
+
+        $this->assertTrue($this->pool->hasItem($key));
+    }
+
+    public function testSavesDeferredItem()
+    {
+        $item = $this->pool->getItem('item');
+        $this->assertTrue($this->pool->saveDeferred($item));
+    }
+
+    public function testCommitsDeferredItems()
+    {
+        $keys = ['item1', 'item2'];
+
+        foreach ($keys as $key) {
+            $item = $this->pool->getItem($key);
+            $item->set('value');
+            $this->pool->saveDeferred($item);
+        }
+
+        $this->assertTrue($this->pool->commit());
+        $this->assertTrue($this->pool->hasItem($keys[0]));
+        $this->assertTrue($this->pool->hasItem($keys[1]));
+    }
+
+    /**
+     * @expectedException \Psr\Cache\InvalidArgumentException
+     * @dataProvider invalidKeys
+     */
+    public function testCheckInvalidKeys($key)
+    {
+        $this->pool->getItem($key);
+        $this->pool->getItems([$key]);
+        $this->pool->hasItem($key);
+        $this->pool->deleteItem($key);
+        $this->pool->deleteItems([$key]);
+    }
+
+    public function invalidKeys()
+    {
+        return [
+            [1],
+            [true],
+            [null],
+            [new \DateTime()],
+            ['{'],
+            ['}'],
+            ['('],
+            [')'],
+            ['/'],
+            ['\\'],
+            ['@'],
+            [':'],
+            [[]]
+        ];
+    }
+}

vendor/google/auth/tests/CacheTraitTest.php

@@ -0,0 +1,151 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\CacheTrait;
+
+class CacheTraitTest extends \PHPUnit_Framework_TestCase
+{
+    private $mockFetcher;
+    private $mockCacheItem;
+    private $mockCache;
+
+    public function setUp()
+    {
+        $this->mockFetcher =
+            $this
+                ->getMockBuilder('Google\Auth\FetchAuthTokenInterface')
+                ->getMock();
+        $this->mockCacheItem =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemInterface')
+                ->getMock();
+        $this->mockCache =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemPoolInterface')
+                ->getMock();
+    }
+
+    public function testSuccessfullyPullsFromCache()
+    {
+        $expectedValue = '1234';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($expectedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->will($this->returnValue($this->mockCacheItem));
+
+        $implementation = new CacheTraitImplementation([
+            'cache' => $this->mockCache,
+        ]);
+
+        $cachedValue = $implementation->gCachedValue();
+        $this->assertEquals($expectedValue, $cachedValue);
+    }
+
+    public function testFailsPullFromCacheWithNoCache()
+    {
+        $implementation = new CacheTraitImplementation();
+
+        $cachedValue = $implementation->gCachedValue();
+        $this->assertEquals(null, $cachedValue);
+    }
+
+    public function testFailsPullFromCacheWithoutKey()
+    {
+        $implementation = new CacheTraitImplementation([
+            'cache' => $this->mockCache,
+            'key'   => null,
+        ]);
+
+        $cachedValue = $implementation->gCachedValue();
+    }
+
+    public function testSuccessfullySetsToCache()
+    {
+        $value = '1234';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($value);
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo('key'))
+            ->will($this->returnValue($this->mockCacheItem));
+
+        $implementation = new CacheTraitImplementation([
+            'cache' => $this->mockCache,
+        ]);
+
+        $implementation->sCachedValue($value);
+    }
+
+    public function testFailsSetToCacheWithNoCache()
+    {
+        $implementation = new CacheTraitImplementation();
+
+        $implementation->sCachedValue('1234');
+
+        $cachedValue = $implementation->sCachedValue('1234');
+        $this->assertNull($cachedValue);
+    }
+
+    public function testFailsSetToCacheWithoutKey()
+    {
+        $implementation = new CacheTraitImplementation([
+            'cache' => $this->mockCache,
+            'key'   => null,
+        ]);
+
+        $cachedValue = $implementation->sCachedValue('1234');
+        $this->assertNull($cachedValue);
+    }
+}
+
+class CacheTraitImplementation
+{
+    use CacheTrait;
+
+    private $cache;
+    private $cacheConfig;
+
+    public function __construct(array $config = [])
+    {
+        $this->key = array_key_exists('key', $config) ? $config['key'] : 'key';
+        $this->cache = isset($config['cache']) ? $config['cache'] : null;
+        $this->cacheConfig = [
+            'prefix' => '',
+            'lifetime' => 1000,
+        ];
+    }
+
+    // allows us to keep trait methods private
+    public function gCachedValue()
+    {
+        return $this->getCachedValue($this->key);
+    }
+
+    public function sCachedValue($v)
+    {
+        $this->setCachedValue($this->key, $v);
+    }
+}

vendor/google/auth/tests/Credentials/AppIndentityCredentialsTest.php

@@ -0,0 +1,104 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use google\appengine\api\app_identity\AppIdentityService;
+// included from tests\mocks\AppIdentityService.php
+use Google\Auth\Credentials\AppIdentityCredentials;
+
+class AppIdentityCredentialsOnAppEngineTest extends \PHPUnit_Framework_TestCase
+{
+    public function testIsFalseByDefault()
+    {
+        $this->assertFalse(AppIdentityCredentials::onAppEngine());
+    }
+
+    public function testIsTrueWhenServerSoftwareIsGoogleAppEngine()
+    {
+        $_SERVER['SERVER_SOFTWARE'] = 'Google App Engine';
+        $this->assertTrue(AppIdentityCredentials::onAppEngine());
+    }
+}
+
+class AppIdentityCredentialsGetCacheKeyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testShouldBeEmpty()
+    {
+        $g = new AppIdentityCredentials();
+        $this->assertEmpty($g->getCacheKey());
+    }
+}
+
+class AppIdentityCredentialsFetchAuthTokenTest extends \PHPUnit_Framework_TestCase
+{
+    public function testShouldBeEmptyIfNotOnAppEngine()
+    {
+        $g = new AppIdentityCredentials();
+        $this->assertEquals(array(), $g->fetchAuthToken());
+    }
+
+    /* @expectedException */
+    public function testThrowsExceptionIfClassDoesntExist()
+    {
+        $_SERVER['SERVER_SOFTWARE'] = 'Google App Engine';
+        $g = new AppIdentityCredentials();
+    }
+
+    public function testReturnsExpectedToken()
+    {
+        // include the mock AppIdentityService class
+        require_once __DIR__ . '/../mocks/AppIdentityService.php';
+
+        $wantedToken = [
+            'access_token' => '1/abdef1234567890',
+            'expires_in' => '57',
+            'token_type' => 'Bearer',
+        ];
+
+        AppIdentityService::$accessToken = $wantedToken;
+
+        $_SERVER['SERVER_SOFTWARE'] = 'Google App Engine';
+
+        $g = new AppIdentityCredentials();
+        $this->assertEquals($wantedToken, $g->fetchAuthToken());
+    }
+
+    public function testScopeIsAlwaysArray()
+    {
+        // include the mock AppIdentityService class
+        require_once __DIR__ . '/../mocks/AppIdentityService.php';
+
+        $scope1 = ['scopeA', 'scopeB'];
+        $scope2 = 'scopeA scopeB';
+        $scope3 = 'scopeA';
+
+        $_SERVER['SERVER_SOFTWARE'] = 'Google App Engine';
+
+        $g = new AppIdentityCredentials($scope1);
+        $g->fetchAuthToken();
+        $this->assertEquals($scope1, AppIdentityService::$scope);
+
+        $g = new AppIdentityCredentials($scope2);
+        $g->fetchAuthToken();
+        $this->assertEquals(explode(' ', $scope2), AppIdentityService::$scope);
+
+        $g = new AppIdentityCredentials($scope3);
+        $g->fetchAuthToken();
+        $this->assertEquals([$scope3], AppIdentityService::$scope);
+    }
+}

vendor/google/auth/tests/Credentials/GCECredentialsTest.php

@@ -0,0 +1,124 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\Credentials\GCECredentials;
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Response;
+
+class GCECredentialsOnGCETest extends \PHPUnit_Framework_TestCase
+{
+    public function testIsFalseOnClientErrorStatus()
+    {
+        $httpHandler = getHandler([
+            buildResponse(400),
+        ]);
+        $this->assertFalse(GCECredentials::onGCE($httpHandler));
+    }
+
+    public function testIsFalseOnServerErrorStatus()
+    {
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+        $this->assertFalse(GCECredentials::onGCE($httpHandler));
+    }
+
+    public function testIsFalseOnOkStatusWithoutExpectedHeader()
+    {
+        $httpHandler = getHandler([
+            buildResponse(200),
+        ]);
+        $this->assertFalse(GCECredentials::onGCE($httpHandler));
+    }
+
+    public function testIsOkIfGoogleIsTheFlavor()
+    {
+        $httpHandler = getHandler([
+            buildResponse(200, [GCECredentials::FLAVOR_HEADER => 'Google']),
+        ]);
+        $this->assertTrue(GCECredentials::onGCE($httpHandler));
+    }
+}
+
+class GCECredentialsOnAppEngineFlexibleTest extends \PHPUnit_Framework_TestCase
+{
+    public function testIsFalseByDefault()
+    {
+        $this->assertFalse(GCECredentials::onAppEngineFlexible());
+    }
+
+    public function testIsTrueWhenGaeVmIsTrue()
+    {
+        $_SERVER['GAE_VM'] = 'true';
+        $this->assertTrue(GCECredentials::onAppEngineFlexible());
+    }
+}
+
+class GCECredentialsGetCacheKeyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testShouldNotBeEmpty()
+    {
+        $g = new GCECredentials();
+        $this->assertNotEmpty($g->getCacheKey());
+    }
+}
+
+class GCECredentialsFetchAuthTokenTest extends \PHPUnit_Framework_TestCase
+{
+    public function testShouldBeEmptyIfNotOnGCE()
+    {
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+        $g = new GCECredentials();
+        $this->assertEquals(array(), $g->fetchAuthToken($httpHandler));
+    }
+
+    /**
+     * @expectedException Exception
+     * @expectedExceptionMessage Invalid JSON response
+     */
+    public function testShouldFailIfResponseIsNotJson()
+    {
+        $notJson = '{"foo": , this is cannot be passed as json" "bar"}';
+        $httpHandler = getHandler([
+            buildResponse(200, [GCECredentials::FLAVOR_HEADER => 'Google']),
+            buildResponse(200, [], $notJson),
+        ]);
+        $g = new GCECredentials();
+        $g->fetchAuthToken($httpHandler);
+    }
+
+    public function testShouldReturnTokenInfo()
+    {
+        $wantedTokens = [
+            'access_token' => '1/abdef1234567890',
+            'expires_in' => '57',
+            'token_type' => 'Bearer',
+        ];
+        $jsonTokens = json_encode($wantedTokens);
+        $httpHandler = getHandler([
+            buildResponse(200, [GCECredentials::FLAVOR_HEADER => 'Google']),
+            buildResponse(200, [], Psr7\stream_for($jsonTokens)),
+        ]);
+        $g = new GCECredentials();
+        $this->assertEquals($wantedTokens, $g->fetchAuthToken($httpHandler));
+        $this->assertEquals(time() + 57, $g->getLastReceivedToken()['expires_at']);
+    }
+}

vendor/google/auth/tests/Credentials/IAMCredentialsTest.php

@@ -0,0 +1,83 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\Credentials\IAMCredentials;
+
+class IAMConstructorTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfSelectorIsNotString()
+    {
+        $notAString = new \stdClass();
+        $iam = new IAMCredentials(
+            $notAString,
+            ''
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfTokenIsNotString()
+    {
+        $notAString = new \stdClass();
+        $iam = new IAMCredentials(
+            '',
+            $notAString
+        );
+    }
+
+    public function testInitializeSuccess()
+    {
+        $this->assertNotNull(
+            new IAMCredentials('iam-selector', 'iam-token')
+        );
+    }
+}
+
+class IAMUpdateMetadataCallbackTest extends \PHPUnit_Framework_TestCase
+{
+    public function testUpdateMetadataFunc()
+    {
+        $selector = 'iam-selector';
+        $token = 'iam-token';
+        $iam = new IAMCredentials(
+            $selector,
+            $token
+        );
+
+        $update_metadata = $iam->getUpdateMetadataFunc();
+        $this->assertTrue(is_callable($update_metadata));
+
+        $actual_metadata = call_user_func($update_metadata,
+            $metadata = array('foo' => 'bar'));
+        $this->assertTrue(
+            isset($actual_metadata[IAMCredentials::SELECTOR_KEY]));
+        $this->assertEquals(
+            $actual_metadata[IAMCredentials::SELECTOR_KEY],
+            $selector);
+        $this->assertTrue(
+            isset($actual_metadata[IAMCredentials::TOKEN_KEY]));
+        $this->assertEquals(
+            $actual_metadata[IAMCredentials::TOKEN_KEY],
+            $token);
+    }
+}

vendor/google/auth/tests/Credentials/ServiceAccountCredentialsTest.php

@@ -0,0 +1,508 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\ApplicationDefaultCredentials;
+use Google\Auth\Credentials\ServiceAccountCredentials;
+use Google\Auth\Credentials\ServiceAccountJwtAccessCredentials;
+use Google\Auth\CredentialsLoader;
+use Google\Auth\OAuth2;
+use GuzzleHttp\Psr7;
+
+// Creates a standard JSON auth object for testing.
+function createTestJson()
+{
+    return [
+        'private_key_id' => 'key123',
+        'private_key' => 'privatekey',
+        'client_email' => 'test@example.com',
+        'client_id' => 'client123',
+        'type' => 'service_account',
+    ];
+}
+
+class SACGetCacheKeyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testShouldBeTheSameAsOAuth2WithTheSameScope()
+    {
+        $testJson = createTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson);
+        $o = new OAuth2(['scope' => $scope]);
+        $this->assertSame(
+            $testJson['client_email'] . ':' . $o->getCacheKey(),
+            $sa->getCacheKey()
+        );
+    }
+
+    public function testShouldBeTheSameAsOAuth2WithTheSameScopeWithSub()
+    {
+        $testJson = createTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $sub = 'sub123';
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson,
+            $sub);
+        $o = new OAuth2(['scope' => $scope]);
+        $this->assertSame(
+            $testJson['client_email'] . ':' . $o->getCacheKey() . ':' . $sub,
+            $sa->getCacheKey()
+        );
+    }
+
+    public function testShouldBeTheSameAsOAuth2WithTheSameScopeWithSubAddedLater()
+    {
+        $testJson = createTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $sub = 'sub123';
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson,
+            null);
+        $sa->setSub($sub);
+
+        $o = new OAuth2(['scope' => $scope]);
+        $this->assertSame(
+            $testJson['client_email'] . ':' . $o->getCacheKey() . ':' . $sub,
+            $sa->getCacheKey()
+        );
+    }
+}
+
+class SACConstructorTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfScopeIsNotAValidType()
+    {
+        $testJson = createTestJson();
+        $notAnArrayOrString = new \stdClass();
+        $sa = new ServiceAccountCredentials(
+            $notAnArrayOrString,
+            $testJson
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfJsonDoesNotHaveClientEmail()
+    {
+        $testJson = createTestJson();
+        unset($testJson['client_email']);
+        $scope = ['scope/1', 'scope/2'];
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfJsonDoesNotHavePrivateKey()
+    {
+        $testJson = createTestJson();
+        unset($testJson['private_key']);
+        $scope = ['scope/1', 'scope/2'];
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testFailsToInitalizeFromANonExistentFile()
+    {
+        $keyFile = __DIR__ . '/../fixtures' . '/does-not-exist-private.json';
+        new ServiceAccountCredentials('scope/1', $keyFile);
+    }
+
+    public function testInitalizeFromAFile()
+    {
+        $keyFile = __DIR__ . '/../fixtures' . '/private.json';
+        $this->assertNotNull(
+            new ServiceAccountCredentials('scope/1', $keyFile)
+        );
+    }
+}
+
+class SACFromEnvTest extends \PHPUnit_Framework_TestCase
+{
+    protected function tearDown()
+    {
+        putenv(ServiceAccountCredentials::ENV_VAR);  // removes it from
+    }
+
+    public function testIsNullIfEnvVarIsNotSet()
+    {
+        $this->assertNull(ServiceAccountCredentials::fromEnv());
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfEnvSpecifiesNonExistentFile()
+    {
+        $keyFile = __DIR__ . '/../fixtures' . '/does-not-exist-private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        ApplicationDefaultCredentials::getCredentials('a scope');
+    }
+
+    public function testSucceedIfFileExists()
+    {
+        $keyFile = __DIR__ . '/../fixtures' . '/private.json';
+        putenv(ServiceAccountCredentials::ENV_VAR . '=' . $keyFile);
+        $this->assertNotNull(ApplicationDefaultCredentials::getCredentials('a scope'));
+    }
+}
+
+class SACFromWellKnownFileTest extends \PHPUnit_Framework_TestCase
+{
+    private $originalHome;
+
+    protected function setUp()
+    {
+        $this->originalHome = getenv('HOME');
+    }
+
+    protected function tearDown()
+    {
+        if ($this->originalHome != getenv('HOME')) {
+            putenv('HOME=' . $this->originalHome);
+        }
+    }
+
+    public function testIsNullIfFileDoesNotExist()
+    {
+        putenv('HOME=' . __DIR__ . '/../not_exists_fixtures');
+        $this->assertNull(
+            ServiceAccountCredentials::fromWellKnownFile()
+        );
+    }
+
+    public function testSucceedIfFileIsPresent()
+    {
+        putenv('HOME=' . __DIR__ . '/../fixtures');
+        $this->assertNotNull(
+            ApplicationDefaultCredentials::getCredentials('a scope')
+        );
+    }
+}
+
+class SACFetchAuthTokenTest extends \PHPUnit_Framework_TestCase
+{
+    private $privateKey;
+
+    public function setUp()
+    {
+        $this->privateKey =
+            file_get_contents(__DIR__ . '/../fixtures' . '/private.pem');
+    }
+
+    private function createTestJson()
+    {
+        $testJson = createTestJson();
+        $testJson['private_key'] = $this->privateKey;
+
+        return $testJson;
+    }
+
+    /**
+     * @expectedException GuzzleHttp\Exception\ClientException
+     */
+    public function testFailsOnClientErrors()
+    {
+        $testJson = $this->createTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $httpHandler = getHandler([
+            buildResponse(400),
+        ]);
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+        $sa->fetchAuthToken($httpHandler);
+    }
+
+    /**
+     * @expectedException GuzzleHttp\Exception\ServerException
+     */
+    public function testFailsOnServerErrors()
+    {
+        $testJson = $this->createTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+        $sa->fetchAuthToken($httpHandler);
+    }
+
+    public function testCanFetchCredsOK()
+    {
+        $testJson = $this->createTestJson();
+        $testJsonText = json_encode($testJson);
+        $scope = ['scope/1', 'scope/2'];
+        $httpHandler = getHandler([
+            buildResponse(200, [], Psr7\stream_for($testJsonText)),
+        ]);
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+        $tokens = $sa->fetchAuthToken($httpHandler);
+        $this->assertEquals($testJson, $tokens);
+    }
+
+    public function testUpdateMetadataFunc()
+    {
+        $testJson = $this->createTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $access_token = 'accessToken123';
+        $responseText = json_encode(array('access_token' => $access_token));
+        $httpHandler = getHandler([
+            buildResponse(200, [], Psr7\stream_for($responseText)),
+        ]);
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+        $update_metadata = $sa->getUpdateMetadataFunc();
+        $this->assertTrue(is_callable($update_metadata));
+
+        $actual_metadata = call_user_func($update_metadata,
+            $metadata = array('foo' => 'bar'),
+            $authUri = null,
+            $httpHandler);
+        $this->assertTrue(
+            isset($actual_metadata[CredentialsLoader::AUTH_METADATA_KEY]));
+        $this->assertEquals(
+            $actual_metadata[CredentialsLoader::AUTH_METADATA_KEY],
+            array('Bearer ' . $access_token));
+    }
+}
+
+class SACJwtAccessTest extends \PHPUnit_Framework_TestCase
+{
+    private $privateKey;
+
+    public function setUp()
+    {
+        $this->privateKey =
+            file_get_contents(__DIR__ . '/../fixtures' . '/private.pem');
+    }
+
+    private function createTestJson()
+    {
+        $testJson = createTestJson();
+        $testJson['private_key'] = $this->privateKey;
+
+        return $testJson;
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testFailsOnMissingClientEmail()
+    {
+        $testJson = $this->createTestJson();
+        unset($testJson['client_email']);
+        $sa = new ServiceAccountJwtAccessCredentials(
+            $testJson
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testFailsOnMissingPrivateKey()
+    {
+        $testJson = $this->createTestJson();
+        unset($testJson['private_key']);
+        $sa = new ServiceAccountJwtAccessCredentials(
+            $testJson
+        );
+    }
+
+    public function testCanInitializeFromJson()
+    {
+        $testJson = $this->createTestJson();
+        $sa = new ServiceAccountJwtAccessCredentials(
+            $testJson
+        );
+        $this->assertNotNull($sa);
+    }
+
+    public function testNoOpOnFetchAuthToken()
+    {
+        $testJson = $this->createTestJson();
+        $sa = new ServiceAccountJwtAccessCredentials(
+            $testJson
+        );
+        $this->assertNotNull($sa);
+
+        $httpHandler = getHandler([
+            buildResponse(200),
+        ]);
+        $result = $sa->fetchAuthToken($httpHandler); // authUri has not been set
+        $this->assertNull($result);
+    }
+
+    public function testAuthUriIsNotSet()
+    {
+        $testJson = $this->createTestJson();
+        $sa = new ServiceAccountJwtAccessCredentials(
+            $testJson
+        );
+        $this->assertNotNull($sa);
+
+        $update_metadata = $sa->getUpdateMetadataFunc();
+        $this->assertTrue(is_callable($update_metadata));
+
+        $actual_metadata = call_user_func($update_metadata,
+            $metadata = array('foo' => 'bar'),
+            $authUri = null);
+        $this->assertTrue(
+            !isset($actual_metadata[CredentialsLoader::AUTH_METADATA_KEY]));
+    }
+
+    public function testUpdateMetadataFunc()
+    {
+        $testJson = $this->createTestJson();
+        $sa = new ServiceAccountJwtAccessCredentials(
+            $testJson
+        );
+        $this->assertNotNull($sa);
+
+        $update_metadata = $sa->getUpdateMetadataFunc();
+        $this->assertTrue(is_callable($update_metadata));
+
+        $actual_metadata = call_user_func($update_metadata,
+            $metadata = array('foo' => 'bar'),
+            $authUri = 'https://example.com/service');
+        $this->assertTrue(
+            isset($actual_metadata[CredentialsLoader::AUTH_METADATA_KEY]));
+
+        $authorization = $actual_metadata[CredentialsLoader::AUTH_METADATA_KEY];
+        $this->assertTrue(is_array($authorization));
+
+        $bearer_token = current($authorization);
+        $this->assertTrue(is_string($bearer_token));
+        $this->assertTrue(strpos($bearer_token, 'Bearer ') == 0);
+        $this->assertTrue(strlen($bearer_token) > 30);
+
+        $actual_metadata2 = call_user_func($update_metadata,
+            $metadata = array('foo' => 'bar'),
+            $authUri = 'https://example.com/anotherService');
+        $this->assertTrue(
+            isset($actual_metadata2[CredentialsLoader::AUTH_METADATA_KEY]));
+
+        $authorization2 = $actual_metadata2[CredentialsLoader::AUTH_METADATA_KEY];
+        $this->assertTrue(is_array($authorization2));
+
+        $bearer_token2 = current($authorization2);
+        $this->assertTrue(is_string($bearer_token2));
+        $this->assertTrue(strpos($bearer_token2, 'Bearer ') == 0);
+        $this->assertTrue(strlen($bearer_token2) > 30);
+        $this->assertTrue($bearer_token != $bearer_token2);
+    }
+}
+
+class SACJwtAccessComboTest extends \PHPUnit_Framework_TestCase
+{
+    private $privateKey;
+
+    public function setUp()
+    {
+        $this->privateKey =
+            file_get_contents(__DIR__ . '/../fixtures' . '/private.pem');
+    }
+
+    private function createTestJson()
+    {
+        $testJson = createTestJson();
+        $testJson['private_key'] = $this->privateKey;
+
+        return $testJson;
+    }
+
+    public function testNoScopeUseJwtAccess()
+    {
+        $testJson = $this->createTestJson();
+        // no scope, jwt access should be used, no outbound
+        // call should be made
+        $scope = null;
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+        $this->assertNotNull($sa);
+
+        $update_metadata = $sa->getUpdateMetadataFunc();
+        $this->assertTrue(is_callable($update_metadata));
+
+        $actual_metadata = call_user_func($update_metadata,
+            $metadata = array('foo' => 'bar'),
+            $authUri = 'https://example.com/service');
+        $this->assertTrue(
+            isset($actual_metadata[CredentialsLoader::AUTH_METADATA_KEY]));
+
+        $authorization = $actual_metadata[CredentialsLoader::AUTH_METADATA_KEY];
+        $this->assertTrue(is_array($authorization));
+
+        $bearer_token = current($authorization);
+        $this->assertTrue(is_string($bearer_token));
+        $this->assertTrue(strpos($bearer_token, 'Bearer ') == 0);
+        $this->assertTrue(strlen($bearer_token) > 30);
+    }
+
+    public function testNoScopeAndNoAuthUri()
+    {
+        $testJson = $this->createTestJson();
+        // no scope, jwt access should be used, no outbound
+        // call should be made
+        $scope = null;
+        $sa = new ServiceAccountCredentials(
+            $scope,
+            $testJson
+        );
+        $this->assertNotNull($sa);
+
+        $update_metadata = $sa->getUpdateMetadataFunc();
+        $this->assertTrue(is_callable($update_metadata));
+
+        $actual_metadata = call_user_func($update_metadata,
+            $metadata = array('foo' => 'bar'),
+            $authUri = null);
+        // no access_token is added to the metadata hash
+        // but also, no error should be thrown
+        $this->assertTrue(is_array($actual_metadata));
+        $this->assertTrue(
+            !isset($actual_metadata[CredentialsLoader::AUTH_METADATA_KEY]));
+    }
+}

vendor/google/auth/tests/Credentials/UserRefreshCredentialsTest.php

@@ -0,0 +1,228 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\ApplicationDefaultCredentials;
+use Google\Auth\Credentials\UserRefreshCredentials;
+use Google\Auth\OAuth2;
+use GuzzleHttp\Psr7;
+
+// Creates a standard JSON auth object for testing.
+function createURCTestJson()
+{
+    return [
+        'client_id' => 'client123',
+        'client_secret' => 'clientSecret123',
+        'refresh_token' => 'refreshToken123',
+        'type' => 'authorized_user',
+    ];
+}
+
+class URCGetCacheKeyTest extends \PHPUnit_Framework_TestCase
+{
+    public function testShouldBeTheSameAsOAuth2WithTheSameScope()
+    {
+        $testJson = createURCTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $sa = new UserRefreshCredentials(
+            $scope,
+            $testJson);
+        $o = new OAuth2(['scope' => $scope]);
+        $this->assertSame(
+            $testJson['client_id'] . ':' . $o->getCacheKey(),
+            $sa->getCacheKey()
+        );
+    }
+}
+
+class URCConstructorTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfScopeIsNotAValidType()
+    {
+        $testJson = createURCTestJson();
+        $notAnArrayOrString = new \stdClass();
+        $sa = new UserRefreshCredentials(
+            $notAnArrayOrString,
+            $testJson
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfJsonDoesNotHaveClientSecret()
+    {
+        $testJson = createURCTestJson();
+        unset($testJson['client_secret']);
+        $scope = ['scope/1', 'scope/2'];
+        $sa = new UserRefreshCredentials(
+            $scope,
+            $testJson
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testShouldFailIfJsonDoesNotHaveRefreshToken()
+    {
+        $testJson = createURCTestJson();
+        unset($testJson['refresh_token']);
+        $scope = ['scope/1', 'scope/2'];
+        $sa = new UserRefreshCredentials(
+            $scope,
+            $testJson
+        );
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testFailsToInitalizeFromANonExistentFile()
+    {
+        $keyFile = __DIR__ . '/../fixtures' . '/does-not-exist-private.json';
+        new UserRefreshCredentials('scope/1', $keyFile);
+    }
+
+    public function testInitalizeFromAFile()
+    {
+        $keyFile = __DIR__ . '/../fixtures2' . '/private.json';
+        $this->assertNotNull(
+            new UserRefreshCredentials('scope/1', $keyFile)
+        );
+    }
+}
+
+class URCFromEnvTest extends \PHPUnit_Framework_TestCase
+{
+    protected function tearDown()
+    {
+        putenv(UserRefreshCredentials::ENV_VAR);  // removes it from
+    }
+
+    public function testIsNullIfEnvVarIsNotSet()
+    {
+        $this->assertNull(UserRefreshCredentials::fromEnv('a scope'));
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfEnvSpecifiesNonExistentFile()
+    {
+        $keyFile = __DIR__ . '/../fixtures' . '/does-not-exist-private.json';
+        putenv(UserRefreshCredentials::ENV_VAR . '=' . $keyFile);
+        UserRefreshCredentials::fromEnv('a scope');
+    }
+
+    public function testSucceedIfFileExists()
+    {
+        $keyFile = __DIR__ . '/../fixtures2' . '/private.json';
+        putenv(UserRefreshCredentials::ENV_VAR . '=' . $keyFile);
+        $this->assertNotNull(ApplicationDefaultCredentials::getCredentials('a scope'));
+    }
+}
+
+class URCFromWellKnownFileTest extends \PHPUnit_Framework_TestCase
+{
+    private $originalHome;
+
+    protected function setUp()
+    {
+        $this->originalHome = getenv('HOME');
+    }
+
+    protected function tearDown()
+    {
+        if ($this->originalHome != getenv('HOME')) {
+            putenv('HOME=' . $this->originalHome);
+        }
+    }
+
+    public function testIsNullIfFileDoesNotExist()
+    {
+        putenv('HOME=' . __DIR__ . '/../not_exist_fixtures');
+        $this->assertNull(
+            UserRefreshCredentials::fromWellKnownFile('a scope')
+        );
+    }
+
+    public function testSucceedIfFileIsPresent()
+    {
+        putenv('HOME=' . __DIR__ . '/../fixtures2');
+        $this->assertNotNull(
+            ApplicationDefaultCredentials::getCredentials('a scope')
+        );
+    }
+}
+
+class URCFetchAuthTokenTest extends \PHPUnit_Framework_TestCase
+{
+    /**
+     * @expectedException GuzzleHttp\Exception\ClientException
+     */
+    public function testFailsOnClientErrors()
+    {
+        $testJson = createURCTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $httpHandler = getHandler([
+            buildResponse(400),
+        ]);
+        $sa = new UserRefreshCredentials(
+            $scope,
+            $testJson
+        );
+        $sa->fetchAuthToken($httpHandler);
+    }
+
+    /**
+     * @expectedException GuzzleHttp\Exception\ServerException
+     */
+    public function testFailsOnServerErrors()
+    {
+        $testJson = createURCTestJson();
+        $scope = ['scope/1', 'scope/2'];
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+        $sa = new UserRefreshCredentials(
+            $scope,
+            $testJson
+        );
+        $sa->fetchAuthToken($httpHandler);
+    }
+
+    public function testCanFetchCredsOK()
+    {
+        $testJson = createURCTestJson();
+        $testJsonText = json_encode($testJson);
+        $scope = ['scope/1', 'scope/2'];
+        $httpHandler = getHandler([
+            buildResponse(200, [], Psr7\stream_for($testJsonText)),
+        ]);
+        $sa = new UserRefreshCredentials(
+            $scope,
+            $testJson
+        );
+        $tokens = $sa->fetchAuthToken($httpHandler);
+        $this->assertEquals($testJson, $tokens);
+    }
+}

vendor/google/auth/tests/FetchAuthTokenCacheTest.php

@@ -0,0 +1,146 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\tests;
+
+use Google\Auth\FetchAuthTokenCache;
+
+class FetchAuthTokenCacheTest extends BaseTest
+{
+    protected function setUp()
+    {
+        $this->mockFetcher =
+            $this
+                ->getMockBuilder('Google\Auth\FetchAuthTokenInterface')
+                ->getMock();
+        $this->mockCacheItem =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemInterface')
+                ->getMock();
+        $this->mockCache =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemPoolInterface')
+                ->getMock();
+    }
+
+    public function testUsesCachedAuthToken()
+    {
+        $cacheKey = 'myKey';
+        $cachedValue = '2/abcdef1234567890';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->never())
+            ->method('fetchAuthToken');
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+
+        // Run the test.
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            null,
+            $this->mockCache
+        );
+        $accessToken = $cachedFetcher->fetchAuthToken();
+        $this->assertEquals($accessToken, ['access_token' => $cachedValue]);
+    }
+
+    public function testGetsCachedAuthTokenUsingCachePrefix()
+    {
+        $prefix = 'test_prefix_';
+        $cacheKey = 'myKey';
+        $cachedValue = '2/abcdef1234567890';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->never())
+            ->method('fetchAuthToken');
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+
+        // Run the test
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix],
+            $this->mockCache
+        );
+        $accessToken = $cachedFetcher->fetchAuthToken();
+        $this->assertEquals($accessToken, ['access_token' => $cachedValue]);
+    }
+
+    public function testShouldSaveValueInCacheWithCacheOptions()
+    {
+        $prefix = 'test_prefix_';
+        $lifetime = '70707';
+        $cacheKey = 'myKey';
+        $token = '1/abcdef1234567890';
+        $authResult = ['access_token' => $token];
+        $this->mockCacheItem
+            ->expects($this->any())
+            ->method('get')
+            ->will($this->returnValue(null));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($this->equalTo($token))
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('expiresAfter')
+            ->with($this->equalTo($lifetime));
+        $this->mockCache
+            ->expects($this->exactly(2))
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+
+        // Run the test
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix, 'lifetime' => $lifetime],
+            $this->mockCache
+        );
+        $accessToken = $cachedFetcher->fetchAuthToken();
+        $this->assertEquals($accessToken, ['access_token' => $token]);
+    }
+}

vendor/google/auth/tests/FetchAuthTokenTest.php

@@ -0,0 +1,170 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\tests;
+
+use Google\Auth\Credentials\AppIdentityCredentials;
+use Google\Auth\Credentials\GCECredentials;
+use Google\Auth\Credentials\ServiceAccountCredentials;
+use Google\Auth\Credentials\ServiceAccountJwtAccessCredentials;
+use Google\Auth\Credentials\UserRefreshCredentials;
+use Google\Auth\CredentialsLoader;
+use Google\Auth\FetchAuthTokenInterface;
+use Google\Auth\OAuth2;
+
+class FetchAuthTokenTest extends BaseTest
+{
+    /** @dataProvider provideAuthTokenFetcher */
+    public function testGetLastReceivedToken(FetchAuthTokenInterface $fetcher)
+    {
+        $accessToken = $fetcher->getLastReceivedToken();
+
+        $this->assertNotNull($accessToken);
+        $this->assertArrayHasKey('access_token', $accessToken);
+        $this->assertArrayHasKey('expires_at', $accessToken);
+
+        $this->assertEquals('xyz', $accessToken['access_token']);
+        $this->assertEquals(strtotime('2001'), $accessToken['expires_at']);
+    }
+
+    public function provideAuthTokenFetcher()
+    {
+        $scopes = ['https://www.googleapis.com/auth/drive.readonly'];
+        $jsonPath = sprintf(
+            '%s/fixtures/.config/%s',
+            __DIR__,
+            CredentialsLoader::WELL_KNOWN_PATH
+        );
+        $jsonPath2 = sprintf(
+            '%s/fixtures2/.config/%s',
+            __DIR__,
+            CredentialsLoader::WELL_KNOWN_PATH
+        );
+
+        return [
+            [$this->getAppIdentityCredentials()],
+            [$this->getGCECredentials()],
+            [$this->getServiceAccountCredentials($scopes, $jsonPath)],
+            [$this->getServiceAccountJwtAccessCredentials($jsonPath)],
+            [$this->getUserRefreshCredentials($scopes, $jsonPath2)],
+            [$this->getOAuth2()],
+        ];
+    }
+
+    private function getAppIdentityCredentials()
+    {
+        $class = new \ReflectionClass(
+            'Google\Auth\Credentials\AppIdentityCredentials'
+        );
+        $property = $class->getProperty('lastReceivedToken');
+        $property->setAccessible(true);
+
+        $credentials = new AppIdentityCredentials();
+        $property->setValue($credentials, [
+            'access_token' => 'xyz',
+            'expiration_time' => strtotime('2001'),
+        ]);
+
+        return $credentials;
+    }
+
+    private function getGCECredentials()
+    {
+        $class = new \ReflectionClass(
+            'Google\Auth\Credentials\GCECredentials'
+        );
+        $property = $class->getProperty('lastReceivedToken');
+        $property->setAccessible(true);
+
+        $credentials = new GCECredentials();
+        $property->setValue($credentials, [
+            'access_token' => 'xyz',
+            'expires_at' => strtotime('2001'),
+        ]);
+
+        return $credentials;
+    }
+
+    private function getServiceAccountCredentials($scopes, $jsonPath)
+    {
+        $class = new \ReflectionClass(
+            'Google\Auth\Credentials\ServiceAccountCredentials'
+        );
+        $property = $class->getProperty('auth');
+        $property->setAccessible(true);
+
+        $credentials = new ServiceAccountCredentials($scopes, $jsonPath);
+        $property->setValue($credentials, $this->getOAuth2Mock());
+
+        return $credentials;
+    }
+
+    private function getServiceAccountJwtAccessCredentials($jsonPath)
+    {
+        $class = new \ReflectionClass(
+            'Google\Auth\Credentials\ServiceAccountJwtAccessCredentials'
+        );
+        $property = $class->getProperty('auth');
+        $property->setAccessible(true);
+
+        $credentials = new ServiceAccountJwtAccessCredentials($jsonPath);
+        $property->setValue($credentials, $this->getOAuth2Mock());
+
+        return $credentials;
+    }
+
+    private function getUserRefreshCredentials($scopes, $jsonPath)
+    {
+        $class = new \ReflectionClass(
+            'Google\Auth\Credentials\UserRefreshCredentials'
+        );
+        $property = $class->getProperty('auth');
+        $property->setAccessible(true);
+
+        $credentials = new UserRefreshCredentials($scopes, $jsonPath);
+        $property->setValue($credentials, $this->getOAuth2Mock());
+
+        return $credentials;
+    }
+
+    private function getOAuth2()
+    {
+        $oauth = new OAuth2([
+            'access_token' => 'xyz',
+            'expires_at' => strtotime('2001'),
+        ]);
+
+        return $oauth;
+    }
+
+    private function getOAuth2Mock()
+    {
+        $mock = $this->getMockBuilder('Google\Auth\OAuth2')
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        $mock
+            ->expects($this->once())
+            ->method('getLastReceivedToken')
+            ->will($this->returnValue([
+                'access_token' => 'xyz',
+                'expires_at' => strtotime('2001'),
+            ]));
+
+        return $mock;
+    }
+}

vendor/google/auth/tests/HttpHandler/Guzzle5HttpHandlerTest.php

@@ -0,0 +1,59 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\HttpHandler\Guzzle5HttpHandler;
+use GuzzleHttp\Message\Response;
+
+class Guzzle5HttpHandlerTest extends BaseTest
+{
+    public function setUp()
+    {
+        $this->onlyGuzzle5();
+
+        $this->mockPsr7Request =
+            $this
+                ->getMockBuilder('Psr\Http\Message\RequestInterface')
+                ->getMock();
+        $this->mockRequest =
+            $this
+                ->getMockBuilder('GuzzleHttp\Message\RequestInterface')
+                ->getMock();
+        $this->mockClient =
+            $this
+                ->getMockBuilder('GuzzleHttp\Client')
+                ->disableOriginalConstructor()
+                ->getMock();
+    }
+
+    public function testSuccessfullySendsRequest()
+    {
+        $this->mockClient
+            ->expects($this->any())
+            ->method('send')
+            ->will($this->returnValue(new Response(200)));
+        $this->mockClient
+            ->expects($this->any())
+            ->method('createRequest')
+            ->will($this->returnValue($this->mockRequest));
+
+        $handler = new Guzzle5HttpHandler($this->mockClient);
+        $response = $handler($this->mockPsr7Request);
+        $this->assertInstanceOf('Psr\Http\Message\ResponseInterface', $response);
+    }
+}

vendor/google/auth/tests/HttpHandler/Guzzle6HttpHandlerTest.php

@@ -0,0 +1,50 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\HttpHandler\Guzzle6HttpHandler;
+use GuzzleHttp\Psr7\Response;
+
+class Guzzle6HttpHandlerTest extends BaseTest
+{
+    public function setUp()
+    {
+        $this->onlyGuzzle6();
+
+        $this->mockRequest =
+            $this
+                ->getMockBuilder('Psr\Http\Message\RequestInterface')
+                ->getMock();
+        $this->mockClient =
+            $this
+                ->getMockBuilder('GuzzleHttp\Client')
+                ->getMock();
+    }
+
+    public function testSuccessfullySendsRequest()
+    {
+        $this->mockClient
+            ->expects($this->any())
+            ->method('send')
+            ->will($this->returnValue(new Response(200)));
+
+        $handler = new Guzzle6HttpHandler($this->mockClient);
+        $response = $handler($this->mockRequest);
+        $this->assertInstanceOf('Psr\Http\Message\ResponseInterface', $response);
+    }
+}

vendor/google/auth/tests/HttpHandler/HttpHandlerFactoryTest.php

@@ -0,0 +1,39 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\HttpHandler\HttpHandlerFactory;
+
+class HttpHandlerFactoryTest extends BaseTest
+{
+    public function testBuildsGuzzle5Handler()
+    {
+        $this->onlyGuzzle5();
+
+        $handler = HttpHandlerFactory::build();
+        $this->assertInstanceOf('Google\Auth\HttpHandler\Guzzle5HttpHandler', $handler);
+    }
+
+    public function testBuildsGuzzle6Handler()
+    {
+        $this->onlyGuzzle6();
+
+        $handler = HttpHandlerFactory::build();
+        $this->assertInstanceOf('Google\Auth\HttpHandler\Guzzle6HttpHandler', $handler);
+    }
+}

vendor/google/auth/tests/Middleware/AuthTokenMiddlewareTest.php

@@ -0,0 +1,336 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\FetchAuthTokenCache;
+use Google\Auth\Middleware\AuthTokenMiddleware;
+use GuzzleHttp\Handler\MockHandler;
+use GuzzleHttp\Psr7\Response;
+
+class AuthTokenMiddlewareTest extends BaseTest
+{
+    private $mockFetcher;
+    private $mockCacheItem;
+    private $mockCache;
+    private $mockRequest;
+
+    protected function setUp()
+    {
+        $this->onlyGuzzle6();
+
+        $this->mockFetcher =
+            $this
+                ->getMockBuilder('Google\Auth\FetchAuthTokenInterface')
+                ->getMock();
+        $this->mockCacheItem =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemInterface')
+                ->getMock();
+        $this->mockCache =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemPoolInterface')
+                ->getMock();
+        $this->mockRequest =
+            $this
+                ->getMockBuilder('GuzzleHttp\Psr7\Request')
+                ->disableOriginalConstructor()
+                ->getMock();
+    }
+
+    public function testOnlyTouchesWhenAuthConfigScoped()
+    {
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue([]));
+        $this->mockRequest
+            ->expects($this->never())
+            ->method('withHeader');
+
+        $middleware = new AuthTokenMiddleware($this->mockFetcher);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'not_google_auth']);
+    }
+
+    public function testAddsTheTokenAsAnAuthorizationHeader()
+    {
+        $authResult = ['access_token' => '1/abcdef1234567890'];
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $authResult['access_token'])
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test.
+        $middleware = new AuthTokenMiddleware($this->mockFetcher);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'google_auth']);
+    }
+
+    public function testDoesNotAddAnAuthorizationHeaderOnNoAccessToken()
+    {
+        $authResult = ['not_access_token' => '1/abcdef1234567890'];
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ')
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test.
+        $middleware = new AuthTokenMiddleware($this->mockFetcher);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'google_auth']);
+    }
+
+    public function testUsesCachedAuthToken()
+    {
+        $cacheKey = 'myKey';
+        $cachedValue = '2/abcdef1234567890';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->never())
+            ->method('fetchAuthToken');
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $cachedValue)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test.
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            null,
+            $this->mockCache
+        );
+        $middleware = new AuthTokenMiddleware($cachedFetcher);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'google_auth']);
+    }
+
+    public function testGetsCachedAuthTokenUsingCacheOptions()
+    {
+        $prefix = 'test_prefix_';
+        $cacheKey = 'myKey';
+        $cachedValue = '2/abcdef1234567890';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->never())
+            ->method('fetchAuthToken');
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $cachedValue)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test.
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix],
+            $this->mockCache
+        );
+        $middleware = new AuthTokenMiddleware($cachedFetcher);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'google_auth']);
+    }
+
+    public function testShouldSaveValueInCacheWithSpecifiedPrefix()
+    {
+        $prefix = 'test_prefix_';
+        $lifetime = '70707';
+        $cacheKey = 'myKey';
+        $token = '1/abcdef1234567890';
+        $authResult = ['access_token' => $token];
+        $this->mockCacheItem
+            ->expects($this->any())
+            ->method('get')
+            ->will($this->returnValue(null));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($this->equalTo($token))
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('expiresAfter')
+            ->with($this->equalTo($lifetime));
+        $this->mockCache
+            ->expects($this->any())
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $token)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test.
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix, 'lifetime' => $lifetime],
+            $this->mockCache
+        );
+        $middleware = new AuthTokenMiddleware($cachedFetcher);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'google_auth']);
+    }
+
+    /** @dataProvider provideShouldNotifyTokenCallback */
+    public function testShouldNotifyTokenCallback(callable $tokenCallback)
+    {
+        $prefix = 'test_prefix_';
+        $cacheKey = 'myKey';
+        $token = '1/abcdef1234567890';
+        $authResult = ['access_token' => $token];
+        $this->mockCacheItem
+            ->expects($this->any())
+            ->method('get')
+            ->will($this->returnValue(null));
+        $this->mockCache
+            ->expects($this->any())
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->will($this->returnValue($this->mockRequest));
+
+        MiddlewareCallback::$expectedKey = $this->getValidKeyName($prefix . $cacheKey);
+        MiddlewareCallback::$expectedValue = $token;
+        MiddlewareCallback::$called = false;
+
+        // Run the test.
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix],
+            $this->mockCache
+        );
+        $middleware = new AuthTokenMiddleware(
+            $cachedFetcher,
+            null,
+            $tokenCallback
+        );
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'google_auth']);
+        $this->assertTrue(MiddlewareCallback::$called);
+    }
+
+    public function provideShouldNotifyTokenCallback()
+    {
+        MiddlewareCallback::$phpunit = $this;
+        $anonymousFunc = function ($key, $value) {
+            MiddlewareCallback::staticInvoke($key, $value);
+        };
+        return [
+            ['Google\Auth\Tests\MiddlewareCallbackFunction'],
+            ['Google\Auth\Tests\MiddlewareCallback::staticInvoke'],
+            [['Google\Auth\Tests\MiddlewareCallback', 'staticInvoke']],
+            [$anonymousFunc],
+            [[new MiddlewareCallback, 'staticInvoke']],
+            [[new MiddlewareCallback, 'methodInvoke']],
+            [new MiddlewareCallback],
+        ];
+    }
+}
+
+class MiddlewareCallback
+{
+    public static $phpunit;
+    public static $expectedKey;
+    public static $expectedValue;
+    public static $called = false;
+
+    public function __invoke($key, $value)
+    {
+        self::$phpunit->assertEquals(self::$expectedKey, $key);
+        self::$phpunit->assertEquals(self::$expectedValue, $value);
+        self::$called = true;
+    }
+
+    public function methodInvoke($key, $value)
+    {
+        return $this($key, $value);
+    }
+
+    public static function staticInvoke($key, $value)
+    {
+        $instance = new self();
+        return $instance($key, $value);
+    }
+}
+
+function MiddlewareCallbackFunction($key, $value)
+{
+    return MiddlewareCallback::staticInvoke($key, $value);
+}

vendor/google/auth/tests/Middleware/ScopedAccessTokenMiddlewareTest.php

@@ -0,0 +1,245 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\Middleware\ScopedAccessTokenMiddleware;
+use GuzzleHttp\Handler\MockHandler;
+use GuzzleHttp\Psr7\Response;
+
+class ScopedAccessTokenMiddlewareTest extends BaseTest
+{
+    const TEST_SCOPE = 'https://www.googleapis.com/auth/cloud-taskqueue';
+
+    private $mockCacheItem;
+    private $mockCache;
+    private $mockRequest;
+
+    protected function setUp()
+    {
+        $this->onlyGuzzle6();
+
+        $this->mockCacheItem =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemInterface')
+                ->getMock();
+        $this->mockCache =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemPoolInterface')
+                ->getMock();
+        $this->mockRequest =
+            $this
+                ->getMockBuilder('GuzzleHttp\Psr7\Request')
+                ->disableOriginalConstructor()
+                ->getMock();
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRequiresScopeAsAStringOrArray()
+    {
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '1/abcdef1234567890';
+        };
+        new ScopedAccessTokenMiddleware($fakeAuthFunc, new \stdClass());
+    }
+
+    public function testAddsTheTokenAsAnAuthorizationHeader()
+    {
+        $token = '1/abcdef1234567890';
+        $fakeAuthFunc = function ($unused_scopes) use ($token) {
+            return $token;
+        };
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $token)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test
+        $middleware = new ScopedAccessTokenMiddleware($fakeAuthFunc, self::TEST_SCOPE);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'scoped']);
+    }
+
+    public function testUsesCachedAuthToken()
+    {
+        $cachedValue = '2/abcdef1234567890';
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '';
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($this->getValidKeyName(self::TEST_SCOPE)))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $cachedValue)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test
+        $middleware = new ScopedAccessTokenMiddleware(
+            $fakeAuthFunc,
+            self::TEST_SCOPE,
+            [],
+            $this->mockCache
+        );
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'scoped']);
+    }
+
+    public function testGetsCachedAuthTokenUsingCachePrefix()
+    {
+        $prefix = 'test_prefix_';
+        $cachedValue = '2/abcdef1234567890';
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '';
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $this->getValidKeyName(self::TEST_SCOPE)))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $cachedValue)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test
+        $middleware = new ScopedAccessTokenMiddleware(
+            $fakeAuthFunc,
+            self::TEST_SCOPE,
+            ['prefix' => $prefix],
+            $this->mockCache
+        );
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'scoped']);
+    }
+
+    public function testShouldSaveValueInCache()
+    {
+        $token = '2/abcdef1234567890';
+        $fakeAuthFunc = function ($unused_scopes) use ($token) {
+            return $token;
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($this->equalTo($token))
+            ->will($this->returnValue(false));
+        $this->mockCache
+            ->expects($this->exactly(2))
+            ->method('getItem')
+            ->with($this->equalTo($this->getValidKeyName(self::TEST_SCOPE)))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $token)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test
+        $middleware = new ScopedAccessTokenMiddleware(
+            $fakeAuthFunc,
+            self::TEST_SCOPE,
+            [],
+            $this->mockCache
+        );
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'scoped']);
+    }
+
+    public function testShouldSaveValueInCacheWithCacheOptions()
+    {
+        $token = '2/abcdef1234567890';
+        $prefix = 'test_prefix_';
+        $lifetime = '70707';
+        $fakeAuthFunc = function ($unused_scopes) use ($token) {
+            return $token;
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($this->equalTo($token))
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('expiresAfter')
+            ->with($this->equalTo($lifetime));
+        $this->mockCache
+            ->expects($this->exactly(2))
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $this->getValidKeyName(self::TEST_SCOPE)))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockRequest
+            ->expects($this->once())
+            ->method('withHeader')
+            ->with('Authorization', 'Bearer ' . $token)
+            ->will($this->returnValue($this->mockRequest));
+
+        // Run the test
+        $middleware = new ScopedAccessTokenMiddleware(
+            $fakeAuthFunc,
+            self::TEST_SCOPE,
+            ['prefix' => $prefix, 'lifetime' => $lifetime],
+            $this->mockCache
+        );
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'scoped']);
+    }
+
+    public function testOnlyTouchesWhenAuthConfigScoped()
+    {
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '1/abcdef1234567890';
+        };
+        $this->mockRequest
+            ->expects($this->never())
+            ->method('withHeader');
+
+        // Run the test
+        $middleware = new ScopedAccessTokenMiddleware($fakeAuthFunc, self::TEST_SCOPE);
+        $mock = new MockHandler([new Response(200)]);
+        $callable = $middleware($mock);
+        $callable($this->mockRequest, ['auth' => 'not_scoped']);
+    }
+}

vendor/google/auth/tests/Middleware/SimpleMiddlewareTest.php

@@ -0,0 +1,41 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+class SimpleMiddlewareTest extends BaseTest
+{
+    private $mockRequest;
+
+    /**
+     * @todo finish
+     */
+    protected function setUp()
+    {
+        $this->onlyGuzzle6();
+
+        $this->mockRequest =
+            $this
+                ->getMockBuilder('GuzzleHttp\Psr7\Request')
+                ->disableOriginalConstructor()
+                ->getMock();
+    }
+
+    public function testTest()
+    {
+    }
+}

vendor/google/auth/tests/OAuth2Test.php

@@ -0,0 +1,858 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\OAuth2;
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Response;
+
+class OAuth2AuthorizationUriTest extends \PHPUnit_Framework_TestCase
+{
+    private $minimal = [
+        'authorizationUri' => 'https://accounts.test.org/insecure/url',
+        'redirectUri' => 'https://accounts.test.org/redirect/url',
+        'clientId' => 'aClientID',
+    ];
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testIsNullIfAuthorizationUriIsNull()
+    {
+        $o = new OAuth2([]);
+        $this->assertNull($o->buildFullAuthorizationUri());
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRequiresTheClientId()
+    {
+        $o = new OAuth2([
+            'authorizationUri' => 'https://accounts.test.org/auth/url',
+            'redirectUri' => 'https://accounts.test.org/redirect/url',
+        ]);
+        $o->buildFullAuthorizationUri();
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRequiresTheRedirectUri()
+    {
+        $o = new OAuth2([
+            'authorizationUri' => 'https://accounts.test.org/auth/url',
+            'clientId' => 'aClientID',
+        ]);
+        $o->buildFullAuthorizationUri();
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testCannotHavePromptAndApprovalPrompt()
+    {
+        $o = new OAuth2([
+            'authorizationUri' => 'https://accounts.test.org/auth/url',
+            'clientId' => 'aClientID',
+        ]);
+        $o->buildFullAuthorizationUri([
+            'approval_prompt' => 'an approval prompt',
+            'prompt' => 'a prompt',
+        ]);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testCannotHaveInsecureAuthorizationUri()
+    {
+        $o = new OAuth2([
+            'authorizationUri' => 'http://accounts.test.org/insecure/url',
+            'redirectUri' => 'https://accounts.test.org/redirect/url',
+            'clientId' => 'aClientID',
+        ]);
+        $o->buildFullAuthorizationUri();
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testCannotHaveRelativeRedirectUri()
+    {
+        $o = new OAuth2([
+            'authorizationUri' => 'http://accounts.test.org/insecure/url',
+            'redirectUri' => '/redirect/url',
+            'clientId' => 'aClientID',
+        ]);
+        $o->buildFullAuthorizationUri();
+    }
+
+    public function testHasDefaultXXXTypeParams()
+    {
+        $o = new OAuth2($this->minimal);
+        $q = Psr7\parse_query($o->buildFullAuthorizationUri()->getQuery());
+        $this->assertEquals('code', $q['response_type']);
+        $this->assertEquals('offline', $q['access_type']);
+    }
+
+    public function testCanBeUrlObject()
+    {
+        $config = array_merge($this->minimal, [
+            'authorizationUri' => Psr7\uri_for('https://another/uri'),
+        ]);
+        $o = new OAuth2($config);
+        $this->assertEquals('/uri', $o->buildFullAuthorizationUri()->getPath());
+    }
+
+    public function testCanOverrideParams()
+    {
+        $overrides = [
+            'access_type' => 'o_access_type',
+            'client_id' => 'o_client_id',
+            'redirect_uri' => 'o_redirect_uri',
+            'response_type' => 'o_response_type',
+            'state' => 'o_state',
+        ];
+        $config = array_merge($this->minimal, ['state' => 'the_state']);
+        $o = new OAuth2($config);
+        $q = Psr7\parse_query($o->buildFullAuthorizationUri($overrides)->getQuery());
+        $this->assertEquals('o_access_type', $q['access_type']);
+        $this->assertEquals('o_client_id', $q['client_id']);
+        $this->assertEquals('o_redirect_uri', $q['redirect_uri']);
+        $this->assertEquals('o_response_type', $q['response_type']);
+        $this->assertEquals('o_state', $q['state']);
+    }
+
+    public function testIncludesTheScope()
+    {
+        $with_strings = array_merge($this->minimal, ['scope' => 'scope1 scope2']);
+        $o = new OAuth2($with_strings);
+        $q = Psr7\parse_query($o->buildFullAuthorizationUri()->getQuery());
+        $this->assertEquals('scope1 scope2', $q['scope']);
+
+        $with_array = array_merge($this->minimal, [
+            'scope' => ['scope1', 'scope2'],
+        ]);
+        $o = new OAuth2($with_array);
+        $q = Psr7\parse_query($o->buildFullAuthorizationUri()->getQuery());
+        $this->assertEquals('scope1 scope2', $q['scope']);
+    }
+
+    public function testRedirectUriPostmessageIsAllowed()
+    {
+        $o = new OAuth2([
+            'authorizationUri' => 'https://accounts.test.org/insecure/url',
+            'redirectUri' => 'postmessage',
+            'clientId' => 'aClientID',
+        ]);
+        $this->assertEquals('postmessage', $o->getRedirectUri());
+        $url = $o->buildFullAuthorizationUri();
+        $parts = parse_url((string)$url);
+        parse_str($parts['query'], $query);
+        $this->assertArrayHasKey('redirect_uri', $query);
+        $this->assertEquals('postmessage', $query['redirect_uri']);
+    }
+}
+
+class OAuth2GrantTypeTest extends \PHPUnit_Framework_TestCase
+{
+    private $minimal = [
+        'authorizationUri' => 'https://accounts.test.org/insecure/url',
+        'redirectUri' => 'https://accounts.test.org/redirect/url',
+        'clientId' => 'aClientID',
+    ];
+
+    public function testReturnsNullIfCannotBeInferred()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertNull($o->getGrantType());
+    }
+
+    public function testInfersAuthorizationCode()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setCode('an auth code');
+        $this->assertEquals('authorization_code', $o->getGrantType());
+    }
+
+    public function testInfersRefreshToken()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setRefreshToken('a refresh token');
+        $this->assertEquals('refresh_token', $o->getGrantType());
+    }
+
+    public function testInfersPassword()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setPassword('a password');
+        $o->setUsername('a username');
+        $this->assertEquals('password', $o->getGrantType());
+    }
+
+    public function testInfersJwtBearer()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setIssuer('an issuer');
+        $o->setSigningKey('a key');
+        $this->assertEquals('urn:ietf:params:oauth:grant-type:jwt-bearer',
+            $o->getGrantType());
+    }
+
+    public function testSetsKnownTypes()
+    {
+        $o = new OAuth2($this->minimal);
+        foreach (OAuth2::$knownGrantTypes as $t) {
+            $o->setGrantType($t);
+            $this->assertEquals($t, $o->getGrantType());
+        }
+    }
+
+    public function testSetsUrlAsGrantType()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setGrantType('http://a/grant/url');
+        $this->assertEquals('http://a/grant/url', $o->getGrantType());
+    }
+}
+
+class OAuth2GetCacheKeyTest extends \PHPUnit_Framework_TestCase
+{
+    private $minimal = [
+        'clientID' => 'aClientID',
+    ];
+
+    public function testIsNullWithNoScopes()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertNull($o->getCacheKey());
+    }
+
+    public function testIsScopeIfSingleScope()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setScope('test/scope/1');
+        $this->assertEquals('test/scope/1', $o->getCacheKey());
+    }
+
+    public function testIsAllScopesWhenScopeIsArray()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setScope(['test/scope/1', 'test/scope/2']);
+        $this->assertEquals('test/scope/1:test/scope/2', $o->getCacheKey());
+    }
+}
+
+class OAuth2TimingTest extends \PHPUnit_Framework_TestCase
+{
+    private $minimal = [
+        'authorizationUri' => 'https://accounts.test.org/insecure/url',
+        'redirectUri' => 'https://accounts.test.org/redirect/url',
+        'clientId' => 'aClientID',
+    ];
+
+    public function testIssuedAtDefaultsToNull()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertNull($o->getIssuedAt());
+    }
+
+    public function testExpiresAtDefaultsToNull()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertNull($o->getExpiresAt());
+    }
+
+    public function testExpiresInDefaultsToNull()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertNull($o->getExpiresIn());
+    }
+
+    public function testSettingExpiresInSetsIssuedAt()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertNull($o->getIssuedAt());
+        $aShortWhile = 5;
+        $o->setExpiresIn($aShortWhile);
+        $this->assertEquals($aShortWhile, $o->getExpiresIn());
+        $this->assertNotNull($o->getIssuedAt());
+    }
+
+    public function testSettingExpiresInSetsExpireAt()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertNull($o->getExpiresAt());
+        $aShortWhile = 5;
+        $o->setExpiresIn($aShortWhile);
+        $this->assertNotNull($o->getExpiresAt());
+        $this->assertEquals($aShortWhile, $o->getExpiresAt() - $o->getIssuedAt());
+    }
+
+    public function testIsNotExpiredByDefault()
+    {
+        $o = new OAuth2($this->minimal);
+        $this->assertFalse($o->isExpired());
+    }
+
+    public function testIsNotExpiredIfExpiresAtIsOld()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setExpiresAt(time() - 2);
+        $this->assertTrue($o->isExpired());
+    }
+}
+
+class OAuth2GeneralTest extends \PHPUnit_Framework_TestCase
+{
+    private $minimal = [
+        'authorizationUri' => 'https://accounts.test.org/insecure/url',
+        'redirectUri' => 'https://accounts.test.org/redirect/url',
+        'clientId' => 'aClientID',
+    ];
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testFailsOnUnknownSigningAlgorithm()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setSigningAlgorithm('this is definitely not an algorithm name');
+    }
+
+    public function testAllowsKnownSigningAlgorithms()
+    {
+        $o = new OAuth2($this->minimal);
+        foreach (OAuth2::$knownSigningAlgorithms as $a) {
+            $o->setSigningAlgorithm($a);
+            $this->assertEquals($a, $o->getSigningAlgorithm());
+        }
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testFailsOnRelativeRedirectUri()
+    {
+        $o = new OAuth2($this->minimal);
+        $o->setRedirectUri('/relative/url');
+    }
+
+    public function testAllowsUrnRedirectUri()
+    {
+        $urn = 'urn:ietf:wg:oauth:2.0:oob';
+        $o = new OAuth2($this->minimal);
+        $o->setRedirectUri($urn);
+        $this->assertEquals($urn, $o->getRedirectUri());
+    }
+}
+
+class OAuth2JwtTest extends \PHPUnit_Framework_TestCase
+{
+    private $signingMinimal = [
+        'signingKey' => 'example_key',
+        'signingAlgorithm' => 'HS256',
+        'scope' => 'https://www.googleapis.com/auth/userinfo.profile',
+        'issuer' => 'app@example.com',
+        'audience' => 'accounts.google.com',
+        'clientId' => 'aClientID',
+    ];
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsWithMissingAudience()
+    {
+        $testConfig = $this->signingMinimal;
+        unset($testConfig['audience']);
+        $o = new OAuth2($testConfig);
+        $o->toJwt();
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsWithMissingIssuer()
+    {
+        $testConfig = $this->signingMinimal;
+        unset($testConfig['issuer']);
+        $o = new OAuth2($testConfig);
+        $o->toJwt();
+    }
+
+    /**
+     */
+    public function testCanHaveNoScope()
+    {
+        $testConfig = $this->signingMinimal;
+        unset($testConfig['scope']);
+        $o = new OAuth2($testConfig);
+        $o->toJwt();
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsWithMissingSigningKey()
+    {
+        $testConfig = $this->signingMinimal;
+        unset($testConfig['signingKey']);
+        $o = new OAuth2($testConfig);
+        $o->toJwt();
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsWithMissingSigningAlgorithm()
+    {
+        $testConfig = $this->signingMinimal;
+        unset($testConfig['signingAlgorithm']);
+        $o = new OAuth2($testConfig);
+        $o->toJwt();
+    }
+
+    public function testCanHS256EncodeAValidPayload()
+    {
+        $testConfig = $this->signingMinimal;
+        $o = new OAuth2($testConfig);
+        $payload = $o->toJwt();
+        $roundTrip = $this->jwtDecode($payload, $testConfig['signingKey'], array('HS256'));
+        $this->assertEquals($roundTrip->iss, $testConfig['issuer']);
+        $this->assertEquals($roundTrip->aud, $testConfig['audience']);
+        $this->assertEquals($roundTrip->scope, $testConfig['scope']);
+    }
+
+    public function testCanRS256EncodeAValidPayload()
+    {
+        $publicKey = file_get_contents(__DIR__ . '/fixtures' . '/public.pem');
+        $privateKey = file_get_contents(__DIR__ . '/fixtures' . '/private.pem');
+        $testConfig = $this->signingMinimal;
+        $o = new OAuth2($testConfig);
+        $o->setSigningAlgorithm('RS256');
+        $o->setSigningKey($privateKey);
+        $payload = $o->toJwt();
+        $roundTrip = $this->jwtDecode($payload, $publicKey, array('RS256'));
+        $this->assertEquals($roundTrip->iss, $testConfig['issuer']);
+        $this->assertEquals($roundTrip->aud, $testConfig['audience']);
+        $this->assertEquals($roundTrip->scope, $testConfig['scope']);
+    }
+
+    private function jwtDecode()
+    {
+        $args = func_get_args();
+        $class = 'JWT';
+        if (class_exists('Firebase\JWT\JWT')) {
+            $class = 'Firebase\JWT\JWT';
+        }
+
+        return call_user_func_array("$class::decode", $args);
+    }
+}
+
+class OAuth2GenerateAccessTokenRequestTest extends \PHPUnit_Framework_TestCase
+{
+    private $tokenRequestMinimal = [
+        'tokenCredentialUri' => 'https://tokens_r_us/test',
+        'scope' => 'https://www.googleapis.com/auth/userinfo.profile',
+        'issuer' => 'app@example.com',
+        'audience' => 'accounts.google.com',
+        'clientId' => 'aClientID',
+    ];
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfNoTokenCredentialUri()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        unset($testConfig['tokenCredentialUri']);
+        $o = new OAuth2($testConfig);
+        $o->generateCredentialsRequest();
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfAuthorizationCodeIsMissing()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $testConfig['redirectUri'] = 'https://has/redirect/uri';
+        $o = new OAuth2($testConfig);
+        $o->generateCredentialsRequest();
+    }
+
+    public function testGeneratesAuthorizationCodeRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $testConfig['redirectUri'] = 'https://has/redirect/uri';
+        $o = new OAuth2($testConfig);
+        $o->setCode('an_auth_code');
+
+        // Generate the request and confirm that it's correct.
+        $req = $o->generateCredentialsRequest();
+        $this->assertInstanceOf('Psr\Http\Message\RequestInterface', $req);
+        $this->assertEquals('POST', $req->getMethod());
+        $fields = Psr7\parse_query((string)$req->getBody());
+        $this->assertEquals('authorization_code', $fields['grant_type']);
+        $this->assertEquals('an_auth_code', $fields['code']);
+    }
+
+    public function testGeneratesPasswordRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $o = new OAuth2($testConfig);
+        $o->setUsername('a_username');
+        $o->setPassword('a_password');
+
+        // Generate the request and confirm that it's correct.
+        $req = $o->generateCredentialsRequest();
+        $this->assertInstanceOf('Psr\Http\Message\RequestInterface', $req);
+        $this->assertEquals('POST', $req->getMethod());
+        $fields = Psr7\parse_query((string)$req->getBody());
+        $this->assertEquals('password', $fields['grant_type']);
+        $this->assertEquals('a_password', $fields['password']);
+        $this->assertEquals('a_username', $fields['username']);
+    }
+
+    public function testGeneratesRefreshTokenRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $o = new OAuth2($testConfig);
+        $o->setRefreshToken('a_refresh_token');
+
+        // Generate the request and confirm that it's correct.
+        $req = $o->generateCredentialsRequest();
+        $this->assertInstanceOf('Psr\Http\Message\RequestInterface', $req);
+        $this->assertEquals('POST', $req->getMethod());
+        $fields = Psr7\parse_query((string)$req->getBody());
+        $this->assertEquals('refresh_token', $fields['grant_type']);
+        $this->assertEquals('a_refresh_token', $fields['refresh_token']);
+    }
+
+    public function testClientSecretAddedIfSetForAuthorizationCodeRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $testConfig['clientSecret'] = 'a_client_secret';
+        $testConfig['redirectUri'] = 'https://has/redirect/uri';
+        $o = new OAuth2($testConfig);
+        $o->setCode('an_auth_code');
+        $request = $o->generateCredentialsRequest();
+        $fields = Psr7\parse_query((string)$request->getBody());
+        $this->assertEquals('a_client_secret', $fields['client_secret']);
+    }
+
+    public function testClientSecretAddedIfSetForRefreshTokenRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $testConfig['clientSecret'] = 'a_client_secret';
+        $o = new OAuth2($testConfig);
+        $o->setRefreshToken('a_refresh_token');
+        $request = $o->generateCredentialsRequest();
+        $fields = Psr7\parse_query((string)$request->getBody());
+        $this->assertEquals('a_client_secret', $fields['client_secret']);
+    }
+
+    public function testClientSecretAddedIfSetForPasswordRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $testConfig['clientSecret'] = 'a_client_secret';
+        $o = new OAuth2($testConfig);
+        $o->setUsername('a_username');
+        $o->setPassword('a_password');
+        $request = $o->generateCredentialsRequest();
+        $fields = Psr7\parse_query((string)$request->getBody());
+        $this->assertEquals('a_client_secret', $fields['client_secret']);
+    }
+
+    public function testGeneratesAssertionRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $o = new OAuth2($testConfig);
+        $o->setSigningKey('a_key');
+        $o->setSigningAlgorithm('HS256');
+
+        // Generate the request and confirm that it's correct.
+        $req = $o->generateCredentialsRequest();
+        $this->assertInstanceOf('Psr\Http\Message\RequestInterface', $req);
+        $this->assertEquals('POST', $req->getMethod());
+        $fields = Psr7\parse_query((string)$req->getBody());
+        $this->assertEquals(OAuth2::JWT_URN, $fields['grant_type']);
+        $this->assertTrue(array_key_exists('assertion', $fields));
+    }
+
+    public function testGeneratesExtendedRequests()
+    {
+        $testConfig = $this->tokenRequestMinimal;
+        $o = new OAuth2($testConfig);
+        $o->setGrantType('urn:my_test_grant_type');
+        $o->setExtensionParams(['my_param' => 'my_value']);
+
+        // Generate the request and confirm that it's correct.
+        $req = $o->generateCredentialsRequest();
+        $this->assertInstanceOf('Psr\Http\Message\RequestInterface', $req);
+        $this->assertEquals('POST', $req->getMethod());
+        $fields = Psr7\parse_query((string)$req->getBody());
+        $this->assertEquals('my_value', $fields['my_param']);
+        $this->assertEquals('urn:my_test_grant_type', $fields['grant_type']);
+    }
+}
+
+class OAuth2FetchAuthTokenTest extends \PHPUnit_Framework_TestCase
+{
+    private $fetchAuthTokenMinimal = [
+        'tokenCredentialUri' => 'https://tokens_r_us/test',
+        'scope' => 'https://www.googleapis.com/auth/userinfo.profile',
+        'signingKey' => 'example_key',
+        'signingAlgorithm' => 'HS256',
+        'issuer' => 'app@example.com',
+        'audience' => 'accounts.google.com',
+        'clientId' => 'aClientID',
+    ];
+
+    /**
+     * @expectedException GuzzleHttp\Exception\ClientException
+     */
+    public function testFailsOn400()
+    {
+        $testConfig = $this->fetchAuthTokenMinimal;
+        $httpHandler = getHandler([
+            buildResponse(400),
+        ]);
+        $o = new OAuth2($testConfig);
+        $o->fetchAuthToken($httpHandler);
+    }
+
+    /**
+     * @expectedException GuzzleHttp\Exception\ServerException
+     */
+    public function testFailsOn500()
+    {
+        $testConfig = $this->fetchAuthTokenMinimal;
+        $httpHandler = getHandler([
+            buildResponse(500),
+        ]);
+        $o = new OAuth2($testConfig);
+        $o->fetchAuthToken($httpHandler);
+    }
+
+    /**
+     * @expectedException Exception
+     * @expectedExceptionMessage Invalid JSON response
+     */
+    public function testFailsOnNoContentTypeIfResponseIsNotJSON()
+    {
+        $testConfig = $this->fetchAuthTokenMinimal;
+        $notJson = '{"foo": , this is cannot be passed as json" "bar"}';
+        $httpHandler = getHandler([
+            buildResponse(200, [], Psr7\stream_for($notJson)),
+        ]);
+        $o = new OAuth2($testConfig);
+        $o->fetchAuthToken($httpHandler);
+    }
+
+    public function testFetchesJsonResponseOnNoContentTypeOK()
+    {
+        $testConfig = $this->fetchAuthTokenMinimal;
+        $json = '{"foo": "bar"}';
+        $httpHandler = getHandler([
+            buildResponse(200, [], Psr7\stream_for($json)),
+        ]);
+        $o = new OAuth2($testConfig);
+        $tokens = $o->fetchAuthToken($httpHandler);
+        $this->assertEquals($tokens['foo'], 'bar');
+    }
+
+    public function testFetchesFromFormEncodedResponseOK()
+    {
+        $testConfig = $this->fetchAuthTokenMinimal;
+        $json = 'foo=bar&spice=nice';
+        $httpHandler = getHandler([
+            buildResponse(
+                200,
+                ['Content-Type' => 'application/x-www-form-urlencoded'],
+                Psr7\stream_for($json)
+            ),
+        ]);
+        $o = new OAuth2($testConfig);
+        $tokens = $o->fetchAuthToken($httpHandler);
+        $this->assertEquals($tokens['foo'], 'bar');
+        $this->assertEquals($tokens['spice'], 'nice');
+    }
+
+    public function testUpdatesTokenFieldsOnFetch()
+    {
+        $testConfig = $this->fetchAuthTokenMinimal;
+        $wanted_updates = [
+            'expires_at' => '1',
+            'expires_in' => '57',
+            'issued_at' => '2',
+            'access_token' => 'an_access_token',
+            'id_token' => 'an_id_token',
+            'refresh_token' => 'a_refresh_token',
+        ];
+        $json = json_encode($wanted_updates);
+        $httpHandler = getHandler([
+            buildResponse(200, [], Psr7\stream_for($json)),
+        ]);
+        $o = new OAuth2($testConfig);
+        $this->assertNull($o->getExpiresAt());
+        $this->assertNull($o->getExpiresIn());
+        $this->assertNull($o->getIssuedAt());
+        $this->assertNull($o->getAccessToken());
+        $this->assertNull($o->getIdToken());
+        $this->assertNull($o->getRefreshToken());
+        $tokens = $o->fetchAuthToken($httpHandler);
+        $this->assertEquals(1, $o->getExpiresAt());
+        $this->assertEquals(57, $o->getExpiresIn());
+        $this->assertEquals(2, $o->getIssuedAt());
+        $this->assertEquals('an_access_token', $o->getAccessToken());
+        $this->assertEquals('an_id_token', $o->getIdToken());
+        $this->assertEquals('a_refresh_token', $o->getRefreshToken());
+    }
+
+    public function testUpdatesTokenFieldsOnFetchMissingRefreshToken()
+    {
+        $testConfig = $this->fetchAuthTokenMinimal;
+        $testConfig['refresh_token'] = 'a_refresh_token';
+        $wanted_updates = [
+            'expires_at' => '1',
+            'expires_in' => '57',
+            'issued_at' => '2',
+            'access_token' => 'an_access_token',
+            'id_token' => 'an_id_token',
+        ];
+        $json = json_encode($wanted_updates);
+        $httpHandler = getHandler([
+            buildResponse(200, [], Psr7\stream_for($json)),
+        ]);
+        $o = new OAuth2($testConfig);
+        $this->assertNull($o->getExpiresAt());
+        $this->assertNull($o->getExpiresIn());
+        $this->assertNull($o->getIssuedAt());
+        $this->assertNull($o->getAccessToken());
+        $this->assertNull($o->getIdToken());
+        $this->assertEquals('a_refresh_token', $o->getRefreshToken());
+        $tokens = $o->fetchAuthToken($httpHandler);
+        $this->assertEquals(1, $o->getExpiresAt());
+        $this->assertEquals(57, $o->getExpiresIn());
+        $this->assertEquals(2, $o->getIssuedAt());
+        $this->assertEquals('an_access_token', $o->getAccessToken());
+        $this->assertEquals('an_id_token', $o->getIdToken());
+        $this->assertEquals('a_refresh_token', $o->getRefreshToken());
+    }
+}
+
+class OAuth2VerifyIdTokenTest extends \PHPUnit_Framework_TestCase
+{
+    private $publicKey;
+    private $privateKey;
+    private $verifyIdTokenMinimal = [
+        'scope' => 'https://www.googleapis.com/auth/userinfo.profile',
+        'audience' => 'myaccount.on.host.issuer.com',
+        'issuer' => 'an.issuer.com',
+        'clientId' => 'myaccount.on.host.issuer.com',
+    ];
+
+    public function setUp()
+    {
+        $this->publicKey =
+            file_get_contents(__DIR__ . '/fixtures' . '/public.pem');
+        $this->privateKey =
+            file_get_contents(__DIR__ . '/fixtures' . '/private.pem');
+    }
+
+    /**
+     * @expectedException UnexpectedValueException
+     */
+    public function testFailsIfIdTokenIsInvalid()
+    {
+        $testConfig = $this->verifyIdTokenMinimal;
+        $not_a_jwt = 'not a jot';
+        $o = new OAuth2($testConfig);
+        $o->setIdToken($not_a_jwt);
+        $o->verifyIdToken($this->publicKey);
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfAudienceIsMissing()
+    {
+        $testConfig = $this->verifyIdTokenMinimal;
+        $now = time();
+        $origIdToken = [
+            'issuer' => $testConfig['issuer'],
+            'exp' => $now + 65, // arbitrary
+            'iat' => $now,
+        ];
+        $o = new OAuth2($testConfig);
+        $jwtIdToken = $this->jwtEncode($origIdToken, $this->privateKey, 'RS256');
+        $o->setIdToken($jwtIdToken);
+        $o->verifyIdToken($this->publicKey, ['RS256']);
+    }
+
+    /**
+     * @expectedException DomainException
+     */
+    public function testFailsIfAudienceIsWrong()
+    {
+        $now = time();
+        $testConfig = $this->verifyIdTokenMinimal;
+        $origIdToken = [
+            'aud' => 'a different audience',
+            'iss' => $testConfig['issuer'],
+            'exp' => $now + 65, // arbitrary
+            'iat' => $now,
+        ];
+        $o = new OAuth2($testConfig);
+        $jwtIdToken = $this->jwtEncode($origIdToken, $this->privateKey, 'RS256');
+        $o->setIdToken($jwtIdToken);
+        $o->verifyIdToken($this->publicKey, ['RS256']);
+    }
+
+    public function testShouldReturnAValidIdToken()
+    {
+        $testConfig = $this->verifyIdTokenMinimal;
+        $now = time();
+        $origIdToken = [
+            'aud' => $testConfig['audience'],
+            'iss' => $testConfig['issuer'],
+            'exp' => $now + 65, // arbitrary
+            'iat' => $now,
+        ];
+        $o = new OAuth2($testConfig);
+        $alg = 'RS256';
+        $jwtIdToken = $this->jwtEncode($origIdToken, $this->privateKey, $alg);
+        $o->setIdToken($jwtIdToken);
+        $roundTrip = $o->verifyIdToken($this->publicKey, array($alg));
+        $this->assertEquals($origIdToken['aud'], $roundTrip->aud);
+    }
+
+    private function jwtEncode()
+    {
+        $args = func_get_args();
+        $class = 'JWT';
+        if (class_exists('Firebase\JWT\JWT')) {
+            $class = 'Firebase\JWT\JWT';
+        }
+
+        return call_user_func_array("$class::encode", $args);
+    }
+}

vendor/google/auth/tests/Subscriber/AuthTokenSubscriberTest.php

@@ -0,0 +1,325 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\FetchAuthTokenCache;
+use Google\Auth\Subscriber\AuthTokenSubscriber;
+use GuzzleHttp\Client;
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Transaction;
+
+class AuthTokenSubscriberTest extends BaseTest
+{
+    private $mockFetcher;
+    private $mockCacheItem;
+    private $mockCache;
+
+    protected function setUp()
+    {
+        $this->onlyGuzzle5();
+
+        $this->mockFetcher =
+            $this
+                ->getMockBuilder('Google\Auth\FetchAuthTokenInterface')
+                ->getMock();
+        $this->mockCacheItem =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemInterface')
+                ->getMock();
+        $this->mockCache =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemPoolInterface')
+                ->getMock();
+    }
+
+    public function testSubscribesToEvents()
+    {
+        $a = new AuthTokenSubscriber($this->mockFetcher);
+        $this->assertArrayHasKey('before', $a->getEvents());
+    }
+
+    public function testOnlyTouchesWhenAuthConfigScoped()
+    {
+        $s = new AuthTokenSubscriber($this->mockFetcher);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'not_google_auth']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertSame($request->getHeader('Authorization'), '');
+    }
+
+    public function testAddsTheTokenAsAnAuthorizationHeader()
+    {
+        $authResult = ['access_token' => '1/abcdef1234567890'];
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+
+        // Run the test.
+        $a = new AuthTokenSubscriber($this->mockFetcher);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'google_auth']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $a->onBefore($before);
+        $this->assertSame($request->getHeader('Authorization'),
+            'Bearer 1/abcdef1234567890');
+    }
+
+    public function testDoesNotAddAnAuthorizationHeaderOnNoAccessToken()
+    {
+        $authResult = ['not_access_token' => '1/abcdef1234567890'];
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+
+        // Run the test.
+        $a = new AuthTokenSubscriber($this->mockFetcher);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'google_auth']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $a->onBefore($before);
+        $this->assertSame($request->getHeader('Authorization'), '');
+    }
+
+    public function testUsesCachedAuthToken()
+    {
+        $cacheKey = 'myKey';
+        $cachedValue = '2/abcdef1234567890';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->never())
+            ->method('fetchAuthToken');
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+
+        // Run the test.
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            null,
+            $this->mockCache
+        );
+        $a = new AuthTokenSubscriber($cachedFetcher);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'google_auth']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $a->onBefore($before);
+        $this->assertSame($request->getHeader('Authorization'),
+            'Bearer 2/abcdef1234567890');
+    }
+
+    public function testGetsCachedAuthTokenUsingCachePrefix()
+    {
+        $prefix = 'test_prefix_';
+        $cacheKey = 'myKey';
+        $cachedValue = '2/abcdef1234567890';
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->never())
+            ->method('fetchAuthToken');
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+
+        // Run the test
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix],
+            $this->mockCache
+        );
+        $a = new AuthTokenSubscriber($cachedFetcher);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'google_auth']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $a->onBefore($before);
+        $this->assertSame($request->getHeader('Authorization'),
+            'Bearer 2/abcdef1234567890');
+    }
+
+    public function testShouldSaveValueInCacheWithCacheOptions()
+    {
+        $prefix = 'test_prefix_';
+        $lifetime = '70707';
+        $cacheKey = 'myKey';
+        $token = '1/abcdef1234567890';
+        $authResult = ['access_token' => $token];
+        $this->mockCacheItem
+            ->expects($this->any())
+            ->method('get')
+            ->will($this->returnValue(null));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($this->equalTo($token))
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('expiresAfter')
+            ->with($this->equalTo($lifetime));
+        $this->mockCache
+            ->expects($this->exactly(2))
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+
+        // Run the test
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix, 'lifetime' => $lifetime],
+            $this->mockCache
+        );
+        $a = new AuthTokenSubscriber($cachedFetcher);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'google_auth']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $a->onBefore($before);
+        $this->assertSame($request->getHeader('Authorization'),
+            'Bearer 1/abcdef1234567890');
+    }
+
+    /** @dataProvider provideShouldNotifyTokenCallback */
+    public function testShouldNotifyTokenCallback(callable $tokenCallback)
+    {
+        $prefix = 'test_prefix_';
+        $cacheKey = 'myKey';
+        $token = '1/abcdef1234567890';
+        $authResult = ['access_token' => $token];
+        $this->mockCacheItem
+            ->expects($this->any())
+            ->method('get')
+            ->will($this->returnValue(null));
+        $this->mockCache
+            ->expects($this->any())
+            ->method('getItem')
+            ->with($this->equalTo($prefix . $cacheKey))
+            ->will($this->returnValue($this->mockCacheItem));
+        $this->mockFetcher
+            ->expects($this->any())
+            ->method('getCacheKey')
+            ->will($this->returnValue($cacheKey));
+        $this->mockFetcher
+            ->expects($this->once())
+            ->method('fetchAuthToken')
+            ->will($this->returnValue($authResult));
+
+        SubscriberCallback::$expectedKey = $this->getValidKeyName($prefix . $cacheKey);
+        SubscriberCallback::$expectedValue = $token;
+        SubscriberCallback::$called = false;
+
+        // Run the test
+        $cachedFetcher = new FetchAuthTokenCache(
+            $this->mockFetcher,
+            ['prefix' => $prefix],
+            $this->mockCache
+        );
+        $a = new AuthTokenSubscriber(
+            $cachedFetcher,
+            null,
+            $tokenCallback
+        );
+
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'google_auth']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $a->onBefore($before);
+        $this->assertTrue(SubscriberCallback::$called);
+    }
+
+    public function provideShouldNotifyTokenCallback()
+    {
+        SubscriberCallback::$phpunit = $this;
+        $anonymousFunc = function ($key, $value) {
+            SubscriberCallback::staticInvoke($key, $value);
+        };
+        return [
+            ['Google\Auth\Tests\SubscriberCallbackFunction'],
+            ['Google\Auth\Tests\SubscriberCallback::staticInvoke'],
+            [['Google\Auth\Tests\SubscriberCallback', 'staticInvoke']],
+            [$anonymousFunc],
+            [[new SubscriberCallback, 'staticInvoke']],
+            [[new SubscriberCallback, 'methodInvoke']],
+            [new SubscriberCallback],
+        ];
+    }
+}
+
+class SubscriberCallback
+{
+    public static $phpunit;
+    public static $expectedKey;
+    public static $expectedValue;
+    public static $called = false;
+
+    public function __invoke($key, $value)
+    {
+        self::$phpunit->assertEquals(self::$expectedKey, $key);
+        self::$phpunit->assertEquals(self::$expectedValue, $value);
+        self::$called = true;
+    }
+
+    public function methodInvoke($key, $value)
+    {
+        return $this($key, $value);
+    }
+
+    public static function staticInvoke($key, $value)
+    {
+        $instance = new self();
+        return $instance($key, $value);
+    }
+}
+
+function SubscriberCallbackFunction($key, $value)
+{
+    return SubscriberCallback::staticInvoke($key, $value);
+}

vendor/google/auth/tests/Subscriber/ScopedAccessTokenSubscriberTest.php

@@ -0,0 +1,238 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\Subscriber\ScopedAccessTokenSubscriber;
+use GuzzleHttp\Client;
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Transaction;
+
+class ScopedAccessTokenSubscriberTest extends BaseTest
+{
+    const TEST_SCOPE = 'https://www.googleapis.com/auth/cloud-taskqueue';
+
+    private $mockCacheItem;
+    private $mockCache;
+    private $mockRequest;
+
+    protected function setUp()
+    {
+        $this->onlyGuzzle5();
+
+        $this->mockCacheItem =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemInterface')
+                ->getMock();
+        $this->mockCache =
+            $this
+                ->getMockBuilder('Psr\Cache\CacheItemPoolInterface')
+                ->getMock();
+        $this->mockRequest =
+            $this
+                ->getMockBuilder('GuzzleHttp\Psr7\Request')
+                ->disableOriginalConstructor()
+                ->getMock();
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRequiresScopeAsAStringOrArray()
+    {
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '1/abcdef1234567890';
+        };
+        new ScopedAccessTokenSubscriber($fakeAuthFunc, new \stdClass(), array());
+    }
+
+    public function testSubscribesToEvents()
+    {
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '1/abcdef1234567890';
+        };
+        $s = new ScopedAccessTokenSubscriber($fakeAuthFunc, self::TEST_SCOPE, array());
+        $this->assertArrayHasKey('before', $s->getEvents());
+    }
+
+    public function testAddsTheTokenAsAnAuthorizationHeader()
+    {
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '1/abcdef1234567890';
+        };
+        $s = new ScopedAccessTokenSubscriber($fakeAuthFunc, self::TEST_SCOPE, array());
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'scoped']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertSame(
+            'Bearer 1/abcdef1234567890',
+            $request->getHeader('Authorization')
+        );
+    }
+
+    public function testUsesCachedAuthToken()
+    {
+        $cachedValue = '2/abcdef1234567890';
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '';
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($this->getValidKeyName(self::TEST_SCOPE))
+            ->will($this->returnValue($this->mockCacheItem));
+
+        // Run the test
+        $s = new ScopedAccessTokenSubscriber($fakeAuthFunc, self::TEST_SCOPE, array(),
+            $this->mockCache);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'scoped']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertSame(
+            'Bearer 2/abcdef1234567890',
+            $request->getHeader('Authorization')
+        );
+    }
+
+    public function testGetsCachedAuthTokenUsingCachePrefix()
+    {
+        $prefix = 'test_prefix_';
+        $cachedValue = '2/abcdef1234567890';
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '';
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue($cachedValue));
+        $this->mockCache
+            ->expects($this->once())
+            ->method('getItem')
+            ->with($prefix . $this->getValidKeyName(self::TEST_SCOPE))
+            ->will($this->returnValue($this->mockCacheItem));
+
+        // Run the test
+        $s = new ScopedAccessTokenSubscriber($fakeAuthFunc, self::TEST_SCOPE,
+            ['prefix' => $prefix],
+            $this->mockCache);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'scoped']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertSame(
+            'Bearer 2/abcdef1234567890',
+            $request->getHeader('Authorization')
+        );
+    }
+
+    public function testShouldSaveValueInCache()
+    {
+        $token = '2/abcdef1234567890';
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '2/abcdef1234567890';
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($this->equalTo($token))
+            ->will($this->returnValue(false));
+        $this->mockCache
+            ->expects($this->exactly(2))
+            ->method('getItem')
+            ->with($this->getValidKeyName(self::TEST_SCOPE))
+            ->will($this->returnValue($this->mockCacheItem));
+        $s = new ScopedAccessTokenSubscriber($fakeAuthFunc, self::TEST_SCOPE, array(),
+            $this->mockCache);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'scoped']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertSame(
+            'Bearer 2/abcdef1234567890',
+            $request->getHeader('Authorization')
+        );
+    }
+
+    public function testShouldSaveValueInCacheWithCacheOptions()
+    {
+        $token = '2/abcdef1234567890';
+        $prefix = 'test_prefix_';
+        $lifetime = '70707';
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '2/abcdef1234567890';
+        };
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('get')
+            ->will($this->returnValue(false));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('set')
+            ->with($this->equalTo($token));
+        $this->mockCacheItem
+            ->expects($this->once())
+            ->method('expiresAfter')
+            ->with($this->equalTo($lifetime));
+        $this->mockCache
+            ->expects($this->exactly(2))
+            ->method('getItem')
+            ->with($prefix . $this->getValidKeyName(self::TEST_SCOPE))
+            ->will($this->returnValue($this->mockCacheItem));
+
+        // Run the test
+        $s = new ScopedAccessTokenSubscriber($fakeAuthFunc, self::TEST_SCOPE,
+            ['prefix' => $prefix, 'lifetime' => $lifetime],
+            $this->mockCache);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'scoped']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertSame(
+            'Bearer 2/abcdef1234567890',
+            $request->getHeader('Authorization')
+        );
+    }
+
+    public function testOnlyTouchesWhenAuthConfigScoped()
+    {
+        $fakeAuthFunc = function ($unused_scopes) {
+            return '1/abcdef1234567890';
+        };
+        $s = new ScopedAccessTokenSubscriber($fakeAuthFunc, self::TEST_SCOPE, array());
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'notscoped']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertSame('', $request->getHeader('Authorization'));
+    }
+}

vendor/google/auth/tests/Subscriber/SimpleSubscriberTest.php

@@ -0,0 +1,69 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Auth\Tests;
+
+use Google\Auth\Subscriber\SimpleSubscriber;
+use GuzzleHttp\Client;
+use GuzzleHttp\Event\BeforeEvent;
+use GuzzleHttp\Transaction;
+
+class SimpleSubscriberTest extends BaseTest
+{
+    protected function setUp()
+    {
+        $this->onlyGuzzle5();
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testRequiresADeveloperKey()
+    {
+        new SimpleSubscriber(['not_key' => 'a test key']);
+    }
+
+    public function testSubscribesToEvents()
+    {
+        $events = (new SimpleSubscriber(['key' => 'a test key']))->getEvents();
+        $this->assertArrayHasKey('before', $events);
+    }
+
+    public function testAddsTheKeyToTheQuery()
+    {
+        $s = new SimpleSubscriber(['key' => 'test_key']);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'simple']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertCount(1, $request->getQuery());
+        $this->assertTrue($request->getQuery()->hasKey('key'));
+        $this->assertSame($request->getQuery()->get('key'), 'test_key');
+    }
+
+    public function testOnlyTouchesWhenAuthConfigIsSimple()
+    {
+        $s = new SimpleSubscriber(['key' => 'test_key']);
+        $client = new Client();
+        $request = $client->createRequest('GET', 'http://testing.org',
+            ['auth' => 'notsimple']);
+        $before = new BeforeEvent(new Transaction($client, $request));
+        $s->onBefore($before);
+        $this->assertCount(0, $request->getQuery());
+    }
+}

vendor/google/auth/tests/bootstrap.php

@@ -0,0 +1,55 @@
+<?php
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+error_reporting(E_ALL | E_STRICT);
+require dirname(__DIR__) . '/vendor/autoload.php';
+date_default_timezone_set('UTC');
+
+// autoload base test
+require_once __DIR__ . '/BaseTest.php';
+
+function buildResponse($code, array $headers = [], $body = null)
+{
+    if (class_exists('GuzzleHttp\HandlerStack')) {
+        return new \GuzzleHttp\Psr7\Response($code, $headers, $body);
+    }
+
+    return new \GuzzleHttp\Message\Response(
+        $code,
+        $headers,
+        \GuzzleHttp\Stream\Stream::factory((string)$body)
+    );
+}
+
+function getHandler(array $mockResponses = [])
+{
+    if (class_exists('GuzzleHttp\HandlerStack')) {
+        $mock = new \GuzzleHttp\Handler\MockHandler($mockResponses);
+
+        $handler = \GuzzleHttp\HandlerStack::create($mock);
+        $client = new \GuzzleHttp\Client(['handler' => $handler]);
+
+        return new \Google\Auth\HttpHandler\Guzzle6HttpHandler($client);
+    }
+
+    $client = new \GuzzleHttp\Client();
+    $client->getEmitter()->attach(
+        new \GuzzleHttp\Subscriber\Mock($mockResponses)
+    );
+
+    return new \Google\Auth\HttpHandler\Guzzle5HttpHandler($client);
+}

vendor/google/auth/tests/fixtures/.config/gcloud/application_default_credentials.json

@@ -0,0 +1,7 @@
+{
+  "private_key_id": "key123",
+  "private_key": "privatekey",
+  "client_email": "hello@youarecool.com",
+  "client_id": "client123",
+  "type": "service_account"
+}

vendor/google/auth/tests/fixtures/private.json

@@ -0,0 +1,7 @@
+{
+  "private_key_id": "key123",
+  "private_key": "privatekey",
+  "client_email": "hello@youarecool.com",
+  "client_id": "client123",
+  "type": "service_account"
+}

vendor/google/auth/tests/fixtures/private.pem

@@ -0,0 +1,15 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIICXQIBAAKBgQDzU+jLTzW6154Joezxrd2+5pCNYP0HcaMoYqEyXfNRpkNE7wrQ
+UEG830o4Qcaae2BhqZoujwSW7RkR6h0Fkd0WTR8h5J8rSGNHv/1jJoUUjP9iZ/5S
+FAyIIyEYfDPqtnA4iF1QWO2lXWlEFSuZjwM/8jBmeGzoiw17akNThIw8NwIDAQAB
+AoGATpboVloEAY/IdFX/QGOmfhTb1T3hG3lheBa695iOkO2BRo9qT7PMN6NqxlbA
+PX7ht0lfCfCZS+HSOg4CR50/6WXHMSmwlvcjGuDIDKWjviQTTYE77MlVBQHw9WzY
+PfiRBbtouyPGQtO4rk42zkIILC6exBZ1vKpRPOmTAnxrjCECQQD+56r6hYcS6GNp
+NOWyv0eVFMBX4iNWAsRf9JVVvGDz2rVuhnkNiN73vfffDWvSXkCydL1jFmalgdQD
+gm77UZQHAkEA9F+CauU0aZsJ1SthQ6H0sDQ+eNRUgnz4itnkSC2C20fZ3DaSpCMC
+0go81CcZOhftNO730ILqiS67C3d3rqLqUQJBAP10ROHMmz4Fq7MUUcClyPtHIuk/
+hXskTTZL76DMKmrN8NDxDLSUf38+eJRkt+z4osPOp/E6eN3gdXr32nox50kCQCl8
+hXGMU+eR0IuF/88xkY7Qb8KnmWlFuhQohZ7TSyHbAttl0GNZJkNuRYFm2duI8FZK
+M3wMnbCIZGy/7WuScOECQQCV+0yrf5dL1M2GHjJfwuTb00wRKalKQEH1v/kvE5vS
+FmdN7BPK5Ra50MaecMNoYqu9rmtyWRBn93dcvKrL57nY
+-----END RSA PRIVATE KEY-----

vendor/google/auth/tests/fixtures/public.pem

@@ -0,0 +1,6 @@
+-----BEGIN PUBLIC KEY-----
+MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDzU+jLTzW6154Joezxrd2+5pCN
+YP0HcaMoYqEyXfNRpkNE7wrQUEG830o4Qcaae2BhqZoujwSW7RkR6h0Fkd0WTR8h
+5J8rSGNHv/1jJoUUjP9iZ/5SFAyIIyEYfDPqtnA4iF1QWO2lXWlEFSuZjwM/8jBm
+eGzoiw17akNThIw8NwIDAQAB
+-----END PUBLIC KEY-----

vendor/google/auth/tests/fixtures2/.config/gcloud/application_default_credentials.json

@@ -0,0 +1,6 @@
+{
+  "client_id": "client123",
+  "client_secret": "clientSecret123",
+  "refresh_token": "refreshToken123",
+  "type": "authorized_user"
+}

vendor/google/auth/tests/fixtures2/private.json

@@ -0,0 +1,6 @@
+{
+  "client_id": "client123",
+  "client_secret": "clientSecret123",
+  "refresh_token": "refreshToken123",
+  "type": "authorized_user"
+}

vendor/google/auth/tests/mocks/AppIdentityService.php

@@ -0,0 +1,19 @@
+<?php
+
+namespace google\appengine\api\app_identity;
+
+class AppIdentityService
+{
+    public static $scope;
+    public static $accessToken = array(
+        'access_token' => 'xyz',
+        'expiration_time' => '2147483646',
+    );
+
+    public static function getAccessToken($scope)
+    {
+        self::$scope = $scope;
+
+        return self::$accessToken;
+    }
+}