From 83295c69edc5d2a6594c09fcd06eae7073753171 Mon Sep 17 00:00:00 2001 From: Victor Vazquez Date: Thu, 5 Aug 2021 16:20:29 -0700 Subject: [PATCH] Re implement keyvault keys (#2705) * updated-create-key with no protocol client --- .../keys/cryptography/cryptography_client.hpp | 27 +- .../inc/azure/keyvault/keys/key_client.hpp | 27 +- .../src/cryptography/cryptography_client.cpp | 177 ++++---- .../src/key_client.cpp | 392 ++++++++++-------- .../src/key_operation.cpp | 17 +- .../src/keyvault_protocol.cpp | 64 ++- .../src/private/key_constants.hpp | 11 + .../src/private/keyvault_protocol.hpp | 172 +------- .../test/ut/CMakeLists.txt | 1 - .../test/ut/mocked_transport_adapter_test.hpp | 10 +- .../test/ut/protocol_test.cpp | 26 -- 11 files changed, 409 insertions(+), 515 deletions(-) delete mode 100644 sdk/keyvault/azure-security-keyvault-keys/test/ut/protocol_test.cpp diff --git a/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/cryptography/cryptography_client.hpp b/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/cryptography/cryptography_client.hpp index 83da2d5a2..742a62d60 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/cryptography/cryptography_client.hpp +++ b/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/cryptography/cryptography_client.hpp @@ -9,13 +9,16 @@ #pragma once -#include -#include -#include - #include "azure/keyvault/keys/cryptography/cryptography_client_models.hpp" #include "azure/keyvault/keys/cryptography/cryptography_client_options.hpp" +#include +#include +#include +#include +#include +#include + #include #include #include @@ -33,9 +36,21 @@ namespace Azure { namespace Security { namespace KeyVault { * */ class CryptographyClient final { - private: - std::shared_ptr m_pipeline; + protected: Azure::Core::Url m_keyId; + std::string m_apiVersion; + std::shared_ptr m_pipeline; + + private: + Azure::Core::Http::Request CreateRequest( + Azure::Core::Http::HttpMethod method, + std::vector const& path = {}, + Azure::Core::IO::BodyStream* content = nullptr) const; + + std::unique_ptr SendCryptoRequest( + std::vector const& path, + std::string const& payload, + Azure::Core::Context const& context) const; public: /** diff --git a/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/key_client.hpp b/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/key_client.hpp index c0c955f3e..5830a15d0 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/key_client.hpp +++ b/sdk/keyvault/azure-security-keyvault-keys/inc/azure/keyvault/keys/key_client.hpp @@ -12,6 +12,13 @@ #include "azure/keyvault/keys/key_client_models.hpp" #include "azure/keyvault/keys/key_client_options.hpp" +#include +#include +#include +#include +#include +#include + #include #include @@ -33,7 +40,9 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { { protected: // Using a shared pipeline for a client to share it with LRO (like delete key) - std::shared_ptr m_pipeline; + Azure::Core::Url m_vaultUrl; + std::string m_apiVersion; + std::shared_ptr m_pipeline; public: /** @@ -59,7 +68,7 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { * * @param keyClient An existing key vault key client. */ - explicit KeyClient(KeyClient const& keyClient) : m_pipeline(keyClient.m_pipeline) {} + explicit KeyClient(KeyClient const& keyClient) = default; /** * @brief Gets the public part of a stored key. @@ -377,5 +386,19 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { Azure::Response ImportKey( ImportKeyOptions const& importKeyOptions, Azure::Core::Context const& context = Azure::Core::Context()) const; + + private: + std::unique_ptr SendRequest( + Azure::Core::Http::Request& request, + Azure::Core::Context const& context) const; + + Azure::Core::Http::Request CreateRequest( + Azure::Core::Http::HttpMethod method, + std::vector const& path = {}, + Azure::Core::IO::BodyStream* content = nullptr) const; + + Azure::Core::Http::Request ContinuationTokenRequest( + std::vector const& path, + const Azure::Nullable& NextPageToken) const; }; }}}} // namespace Azure::Security::KeyVault::Keys diff --git a/sdk/keyvault/azure-security-keyvault-keys/src/cryptography/cryptography_client.cpp b/sdk/keyvault/azure-security-keyvault-keys/src/cryptography/cryptography_client.cpp index 077ea819d..5e0074612 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/src/cryptography/cryptography_client.cpp +++ b/sdk/keyvault/azure-security-keyvault-keys/src/cryptography/cryptography_client.cpp @@ -1,8 +1,6 @@ // Copyright (c) Microsoft Corporation. All rights reserved. // SPDX-License-Identifier: MIT -#include -#include #include #include #include @@ -24,10 +22,12 @@ #include using namespace Azure::Security::KeyVault::Keys::Cryptography; +using namespace Azure::Security::KeyVault::Keys::_detail; using namespace Azure::Security::KeyVault::Keys::Cryptography::_detail; using namespace Azure::Core::Http; using namespace Azure::Core::Http::Policies; using namespace Azure::Core::Http::Policies::_internal; +using namespace Azure::Core::Http::_internal; namespace { // 1Mb at a time @@ -58,6 +58,34 @@ inline std::vector CreateDigest( } } // namespace +Request CryptographyClient::CreateRequest( + HttpMethod method, + std::vector const& path, + Azure::Core::IO::BodyStream* content) const +{ + return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::CreateRequest( + m_keyId, m_apiVersion, method, path, content); +} + +std::unique_ptr CryptographyClient::SendCryptoRequest( + std::vector const& path, + std::string const& payload, + Azure::Core::Context const& context) const +{ + // Payload for the request + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request = CreateRequest(HttpMethod::Post, path, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + request.SetHeader(HttpShared::Accept, HttpShared::ApplicationJson); + + // Send, parse and validate respone + return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::SendRequest( + *m_pipeline, request, context); +} + CryptographyClient::~CryptographyClient() = default; CryptographyClient::CryptographyClient( @@ -65,58 +93,47 @@ CryptographyClient::CryptographyClient( std::shared_ptr credential, CryptographyClientOptions const& options) { - auto apiVersion = options.Version.ToString(); m_keyId = Azure::Core::Url(keyId); + m_apiVersion = options.Version.ToString(); std::vector> perRetrypolicies; { - Azure::Core::Credentials::TokenRequestContext const tokenContext - = {{"https://vault.azure.net/.default"}}; + Azure::Core::Credentials::TokenRequestContext const tokenContext = {{TokenContextValue}}; perRetrypolicies.emplace_back( std::make_unique(credential, tokenContext)); } + std::vector> perCallpolicies; - m_pipeline = std::make_shared( - m_keyId, - apiVersion, - Azure::Core::Http::_internal::HttpPipeline( - options, "KeyVault", apiVersion, std::move(perRetrypolicies), {})); + m_pipeline = std::make_shared( + options, + "KeyVault", + options.Version.ToString(), + std::move(perRetrypolicies), + std::move(perCallpolicies)); } Azure::Response CryptographyClient::Encrypt( EncryptParameters const& parameters, Azure::Core::Context const& context) { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - [¶meters]() { - return EncryptParametersSerializer::EncryptParametersSerialize(parameters); - }, - [¶meters](Azure::Core::Http::RawResponse const& rawResponse) { - auto result = EncryptResultSerializer::EncryptResultDeserialize(rawResponse); - result.Algorithm = parameters.Algorithm; - return result; - }, - {"encrypt"}); + // Send and parse respone + auto rawResponse = SendCryptoRequest( + {EncryptValue}, EncryptParametersSerializer::EncryptParametersSerialize(parameters), context); + auto value = EncryptResultSerializer::EncryptResultDeserialize(*rawResponse); + value.Algorithm = parameters.Algorithm; + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response CryptographyClient::Decrypt( DecryptParameters const& parameters, Azure::Core::Context const& context) { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - [¶meters]() { - return DecryptParametersSerializer::DecryptParametersSerialize(parameters); - }, - [¶meters](Azure::Core::Http::RawResponse const& rawResponse) { - auto result = DecryptResultSerializer::DecryptResultDeserialize(rawResponse); - result.Algorithm = parameters.Algorithm; - return result; - }, - {"decrypt"}); + // Send and parse respone + auto rawResponse = SendCryptoRequest( + {DecryptValue}, DecryptParametersSerializer::DecryptParametersSerialize(parameters), context); + auto value = DecryptResultSerializer::DecryptResultDeserialize(*rawResponse); + value.Algorithm = parameters.Algorithm; + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response CryptographyClient::WrapKey( @@ -124,19 +141,15 @@ Azure::Response CryptographyClient::WrapKey( std::vector const& key, Azure::Core::Context const& context) { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - [&algorithm, &key]() { - return KeyWrapParametersSerializer::KeyWrapParametersSerialize( - KeyWrapParameters(algorithm.ToString(), key)); - }, - [&algorithm](Azure::Core::Http::RawResponse const& rawResponse) { - auto result = WrapResultSerializer::WrapResultDeserialize(rawResponse); - result.Algorithm = algorithm; - return result; - }, - {"wrapKey"}); + // Send and parse respone + auto rawResponse = SendCryptoRequest( + {WrapKeyValue}, + KeyWrapParametersSerializer::KeyWrapParametersSerialize( + KeyWrapParameters(algorithm.ToString(), key)), + context); + auto value = WrapResultSerializer::WrapResultDeserialize(*rawResponse); + value.Algorithm = algorithm; + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response CryptographyClient::UnwrapKey( @@ -144,19 +157,15 @@ Azure::Response CryptographyClient::UnwrapKey( std::vector const& encryptedKey, Azure::Core::Context const& context) { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - [&algorithm, &encryptedKey]() { - return KeyWrapParametersSerializer::KeyWrapParametersSerialize( - KeyWrapParameters(algorithm.ToString(), encryptedKey)); - }, - [&algorithm](Azure::Core::Http::RawResponse const& rawResponse) { - auto result = UnwrapResultSerializer::UnwrapResultDeserialize(rawResponse); - result.Algorithm = algorithm; - return result; - }, - {"unwrapKey"}); + // Send and parse respone + auto rawResponse = SendCryptoRequest( + {UnwrapKeyValue}, + KeyWrapParametersSerializer::KeyWrapParametersSerialize( + KeyWrapParameters(algorithm.ToString(), encryptedKey)), + context); + auto value = UnwrapResultSerializer::UnwrapResultDeserialize(*rawResponse); + value.Algorithm = algorithm; + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response CryptographyClient::Sign( @@ -164,19 +173,15 @@ Azure::Response CryptographyClient::Sign( std::vector const& digest, Azure::Core::Context const& context) { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - [&algorithm, &digest]() { - return KeySignParametersSerializer::KeySignParametersSerialize( - KeySignParameters(algorithm.ToString(), digest)); - }, - [&algorithm](Azure::Core::Http::RawResponse const& rawResponse) { - auto result = SignResultSerializer::SignResultDeserialize(rawResponse); - result.Algorithm = algorithm; - return result; - }, - {"sign"}); + // Send and parse respone + auto rawResponse = SendCryptoRequest( + {SignValue}, + KeySignParametersSerializer::KeySignParametersSerialize( + KeySignParameters(algorithm.ToString(), digest)), + context); + auto value = SignResultSerializer::SignResultDeserialize(*rawResponse); + value.Algorithm = algorithm; + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response CryptographyClient::SignData( @@ -201,22 +206,16 @@ Azure::Response CryptographyClient::Verify( std::vector const& signature, Azure::Core::Context const& context) { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - [&algorithm, &digest, &signature]() { - return KeyVerifyParametersSerializer::KeyVerifyParametersSerialize( - KeyVerifyParameters(algorithm.ToString(), digest, signature)); - }, - [&algorithm, this](Azure::Core::Http::RawResponse const& rawResponse) { - auto result = VerifyResultSerializer::VerifyResultDeserialize(rawResponse); - result.Algorithm = algorithm; - // Verify result won't return the KeyId, the client SDK will add it based on the client - // KeyId. - result.KeyId = this->m_keyId.GetAbsoluteUrl(); - return result; - }, - {"verify"}); + // Send and parse respone + auto rawResponse = SendCryptoRequest( + {VerifyValue}, + KeyVerifyParametersSerializer::KeyVerifyParametersSerialize( + KeyVerifyParameters(algorithm.ToString(), digest, signature)), + context); + auto value = VerifyResultSerializer::VerifyResultDeserialize(*rawResponse); + value.Algorithm = algorithm; + value.KeyId = this->m_keyId.GetAbsoluteUrl(); + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response CryptographyClient::VerifyData( diff --git a/sdk/keyvault/azure-security-keyvault-keys/src/key_client.cpp b/sdk/keyvault/azure-security-keyvault-keys/src/key_client.cpp index 7d3a86d3d..b92a10bda 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/src/key_client.cpp +++ b/sdk/keyvault/azure-security-keyvault-keys/src/key_client.cpp @@ -18,60 +18,78 @@ #include using namespace Azure::Security::KeyVault::Keys; +using namespace Azure::Security::KeyVault::Keys::_detail; using namespace Azure::Core::Http; using namespace Azure::Core::Http::Policies; using namespace Azure::Core::Http::Policies::_internal; +using namespace Azure::Core::Http::_internal; namespace { constexpr static const char KeyVaultServicePackageName[] = "keyvault-keys"; +constexpr static const char CreateValue[] = "create"; +} // namespace -struct RequestWithContinuationToken final +std::unique_ptr KeyClient::SendRequest( + Azure::Core::Http::Request& request, + Azure::Core::Context const& context) const { - std::vector Path; - std::unique_ptr> Query; -}; + return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::SendRequest( + *m_pipeline, request, context); +} -static inline RequestWithContinuationToken BuildRequestFromContinuationToken( - const Azure::Nullable& NextPageToken, - std::vector defaultPath) +Request KeyClient::CreateRequest( + HttpMethod method, + std::vector const& path, + Azure::Core::IO::BodyStream* content) const +{ + return Azure::Security::KeyVault::_detail::KeyVaultKeysCommonRequest::CreateRequest( + m_vaultUrl, m_apiVersion, method, path, content); +} + +Request KeyClient::ContinuationTokenRequest( + std::vector const& path, + const Azure::Nullable& NextPageToken) const { - RequestWithContinuationToken request; - request.Path = std::move(defaultPath); if (NextPageToken) { // Using a continuation token requires to send the request to the continuation token URL instead // of the default URL which is used only for the first page. Azure::Core::Url nextPageUrl(NextPageToken.Value()); - request.Query - = std::make_unique>(nextPageUrl.GetQueryParameters()); - request.Path.clear(); - request.Path.emplace_back(nextPageUrl.GetPath()); + return Request(HttpMethod::Get, nextPageUrl); } - return request; + return CreateRequest(HttpMethod::Get, path); } -} // namespace KeyClient::KeyClient( std::string const& vaultUrl, std::shared_ptr credential, KeyClientOptions options) + : m_vaultUrl(vaultUrl), m_apiVersion(options.Version.ToString()) { auto apiVersion = options.Version.ToString(); + std::vector> perRetrypoliciesOld; + { + Azure::Core::Credentials::TokenRequestContext const tokenContext = {{TokenContextValue}}; + + perRetrypoliciesOld.emplace_back( + std::make_unique(credential, tokenContext)); + } std::vector> perRetrypolicies; { - Azure::Core::Credentials::TokenRequestContext const tokenContext - = {{"https://vault.azure.net/.default"}}; + Azure::Core::Credentials::TokenRequestContext const tokenContext = {{TokenContextValue}}; perRetrypolicies.emplace_back( std::make_unique(credential, tokenContext)); } + std::vector> perCallpolicies; - m_pipeline = std::make_shared( - Azure::Core::Url(vaultUrl), - apiVersion, - Azure::Core::Http::_internal::HttpPipeline( - options, KeyVaultServicePackageName, apiVersion, std::move(perRetrypolicies), {})); + m_pipeline = std::make_shared( + options, + KeyVaultServicePackageName, + m_apiVersion, + std::move(perRetrypolicies), + std::move(perCallpolicies)); } Azure::Response KeyClient::GetKey( @@ -79,13 +97,13 @@ Azure::Response KeyClient::GetKey( GetKeyOptions const& options, Azure::Core::Context const& context) const { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Get, - [&name](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse); - }, - {_detail::KeysPath, name, options.Version}); + // Request with no payload + auto request = CreateRequest(HttpMethod::Get, {_detail::KeysPath, name, options.Version}); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response KeyClient::CreateKey( @@ -94,81 +112,99 @@ Azure::Response KeyClient::CreateKey( CreateKeyOptions const& options, Azure::Core::Context const& context) const { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - _detail::KeyRequestParameters(keyType, options), - [&name](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse); - }, - {_detail::KeysPath, name, "create"}); + // Payload for the request + _detail::KeyRequestParameters const params(keyType, options); + auto payload = params.Serialize(); + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request + = CreateRequest(HttpMethod::Post, {_detail::KeysPath, name, CreateValue}, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response KeyClient::CreateEcKey( CreateEcKeyOptions const& ecKeyOptions, Azure::Core::Context const& context) const { + // Payload for the request std::string const& keyName = ecKeyOptions.GetName(); - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - _detail::KeyRequestParameters(ecKeyOptions), - [&keyName](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, rawResponse); - }, - {_detail::KeysPath, keyName, "create"}); + auto payload = _detail::KeyRequestParameters(ecKeyOptions).Serialize(); + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request + = CreateRequest(HttpMethod::Post, {_detail::KeysPath, keyName, CreateValue}, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response KeyClient::CreateRsaKey( CreateRsaKeyOptions const& rsaKeyOptions, Azure::Core::Context const& context) const { + // Payload for the request std::string const& keyName = rsaKeyOptions.GetName(); - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - _detail::KeyRequestParameters(rsaKeyOptions), - [&keyName](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, rawResponse); - }, - {_detail::KeysPath, keyName, "create"}); + auto payload = _detail::KeyRequestParameters(rsaKeyOptions).Serialize(); + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request + = CreateRequest(HttpMethod::Post, {_detail::KeysPath, keyName, CreateValue}, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response KeyClient::CreateOctKey( CreateOctKeyOptions const& octKeyOptions, Azure::Core::Context const& context) const { + // Payload for the request. std::string const& keyName = octKeyOptions.GetName(); - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - _detail::KeyRequestParameters(octKeyOptions), - [&keyName](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, rawResponse); - }, - {_detail::KeysPath, keyName, "create"}); + auto payload = _detail::KeyRequestParameters(octKeyOptions).Serialize(); + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request + = CreateRequest(HttpMethod::Post, {_detail::KeysPath, keyName, CreateValue}, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(keyName, *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } KeyPropertiesPagedResponse KeyClient::GetPropertiesOfKeys( GetPropertiesOfKeysOptions const& options, Azure::Core::Context const& context) const { - auto const request - = BuildRequestFromContinuationToken(options.NextPageToken, {_detail::KeysPath}); - auto response = m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Get, - [](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize( - rawResponse); - }, - request.Path, - request.Query); + // Request and settings + auto request = ContinuationTokenRequest({_detail::KeysPath}, options.NextPageToken); + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize( + *rawResponse); return KeyPropertiesPagedResponse( - std::move(response.Value), - std::move(response.RawResponse), - std::make_unique(*this)); + std::move(value), std::move(rawResponse), std::make_unique(*this)); } KeyPropertiesPagedResponse KeyClient::GetPropertiesOfKeyVersions( @@ -176,99 +212,87 @@ KeyPropertiesPagedResponse KeyClient::GetPropertiesOfKeyVersions( GetPropertiesOfKeyVersionsOptions const& options, Azure::Core::Context const& context) const { - auto const request = BuildRequestFromContinuationToken( - options.NextPageToken, {_detail::KeysPath, name, "versions"}); - auto response = m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Get, - [](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize( - rawResponse); - }, - request.Path, - request.Query); + // Request and settings + auto request + = ContinuationTokenRequest({_detail::KeysPath, name, "versions"}, options.NextPageToken); + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyPropertiesPagedResultSerializer::KeyPropertiesPagedResultDeserialize( + *rawResponse); return KeyPropertiesPagedResponse( - std::move(response.Value), - std::move(response.RawResponse), - std::make_unique(*this), - name); + std::move(value), std::move(rawResponse), std::make_unique(*this)); } Azure::Security::KeyVault::Keys::DeleteKeyOperation KeyClient::StartDeleteKey( std::string const& name, Azure::Core::Context const& context) const { + // Request with no payload + auto request = CreateRequest(HttpMethod::Delete, {_detail::KeysPath, name}); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, *rawResponse); + auto responseT = Azure::Response(std::move(value), std::move(rawResponse)); return Azure::Security::KeyVault::Keys::DeleteKeyOperation( - std::make_shared(*this), - m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Delete, - [&name](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, rawResponse); - }, - {_detail::KeysPath, name})); + std::make_shared(*this), std::move(responseT)); } Azure::Security::KeyVault::Keys::RecoverDeletedKeyOperation KeyClient::StartRecoverDeletedKey( std::string const& name, Azure::Core::Context const& context) const { + // Request with no payload + auto request = CreateRequest(HttpMethod::Post, {_detail::DeletedKeysPath, name, "recover"}); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, *rawResponse); + auto responseT = Azure::Response(std::move(value), std::move(rawResponse)); return Azure::Security::KeyVault::Keys::RecoverDeletedKeyOperation( - std::make_shared(*this), - m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - [&name](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse); - }, - {_detail::DeletedKeysPath, name, "recover"})); + std::make_shared(*this), std::move(responseT)); } Azure::Response KeyClient::GetDeletedKey( std::string const& name, Azure::Core::Context const& context) const { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Get, - [&name](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, rawResponse); - }, - {_detail::DeletedKeysPath, name}); + // Request with no payload + auto request = CreateRequest(HttpMethod::Get, {_detail::DeletedKeysPath, name}); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::DeletedKeySerializer::DeletedKeyDeserialize(name, *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } DeletedKeyPagedResponse KeyClient::GetDeletedKeys( GetDeletedKeysOptions const& options, Azure::Core::Context const& context) const { - auto const request - = BuildRequestFromContinuationToken(options.NextPageToken, {_detail::DeletedKeysPath}); - auto response = m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Get, - [](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyPropertiesPagedResultSerializer::DeletedKeyPagedResultDeserialize( - rawResponse); - }, - request.Path, - request.Query); + // Request and settings + auto request = ContinuationTokenRequest({_detail::DeletedKeysPath}, options.NextPageToken); + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value + = _detail::KeyPropertiesPagedResultSerializer::DeletedKeyPagedResultDeserialize(*rawResponse); return DeletedKeyPagedResponse( - std::move(response.Value), - std::move(response.RawResponse), - std::make_unique(*this)); + std::move(value), std::move(rawResponse), std::make_unique(*this)); } Azure::Response KeyClient::PurgeDeletedKey( std::string const& name, Azure::Core::Context const& context) const { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Delete, - [](Azure::Core::Http::RawResponse const&) { return PurgedKey(); }, - {_detail::DeletedKeysPath, name}); + // Request with no payload + auto request = CreateRequest(HttpMethod::Delete, {_detail::DeletedKeysPath, name}); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = PurgedKey(); + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response KeyClient::UpdateKeyProperties( @@ -276,49 +300,58 @@ Azure::Response KeyClient::UpdateKeyProperties( Azure::Nullable> const& keyOperations, Azure::Core::Context const& context) const { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Patch, - _detail::KeyRequestParameters(properties, keyOperations), - [&properties](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(properties.Name, rawResponse); - }, - {_detail::KeysPath, properties.Name, properties.Version}); + // Payload for the request + _detail::KeyRequestParameters const params(properties, keyOperations); + auto payload = params.Serialize(); + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request = CreateRequest( + HttpMethod::Patch, {_detail::KeysPath, properties.Name, properties.Version}, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value + = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(properties.Name, *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } -Azure::Response KeyClient::BackupKey( +Azure::Response KeyClient::BackupKey( std::string const& name, Azure::Core::Context const& context) const { - // Use the internal model KeyBackup to parse from Json - auto response = m_pipeline->SendRequest<_detail::KeyBackup>( - context, - Azure::Core::Http::HttpMethod::Post, - [](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyBackup::Deserialize(rawResponse); - }, - {_detail::KeysPath, name, "backup"}); + // Request with no payload + auto request = CreateRequest(HttpMethod::Post, {_detail::KeysPath, name, "backup"}); - // Convert the internal KeyBackup model to a raw vector. - return Azure::Response( - Azure::Security::KeyVault::Keys::BackupKeyResult{response.Value.Value}, - std::move(response.RawResponse)); + // Send and parse respone + auto rawResponse = SendRequest(request, context); + // the internal backupKey model provides the Deserialize implementation + auto internalValue = _detail::KeyBackup::Deserialize(*rawResponse); + auto value = BackupKeyResult{internalValue.Value}; + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response KeyClient::RestoreKeyBackup( std::vector const& backup, Azure::Core::Context const& context) const { + // Payload for the request _detail::KeyBackup backupModel; backupModel.Value = backup; - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Post, - backupModel, - [](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(rawResponse); - }, - {_detail::KeysPath, "restore"}); + auto payload = backupModel.Serialize(); + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request = CreateRequest(HttpMethod::Post, {_detail::KeysPath, "restore"}, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(*rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } Azure::Response KeyClient::ImportKey( @@ -327,31 +360,26 @@ Azure::Response KeyClient::ImportKey( Azure::Core::Context const& context) const { ImportKeyOptions const importKeyOptions(name, keyMaterial); - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Put, - [&importKeyOptions]() { - return _detail::ImportKeyOptionsSerializer::ImportKeyOptionsSerialize(importKeyOptions); - }, - [&name](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize(name, rawResponse); - }, - {_detail::KeysPath, name}); + return ImportKey(importKeyOptions, context); } Azure::Response KeyClient::ImportKey( ImportKeyOptions const& importKeyOptions, Azure::Core::Context const& context) const { - return m_pipeline->SendRequest( - context, - Azure::Core::Http::HttpMethod::Put, - [&importKeyOptions]() { - return _detail::ImportKeyOptionsSerializer::ImportKeyOptionsSerialize(importKeyOptions); - }, - [&importKeyOptions](Azure::Core::Http::RawResponse const& rawResponse) { - return _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize( - importKeyOptions.Name(), rawResponse); - }, - {_detail::KeysPath, importKeyOptions.Name()}); + // Payload for the request + auto payload = _detail::ImportKeyOptionsSerializer::ImportKeyOptionsSerialize(importKeyOptions); + Azure::Core::IO::MemoryBodyStream payloadStream( + reinterpret_cast(payload.data()), payload.size()); + + // Request and settings + auto request = CreateRequest( + HttpMethod::Put, {_detail::KeysPath, importKeyOptions.Name()}, &payloadStream); + request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); + + // Send and parse respone + auto rawResponse = SendRequest(request, context); + auto value = _detail::KeyVaultKeySerializer::KeyVaultKeyDeserialize( + importKeyOptions.Name(), *rawResponse); + return Azure::Response(std::move(value), std::move(rawResponse)); } diff --git a/sdk/keyvault/azure-security-keyvault-keys/src/key_operation.cpp b/sdk/keyvault/azure-security-keyvault-keys/src/key_operation.cpp index 8ca1d70f3..5b9f04ad3 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/src/key_operation.cpp +++ b/sdk/keyvault/azure-security-keyvault-keys/src/key_operation.cpp @@ -2,21 +2,24 @@ // SPDX-License-Identifier: MIT #include "azure/keyvault/keys/key_client_models.hpp" +#include "private/key_constants.hpp" + +using namespace Azure::Security::KeyVault::Keys::_detail; namespace Azure { namespace Security { namespace KeyVault { namespace Keys { - const KeyOperation KeyOperation::Encrypt("encrypt"); + const KeyOperation KeyOperation::Encrypt(EncryptValue); - const KeyOperation KeyOperation::Decrypt("decrypt"); + const KeyOperation KeyOperation::Decrypt(DecryptValue); - const KeyOperation KeyOperation::Sign("sign"); + const KeyOperation KeyOperation::Sign(SignValue); - const KeyOperation KeyOperation::Verify("verify"); + const KeyOperation KeyOperation::Verify(VerifyValue); - const KeyOperation KeyOperation::WrapKey("wrapKey"); + const KeyOperation KeyOperation::WrapKey(WrapKeyValue); - const KeyOperation KeyOperation::UnwrapKey("unwrapKey"); + const KeyOperation KeyOperation::UnwrapKey(UnwrapKeyValue); - const KeyOperation KeyOperation::Import("import"); + const KeyOperation KeyOperation::Import(ImportValue); }}}} // namespace Azure::Security::KeyVault::Keys diff --git a/sdk/keyvault/azure-security-keyvault-keys/src/keyvault_protocol.cpp b/sdk/keyvault/azure-security-keyvault-keys/src/keyvault_protocol.cpp index bf0160156..9e0c4ca06 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/src/keyvault_protocol.cpp +++ b/sdk/keyvault/azure-security-keyvault-keys/src/keyvault_protocol.cpp @@ -2,6 +2,7 @@ // SPDX-License-Identifier: MIT #include "private/keyvault_protocol.hpp" +#include "private/key_constants.hpp" #include "private/keyvault_constants.hpp" #include @@ -9,43 +10,14 @@ using namespace Azure::Security::KeyVault; using namespace Azure::Core::Http::_internal; +using namespace Azure::Security::KeyVault::Keys::_detail; -Azure::Core::Http::Request _detail::KeyVaultProtocolClient::CreateRequest( - Azure::Core::Http::HttpMethod method, - Azure::Core::IO::BodyStream* content, - std::vector const& path) const +std::unique_ptr _detail::KeyVaultKeysCommonRequest::SendRequest( + Azure::Core::Http::_internal::HttpPipeline const& pipeline, + Azure::Core::Http::Request& request, + Azure::Core::Context const& context) { - Azure::Core::Http::Request request = content == nullptr - ? Azure::Core::Http::Request(method, m_vaultUrl) - : Azure::Core::Http::Request(method, m_vaultUrl, content); - - request.SetHeader(HttpShared::ContentType, HttpShared::ApplicationJson); - request.SetHeader(HttpShared::Accept, HttpShared::ApplicationJson); - - request.GetUrl().AppendQueryParameter(_detail::ApiVersion, m_apiVersion); - - for (std::string const& p : path) - { - if (!p.empty()) - { - request.GetUrl().AppendPath(p); - } - } - return request; -} - -Azure::Core::Http::Request _detail::KeyVaultProtocolClient::CreateRequest( - Azure::Core::Http::HttpMethod method, - std::vector const& path) const -{ - return CreateRequest(method, nullptr, path); -} - -std::unique_ptr _detail::KeyVaultProtocolClient::SendRequest( - Azure::Core::Context const& context, - Azure::Core::Http::Request& request) const -{ - auto response = m_pipeline.Send(request, context); + auto response = pipeline.Send(request, context); auto responseCode = response->GetStatusCode(); switch (responseCode) { @@ -61,3 +33,25 @@ std::unique_ptr _detail::KeyVaultProtocolClient: } return response; } + +Azure::Core::Http::Request _detail::KeyVaultKeysCommonRequest::CreateRequest( + Azure::Core::Url url, + std::string const& apiVersion, + Azure::Core::Http::HttpMethod method, + std::vector const& path, + Azure::Core::IO::BodyStream* content) +{ + using namespace Azure::Core::Http; + Request request = content == nullptr ? Request(method, url) : Request(method, url, content); + + request.GetUrl().AppendQueryParameter(ApiVersionValue, apiVersion); + + for (std::string const& p : path) + { + if (!p.empty()) + { + request.GetUrl().AppendPath(p); + } + } + return request; +} diff --git a/sdk/keyvault/azure-security-keyvault-keys/src/private/key_constants.hpp b/sdk/keyvault/azure-security-keyvault-keys/src/private/key_constants.hpp index a1f2ac7bf..8d10fd5bc 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/src/private/key_constants.hpp +++ b/sdk/keyvault/azure-security-keyvault-keys/src/private/key_constants.hpp @@ -115,5 +115,16 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { nam constexpr static const char IvValue[] = "iv"; constexpr static const char AdditionalAuthenticatedValue[] = "aad"; constexpr static const char AuthenticationTagValue[] = "tag"; + constexpr static const char EncryptValue[] = "encrypt"; + constexpr static const char DecryptValue[] = "decrypt"; + constexpr static const char WrapKeyValue[] = "wrapKey"; + constexpr static const char UnwrapKeyValue[] = "unwrapKey"; + constexpr static const char SignValue[] = "sign"; + constexpr static const char VerifyValue[] = "verify"; + constexpr static const char ImportValue[] = "import"; + + /***************** Service *********/ + constexpr static const char ApiVersionValue[] = "api-version"; + constexpr static const char TokenContextValue[] = "https://vault.azure.net/.default"; }}}}} // namespace Azure::Security::KeyVault::Keys::_detail diff --git a/sdk/keyvault/azure-security-keyvault-keys/src/private/keyvault_protocol.hpp b/sdk/keyvault/azure-security-keyvault-keys/src/private/keyvault_protocol.hpp index c4e13b683..f22ece7a4 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/src/private/keyvault_protocol.hpp +++ b/sdk/keyvault/azure-security-keyvault-keys/src/private/keyvault_protocol.hpp @@ -16,175 +16,25 @@ #include #include -#include #include #include #include namespace Azure { namespace Security { namespace KeyVault { namespace _detail { - /** - * @brief The Protocol layer used by Key Vault clients. - * - */ - class KeyVaultProtocolClient final { - Azure::Core::Url m_vaultUrl; - Azure::Core::Http::_internal::HttpPipeline m_pipeline; - std::string m_apiVersion; - - /** - * @brief Create a Request to be sent. - * - * @param method Represent an HTTP method. - * @param path The path for the HTTP request. - * @return A constructed request. - */ - Azure::Core::Http::Request CreateRequest( + struct KeyVaultKeysCommonRequest final + { + static Azure::Core::Http::Request CreateRequest( + Azure::Core::Url url, + std::string const& apiVersion, Azure::Core::Http::HttpMethod method, - std::vector const& path) const; - - /** - * @brief Create a Key Vault request with payload. - * - * @param method The HTTP method. - * @param content The HTTP payload. - * @param path The HTTP request path. - * @return A constructed request. - */ - Azure::Core::Http::Request CreateRequest( - Azure::Core::Http::HttpMethod method, - Azure::Core::IO::BodyStream* content, - std::vector const& path) const; - - /** - * @brief Start the HTTP transfer based on the \p request. - * - * @param context The context for per-operation options or cancellation. - * @param request The HTTP request to be sent. - * @return The raw response from the network. - */ - std::unique_ptr SendRequest( - Azure::Core::Context const& context, - Azure::Core::Http::Request& request) const; - - public: - /** - * @brief Construct a new Key Vault Protocol Client. - * - * @param vaultUrl The URL address for the Key Vault. - * @param apiVersion The service API version. - * @param pipeline The HTTP pipeline for sending requests with. - */ - explicit KeyVaultProtocolClient( - Azure::Core::Url vaultUrl, - std::string apiVersion, - Azure::Core::Http::_internal::HttpPipeline&& pipeline) - : m_vaultUrl(std::move(vaultUrl)), m_pipeline(pipeline), m_apiVersion(std::move(apiVersion)) - { - } - - /** - * @brief Create and send the HTTP request. Uses the \p factoryFn function to create - * the response type. - * - * @param context The context for per-operation options or cancellation. - * @param method The method for the request. - * @param factoryFn The function to deserialize and produce T from the raw response. - * @param path A path for the request represented as a vector of strings. - * @param query Optional query parameters for constructing the request. - * @return The object produced by the \p factoryFn and the raw response from the network. - */ - template - Azure::Response SendRequest( - Azure::Core::Context const& context, - Azure::Core::Http::HttpMethod method, - std::function factoryFn, std::vector const& path, - std::unique_ptr> const& query = nullptr) - { - auto request = CreateRequest(method, path); - if (query != nullptr) - { - for (auto const& queryParameter : *query) - { - request.GetUrl().AppendQueryParameter(queryParameter.first, queryParameter.second); - } - } - auto response = SendRequest(context, request); - // Saving the value in a local is required before passing it in to Response to avoid - // compiler optimizations re-ordering the `factoryFn` function call and the RawResponse move. - T value = factoryFn(*response); - return Azure::Response(std::move(value), std::move(response)); - } + Azure::Core::IO::BodyStream* content); - /** - * @brief Create and send the HTTP request with payload content. Uses the \p factoryFn function - * to create the response type. - * - * @param context The context for per-operation options or cancellation. - * @param method The method for the request. - * @param content The HTTP payload. - * @param factoryFn The function to deserialize and produce T from the raw response. - * @param path A path for the request represented as a vector of strings. - * @return The object produced by the \p factoryFn and the raw response from the network. - */ - template - Azure::Response SendRequest( - Azure::Core::Context const& context, - Azure::Core::Http::HttpMethod method, - Azure::Core::Json::_internal::JsonSerializable const& content, - std::function factoryFn, - std::vector const& path) - { - auto serialContent = content.Serialize(); - auto streamContent = Azure::Core::IO::MemoryBodyStream( - reinterpret_cast(serialContent.data()), serialContent.size()); - - auto request = CreateRequest(method, &streamContent, path); - auto response = SendRequest(context, request); - // Saving the value in a local is required before passing it in to Response to avoid - // compiler optimizations re-ordering the `factoryFn` function call and the RawResponse move. - T value = factoryFn(*response); - return Azure::Response(value, std::move(response)); - } - - template - Azure::Response SendRequest( - Azure::Core::Context const& context, - Azure::Core::Http::HttpMethod method, - std::function serializeContentFn, - std::function factoryFn, - std::vector const& path) - { - auto serialContent = serializeContentFn(); - auto streamContent = Azure::Core::IO::MemoryBodyStream( - reinterpret_cast(serialContent.data()), serialContent.size()); - - auto request = CreateRequest(method, &streamContent, path); - auto response = SendRequest(context, request); - // Saving the value in a local is required before passing it in to Response to avoid - // compiler optimizations re-ordering the `factoryFn` function call and the RawResponse move. - T value = factoryFn(*response); - return Azure::Response(value, std::move(response)); - } - - /** - * @brief Create a key vault request and send it using the Azure Core pipeline directly to avoid - * checking the respone code. - * - * @param context A context for cancellation. - * @param method The HTTP method for the request. - * @param path The path for the request. - * @return A unique ptr to an HTTP raw response. - */ - std::unique_ptr Send( - Azure::Core::Context const& context, - Azure::Core::Http::HttpMethod method, - std::vector const& path) - { - auto request = CreateRequest(method, path); - // Use the core pipeline directly to avoid checking the response code. - return m_pipeline.Send(request, context); - } + static std::unique_ptr SendRequest( + Azure::Core::Http::_internal::HttpPipeline const& pipeline, + Azure::Core::Http::Request& request, + Azure::Core::Context const& context); }; + }}}} // namespace Azure::Security::KeyVault::_detail diff --git a/sdk/keyvault/azure-security-keyvault-keys/test/ut/CMakeLists.txt b/sdk/keyvault/azure-security-keyvault-keys/test/ut/CMakeLists.txt index b7e9b92fa..2f825c2f9 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/test/ut/CMakeLists.txt +++ b/sdk/keyvault/azure-security-keyvault-keys/test/ut/CMakeLists.txt @@ -18,7 +18,6 @@ add_executable ( macro_guard.cpp mocked_transport_adapter_test.hpp mocked_client_test.cpp - protocol_test.cpp ) if (MSVC) diff --git a/sdk/keyvault/azure-security-keyvault-keys/test/ut/mocked_transport_adapter_test.hpp b/sdk/keyvault/azure-security-keyvault-keys/test/ut/mocked_transport_adapter_test.hpp index e825bebbb..02fb56911 100644 --- a/sdk/keyvault/azure-security-keyvault-keys/test/ut/mocked_transport_adapter_test.hpp +++ b/sdk/keyvault/azure-security-keyvault-keys/test/ut/mocked_transport_adapter_test.hpp @@ -102,12 +102,10 @@ namespace Azure { namespace Security { namespace KeyVault { namespace Keys { nam KeyClientOptions const& options = KeyClientOptions()) : KeyClient(vaultUrl, nullptr, options) { - auto apiVersion = options.Version.ToString(); - - m_pipeline = std::make_unique( - Azure::Core::Url(vaultUrl), - apiVersion, - Azure::Core::Http::_internal::HttpPipeline(options, "test", "version", {}, {})); + std::vector> perCallpolicies; + std::vector> perRetrypolicies; + m_pipeline = std::make_unique( + options, "test", "version", std::move(perRetrypolicies), std::move(perCallpolicies)); } }; diff --git a/sdk/keyvault/azure-security-keyvault-keys/test/ut/protocol_test.cpp b/sdk/keyvault/azure-security-keyvault-keys/test/ut/protocol_test.cpp deleted file mode 100644 index 23f42cd7f..000000000 --- a/sdk/keyvault/azure-security-keyvault-keys/test/ut/protocol_test.cpp +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. -// SPDX-License-Identifier: MIT - -#include "gtest/gtest.h" - -#include -#include -#include - -#include "./../../src/private/keyvault_protocol.hpp" - -#include - -using namespace Azure::Security::KeyVault::_detail; - -TEST(KeyVaultProtocolClient, initPipeline) -{ - std::vector> policies; - policies.emplace_back( - std::make_unique()); - Azure::Core::Url url("urlTest"); - Azure::Core::_internal::ClientOptions options; - Azure::Core::Http::_internal::HttpPipeline pipeline( - options, "service-name", "service-version", std::move(policies), {}); - EXPECT_NO_THROW(KeyVaultProtocolClient p(url, "version", std::move(pipeline))); -}