github/azure-sdk-for-cpp
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

adapt to breaking change in Azure Core (#356)

Browse Source 
* adapt to breaking change in Azure Core

* Adapt breaking change for Datalake service.

* Adapt to the breaking change

* Adapt breaking change for Datalake service.

* fix ut

* Fixed UT.

Co-authored-by: Tank Tang <kat@microsoft.com>
This commit is contained in:
JinmingHu 2020-07-29 14:55:53 +08:00 committed by GitHub
parent 61f36fd64d
commit b0facd3dd5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
16 changed files with 322 additions and 1024 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1141
sdk/storage/inc/blobs/protocol/blob_rest_client.hpp
View File

File diff suppressed because it is too large Load Diff

1
sdk/storage/inc/common/storage_error.hpp
View File

@ -24,6 +24,7 @@ namespace Azure { namespace Storage {
std::unique_ptr<Azure::Core::Http::RawResponse> RawResponse;
static StorageError CreateFromResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> response);
};
}} // namespace Azure::Storage

98
sdk/storage/inc/datalake/protocol/datalake_rest_client.hpp
View File

@ -857,20 +857,19 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
request.AddHeader(
Details::c_HeaderApiVersionParameter, listFileSystemsOptions.ApiVersionParameter);
return ListFileSystemsParseResponse(pipeline.Send(context, request));
return ListFileSystemsParseResponse(context, pipeline.Send(context, request));
}
private:
static Azure::Core::Response<ServiceListFileSystemsResponse> ListFileSystemsParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
{
// OK
auto context = Azure::Core::Context();
auto bodyBuffer
= Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
const auto& bodyBuffer = response.GetBody();
ServiceListFileSystemsResponse result = bodyBuffer.empty()
? ServiceListFileSystemsResponse()
: ServiceListFileSystemsResponse::ServiceListFileSystemsResponseFromFileSystemList(
@ -885,7 +884,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
};
@ -941,7 +940,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
request.AddHeader(Details::c_HeaderProperties, createOptions.Properties.GetValue());
}
return CreateParseResponse(pipeline.Send(context, request));
return CreateParseResponse(context, pipeline.Send(context, request));
}
struct SetPropertiesOptions
@ -1011,7 +1010,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Details::c_HeaderIfUnmodifiedSince,
setPropertiesOptions.IfUnmodifiedSince.GetValue());
}
return SetPropertiesParseResponse(pipeline.Send(context, request));
return SetPropertiesParseResponse(context, pipeline.Send(context, request));
}
struct GetPropertiesOptions
@ -1049,7 +1048,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
request.AddHeader(
Details::c_HeaderApiVersionParameter, getPropertiesOptions.ApiVersionParameter);
return GetPropertiesParseResponse(pipeline.Send(context, request));
return GetPropertiesParseResponse(context, pipeline.Send(context, request));
}
struct DeleteOptions
@ -1102,7 +1101,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
request.AddHeader(
Details::c_HeaderIfUnmodifiedSince, deleteOptions.IfUnmodifiedSince.GetValue());
}
return DeleteParseResponse(pipeline.Send(context, request));
return DeleteParseResponse(context, pipeline.Send(context, request));
}
struct ListPathsOptions
@ -1186,11 +1185,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
request.AddQueryParameter(
Details::c_QueryUpn, (listPathsOptions.Upn.GetValue() ? "true" : "false"));
}
return ListPathsParseResponse(pipeline.Send(context, request));
return ListPathsParseResponse(context, pipeline.Send(context, request));
}
private:
static Azure::Core::Response<FileSystemCreateResponse> CreateParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1206,11 +1206,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<FileSystemSetPropertiesResponse> SetPropertiesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1225,11 +1226,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<FileSystemGetPropertiesResponse> GetPropertiesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1246,11 +1248,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<FileSystemDeleteResponse> DeleteParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -1263,20 +1266,19 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<FileSystemListPathsResponse> ListPathsParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
{
// Ok
auto context = Azure::Core::Context();
auto bodyBuffer
= Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
const auto& bodyBuffer = response.GetBody();
FileSystemListPathsResponse result = bodyBuffer.empty()
? FileSystemListPathsResponse()
: FileSystemListPathsResponse::FileSystemListPathsResponseFromPathList(
@ -1291,7 +1293,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
};
@ -1523,7 +1525,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Details::c_HeaderSourceIfUnmodifiedSince,
createOptions.SourceIfUnmodifiedSince.GetValue());
}
return CreateParseResponse(pipeline.Send(context, request));
return CreateParseResponse(context, pipeline.Send(context, request));
}
struct UpdateOptions
@ -1783,7 +1785,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
request.AddHeader(
Details::c_HeaderIfUnmodifiedSince, updateOptions.IfUnmodifiedSince.GetValue());
}
return UpdateParseResponse(pipeline.Send(context, request));
return UpdateParseResponse(context, pipeline.Send(context, request));
}
struct LeaseOptions
@ -1903,7 +1905,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
request.AddHeader(
Details::c_HeaderIfUnmodifiedSince, leaseOptions.IfUnmodifiedSince.GetValue());
}
return LeaseParseResponse(pipeline.Send(context, request));
return LeaseParseResponse(context, pipeline.Send(context, request));
}
struct ReadOptions
@ -1951,7 +1953,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Azure::Core::Context context,
const ReadOptions& readOptions)
{
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url);
Azure::Core::Http::Request request(Azure::Core::Http::HttpMethod::Get, url, true);
if (readOptions.ClientRequestId.HasValue())
{
request.AddHeader(
@ -1996,7 +1998,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
request.AddHeader(
Details::c_HeaderIfUnmodifiedSince, readOptions.IfUnmodifiedSince.GetValue());
}
return ReadParseResponse(pipeline.Send(context, request));
return ReadParseResponse(context, pipeline.Send(context, request));
}
struct GetPropertiesOptions
@ -2095,7 +2097,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
Details::c_HeaderIfUnmodifiedSince,
getPropertiesOptions.IfUnmodifiedSince.GetValue());
}
return GetPropertiesParseResponse(pipeline.Send(context, request));
return GetPropertiesParseResponse(context, pipeline.Send(context, request));
}
struct DeleteOptions
@ -2186,7 +2188,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
request.AddHeader(
Details::c_HeaderIfUnmodifiedSince, deleteOptions.IfUnmodifiedSince.GetValue());
}
return DeleteParseResponse(pipeline.Send(context, request));
return DeleteParseResponse(context, pipeline.Send(context, request));
}
struct SetAccessControlOptions
@ -2293,7 +2295,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
request.AddHeader(
Details::c_HeaderApiVersionParameter, setAccessControlOptions.ApiVersionParameter);
return SetAccessControlParseResponse(pipeline.Send(context, request));
return SetAccessControlParseResponse(context, pipeline.Send(context, request));
}
struct SetAccessControlRecursiveOptions
@ -2374,7 +2376,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
request.AddHeader(
Details::c_HeaderApiVersionParameter,
setAccessControlRecursiveOptions.ApiVersionParameter);
return SetAccessControlRecursiveParseResponse(pipeline.Send(context, request));
return SetAccessControlRecursiveParseResponse(context, pipeline.Send(context, request));
}
struct FlushDataOptions
@ -2549,7 +2551,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
request.AddHeader(
Details::c_HeaderApiVersionParameter, flushDataOptions.ApiVersionParameter);
return FlushDataParseResponse(pipeline.Send(context, request));
return FlushDataParseResponse(context, pipeline.Send(context, request));
}
struct AppendDataOptions
@ -2631,11 +2633,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
request.AddHeader(
Details::c_HeaderApiVersionParameter, appendDataOptions.ApiVersionParameter);
return AppendDataParseResponse(pipeline.Send(context, request));
return AppendDataParseResponse(context, pipeline.Send(context, request));
}
private:
static Azure::Core::Response<PathCreateResponse> CreateParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2668,11 +2671,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathUpdateResponse> UpdateParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2680,9 +2684,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
{
// The data was flushed (written) to the file or the properties were set successfully.
// Response body is optional and is valid only for "SetAccessControlRecursive"
auto context = Azure::Core::Context();
auto bodyBuffer
= Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
const auto& bodyBuffer = response.GetBody();
PathUpdateResponse result = bodyBuffer.empty()
? PathUpdateResponse()
: PathUpdateResponse::PathUpdateResponseFromSetAccessControlRecursiveResponse(
@ -2756,11 +2758,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathLeaseResponse> LeaseParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2804,11 +2807,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathReadResponse> ReadParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -2947,11 +2951,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathGetPropertiesResponse> GetPropertiesParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3050,11 +3055,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathDeleteResponse> DeleteParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3072,11 +3078,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathSetAccessControlResponse> SetAccessControlParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3091,21 +3098,20 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathSetAccessControlRecursiveResponse>
SetAccessControlRecursiveParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
if (response.GetStatusCode() == Azure::Core::Http::HttpStatusCode::Ok)
{
// Set directory access control recursive response.
auto context = Azure::Core::Context();
auto bodyBuffer
= Azure::Core::Http::BodyStream::ReadToEnd(context, *response.GetBodyStream());
const auto& bodyBuffer = response.GetBody();
PathSetAccessControlRecursiveResponse result = bodyBuffer.empty()
? PathSetAccessControlRecursiveResponse()
: PathSetAccessControlRecursiveResponse::
@ -3122,11 +3128,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathFlushDataResponse> FlushDataParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3147,11 +3154,12 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
static Azure::Core::Response<PathAppendDataResponse> AppendDataParseResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> responsePtr)
{
/* const */ auto& response = *responsePtr;
@ -3164,7 +3172,7 @@ namespace Azure { namespace Storage { namespace Files { namespace DataLake {
}
else
{
throw Azure::Storage::StorageError::CreateFromResponse(std::move(responsePtr));
throw Azure::Storage::StorageError::CreateFromResponse(context, std::move(responsePtr));
}
}
};

2
sdk/storage/src/blobs/append_blob_client.cpp
View File

@ -88,7 +88,7 @@ namespace Azure { namespace Storage { namespace Blobs {
protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch;
protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch;
return BlobRestClient::AppendBlob::AppendBlock(
options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
}
Azure::Core::Response<BlobAppendInfo> AppendBlobClient::AppendBlockFromUri(

4
sdk/storage/src/blobs/block_blob_client.cpp
View File

@ -77,7 +77,7 @@ namespace Azure { namespace Storage { namespace Blobs {
protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch;
protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch;
return BlobRestClient::BlockBlob::Upload(
options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
}
Azure::Core::Response<BlobContentInfo> BlockBlobClient::UploadFromBuffer(
@ -210,7 +210,7 @@ namespace Azure { namespace Storage { namespace Blobs {
protocolLayerOptions.ContentCRC64 = options.ContentCRC64;
protocolLayerOptions.LeaseId = options.AccessConditions.LeaseId;
return BlobRestClient::BlockBlob::StageBlock(
options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
}
Azure::Core::Response<BlockInfo> BlockBlobClient::StageBlockFromUri(

2
sdk/storage/src/blobs/page_blob_client.cpp
View File

@ -90,7 +90,7 @@ namespace Azure { namespace Storage { namespace Blobs {
protocolLayerOptions.IfMatch = options.AccessConditions.IfMatch;
protocolLayerOptions.IfNoneMatch = options.AccessConditions.IfNoneMatch;
return BlobRestClient::PageBlob::UploadPages(
options.Context, *m_pipeline, m_blobUrl.ToString(), *content, protocolLayerOptions);
options.Context, *m_pipeline, m_blobUrl.ToString(), content, protocolLayerOptions);
}
Azure::Core::Response<PageInfo> PageBlobClient::UploadPagesFromUri(

12
sdk/storage/src/common/storage_error.cpp
View File

@ -5,22 +5,26 @@
#include "common/constants.hpp"
#include "common/xml_wrapper.hpp"
#include "http/policy.hpp"
#include "json.hpp"
#include <type_traits>
namespace Azure { namespace Storage {
StorageError StorageError::CreateFromResponse(
Azure::Core::Context context,
std::unique_ptr<Azure::Core::Http::RawResponse> response)
{
auto bodyStream = response->GetBodyStream();
std::vector<uint8_t> bodyBuffer;
if (bodyStream != nullptr)
auto bodyStream = response->GetBodyStream();
if (bodyStream)
{
// TODO: get the real context somewhere
Azure::Core::Context context;
bodyBuffer = Azure::Core::Http::BodyStream::ReadToEnd(context, *bodyStream);
}
else
{
bodyBuffer = std::move(response->GetBody());
}
auto httpStatusCode = response->GetStatusCode();
std::string reasonPhrase = response->GetReasonPhrase();

6
sdk/storage/test/blobs/append_blob_client_test.cpp
View File

@ -59,7 +59,7 @@ namespace Azure { namespace Storage { namespace Test {
Azure::Storage::Blobs::AppendBlockOptions options;
options.AccessConditions.AppendPosition = 1_MB;
blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), std::runtime_error);
EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), StorageError);
options.AccessConditions.AppendPosition = properties.ContentLength;
blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
appendBlobClient.AppendBlock(&blockContent, options);
@ -68,7 +68,7 @@ namespace Azure { namespace Storage { namespace Test {
options = Azure::Storage::Blobs::AppendBlockOptions();
options.AccessConditions.MaxSize = properties.ContentLength + m_blobContent.size() - 1;
blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), std::runtime_error);
EXPECT_THROW(appendBlobClient.AppendBlock(&blockContent, options), StorageError);
options.AccessConditions.MaxSize = properties.ContentLength + m_blobContent.size();
blockContent = Azure::Core::Http::MemoryBodyStream(m_blobContent.data(), m_blobContent.size());
appendBlobClient.AppendBlock(&blockContent, options);
@ -76,7 +76,7 @@ namespace Azure { namespace Storage { namespace Test {
// TODO: AppendBlockFromUri must be authorized with SAS, but we don't have SAS for now.
appendBlobClient.Delete();
EXPECT_THROW(appendBlobClient.Delete(), std::runtime_error);
EXPECT_THROW(appendBlobClient.Delete(), StorageError);
}
}}} // namespace Azure::Storage::Test

2
sdk/storage/test/blobs/blob_container_client_test.cpp
View File

@ -37,7 +37,7 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_FALSE(res.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderXMsVersion).empty());
EXPECT_FALSE(res->ETag.empty());
EXPECT_FALSE(res->LastModified.empty());
EXPECT_THROW(container_client.Create(), std::runtime_error);
EXPECT_THROW(container_client.Create(), StorageError);
auto res2 = container_client.Delete();
EXPECT_FALSE(res2.GetRawResponse().GetHeaders().at(Details::c_HttpHeaderRequestId).empty());

12
sdk/storage/test/blobs/blob_sas_test.cpp
View File

@ -211,7 +211,7 @@ namespace Azure { namespace Storage { namespace Test {
builder2.StartsOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(5));
builder2.ExpiresOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(1));
auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
EXPECT_THROW(verify_blob_create(sasToken), StorageError);
}
// Without start time
@ -230,7 +230,7 @@ namespace Azure { namespace Storage { namespace Test {
builder2.IPRange = "1.1.1.1";
auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
EXPECT_THROW(verify_blob_create(sasToken), StorageError);
builder2.IPRange = "0.0.0.0-255.255.255.255";
sasToken = builder2.ToSasQueryParameters(*keyCredential);
blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
@ -244,7 +244,7 @@ namespace Azure { namespace Storage { namespace Test {
builder2.Services = AccountSasServices::Files;
auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
EXPECT_THROW(verify_blob_create(sasToken), StorageError);
builder2.Services = AccountSasServices::All;
sasToken = builder2.ToSasQueryParameters(*keyCredential);
@ -259,7 +259,7 @@ namespace Azure { namespace Storage { namespace Test {
builder2.ResourceTypes = AccountSasResource::Service;
auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
EXPECT_THROW(verify_blob_create(sasToken), StorageError);
auto serviceClient = Blobs::BlobServiceClient(serviceUri + sasToken);
EXPECT_NO_THROW(serviceClient.ListBlobContainersSegment());
@ -321,7 +321,7 @@ namespace Azure { namespace Storage { namespace Test {
builder2.StartsOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(5));
builder2.ExpiresOn = ToISO8601(std::chrono::system_clock::now() - std::chrono::minutes(1));
auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
EXPECT_THROW(verify_blob_create(sasToken), StorageError);
}
// IP
@ -330,7 +330,7 @@ namespace Azure { namespace Storage { namespace Test {
builder2.IPRange = "0.0.0.0-0.0.0.1";
auto sasToken = builder2.ToSasQueryParameters(*keyCredential);
auto blobClient = Blobs::AppendBlobClient(blobUri + sasToken);
EXPECT_THROW(verify_blob_create(sasToken), std::runtime_error);
EXPECT_THROW(verify_blob_create(sasToken), StorageError);
builder2.IPRange = "0.0.0.0-255.255.255.255";
sasToken = builder2.ToSasQueryParameters(*keyCredential);
blobClient = Blobs::AppendBlobClient(blobUri + sasToken);

60
sdk/storage/test/blobs/block_blob_client_test.cpp
View File

@ -67,10 +67,10 @@ namespace Azure { namespace Storage { namespace Test {
blockBlobClient.Upload(&blobContent, m_blobUploadOptions);
blockBlobClient.Delete();
EXPECT_THROW(blockBlobClient.Delete(), std::runtime_error);
EXPECT_THROW(blockBlobClient.Delete(), StorageError);
blockBlobClient.Undelete();
blockBlobClient.Delete();
EXPECT_THROW(blockBlobClient.Delete(), std::runtime_error);
EXPECT_THROW(blockBlobClient.Delete(), StorageError);
}
TEST_F(BlockBlobClientTest, UploadDownload)
@ -122,9 +122,9 @@ namespace Azure { namespace Storage { namespace Test {
Azure::Storage::Blobs::DownloadBlobOptions options;
options.Offset = 0;
EXPECT_THROW(blockBlobClient.Download(options), std::runtime_error);
EXPECT_THROW(blockBlobClient.Download(options), StorageError);
options.Length = 1;
EXPECT_THROW(blockBlobClient.Download(options), std::runtime_error);
EXPECT_THROW(blockBlobClient.Download(options), StorageError);
}
TEST_F(BlockBlobClientTest, CopyFromUri)
@ -167,13 +167,12 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_EQ(ReadBodyStream(snapshotClient.Download()->BodyStream), m_blobContent);
EXPECT_EQ(snapshotClient.GetProperties()->Metadata, m_blobUploadOptions.Metadata);
auto emptyContent = Azure::Core::Http::MemoryBodyStream(nullptr, 0);
EXPECT_THROW(snapshotClient.Upload(&emptyContent), std::runtime_error);
EXPECT_THROW(snapshotClient.SetMetadata({}), std::runtime_error);
EXPECT_THROW(snapshotClient.Upload(&emptyContent), StorageError);
EXPECT_THROW(snapshotClient.SetMetadata({}), StorageError);
EXPECT_THROW(
snapshotClient.SetAccessTier(Azure::Storage::Blobs::AccessTier::Cool), std::runtime_error);
snapshotClient.SetAccessTier(Azure::Storage::Blobs::AccessTier::Cool), StorageError);
EXPECT_THROW(
snapshotClient.SetHttpHeaders(Azure::Storage::Blobs::BlobHttpHeaders()),
std::runtime_error);
snapshotClient.SetHttpHeaders(Azure::Storage::Blobs::BlobHttpHeaders()), StorageError);
Azure::Storage::Blobs::CreateSnapshotOptions options;
options.Metadata = {{"snapshotkey1", "snapshotvalue1"}, {"snapshotkey2", "SNAPSHOTVALUE2"}};
@ -352,9 +351,8 @@ namespace Azure { namespace Storage { namespace Test {
{
EXPECT_THROW(
m_blockBlobClient->DownloadToBuffer(nullptr, 8 * 1024 * 1024, optionsCopy),
std::runtime_error);
EXPECT_THROW(
m_blockBlobClient->DownloadToFile(tempFilename, optionsCopy), std::runtime_error);
StorageError);
EXPECT_THROW(m_blockBlobClient->DownloadToFile(tempFilename, optionsCopy), StorageError);
DeleteFile(tempFilename);
}
};
@ -476,31 +474,31 @@ namespace Azure { namespace Storage { namespace Test {
EXPECT_THROW(
blockBlobClient.DownloadToBuffer(
emptyContent.data(), static_cast<std::size_t>(8_MB), options),
std::runtime_error);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
StorageError);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
options.Offset = 1;
EXPECT_THROW(
blockBlobClient.DownloadToBuffer(
emptyContent.data(), static_cast<std::size_t>(8_MB), options),
std::runtime_error);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
StorageError);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
options.Offset = 0;
options.Length = 1;
EXPECT_THROW(
blockBlobClient.DownloadToBuffer(
emptyContent.data(), static_cast<std::size_t>(8_MB), options),
std::runtime_error);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
StorageError);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
options.Offset = 100;
options.Length = 100;
EXPECT_THROW(
blockBlobClient.DownloadToBuffer(
emptyContent.data(), static_cast<std::size_t>(8_MB), options),
std::runtime_error);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), std::runtime_error);
StorageError);
EXPECT_THROW(blockBlobClient.DownloadToFile(tempFilename, options), StorageError);
DeleteFile(tempFilename);
}
}
@ -576,4 +574,26 @@ namespace Azure { namespace Storage { namespace Test {
DeleteFile(tempFilename);
}
TEST_F(BlockBlobClientTest, DownloadError)
{
auto blockBlobClient = Azure::Storage::Blobs::BlockBlobClient::CreateFromConnectionString(
StandardStorageConnectionString(), m_containerName, RandomString());
bool exceptionCaught = false;
try
{
blockBlobClient.Download();
}
catch (StorageError& e)
{
exceptionCaught = true;
EXPECT_EQ(e.StatusCode, Azure::Core::Http::HttpStatusCode::NotFound);
EXPECT_FALSE(e.ReasonPhrase.empty());
EXPECT_FALSE(e.RequestId.empty());
EXPECT_FALSE(e.ErrorCode.empty());
EXPECT_FALSE(e.Message.empty());
EXPECT_TRUE(e.RawResponse);
}
EXPECT_TRUE(exceptionCaught);
}
}}} // namespace Azure::Storage::Test

2
sdk/storage/test/blobs/page_blob_client_test.cpp
View File

@ -45,7 +45,7 @@ namespace Azure { namespace Storage { namespace Test {
pageBlobClient.Create(0, m_blobUploadOptions);
pageBlobClient.Delete();
EXPECT_THROW(pageBlobClient.Delete(), std::runtime_error);
EXPECT_THROW(pageBlobClient.Delete(), StorageError);
}
TEST_F(PageBlobClientTest, Resize)

1
sdk/storage/test/datalake/directory_client_test.cpp
View File

@ -269,7 +269,6 @@ namespace Azure { namespace Storage { namespace Test {
auto properties3 = m_directoryClient->GetProperties();
EXPECT_NE(properties1->ETag, properties3->ETag);
EXPECT_NE(properties1->LastModified, properties3->LastModified);
}
{

1
sdk/storage/test/datalake/file_client_test.cpp
View File

@ -250,7 +250,6 @@ namespace Azure { namespace Storage { namespace Test {
auto properties3 = m_fileClient->GetProperties();
EXPECT_NE(properties1->ETag, properties3->ETag);
EXPECT_NE(properties1->LastModified, properties3->LastModified);
}
{

1
sdk/storage/test/datalake/file_system_client_test.cpp
View File

@ -187,7 +187,6 @@ namespace Azure { namespace Storage { namespace Test {
auto properties3 = m_fileSystemClient->GetProperties();
EXPECT_NE(properties1->ETag, properties3->ETag);
EXPECT_NE(properties1->LastModified, properties3->LastModified);
}
}

1
sdk/storage/test/datalake/path_client_test.cpp
View File

@ -112,7 +112,6 @@ namespace Azure { namespace Storage { namespace Test {
auto properties3 = m_pathClient->GetProperties();
EXPECT_NE(properties1->ETag, properties3->ETag);
EXPECT_NE(properties1->LastModified, properties3->LastModified);
}
}