/// <summary>
/// Checks a get blob range response for consistency with the given parameters, and closes the response.
/// </summary>
/// <param name="response">The HTTP web response to check.</param>
/// <param name="context">The testing context.</param>
/// <param name="content">The expected content returned in the response.</param>
/// <param name="expectedStartRange">The expected start range returned in the response header.</param>
/// <param name="expectedEndRange">The expected end range returned in the response header.</param>
/// <param name="expectedTotalBytes">The expected total number of bytes in the blob.</param>
/// <param name="expectedError">The expected error code, or null if the operation is expected to succeed.</param>
public static void CheckBlobRangeResponse(
HttpResponseMessage response,
BlobContext context,
byte[] content,
long expectedStartRange,
long expectedEndRange,
long expectedTotalBytes,
HttpStatusCode?expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.PartialContent, response.StatusCode);
Assert.IsNotNull(content);
BlobTestUtils.LastModifiedHeader(response);
BlobTestUtils.ContentLengthHeader(response, content.Length);
BlobTestUtils.ETagHeader(response);
BlobTestUtils.RequestIdHeader(response);
BlobTestUtils.Contents(response, content);
BlobTestUtils.ContentRangeHeader(response, expectedStartRange, expectedEndRange, expectedTotalBytes);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.ReasonPhrase);
}
response.Dispose();
}
/// <summary>
/// Generates a get blob request over the specified range, and checks the request for consistency.
/// </summary>
/// <param name="context">The testing context.</param>
/// <param name="containerName">The name of the container.</param>
/// <param name="blobName">The name of the blob.</param>
/// <param name="offset">The offset to the range.</param>
/// <param name="count">The number of elements in the range.</param>
/// <param name="leaseId">The lease ID, or null if the blob is not leased.</param>
/// <returns>A web request for getting a blob range.</returns>
public static HttpRequestMessage GetBlobRangeRequest(BlobContext context, string containerName, string blobName, long offset, long?count, AccessCondition accessCondition)
{
bool valid = BlobTests.ContainerNameValidator(containerName) &&
BlobTests.BlobNameValidator(blobName) &&
BlobTests.LeaseIdValidator(accessCondition);
Uri uri = BlobTests.ConstructGetUri(context.Address, containerName, blobName);
HttpRequestMessage request = null;
OperationContext opContext = new OperationContext();
try
{
request = BlobHttpRequestMessageFactory.Get(uri, context.Timeout, null /* snapshot */, offset, count, ChecksumRequested.None, accessCondition, null, opContext, SharedKeyCanonicalizer.Instance, context.Credentials, null);
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Get, request.Method);
BlobTestUtils.RangeHeader(request, offset, count.HasValue ? (long?)(count.Value + offset - 1) : null);
BlobTestUtils.LeaseIdHeader(request, accessCondition == null ? null : accessCondition.LeaseId);
}
return(request);
}
public async Task BlobProtocolGetContainerWithEmptyHeader()
{
ListingContext listingContext = new ListingContext("default", null);
await cloudOwnerAsync.CreateContainer("emptyheadercontainer", true);
HttpRequestMessage request = BlobTests.ListContainersRequest(cloudOwnerAsync.BlobContext, listingContext);
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
if (cloudOwnerAsync.BlobContext.Credentials != null)
{
request.Headers.Add("x-ms-blob-application-metadata", "");
}
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, cloudOwnerAsync.BlobContext))
{
BlobTests.ListContainersResponse(response, cloudOwnerAsync.BlobContext, HttpStatusCode.OK /*HttpStatusCode.Forbidden*/);
}
request = BlobTests.ListContainersRequest(cloudOwnerAsync.BlobContext, listingContext);
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
if (cloudOwnerAsync.BlobContext.Credentials != null)
{
request.Headers.Add("x-ms-blob-application-metadata", "");
}
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, cloudOwnerAsync.BlobContext))
{
BlobTests.ListContainersResponse(response, cloudOwnerAsync.BlobContext, HttpStatusCode.OK);
}
}
public async Task CreateContainer(string containerName, bool isPublic, int retries, int millisecondsBetweenRetries)
{
HttpStatusCode statusCode;
StorageExtendedErrorInformation error;
while (true)
{
HttpRequestMessage request = BlobTests.CreateContainerRequest(BlobContext, containerName);
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
if (isPublic)
{
request.Headers.Add("x-ms-blob-public-access", "container");
}
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
statusCode = response.StatusCode;
string statusDescription = response.ReasonPhrase;
error = await StorageExtendedErrorInformation.ReadFromStreamAsync(
HttpResponseParsers.GetResponseStream(response));
}
// if the container is being deleted, retry up to the specified times.
if (statusCode == HttpStatusCode.Conflict && error != null && error.ErrorCode == BlobErrorCodeStrings.ContainerBeingDeleted && retries > 0)
{
await Task.Delay(millisecondsBetweenRetries);
retries--;
continue;
}
break;
}
}
public async Task ListContainersScenarioTest(ListingContext listingContext, HttpStatusCode?expectedError, params string[] expectedContainers)
{
HttpRequestMessage request = BlobTests.ListContainersRequest(BlobContext, listingContext);
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.ListContainersResponse(response, BlobContext, expectedError);
ListContainersResponse listContainersResponse = await ListContainersResponse.ParseAsync(HttpResponseParsers.GetResponseStream(response), CancellationToken.None);
int i = 0;
foreach (BlobContainerEntry item in listContainersResponse.Containers)
{
if (expectedContainers == null)
{
Assert.Fail("Should not have containers.");
}
Assert.IsTrue(i < expectedContainers.Length, "Unexpected container: " + item.Name);
Assert.AreEqual <string>(expectedContainers[i++], item.Name, "Incorrect container.");
}
if (expectedContainers != null && i < expectedContainers.Length)
{
Assert.Fail("Missing container: " + expectedContainers[i] + "(and " + (expectedContainers.Length - i - 1) + " more).");
}
}
}
public async Task CreateBlob(string containerName, string blobName, bool isPublic)
{
Properties = new BlobProperties()
{
BlobType = BlobType.BlockBlob
};
HttpRequestMessage request = BlobTests.PutBlobRequest(BlobContext, containerName, blobName, Properties, BlobType.BlockBlob, Content, 0, null);
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
//HttpRequestHandler.SetContentLength(request, Content.Length);
CancellationTokenSource timeout = new CancellationTokenSource(30000);
request.Content = new ByteArrayContent(Content);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext, timeout))
{
HttpStatusCode statusCode = response.StatusCode;
string statusDescription = response.ReasonPhrase;
if (statusCode != HttpStatusCode.Created)
{
Assert.Fail(string.Format("Failed to create blob: {0}, Status: {1}, Status Description: {2}", containerName, statusCode, statusDescription));
}
}
}
public async Task GetBlockListScenarioTest(string containerName, string blobName, BlockListingFilter typesOfBlocks, string leaseId, HttpStatusCode?expectedError, params string[] expectedBlocks)
{
HttpRequestMessage request = BlobTests.GetBlockListRequest(BlobContext, containerName, blobName, typesOfBlocks, AccessCondition.GenerateLeaseCondition(leaseId));
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.GetBlockListResponse(response, BlobContext, expectedError);
IEnumerable <ListBlockItem> getBlockListResponse = await GetBlockListResponse.ParseAsync(HttpResponseParsers.GetResponseStream(response), CancellationToken.None);
int i = 0;
foreach (ListBlockItem item in getBlockListResponse)
{
if (expectedBlocks == null)
{
Assert.Fail("Should not have blocks.");
}
Assert.IsTrue(i < expectedBlocks.Length, "Unexpected block: " + item.Name);
Assert.AreEqual <string>(expectedBlocks[i++], item.Name, "Incorrect block.");
}
if (expectedBlocks != null && i < expectedBlocks.Length)
{
Assert.Fail("Missing block: " + expectedBlocks[i] + "(and " + (expectedBlocks.Length - i - 1) + " more).");
}
}
}
public async Task DeleteBlob(string containerName, string blobName)
{
HttpRequestMessage request = BlobTests.DeleteBlobRequest(BlobContext, containerName, blobName, null);
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
await BlobTestUtils.GetResponse(request, BlobContext);
}
public async static void AcquireAndReleaseLeaseTest(BlobContext context, string containerName, string blobName)
{
CloudStorageAccount account = new CloudStorageAccount(new StorageCredentials(context.Account, context.Key), false);
CloudBlobClient client = new CloudBlobClient(new Uri(context.Address), account.Credentials);
CloudBlobContainer container = client.GetContainerReference(containerName);
CloudBlockBlob blob = container.GetBlockBlobReference(blobName);
BlobTestBase.UploadText(blob, "Text sent to cloud", Encoding.UTF8);
// acquire a release on the blob and check LeaseStatus to be "locked"
OperationContext opContext = new OperationContext();
HttpRequestMessage blobRequest = BlobHttpRequestMessageFactory.Lease(
blob.Uri,
context.Timeout,
LeaseAction.Acquire,
null /* proposed lease ID */,
60 /* lease duration */,
null /* break period */,
null /* access condition */,
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
string leaseId = null;
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(blobRequest, context))
{
leaseId = HttpResponseParsers.GetHeader(response, "x-ms-lease-id");
Assert.AreEqual <HttpStatusCode>(response.StatusCode, HttpStatusCode.Created);
}
blob.FetchAttributes();
Assert.AreEqual <LeaseStatus>(blob.Properties.LeaseStatus, LeaseStatus.Locked);
// release the release on the blob and check LeaseStatus to be "unlocked"
opContext = new OperationContext();
blobRequest = BlobHttpRequestMessageFactory.Lease(
blob.Uri,
context.Timeout,
LeaseAction.Release,
null /* proposed lease ID */,
null /* lease duration */,
null /* break period */,
AccessCondition.GenerateLeaseCondition(leaseId),
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(blobRequest, context))
{
Assert.AreEqual <HttpStatusCode>(response.StatusCode, HttpStatusCode.OK);
}
blob.FetchAttributes();
Assert.AreEqual <LeaseStatus>(blob.Properties.LeaseStatus, LeaseStatus.Unlocked);
blob.Delete();
}
/// <summary>
/// Scenario test for releasing a lease.
/// </summary>
/// <param name="containerName">The name of the container.</param>
/// <param name="blobName">The name of the blob, if any.</param>
/// <param name="leaseId">The lease ID.</param>
/// <param name="expectedError">The error status code to expect.</param>
public async Task ReleaseLeaseScenarioTest(string containerName, string blobName, string leaseId, HttpStatusCode?expectedError)
{
// Create and validate the web request
HttpRequestMessage request = BlobTests.ReleaseLeaseRequest(BlobContext, containerName, blobName, AccessCondition.GenerateLeaseCondition(leaseId));
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.ReleaseLeaseResponse(response, expectedError);
}
}
/// <summary>
/// Scenario test for changing a lease.
/// </summary>
/// <param name="containerName">The name of the container.</param>
/// <param name="blobName">The name of the blob, if any.</param>
/// <param name="leaseId">The lease ID.</param>
/// <param name="proposedLeaseId">The proposed lease ID.</param>
/// <param name="expectedError">The error status code to expect.</param>
/// <returns>The lease ID.</returns>
public async Task <string> ChangeLeaseScenarioTest(string containerName, string blobName, string leaseId, string proposedLeaseId, HttpStatusCode?expectedError)
{
// Create and validate the web request
HttpRequestMessage request = BlobTests.ChangeLeaseRequest(BlobContext, containerName, blobName, proposedLeaseId, AccessCondition.GenerateLeaseCondition(leaseId));
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.ChangeLeaseResponse(response, proposedLeaseId, expectedError);
return(BlobHttpResponseParsers.GetLeaseId(response));
}
}
/// <summary>
/// Scenario test for acquiring a lease.
/// </summary>
/// <param name="containerName">The name of the container.</param>
/// <param name="blobName">The name of the blob, if any.</param>
/// <param name="leaseDuration">The lease duration.</param>
/// <param name="proposedLeaseId">The proposed lease ID.</param>
/// <param name="expectedError">The error status code to expect.</param>
/// <returns>The lease ID.</returns>
public async Task <string> AcquireLeaseScenarioTest(string containerName, string blobName, int leaseDuration, string proposedLeaseId, HttpStatusCode?expectedError)
{
// Create and validate the web request
HttpRequestMessage request = BlobTests.AcquireLeaseRequest(BlobContext, containerName, blobName, leaseDuration, proposedLeaseId, null);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.AcquireLeaseResponse(response, proposedLeaseId, expectedError);
return(BlobHttpResponseParsers.GetLeaseId(response));
}
}
public async Task GetBlobScenarioTest(string containerName, string blobName, BlobProperties properties, string leaseId,
byte[] content, HttpStatusCode?expectedError)
{
HttpRequestMessage request = BlobTests.GetBlobRequest(BlobContext, containerName, blobName, AccessCondition.GenerateLeaseCondition(leaseId));
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.GetBlobResponse(response, BlobContext, properties, content, expectedError);
}
}
public async Task PutBlockScenarioTest(string containerName, string blobName, string blockId, string leaseId, byte[] content, HttpStatusCode?expectedError)
{
HttpRequestMessage request = BlobTests.PutBlockRequest(BlobContext, containerName, blobName, blockId, AccessCondition.GenerateLeaseCondition(leaseId));
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
//HttpRequestHandler.SetContentLength(request, content.Length);
request.Content = new ByteArrayContent(content);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.PutBlockResponse(response, BlobContext, expectedError);
}
}
public async Task PutBlobScenarioTest(string containerName, string blobName, BlobProperties properties, BlobType blobType, byte[] content, HttpStatusCode?expectedError)
{
HttpRequestMessage request = BlobTests.PutBlobRequest(BlobContext, containerName, blobName, properties, blobType, content, content.Length, null);
request.Content = new ByteArrayContent(content);
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
//HttpRequestHandler.SetContentLength(request, content.Length);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.PutBlobResponse(response, BlobContext, expectedError);
}
}
/// <summary>
/// Scenario test for breaking a lease.
/// </summary>
/// <param name="containerName">The name of the container.</param>
/// <param name="blobName">The name of the blob, if any.</param>
/// <param name="breakPeriod">The break period.</param>
/// <param name="expectedRemainingTime">The expected remaining time.</param>
/// <param name="expectedError">The error status code to expect.</param>
/// <returns>The remaining lease time.</returns>
public async Task <int> BreakLeaseScenarioTest(string containerName, string blobName, int?breakPeriod, int?expectedRemainingTime, HttpStatusCode?expectedError)
{
// Create and validate the web request
HttpRequestMessage request = BlobTests.BreakLeaseRequest(BlobContext, containerName, blobName, breakPeriod, null);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
int expectedTime = expectedRemainingTime ?? breakPeriod.Value;
int errorMargin = 10;
BlobTests.BreakLeaseResponse(response, expectedTime, errorMargin, expectedError);
return(expectedError.HasValue ? 0 : BlobHttpResponseParsers.GetRemainingLeaseTime(response).Value);
}
}
public static void GetBlockListResponse(HttpResponseMessage response, BlobContext context, HttpStatusCode?expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, response.ReasonPhrase);
BlobTestUtils.ContentTypeHeader(response, "application/xml");
BlobTestUtils.RequestIdHeader(response);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.ReasonPhrase);
}
}
/// <summary>
/// Generates and validates a request to break a lease.
/// </summary>
/// <param name="context">The blob context.</param>
/// <param name="containerName">The container name.</param>
/// <param name="blobName">The blob name.</param>
/// <param name="breakPeriod">The break period.</param>
/// <returns>A web request for the operation.</returns>
public static HttpRequestMessage BreakLeaseRequest(BlobContext context, string containerName, string blobName, int?breakPeriod, AccessCondition accessCondition)
{
HttpRequestMessage request;
OperationContext opContext = new OperationContext();
if (blobName != null)
{
// blob lease
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
request = BlobHttpRequestMessageFactory.Lease(
uri,
context.Timeout,
LeaseAction.Break,
null /* proposed lease ID */,
null /* lease duration */,
breakPeriod,
accessCondition,
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
}
else
{
// container lease
Uri uri = BlobClientTests.ConstructUri(context.Address, containerName);
request = ContainerHttpRequestMessageFactory.Lease(
uri,
context.Timeout,
LeaseAction.Break,
null /* proposed lease ID */,
null /* lease duration */,
breakPeriod,
accessCondition,
null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
}
Assert.IsNotNull(request);
Assert.AreEqual(HttpMethod.Put, request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.LeaseIdHeader(request, null);
BlobTestUtils.LeaseActionHeader(request, "break");
BlobTestUtils.LeaseDurationHeader(request, null);
BlobTestUtils.ProposedLeaseIdHeader(request, null);
BlobTestUtils.BreakPeriodHeader(request, breakPeriod.HasValue ? breakPeriod.Value.ToString() : null);
return(request);
}
/// <summary>
/// Validates a response to a break lease operation.
/// </summary>
/// <param name="response">The response to validate.</param>
/// <param name="expectedLeaseTime">The expected remaining lease time.</param>
/// <param name="errorMargin">The error margin on the expected remaining lease time.</param>
/// <param name="expectedError">The error status code to expect.</param>
public static void BreakLeaseResponse(HttpResponseMessage response, int expectedLeaseTime, int errorMargin, HttpStatusCode?expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.Accepted, response.StatusCode, response.ReasonPhrase);
BlobTestUtils.LeaseIdHeader(response, null);
BlobTestUtils.LeaseTimeHeader(response, expectedLeaseTime, errorMargin);
BlobTestUtils.RequestIdHeader(response);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.ReasonPhrase);
}
}
/// <summary>
/// Validates a response to a release lease operation.
/// </summary>
/// <param name="response">The response to validate.</param>
/// <param name="expectedError">The error status code to expect.</param>
public static void ReleaseLeaseResponse(HttpResponseMessage response, HttpStatusCode?expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode, response.ReasonPhrase);
BlobTestUtils.LeaseIdHeader(response, null);
BlobTestUtils.LeaseTimeHeader(response, null, null);
BlobTestUtils.RequestIdHeader(response);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.ReasonPhrase);
}
}
public static HttpRequestMessage PutBlockListRequest(BlobContext context, string containerName, string blobName, BlobProperties blobProperties, AccessCondition accessCondition)
{
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpRequestMessage request = null;
OperationContext opContext = new OperationContext();
request = BlobHttpRequestMessageFactory.PutBlockList(uri, context.Timeout, blobProperties, accessCondition, null, opContext, SharedKeyCanonicalizer.Instance, context.Credentials);
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Put, request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
return(request);
}
public static HttpRequestMessage PutBlobRequest(BlobContext context, string containerName, string blobName,
BlobProperties properties, BlobType blobType, byte[] content, long pageBlobSize, AccessCondition accessCondition)
{
bool valid = BlobTests.ContainerNameValidator(containerName) &&
BlobTests.BlobNameValidator(blobName) &&
BlobTests.PutPropertiesValidator(properties) &&
BlobTestUtils.ContentValidator(content);
bool fatal = !BlobTests.PutPropertiesValidator(properties);
Uri uri = BlobTests.ConstructPutUri(context.Address, containerName, blobName);
HttpRequestMessage request = null;
OperationContext opContext = new OperationContext();
try
{
request = BlobHttpRequestMessageFactory.Put(uri, context.Timeout, properties, blobType, pageBlobSize, null, accessCondition, null, opContext,
SharedKeyCanonicalizer.Instance, context.Credentials, null);
if (fatal)
{
Assert.Fail();
}
}
catch (InvalidOperationException)
{
if (valid)
{
Assert.Fail();
}
}
if (valid)
{
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Put, request.Method);
BlobTestUtils.VersionHeader(request, false);
BlobTestUtils.ContentTypeHeader(request, null);
BlobTestUtils.ContentDispositionHeader(request, properties.ContentDisposition);
BlobTestUtils.ContentEncodingHeader(request, properties.ContentEncoding);
BlobTestUtils.ContentLanguageHeader(request, null);
BlobTestUtils.ContentMd5Header(request, null);
BlobTestUtils.ContentCrc64Header(request, null);
BlobTestUtils.CacheControlHeader(request, null);
BlobTestUtils.BlobTypeHeader(request, properties.BlobType);
BlobTestUtils.BlobSizeHeader(request, (properties.BlobType == BlobType.PageBlob) ? properties.Length : (long?)null);
}
return(request);
}
public static void PutBlockListResponse(HttpResponseMessage response, BlobContext context, HttpStatusCode?expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode, response.ReasonPhrase);
BlobTestUtils.ContentChecksumHeader(response);
BlobTestUtils.RequestIdHeader(response);
BlobTestUtils.ContentLengthHeader(response, 0);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.ReasonPhrase);
}
response.Dispose();
}
public static HttpRequestMessage DeleteContainerRequest(BlobContext context, string containerName, AccessCondition accessCondition)
{
Uri uri = BlobClientTests.ConstructUri(context.Address, containerName);
OperationContext opContext = new OperationContext();
HttpRequestMessage request = ContainerHttpRequestMessageFactory.Delete(uri, context.Timeout, accessCondition, null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Delete, request.Method);
BlobTestUtils.RangeHeader(request, null);
BlobTestUtils.LeaseIdHeader(request, null);
return(request);
}
public static HttpRequestMessage ListContainersRequest(BlobContext context, ListingContext listingContext)
{
Uri uri = BlobClientTests.ConstructUri(context.Address);
OperationContext opContext = new OperationContext();
HttpRequestMessage request = ContainerHttpRequestMessageFactory.List(uri, context.Timeout, listingContext, ContainerListingDetails.Metadata, null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Get, request.Method);
BlobTestUtils.RangeHeader(request, null);
BlobTestUtils.LeaseIdHeader(request, null);
return(request);
}
public static HttpRequestMessage GetBlockListRequest(BlobContext context, string containerName, string blobName, BlockListingFilter typesOfBlocks, AccessCondition accessCondition)
{
Uri uri = BlobClientTests.ConstructUri(context.Address, containerName, blobName);
OperationContext opContext = new OperationContext();
HttpRequestMessage request = BlobHttpRequestMessageFactory.GetBlockList(uri, context.Timeout, null /* snapshot */, typesOfBlocks, accessCondition, null,
opContext,
SharedKeyCanonicalizer.Instance,
context.Credentials);
Assert.IsNotNull(request);
Assert.IsNotNull(request.Method);
Assert.AreEqual(HttpMethod.Get, request.Method);
BlobTestUtils.RangeHeader(request, null);
BlobTestUtils.LeaseIdHeader(request, null);
return(request);
}
public static void GetBlobResponse(HttpResponseMessage response, BlobContext context, BlobProperties properties, byte[] content, HttpStatusCode?expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
BlobTestUtils.LastModifiedHeader(response);
BlobTestUtils.ContentLengthHeader(response, content.Length);
BlobTestUtils.ETagHeader(response);
BlobTestUtils.RequestIdHeader(response);
BlobTestUtils.Contents(response, content);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.ReasonPhrase);
}
response.Dispose();
}
public async Task PutBlockListScenarioTest(string containerName, string blobName, List <PutBlockListItem> blocks, BlobProperties blobProperties, string leaseId, HttpStatusCode?expectedError)
{
HttpRequestMessage request = BlobTests.PutBlockListRequest(BlobContext, containerName, blobName, blobProperties, AccessCondition.GenerateLeaseCondition(leaseId));
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
byte[] content;
using (MemoryStream stream = new MemoryStream())
{
BlobRequest.WriteBlockListBody(blocks, stream);
stream.Seek(0, SeekOrigin.Begin);
content = new byte[stream.Length];
stream.Read(content, 0, content.Length);
}
//HttpRequestHandler.SetContentLength(request, content.Length);
request.Content = new ByteArrayContent(content);
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
BlobTests.PutBlockListResponse(response, BlobContext, expectedError);
}
}
/// <summary>
/// Sends a get blob range request with the given parameters and validates both request and response.
/// </summary>
/// <param name="containerName">The blob's container's name.</param>
/// <param name="blobName">The blob's name.</param>
/// <param name="leaseId">The lease ID, or null if there is no lease.</param>
/// <param name="content">The total contents of the blob.</param>
/// <param name="offset">The offset of the contents we will get.</param>
/// <param name="count">The number of bytes we will get, or null to get the rest of the blob.</param>
/// <param name="expectedError">The error code we expect from this operation, or null if we expect it to succeed.</param>
public async Task GetBlobRangeScenarioTest(string containerName, string blobName, string leaseId, byte[] content, long offset, long?count, HttpStatusCode?expectedError)
{
HttpRequestMessage request = BlobTests.GetBlobRangeRequest(BlobContext, containerName, blobName, offset, count, AccessCondition.GenerateLeaseCondition(leaseId));
Assert.IsTrue(request != null, "Failed to create HttpRequestMessage");
using (HttpResponseMessage response = await BlobTestUtils.GetResponse(request, BlobContext))
{
long endRange = count.HasValue ? count.Value + offset - 1 : content.Length - 1;
byte[] selectedContent = null;
// Compute expected content only if call is expected to succeed.
if (expectedError == null)
{
selectedContent = new byte[endRange - offset + 1];
Array.Copy(content, offset, selectedContent, 0, selectedContent.Length);
}
BlobTests.CheckBlobRangeResponse(response, BlobContext, selectedContent, offset, endRange, content.Length, expectedError);
}
}
/// <summary>
/// Validates a response to an acquire lease operation.
/// </summary>
/// <param name="response">The response to validate.</param>
/// <param name="expectedLeaseId">The expected lease ID.</param>
/// <param name="expectedError">The error status code to expect.</param>
public static void AcquireLeaseResponse(HttpResponseMessage response, string expectedLeaseId, HttpStatusCode?expectedError)
{
Assert.IsNotNull(response);
if (expectedError == null)
{
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode, response.ReasonPhrase);
if (expectedLeaseId != null)
{
BlobTestUtils.LeaseIdHeader(response, expectedLeaseId);
}
else
{
BlobTestUtils.LeaseIdHeader(response);
}
BlobTestUtils.LeaseTimeHeader(response, null, null);
BlobTestUtils.RequestIdHeader(response);
}
else
{
Assert.AreEqual(expectedError, response.StatusCode, response.ReasonPhrase);
}
}
