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_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_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_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 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 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_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 void When_a_query_expression_without_pagination_is_executed_all_records_are_returned() { var context = new XrmFakedContext(); //Create 20 contacts var contactList = new List<Entity>(); for (var i= 0; i < 20; i++) { contactList.Add(new Entity("contact") { Id = Guid.NewGuid() }); } context.Initialize(contactList); var qe = new QueryExpression() { EntityName = "contact" }; qe.ColumnSet = new ColumnSet(true); var result = XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList(); Assert.True(result.Count == 20); }
public void When_a_query_expression_with_topcount_is_executed_only_a_number_of_records_equals_to_the_page_size_is_returned() { var context = new XrmFakedContext(); //Create 20 contacts var contactList = new List<Entity>(); for (var i = 0; i < 20; i++) { contactList.Add(new Entity("contact") { Id = Guid.NewGuid() }); } context.Initialize(contactList); var qe = new QueryExpression() { EntityName = "contact" }; qe.ColumnSet = new ColumnSet(true); qe.TopCount = 10; var result = XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList(); Assert.True(result.Count == 10); }
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 Should_Not_Change_Context_Objects_Without_Update_And_Retrieve_Multiple() { var entityId = Guid.NewGuid(); var context = new XrmFakedContext(); var service = context.GetOrganizationService(); context.Initialize(new[] { new Account { Id = entityId, Name = "Adventure Works" } }); Account firstRetrieve, secondRetrieve = null; using (var ctx = new XrmServiceContext(service)) { firstRetrieve = ctx.CreateQuery <Account>() .Where(a => a.AccountId == entityId) .FirstOrDefault(); } using (var ctx = new XrmServiceContext(service)) { secondRetrieve = ctx.CreateQuery <Account>() .Where(a => a.AccountId == entityId) .FirstOrDefault(); } firstRetrieve.Name = "Updated locally"; Assert.False(firstRetrieve == secondRetrieve); Assert.Equal("Updated locally", firstRetrieve.Name); Assert.Equal("Adventure Works", secondRetrieve.Name); }
public void When_executing_a_query_expression_with_a_not_null_operator_right_result_is_returned() { var context = new XrmFakedContext(); var contact1 = new Entity("contact") { Id = Guid.NewGuid() }; contact1["fullname"] = "1 Contact"; var contact2 = new Entity("contact") { Id = Guid.NewGuid() }; contact2["fullname"] = null; var contact3 = new Entity("contact") { Id = Guid.NewGuid() }; context.Initialize(new List <Entity>() { contact1, contact2, contact3 }); var qe = new QueryExpression() { EntityName = "contact" }; qe.ColumnSet = new ColumnSet(true); qe.Criteria = new FilterExpression(LogicalOperator.And); var condition = new ConditionExpression("fullname", ConditionOperator.NotNull); qe.Criteria.AddCondition(condition); var result = XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList(); Assert.True(result.Count() == 1); }
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 TestRetrieveMultipleWithNull() { Entity testEntity = new Entity("testentity"); testEntity["field"] = null; testEntity.Id = Guid.NewGuid(); XrmFakedContext context = new XrmFakedContext(); IOrganizationService service = context.GetOrganizationService(); context.Initialize( new List <Entity>() { testEntity } ); QueryExpression contactQuery = new QueryExpression("testentity"); contactQuery.ColumnSet = new ColumnSet("field"); EntityCollection result = service.RetrieveMultiple(contactQuery); Assert.False(result.Entities[0].Contains("field")); }
public void When_executing_a_linq_query_with_equals_between_2_strings_with_date_format_right_result_is_returned() { var fakedContext = new XrmFakedContext(); var guid = Guid.NewGuid(); fakedContext.Initialize(new List <Entity>() { new Contact() { Id = guid, FirstName = "11.1" } }); var service = fakedContext.GetFakedOrganizationService(); using (XrmServiceContext ctx = new XrmServiceContext(service)) { var contact = (from c in ctx.CreateQuery <Contact>() where c.FirstName == "11.1" select c).FirstOrDefault(); Assert.True(contact != null); } }
public void SingleEntity_AllPluginsDisabled() { var fakedContext = new XrmFakedContext(); fakedContext.InitializeMetadata(typeof(CrmEarlyBound.CrmServiceContext).Assembly); fakedContext.Initialize(SupportMethods.GetSingleEntity_AllPluginsDisabledEntity()); fakedContext.AddExecutionMock <RetrieveEntityRequest>(req => { var entityMetadata = fakedContext.GetEntityMetadataByName(SupportMethods.AccountLogicalName); entityMetadata.DisplayName = new Label(SupportMethods.AccountDisplayName, 1033); entityMetadata.SetSealedPropertyValue("PrimaryNameAttribute", "name"); entityMetadata.Attributes.First(a => a.LogicalName == "name").SetSealedPropertyValue("DisplayName", new Label("Account Name", 1033)); entityMetadata.Attributes.First(a => a.LogicalName == "accountid").SetSealedPropertyValue("DisplayName", new Label("Account", 1033)); entityMetadata.Attributes.First(a => a.LogicalName == "accountid").SetSealedPropertyValue("AttributeType", AttributeTypeCode.Uniqueidentifier); var response = new RetrieveEntityResponse() { Results = new ParameterCollection { { "EntityMetadata", entityMetadata } } }; return(response); }); IOrganizationService fakedService = fakedContext.GetOrganizationService(); DataBuilder DataBuilder = new DataBuilder(fakedService); DataBuilder.SetPluginsDisabled(true); DataBuilder.AppendData(SupportMethods.GetSingleEntity_AllPluginsDisabledFetch()); Assert.AreEqual( DataBuilder.BuildSchemaXML().InnerXml, SupportMethods.GetSingleEntity_AllPluginsDisabledEntityExpectedSchema()); }
public void BuAndOrgAreReturnedWhenUserBelongsToBuAndOrg() { var businessUnit = new Entity("businessunit") { Id = Guid.NewGuid() }; var user = new Entity("systemuser") { Id = Guid.NewGuid(), ["businessunitid"] = businessUnit.ToEntityReference(), ["organizationid"] = (Guid?)organization_.Id }; var dbContent = new List <Entity> { user, businessUnit, organization_ }; var context = new XrmFakedContext() { CallerId = user.ToEntityReference() }; context.Initialize(dbContent); var service = context.GetOrganizationService(); var req = new WhoAmIRequest(); var response = service.Execute(req) as WhoAmIResponse; Assert.Equal(user.Id, response.UserId); Assert.Equal(businessUnit.Id, response.BusinessUnitId); Assert.Equal(organization_.Id, response.OrganizationId); }
public void It_Should_Execute_On_Custom_Action() { var context = new XrmFakedContext(); 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", "{" + $"\"template\": \"{template}\"," + $"\"target\": {{\"Id\": \"{email.Id}\", \"LogicalName\": \"{email.LogicalName}\"}}" + "}" } }; var pluginContext = context.GetDefaultPluginContext(); pluginContext.InputParameters = inputParameters; pluginContext.OutputParameters = new ParameterCollection(); context.ExecutePluginWith <XTLProcessor>(pluginContext); var expected = @"{""error"":null,""result"":""Hello Demo"",""success"":true,""traceLog"":""Processing token 'Value(\""subject\"")'\u000d\u000aInitiating interpreter\u000d\u000aProcessing handler Value\u000d\u000aSuccessfully processed handler Value\u000d\u000aReplacing token with 'Demo'\u000d\u000a""}"; Assert.That(pluginContext.OutputParameters["jsonOutput"], Is.EqualTo(expected)); }
public void Should_Override_Execution_Mock() { var context = new XrmFakedContext(); var service = context.GetFakedOrganizationService(); var e = new Entity("Contact") { Id = Guid.NewGuid() }; context.Initialize(new[] { e }); context.AddExecutionMock <RetrieveEntityRequest>(RetrieveEntityMock); context.AddExecutionMock <RetrieveEntityRequest>(AnotherRetrieveEntityMock); var inputs = new ParameterCollection { { "Target", e } }; context.ExecutePluginWith <CustomMockPlugin>(inputs, new ParameterCollection(), new EntityImageCollection(), new EntityImageCollection()); Assert.Equal("Another", (string)e["response"]); Assert.DoesNotThrow(() => context.RemoveExecutionMock <RetrieveEntityRequest>()); }
public void When_filtering_by_a_boolean_attribute_and_using_proxy_types_right_result_is_returned() { var context = new XrmFakedContext(); context.ProxyTypesAssembly = Assembly.GetAssembly(typeof(Account)); var account1 = new Account(); account1.Id = Guid.NewGuid(); account1.Name = "Test 1"; account1.DoNotEMail = false; var account2 = new Account(); account2.Id = Guid.NewGuid(); account2.Name = "Test 2"; account2.DoNotEMail = true; context.Initialize(new List <Entity> { account1, account2 }); var fetchXml = "<fetch>" + " <entity name='account'>" + " <attribute name='name'/>" + " <filter type='and'>" + " <condition attribute='donotemail' operator='eq' value='0' />" + " </filter>" + " </entity>" + "</fetch>"; var rows = context.GetFakedOrganizationService().RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(rows.Entities.Count, 1); Assert.Equal(rows.Entities[0].ToEntity <Account>().Name, account1.Name); }
public void When_executing_a_query_expression_with_in_operator_right_result_is_returned() { var context = new XrmFakedContext(); var contact1 = new Entity("contact") { Id = Guid.NewGuid() }; contact1["fullname"] = "McDonald"; contact1["firstname"] = "First 1"; var contact2 = new Entity("contact") { Id = Guid.NewGuid() }; contact2["fullname"] = "King"; contact2["firstname"] = "First 2"; var contact3 = new Entity("contact") { Id = Guid.NewGuid() }; contact2["fullname"] = "King"; contact2["firstname"] = "First 2"; context.Initialize(new List <Entity>() { contact1, contact2 }); var qe = new QueryExpression() { EntityName = "contact" }; qe.ColumnSet = new ColumnSet(true); qe.Criteria = new FilterExpression(LogicalOperator.And); var condition = new ConditionExpression("fullname", ConditionOperator.In, new string[] { "McDonald", "King" }); qe.Criteria.AddCondition(condition); var result = XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList(); Assert.True(result.Count() == 2); }
public void DeleteAttachment_Delete_From_0_To_100000_No_Extensions() { //Arrange XrmFakedWorkflowContext workflowContext = new XrmFakedWorkflowContext(); Entity note1 = new Entity("annotation") { Id = Guid.NewGuid(), ["filesize"] = 100000, ["filename"] = "text.docx", ["isdocument"] = true }; var inputs = new Dictionary <string, object> { { "NoteWithAttachment", note1.ToEntityReference() }, { "DeleteSizeMax", 10000 }, { "DeleteSizeMin", 0 }, { "Extensions", null }, { "AppendNotice", false } }; XrmFakedContext xrmFakedContext = new XrmFakedContext(); xrmFakedContext.Initialize(new List <Entity> { note1 }); const int expected = 1; //Act var result = xrmFakedContext.ExecuteCodeActivity <DeleteAttachment>(workflowContext, inputs); //Assert Assert.AreEqual(expected, result["NumberOfAttachmentsDeleted"]); }
public static void When_a_query_by_a_boolean_attribute_is_executed_with_one_attribute_right_result_is_returned() { var context = new XrmFakedContext(); var account = new Account() { Id = Guid.NewGuid(), Name = "Test", DoNotEMail = false }; var account2 = new Account() { Id = Guid.NewGuid(), Name = "Other account!", DoNotEMail = true }; context.Initialize(new List <Entity>() { account, account2 }); var service = context.GetFakedOrganizationService(); var query = new QueryByAttribute { EntityName = Account.EntityLogicalName, ColumnSet = new ColumnSet("name") }; query.AddAttributeValue("donotemail", false); //Execute using a request to test the OOB (XRM) message contracts RetrieveMultipleRequest request = new RetrieveMultipleRequest(); request.Query = query; Collection <Entity> entityList = ((RetrieveMultipleResponse)service.Execute(request)).EntityCollection.Entities; Assert.True(entityList.Count == 1); Assert.Equal(entityList[0]["name"].ToString(), "Test"); }
public void When_Querying_Using_LinQ_Results_Should_Appear() { var context = new XrmFakedContext(); var account = new Account { Id = Guid.NewGuid() }; var contact = new Contact { Id = Guid.NewGuid(), Attributes = new AttributeCollection { { "accountid", account.ToEntityReference() } } }; context.Initialize(new Entity[] { account, contact }); var contactResult = context.CreateQuery <Contact>().SingleOrDefault(con => con.Id == contact.Id); Assert.NotNull(contactResult); }
public static void When_a_query_by_attribute_is_executed_with_one_null_attribute_it_is_not_returned() { var fakedContext = new XrmFakedContext(); var fakedService = fakedContext.GetFakedOrganizationService(); var contact = new Contact { Id = Guid.NewGuid(), FirstName = null, LastName = "asdf" }; fakedContext.Initialize(new List <Entity> { contact }); QueryByAttribute query = new QueryByAttribute("contact"); query.ColumnSet = new ColumnSet("firstname", "lastname"); var results = fakedService.RetrieveMultiple(query); Assert.True(results.Entities[0].Attributes.ContainsKey("lastname")); Assert.False(results.Entities[0].Attributes.ContainsKey("firstname")); }
public void When_OnlyDeactivated_WorkOrderExist_And_Passing_Correct_IotAlertId_Should_Return_Null() { XrmFakedContext fakedContext = new XrmFakedContext(); Entity serviceRequest = new Entity("incident", Guid.NewGuid()); Entity workOrder = new Entity("msdyn_workorder", Guid.NewGuid()); workOrder["msdyn_servicerequest"] = serviceRequest.ToEntityReference(); workOrder["statuscode"] = new OptionSetValue((int)StatusCode_WO.Inactive); fakedContext.Initialize(new List <Entity>() { serviceRequest, workOrder }); var inputs = new Dictionary <string, object>() { { "ServiceRequestId", serviceRequest.ToEntityReference() } }; var outputParameter = fakedContext.ExecuteCodeActivity <GetWorkOrderRelatedServiceRequest>(inputs); var isExists = (bool)outputParameter["IsExists"]; Assert.IsFalse(isExists); var workOrderId = outputParameter["WorkOrderId"] as EntityReference; Assert.IsNull(workOrderId); }
public void TestThatPageInfoTotalRecordCountWorks() { XrmFakedContext context = new XrmFakedContext(); IOrganizationService service = context.GetOrganizationService(); List <Entity> initialEntities = new List <Entity>(); Entity e = new Entity("entity"); e.Id = Guid.NewGuid(); e["retrieve"] = true; initialEntities.Add(e); Entity e2 = new Entity("entity"); e2.Id = Guid.NewGuid(); e2["retrieve"] = true; initialEntities.Add(e2); Entity e3 = new Entity("entity"); e3.Id = Guid.NewGuid(); e3["retrieve"] = false; initialEntities.Add(e3); context.Initialize(initialEntities); QueryExpression query = new QueryExpression("entity"); query.PageInfo.ReturnTotalRecordCount = true; query.Criteria.AddCondition("retrieve", ConditionOperator.Equal, true); EntityCollection result = service.RetrieveMultiple(query); Assert.Equal(2, result.Entities.Count); Assert.Equal(2, result.TotalRecordCount); Assert.False(result.MoreRecords); }
public void When_a_non_existing_member_is_added_to_an_existing_list_exception_is_thrown() { var ctx = new XrmFakedContext(); var service = ctx.GetOrganizationService(); var list = new Crm.List() { Id = Guid.NewGuid(), ListName = "Some list", CreatedFromCode = new OptionSetValue((int)ListCreatedFromCode.Account) }; ctx.Initialize(new List <Entity> { list }); AddMemberListRequest request = new AddMemberListRequest(); request.EntityId = Guid.NewGuid(); request.ListId = list.ToEntityReference().Id; Assert.Throws <FaultException <OrganizationServiceFault> >(() => service.Execute(request)); }
public void When_executing_a_query_expression_with_an_attribute_in_columnset_that_doesnt_exists_no_value_is_returned_with_dynamic_entities() { var context = new XrmFakedContext(); var contact1 = new Entity("contact") { Id = Guid.NewGuid() }; contact1["fullname"] = "Contact 1"; contact1["firstname"] = "First 1"; var account = new Entity("account") { Id = Guid.NewGuid() }; account["name"] = "Account 1"; contact1["parentcustomerid"] = account.ToEntityReference(); //Both contacts are related to the same account context.Initialize(new List <Entity>() { account, contact1 }); var qe = new QueryExpression() { EntityName = "contact" }; //We only select fullname and parentcustomerid, firstname should not be included qe.ColumnSet = new ColumnSet(new string[] { "this attribute doesnt exists!" }); XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList(); var list = XrmFakedContext.TranslateQueryExpressionToLinq(context, qe).ToList(); Assert.False(list[0].Attributes.ContainsKey("this attribute doesnt exists!")); }
public void When_initializing_with_two_entities_with_two_different_guids_the_context_will_have_both() { var context = new XrmFakedContext(); var guid1 = Guid.NewGuid(); var guid2 = Guid.NewGuid(); IQueryable <Entity> data = new List <Entity>() { new Entity("account") { Id = guid1 }, new Entity("account") { Id = guid2 } }.AsQueryable(); context.Initialize(data); Assert.True(context.Data.Count == 1); Assert.True(context.Data["account"].Count == 2); Assert.Equal(context.Data["account"][guid1].Id, data.FirstOrDefault().Id); Assert.Equal(context.Data["account"][guid2].Id, data.LastOrDefault().Id); }
public void FetchXml_Aggregate_Sum_Money() { var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' aggregate='true'> <entity name='salesorderdetail'> <attribute name='priceperunit' alias='sum' aggregate='sum'/> </entity> </fetch>"; var ctx = new XrmFakedContext(); ctx.Initialize(new[] { new SalesOrderDetail() { Id = Guid.NewGuid(), PricePerUnit = new Money(100m) }, new SalesOrderDetail() { Id = Guid.NewGuid(), PricePerUnit = new Money(100m) }, new SalesOrderDetail() { Id = Guid.NewGuid(), }, /* attribute missing */ new SalesOrderDetail() { Id = Guid.NewGuid(), PricePerUnit = null }, }); var collection = ctx.GetFakedOrganizationService().RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(1, collection.Entities.Count); var ent = collection.Entities[0]; Assert.IsType(typeof(Money), ent.GetAttributeValue <AliasedValue>("sum")?.Value); Assert.Equal(200m, (ent.GetAttributeValue <AliasedValue>("sum")?.Value as Money)?.Value); }
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 void FetchXml_Aggregate_Dategroup_Month() { var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false' aggregate='true'> <entity name='contact'> <attribute name='contactid' alias='count.contacts' aggregate='count' /> <attribute name='birthdate' alias='group.dob' groupby='true' dategrouping='month' /> </entity> </fetch>"; var ctx = new XrmFakedContext(); ctx.Initialize(BirthdateContacts); var collection = ctx.GetFakedOrganizationService().RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(3, collection.Entities.Count); var byMonth = collection.Entities.ToDictionary(x => x.GetAttributeValue <AliasedValue>("group.dob").Value as int?); Assert.Equal(new int?[] { 1, 2, 5 }, byMonth.Keys.OrderBy(x => x)); Assert.Equal(2, byMonth[1].GetAttributeValue <AliasedValue>("count.contacts").Value); Assert.Equal(1, byMonth[2].GetAttributeValue <AliasedValue>("count.contacts").Value); Assert.Equal(1, byMonth[5].GetAttributeValue <AliasedValue>("count.contacts").Value); }
public void TestThatPageInfoTotalRecordCountWorksWithPaging() { XrmFakedContext context = new XrmFakedContext(); IOrganizationService service = context.GetOrganizationService(); List <Entity> initialEntities = new List <Entity>(); for (int i = 0; i < 100; i++) { Entity e = new Entity("entity"); e.Id = Guid.NewGuid(); initialEntities.Add(e); } context.Initialize(initialEntities); QueryExpression query = new QueryExpression("entity"); query.PageInfo.ReturnTotalRecordCount = true; query.PageInfo.PageNumber = 1; query.PageInfo.Count = 10; EntityCollection result = service.RetrieveMultiple(query); Assert.Equal(10, result.Entities.Count); Assert.Equal(100, result.TotalRecordCount); Assert.True(result.MoreRecords); query.PageInfo.PageNumber++; query.PageInfo.Count = 20; query.PageInfo.PagingCookie = result.PagingCookie; result = service.RetrieveMultiple(query); Assert.Equal(20, result.Entities.Count); Assert.Equal(100, result.TotalRecordCount); Assert.True(result.MoreRecords); }
public void When_updating_an_entity_Modified_On_Should_Also_Be_Updated() { var context = new XrmFakedContext(); var service = context.GetFakedOrganizationService(); var e = new Entity("account") { Id = Guid.NewGuid() }; context.Initialize(new List <Entity>() { e }); var oldModifiedOn = (DateTime)e["modifiedon"]; Thread.Sleep(1000); service.Update(e); var newModifiedOn = (DateTime)e["modifiedon"]; Assert.NotEqual(oldModifiedOn, newModifiedOn); }
public void When_querying_fetchxml_with_linked_entities_with_left_outer_join_right_result_is_returned() { var context = new XrmFakedContext(); var service = context.GetFakedOrganizationService(); var contact = new Contact() { Id = Guid.NewGuid(), FirstName = "Lionel" }; var account = new Account() { Id = Guid.NewGuid(), PrimaryContactId = contact.ToEntityReference() }; var account2 = new Account() { Id = Guid.NewGuid(), PrimaryContactId = null }; context.Initialize(new List<Entity> { contact, account, account2 }); var fetchXml = @" <fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'> <entity name='account'> <attribute name='name' /> <attribute name='primarycontactid' /> <attribute name='telephone1' /> <attribute name='accountid' /> <order attribute='name' descending='false' /> <link-entity name='contact' from='contactid' to='primarycontactid' alias='aa' link-type='outer'> <attribute name='firstname' /> </link-entity> <filter type='and'> <condition attribute='statecode' operator='eq' value='0' /> </filter> </entity> </fetch> "; //Translated correctly var queryExpression = XrmFakedContext.TranslateFetchXmlToQueryExpression(context, fetchXml); Assert.True(queryExpression.LinkEntities.Count == 1); var linkedEntity = queryExpression.LinkEntities[0]; Assert.Equal(linkedEntity.JoinOperator, JoinOperator.LeftOuter); //Executed correctly var request = new RetrieveMultipleRequest { Query = new FetchExpression(fetchXml) }; var response = ((RetrieveMultipleResponse)service.Execute(request)); var entities = response.EntityCollection.Entities; Assert.True(entities.Count == 2); Assert.Equal("Lionel", (entities[0]["aa.firstname"] as AliasedValue).Value.ToString()); Assert.False(entities[1].Attributes.ContainsKey("aa.firstname")); }
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_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 static void Should_Only_Find_Correct_Faked_N_To_N_Records() { var fakedContext = new XrmFakedContext(); var fakedService = fakedContext.GetFakedOrganizationService(); var userId = new Guid("11111111-7982-4276-A8FE-7CE05FABEAB4"); var businessId = Guid.NewGuid(); var testUser = new SystemUser { Id = userId }; var testRole = new Role { Id = new Guid("22222222-7982-4276-A8FE-7CE05FABEAB4"), Name = "Test Role", BusinessUnitId = new EntityReference(BusinessUnit.EntityLogicalName, businessId) }; var testUser2 = new SystemUser { Id = Guid.NewGuid() }; var testRole2 = new Role { Id = Guid.NewGuid(), Name = "Test Role", BusinessUnitId = new EntityReference(BusinessUnit.EntityLogicalName, businessId) }; fakedContext.Initialize(new Entity[] { testUser, testRole, testUser2, testRole2 }); fakedContext.AddRelationship("systemuserroles_association", new XrmFakedRelationship { IntersectEntity = "systemuserroles", Entity1LogicalName = SystemUser.EntityLogicalName, Entity1Attribute = "systemuserid", Entity2LogicalName = Role.EntityLogicalName, Entity2Attribute = "roleid" }); var request = new AssociateRequest() { Target = testUser.ToEntityReference(), RelatedEntities = new EntityReferenceCollection() { new EntityReference(Role.EntityLogicalName, testRole.Id), }, Relationship = new Relationship("systemuserroles_association") }; fakedService.Execute(request); var request2 = new AssociateRequest() { Target = testUser2.ToEntityReference(), RelatedEntities = new EntityReferenceCollection() { new EntityReference(Role.EntityLogicalName, testRole2.Id), }, Relationship = new Relationship("systemuserroles_association") }; fakedService.Execute(request2); var query = new QueryExpression() { EntityName = "role", ColumnSet = new ColumnSet("name"), LinkEntities = { new LinkEntity { LinkFromEntityName = Role.EntityLogicalName, LinkFromAttributeName = "roleid", LinkToEntityName = SystemUserRoles.EntityLogicalName, LinkToAttributeName = "roleid", LinkCriteria = new FilterExpression { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression { AttributeName = "systemuserid", Operator = ConditionOperator.Equal, Values = { userId } } } } } } }; var result = fakedService.RetrieveMultiple(query); Assert.NotEmpty(result.Entities); Assert.Equal(1, result.Entities.Count); }
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 void Should_Apply_Left_Outer_Join_Filters_When_The_Right_hand_side_of_the_expression_was_found() { var context = new XrmFakedContext(); var service = context.GetFakedOrganizationService(); // Date for filtering, we only want "expired" records, i.e. those that weren't set as regarding in any emails for this period and logically even exist this long var days = 5; var incident = new Incident { Id = Guid.NewGuid(), Title = "Test case", StatusCode = new OptionSetValue((int)IncidentState.Active) }; var email = new Email { Id = Guid.NewGuid(), RegardingObjectId = incident.ToEntityReference(), }; incident["createdon"] = DateTime.UtcNow.AddDays(-6); email["createdon"] = DateTime.UtcNow.AddDays(10); context.Initialize(new List <Entity>() { incident, email }); // Remove either incident createdon conditionexpression, or LinkEntities and the e-mail conditionexpression and it will pass // What this query expresses: Get all incidents, that are older than given number of days and that also didn't receive emails for this number of days var query = new QueryExpression { ColumnSet = new ColumnSet(true), EntityName = Incident.EntityLogicalName, Criteria = { FilterOperator = LogicalOperator.And, Filters = { new FilterExpression { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression("statuscode", ConditionOperator.Equal, new OptionSetValue((int)IncidentState.Active)), new ConditionExpression("createdon", ConditionOperator.LessEqual, DateTime.UtcNow.AddDays(-1 * days)) } } } }, LinkEntities = { new LinkEntity { LinkFromEntityName = "incident", LinkToEntityName = "email", LinkFromAttributeName = "incidentid", LinkToAttributeName = "regardingobjectid", JoinOperator = JoinOperator.LeftOuter, LinkCriteria = new FilterExpression { Filters = { new FilterExpression { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression("createdon", ConditionOperator.GreaterEqual, DateTime.UtcNow.AddDays(-1 * days)) } } } } } } }; var incidents = service.RetrieveMultiple(query).Entities; Assert.Equal(1, incidents.Count); }
public void When_execute_is_called_with_reverse_param_order() { var context = new XrmFakedContext(); var userId = Guid.NewGuid(); var teamId = Guid.NewGuid(); var user2Id = Guid.NewGuid(); context.Initialize(new List <Entity> { new SystemUser { Id = userId }, new SystemUser { Id = user2Id }, new Team { Id = teamId }, new Entity("teammembership") { Id = Guid.NewGuid(), ["systemuserid"] = userId, ["teamid"] = teamId }, new Entity("teammembership") { Id = Guid.NewGuid(), ["systemuserid"] = teamId, ["teamid"] = userId }, new Entity("teammembership") { Id = Guid.NewGuid(), ["systemuserid"] = user2Id, ["teamid"] = teamId }, new Entity("teammembership") { Id = Guid.NewGuid(), ["systemuserid"] = teamId, ["teamid"] = user2Id } }); context.AddRelationship("teammembership", new XrmFakedRelationship() { RelationshipType = XrmFakedRelationship.enmFakeRelationshipType.ManyToMany, IntersectEntity = "teammembership", Entity1Attribute = "systemuserid", Entity1LogicalName = "systemuser", Entity2Attribute = "teamid", Entity2LogicalName = "team" }); var orgSvc = context.GetFakedOrganizationService(); orgSvc.Disassociate("team", teamId, new Relationship("teammembership"), new EntityReferenceCollection(new List <EntityReference> { new EntityReference("systemuser", userId), new EntityReference("systemuser", user2Id) })); using (Crm.XrmServiceContext ctx = new XrmServiceContext(orgSvc)) { var correctAssociation1 = (from tu in ctx.TeamMembershipSet where tu.TeamId == teamId && tu.SystemUserId == user2Id select tu).ToList(); Assert.False(correctAssociation1.Any()); var correctAssociation = (from tu in ctx.TeamMembershipSet where tu.TeamId == teamId && tu.SystemUserId == userId select tu).ToList(); Assert.False(correctAssociation.Any()); var wrongAssociation2 = (from tu in ctx.TeamMembershipSet where tu.TeamId == user2Id && tu.SystemUserId == teamId select tu).ToList(); Assert.Equal(1, wrongAssociation2.Count()); var wrongAssociation = (from tu in ctx.TeamMembershipSet where tu.TeamId == userId && tu.SystemUserId == teamId select tu).ToList(); Assert.Equal(1, wrongAssociation.Count()); } }
public void When_ordering_by_guid_fields_expected_result_is_returned() { List<Entity> contactList = new List<Entity>(); var g1 = new Guid(12, 0, 0, new byte[] { new byte(), new byte(), new byte(), new byte(), new byte(), new byte(), new byte(), new byte() }); var g2 = new Guid(24, 0, 0, new byte[] { new byte(), new byte(), new byte(), new byte(), new byte(), new byte(), new byte(), new byte() }); Entity contact1 = new Entity("contact"); contact1.Id = Guid.NewGuid(); contact1.Attributes["firstname"] = "Fred"; contact1.Attributes["new_orderbyfield"] = g1; Entity contact2 = new Entity("contact"); contact2.Id = Guid.NewGuid(); contact2.Attributes["firstname"] = "Jo"; contact2.Attributes["new_orderbyfield"] = g2; 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 = (Guid)results.Entities[0]["new_orderbyfield"]; Assert.Equal(g1, firstResultValue); }
public void When_ordering_by_entity_reference_fields_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 EntityReference() { Id = Guid.NewGuid(), Name = "Jordi" }; Entity contact2 = new Entity("contact"); contact2.Id = Guid.NewGuid(); contact2.Attributes["firstname"] = "Jo"; contact2.Attributes["lastname"] = "Bloggs"; contact2.Attributes["new_somefield"] = new EntityReference() { Id = Guid.NewGuid(), Name = "Skuba" }; 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.Ascending); var results = service.RetrieveMultiple(qry); var firstResultValue = results.Entities[0]["new_somefield"] as EntityReference; Assert.Equal("Jordi", firstResultValue.Name); }
public void FetchXml_Operator_Le_Execution() { var ctx = new XrmFakedContext(); var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'> <entity name='contact'> <attribute name='address1_longitude' /> <filter type='and'> <condition attribute='address1_longitude' operator='le' value='1.2345' /> </filter> </entity> </fetch>"; var ct1 = new Contact() { Id = Guid.NewGuid(), Address1_Longitude = 1.23 }; var ct2 = new Contact() { Id = Guid.NewGuid(), Address1_Longitude = 1.33 }; var ct3 = new Contact() { Id = Guid.NewGuid(), Address1_Longitude = 1.2345 }; ctx.Initialize(new[] { ct1, ct2, ct3 }); var service = ctx.GetFakedOrganizationService(); var collection = service.RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(2, collection.Entities.Count); Assert.Equal(1.23, collection.Entities[0]["address1_longitude"]); Assert.Equal(1.2345, collection.Entities[1]["address1_longitude"]); }
public void FetchXml_Operator_On_Execution() { var ctx = new XrmFakedContext(); var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'> <entity name='contact'> <attribute name='anniversary' /> <filter type='and'> <condition attribute='anniversary' operator='on' value='2014-11-23' /> </filter> </entity> </fetch>"; var date = new DateTime(2014, 11, 23); var ct1 = new Contact() { Id = Guid.NewGuid(), Anniversary = date }; var ct2 = new Contact() { Id = Guid.NewGuid(), Anniversary = date.AddDays(1) }; ctx.Initialize(new[] { ct1, ct2 }); var service = ctx.GetFakedOrganizationService(); var collection = service.RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(1, collection.Entities.Count); var retrievedDate = collection.Entities[0]["anniversary"] as DateTime?; Assert.Equal(2014, retrievedDate.Value.Year); Assert.Equal(11, retrievedDate.Value.Month); Assert.Equal(23, retrievedDate.Value.Day); }
public void FetchXml_Operator_Yesterday_Execution() { var ctx = new XrmFakedContext(); var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'> <entity name='contact'> <attribute name='anniversary' /> <filter type='and'> <condition attribute='anniversary' operator='yesterday' /> </filter> </entity> </fetch>"; var date = DateTime.Today; var ct1 = new Contact() { Id = Guid.NewGuid(), Anniversary = date }; //Shouldnt var ct2 = new Contact() { Id = Guid.NewGuid(), Anniversary = date.AddDays(-1) }; //Should be returned ctx.Initialize(new[] { ct1, ct2 }); var service = ctx.GetFakedOrganizationService(); var collection = service.RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(1, collection.Entities.Count); var retrievedDate = collection.Entities[0]["anniversary"] as DateTime?; Assert.Equal(retrievedDate, DateTime.Today.AddDays(-1)); }
public void FetchXml_Operator_NotBetween_Execution() { var ctx = new XrmFakedContext(); var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'> <entity name='contact'> <attribute name='anniversary' /> <filter type='and'> <condition attribute='anniversary' operator='not-between'> <value>2013-05-17 00:00:00</value> <value>2013-05-20 14:40:00</value> </condition> </filter> </entity> </fetch>"; var date = DateTime.Today; var ct1 = new Contact() { Id = Guid.NewGuid(), Anniversary = date }; //Should var ct2 = new Contact() { Id = Guid.NewGuid(), Anniversary = new DateTime(2013, 05, 19) }; //Shouldnt ctx.Initialize(new[] { ct1, ct2 }); var service = ctx.GetFakedOrganizationService(); var collection = service.RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(1, collection.Entities.Count); var retrievedDate = collection.Entities[0]["anniversary"] as DateTime?; Assert.Equal(retrievedDate, date); }
public void When_querying_by_an_attribute_which_wasnt_initialised_null_value_is_returned_for_early_bound_and_not_an_exception() { var ctx = new XrmFakedContext(); ctx.ProxyTypesAssembly = Assembly.GetAssembly(typeof(Contact)); var service = ctx.GetFakedOrganizationService(); ctx.Initialize(new List<Entity>() { new Contact() { Id = Guid.NewGuid(), LastName = "Mcdonald" } }); var name = "Mcdonald"; using (var context = new XrmServiceContext(service)) { var contacts = (from c in context.ContactSet where c.FirstName == name || c.LastName == name select new Contact { Id = c.Id, FirstName = c.FirstName, LastName = c.LastName }).ToList(); Assert.Equal(1, contacts.Count); Assert.Null(contacts[0].FirstName); } }
public void When_querying_fetchxml_with_linked_entities_linked_entity_properties_match_the_equivalent_linq_expression() { var context = new XrmFakedContext(); var service = context.GetFakedOrganizationService(); var contact = new Contact() { Id = Guid.NewGuid(), FirstName = "Lionel" }; var account = new Account() { Id = Guid.NewGuid(), PrimaryContactId = contact.ToEntityReference() }; context.Initialize(new List<Entity> { contact, account }); var fetchXml = @" <fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false'> <entity name='account'> <attribute name='name' /> <attribute name='primarycontactid' /> <attribute name='telephone1' /> <attribute name='accountid' /> <order attribute='name' descending='false' /> <link-entity name='contact' from='contactid' to='primarycontactid' alias='aa'> <attribute name='firstname' /> <filter type='and'> <condition attribute='firstname' operator='eq' value='Lionel' /> </filter> </link-entity> </entity> </fetch> "; //Equivalent linq query using(var ctx = new XrmServiceContext(service)) { var linqQuery = (from a in ctx.CreateQuery<Account>() join c in ctx.CreateQuery<Contact>() on a.PrimaryContactId.Id equals c.ContactId where c.FirstName == "Lionel" select new { Account = a, Contact = c }).ToList(); } var queryExpression = XrmFakedContext.TranslateFetchXmlToQueryExpression(context, fetchXml); Assert.True(queryExpression.LinkEntities.Count == 1); var linkedEntity = queryExpression.LinkEntities[0]; Assert.Equal(linkedEntity.LinkFromAttributeName, "primarycontactid"); Assert.Equal(linkedEntity.LinkToAttributeName, "contactid"); Assert.Equal(linkedEntity.JoinOperator, JoinOperator.Inner); var request = new RetrieveMultipleRequest { Query = new FetchExpression(fetchXml) }; var response = ((RetrieveMultipleResponse)service.Execute(request)); var entities = response.EntityCollection.Entities; Assert.True(entities.Count == 1); Assert.True(entities[0].Attributes.ContainsKey("aa.firstname")); Assert.IsType<AliasedValue>(entities[0]["aa.firstname"]); Assert.Equal("Lionel", (entities[0]["aa.firstname"] as AliasedValue).Value.ToString()); }
public void When_executing_fetchxml_with_count_attribute_only_that_number_of_results_is_returned() { //This will test a query expression is generated and executed var ctx = new XrmFakedContext(); //Arrange var contactList = new List<Entity>(); for(var i=0; i < 20; i++) { contactList.Add(new Contact() { Id = Guid.NewGuid() }); } ctx.Initialize(contactList); //Act var fetchXml = @"<fetch version='1.0' output-format='xml-platform' mapping='logical' distinct='false' count='7'> <entity name='contact'> <attribute name='fullname' /> <attribute name='telephone1' /> <attribute name='contactid' /> </entity> </fetch>"; var retrieveMultiple = new RetrieveMultipleRequest() { Query = new FetchExpression(fetchXml) }; var service = ctx.GetFakedOrganizationService(); var response = service.Execute(retrieveMultiple) as RetrieveMultipleResponse; Assert.Equal(7, response.EntityCollection.Entities.Count); }
public void Should_Not_Throw_Unable_To_Cast_AliasedValue_Exception() { var account1 = new Account() { Id = Guid.NewGuid(), Name = "1 Test", Address1_City = "1 City", Address1_StateOrProvince = "a2 State" }; var account2 = new Account() { Id = Guid.NewGuid(), Name = "2 Test", Address1_City = "2 City", Address1_StateOrProvince = "b2 State" }; var account3 = new Account() { Id = Guid.NewGuid(), Name = "3 Test", Address1_City = "2 City", Address1_StateOrProvince = "b1 State" }; var contact1 = new Contact() { Id = Guid.NewGuid(), FirstName = "1 Cont", LastName = "Cont 1", Address1_City = "1 City", ParentCustomerId = account1.ToEntityReference() }; var contact2 = new Contact() { Id = Guid.NewGuid(), FirstName = "2 Cont", LastName = "Cont 2", Address1_City = "1 City", ParentCustomerId = account2.ToEntityReference() }; var contact3 = new Contact() { Id = Guid.NewGuid(), FirstName = "3 Cont", LastName = "Cont 3", Address1_City = "1 City", ParentCustomerId = account3.ToEntityReference() }; var contact4 = new Contact() { Id = Guid.NewGuid(), FirstName = "4 Cont", LastName = "Cont 4", Address1_City = "2 City", ParentCustomerId = account1.ToEntityReference() }; var contact5 = new Contact() { Id = Guid.NewGuid(), FirstName = "5 Cont", LastName = "Cont 5", Address1_City = "2 City", ParentCustomerId = account2.ToEntityReference() }; var contact6 = new Contact() { Id = Guid.NewGuid(), FirstName = "6 Cont", LastName = "Cont 6", Address1_City = "2 City", ParentCustomerId = account3.ToEntityReference() }; var ctx = new XrmFakedContext(); ctx.ProxyTypesAssembly = Assembly.GetAssembly(typeof(Contact)); var service = ctx.GetFakedOrganizationService(); ctx.Initialize(new List <Entity>() { account1, account2, account3, contact1, contact2, contact3, contact4, contact5, contact6 }); QueryExpression query = new QueryExpression() { EntityName = "contact", ColumnSet = new ColumnSet(true), LinkEntities = { new LinkEntity(Contact.EntityLogicalName, Account.EntityLogicalName, "parentcustomerid", "accountid", JoinOperator.LeftOuter) { LinkCriteria = new FilterExpression() { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression("address1_city", ConditionOperator.Like, "2%") } } }, new LinkEntity(Contact.EntityLogicalName, Contact.EntityLogicalName, "parentcustomerid", "contactid", JoinOperator.LeftOuter) { LinkCriteria = new FilterExpression() { FilterOperator = LogicalOperator.And, Conditions = { new ConditionExpression("address1_city", ConditionOperator.Like, "2%") } } }, } }; EntityCollection entities = service.RetrieveMultiple(query); Assert.Equal(6, entities.Entities.Count); }
public void When_filtering_by_a_guid_attribute_right_result_is_returned() { var context = new XrmFakedContext(); var accountId = Guid.NewGuid(); var license1 = new Entity("pl_license"); license1.Id = Guid.NewGuid(); license1.Attributes["pl_no"] = 1; license1.Attributes["pl_accountid"] = new EntityReference("account", accountId); var license2 = new Entity("pl_license"); license2.Id = Guid.NewGuid(); license2.Attributes["pl_no"] = 2; license2.Attributes["pl_accountid"] = new EntityReference("account", accountId); context.Initialize(new List<Entity> { license1, license2 }); var fetchXml = "<fetch>" + " <entity name='pl_license'>" + " <attribute name='pl_no'/>" + " <filter type='and'>" + " <condition attribute='pl_accountid' operator='eq' value='{0}' />" + " </filter>" + " </entity>" + "</fetch>"; fetchXml = string.Format(fetchXml, accountId); var rows = context.GetFakedOrganizationService().RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(rows.Entities.Count, 2); }
public void When_filtering_by_a_guid_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.PrimaryContactId = new EntityReference(Contact.EntityLogicalName, contactId1); var account2 = new Account(); account2.Id = Guid.NewGuid(); account2.PrimaryContactId = new EntityReference(Contact.EntityLogicalName, contactId2); context.Initialize(new List<Entity> { account1, account2 }); var fetchXml = "<fetch>" + " <entity name='account'>" + " <attribute name='name'/>" + " <filter type='and'>" + " <condition attribute='primarycontactid' operator='eq' value='{0}' />" + " </filter>" + " </entity>" + "</fetch>"; fetchXml = string.Format(fetchXml, contactId1); var rows = context.GetFakedOrganizationService().RetrieveMultiple(new FetchExpression(fetchXml)); Assert.Equal(rows.Entities.Count, 1); }
public void IsBusinessDay_Week_Day_Holiday_User_Local() { //Arrange XrmFakedWorkflowContext workflowContext = new XrmFakedWorkflowContext(); EntityCollection userSettings = new EntityCollection(); Entity userSetting = new Entity("usersettings") { Id = Guid.NewGuid(), ["systemuserid"] = Guid.NewGuid(), ["timezonecode"] = 20 }; userSettings.Entities.Add(userSetting); EntityCollection calendarRules = new EntityCollection(); Entity calendarRule = new Entity { LogicalName = "calendarRule", Id = Guid.NewGuid(), Attributes = new AttributeCollection() }; calendarRule.Attributes.Add("name", "4th of July"); calendarRule.Attributes.Add("starttime", new DateTime(2014, 7, 4, 0, 0, 0)); calendarRule.Attributes.Add("duration", 1440); calendarRules.Entities.Add(calendarRule); Entity holidayCalendar = new Entity { Id = new Guid("e9717a91-ba0a-e411-b681-6c3be5a8ad70"), LogicalName = "calendar", Attributes = new AttributeCollection() }; holidayCalendar.Attributes.Add("name", "Main Holiday Schedule"); holidayCalendar.Attributes.Add("calendarrules", calendarRules); var inputs = new Dictionary <string, object> { { "DateToCheck", new DateTime(2014, 7, 4, 8, 48, 0, 0) }, { "HolidayClosureCalendar", new EntityReference { LogicalName = "calendar", Id = new Guid("e9717a91-ba0a-e411-b681-6c3be5a8ad70") } }, { "EvaluateAsUserLocal", true } }; XrmFakedContext xrmFakedContext = new XrmFakedContext(); xrmFakedContext.Initialize(new List <Entity> { userSetting, calendarRule, holidayCalendar }); xrmFakedContext.CallerId = new EntityReference("systemuser", userSetting.GetAttributeValue <Guid>("systemuserid")); var fakeLocalTimeFromUtcTimeRequestExecutor = new FakeLocalTimeFromUtcTimeRequestExecutor(new DateTime(2014, 7, 4, 2, 48, 0, 0)); xrmFakedContext.AddFakeMessageExecutor <LocalTimeFromUtcTimeRequest>(fakeLocalTimeFromUtcTimeRequestExecutor); const bool expected = false; //Act var result = xrmFakedContext.ExecuteCodeActivity <IsBusinessDay>(workflowContext, inputs); //Assert Assert.AreEqual(expected, result["ValidBusinessDay"]); }
public void When_sorting_by_an_attribute_which_wasnt_initialised_an_exception_is_not_thrown() { var ctx = new XrmFakedContext(); ctx.ProxyTypesAssembly = Assembly.GetAssembly(typeof(Contact)); var service = ctx.GetFakedOrganizationService(); ctx.Initialize(new List<Entity>() { new Contact() { Id = Guid.NewGuid(), FirstName = "Ronald", LastName = "Mcdonald" }, new Contact() { Id = Guid.NewGuid(), LastName = "Jordan" } }); using (var context = new XrmServiceContext(service)) { var contacts = (from c in context.ContactSet orderby c.FirstName select new Contact { Id = c.Id, FirstName = c.FirstName, LastName = c.LastName }).ToList(); Assert.Equal(2, contacts.Count); Assert.Null(contacts[0].FirstName); } }