public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var assignRequest = (AssignRequest)request;
var target = assignRequest.Target;
var assignee = assignRequest.Assignee;
if (target == null)
{
throw new FaultException<OrganizationServiceFault>(new OrganizationServiceFault(), "Can not assign without target");
}
if (assignee == null)
{
throw new FaultException<OrganizationServiceFault>(new OrganizationServiceFault(), "Can not assign without assignee");
}
var service = ctx.GetFakedOrganizationService();
var assignment = new Entity
{
LogicalName = target.LogicalName,
Id = target.Id,
Attributes = new AttributeCollection
{
{ "ownerid", assignee }
}
};
service.Update(assignment);
return new AssignResponse();
}
public void When_ordering_by_datetime_fields_expected_result_is_returned()
{
List<Entity> contactList = new List<Entity>();
var now = DateTime.UtcNow;
Entity contact1 = new Entity("contact");
contact1.Id = Guid.NewGuid();
contact1.Attributes["firstname"] = "Fred";
contact1.Attributes["new_orderbyfield"] = now;
Entity contact2 = new Entity("contact");
contact2.Id = Guid.NewGuid();
contact2.Attributes["firstname"] = "Jo";
contact2.Attributes["new_orderbyfield"] = now.AddDays(1);
contactList.Add(contact2);
contactList.Add(contact1);
var context = new XrmFakedContext();
context.Initialize(contactList);
var service = context.GetFakedOrganizationService();
QueryExpression qry = new QueryExpression("contact");
qry.ColumnSet = new ColumnSet(true);
qry.AddOrder("new_orderbyfield", OrderType.Ascending);
var results = service.RetrieveMultiple(qry);
var firstResultValue = (DateTime)results.Entities[0]["new_orderbyfield"];
Assert.Equal(now, firstResultValue);
}
public void When_set_state_request_is_called_an_entity_is_updated()
{
var context = new XrmFakedContext();
context.ProxyTypesAssembly = Assembly.GetExecutingAssembly();
var service = context.GetFakedOrganizationService();
var c = new Contact() {
Id = Guid.NewGuid()
};
context.Initialize(new[] { c });
var request = new SetStateRequest
{
EntityMoniker = c.ToEntityReference(),
State = new OptionSetValue(69),
Status = new OptionSetValue(6969),
};
var response = service.Execute(request);
//Retrieve record after update
var contact = (from con in context.CreateQuery<Contact>()
where con.Id == c.Id
select con).FirstOrDefault();
Assert.Equal((int) contact.StateCode.Value, 69);
Assert.Equal((int) contact.StatusCode.Value, 6969);
}
public void When_Executing_Assign_Request_New_Owner_Should_Be_Assigned()
{
var oldOwner = new EntityReference("systemuser", Guid.NewGuid());
var newOwner = new EntityReference("systemuser", Guid.NewGuid());
var account = new Account
{
Id = Guid.NewGuid(),
OwnerId = oldOwner
};
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
context.Initialize(new [] { account });
var assignRequest = new AssignRequest
{
Target = account.ToEntityReference(),
Assignee = newOwner
};
service.Execute(assignRequest);
Assert.Equal(newOwner, account.OwnerId);
}
public void When_ordering_by_money_fields_descending_expected_result_is_returned()
{
List<Entity> contactList = new List<Entity>();
Entity contact1 = new Entity("contact");
contact1.Id = Guid.NewGuid();
contact1.Attributes["firstname"] = "Fred";
contact1.Attributes["lastname"] = "Bloggs";
contact1.Attributes["new_somefield"] = new Money(12345); // (decimal)678910
Entity contact2 = new Entity("contact");
contact2.Id = Guid.NewGuid();
contact2.Attributes["firstname"] = "Jo";
contact2.Attributes["lastname"] = "Bloggs";
contact2.Attributes["new_somefield"] = new Money(678910); // (decimal)678910
contactList.Add(contact2);
contactList.Add(contact1);
var context = new XrmFakedContext();
context.Initialize(contactList);
var service = context.GetFakedOrganizationService();
QueryExpression qry = new QueryExpression("contact");
qry.ColumnSet = new ColumnSet(true);
qry.AddOrder("new_somefield", OrderType.Descending);
var results = service.RetrieveMultiple(qry);
var firstResultValue = results.Entities[0]["new_somefield"] as Money;
Assert.Equal(678910M, firstResultValue.Value);
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var associateRequest = request as AssociateRequest;
var service = ctx.GetFakedOrganizationService();
if (associateRequest == null)
{
throw new Exception("Only associate request can be processed!");
}
var associateRelationship = associateRequest.Relationship;
var relationShipName = associateRelationship.SchemaName;
var fakeRelationShip = ctx.GetRelationship(relationShipName);
if (fakeRelationShip == null)
{
throw new Exception(string.Format("Relationship {0} does not exist in the metadata cache", relationShipName));
}
if (associateRequest.Target == null)
{
throw new Exception("Association without target is invalid!");
}
foreach (var relatedEntityReference in associateRequest.RelatedEntities)
{
if (fakeRelationShip.RelationshipType == XrmFakedRelationship.enmFakeRelationshipType.ManyToMany)
{
var association = new Entity(fakeRelationShip.IntersectEntity)
{
Attributes = new AttributeCollection
{
{ fakeRelationShip.Entity1Attribute, associateRequest.Target.Id },
{ fakeRelationShip.Entity2Attribute, relatedEntityReference.Id }
}
};
service.Create(association);
}
else
{
//One to many
//Get entity to update
var entityToUpdate = new Entity(relatedEntityReference.LogicalName)
{
Id = relatedEntityReference.Id
};
entityToUpdate[fakeRelationShip.Entity2Attribute] = associateRequest.Target;
service.Update(entityToUpdate);
}
}
return new AssociateResponse ();
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var createRequest = (CreateRequest)request;
var service = ctx.GetFakedOrganizationService();
service.Create(createRequest.Target);
return new CreateResponse();
}
public void When_calling_publish_xml_exception_is_raised_if_parameter_xml_is_blank()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var req = new PublishXmlRequest()
{
ParameterXml = ""
};
Assert.Throws<Exception>(() => service.Execute(req));
}
public void When_calling_insert_option_set_value_without_optionsetname_exception_is_thrown()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var req = new InsertOptionValueRequest()
{
Label = new Label("Yeah! This is a fake label!", 0)
};
Assert.Throws<Exception>(() => service.Execute(req));
}
public void When_calling_publish_xml_no_exception_is_raised()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var req = new PublishXmlRequest()
{
ParameterXml = "<somexml></somexml>"
};
Assert.DoesNotThrow(() => service.Execute(req));
}
public static void When_retrieve_attribute_request_is_called_an_exception_is_not_thrown()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
RetrieveAttributeRequest req = new RetrieveAttributeRequest()
{
EntityLogicalName = "account",
LogicalName = "name"
};
Assert.Throws<PullRequestException>(() => service.Execute(req));
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var createRequest = (CreateRequest)request;
var service = ctx.GetFakedOrganizationService();
var guid = service.Create(createRequest.Target);
return new CreateResponse()
{
ResponseName = "Create",
Results = new ParameterCollection { { "id", guid } }
};
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var deleteRequest = (DeleteRequest)request;
var target = deleteRequest.Target;
if (target == null)
{
throw new FaultException<OrganizationServiceFault>(new OrganizationServiceFault(), "Can not delete without target");
}
var service = ctx.GetFakedOrganizationService();
service.Delete(target.LogicalName, target.Id);
return new DeleteResponse();
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var disassociateRequest = request as DisassociateRequest;
var service = ctx.GetFakedOrganizationService();
if (disassociateRequest == null)
{
throw new Exception("Only disassociate request can be processed!");
}
var relationShipName = disassociateRequest.Relationship.SchemaName;
var relationShip = ctx.GetRelationship(relationShipName);
if (relationShip == null)
{
throw new Exception(string.Format("Relationship {0} does not exist in the metadata cache", relationShipName));
}
if (disassociateRequest.Target == null)
{
throw new Exception("Disassociation without target is invalid!");
}
foreach (var relatedEntity in disassociateRequest.RelatedEntities)
{
var query = new QueryExpression(relationShip.IntersectEntity)
{
ColumnSet = new ColumnSet(true),
Criteria = new FilterExpression(LogicalOperator.And)
};
query.Criteria.AddCondition(new ConditionExpression(relationShip.Entity1Attribute,
ConditionOperator.Equal, disassociateRequest.Target.Id));
query.Criteria.AddCondition(new ConditionExpression(relationShip.Entity2Attribute,
ConditionOperator.Equal, relatedEntity.Id));
var results = service.RetrieveMultiple(query);
if (results.Entities.Count == 1)
{
service.Delete(relationShip.IntersectEntity, results.Entities.First().Id);
}
}
return new DisassociateResponse();
}
public static void Should_Execute_Subsequent_Requests()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var account1 = new Account
{
Id = Guid.NewGuid(),
Name = "Acc1"
};
var account2 = new Account
{
Id = Guid.NewGuid(),
Name = "Acc2"
};
var executeMultipleRequest = new ExecuteMultipleRequest
{
Settings = new ExecuteMultipleSettings
{
ReturnResponses = true
},
Requests = new OrganizationRequestCollection
{
new CreateRequest
{
Target = account1
},
new CreateRequest
{
Target = account2
}
}
};
var response = service.Execute(executeMultipleRequest) as ExecuteMultipleResponse;
Assert.False(response.IsFaulted);
Assert.NotEmpty(response.Responses);
Assert.NotNull(service.Retrieve(Account.EntityLogicalName, account1.Id, new ColumnSet(true)));
Assert.NotNull(service.Retrieve(Account.EntityLogicalName, account2.Id, new ColumnSet(true)));
}
public void When_calling_context_add_and_save_changes_entity_is_added_to_the_faked_context()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
using(var ctx = new XrmServiceContext(service))
{
ctx.AddObject(new Account() { Name = "Test account" });
ctx.SaveChanges();
var account = ctx.CreateQuery<Account>()
.ToList()
.FirstOrDefault();
Assert.Equal("Test account", account.Name);
}
}
public void When_calling_context_add_addrelated_and_save_changes_entities_are_added_to_the_faked_context()
{
var context = new XrmFakedContext();
var relationship = new XrmFakedRelationship()
{
IntersectEntity = "accountleads",
Entity1Attribute = "accountid",
Entity2Attribute = "leadid",
Entity1LogicalName = "account",
Entity2LogicalName = "lead"
};
context.AddRelationship("accountleads", relationship);
var service = context.GetFakedOrganizationService();
using (var ctx = new XrmServiceContext(service))
{
var account = new Account() { Name = "Test account" };
ctx.AddObject(account);
var contact = new Lead() { FirstName = "Jane", LastName = "Doe" };
ctx.AddRelatedObject(account, new Relationship("accountleads"), contact);
var result = ctx.SaveChanges();
var resultaccount = ctx.CreateQuery<Account>()
.ToList()
.FirstOrDefault();
Assert.NotNull(resultaccount);
Assert.Equal("Test account", resultaccount.Name);
var reaultlead = ctx.CreateQuery<Lead>()
.ToList()
.FirstOrDefault();
Assert.NotNull(reaultlead);
Assert.Equal("Jane", reaultlead.FirstName);
Assert.Equal("Doe", reaultlead.LastName);
var relationshipRecords = ctx.CreateQuery("accountleads")
.ToList();
Assert.NotEmpty(relationshipRecords);
}
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var executeTransactionRequest = (ExecuteTransactionRequest)request;
var response = new ExecuteTransactionResponse { ["Responses"] = new OrganizationResponseCollection() };
var service = ctx.GetFakedOrganizationService();
foreach (var r in executeTransactionRequest.Requests)
{
var result = service.Execute(r);
if (executeTransactionRequest.ReturnResponses.HasValue && executeTransactionRequest.ReturnResponses.Value)
{
response.Responses.Add(result);
}
}
return response;
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var req = request as SetStateRequest;
//We are going to translate a SetStateRequest into an update message basically
var entityName = req.EntityMoniker.LogicalName;
var guid = req.EntityMoniker.Id;
var entityToUpdate = new Entity(entityName) { Id = guid };
entityToUpdate["statecode"] = req.State;
entityToUpdate["statuscode"] = req.Status;
var fakedService = ctx.GetFakedOrganizationService();
fakedService.Update(entityToUpdate);
return new SetStateResponse();
}
public void Should_set_a_statecode_by_default_when_an_entity_record_is_added_to_the_context()
{
var context = new XrmFakedContext();
context.ProxyTypesAssembly = Assembly.GetExecutingAssembly();
var service = context.GetFakedOrganizationService();
var c = new Contact()
{
Id = Guid.NewGuid()
};
context.Initialize(new[] { c });
//Retrieve record after update
var contact = (from con in context.CreateQuery<Contact>()
where con.Id == c.Id
select con).FirstOrDefault();
Assert.Equal((int)contact.StateCode.Value, 0); //Active
}
public void Should_Execute_Mock_For_OrganizationRequests()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var e = new Entity("Contact") { Id = Guid.NewGuid() };
context.Initialize(new[] { e });
context.AddExecutionMock<RetrieveEntityRequest>(RetrieveEntityMock);
var inputs = new ParameterCollection
{
{"Target", e }
};
context.ExecutePluginWith<CustomMockPlugin>(inputs, new ParameterCollection(), new EntityImageCollection(), new EntityImageCollection());
Assert.Equal("Successful", (string)e["response"]);
Assert.DoesNotThrow(() => context.RemoveExecutionMock<RetrieveEntityRequest>());
}
public void When_executing_fetchxml_right_result_is_returned()
{
//This will test a query expression is generated and executed
var ctx = new XrmFakedContext();
ctx.Initialize(new List<Entity>()
{
new Contact() {Id = Guid.NewGuid(), FirstName = "Leo Messi", Telephone1 = "123" }, //should be returned
new Contact() {Id = Guid.NewGuid(), FirstName = "Leo Messi", Telephone1 = "234" }, //should be returned
new Contact() {Id = Guid.NewGuid(), FirstName = "Leo", Telephone1 = "789" }, //shouldnt
new Contact() {Id = Guid.NewGuid(), FirstName = "Andrés", Telephone1 = "123" }, //shouldnt
});
var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
<entity name='contact'>
<attribute name='fullname' />
<attribute name='telephone1' />
<attribute name='contactid' />
<filter type='and'>
<condition attribute='firstname' operator='like' value='%Leo%' />
<filter type='or'>
<condition attribute='telephone1' operator='eq' value='123' />
<condition attribute='telephone1' operator='eq' value='234' />
</filter>
</filter>
</entity>
</fetch>";
var retrieveMultiple = new RetrieveMultipleRequest()
{
Query = new FetchExpression(fetchXml)
};
var service = ctx.GetFakedOrganizationService();
var response = service.Execute(retrieveMultiple) as RetrieveMultipleResponse;
Assert.Equal(2, response.EntityCollection.Entities.Count);
//Executing the same via ExecuteMultiple returns also the same
var response2 = service.RetrieveMultiple(retrieveMultiple.Query);
Assert.Equal(2, response2.Entities.Count);
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var associateRequest = request as AssociateRequest;
var service = ctx.GetFakedOrganizationService();
if (associateRequest == null)
{
throw new Exception("Only associate request can be processed!");
}
var relationShipName = associateRequest.Relationship.SchemaName;
var relationShip = ctx.GetRelationship(relationShipName);
if (relationShip == null)
{
throw new Exception(string.Format("Relationship {0} does not exist in the metadata cache", relationShipName));
}
if (associateRequest.Target == null)
{
throw new Exception("Association without target is invalid!");
}
foreach (var relatedEntity in associateRequest.RelatedEntities)
{
var association = new Entity(relationShip.IntersectEntity)
{
Attributes = new AttributeCollection
{
{ relationShip.Entity1Attribute, associateRequest.Target.Id },
{ relationShip.Entity2Attribute, relatedEntity.Id }
}
};
service.Create(association);
}
return new AssociateResponse ();
}
public void When_calling_insert_option_set_value_for_global_optionset_optionmetadata_contains_it()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var req = new InsertOptionValueRequest()
{
OptionSetName = "GlobalOptionSet",
Label = new Label("Yeah! This is a fake label!", 0)
};
Assert.DoesNotThrow(() => service.Execute(req));
//Check the optionsetmetadata was updated
Assert.True(ctx.OptionSetValuesMetadata.ContainsKey("GlobalOptionSet"));
var option = ctx.OptionSetValuesMetadata["GlobalOptionSet"].Options.FirstOrDefault();
Assert.NotEqual(null, option);
Assert.Equal("Yeah! This is a fake label!", option.Label.LocalizedLabels[0].Label);
}
public void It_Should_Recognize_Not_Matching_Strings()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "string", "cba" }
}
};
var formula = "If ( IsEqual ( Value ( \"string\" ), \"abc\" ), \"true\", \"false\" )";
var result = new XTLInterpreter(formula, email, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("false"));
}
public void It_Should_Execute_Lambdas_On_Map()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "subject", "TestSubject" }
}
};
var formula = "Join(\" \", Map([\"Lord\", \"of\", \"the\", \"Rings\"], (e) => Substring(e, 0, 1)))";
var result = new XTLInterpreter(formula, email, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("L o t R"));
}
public void It_Should_Union_Arrays()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "subject", "TestSubject" }
}
};
var formula = "Join(\" \", Union ([\"Lord\"], [\"of\", \"the\"], [\"Rings\"]))";
var result = new XTLInterpreter(formula, email, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("Lord of the Rings"));
}
public void When_Creating_Using_Organization_Context_Without_Saving_Changes_Record_Should_Not_Be_Created()
{
var context = new XrmFakedContext();
context.ProxyTypesAssembly = Assembly.GetAssembly(typeof(Account));
var account = new Account()
{
Id = Guid.NewGuid(), Name = "Super Great Customer", AccountNumber = "69"
};
var service = context.GetFakedOrganizationService();
using (var ctx = new OrganizationServiceContext(service))
{
ctx.AddObject(account);
var retrievedAccount = ctx.CreateQuery <Account>().SingleOrDefault(acc => acc.Id == account.Id);
Assert.Null(retrievedAccount);
}
}
public void It_Should_Return_Correct_Index()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var contact = new Entity
{
LogicalName = "contact",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "firstname", "Frodo Beutlin" }
}
};
var formula = "IndexOf ( Value ( \"firstname\" ), \"Beutlin\")";
var result = new XTLInterpreter(formula, contact, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("6"));
}
public void It_Should_Apply_Paging_Info()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var query = service.Query("account")
.With.PagingInfo(p => p
.PageNumber(2)
.PageSize(100)
.PagingCookie("asdf")
.ReturnTotalRecordCount()
)
.Expression;
Assert.That(query.PageInfo, Is.Not.Null);
Assert.That(query.PageInfo.PageNumber, Is.EqualTo(2));
Assert.That(query.PageInfo.Count, Is.EqualTo(100));
Assert.That(query.PageInfo.PagingCookie, Is.EqualTo("asdf"));
Assert.That(query.PageInfo.ReturnTotalRecordCount, Is.True);
}
public void Should_Not_Send_Update_If_No_Changes_Made()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var contact = new Entity
{
LogicalName = "contact",
Id = Guid.NewGuid()
};
context.Initialize(new[] { contact });
using (var updateContext = new UpdateContext <Entity>(contact))
{
var updateSent = updateContext.Update(service);
Assert.False(updateSent);
A.CallTo(() => service.Update(A <Entity> ._)).MustNotHaveHappened();
}
}
public void It_Should_Apply_Regex()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var contact = new Entity
{
LogicalName = "contact",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "firstname", "Frodo" }
}
};
var formula = "Replace ( Value ( \"firstname\" ), \"o\", \"a\" )";
var result = new XTLInterpreter(formula, contact, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("Frada"));
}
public void It_Should_Get_LogicalName_From_Entity()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var contact = new Entity
{
LogicalName = "contact",
Id = new Guid("a99b0170-d463-4f70-8db9-e2d8ee348f5f"),
Attributes = new AttributeCollection
{
{ "name", "newName" }
}
};
var formula = "RecordLogicalName (PrimaryRecord())";
var result = new XTLInterpreter(formula, contact, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("contact"));
}
public void When_calling_insert_option_set_value_without_entityname_or_attributename_exception_is_thrown()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var req = new InsertOptionValueRequest()
{
EntityLogicalName = "Not empty",
Label = new Label("Yeah! This is a fake label!", 0)
};
Assert.Throws<Exception>(() => service.Execute(req));
req = new InsertOptionValueRequest()
{
AttributeLogicalName = "Not empty",
Label = new Label("Yeah! This is a fake label!", 0)
};
Assert.Throws<Exception>(() => service.Execute(req));
}
public void When_Creating_Using_Organization_Context_Record_Should_Be_Created()
{
var context = new XrmFakedContext();
context.ProxyTypesAssembly = Assembly.GetAssembly(typeof(Account));
var account = new Account()
{
Id = Guid.NewGuid(), Name = "Super Great Customer", AccountNumber = "69"
};
var service = context.GetFakedOrganizationService();
using (var ctx = new OrganizationServiceContext(service))
{
ctx.AddObject(account);
ctx.SaveChanges();
}
Assert.NotNull(service.Retrieve(Account.EntityLogicalName, account.Id, new ColumnSet(true)));
}
public void It_Should_Take_Everything_From_Start_Without_Length()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var contact = new Entity
{
LogicalName = "contact",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "firstname", "Frodo" }
}
};
var formula = "Substring ( Value ( \"firstname\" ), 1 )";
var result = new XTLInterpreter(formula, contact, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("rodo"));
}
public void Should_set_a_statecode_by_default_when_an_entity_record_is_added_to_the_context()
{
var context = new XrmFakedContext();
context.ProxyTypesAssembly = Assembly.GetExecutingAssembly();
var service = context.GetFakedOrganizationService();
var c = new Contact()
{
Id = Guid.NewGuid()
};
context.Initialize(new[] { c });
//Retrieve record after update
var contact = (from con in context.CreateQuery <Contact>()
where con.Id == c.Id
select con).FirstOrDefault();
Assert.Equal((int)contact.StateCode.Value, 0); //Active
}
public void When_calling_insert_option_set_value_without_entityname_or_attributename_exception_is_thrown()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var req = new InsertOptionValueRequest()
{
EntityLogicalName = "Not empty",
Label = new Label("Yeah! This is a fake label!", 0)
};
Assert.Throws <Exception>(() => service.Execute(req));
req = new InsertOptionValueRequest()
{
AttributeLogicalName = "Not empty",
Label = new Label("Yeah! This is a fake label!", 0)
};
Assert.Throws <Exception>(() => service.Execute(req));
}
public void When_executing_a_query_expression_attributes_returned_are_case_sensitive()
{
//So Where clauses shouldn't affect the Select clause
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
service.Create(new Contact {
FirstName = "JimmY"
});
var qe = new QueryExpression("contact");
qe.Criteria.AddCondition("firstname", ConditionOperator.EndsWith, "y");
qe.ColumnSet = new ColumnSet(true);
var entities = service.RetrieveMultiple(qe).Entities;
Assert.Equal(1, entities.Count);
Assert.Equal("JimmY", entities[0]["firstname"]);
}
public void Strings_Should_Also_Be_Possible_With_Single_Quotes()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "subject", "TestSubject" }
}
};
var formula = "Concat(Value ('subject'), '\"', Value(\"subject\"), \"'\")";
var result = new XTLInterpreter(formula, email, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("TestSubject\"TestSubject'"));
}
public void When_calling_insert_option_set_value_for_global_optionset_optionmetadata_contains_it()
{
var ctx = new XrmFakedContext();
var service = ctx.GetFakedOrganizationService();
var req = new InsertOptionValueRequest()
{
OptionSetName = "GlobalOptionSet",
Label = new Label("Yeah! This is a fake label!", 0)
};
service.Execute(req);
//Check the optionsetmetadata was updated
Assert.True(ctx.OptionSetValuesMetadata.ContainsKey("GlobalOptionSet"));
var option = ctx.OptionSetValuesMetadata["GlobalOptionSet"].Options.FirstOrDefault();
Assert.NotEqual(null, option);
Assert.Equal("Yeah! This is a fake label!", option.Label.LocalizedLabels[0].Label);
}
public static void Should_Throw_When_Relationship_Not_Set_In_Metadata()
{
var fakedContext = new XrmFakedContext();
var fakedService = fakedContext.GetFakedOrganizationService();
A.CallTo(() => fakedService.Retrieve(A <string> .Ignored, A <Guid> .Ignored, A <ColumnSet> .Ignored))
.Returns <Entity>(new Entity());
var request = new RetrieveRequest
{
Target = new EntityReference(Account.EntityLogicalName, Guid.NewGuid()),
RelatedEntitiesQuery = new RelationshipQueryCollection
{
{ new Relationship("any"), new QueryExpression() }
}
};
var exception = Assert.Throws <Exception>(() => fakedService.Execute(request));
Assert.Equal("Relationship \"any\" does not exist in the metadata cache.", exception.Message);
}
public void It_Should_Concatenate_Array_Values_For_String_Representation()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "subject", "TestSubject" }
}
};
string result = null;
Assert.That(() => result = new XTLInterpreter("Array(\"This\", null, \"is\", \"a\", \"test\")", email, null, service, tracing).Produce(), Throws.Nothing);
Assert.That(result, Is.EqualTo("This, , is, a, test"));
}
public void It_Should_Format_Money()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var contact = new Entity
{
LogicalName = "contact",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "revenue", new Money(123456789.2m) }
}
};
var formula = "Format ( Value(\"revenue\"), { format: \"{0:0,0.0}\" } )";
var result = new XTLInterpreter(formula, contact, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("123,456,789.2"));
}
public void It_Should_Ignore_Whitespace()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "account",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "name", "TestSubject" }
}
};
var formula = "\nValue\n(\n\"name\"\n)\n";
var result = new XTLInterpreter(formula, email, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("TestSubject"));
}
public void It_Should_Recognize_Not_Matching_OptionSet_Values()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var contact = new Entity
{
LogicalName = "contact",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "gendercode", new OptionSetValue(1) }
}
};
var formula = "If ( IsEqual ( Value ( \"gendercode\" ), 2 ), \"true\", \"false\" )";
var result = new XTLInterpreter(formula, contact, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("false"));
}
public void When_delete_is_invoked_with_an_existing_entity_that_entity_is_delete_from_the_context()
{
var context = new XrmFakedContext();
//Initialize the context with a single entity
var guid = Guid.NewGuid();
var data = new List <Entity>()
{
new Entity("account")
{
Id = guid
}
}.AsQueryable();
context.Initialize(data);
var service = context.GetFakedOrganizationService();
service.Delete("account", guid);
Assert.True(context.Data["account"].Count == 0);
}
public void It_Should_Join_Values_And_Remove_Empty_Entries_With_Native_Array()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "subject", "TestSubject" }
}
};
string result = null;
Assert.That(() => result = new XTLInterpreter(@"Join ( "","", [ Value(""subject""), Value(""none""), Value(""subject"") ], true)", email, null, service, tracing).Produce(), Throws.Nothing);
Assert.That(result, Is.EqualTo("TestSubject,TestSubject"));
}
public void It_Should_Not_Fail_On_Null_Valued_Formula()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "subject", "TestSubject" }
}
};
string result = null;
Assert.That(() => result = new XTLInterpreter(null, email, null, service, tracing).Produce(), Throws.Nothing);
Assert.That(result, Is.EqualTo(string.Empty));
}
public static void Should_Throw_When_Related_Record_Query_Not_Set_For_Relationship()
{
var fakedContext = new XrmFakedContext();
var fakedService = fakedContext.GetFakedOrganizationService();
A.CallTo(() => fakedService.Retrieve(A <string> .Ignored, A <Guid> .Ignored, A <ColumnSet> .Ignored))
.Returns <Entity>(new Entity());
var request = new RetrieveRequest
{
Target = new EntityReference(Account.EntityLogicalName, Guid.NewGuid()),
RelatedEntitiesQuery = new RelationshipQueryCollection
{
{ new Relationship("any"), null }
}
};
var exception = Assert.Throws <ArgumentNullException>(() => fakedService.Execute(request));
Assert.Equal("relateEntitiesQuery.Value", exception.ParamName);
}
public void It_Should_Concatenate_Strings()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var tracing = context.GetFakeTracingService();
var email = new Entity
{
LogicalName = "email",
Id = Guid.NewGuid(),
Attributes = new AttributeCollection
{
{ "subject", "TestSubject" }
}
};
var formula = "Concat(Value (\"subject\"), \" \", Value (\"subject\"))";
var result = new XTLInterpreter(formula, email, null, service, tracing).Produce();
Assert.That(result, Is.EqualTo("TestSubject TestSubject"));
}
public void When_executing_fetchxml_with_count_attribute_requesting_less_than_0_rows_throws_an_error()
{
//This will test a count attribute can not be less than 0
var ctx = new XrmFakedContext();
//Act
var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false' count='-1'>
<entity name='contact'>
<attribute name='fullname' />
</entity>
</fetch>";
var service = ctx.GetFakedOrganizationService();
Exception exception = Assert.Throws <Exception>(() => service.Execute(new ExecuteFetchRequest {
FetchXml = fetchXml
}));
Assert.Equal("Expected value between 0 and 5000 inclusive.", exception.Message);
}
public static void Should_Retrieve_A_Correct_Entity()
{
var account1 = new Account
{
AccountId = Guid.NewGuid(),
Name = "Account 1"
};
var account2 = new Account
{
AccountId = Guid.NewGuid(),
Name = "Account 2"
};
var account3 = new Account
{
AccountId = Guid.NewGuid(),
Name = "Account 3"
};
var fakedContext = new XrmFakedContext();
var fakedService = fakedContext.GetFakedOrganizationService();
fakedContext.Initialize(new[] { account1, account2, account3 });
var request = new RetrieveRequest
{
ColumnSet = new ColumnSet("name"),
Target = account2.ToEntityReference(),
};
var result = (RetrieveResponse)fakedService.Execute(request);
Assert.NotNull(result.Entity);
var resultAccount = result.Entity.ToEntity <Account>();
Assert.Equal(account2.Id, resultAccount.Id);
Assert.Equal(account2.Name, resultAccount.Name);
}
public void It_Should_Check_Execution_Criteria_On_Custom_Action()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
var template = "Hello ${{Value(\\\"subject\\\")}}";
var email = new Entity
{
Id = Guid.NewGuid(),
LogicalName = "email",
Attributes =
{
{ "subject", "Demo" }
}
};
context.Initialize(email);
var inputParameters = new ParameterCollection
{
{ "jsonInput", "{" +
"\"triggerUpdate\": true," +
"\"executionCriteria\": \"IsNull(Value(\\\"subject\\\"))\"," +
"\"targetField\": \"description\"," +
$"\"template\": \"{template}\"," +
$"\"target\": {{\"Id\": \"{email.Id}\", \"LogicalName\": \"{email.LogicalName}\"}}" +
"}" }
};
var pluginContext = context.GetDefaultPluginContext();
pluginContext.InputParameters = inputParameters;
pluginContext.OutputParameters = new ParameterCollection();
context.ExecutePluginWith <XTLProcessor>(pluginContext);
email = service.Retrieve(email.LogicalName, email.Id, new ColumnSet(true));
A.CallTo(() => service.Update(A <Entity> ._)).MustHaveHappened(Repeated.Never);
}
public void Shouldnt_store_references_to_variables_but_actual_clones()
{
var context = new XrmFakedContext();
var service = context.GetFakedOrganizationService();
//create an account and then retrieve it with no changes
Entity newAccount = new Entity("account");
newAccount["name"] = "New Account";
newAccount.Id = service.Create(newAccount);
Entity retrievedAccount = service.Retrieve("account", newAccount.Id, new Microsoft.Xrm.Sdk.Query.ColumnSet(true));
Assert.True(retrievedAccount.Attributes.Contains("name"));
//do the same as above, but this time clear the attributes - see that when retrieved, the retrieved entity does not contain the name attribute
Entity newAccount1 = new Entity("account");
newAccount1["name"] = "New Account1";
newAccount1.Id = service.Create(newAccount1);
newAccount1.Attributes.Clear();
Entity retrievedAccount1 = service.Retrieve("account", newAccount1.Id, new Microsoft.Xrm.Sdk.Query.ColumnSet(true));
Assert.True(retrievedAccount1.Attributes.Contains("name"));
//third time around, change the name to something new, the retrieved entity should not reflect this change
Entity newAccount2 = new Entity("account");
newAccount2["name"] = "New Account2";
newAccount2.Id = service.Create(newAccount2);
newAccount2["name"] = "Changed name";
Entity retrievedAccount2 = service.Retrieve("account", newAccount2.Id, new Microsoft.Xrm.Sdk.Query.ColumnSet(true));
Assert.True(retrievedAccount2["name"].ToString() == "New Account2", $"'{retrievedAccount2["name"]}' was not the expected result");
}
public void Should_not_override_a_statecode_already_initialized()
{
var context = new XrmFakedContext();
context.ProxyTypesAssembly = Assembly.GetExecutingAssembly();
var service = context.GetFakedOrganizationService();
var c = new Contact()
{
Id = Guid.NewGuid(),
};
c["statecode"] = new OptionSetValue(69); //As the StateCode is read only in the early bound entity, this is the only way of updating it
context.Initialize(new[] { c });
//Retrieve record after update
var contact = (from con in context.CreateQuery<Contact>()
where con.Id == c.Id
select con).FirstOrDefault();
Assert.Equal((int)contact.StateCode.Value, 69); //Set
}
public void When_querying_the_same_entity_records_with_joins_no_collection_modified_exception_is_thrown()
{
var fakedContext = new XrmFakedContext { };
var service = fakedContext.GetFakedOrganizationService();
var entityAccount = new Account { Id = Guid.NewGuid(), Name = "My First Faked Account yeah!", LogicalName = "account" };
var entityContact = new Contact { Id = Guid.NewGuid(), ParentCustomerId = entityAccount.ToEntityReference() };
var entityBusinessUnit = new BusinessUnit { Name = "TestBU", BusinessUnitId = Guid.NewGuid() };
var initiatingUser = new SystemUser
{
Id = Guid.NewGuid(),
FirstName = "TestUser",
DomainName = "TestDomain",
BusinessUnitId = entityBusinessUnit.ToEntityReference()
};
fakedContext.Initialize(new List<Entity>() {
entityBusinessUnit,entityAccount,entityContact,initiatingUser
});
var fetchXml = @"
<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'>
<entity name='systemuser'>
<attribute name='fullname' />
<attribute name='systemuserid' />
<attribute name='businessunitid' />
<filter type='and'>
<condition attribute='systemuserid' operator='eq' uitype='systemuser' value='#userId#' />
</filter>
<link-entity name='businessunit' from='businessunitid' to='businessunitid' alias='bu' intersect='true' >
<attribute name='name' />
</link-entity>
</entity>
</fetch>
";
var UserRequest = new RetrieveMultipleRequest { Query = new FetchExpression(fetchXml.Replace("#userId#", initiatingUser.Id.ToString())) };
var response = ((RetrieveMultipleResponse)service.Execute(UserRequest));
var entities = response.EntityCollection.Entities;
Assert.True(entities.Count == 1);
Assert.True(entities[0].Attributes.ContainsKey("bu.name"));
Assert.IsType<AliasedValue>(entities[0]["bu.name"]);
Assert.Equal("TestBU", (entities[0]["bu.name"] as AliasedValue).Value.ToString());
}
public void When_filtering_by_a_money_attribute_and_using_proxy_types_right_result_is_returned()
{
var context = new XrmFakedContext();
context.ProxyTypesAssembly = Assembly.GetAssembly(typeof(Account));
var contactId1 = Guid.NewGuid();
var contactId2 = Guid.NewGuid();
var account1 = new Account();
account1.Id = Guid.NewGuid();
account1.MarketCap = new Money(123.45m);
var account2 = new Account();
account2.Id = Guid.NewGuid();
account2.MarketCap = new Money(223.45m);
context.Initialize(new List<Entity> { account1, account2 });
var fetchXml =
"<fetch>" +
" <entity name='account'>" +
" <attribute name='name'/>" +
" <filter type='and'>" +
" <condition attribute='marketcap' operator='eq' value='123.45' />" +
" </filter>" +
" </entity>" +
"</fetch>";
var rows = context.GetFakedOrganizationService().RetrieveMultiple(new FetchExpression(fetchXml));
Assert.Equal(rows.Entities.Count, 1);
}
public void When_filtering_by_an_enum_attribute_and_using_proxy_types_right_result_is_returned()
{
var fakedContext = new XrmFakedContext { };
var entityAccount = new Account { Id = Guid.NewGuid(), Name = "Test Account", LogicalName = "account" };
var entityContact = new Contact { Id = Guid.NewGuid(), ParentCustomerId = entityAccount.ToEntityReference(), EMailAddress1 = "*****@*****.**" };
var entityCase = new Incident
{
Id = Guid.NewGuid(),
PrimaryContactId = entityContact.ToEntityReference(),
CustomerId = entityAccount.ToEntityReference(),
Title = "Unit Test Case"
};
entityCase["statecode"] = new OptionSetValue((int) IncidentState.Active);
fakedContext.Initialize(new List<Entity>() {
entityAccount,entityContact, entityCase
});
var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false' >
<entity name='incident' >
<attribute name='incidentid' />
<attribute name='statecode' />
<order attribute='createdon' descending='true' />
<filter type='and' >
<condition attribute='statecode' operator='neq' value='2' />
</filter>
</entity>
</fetch>";
var rows = fakedContext.GetFakedOrganizationService().RetrieveMultiple(new FetchExpression(fetchXml));
Assert.Equal(rows.Entities.Count, 1);
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var updateRequest = (UpdateRequest) request;
var target = (Entity)request.Parameters["Target"];
var service = ctx.GetFakedOrganizationService();
service.Update(target);
return new UpdateResponse();
}
