171 lines
4.4 KiB
Python
171 lines
4.4 KiB
Python
# Copyright 2016 Google LLC
|
|
#
|
|
# 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.
|
|
|
|
import datetime
|
|
|
|
import pytest
|
|
from six.moves import urllib
|
|
|
|
from google.auth import _helpers
|
|
|
|
|
|
class SourceClass(object):
|
|
def func(self): # pragma: NO COVER
|
|
"""example docstring"""
|
|
|
|
|
|
def test_copy_docstring_success():
|
|
def func(): # pragma: NO COVER
|
|
pass
|
|
|
|
_helpers.copy_docstring(SourceClass)(func)
|
|
|
|
assert func.__doc__ == SourceClass.func.__doc__
|
|
|
|
|
|
def test_copy_docstring_conflict():
|
|
def func(): # pragma: NO COVER
|
|
"""existing docstring"""
|
|
pass
|
|
|
|
with pytest.raises(ValueError):
|
|
_helpers.copy_docstring(SourceClass)(func)
|
|
|
|
|
|
def test_copy_docstring_non_existing():
|
|
def func2(): # pragma: NO COVER
|
|
pass
|
|
|
|
with pytest.raises(AttributeError):
|
|
_helpers.copy_docstring(SourceClass)(func2)
|
|
|
|
|
|
def test_utcnow():
|
|
assert isinstance(_helpers.utcnow(), datetime.datetime)
|
|
|
|
|
|
def test_datetime_to_secs():
|
|
assert _helpers.datetime_to_secs(datetime.datetime(1970, 1, 1)) == 0
|
|
assert _helpers.datetime_to_secs(datetime.datetime(1990, 5, 29)) == 643939200
|
|
|
|
|
|
def test_to_bytes_with_bytes():
|
|
value = b"bytes-val"
|
|
assert _helpers.to_bytes(value) == value
|
|
|
|
|
|
def test_to_bytes_with_unicode():
|
|
value = u"string-val"
|
|
encoded_value = b"string-val"
|
|
assert _helpers.to_bytes(value) == encoded_value
|
|
|
|
|
|
def test_to_bytes_with_nonstring_type():
|
|
with pytest.raises(ValueError):
|
|
_helpers.to_bytes(object())
|
|
|
|
|
|
def test_from_bytes_with_unicode():
|
|
value = u"bytes-val"
|
|
assert _helpers.from_bytes(value) == value
|
|
|
|
|
|
def test_from_bytes_with_bytes():
|
|
value = b"string-val"
|
|
decoded_value = u"string-val"
|
|
assert _helpers.from_bytes(value) == decoded_value
|
|
|
|
|
|
def test_from_bytes_with_nonstring_type():
|
|
with pytest.raises(ValueError):
|
|
_helpers.from_bytes(object())
|
|
|
|
|
|
def _assert_query(url, expected):
|
|
parts = urllib.parse.urlsplit(url)
|
|
query = urllib.parse.parse_qs(parts.query)
|
|
assert query == expected
|
|
|
|
|
|
def test_update_query_params_no_params():
|
|
uri = "http://www.google.com"
|
|
updated = _helpers.update_query(uri, {"a": "b"})
|
|
assert updated == uri + "?a=b"
|
|
|
|
|
|
def test_update_query_existing_params():
|
|
uri = "http://www.google.com?x=y"
|
|
updated = _helpers.update_query(uri, {"a": "b", "c": "d&"})
|
|
_assert_query(updated, {"x": ["y"], "a": ["b"], "c": ["d&"]})
|
|
|
|
|
|
def test_update_query_replace_param():
|
|
base_uri = "http://www.google.com"
|
|
uri = base_uri + "?x=a"
|
|
updated = _helpers.update_query(uri, {"x": "b", "y": "c"})
|
|
_assert_query(updated, {"x": ["b"], "y": ["c"]})
|
|
|
|
|
|
def test_update_query_remove_param():
|
|
base_uri = "http://www.google.com"
|
|
uri = base_uri + "?x=a"
|
|
updated = _helpers.update_query(uri, {"y": "c"}, remove=["x"])
|
|
_assert_query(updated, {"y": ["c"]})
|
|
|
|
|
|
def test_scopes_to_string():
|
|
cases = [
|
|
("", ()),
|
|
("", []),
|
|
("", ("",)),
|
|
("", [""]),
|
|
("a", ("a",)),
|
|
("b", ["b"]),
|
|
("a b", ["a", "b"]),
|
|
("a b", ("a", "b")),
|
|
("a b", (s for s in ["a", "b"])),
|
|
]
|
|
for expected, case in cases:
|
|
assert _helpers.scopes_to_string(case) == expected
|
|
|
|
|
|
def test_string_to_scopes():
|
|
cases = [("", []), ("a", ["a"]), ("a b c d e f", ["a", "b", "c", "d", "e", "f"])]
|
|
|
|
for case, expected in cases:
|
|
assert _helpers.string_to_scopes(case) == expected
|
|
|
|
|
|
def test_padded_urlsafe_b64decode():
|
|
cases = [
|
|
("YQ==", b"a"),
|
|
("YQ", b"a"),
|
|
("YWE=", b"aa"),
|
|
("YWE", b"aa"),
|
|
("YWFhYQ==", b"aaaa"),
|
|
("YWFhYQ", b"aaaa"),
|
|
("YWFhYWE=", b"aaaaa"),
|
|
("YWFhYWE", b"aaaaa"),
|
|
]
|
|
|
|
for case, expected in cases:
|
|
assert _helpers.padded_urlsafe_b64decode(case) == expected
|
|
|
|
|
|
def test_unpadded_urlsafe_b64encode():
|
|
cases = [(b"", b""), (b"a", b"YQ"), (b"aa", b"YWE"), (b"aaa", b"YWFh")]
|
|
|
|
for case, expected in cases:
|
|
assert _helpers.unpadded_urlsafe_b64encode(case) == expected
|