private void DoSingleEntityInsertOrReplace(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
TableServiceContext queryContext = tableClient.GetTableServiceContext();
queryContext.MergeOption = MergeOption.NoTracking;
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
SetPayloadFormatOnDataServiceContext(queryContext, format, tableClient);
// Insert Entity
BaseEntity baseEntity = new BaseEntity("insert test", "foo" + format.ToString());
// Insert Or Merge with no pre-existing entity
MergeEntity insertOrReplaceEntity = new MergeEntity(baseEntity.PartitionKey, baseEntity.RowKey);
insertOrReplaceEntity.Randomize();
ctx.AttachTo(currentTable.Name, insertOrReplaceEntity, null);
ctx.UpdateObject(insertOrReplaceEntity);
ctx.SaveChangesWithRetries(SaveChangesOptions.ReplaceOnUpdate);
ctx.Detach(insertOrReplaceEntity);
// Retrieve Entity & Verify Contents
UnionEnitity retrievedEntity = (from ent in queryContext.CreateQuery <UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey &&
ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(queryContext).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(null, retrievedEntity.A);
Assert.AreEqual(null, retrievedEntity.B);
Assert.AreEqual(null, retrievedEntity.C);
Assert.AreEqual(insertOrReplaceEntity.D, retrievedEntity.D);
Assert.AreEqual(insertOrReplaceEntity.E, retrievedEntity.E);
Assert.AreEqual(insertOrReplaceEntity.F, retrievedEntity.F);
BaseEntity replacedEntity = new BaseEntity("insert test", "foo" + format.ToString());
replacedEntity.Randomize();
ctx.AttachTo(currentTable.Name, replacedEntity, null);
ctx.UpdateObject(replacedEntity);
ctx.SaveChangesWithRetries(SaveChangesOptions.ReplaceOnUpdate);
// Retrieve Entity & Verify
retrievedEntity = (from ent in queryContext.CreateQuery <UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey &&
ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(queryContext).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(replacedEntity.A, retrievedEntity.A);
Assert.AreEqual(replacedEntity.B, retrievedEntity.B);
Assert.AreEqual(replacedEntity.C, retrievedEntity.C);
Assert.AreEqual(null, retrievedEntity.D);
Assert.AreEqual(null, retrievedEntity.E);
Assert.AreEqual(null, retrievedEntity.F);
}
private void DoSingleEntityInsertConflict(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Insert Entity
ComplexEntity insertEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AddObject(currentTable.Name, insertEntity);
ctx.SaveChangesWithRetries();
// Attempt Insert Conflict Entity
TableServiceContext ctx2 = tableClient.GetTableServiceContext();
ComplexEntity conflictEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx2.AddObject(currentTable.Name, insertEntity);
OperationContext opContext = new OperationContext();
try
{
ctx2.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.Conflict, new string[] { "EntityAlreadyExists" }, "The specified entity already exists");
}
}
private void DoSingleEntityReplaceFail(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
TableServiceContext secondContext = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
SetPayloadFormatOnDataServiceContext(secondContext, format, tableClient);
// Insert Entity
BaseEntity baseEntity = new BaseEntity("insert test", "foo" + format.ToString());
baseEntity.Randomize();
ctx.AddObject(currentTable.Name, baseEntity);
ctx.SaveChangesWithRetries();
string etag = ctx.Entities.First().ETag;
baseEntity.A = "updated";
ctx.UpdateObject(baseEntity);
ctx.SaveChangesWithRetries();
MergeEntity replaceEntity = new MergeEntity(baseEntity.PartitionKey, baseEntity.RowKey);
replaceEntity.Randomize();
secondContext.AttachTo(currentTable.Name, replaceEntity, etag);
secondContext.UpdateObject(replaceEntity);
OperationContext opContext = new OperationContext();
try
{
secondContext.SaveChangesWithRetries(SaveChangesOptions.ReplaceOnUpdate, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext,
1,
(int)HttpStatusCode.PreconditionFailed,
new string[] { "UpdateConditionNotSatisfied", "ConditionNotMet" },
new string[] { "The update condition specified in the request was not satisfied.", "The condition specified using HTTP conditional header(s) is not met." });
}
ctx.DeleteObject(baseEntity);
ctx.SaveChangesWithRetries();
opContext = new OperationContext();
// try merging with deleted entity
try
{
secondContext.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.NotFound, new string[] { "ResourceNotFound" }, "The specified resource does not exist.");
}
}
private void DoSingleEntityMerge(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
TableServiceContext queryContext = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
SetPayloadFormatOnDataServiceContext(queryContext, format, tableClient);
// Insert Entity
BaseEntity baseEntity = new BaseEntity("insert test", "foo" + format.ToString());
baseEntity.Randomize();
ctx.AddObject(currentTable.Name, baseEntity);
ctx.SaveChangesWithRetries();
string etag = ctx.Entities.First().ETag;
ctx.Detach(baseEntity);
MergeEntity mergeEntity = new MergeEntity(baseEntity.PartitionKey, baseEntity.RowKey);
mergeEntity.Randomize();
ctx.AttachTo(currentTable.Name, mergeEntity, etag);
ctx.UpdateObject(mergeEntity);
ctx.SaveChangesWithRetries();
// Retrieve Entity
UnionEnitity retrievedEntity = (from ent in queryContext.CreateQuery <UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey &&
ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(queryContext).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(baseEntity.A, retrievedEntity.A);
Assert.AreEqual(baseEntity.B, retrievedEntity.B);
Assert.AreEqual(baseEntity.C, retrievedEntity.C);
Assert.AreEqual(mergeEntity.D, retrievedEntity.D);
Assert.AreEqual(mergeEntity.E, retrievedEntity.E);
Assert.AreEqual(mergeEntity.F, retrievedEntity.F);
}
private void DoSingleEntityInsert(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Insert Entity
ComplexEntity insertEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AddObject(currentTable.Name, insertEntity);
ctx.SaveChangesWithRetries();
// Retrieve Entity
ComplexEntity retrievedEntity = (from ent in ctx.CreateQuery <ComplexEntity>(currentTable.Name)
where ent.PartitionKey == insertEntity.PartitionKey &&
ent.RowKey == insertEntity.RowKey
select ent).AsTableServiceQuery(ctx).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
ComplexEntity.AssertEquality(insertEntity, retrievedEntity);
}
private void DoBatchInsert(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Insert Entities
SortedDictionary <string, ComplexEntity> entities = new SortedDictionary <string, ComplexEntity>();
for (int i = 0; i < 100; i++)
{
ComplexEntity insertEntity = new ComplexEntity("insert test" + format.ToString(), "foo" + format.ToString() + i);
entities.Add(insertEntity.RowKey, insertEntity);
ctx.AddObject(currentTable.Name, insertEntity);
}
DataServiceResponse response = ctx.SaveChangesWithRetries(SaveChangesOptions.Batch);
Assert.AreEqual((int)HttpStatusCode.Accepted, response.BatchStatusCode);
// Retrieve Entities
List <ComplexEntity> retrievedEntities = (from ent in ctx.CreateQuery <ComplexEntity>(currentTable.Name)
where ent.PartitionKey == entities.First().Value.PartitionKey
select ent).AsTableServiceQuery(ctx).Execute().ToList();
Assert.AreEqual(entities.Count, retrievedEntities.Count);
foreach (ComplexEntity retrievedEntity in retrievedEntities)
{
ComplexEntity.AssertEquality(entities[retrievedEntity.RowKey], retrievedEntity);
entities.Remove(retrievedEntity.RowKey);
}
Assert.AreEqual(0, entities.Count);
}
private void DoSingleEntityInsert(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Insert Entity
ComplexEntity insertEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AddObject(currentTable.Name, insertEntity);
ctx.SaveChangesWithRetries();
// Retrieve Entity
ComplexEntity retrievedEntity = (from ent in ctx.CreateQuery<ComplexEntity>(currentTable.Name)
where ent.PartitionKey == insertEntity.PartitionKey
&& ent.RowKey == insertEntity.RowKey
select ent).AsTableServiceQuery(ctx).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
ComplexEntity.AssertEquality(insertEntity, retrievedEntity);
}
private async Task DoTableBatchReplaceFailAsync(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
// Insert Entity
DynamicTableEntity baseEntity = new DynamicTableEntity("merge test", "foo" + format.ToString());
baseEntity.Properties.Add("prop1", new EntityProperty("value1"));
await currentTable.ExecuteAsync(TableOperation.Insert(baseEntity));
string staleEtag = baseEntity.ETag;
// update entity to rev etag
baseEntity.Properties["prop1"].StringValue = "updated value";
await currentTable.ExecuteAsync(TableOperation.Replace(baseEntity));
OperationContext opContext = new OperationContext();
try
{
// Attempt a merge with stale etag
DynamicTableEntity replaceEntity = new DynamicTableEntity(baseEntity.PartitionKey, baseEntity.RowKey) { ETag = staleEtag };
replaceEntity.Properties.Add("prop2", new EntityProperty("value2"));
TableBatchOperation batch = new TableBatchOperation();
batch.Replace(replaceEntity);
await currentTable.ExecuteBatchAsync(batch, null, opContext);
Assert.Fail();
}
catch (Exception)
{
TestHelper.ValidateResponse(opContext,
1,
(int)HttpStatusCode.PreconditionFailed,
new string[] { "UpdateConditionNotSatisfied", "ConditionNotMet" },
new string[] { "The update condition specified in the request was not satisfied.", "The condition specified using HTTP conditional header(s) is not met." });
}
// Delete Entity
await currentTable.ExecuteAsync(TableOperation.Delete(baseEntity));
opContext = new OperationContext();
// try replacing with deleted entity
try
{
DynamicTableEntity replaceEntity = new DynamicTableEntity(baseEntity.PartitionKey, baseEntity.RowKey) { ETag = baseEntity.ETag };
replaceEntity.Properties.Add("prop2", new EntityProperty("value2"));
TableBatchOperation batch = new TableBatchOperation();
batch.Replace(replaceEntity);
await currentTable.ExecuteBatchAsync(batch, null, opContext);
Assert.Fail();
}
catch (Exception)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.NotFound, new string[] { "ResourceNotFound" }, "The specified resource does not exist.");
}
}
private async Task DoTableBatchReplaceAsync(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
// Insert Entity
DynamicTableEntity baseEntity = new DynamicTableEntity("merge test", "foo" + format.ToString());
baseEntity.Properties.Add("prop1", new EntityProperty("value1"));
await currentTable.ExecuteAsync(TableOperation.Insert(baseEntity));
// ReplaceEntity
DynamicTableEntity replaceEntity = new DynamicTableEntity(baseEntity.PartitionKey, baseEntity.RowKey) { ETag = baseEntity.ETag };
replaceEntity.Properties.Add("prop2", new EntityProperty("value2"));
TableBatchOperation batch = new TableBatchOperation();
batch.Replace(replaceEntity);
await currentTable.ExecuteBatchAsync(batch);
// Retrieve Entity & Verify Contents
TableResult result = await currentTable.ExecuteAsync(TableOperation.Retrieve(baseEntity.PartitionKey, baseEntity.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(replaceEntity.Properties.Count, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
}
private async Task DoTableBatchInsertOrReplaceAsync(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
// Insert Or Replace with no pre-existing entity
DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity("insertOrReplace entity", "foo" + format.ToString());
insertOrReplaceEntity.Properties.Add("prop1", new EntityProperty("value1"));
TableBatchOperation batch = new TableBatchOperation();
batch.InsertOrReplace(insertOrReplaceEntity);
await currentTable.ExecuteBatchAsync(batch);
// Retrieve Entity & Verify Contents
TableResult result = await currentTable.ExecuteAsync(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrReplaceEntity.Properties.Count, retrievedEntity.Properties.Count);
DynamicTableEntity replaceEntity = new DynamicTableEntity(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey);
replaceEntity.Properties.Add("prop2", new EntityProperty("value2"));
TableBatchOperation batch2 = new TableBatchOperation();
batch2.InsertOrReplace(replaceEntity);
await currentTable.ExecuteBatchAsync(batch2);
// Retrieve Entity & Verify Contents
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(1, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
}
private void DoSingleEntityReplaceFail(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
TableServiceContext secondContext = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
SetPayloadFormatOnDataServiceContext(secondContext, format, tableClient);
// Insert Entity
BaseEntity baseEntity = new BaseEntity("insert test", "foo" + format.ToString());
baseEntity.Randomize();
ctx.AddObject(currentTable.Name, baseEntity);
ctx.SaveChangesWithRetries();
string etag = ctx.Entities.First().ETag;
baseEntity.A = "updated";
ctx.UpdateObject(baseEntity);
ctx.SaveChangesWithRetries();
MergeEntity replaceEntity = new MergeEntity(baseEntity.PartitionKey, baseEntity.RowKey);
replaceEntity.Randomize();
secondContext.AttachTo(currentTable.Name, replaceEntity, etag);
secondContext.UpdateObject(replaceEntity);
OperationContext opContext = new OperationContext();
try
{
secondContext.SaveChangesWithRetries(SaveChangesOptions.ReplaceOnUpdate, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext,
1,
(int)HttpStatusCode.PreconditionFailed,
new string[] { "UpdateConditionNotSatisfied", "ConditionNotMet" },
new string[] { "The update condition specified in the request was not satisfied.", "The condition specified using HTTP conditional header(s) is not met." });
}
ctx.DeleteObject(baseEntity);
ctx.SaveChangesWithRetries();
opContext = new OperationContext();
// try merging with deleted entity
try
{
secondContext.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.NotFound, new string[] { "ResourceNotFound" }, "The specified resource does not exist.");
}
}
private void DoSingleEntityInsertDeleteFail(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Delete Entity that does not exits
ComplexEntity deleteEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AttachTo(currentTable.Name, deleteEntity, "*");
ctx.DeleteObject(deleteEntity);
OperationContext opContext = new OperationContext();
try
{
ctx.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.NotFound, new string[] { "ResourceNotFound" }, "The specified resource does not exist.");
}
ctx = tableClient.GetTableServiceContext();
TableServiceContext ctx2 = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx2, format, tableClient);
// Insert Entity
ComplexEntity insertEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AddObject(currentTable.Name, insertEntity);
ctx.SaveChangesWithRetries();
// Update Entity
ComplexEntity retrievedEntity = (from ent in ctx2.CreateQuery<ComplexEntity>(currentTable.Name)
where ent.PartitionKey == insertEntity.PartitionKey
&& ent.RowKey == insertEntity.RowKey
select ent).AsTableServiceQuery(ctx2).Execute().FirstOrDefault();
retrievedEntity.String = "updated value";
ctx2.UpdateObject(retrievedEntity);
ctx2.SaveChangesWithRetries();
// Now delete old reference with stale etag and validate exception
ctx.DeleteObject(insertEntity);
opContext = new OperationContext();
try
{
ctx.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext,
1,
(int)HttpStatusCode.PreconditionFailed,
new string[] { "UpdateConditionNotSatisfied", "ConditionNotMet" },
new string[] { "The update condition specified in the request was not satisfied.", "The condition specified using HTTP conditional header(s) is not met." });
}
}
private void DoTableOperationMergeSync(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
// Insert Entity
DynamicTableEntity baseEntity = new DynamicTableEntity("merge test", "foo" + format.ToString());
baseEntity.Properties.Add("prop1", new EntityProperty("value1"));
currentTable.Execute(TableOperation.Insert(baseEntity));
DynamicTableEntity mergeEntity = new DynamicTableEntity(baseEntity.PartitionKey, baseEntity.RowKey) { ETag = baseEntity.ETag };
mergeEntity.Properties.Add("prop2", new EntityProperty("value2"));
currentTable.Execute(TableOperation.Merge(mergeEntity));
// Retrieve Entity & Verify Contents
TableResult result = currentTable.Execute(TableOperation.Retrieve(baseEntity.PartitionKey, baseEntity.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(2, retrievedEntity.Properties.Count);
Assert.AreEqual(baseEntity.Properties["prop1"], retrievedEntity.Properties["prop1"]);
Assert.AreEqual(mergeEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
}
private void DoSingleEntityInsertDeleteFail(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Delete Entity that does not exits
ComplexEntity deleteEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AttachTo(currentTable.Name, deleteEntity, "*");
ctx.DeleteObject(deleteEntity);
OperationContext opContext = new OperationContext();
try
{
ctx.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.NotFound, new string[] { "ResourceNotFound" }, "The specified resource does not exist.");
}
ctx = tableClient.GetTableServiceContext();
TableServiceContext ctx2 = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx2, format, tableClient);
// Insert Entity
ComplexEntity insertEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AddObject(currentTable.Name, insertEntity);
ctx.SaveChangesWithRetries();
// Update Entity
ComplexEntity retrievedEntity = (from ent in ctx2.CreateQuery <ComplexEntity>(currentTable.Name)
where ent.PartitionKey == insertEntity.PartitionKey &&
ent.RowKey == insertEntity.RowKey
select ent).AsTableServiceQuery(ctx2).Execute().FirstOrDefault();
retrievedEntity.String = "updated value";
ctx2.UpdateObject(retrievedEntity);
ctx2.SaveChangesWithRetries();
// Now delete old reference with stale etag and validate exception
ctx.DeleteObject(insertEntity);
opContext = new OperationContext();
try
{
ctx.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext,
1,
(int)HttpStatusCode.PreconditionFailed,
new string[] { "UpdateConditionNotSatisfied", "ConditionNotMet" },
new string[] { "The update condition specified in the request was not satisfied.", "The condition specified using HTTP conditional header(s) is not met." });
}
}
private void DoSingleEntityInsertConflict(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Insert Entity
ComplexEntity insertEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx.AddObject(currentTable.Name, insertEntity);
ctx.SaveChangesWithRetries();
// Attempt Insert Conflict Entity
TableServiceContext ctx2 = tableClient.GetTableServiceContext();
ComplexEntity conflictEntity = new ComplexEntity("insert test", "foo" + format.ToString());
ctx2.AddObject(currentTable.Name, insertEntity);
OperationContext opContext = new OperationContext();
try
{
ctx2.SaveChangesWithRetries(SaveChangesOptions.None, null, opContext);
Assert.Fail();
}
catch (StorageException)
{
TestHelper.ValidateResponse(opContext, 1, (int)HttpStatusCode.Conflict, new string[] { "EntityAlreadyExists" }, "The specified entity already exists");
}
}
private async Task DoTableOperationInsertOrMerge(TablePayloadFormat format)
{
tableClient.PayloadFormat = format;
// Insert Or Merge with no pre-existing entity
DynamicTableEntity insertOrMergeEntity = new DynamicTableEntity("insertOrMerge entity", "foo" + format.ToString());
insertOrMergeEntity.Properties.Add("prop1", new EntityProperty("value1"));
await currentTable.ExecuteAsync(TableOperation.InsertOrMerge(insertOrMergeEntity));
// Retrieve Entity & Verify Contents
TableResult result = await currentTable.ExecuteAsync(TableOperation.Retrieve(insertOrMergeEntity.PartitionKey, insertOrMergeEntity.RowKey));
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrMergeEntity.Properties.Count, retrievedEntity.Properties.Count);
DynamicTableEntity mergeEntity = new DynamicTableEntity(insertOrMergeEntity.PartitionKey, insertOrMergeEntity.RowKey);
mergeEntity.Properties.Add("prop2", new EntityProperty("value2"));
await currentTable.ExecuteAsync(TableOperation.InsertOrMerge(mergeEntity));
// Retrieve Entity & Verify Contents
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(insertOrMergeEntity.PartitionKey, insertOrMergeEntity.RowKey));
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(2, retrievedEntity.Properties.Count);
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrMergeEntity.Properties["prop1"], retrievedEntity.Properties["prop1"]);
Assert.AreEqual(mergeEntity.Properties["prop2"], retrievedEntity.Properties["prop2"]);
}
private void DoSingleEntityInsertOrMerge(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
TableServiceContext queryContext = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
SetPayloadFormatOnDataServiceContext(queryContext, format, tableClient);
// Insert Entity
BaseEntity baseEntity = new BaseEntity("insert test", "foo" + format.ToString());
// Insert Or Merge with no pre-existing entity
MergeEntity insertOrMergeEntity = new MergeEntity(baseEntity.PartitionKey, baseEntity.RowKey);
insertOrMergeEntity.Randomize();
ctx.AttachTo(currentTable.Name, insertOrMergeEntity, null);
ctx.UpdateObject(insertOrMergeEntity);
ctx.SaveChangesWithRetries();
ctx.Detach(insertOrMergeEntity);
// Retrieve Entity & Verify Contents
UnionEnitity retrievedEntity = (from ent in queryContext.CreateQuery<UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey
&& ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(ctx).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrMergeEntity.D, retrievedEntity.D);
Assert.AreEqual(insertOrMergeEntity.E, retrievedEntity.E);
Assert.AreEqual(insertOrMergeEntity.F, retrievedEntity.F);
UnionEnitity mergedEntity = new UnionEnitity("insert test", "foo" + format.ToString());
mergedEntity.Randomize();
mergedEntity.D = insertOrMergeEntity.D;
mergedEntity.E = insertOrMergeEntity.E;
mergedEntity.F = insertOrMergeEntity.F;
ctx.AttachTo(currentTable.Name, mergedEntity, null);
ctx.UpdateObject(mergedEntity);
ctx.SaveChangesWithRetries();
ctx.Detach(mergedEntity);
// Retrieve Entity & Verify
retrievedEntity = (from ent in queryContext.CreateQuery<UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey
&& ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(queryContext).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(mergedEntity.A, retrievedEntity.A);
Assert.AreEqual(mergedEntity.B, retrievedEntity.B);
Assert.AreEqual(mergedEntity.C, retrievedEntity.C);
Assert.AreEqual(mergedEntity.D, retrievedEntity.D);
Assert.AreEqual(mergedEntity.E, retrievedEntity.E);
Assert.AreEqual(mergedEntity.F, retrievedEntity.F);
}
private void DoTableBatchOperationWithRetryHasCorrectNumberOfResults(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
TableBatchOperation batch = new TableBatchOperation();
for (int i = 0; i < 100; i++)
{
DynamicTableEntity insertEntity = new DynamicTableEntity("retry test", format.ToString() + i.ToString());
insertEntity.Properties.Add("prop", new EntityProperty(new byte[20 * 1024]));
batch.Insert(insertEntity);
}
IList<TableResult> results = null;
TestHelper.ExecuteMethodWithRetry(
3,
new[] {
// Insert upstream network delay to prevent upload to server @ 1000ms / kb
PerformanceBehaviors.InsertUpstreamNetworkDelay(10000,
AzureStorageSelectors.TableTraffic().IfHostNameContains(tableClient.Credentials.AccountName),
new BehaviorOptions(2)),
// After 500 ms return throttle message
DelayedActionBehaviors.ExecuteAfter(Actions.ThrottleTableRequest,
100,
AzureStorageSelectors.TableTraffic().IfHostNameContains(tableClient.Credentials.AccountName),
new BehaviorOptions(2))
},
(options, opContext) => results = currentTable.ExecuteBatch(batch, (TableRequestOptions)options, opContext));
Assert.AreEqual(batch.Count, results.Count);
}
private void DoSingleEntityReplace(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
TableServiceContext queryContext = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
SetPayloadFormatOnDataServiceContext(queryContext, format, tableClient);
// Insert Entity
BaseEntity baseEntity = new BaseEntity("insert test", "foo" + format.ToString());
baseEntity.Randomize();
ctx.AddObject(currentTable.Name, baseEntity);
ctx.SaveChangesWithRetries();
string etag = ctx.Entities.First().ETag;
ctx.Detach(baseEntity);
MergeEntity replaceEntity = new MergeEntity(baseEntity.PartitionKey, baseEntity.RowKey);
replaceEntity.Randomize();
ctx.AttachTo(currentTable.Name, replaceEntity, etag);
ctx.UpdateObject(replaceEntity);
ctx.SaveChangesWithRetries(SaveChangesOptions.ReplaceOnUpdate);
// Retrieve Entity
UnionEnitity retrievedEntity = (from ent in queryContext.CreateQuery<UnionEnitity>(currentTable.Name)
where ent.PartitionKey == baseEntity.PartitionKey
&& ent.RowKey == baseEntity.RowKey
select ent).AsTableServiceQuery(queryContext).Execute().FirstOrDefault();
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(null, retrievedEntity.A);
Assert.AreEqual(null, retrievedEntity.B);
Assert.AreEqual(null, retrievedEntity.C);
Assert.AreEqual(replaceEntity.D, retrievedEntity.D);
Assert.AreEqual(replaceEntity.E, retrievedEntity.E);
Assert.AreEqual(replaceEntity.F, retrievedEntity.F);
}
private void DoTableBatchInsertOrReplaceEncryption(TablePayloadFormat format)
{
tableClient.DefaultRequestOptions.PayloadFormat = format;
// Create the Key to be used for wrapping.
SymmetricKey aesKey = new SymmetricKey("symencryptionkey");
TableRequestOptions options = new TableRequestOptions()
{
EncryptionPolicy = new TableEncryptionPolicy(aesKey, null),
EncryptionResolver = (pk, rk, propName) =>
{
if (propName == "A" || propName == "B")
{
return true;
}
return false;
}
};
// Insert Or Replace with no pre-existing entity
DynamicTableEntity insertOrReplaceEntity = new DynamicTableEntity("insertOrReplace entity", "foo" + format.ToString());
insertOrReplaceEntity.Properties.Add("A", new EntityProperty("a"));
TableBatchOperation batch = new TableBatchOperation();
batch.InsertOrReplace(insertOrReplaceEntity);
currentTable.ExecuteBatch(batch, options);
// Retrieve Entity & Verify Contents
// Create the resolver to be used for unwrapping.
DictionaryKeyResolver resolver = new DictionaryKeyResolver();
resolver.Add(aesKey);
TableRequestOptions retrieveOptions = new TableRequestOptions() { EncryptionPolicy = new TableEncryptionPolicy(null, resolver) };
TableResult result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey), retrieveOptions);
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(insertOrReplaceEntity.Properties.Count, retrievedEntity.Properties.Count);
DynamicTableEntity replaceEntity = new DynamicTableEntity(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey);
replaceEntity.Properties.Add("B", new EntityProperty("b"));
TableBatchOperation batch2 = new TableBatchOperation();
batch2.InsertOrReplace(replaceEntity);
currentTable.ExecuteBatch(batch2, options);
// Retrieve Entity & Verify Contents
result = currentTable.Execute(TableOperation.Retrieve(insertOrReplaceEntity.PartitionKey, insertOrReplaceEntity.RowKey), retrieveOptions);
retrievedEntity = result.Result as DynamicTableEntity;
Assert.IsNotNull(retrievedEntity);
Assert.AreEqual(1, retrievedEntity.Properties.Count);
Assert.AreEqual(replaceEntity.Properties["B"], retrievedEntity.Properties["B"]);
}
private void DoBatchInsert(TablePayloadFormat format)
{
CloudTableClient tableClient = GenerateCloudTableClient();
TableServiceContext ctx = tableClient.GetTableServiceContext();
SetPayloadFormatOnDataServiceContext(ctx, format, tableClient);
// Insert Entities
SortedDictionary<string, ComplexEntity> entities = new SortedDictionary<string, ComplexEntity>();
for (int i = 0; i < 100; i++)
{
ComplexEntity insertEntity = new ComplexEntity("insert test" + format.ToString(), "foo" + format.ToString() + i);
entities.Add(insertEntity.RowKey, insertEntity);
ctx.AddObject(currentTable.Name, insertEntity);
}
DataServiceResponse response = ctx.SaveChangesWithRetries(SaveChangesOptions.Batch);
Assert.AreEqual((int)HttpStatusCode.Accepted, response.BatchStatusCode);
// Retrieve Entities
List<ComplexEntity> retrievedEntities = (from ent in ctx.CreateQuery<ComplexEntity>(currentTable.Name)
where ent.PartitionKey == entities.First().Value.PartitionKey
select ent).AsTableServiceQuery(ctx).Execute().ToList();
Assert.AreEqual(entities.Count, retrievedEntities.Count);
foreach (ComplexEntity retrievedEntity in retrievedEntities)
{
ComplexEntity.AssertEquality(entities[retrievedEntity.RowKey], retrievedEntity);
entities.Remove(retrievedEntity.RowKey);
}
Assert.AreEqual(0, entities.Count);
}
private async Task DoTableBatchRetrieveAsync(TablePayloadFormat payloadFormat)
{
if (payloadFormat == TablePayloadFormat.JsonNoMetadata)
{
// Entities not resolved correctly for no metadata JSON.
return;
}
tableClient.DefaultRequestOptions.PayloadFormat = payloadFormat;
string pk = Guid.NewGuid().ToString();
// Add insert
DynamicTableEntity sendEnt = new DynamicTableEntity();
sendEnt.Properties.Add("foo", new EntityProperty("bar" + payloadFormat.ToString()));
sendEnt.PartitionKey = pk;
sendEnt.RowKey = Guid.NewGuid().ToString();
// generate a set of properties for all supported Types
sendEnt.Properties = new ComplexEntity().WriteEntity(null);
// not found
TableResult result = await currentTable.ExecuteAsync(TableOperation.Retrieve(sendEnt.PartitionKey, sendEnt.RowKey));
Assert.AreEqual(result.HttpStatusCode, (int)HttpStatusCode.NotFound);
Assert.IsNull(result.Result);
Assert.IsNull(result.Etag);
// insert entity
await currentTable.ExecuteAsync(TableOperation.Insert(sendEnt));
// Success
result = await currentTable.ExecuteAsync(TableOperation.Retrieve(sendEnt.PartitionKey, sendEnt.RowKey));
Assert.AreEqual(result.HttpStatusCode, (int)HttpStatusCode.OK);
DynamicTableEntity retrievedEntity = result.Result as DynamicTableEntity;
// Validate entity
Assert.AreEqual(sendEnt.Properties["String"], retrievedEntity.Properties["String"]);
Assert.AreEqual(sendEnt.Properties["Int64"], retrievedEntity.Properties["Int64"]);
Assert.AreEqual(sendEnt.Properties["Int64N"], retrievedEntity.Properties["Int64N"]);
Assert.AreEqual(sendEnt.Properties["LongPrimitive"], retrievedEntity.Properties["LongPrimitive"]);
Assert.AreEqual(sendEnt.Properties["LongPrimitiveN"], retrievedEntity.Properties["LongPrimitiveN"]);
Assert.AreEqual(sendEnt.Properties["Int32"], retrievedEntity.Properties["Int32"]);
Assert.AreEqual(sendEnt.Properties["Int32N"], retrievedEntity.Properties["Int32N"]);
Assert.AreEqual(sendEnt.Properties["IntegerPrimitive"], retrievedEntity.Properties["IntegerPrimitive"]);
Assert.AreEqual(sendEnt.Properties["IntegerPrimitiveN"], retrievedEntity.Properties["IntegerPrimitiveN"]);
Assert.AreEqual(sendEnt.Properties["Guid"], retrievedEntity.Properties["Guid"]);
Assert.AreEqual(sendEnt.Properties["GuidN"], retrievedEntity.Properties["GuidN"]);
Assert.AreEqual(sendEnt.Properties["Double"], retrievedEntity.Properties["Double"]);
Assert.AreEqual(sendEnt.Properties["DoubleN"], retrievedEntity.Properties["DoubleN"]);
Assert.AreEqual(sendEnt.Properties["DoublePrimitive"], retrievedEntity.Properties["DoublePrimitive"]);
Assert.AreEqual(sendEnt.Properties["DoublePrimitiveN"], retrievedEntity.Properties["DoublePrimitiveN"]);
Assert.AreEqual(sendEnt.Properties["BinaryPrimitive"], retrievedEntity.Properties["BinaryPrimitive"]);
Assert.AreEqual(sendEnt.Properties["Binary"], retrievedEntity.Properties["Binary"]);
Assert.AreEqual(sendEnt.Properties["BoolPrimitive"], retrievedEntity.Properties["BoolPrimitive"]);
Assert.AreEqual(sendEnt.Properties["BoolPrimitiveN"], retrievedEntity.Properties["BoolPrimitiveN"]);
Assert.AreEqual(sendEnt.Properties["Bool"], retrievedEntity.Properties["Bool"]);
Assert.AreEqual(sendEnt.Properties["BoolN"], retrievedEntity.Properties["BoolN"]);
Assert.AreEqual(sendEnt.Properties["DateTimeOffsetN"], retrievedEntity.Properties["DateTimeOffsetN"]);
Assert.AreEqual(sendEnt.Properties["DateTimeOffset"], retrievedEntity.Properties["DateTimeOffset"]);
Assert.AreEqual(sendEnt.Properties["DateTime"], retrievedEntity.Properties["DateTime"]);
Assert.AreEqual(sendEnt.Properties["DateTimeN"], retrievedEntity.Properties["DateTimeN"]);
}
