public async Task BatchResponseDeserializationAsync()
{
using CosmosClient cosmosClient = MockCosmosUtil.CreateMockCosmosClient();
ContainerInternal containerCore = (ContainerInlineCore)cosmosClient.GetDatabase("db").GetContainer("cont");
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>
{
new TransactionalBatchOperationResult(HttpStatusCode.Conflict),
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
RequestCharge = 2.5,
ETag = "1234",
RetryAfter = TimeSpan.FromMilliseconds(360)
}
};
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
CosmosSerializer serializer = new CosmosJsonDotNetSerializer();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : Cosmos.PartitionKey.None,
operations : new ArraySegment <ItemBatchOperation>(
new ItemBatchOperation[]
{
new ItemBatchOperation(OperationType.Read, operationIndex: 0, id: "someId", containerCore: containerCore),
new ItemBatchOperation(OperationType.Read, operationIndex: 0, id: "someId", containerCore: containerCore)
}),
serializerCore : MockCosmosUtil.Serializer,
trace : NoOpTrace.Singleton,
cancellationToken : CancellationToken.None);
ResponseMessage response = new ResponseMessage((HttpStatusCode)StatusCodes.MultiStatus)
{
Content = responseContent
};
response.Headers.Session = Guid.NewGuid().ToString();
response.Headers.ActivityId = Guid.NewGuid().ToString();
TransactionalBatchResponse batchResponse = await TransactionalBatchResponse.FromResponseMessageAsync(
response,
batchRequest,
MockCosmosUtil.Serializer,
true,
NoOpTrace.Singleton,
CancellationToken.None);
Assert.IsNotNull(batchRequest);
Assert.AreEqual(HttpStatusCode.Conflict, batchResponse.StatusCode);
Assert.AreEqual(2, batchResponse.Count);
Assert.AreEqual(response.Headers.Session, batchResponse[0].SessionToken);
Assert.AreEqual(response.Headers.Session, batchResponse[1].SessionToken);
Assert.AreEqual(response.Headers.ActivityId, batchResponse[0].ActivityId);
Assert.AreEqual(response.Headers.ActivityId, batchResponse[1].ActivityId);
CosmosBatchOperationResultEqualityComparer comparer = new CosmosBatchOperationResultEqualityComparer();
Assert.IsTrue(comparer.Equals(results[0], batchResponse[0]));
Assert.IsTrue(comparer.Equals(results[1], batchResponse[1]));
}
public async Task DiagnosticsAreSetThroughResponseAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Read, 0, Cosmos.PartitionKey.Null, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : default(CancellationToken));
PointOperationStatistics diagnostics = new PointOperationStatistics(
activityId: Guid.NewGuid().ToString(),
statusCode: HttpStatusCode.OK,
subStatusCode: SubStatusCodes.Unknown,
responseTimeUtc: DateTime.UtcNow,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: "http://localhost",
requestSessionToken: null,
responseSessionToken: null);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK)
{
Content = responseContent,
};
responseMessage.DiagnosticsContext.AddDiagnosticsInternal(diagnostics);
TransactionalBatchResponse batchresponse = await TransactionalBatchResponse.FromResponseMessageAsync(
responseMessage,
batchRequest,
MockCosmosUtil.Serializer,
true,
CancellationToken.None);
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, MockCosmosUtil.Serializer);
string pointDiagnosticString = diagnostics.ToString();
pointDiagnosticString = pointDiagnosticString.Substring(1, pointDiagnosticString.Length - 2);
string diagnosticContextString = response.DiagnosticsContext.ToString();
Assert.IsTrue(diagnosticContextString.Contains(pointDiagnosticString));
}
private async Task <ResponseMessage> GenerateOkResponseAsync(ItemBatchOperation itemBatchOperation)
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ETag = itemBatchOperation.Id
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK)
{
Content = responseContent, Diagnostics = new PointOperationStatistics(HttpStatusCode.OK, SubStatusCodes.Unknown, 0, string.Empty, HttpMethod.Get, new Uri("http://localhost"), new CosmosClientSideRequestStatistics())
};
return(responseMessage);
}
public async Task StatusCodesAreSetThroughResponseAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.AddComputeGatewayRequestCharges, 0, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : default(CancellationToken));
TransactionalBatchResponse batchresponse = await TransactionalBatchResponse.FromResponseMessageAsync(
new ResponseMessage(HttpStatusCode.OK) { Content = responseContent },
batchRequest,
MockCosmosUtil.Serializer);
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, MockCosmosUtil.Serializer);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
}
private async Task <ResponseMessage> GenerateOkResponseAsync(ItemBatchOperation itemBatchOperation)
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ETag = itemBatchOperation.Id
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK)
{
Content = responseContent
};
return(responseMessage);
}
public async Task BatchRequestSerializationFillAsync()
{
const int maxBodySize = 5 * 1024;
const int maxOperationCount = 10;
const int operationBodySize = 2 * 1024;
const string partitionKey1 = "pk1";
const string id = "random";
ItemBatchOperation[] operations = new ItemBatchOperation[]
{
new ItemBatchOperation(
operationType: OperationType.Replace,
id: id,
operationIndex: 0)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('w', operationBodySize))
},
new ItemBatchOperation(
operationType: OperationType.Create,
operationIndex: 1)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('x', operationBodySize))
},
new ItemBatchOperation(
operationType: OperationType.Upsert,
operationIndex: 2)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('y', operationBodySize))
},
new ItemBatchOperation(
operationType: OperationType.Create,
operationIndex: 3)
{
ResourceBody = Encoding.UTF8.GetBytes(new string('z', operationBodySize))
}
};
ServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
new Cosmos.PartitionKey(partitionKey1),
new ArraySegment <ItemBatchOperation>(operations),
maxBodySize,
maxOperationCount,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
Assert.AreEqual(2, batchRequest.Operations.Count);
using (MemoryStream payload = batchRequest.TransferBodyStream())
{
Assert.IsNotNull(payload);
List <ItemBatchOperation> readOperations = await new BatchRequestPayloadReader().ReadPayloadAsync(payload);
Assert.AreEqual(2, readOperations.Count);
ItemBatchOperationEqualityComparer comparer = new ItemBatchOperationEqualityComparer();
Assert.IsTrue(comparer.Equals(operations[0], readOperations[0]));
Assert.IsTrue(comparer.Equals(operations[1], readOperations[1]));
}
}
private static async Task <ResponseMessage> GenerateResponseAsync(
ItemBatchOperation itemBatchOperation,
HttpStatusCode httpStatusCode,
SubStatusCodes subStatusCode)
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new TransactionalBatchOperationResult(httpStatusCode)
{
ETag = itemBatchOperation.Id,
SubStatusCode = subStatusCode
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
_ = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
trace : NoOpTrace.Singleton,
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(httpStatusCode)
{
Content = responseContent,
};
using (responseMessage.Trace = Trace.GetRootTrace("Test Trace"))
{
responseMessage.Trace.AddDatum(
"Point Operation Statistics",
new PointOperationStatisticsTraceDatum(
activityId: Guid.NewGuid().ToString(),
statusCode: httpStatusCode,
subStatusCode: subStatusCode,
responseTimeUtc: DateTime.UtcNow,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: "http://localhost",
requestSessionToken: null,
responseSessionToken: null,
beLatencyInMs: "0.42"));
}
responseMessage.Headers.SubStatusCode = subStatusCode;
return(responseMessage);
}
public async Task BatchResponseDeserializationAsync()
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
results.Add(new BatchOperationResult(HttpStatusCode.Conflict));
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = "1234"
});
results.Add(
new BatchOperationResult((HttpStatusCode)StatusCodes.TooManyRequests)
{
RetryAfter = TimeSpan.FromMilliseconds(360)
});
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
CosmosSerializer serializer = new CosmosJsonDotNetSerializer();
SinglePartitionKeyServerBatchRequest batchResponse = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : Cosmos.PartitionKey.None,
operations : new ArraySegment <ItemBatchOperation>(
new ItemBatchOperation[]
{
new ItemBatchOperation(OperationType.Read, operationIndex: 0, id: "someId")
}),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : serializer,
cancellationToken : CancellationToken.None);
BatchResponse batchresponse = await BatchResponse.PopulateFromContentAsync(
new ResponseMessage(HttpStatusCode.OK) { Content = responseContent },
batchResponse,
serializer);
Assert.IsNotNull(batchresponse);
Assert.IsTrue(batchresponse.IsSuccessStatusCode);
Assert.AreEqual(3, batchresponse.Count);
CosmosBatchOperationResultEqualityComparer comparer = new CosmosBatchOperationResultEqualityComparer();
Assert.IsTrue(comparer.Equals(results[0], batchresponse[0]));
Assert.IsTrue(comparer.Equals(results[1], batchresponse[1]));
Assert.IsTrue(comparer.Equals(results[2], batchresponse[2]));
}
public async Task BatchRequestSerializationAsync()
{
const string partitionKey1 = "pk1";
using CosmosClient cosmosClient = MockCosmosUtil.CreateMockCosmosClient();
ContainerInternal containerCore = (ContainerInlineCore)cosmosClient.GetDatabase("db").GetContainer("cont");
ItemBatchOperation[] operations = new ItemBatchOperation[]
{
new ItemBatchOperation(
operationType: OperationType.Create,
operationIndex: 0,
containerCore: containerCore)
{
ResourceBody = new byte[] { 0x41, 0x42 }
},
new ItemBatchOperation(
id: "id2",
operationType: OperationType.Replace,
operationIndex: 1,
containerCore: containerCore,
requestOptions: new TransactionalBatchItemRequestOptions()
{
IfMatchEtag = "theCondition"
})
};
ServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
new Cosmos.PartitionKey(partitionKey1),
new ArraySegment <ItemBatchOperation>(operations),
serializerCore : MockCosmosUtil.Serializer,
trace : NoOpTrace.Singleton,
cancellationToken : CancellationToken.None);
Assert.AreEqual(2, batchRequest.Operations.Count);
using (MemoryStream payload = batchRequest.TransferBodyStream())
{
Assert.IsNotNull(payload);
List <ItemBatchOperation> readOperations = await new BatchRequestPayloadReader().ReadPayloadAsync(payload);
Assert.AreEqual(2, readOperations.Count);
ItemBatchOperationEqualityComparer comparer = new ItemBatchOperationEqualityComparer();
Assert.IsTrue(comparer.Equals(operations[0], readOperations[0]));
Assert.IsTrue(comparer.Equals(operations[1], readOperations[1]));
}
}
public async Task DiagnosticsAreSetThroughResponseAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.AddComputeGatewayRequestCharges, 0, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : default(CancellationToken));
CosmosDiagnostics diagnostics = new PointOperationStatistics(
activityId: Guid.NewGuid().ToString(),
statusCode: HttpStatusCode.OK,
subStatusCode: SubStatusCodes.Unknown,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: new Uri("http://localhost"),
requestSessionToken: null,
responseSessionToken: null,
clientSideRequestStatistics: new CosmosClientSideRequestStatistics());
TransactionalBatchResponse batchresponse = await TransactionalBatchResponse.FromResponseMessageAsync(
new ResponseMessage(HttpStatusCode.OK) { Content = responseContent, Diagnostics = diagnostics },
batchRequest,
MockCosmosUtil.Serializer);
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, MockCosmosUtil.Serializer);
Assert.AreEqual(diagnostics, response.Diagnostics);
}
public async Task BatchRequestSerializationAsync()
{
const int maxBodySize = 5 * 1024;
const int maxOperationCount = 10;
const string partitionKey1 = "pk1";
ItemBatchOperation[] operations = new ItemBatchOperation[]
{
new ItemBatchOperation(
operationType: OperationType.Create,
operationIndex: 0)
{
ResourceBody = new byte[] { 0x41, 0x42 }
},
new ItemBatchOperation(
id: "id2",
operationType: OperationType.Replace,
operationIndex: 1,
requestOptions: new BatchItemRequestOptions()
{
IfMatchEtag = "theCondition"
})
};
ServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
new Cosmos.PartitionKey(partitionKey1),
new ArraySegment <ItemBatchOperation>(operations),
maxBodySize,
maxOperationCount,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
Assert.AreEqual(2, batchRequest.Operations.Count);
using (MemoryStream payload = batchRequest.TransferBodyStream())
{
Assert.IsNotNull(payload);
List <ItemBatchOperation> readOperations = await new BatchRequestPayloadReader().ReadPayloadAsync(payload);
Assert.AreEqual(2, readOperations.Count);
ItemBatchOperationEqualityComparer comparer = new ItemBatchOperationEqualityComparer();
Assert.IsTrue(comparer.Equals(operations[0], readOperations[0]));
Assert.IsTrue(comparer.Equals(operations[1], readOperations[1]));
}
}
private async Task <bool> ConstainsSplitIsTrueInternal(HttpStatusCode statusCode, SubStatusCodes subStatusCode)
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Read, 0, Cosmos.PartitionKey.Null, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : default(CancellationToken));
ResponseMessage response = new ResponseMessage(statusCode)
{
Content = responseContent
};
response.Headers.SubStatusCode = subStatusCode;
TransactionalBatchResponse batchresponse = await TransactionalBatchResponse.FromResponseMessageAsync(
response,
batchRequest,
MockCosmosUtil.Serializer,
true,
false,
CancellationToken.None);
PartitionKeyRangeBatchExecutionResult result = new PartitionKeyRangeBatchExecutionResult("0", arrayOperations, batchresponse);
return(result.IsSplit());
}
public async Task BatchResponseDeserializationAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
results.Add(new TransactionalBatchOperationResult(HttpStatusCode.Conflict));
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
RequestCharge = 2.5,
ETag = "1234",
RetryAfter = TimeSpan.FromMilliseconds(360)
});
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
CosmosSerializer serializer = new CosmosJsonDotNetSerializer();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : Cosmos.PartitionKey.None,
operations : new ArraySegment <ItemBatchOperation>(
new ItemBatchOperation[]
{
new ItemBatchOperation(OperationType.Read, operationIndex: 0, id: "someId"),
new ItemBatchOperation(OperationType.Read, operationIndex: 0, id: "someId")
}),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : CancellationToken.None);
TransactionalBatchResponse batchResponse = await TransactionalBatchResponse.FromResponseMessageAsync(
new ResponseMessage((HttpStatusCode)StatusCodes.MultiStatus) { Content = responseContent },
batchRequest,
MockCosmosUtil.Serializer);
Assert.IsNotNull(batchRequest);
Assert.AreEqual(HttpStatusCode.Conflict, batchResponse.StatusCode);
Assert.AreEqual(2, batchResponse.Count);
CosmosBatchOperationResultEqualityComparer comparer = new CosmosBatchOperationResultEqualityComparer();
Assert.IsTrue(comparer.Equals(results[0], batchResponse[0]));
Assert.IsTrue(comparer.Equals(results[1], batchResponse[1]));
}
private async Task <bool> ConstainsSplitIsTrueInternal(HttpStatusCode statusCode, SubStatusCodes subStatusCode)
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.AddComputeGatewayRequestCharges, 0, "0");
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : default(CancellationToken));
ResponseMessage response = new ResponseMessage(statusCode)
{
Content = responseContent
};
response.Headers.SubStatusCode = subStatusCode;
BatchResponse batchresponse = await BatchResponse.PopulateFromContentAsync(
response,
batchRequest,
new CosmosJsonDotNetSerializer());
PartitionKeyRangeBatchExecutionResult result = new PartitionKeyRangeBatchExecutionResult("0", arrayOperations, batchresponse);
return(result.IsSplit());
}
private async Task <ResponseMessage> GenerateCacheStaleResponseAsync(ItemBatchOperation itemBatchOperation)
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.Gone)
{
ETag = itemBatchOperation.Id,
SubStatusCode = SubStatusCodes.NameCacheIsStale
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
_ = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.Gone)
{
Content = responseContent,
};
responseMessage.DiagnosticsContext.AddDiagnosticsInternal(new PointOperationStatistics(
activityId: Guid.NewGuid().ToString(),
statusCode: HttpStatusCode.Gone,
subStatusCode: SubStatusCodes.Unknown,
responseTimeUtc: DateTime.UtcNow,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: "http://localhost",
requestSessionToken: null,
responseSessionToken: null));
responseMessage.Headers.SubStatusCode = SubStatusCodes.NameCacheIsStale;
return(responseMessage);
}
private async Task <ResponseMessage> GenerateSplitResponseAsync(ItemBatchOperation itemBatchOperation)
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.Gone)
{
ETag = itemBatchOperation.Id,
SubStatusCode = SubStatusCodes.PartitionKeyRangeGone
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.Gone)
{
Content = responseContent,
Diagnostics = new PointOperationStatistics(
activityId: Guid.NewGuid().ToString(),
statusCode: HttpStatusCode.Gone,
subStatusCode: SubStatusCodes.Unknown,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: new Uri("http://localhost"),
requestSessionToken: null,
responseSessionToken: null,
clientSideRequestStatistics: new CosmosClientSideRequestStatistics())
};
responseMessage.Headers.SubStatusCode = SubStatusCodes.PartitionKeyRangeGone;
return(responseMessage);
}
private async Task <ResponseMessage> Generate429ResponseAsync(ItemBatchOperation itemBatchOperation)
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
results.Add(
new TransactionalBatchOperationResult((HttpStatusCode)StatusCodes.TooManyRequests)
{
ETag = itemBatchOperation.Id
});
arrayOperations[0] = itemBatchOperation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
cancellationToken : CancellationToken.None);
ResponseMessage responseMessage = new ResponseMessage((HttpStatusCode)StatusCodes.TooManyRequests)
{
Content = responseContent,
};
responseMessage.DiagnosticsContext.AddDiagnosticsInternal(new PointOperationStatistics(
activityId: Guid.NewGuid().ToString(),
statusCode: (HttpStatusCode)StatusCodes.TooManyRequests,
subStatusCode: SubStatusCodes.Unknown,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: new Uri("http://localhost"),
requestSessionToken: null,
responseSessionToken: null,
clientSideRequestStatistics: new CosmosClientSideRequestStatistics()));
return(responseMessage);
}
public async Task DiagnosticsAreSetThroughResponseAsync()
{
List <BatchOperationResult> results = new List <BatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.AddComputeGatewayRequestCharges, 0, "0");
results.Add(
new BatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
maxBodyLength : 100,
maxOperationCount : 1,
serializer : new CosmosJsonDotNetSerializer(),
cancellationToken : default(CancellationToken));
CosmosDiagnostics diagnostics = new PointOperationStatistics(HttpStatusCode.OK, SubStatusCodes.Unknown, 0, string.Empty, HttpMethod.Get, new Uri("http://localhost"), new CosmosClientSideRequestStatistics());
BatchResponse batchresponse = await BatchResponse.PopulateFromContentAsync(
new ResponseMessage(HttpStatusCode.OK) { Content = responseContent, Diagnostics = diagnostics },
batchRequest,
new CosmosJsonDotNetSerializer());
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, new CosmosJsonDotNetSerializer());
Assert.AreEqual(diagnostics, response.Diagnostics);
}
public async Task DiagnosticsAreSetThroughResponseAsync()
{
List <TransactionalBatchOperationResult> results = new List <TransactionalBatchOperationResult>();
ItemBatchOperation[] arrayOperations = new ItemBatchOperation[1];
ItemBatchOperation operation = new ItemBatchOperation(OperationType.Read, 0, Cosmos.PartitionKey.Null, "0");
results.Add(
new TransactionalBatchOperationResult(HttpStatusCode.OK)
{
ResourceStream = new MemoryStream(new byte[] { 0x41, 0x42 }, index: 0, count: 2, writable: false, publiclyVisible: true),
ETag = operation.Id
});
arrayOperations[0] = operation;
MemoryStream responseContent = await new BatchResponsePayloadWriter(results).GeneratePayloadAsync();
SinglePartitionKeyServerBatchRequest batchRequest = await SinglePartitionKeyServerBatchRequest.CreateAsync(
partitionKey : null,
operations : new ArraySegment <ItemBatchOperation>(arrayOperations),
serializerCore : MockCosmosUtil.Serializer,
trace : NoOpTrace.Singleton,
cancellationToken : default(CancellationToken));
ResponseMessage responseMessage = new ResponseMessage(HttpStatusCode.OK)
{
Content = responseContent,
};
PointOperationStatisticsTraceDatum diagnostics = new PointOperationStatisticsTraceDatum(
activityId: Guid.NewGuid().ToString(),
statusCode: HttpStatusCode.OK,
subStatusCode: SubStatusCodes.Unknown,
responseTimeUtc: DateTime.UtcNow,
requestCharge: 0,
errorMessage: string.Empty,
method: HttpMethod.Get,
requestUri: "http://localhost",
requestSessionToken: null,
responseSessionToken: null);
TransactionalBatchResponse batchresponse;
using (responseMessage.Trace = Trace.GetRootTrace("test trace"))
{
responseMessage.Trace.AddDatum("Point Operation Statistics", diagnostics);
batchresponse = await TransactionalBatchResponse.FromResponseMessageAsync(
responseMessage,
batchRequest,
MockCosmosUtil.Serializer,
true,
responseMessage.Trace,
CancellationToken.None);
}
PartitionKeyRangeBatchResponse response = new PartitionKeyRangeBatchResponse(arrayOperations.Length, batchresponse, MockCosmosUtil.Serializer);
if (!(response.Diagnostics is CosmosTraceDiagnostics cosmosTraceDiagnostics))
{
Assert.Fail();
throw new Exception();
}
Assert.AreEqual(diagnostics, cosmosTraceDiagnostics.Value.Data.Values.First());
}
