| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "topaz/auth_providers/oauth/oauth_response.h" |
| |
| #include <stdlib.h> |
| #include <string> |
| |
| #include "gtest/gtest.h" |
| #include "lib/fsl/socket/strings.h" |
| #include "src/lib/fxl/strings/string_number_conversions.h" |
| #include "peridot/lib/rapidjson/rapidjson.h" |
| |
| namespace auth_providers { |
| namespace oauth { |
| |
| using fuchsia::auth::AuthProviderStatus; |
| |
| namespace { |
| |
| namespace http = ::fuchsia::net::oldhttp; |
| |
| http::URLResponse FakeError(int32_t code, std::string reason) { |
| http::URLResponse response; |
| response.error = http::HttpError::New(); |
| response.error->code = code; |
| response.error->description = reason; |
| return response; |
| } |
| |
| http::URLResponse FakeSuccess(int32_t code, const std::string& body) { |
| http::URLResponse response; |
| response.body = http::URLBody::New(); |
| response.body->set_stream(fsl::WriteStringToSocket(body)); |
| response.status_code = code; |
| |
| http::HttpHeader content_length_header; |
| content_length_header.name = "content-length"; |
| content_length_header.value = fxl::NumberToString(body.size()); |
| response.headers.push_back(std::move(content_length_header)); |
| |
| return response; |
| } |
| |
| void VerifyOAuthResponse(OAuthResponse got, OAuthResponse want) { |
| EXPECT_EQ(want.status, got.status); |
| EXPECT_TRUE(got.error_description.find(want.error_description) != |
| std::string::npos); |
| |
| if (want.json_response.IsObject() && got.json_response.IsObject()) { |
| for (auto& m : want.json_response.GetObject()) { |
| auto key = m.name.GetString(); |
| rapidjson::Value::ConstMemberIterator itr = |
| got.json_response.FindMember(key); |
| EXPECT_TRUE(itr != got.json_response.MemberEnd()); |
| |
| if (m.value.IsString()) |
| EXPECT_EQ(got.json_response[key].GetString(), itr->value.GetString()); |
| if (m.value.IsUint64()) |
| EXPECT_EQ(got.json_response[key].GetUint64(), itr->value.GetUint64()); |
| if (m.value.IsInt()) |
| EXPECT_EQ(got.json_response[key].GetInt(), itr->value.GetInt()); |
| if (m.value.IsInt64()) |
| EXPECT_EQ(got.json_response[key].GetInt64(), itr->value.GetInt64()); |
| if (m.value.IsBool()) |
| EXPECT_EQ(got.json_response[key].GetBool(), itr->value.GetBool()); |
| if (m.value.IsArray()) { |
| for (uint i = 0; i < want.json_response[key].GetArray().Size(); i++) { |
| EXPECT_EQ(want.json_response[key].GetArray()[i], |
| got.json_response[key].GetArray()[i]); |
| } |
| } |
| } |
| } |
| } |
| |
| } // namespace |
| |
| class OAuthResponseTest : public ::testing::Test { |
| protected: |
| OAuthResponseTest() {} |
| |
| ~OAuthResponseTest() override {} |
| }; |
| |
| TEST_F(OAuthResponseTest, CheckParseOAuthResponse) { |
| rapidjson::Document no_json_body; |
| VerifyOAuthResponse(ParseOAuthResponse(FakeError(-2, "Bad request")), |
| OAuthResponse(AuthProviderStatus::NETWORK_ERROR, |
| "Bad request", std::move(no_json_body))); |
| |
| rapidjson::Document json_200; |
| json_200.Parse("{\"token\":\"xyz\"}"); |
| VerifyOAuthResponse( |
| ParseOAuthResponse( |
| FakeSuccess(200, modular::JsonValueToPrettyString(json_200))), |
| OAuthResponse(AuthProviderStatus::OK, "", std::move(json_200))); |
| |
| rapidjson::Document json_400; |
| json_400.Parse("{\"error\":\"invalid_grant\"}"); |
| VerifyOAuthResponse(ParseOAuthResponse(FakeSuccess( |
| 400, modular::JsonValueToPrettyString(json_400))), |
| OAuthResponse(AuthProviderStatus::REAUTH_REQUIRED, "400", |
| std::move(json_400))); |
| |
| rapidjson::Document json_400_br; |
| json_400_br.Parse("{\"error\":\"invalid_argument\"}"); |
| VerifyOAuthResponse(ParseOAuthResponse(FakeSuccess( |
| 400, modular::JsonValueToPrettyString(json_400_br))), |
| OAuthResponse(AuthProviderStatus::OAUTH_SERVER_ERROR, |
| "400", std::move(json_400_br))); |
| |
| rapidjson::Document json_401; |
| json_401.Parse("{\"error\":\"invalid_client\"}"); |
| VerifyOAuthResponse(ParseOAuthResponse(FakeSuccess( |
| 401, modular::JsonValueToPrettyString(json_401))), |
| OAuthResponse(AuthProviderStatus::OAUTH_SERVER_ERROR, |
| "401", std::move(json_401))); |
| |
| rapidjson::Document json_403; |
| json_403.Parse("{\"error\":\"access_denied\"}"); |
| VerifyOAuthResponse(ParseOAuthResponse(FakeSuccess( |
| 403, modular::JsonValueToPrettyString(json_403))), |
| OAuthResponse(AuthProviderStatus::OAUTH_SERVER_ERROR, |
| "403", std::move(json_403))); |
| } |
| |
| } // namespace oauth |
| } // namespace auth_providers |