def request(
self,
method,
path,
query_params=None,
body=None,
authenticator=None,
headers=None,
):
if authenticator:
authenticator()
if method == transport.HttpMethod.POST:
if path == "/login":
token = "AdminAccessToken"
expected_header = {"Content-Type": "application/x-www-form-urlencoded"}
if headers != expected_header:
raise TypeError(f"Must send {expected_header}")
elif path == "/login/5":
token = "UserAccessToken"
access_token = json.dumps(
{"access_token": token, "token_type": "Bearer", "expires_in": 3600}
)
response = transport.Response(
ok=True,
value=bytes(access_token, encoding="utf-8"),
response_mode=transport.ResponseMode.STRING,
)
elif (method == transport.HttpMethod.DELETE) and (path == "/logout"):
response = transport.Response(
ok=True, value=b"", response_mode=transport.ResponseMode.STRING
)
else:
raise TypeError("Bad transport layer call")
return response
def request(
self,
method: transport.HttpMethod,
path: str,
query_params: Optional[MutableMapping[str, str]] = None,
body: Optional[bytes] = None,
authenticator: Optional[Callable[[], Dict[str, str]]] = None,
headers: Optional[MutableMapping[str, str]] = None,
) -> transport.Response:
url = f"{self.api_path}{path}"
if headers is None:
headers = {}
if authenticator:
headers.update(authenticator())
logging.info("%s(%s)", method.name, url)
try:
resp = self.session.request(method.name,
url,
params=query_params,
data=body,
headers=headers)
except IOError as exc:
ret = transport.Response(False, str(exc))
else:
if resp.ok:
ret = transport.Response(True, resp.text)
else:
ret = transport.Response(False, resp.text)
return ret
def request(
self,
method,
path,
query_params=None,
body=None,
authenticator=None,
transport_options=None,
):
if authenticator:
authenticator(transport_options)
if method == transport.HttpMethod.POST:
if path.endswith(("login", "login/5")):
if path.endswith("login"):
token = "AdminAccessToken"
expected_headers = {
"Content-Type": "application/x-www-form-urlencoded"
}
expected_headers.update(
transport_options.get("headers", {}))
if transport_options["headers"] != expected_headers:
raise TypeError(f"Must send {expected_headers}")
else:
token = "UserAccessToken"
access_token = json.dumps({
"access_token": token,
"token_type": "Bearer",
"expires_in": 3600
})
response = transport.Response(
ok=True,
value=bytes(access_token, encoding="utf-8"),
response_mode=transport.ResponseMode.STRING,
)
elif path.endswith("/api/token"):
access_token = {
"access_token": "anOauthToken",
"token_type": "Bearer",
"expires_in": 3600,
"refresh_token": "anOauthRefreshToken",
}
response = transport.Response(
ok=True,
value=json.dumps(access_token).encode("utf8"),
response_mode=transport.ResponseMode.STRING,
)
elif method == transport.HttpMethod.DELETE and path.endswith("logout"):
response = transport.Response(
ok=True,
value=b"",
response_mode=transport.ResponseMode.STRING)
else:
raise TypeError("Bad transport layer call")
return response
def request(
self,
method: transport.HttpMethod,
path: str,
query_params: Optional[MutableMapping[str, str]] = None,
body: Optional[bytes] = None,
authenticator: transport.TAuthenticator = None,
transport_options: Optional[transport.TransportOptions] = None,
) -> transport.Response:
headers = {}
timeout = self.settings.timeout
if authenticator:
headers.update(authenticator(transport_options or {}))
if transport_options:
if transport_options.get("headers"):
headers.update(transport_options["headers"])
if transport_options.get("timeout"):
timeout = transport_options["timeout"]
self.logger.info("%s(%s)", method.name, path)
try:
resp = self.session.request(
method.name,
path,
auth=NullAuth(),
params=query_params,
data=body,
headers=headers,
timeout=timeout,
)
except IOError as exc:
ret = transport.Response(
False,
bytes(str(exc), encoding="utf-8"),
transport.ResponseMode.STRING,
)
else:
ret = transport.Response(
resp.ok,
resp.content,
transport.response_mode(resp.headers.get("content-type")),
)
encoding = cast(
Optional[str],
requests.utils.get_encoding_from_headers(resp.headers))
if encoding:
ret.encoding = encoding
return ret
def request(
self,
method: transport.HttpMethod,
path: str,
query_params: Optional[MutableMapping[str, str]] = None,
body: Optional[bytes] = None,
authenticator: Optional[Callable[[], Dict[str, str]]] = None,
headers: Optional[MutableMapping[str, str]] = None,
transport_options: Optional[transport.TransportSettings] = None,
) -> transport.Response:
url = f"{self.api_path}{path}"
if headers is None:
headers = {}
if authenticator:
headers.update(authenticator())
timeout = self.settings.timeout
if transport_options:
timeout = transport_options.timeout
logging.info("%s(%s)", method.name, url)
try:
resp = self.session.request(
method.name,
url,
auth=NullAuth(),
params=query_params,
data=body,
headers=headers,
timeout=timeout,
)
except IOError as exc:
ret = transport.Response(
False,
bytes(str(exc), encoding="utf-8"),
transport.ResponseMode.STRING,
)
else:
ret = transport.Response(
resp.ok,
resp.content,
transport.response_mode(resp.headers.get("content-type")),
)
encoding = cast(
Optional[str],
requests.utils.get_encoding_from_headers(resp.headers))
if encoding:
ret.encoding = encoding
return ret
def test_env_variables_override_config_file_credentials(
auth_session: auth.AuthSession,
mocker,
monkeypatch,
test_env_client_id: str,
test_env_client_secret: str,
expected_id: str,
expected_secret: str,
):
monkeypatch.setenv("LOOKERSDK_CLIENT_ID", test_env_client_id)
monkeypatch.setenv("LOOKERSDK_CLIENT_SECRET", test_env_client_secret)
mocked_request = mocker.patch.object(MockTransport, "request")
mocked_request.return_value = transport.Response(
ok=True,
value=json.dumps({
"access_token": "AdminAccessToken",
"token_type": "Bearer",
"expires_in": 3600,
}).encode("utf-8"),
response_mode=transport.ResponseMode.STRING,
)
auth_session.authenticate()
expected_body = urllib.parse.urlencode({
"client_id": expected_id,
"client_secret": expected_secret
}).encode("utf-8")
mocked_request.assert_called()
actual_request_body = mocked_request.call_args[1]["body"]
assert actual_request_body == expected_body
def test_return_raises_an_SDKError_for_bad_responses(api):
with pytest.raises(error.SDKError) as exc:
api._return(
transport.Response(
ok=False,
value=b"some error message",
response_mode=transport.ResponseMode.STRING,
),
str,
)
assert "some error message" in str(exc.value)
],
)
def test_get_serialized(
api: api_methods.APIMethods, test_body: api_methods.TBody, expected: Optional[bytes]
):
actual = api._get_serialized(test_body)
assert actual == expected
@pytest.mark.parametrize(
"test_response, test_structure, expected",
[
(
transport.Response(
ok=True,
value=bytes(range(0, 10)),
response_mode=transport.ResponseMode.BINARY,
),
Union[str, bytes],
bytes(range(0, 10)),
),
(
transport.Response(
ok=True,
value=b"some response text",
response_mode=transport.ResponseMode.STRING,
),
Union[str, bytes],
"some response text",
),
(
b'[{"workspace_id": "dev"}, {"workspace_id": "dev"}]',
),
],
)
def test_get_serialized(api: api_methods.APIMethods,
test_body: api_methods.TBody,
expected: Optional[bytes]):
actual = api._get_serialized(test_body)
assert actual == expected
@pytest.mark.parametrize( # type: ignore
"test_response, test_structure, expected",
[
(
transport.Response(ok=True, value="some response text"),
str,
"some response text",
),
(transport.Response(ok=True, value=""), None, None),
(
transport.Response(
ok=True,
value=(
json.dumps(
{ # type: ignore
"current_version": { # type: ignore
"full_version": "6.18.4",
"status": "fully functional",
"swagger_url": None,
"version": None,
