public async Task BasicPatchTests([CombinatorialValues("movies", "movies_pagesize")] string table)
{
var id = GetRandomId();
var expected = MovieServer.GetMovieById(id) !;
expected.Title = "Test Movie Title";
expected.Rating = "PG-13";
var patchDoc = new PatchOperation[]
{
new PatchOperation("replace", "title", "Test Movie Title"),
new PatchOperation("replace", "rating", "PG-13")
};
var response = await MovieServer.SendPatch($"tables/{table}/{id}", patchDoc);
await AssertResponseWithLoggingAsync(HttpStatusCode.OK, response);
var result = response.DeserializeContent <ClientMovie>();
var stored = MovieServer.GetMovieById(id);
AssertEx.SystemPropertiesSet(stored, StartTime);
AssertEx.SystemPropertiesChanged(expected, stored);
AssertEx.SystemPropertiesMatch(stored, result);
Assert.Equal <IMovie>(expected, result !);
AssertEx.ResponseHasConditionalHeaders(stored, response);
}
public async Task AllowBatchingRequestsSendsToExecutor_PatchStream()
{
(ContainerInternal container, Mock <BatchAsyncContainerExecutor> mockedExecutor) = this.CreateMockBulkCosmosClientContext();
dynamic testItem = new
{
id = Guid.NewGuid().ToString(),
pk = "FF627B77-568E-4541-A47E-041EAC10E46F",
};
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Add("/new", "patched")
};
ItemRequestOptions itemRequestOptions = new ItemRequestOptions();
Cosmos.PartitionKey partitionKey = new Cosmos.PartitionKey(testItem.pk);
using (ResponseMessage streamResponse = await container.PatchItemStreamAsync(
partitionKey: partitionKey,
id: testItem.id,
patchOperations: patch))
{
mockedExecutor.Verify(c => c.AddAsync(It.IsAny <ItemBatchOperation>(), It.IsAny <ItemRequestOptions>(), It.IsAny <CancellationToken>()), Times.Once);
}
}
public async Task ItemBulkNoResponseTest()
{
ItemRequestOptions requestOptions = new ItemRequestOptions()
{
EnableContentResponseOnWrite = false
};
CosmosClient bulkClient = TestCommon.CreateCosmosClient((builder) => builder.WithBulkExecution(true));
Container bulkContainer = bulkClient.GetContainer(this.database.Id, this.container.Id);
ContainerInternal bulkContainerInternal = (ContainerInternal)bulkContainer;
string pkId = "TestBulkId";
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Remove("/cost")
};
List <Task <ItemResponse <ToDoActivity> > > bulkOperations = new List <Task <ItemResponse <ToDoActivity> > >();
List <ToDoActivity> items = new List <ToDoActivity>();
for (int i = 0; i < 50; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkId);
items.Add(item);
bulkOperations.Add(bulkContainer.CreateItemAsync <ToDoActivity>(item, requestOptions: requestOptions));
}
foreach (Task <ItemResponse <ToDoActivity> > result in bulkOperations)
{
ItemResponse <ToDoActivity> itemResponse = await result;
this.ValidateItemNoContentResponse(itemResponse);
}
PatchItemRequestOptions patchRequestOptions = new PatchItemRequestOptions()
{
EnableContentResponseOnWrite = false
};
foreach (ToDoActivity item in items)
{
bulkOperations.Add(bulkContainerInternal.PatchItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk), patch, requestOptions: patchRequestOptions));
}
foreach (Task <ItemResponse <ToDoActivity> > result in bulkOperations)
{
ItemResponse <ToDoActivity> itemResponse = await result;
this.ValidateItemNoContentResponse(itemResponse);
}
bulkOperations = new List <Task <ItemResponse <ToDoActivity> > >();
foreach (ToDoActivity item in items)
{
bulkOperations.Add(bulkContainer.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk), requestOptions: requestOptions));
}
foreach (Task <ItemResponse <ToDoActivity> > result in bulkOperations)
{
ItemResponse <ToDoActivity> itemResponse = await result;
this.ValidateItemResponse(itemResponse);
}
}
private static void LoadSaveGamePatchesFor(ModContentPack mod) //Taken from Verse.ModContentPack.LoadPatches()
{
List <LoadableXmlAsset> list = DirectXmlLoader.XmlAssetsInModFolder(mod, "SaveGamePatches/").ToList <LoadableXmlAsset> ();
for (int i = 0; i < list.Count; i++)
{
XmlElement documentElement = list [i].xmlDoc.DocumentElement;
if (documentElement.Name != "Patch")
{
Log.Error(string.Format("Unexpected document element in patch XML; got {0}, expected 'Patch'", documentElement.Name));
}
else
{
for (int j = 0; j < documentElement.ChildNodes.Count; j++)
{
XmlNode xmlNode = documentElement.ChildNodes [j];
if (xmlNode.NodeType == XmlNodeType.Element)
{
if (xmlNode.Name != "Operation")
{
Log.Error(string.Format("Unexpected element in patch XML; got {0}, expected 'Operation'", documentElement.ChildNodes [j].Name));
}
else
{
PatchOperation patchOperation = DirectXmlToObject.ObjectFromXml <PatchOperation> (xmlNode, false);
patchOperation.sourceFile = list [i].FullFilePath;
SaveGamePatches.patches.Add(patchOperation);
}
}
}
}
}
}
public async Task StreamOperationsTest(ConnectionMode mode)
{
Container container = await this.GetContainer(mode);
// Create an item
var testItem = new { id = "MyTestItemId", partitionKeyPath = "MyTestPkValue", details = "it's working", status = "done" };
await container
.CreateItemStreamAsync(TestCommon.SerializerCore.ToStream(testItem),
new Cosmos.PartitionKey(testItem.id));
//Upsert an Item
await container.UpsertItemStreamAsync(TestCommon.SerializerCore.ToStream(testItem), new Cosmos.PartitionKey(testItem.id));
//Read an Item
await container.ReadItemStreamAsync(testItem.id, new Cosmos.PartitionKey(testItem.id));
//Replace an Item
await container.ReplaceItemStreamAsync(TestCommon.SerializerCore.ToStream(testItem), testItem.id, new Cosmos.PartitionKey(testItem.id));
// Patch an Item
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Add("/new", "patched")
};
await((ContainerInternal)container).PatchItemStreamAsync(
partitionKey: new Cosmos.PartitionKey(testItem.id),
id: testItem.id,
patchOperations: patch);
//Delete an Item
await container.DeleteItemStreamAsync(testItem.id, new Cosmos.PartitionKey(testItem.id));
await this.WaitAndAssert(12);
}
private static void ValidateOperations <T>(PatchOperation patchOperation, PatchOperationType operationType, T value)
{
Assert.AreEqual(operationType, patchOperation.OperationType);
Assert.AreEqual(path, patchOperation.Path);
if (!operationType.Equals(PatchOperationType.Remove))
{
string expected;
CosmosSerializer cosmosSerializer = new CosmosJsonDotNetSerializer();
using (Stream stream = cosmosSerializer.ToStream(value))
{
using (StreamReader streamReader = new StreamReader(stream))
{
expected = streamReader.ReadToEnd();
}
}
Assert.IsTrue(patchOperation.TrySerializeValueParameter(new CustomSerializer(), out Stream valueParam));
string actual;
using (valueParam)
{
using (StreamReader streamReader = new StreamReader(valueParam))
{
actual = streamReader.ReadToEnd();
}
}
Assert.AreEqual(expected, actual);
}
}
public void CreateCopy()
{
PatchOperation patchOperation = PatchOperation.CreateCopy(new Range <int>(10, 15));
Assert.AreEqual(PatchOperationType.Copy, patchOperation.Type);
Assert.AreEqual(new Range <int>(10, 15), patchOperation.Copy);
}
public void CreateDeletion()
{
PatchOperation patchOperation = PatchOperation.CreateDeletion(new Range <int>(10, 15));
Assert.AreEqual(PatchOperationType.Deletion, patchOperation.Type);
Assert.AreEqual(new Range <int>(10, 15), patchOperation.Deletion);
}
public async Task PointSuccessOperationsTest(ConnectionMode mode)
{
Container container = await this.GetContainer(mode);
// Create an item
ToDoActivity testItem = ToDoActivity.CreateRandomToDoActivity("MyTestPkValue");
ItemResponse <ToDoActivity> createResponse = await container.CreateItemAsync <ToDoActivity>(testItem);
ToDoActivity testItemCreated = createResponse.Resource;
// Read an Item
await container.ReadItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.id));
// Upsert an Item
await container.UpsertItemAsync <ToDoActivity>(testItem);
// Replace an Item
await container.ReplaceItemAsync <ToDoActivity>(testItemCreated, testItemCreated.id.ToString());
// Patch an Item
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Add("/new", "patched")
};
await((ContainerInternal)container).PatchItemAsync <ToDoActivity>(
testItem.id,
new Cosmos.PartitionKey(testItem.id),
patch);
// Delete an Item
await container.DeleteItemAsync <ToDoActivity>(testItem.id, new Cosmos.PartitionKey(testItem.id));
await this.WaitAndAssert(12);
}
public PackageItemContainer(XmlElement element) : base(element)
{
Children = new SetCollection();
Operations = new OperationCollection();
foreach (XmlElement e in element.ChildNodes)
{
switch (e.Name)
{
case "set":
Set set = new Set(e);
Children.Add(set);
break;
case "patch":
PatchOperation patch = new PatchOperation(e);
Operations.Add(patch);
break;
case "file":
case "filetype":
break;
}
}
}
public void ConstructPatchOperationTest()
{
PatchOperation operation = PatchOperation.CreateAddOperation(path, "string");
PatchOperationTests.ValidateOperations(operation, PatchOperationType.Add, "string");
DateTime current = DateTime.UtcNow;
operation = PatchOperation.CreateAddOperation(path, current);
PatchOperationTests.ValidateOperations(operation, PatchOperationType.Add, current);
dynamic complexObject = new { a = "complex", b = 12.34, c = true };
operation = PatchOperation.CreateAddOperation(path, complexObject);
PatchOperationTests.ValidateOperations(operation, PatchOperationType.Add, complexObject);
operation = PatchOperation.CreateRemoveOperation(path);
PatchOperationTests.ValidateOperations(operation, PatchOperationType.Remove, "value not required");
int[] arrayObject = { 1, 2, 3 };
operation = PatchOperation.CreateReplaceOperation(path, arrayObject);
PatchOperationTests.ValidateOperations(operation, PatchOperationType.Replace, arrayObject);
Guid guid = new Guid();
operation = PatchOperation.CreateSetOperation(path, guid);
PatchOperationTests.ValidateOperations(operation, PatchOperationType.Set, guid);
}
public PatchRequest2 ComposeReferencePatch(
string referenceAttributeName,
string referencedObjectUniqueIdentifier,
OperationName operationName)
{
Assert.IsFalse(string.IsNullOrWhiteSpace(referenceAttributeName));
Assert.IsFalse(string.IsNullOrWhiteSpace(referencedObjectUniqueIdentifier));
IPath path;
Assert.IsTrue(Path.TryParse(referenceAttributeName, out path));
OperationValue operationValue =
new OperationValue()
{
Value = referencedObjectUniqueIdentifier
};
PatchOperation operation =
new PatchOperation()
{
Name = operationName,
Path = path
};
operation.AddValue(operationValue);
PatchRequest2 result = new PatchRequest2();
result.AddOperation(operation);
return(result);
}
public void ValidatePatchOperationSerialization()
{
int toCount = 0;
int fromCount = 0;
CosmosSerializerHelper serializerHelper = new CosmosSerializerHelper(
null,
(input) => fromCount++,
(input) => toCount++);
CosmosSerializerCore serializerCore = new CosmosSerializerCore(serializerHelper);
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Remove("/removePath")
};
Assert.AreEqual(0, toCount);
// custom serializer is not used since operation type is Remove, which doesnt have "value" param to serialize
using (Stream stream = serializerCore.ToStream(patch)) { }
Assert.AreEqual(0, toCount);
patch.Add(PatchOperation.Add("/addPath", "addValue"));
// custom serializer is used since there is Add operation type also
using (Stream stream = serializerCore.ToStream(patch)) { }
Assert.AreEqual(1, toCount);
}
public async Task BatchOperationDiagnostic(bool disableDiagnostics)
{
string pkValue = "DiagnosticTestPk";
TransactionalBatch batch = this.Container.CreateTransactionalBatch(new PartitionKey(pkValue));
BatchCore batchCore = (BatchCore)batch;
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Remove("/cost")
};
List <ToDoActivity> createItems = new List <ToDoActivity>();
for (int i = 0; i < 50; i++)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity(pk: pkValue);
createItems.Add(item);
batch.CreateItem <ToDoActivity>(item);
}
for (int i = 0; i < 20; i++)
{
batch.ReadItem(createItems[i].id);
batchCore.PatchItem(createItems[i].id, patch);
}
TransactionalBatchRequestOptions requestOptions = disableDiagnostics ? RequestOptionDisableDiagnostic : null;
TransactionalBatchResponse response = await batch.ExecuteAsync(requestOptions);
Assert.IsNotNull(response);
CosmosDiagnosticsTests.VerifyPointDiagnostics(
diagnostics: response.Diagnostics,
disableDiagnostics: disableDiagnostics);
}
/// <inheritdoc />
public override async Task <ResourceResponse> ExecuteAsync(PatchResourceRequest request)
{
try
{
var resource = await this.Repository.ReadResourceAsync(request.ResourceId);
resource = this.PatchApplier.ApplyTo(resource, PatchOperation.Parse(request.Payload));
resource = await this.Repository.UpdateResourceAsync(resource);
return(new ResourceResponse {
Code = ResponseCode.Success, Resource = resource
});
}
catch (ResourceNotFoundException exception)
{
return(new ResourceResponse {
Code = ResponseCode.ResourceNotFound, Exception = exception
});
}
catch (Exception exception)
{
return(new ResourceResponse {
Code = ResponseCode.Failure, Exception = exception
});
}
}
public void Equals()
{
Assert.AreEqual(PatchOperation.CreateAddition(1, 10), PatchOperation.CreateAddition(1, 10));
Assert.AreEqual(PatchOperation.CreateDeletion(1, 10), PatchOperation.CreateDeletion(1, 10));
Assert.AreEqual(PatchOperation.CreateCopy(1, 10), PatchOperation.CreateCopy(1, 10));
Assert.AreNotEqual(PatchOperation.CreateAddition(1, 10), PatchOperation.CreateDeletion(1, 10));
Assert.AreNotEqual(PatchOperation.CreateAddition(1, 10), PatchOperation.CreateCopy(1, 10));
Assert.AreNotEqual(PatchOperation.CreateAddition(1, 10), PatchOperation.CreateAddition(10, 1));
Assert.AreNotEqual(PatchOperation.CreateDeletion(1, 10), PatchOperation.CreateAddition(1, 10));
Assert.AreNotEqual(PatchOperation.CreateDeletion(1, 10), PatchOperation.CreateDeletion(10, 1));
Assert.AreNotEqual(PatchOperation.CreateDeletion(1, 10), PatchOperation.CreateCopy(10, 1));
Assert.AreNotEqual(PatchOperation.CreateCopy(1, 10), PatchOperation.CreateAddition(1, 10));
Assert.AreNotEqual(PatchOperation.CreateCopy(1, 10), PatchOperation.CreateCopy(10, 1));
Assert.AreNotEqual(PatchOperation.CreateCopy(1, 10), PatchOperation.CreateDeletion(10, 1));
Assert.AreNotEqual(PatchOperation.CreateAddition(1, 1), null);
Assert.AreNotEqual(PatchOperation.CreateAddition(1, 1), string.Empty);
Assert.AreNotEqual(PatchOperation.CreateDeletion(1, 1), null);
Assert.AreNotEqual(PatchOperation.CreateDeletion(1, 1), string.Empty);
Assert.AreNotEqual(PatchOperation.CreateCopy(1, 1), null);
Assert.AreNotEqual(PatchOperation.CreateCopy(1, 1), string.Empty);
}
public void GetPatchOperations11()
{
DiffEngine <string> diffEngine =
new DiffEngine <string>(
"The metrics for clarity are more-well understood. Do you have a game PLAN to become peerlessly synergetic across all platforms ? Think interactive".Split(' '),
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
//0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
"The metrics for obfuscation are more-well understood. Do you have a game plan to become cross-media ? Think interactive".Split(' '));
PatchOperation[] expectedPatchOperations =
new PatchOperation[] {
PatchOperation.CreateCopy(0, 2),
PatchOperation.CreateAddition(3, 3),
PatchOperation.CreateDeletion(3, 3),
PatchOperation.CreateCopy(4, 11),
PatchOperation.CreateAddition(12, 12),
PatchOperation.CreateDeletion(12, 12),
PatchOperation.CreateCopy(13, 14),
PatchOperation.CreateAddition(15, 15),
PatchOperation.CreateDeletion(15, 19),
PatchOperation.CreateCopy(20, 22)
};
AssertDifferences(diffEngine, expectedPatchOperations);
}
public void CanOverwrite()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Person
{
Name = "John Doe"
}, "people/1");
session.SaveChanges();
}
var reqEx = store.GetRequestExecutor();
using (reqEx.ContextPool.AllocateOperationContext(out var context))
{
PatchOperation operation = new PatchOperation(
id: "people/1",
changeVector: null,
patch: new PatchRequest
{
Script = @"this.NewField= 'new value';
console.log('foo')"
},
patchIfMissing: null);
var cmd = operation.GetCommand(store, store.Conventions, context, reqEx.Cache, true, false);
store.Commands().Execute(cmd);
Assert.Equal("foo", (cmd.Result.Debug["Info"] as BlittableJsonReaderArray)[0].ToString());
}
}
}
public async Task CompareRUs(IEnumerable <RGB> rgbList)
{
try
{
RGB rgb = rgbList.ElementAt(0);
Console.Write("Execute ReplaceItemAsync to update a item [{0}]'s field [/R]... ", rgb.id);
ItemResponse <RGB> responseReplace = await this.Container.ReplaceItemAsync(
partitionKey : new PartitionKey(rgb.x),
id : rgb.id,
item : rgb
);
Console.Write("Complete! RU Charge for Replace a item [{0}] - {1} RU\n", responseReplace.Resource.id, responseReplace.RequestCharge);
Console.Write("Execute PatchItemAsync to update a item [{0}]'s field [/R]... ", rgb.id);
ItemResponse <RGB> responsePatch = await this.Container.PatchItemAsync <RGB>(
id : rgb.id,
partitionKey : new PartitionKey(rgb.x),
patchOperations : new[] { PatchOperation.Replace("/R", rgb.R) }
);
Console.Write("Complete! RU Charge for Patch a item [{0}] - {1} RU\n", responsePatch.Resource.id, responsePatch.RequestCharge);
}
catch (Exception e)
{
throw e;
}
}
public void Then_The_Url_Is_Correctly_Constructed(Guid id, PatchOperation data)
{
var actual = new PatchCourseDemandRequest(id, data);
actual.Data.Should().BeEquivalentTo(new List <PatchOperation> {
data
});
actual.PatchUrl.Should().Be($"api/demand/{id}");
}
public void DebugResultsWhenModifyingCounters()
{
using (var store = GetDocumentStore())
{
using (var session = store.OpenSession())
{
session.Store(new Car {
Model = "Golf"
}, "cars/1");
session.CountersFor("cars/1").Increment("Counter1", 100);
session.SaveChanges();
}
var reqEx = store.GetRequestExecutor();
using (reqEx.ContextPool.AllocateOperationContext(out var context))
{
PatchOperation operation = new PatchOperation(id: "cars/1", changeVector: null, patch: new PatchRequest {
Script = @"
incrementCounter('cars/1', 'Counter1', 50);
incrementCounter('cars/1', 'Counter2');
"
}, patchIfMissing: null);
var cmd = operation.GetCommand(store, store.Conventions, context, reqEx.Cache, true, true);
store.Commands().Execute(cmd);
Assert.True(cmd.Result.Debug.TryGet("Actions", out BlittableJsonReaderObject actions), "<Actions> section not found");
// Counters Modifications Check
Assert.True(actions.TryGet("IncrementCounter", out BlittableJsonReaderArray incrementCounter), "<IncrementCounter> section not found");
(incrementCounter[0] as BlittableJsonReaderObject).TryGet("Name", out string name);
Assert.Equal("Counter1", name);
(incrementCounter[0] as BlittableJsonReaderObject).TryGet("OldValue", out int?oldValue);
Assert.Equal(100, oldValue);
(incrementCounter[0] as BlittableJsonReaderObject).TryGet("AddedValue", out int addedValue);
Assert.Equal(50, addedValue);
(incrementCounter[0] as BlittableJsonReaderObject).TryGet("NewValue", out int newValue);
Assert.Equal(150, newValue);
(incrementCounter[0] as BlittableJsonReaderObject).TryGet("Created", out bool created);
Assert.Equal(false, created);
(incrementCounter[1] as BlittableJsonReaderObject).TryGet("Name", out name);
Assert.Equal("Counter2", name);
(incrementCounter[1] as BlittableJsonReaderObject).TryGet("OldValue", out oldValue);
Assert.Equal(null, oldValue);
(incrementCounter[1] as BlittableJsonReaderObject).TryGet("AddedValue", out addedValue);
Assert.Equal(1, addedValue);
(incrementCounter[1] as BlittableJsonReaderObject).TryGet("NewValue", out newValue);
Assert.Equal(1, newValue);
(incrementCounter[1] as BlittableJsonReaderObject).TryGet("Created", out created);
Assert.Equal(true, created);
}
}
}
private async Task Validate(
ItemRequestOptions requestOptions,
Action <ItemResponse <ToDoActivity> > ValidateWrite,
Action <ItemResponse <ToDoActivity> > ValidateRead)
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> itemResponse = await this.container.CreateItemAsync(item, requestOptions : requestOptions);
Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
ValidateWrite(itemResponse);
itemResponse = await this.container.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.status), requestOptions : requestOptions);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
ValidateRead(itemResponse);
item.cost = 424242.42;
itemResponse = await this.container.UpsertItemAsync <ToDoActivity>(item, requestOptions : requestOptions);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
ValidateWrite(itemResponse);
item.cost = 9000.42;
itemResponse = await this.container.ReplaceItemAsync <ToDoActivity>(
item,
item.id,
new PartitionKey(item.status),
requestOptions : requestOptions);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
ValidateWrite(itemResponse);
item.cost = 1000;
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.CreateReplaceOperation("/cost", item.cost)
};
itemResponse = await this.containerInternal.PatchItemAsync <ToDoActivity>(
item.id,
new PartitionKey(item.status),
patchOperations : patch,
requestOptions : requestOptions);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
ValidateWrite(itemResponse);
itemResponse = await this.container.DeleteItemAsync <ToDoActivity>(
item.id,
new PartitionKey(item.status),
requestOptions : requestOptions);
Assert.AreEqual(HttpStatusCode.NoContent, itemResponse.StatusCode);
this.ValidateItemNoContentResponse(itemResponse);
}
public void TestJsonArrayCanBeParsed()
{
var result = PatchOperation.Parse(
"[{ \"op\": \"test\", \"path\": \"/a/b/c\", \"value\": \"foo\" }, { \"op\": \"remove\", \"path\": \"/a/b/c\" }]");
Assert.AreEqual(2, result.Count);
Assert.AreEqual("test", result[0].Operation);
Assert.AreEqual("/a/b/c", result[0].Path);
Assert.AreEqual("foo", result[0].Value);
}
// </ReplaceItemAsync>
// <PatchItemAsync>
private static async Task PatchItemAsync(SalesOrder order)
{
//******************************************************************************************************************
// 1.7 - Patch a item
//
// Just update a property of an existing item and issue a Patch command
//******************************************************************************************************************
Console.WriteLine("\n1.6 - Patching a item using its Id");
ItemResponse <SalesOrder> response = await container.PatchItemAsync <SalesOrder>(
id : order.Id,
partitionKey : new PartitionKey(order.AccountNumber),
patchOperations : new[] { PatchOperation.Replace("/TotalDue", 0) });
SalesOrder updatedSalesOrder = response.Resource;
Console.WriteLine($"TotalDue of updated item: {updatedSalesOrder.TotalDue}");
PatchItemRequestOptions patchItemRequestOptions = new PatchItemRequestOptions
{
FilterPredicate = "from c where (c.TotalDue = 0 OR NOT IS_DEFINED(c.TotalDue))"
};
response = await container.PatchItemAsync <SalesOrder>(
id : order.Id,
partitionKey : new PartitionKey(order.AccountNumber),
patchOperations : new[] { PatchOperation.Replace("/ShippedDate", DateTime.UtcNow) },
patchItemRequestOptions);
updatedSalesOrder = response.Resource;
Console.WriteLine($"\n1.6.2 - Shipped date of updated item: {updatedSalesOrder.ShippedDate}");
IReadOnlyList <PatchOperation> patchOperations = new[] { PatchOperation.Replace("/ShippedDate", DateTime.UtcNow) };
using (Stream stream = Program.ToStream <IReadOnlyList <PatchOperation> >(patchOperations))
{
using (ResponseMessage responseMessage = await container.PatchItemStreamAsync(
id: order.Id,
partitionKey: new PartitionKey(order.AccountNumber),
patchOperations: patchOperations))
{
// Item stream operations do not throw exceptions for better performance
if (responseMessage.IsSuccessStatusCode)
{
SalesOrder streamResponse = FromStream <SalesOrder>(responseMessage.Content);
Console.WriteLine($"\n1.6.3 - Item Patch via stream {streamResponse.Id}");
}
else
{
Console.WriteLine($"Patch item from stream failed. Status code: {responseMessage.StatusCode} Message: {responseMessage.ErrorMessage}");
}
}
}
}
private bool ApplyPatches(XmlDocument xml)
{
foreach (PatchOperation operation in this.operations)
{
if (!operation.Apply(xml))
{
this.lastFailedOperation = operation;
return(false);
}
}
return(true);
}
private static void PatchMembers(this Core2Group group, PatchOperation operation)
{
//path Members expects operation to only contain one item
group.Members = PatchMembers(group.Members, operation);
if (operation.Value.Count > 1)
{
List <Newtonsoft.Json.Linq.JToken> list = operation.Value.ToList();
list.RemoveAt(0);
operation.Value = list;
group.PatchMembers(operation);
}
}
public void GetPatchOperations5()
{
DiffEngine <long> diffEngine = new DiffEngine <long>(
new long[] { 1, 2, 3 }, new long[] { 2, 3 });
PatchOperation[] expectedPatchOperations =
new PatchOperation[] {
PatchOperation.CreateDeletion(0, 0),
PatchOperation.CreateCopy(1, 2)
};
AssertDifferences(diffEngine, expectedPatchOperations);
}
private static Range <int> GetRange(PatchOperation difference, WordDataProvider dataProvider)
{
int start = dataProvider.Matches[difference.Range.Start].Index;
int end = 0;
for (int match = difference.Range.Start; match <= difference.Range.End; ++match)
{
end = Math.Max(end,
dataProvider.Matches[match].Index + dataProvider.Matches[match].Length);
}
return(new Range <int>(start, end));
}
public void ReplaceGivenPropertyWithRequiredAndJsonAttributesSetsCorrectPatchOperation()
{
//Arrange
IPatchOperationBuilder <RequiredAndJsonItem> builder = new PatchOperationBuilder <RequiredAndJsonItem>();
//Act
builder.Replace(x => x.TestProperty, "Test Value");
//Assert
PatchOperation operation = builder.PatchOperations.First();
Assert.Equal(PatchOperationType.Replace, operation.OperationType);
Assert.Equal("/testProperty", operation.Path);
}
public async Task ClientContentResponseTest()
{
ToDoActivity item = ToDoActivity.CreateRandomToDoActivity();
ItemResponse <ToDoActivity> itemResponse = await this.containerWithFlag.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse);
Assert.IsNotNull(itemResponse.Resource);
itemResponse = await this.containerWithFlag.ReadItemAsync <ToDoActivity>(item.id, new PartitionKey(item.pk));
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
item.cost = 424242.42;
itemResponse = await this.containerWithFlag.UpsertItemAsync <ToDoActivity>(item);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse.Resource);
item.cost = 9000.42;
itemResponse = await this.containerWithFlag.ReplaceItemAsync <ToDoActivity>(
item,
item.id,
new PartitionKey(item.pk));
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse.Resource);
ContainerInternal containerInternal = (ContainerInternal)this.containerWithFlag;
item.cost = 1000;
List <PatchOperation> patch = new List <PatchOperation>()
{
PatchOperation.Replace("/cost", item.cost)
};
itemResponse = await containerInternal.PatchItemAsync <ToDoActivity>(
item.id,
new PartitionKey(item.pk),
patchOperations : patch);
Assert.AreEqual(HttpStatusCode.OK, itemResponse.StatusCode);
Assert.IsNotNull(itemResponse.Resource);
ItemResponse <ToDoActivity> itemResponseWithoutFlag = await this.containerWithoutFlag.CreateItemAsync(item);
Assert.AreEqual(HttpStatusCode.Created, itemResponseWithoutFlag.StatusCode);
Assert.IsNotNull(itemResponseWithoutFlag);
Assert.IsNull(itemResponseWithoutFlag.Resource);
}
public void TestLifecycleGroup()
{
Uri addressBase = new Uri(WebServiceUnitTest.AddressBase);
IMonitor monitor = new ConsoleMonitor();
IAmazonWebServicesIdentityAnchoringBehavior anchoringBehavior =
new AnchoringByIdentifierBehavior();
AmazonWebServicesProviderBase provider = new AmazonWebServicesProvider(WebServiceUnitTest.CredentialsProfileName, anchoringBehavior);
Service webService = null;
try
{
webService = new WebService(monitor, provider);
webService.Start(addressBase);
string identifierGroup;
string identifierGroupExternal;
string identifierMemberOne;
string identifierMemberTwo;
Uri resource;
WebClient client = null;
try
{
IDictionary<string, object> json;
string characters;
byte[] bytes;
byte[] response;
string responseCharacters;
IReadOnlyDictionary<string, object> responseJson;
Core2EnterpriseUser user;
Member member;
IReadOnlyCollection<Member> members;
client = new WebClient();
identifierMemberOne = Guid.NewGuid().ToString();
string identifierMemberOneExternal = Guid.NewGuid().ToString();
user =
new Core2EnterpriseUser()
{
Identifier = identifierMemberOne,
ExternalIdentifier = identifierMemberOneExternal
};
json = user.ToJson();
characters = WebServiceUnitTest.Serializer.Value.Serialize(json);
bytes = Encoding.UTF8.GetBytes(characters);
resource = new Uri(addressBase, WebServiceUnitTest.AddressRelativeUsers);
client.Headers.Clear();
client.Headers.Add(HttpRequestHeader.ContentType, WebServiceUnitTest.ContentTypeJson);
response = client.UploadData(resource.AbsoluteUri, WebRequestMethods.Http.Post, bytes);
responseCharacters = Encoding.UTF8.GetString(response);
responseJson =
WebServiceUnitTest.Serializer.Value.Deserialize<Dictionary<string, object>>(responseCharacters);
user = new Core2EnterpriseUserJsonDeserializingFactory().Create(responseJson);
identifierMemberOne = user.Identifier;
try
{
member =
new Member()
{
Value = identifierMemberOne
};
members =
new Member[]
{
member
};
identifierGroup = Guid.NewGuid().ToString();
identifierGroupExternal = Guid.NewGuid().ToString();
WindowsAzureActiveDirectoryGroup group =
new WindowsAzureActiveDirectoryGroup()
{
Identifier = identifierGroup,
ExternalIdentifier = identifierGroupExternal,
Members = members
};
json = group.ToJson();
characters = WebServiceUnitTest.Serializer.Value.Serialize(json);
bytes = Encoding.UTF8.GetBytes(characters);
resource = new Uri(addressBase, WebServiceUnitTest.AddressRelativeGroups);
client.Headers.Clear();
client.Headers.Add(HttpRequestHeader.ContentType, WebServiceUnitTest.ContentTypeJson);
response = client.UploadData(resource.AbsoluteUri, WebRequestMethods.Http.Post, bytes);
responseCharacters = Encoding.UTF8.GetString(response);
responseJson =
WebServiceUnitTest.Serializer.Value.Deserialize<Dictionary<string, object>>(responseCharacters);
group = new WindowsAzureActiveDirectoryGroupJsonDeserializingFactory().Create(responseJson);
Assert.IsNotNull(group);
Assert.IsNotNull(
group
.Schemas
.SingleOrDefault(
(string item) =>
string.Equals(
SchemaIdentifiers.WindowsAzureActiveDirectoryGroup,
item,
StringComparison.Ordinal)));
Assert.IsFalse(string.IsNullOrWhiteSpace(group.Identifier));
string identifierGroupAmazon = group.Identifier;
try
{
Assert.IsNotNull(group.Metadata);
Assert.IsFalse(string.IsNullOrWhiteSpace(group.Metadata.ResourceType));
Assert.IsFalse(string.Equals(identifierGroup, identifierGroupAmazon, StringComparison.OrdinalIgnoreCase));
string resourcePath =
string.Format(
CultureInfo.InvariantCulture,
WebServiceUnitTest.AddressRelativeGroupTemplate,
identifierGroupAmazon);
resource = new Uri(addressBase, resourcePath);
response = client.DownloadData(resource);
responseCharacters = Encoding.UTF8.GetString(response);
responseJson =
WebServiceUnitTest.Serializer.Value.Deserialize<Dictionary<string, object>>(responseCharacters);
group = new WindowsAzureActiveDirectoryGroupJsonDeserializingFactory().Create(responseJson);
Assert.IsNotNull(group);
Assert.IsNotNull(
group
.Schemas
.SingleOrDefault(
(string item) =>
string.Equals(
SchemaIdentifiers.Core2Group,
item,
StringComparison.Ordinal)));
Assert.IsFalse(string.IsNullOrWhiteSpace(group.Identifier));
Assert.IsTrue(string.Equals(group.Identifier, identifierGroupAmazon, StringComparison.OrdinalIgnoreCase));
Assert.IsFalse(string.IsNullOrWhiteSpace(group.ExternalIdentifier));
Assert.IsTrue(string.Equals(group.ExternalIdentifier, identifierGroupExternal, StringComparison.OrdinalIgnoreCase));
identifierMemberTwo = Guid.NewGuid().ToString();
string identifierMemberTwoExternal = Guid.NewGuid().ToString();
user =
new Core2EnterpriseUser()
{
Identifier = identifierMemberTwo,
ExternalIdentifier = identifierMemberTwoExternal
};
json = user.ToJson();
characters = WebServiceUnitTest.Serializer.Value.Serialize(json);
bytes = Encoding.UTF8.GetBytes(characters);
resource = new Uri(addressBase, WebServiceUnitTest.AddressRelativeUsers);
client.Headers.Clear();
client.Headers.Add(HttpRequestHeader.ContentType, WebServiceUnitTest.ContentTypeJson);
response = client.UploadData(resource.AbsoluteUri, WebRequestMethods.Http.Post, bytes);
responseCharacters = Encoding.UTF8.GetString(response);
responseJson =
WebServiceUnitTest.Serializer.Value.Deserialize<Dictionary<string, object>>(responseCharacters);
user = new Core2EnterpriseUserJsonDeserializingFactory().Create(responseJson);
identifierMemberTwo = user.Identifier;
try
{
IResourceIdentifier resourceIdentifier =
new ResourceIdentifier()
{
Identifier = identifierGroupAmazon,
SchemaIdentifier = SchemaIdentifiers.WindowsAzureActiveDirectoryGroup
};
IPath path = Microsoft.SystemForCrossDomainIdentityManagement.Path.Create(AttributeNames.Members);
OperationValue operationValue;
PatchOperation operation;
IReadOnlyCollection<PatchOperation> operations;
PatchRequest2 patch;
operationValue =
new OperationValue()
{
Value = identifierMemberTwo
};
operation =
new PatchOperation()
{
Name = OperationName.Add,
Path = path
};
operations =
new PatchOperation[]
{
operation
};
operation.AddValue(operationValue);
patch = new PatchRequest2();
patch.AddOperation(operation);
json = patch.ToJson();
characters = WebServiceUnitTest.Serializer.Value.Serialize(json);
bytes = Encoding.UTF8.GetBytes(characters);
resourcePath = string.Concat(WebServiceUnitTest.AddressRelativeGroup, identifierGroupAmazon);
resource = new Uri(addressBase, resourcePath);
client.Headers.Clear();
client.Headers.Add(HttpRequestHeader.ContentType, WebServiceUnitTest.ContentTypeJson);
response = client.UploadData(resource.AbsoluteUri, WebServiceUnitTest.MethodPatch, bytes);
operationValue =
new OperationValue()
{
Value = identifierMemberTwo
};
operation =
new PatchOperation()
{
Name = OperationName.Remove,
Path = path
};
operations =
new PatchOperation[]
{
operation
};
operation.AddValue(operationValue);
patch = new PatchRequest2();
patch.AddOperation(operation);
json = patch.ToJson();
characters = WebServiceUnitTest.Serializer.Value.Serialize(json);
bytes = Encoding.UTF8.GetBytes(characters);
resourcePath = string.Concat(WebServiceUnitTest.AddressRelativeGroup, identifierGroupAmazon);
resource = new Uri(addressBase, resourcePath);
client.Headers.Clear();
client.Headers.Add(HttpRequestHeader.ContentType, WebServiceUnitTest.ContentTypeJson);
response = client.UploadData(resource.AbsoluteUri, WebServiceUnitTest.MethodPatch, bytes);
operationValue =
new OperationValue()
{
Value = identifierMemberOne
};
operation =
new PatchOperation()
{
Name = OperationName.Remove,
Path = path
};
operations =
new PatchOperation[]
{
operation
};
operation.AddValue(operationValue);
patch = new PatchRequest2();
patch.AddOperation(operation);
json = patch.ToJson();
characters = WebServiceUnitTest.Serializer.Value.Serialize(json);
bytes = Encoding.UTF8.GetBytes(characters);
resourcePath = string.Concat(WebServiceUnitTest.AddressRelativeGroup, identifierGroupAmazon);
resource = new Uri(addressBase, resourcePath);
client.Headers.Clear();
client.Headers.Add(HttpRequestHeader.ContentType, WebServiceUnitTest.ContentTypeJson);
response = client.UploadData(resource.AbsoluteUri, WebServiceUnitTest.MethodPatch, bytes);
}
finally
{
resourcePath = string.Concat(WebServiceUnitTest.AddressRelativeUser, identifierMemberTwo);
resource = new Uri(addressBase, resourcePath);
bytes = new byte[0];
client.UploadData(resource, WebServiceUnitTest.MethodDelete, bytes);
}
}
finally
{
string resourcePath = string.Concat(WebServiceUnitTest.AddressRelativeGroup, identifierGroupAmazon);
resource = new Uri(addressBase, resourcePath);
bytes = new byte[0];
client.UploadData(resource, WebServiceUnitTest.MethodDelete, bytes);
}
}
finally
{
string resourcePath = string.Concat(WebServiceUnitTest.AddressRelativeUser, identifierMemberOne);
resource = new Uri(addressBase, resourcePath);
bytes = new byte[0];
client.UploadData(resource, WebServiceUnitTest.MethodDelete, bytes);
}
}
finally
{
if (client != null)
{
client.Dispose();
client = null;
}
}
}
finally
{
if (webService != null)
{
webService.Dispose();
webService = null;
}
}
}
private async Task UpdateMembers(
IResourceIdentifier resourceIdentifier,
PatchOperation membershipOperation,
string correlationIdentifier)
{
if (null == resourceIdentifier)
{
throw new ArgumentNullException(AmazonWebServicesProvider.ArgumentNameResourceIdentifier);
}
if (null == membershipOperation)
{
throw new ArgumentNullException(AmazonWebServicesProvider.ArgumentNameMembershipOperation);
}
if (string.IsNullOrWhiteSpace(correlationIdentifier))
{
throw new ArgumentNullException(AmazonWebServicesProvider.ArgumentNameCorrelationIdentifier);
}
if (string.IsNullOrWhiteSpace(resourceIdentifier.Identifier))
{
throw new ArgumentException(ProvisioningAgentResources.ExceptionInvalidResourceIdentifier);
}
if (string.IsNullOrWhiteSpace(resourceIdentifier.SchemaIdentifier))
{
throw new ArgumentException(ProvisioningAgentResources.ExceptionInvalidResourceIdentifier);
}
IAmazonIdentityManagementService proxy = null;
try
{
proxy = AWSClientFactory.CreateAmazonIdentityManagementServiceClient(this.credentials);
Group group = await this.RetrieveGroup(resourceIdentifier.Identifier, proxy);
if (null == group)
{
string warning =
string.Format(
CultureInfo.InvariantCulture,
AmazonProvisioningAgentResources.WarningEntryNotFoundTemplate,
typeof(Group).Name,
resourceIdentifier.Identifier);
ProvisioningAgentMonitor.Instance.Warn(warning, correlationIdentifier);
return;
}
switch (membershipOperation.Name)
{
case OperationName.Add:
foreach (OperationValue value in membershipOperation.Value)
{
await this.AddMember(group.GroupName, value.Value, proxy, correlationIdentifier);
}
break;
case OperationName.Remove:
foreach (OperationValue value in membershipOperation.Value)
{
await this.RemoveMember(group.GroupName, value.Value, proxy, correlationIdentifier);
}
break;
default:
string unsupportedOperation = Enum.GetName(typeof(OperationName), membershipOperation.Name);
throw new NotSupportedException(unsupportedOperation);
}
}
finally
{
if (proxy != null)
{
proxy.Dispose();
proxy = null;
}
}
}