private ExecuteMultipleResponseItemCollection GetFakeOrgServiceResponse(Guid id, DateTime modifiedOnDate, ICrmMetaDataProvider crmMetaDataProvider)
{
// This is a fake ExecuteMultipleResponse that will be returned to our sut at test time.
var responses = new ExecuteMultipleResponseItemCollection();
// fake response for insert.
ExecuteMultipleResponseItem createResponse = GetCreateResponseItem(0, id);
responses.Add(createResponse);
// fake response for second insert.
ExecuteMultipleResponseItem createResponseWithOutput = GetCreateResponseItem(1, null);
responses.Add(createResponseWithOutput);
// fake response for update.
ExecuteMultipleResponseItem updateResponseItem = GetUpdateResponseItem(2);
responses.Add(updateResponseItem);
ExecuteMultipleResponseItem updateResponseItemWithOutput = GetUpdateResponseItem(3);
responses.Add(updateResponseItemWithOutput);
// This is a fake RetrieveResponse that will be returned to our sut at test time.
var updatedContactEntity = new Entity("contact");
updatedContactEntity.Id = id;
updatedContactEntity["contactid"] = id;
updatedContactEntity["modifiedon"] = modifiedOnDate;
ExecuteMultipleResponseItem retrieveResponseItemForUpdateOutput = GetRetrieveResponseItem(4, updatedContactEntity);
responses.Add(retrieveResponseItemForUpdateOutput);
ExecuteMultipleResponseItem deleteResponseItem = GetDeleteResponseItem(5);
responses.Add(deleteResponseItem);
var entityDataGenerator = new EntityDataGenerator(crmMetaDataProvider);
var entities = entityDataGenerator.GenerateFakeEntities("contact", 10);
EntityCollection fakeEntityResults = new EntityCollection(entities);
ExecuteMultipleResponseItem retrieveMultipleResponseItem = GetRetrieveMultipleResponseItem(6, fakeEntityResults);
responses.Add(retrieveMultipleResponseItem);
return(responses);
}
private List <BulkResponseItem> ReadExecuteMultipleResponse(ExecuteMultipleResponse executeMultipleResponse, Dictionary <string, OrganizationRequest> requests)
{
List <string> requestIds = requests.Keys.ToList();
List <BulkResponseItem> responses = new List <BulkResponseItem>();
if (executeMultipleResponse != null && executeMultipleResponse.Responses != null && executeMultipleResponse.Responses.Count > 0)
{
ExecuteMultipleResponseItemCollection responseItems = executeMultipleResponse.Responses;
foreach (ExecuteMultipleResponseItem responseItem in responseItems)
{
string requestKey = requestIds[responseItem.RequestIndex];
OrganizationRequest orgRequest = requests[requestKey];
BulkResponseItem bulkResponseItem = new BulkResponseItem();
bulkResponseItem.BulkRequestId = requestKey;
bulkResponseItem.Action = GetActionName(orgRequest);
if (responseItem.Fault != null)
{
string message = GetFaultedMessage(responseItem);
bulkResponseItem.Error = message;
}
else
{
OrganizationResponse response = responseItem.Response;
Guid recordId = Guid.Empty;
if (response is CreateResponse)
{
bulkResponseItem.CreatedRecordId = ((CreateResponse)response).id;
}
else if (response is RetrieveMultipleResponse)
{
RetrieveMultipleResponse retrieveMultipleResponse = (RetrieveMultipleResponse)response;
bulkResponseItem.Results = (retrieveMultipleResponse != null) ? retrieveMultipleResponse.EntityCollection : null;
}
bulkResponseItem.Success = true;
}
responses.Add(bulkResponseItem);
}
}
return(responses);
}
public void ActivateAll_SetActiveStateForAllSlas_Called()
{
var allSlas = new List <Entity>
{
new Entity("sla", Guid.NewGuid()),
new Entity("sla", Guid.NewGuid()),
new Entity("sla", Guid.NewGuid()),
};
this.crmServiceAdapterMock
.Setup(x => x.RetrieveMultipleByAttribute("sla", "statecode", It.Is <object[]>(value => (int)value[0] == 0), null))
.Returns(() =>
{
var entityCollection = new EntityCollection
{
EntityName = "sla",
};
entityCollection.Entities.AddRange(allSlas);
return(entityCollection);
});
this.crmServiceAdapterMock
.Setup(x => x.UpdateStateAndStatusForEntityInBatch(
It.Is <EntityCollection>(collection => allSlas.All(sla => collection.Entities.Contains(sla))),
It.IsAny <int>(),
It.IsAny <int>()))
.Returns((EntityCollection records, int statecode, int statuscode) =>
{
var responseItemCollection = new ExecuteMultipleResponseItemCollection
{
new ExecuteMultipleResponseItem {
},
new ExecuteMultipleResponseItem {
},
};
var response = new ExecuteMultipleResponse();
response.Results.Add("Responses", responseItemCollection);
return(response);
})
.Verifiable();
this.slaActivatorService.ActivateAll();
this.crmServiceAdapterMock.Verify();
}
public void ExecuteMultiple_Errors_LogErrors()
{
this.crmServiceAdapterMock
.Setup(x => x.ExecuteMultiple(It.IsAny <List <OrganizationRequest> >(), It.IsAny <bool>(), It.IsAny <bool>()))
.Returns(() =>
{
var responseItemCollection = new ExecuteMultipleResponseItemCollection
{
new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault
{
Message = "Test fault response",
},
},
new ExecuteMultipleResponseItem {
},
};
var response = new ExecuteMultipleResponse();
response.Results.Add("Responses", responseItemCollection);
response.Results.Add("IsFaulted", true);
return(response);
});
List <TableConfig> tableConfigs = new List <TableConfig>();
ColumnConfig[] tableColumns = new ColumnConfig[]
{
GetAutonumberColumnConfig("test_autonumberone", 1000),
GetAutonumberColumnConfig("test_autonumbertwo", 2000),
};
tableConfigs.Add(GetTableConfig("test_table", tableColumns));
// Act
this.tableColumnProcessingService.ProcessTables(tableConfigs);
// Assert
this.loggerMock.VerifyLog(x => x.LogError("Error processing requests for table columns"));
this.loggerMock.VerifyLog(x => x.LogError("Test fault response"));
}
private Mock <IExecuteMultipleResponseAdapter> GetExecuteMultipleResponseAdapter(IEnumerable <Guid> recordIds)
{
var executeMultipleResponseAdapter = new Mock <IExecuteMultipleResponseAdapter>();
var responseCollection = new ExecuteMultipleResponseItemCollection();
responseCollection.AddRange(recordIds.Select(r => new ExecuteMultipleResponseItem()
{
Fault = null,
Response = new DeleteResponse()
{
ResponseName = "delete",
Results = new ParameterCollection {
{ "id", r }
}
}
}));
executeMultipleResponseAdapter
.Setup(e => e.Responses)
.Returns(responseCollection);
return(executeMultipleResponseAdapter);
}
public void Log_AutonumbersProcessed_AutonumberSeedRequestAdded()
{
// Arrage
this.crmServiceAdapterMock
.Setup(x => x.ExecuteMultiple(It.IsAny <List <OrganizationRequest> >(), It.IsAny <bool>(), It.IsAny <bool>()))
.Returns(() =>
{
var responseItemCollection = new ExecuteMultipleResponseItemCollection
{
new ExecuteMultipleResponseItem {
},
new ExecuteMultipleResponseItem {
},
};
var response = new ExecuteMultipleResponse();
response.Results.Add("Responses", responseItemCollection);
return(response);
});
List <TableConfig> tableConfigs = new List <TableConfig>();
ColumnConfig[] tableColumns = new ColumnConfig[]
{
GetAutonumberColumnConfig("test_autonumberone", 1000),
GetAutonumberColumnConfig("test_autonumbertwo", 2000),
};
tableConfigs.Add(GetTableConfig("test_table", tableColumns));
// Act
this.tableColumnProcessingService.ProcessTables(tableConfigs);
// Assert
this.loggerMock.VerifyLog(x => x.LogInformation("Adding auto-number seed request. Entity Name: test_table. Auto-number Attribute: test_autonumberone. Value: 1000"));
this.loggerMock.VerifyLog(x => x.LogInformation("Adding auto-number seed request. Entity Name: test_table. Auto-number Attribute: test_autonumbertwo. Value: 2000"));
this.crmServiceAdapterMock.Verify(svc => svc.ExecuteMultiple(It.IsAny <List <OrganizationRequest> >(), It.IsAny <bool>(), It.IsAny <bool>()));
}
public void ExecuteMultiple_Requests_IsCalled()
{
// Arrange
this.crmServiceAdapterMock
.Setup(x => x.ExecuteMultiple(It.IsAny <List <OrganizationRequest> >(), It.IsAny <bool>(), It.IsAny <bool>()))
.Returns(() =>
{
var responseItemCollection = new ExecuteMultipleResponseItemCollection
{
new ExecuteMultipleResponseItem {
},
new ExecuteMultipleResponseItem {
},
};
var response = new ExecuteMultipleResponse();
response.Results.Add("Responses", responseItemCollection);
return(response);
});
List <TableConfig> tableConfigs = new List <TableConfig>();
ColumnConfig[] tableColumns = new ColumnConfig[]
{
GetAutonumberColumnConfig("test_autonumberone", 1000),
GetAutonumberColumnConfig("test_autonumbertwo", 2000),
};
tableConfigs.Add(GetTableConfig("test_table", tableColumns));
// Act
this.tableColumnProcessingService.ProcessTables(tableConfigs);
// Assert
this.loggerMock.VerifyLog(x => x.LogInformation("Executing requests for table columns."));
this.crmServiceAdapterMock.Verify();
}
internal override OrganizationResponse Execute(OrganizationRequest orgRequest, EntityReference userRef)
{
var request = MakeRequest <ExecuteMultipleRequest>(orgRequest);
var toReturn = new ExecuteMultipleResponse();
var responses = new ExecuteMultipleResponseItemCollection();
for (var i = 0; i < request.Requests.Count; i++)
{
var resp = new ExecuteMultipleResponseItem {
RequestIndex = i
};
var r = request.Requests[i];
try {
var orgResp = core.Execute(r, userRef);
if (request.Settings.ReturnResponses)
{
resp.Response = orgResp;
responses.Add(resp);
}
} catch (Exception e) {
resp.Fault = new OrganizationServiceFault {
Message = e.Message,
Timestamp = DateTime.Now
};
responses.Add(resp);
if (!request.Settings.ContinueOnError)
{
toReturn.Results["Responses"] = responses;
toReturn.Results["IsFaulted"] = true;
return(toReturn);
}
}
}
toReturn.Results["Responses"] = responses;
toReturn.Results["IsFaulted"] = responses.Any(x => x.Fault != null);
return(toReturn);
}
private DetectionResults GetUsageFetchAggregate(EntityMetadata emd, Settings settings, BackgroundWorker worker = null)
{
var result = new DetectionResults();
List <AttributeMetadata> attributes = new List <AttributeMetadata>();
var emRequest = new ExecuteMultipleRequest
{
Settings = new ExecuteMultipleSettings
{
ContinueOnError = true,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
var fetchXmlAttrPart = $"<attribute name=\"{emd.PrimaryIdAttribute}\" aggregate=\"count\" alias=\"count\"/>";
emRequest.Requests.Add(new RetrieveMultipleRequest
{
Query = new FetchExpression(string.Format(FetchXml, emd.LogicalName, fetchXmlAttrPart, "", settings.RecordsReturnedPerTrip))
});
var allResult = new ExecuteMultipleResponseItemCollection();
foreach (var attribute in MetadataHelper.FilterAttributes(emd.Attributes).OrderBy(a => a.LogicalName))
{
if (settings.FilterAttributes &&
settings.Filters.ContainsKey(emd.LogicalName))
{
EntityFilterSetting fs = settings.Filters[emd.LogicalName];
if (fs.Attributes.Count > 0 &&
!fs.Attributes.Contains(attribute.LogicalName))
{
continue;
}
if (fs.ShowOnlyCustom && !attribute.IsCustomAttribute.Value)
{
continue;
}
if (fs.ShowOnlyStandard && attribute.IsCustomAttribute.Value)
{
continue;
}
}
attributes.Add(attribute);
var fetchXmlConditionNotNullPart = $"<condition attribute=\"{attribute.LogicalName}\" operator=\"not-null\"/>";
emRequest.Requests.Add(new RetrieveMultipleRequest
{
Query =
new FetchExpression(string.Format(FetchXml, emd.LogicalName, fetchXmlAttrPart,
fetchXmlConditionNotNullPart, settings.RecordsReturnedPerTrip))
});
if (emRequest.Requests.Count == settings.AttributesReturnedPerTrip)
{
var tempResults = (ExecuteMultipleResponse)service.Execute(emRequest);
allResult.AddRange(tempResults.Responses);
emRequest = new ExecuteMultipleRequest
{
Settings = new ExecuteMultipleSettings
{
ContinueOnError = true,
ReturnResponses = true
},
Requests = new OrganizationRequestCollection()
};
}
}
var results = (ExecuteMultipleResponse)service.Execute(emRequest);
allResult.AddRange(results.Responses);
var allResponse = (RetrieveMultipleResponse)allResult[0].Response;
if (allResult[0].Fault != null)
{
result.IsAggregateQueryRecordLimitReached = allResult[0].Fault.ErrorCode == -2147164125;
result.Fault = allResult[0].Fault;
return(result);
}
var allCount = allResponse != null
? allResponse.EntityCollection.Entities.First().GetAttributeValue <AliasedValue>("count")
: null;
var allCountValue = allCount != null ? (int)allCount.Value : 0;
result.Total = allCountValue;
result.Entity = emd.LogicalName;
foreach (var attribute in attributes)
{
var index = attributes.IndexOf(attribute);
var resultNotNull = allResult[index + 1];
if (resultNotNull.Fault != null)
{
result.Fault = resultNotNull.Fault;
return(result);
}
var notNullValueAliased =
((RetrieveMultipleResponse)resultNotNull.Response).EntityCollection.Entities.First()
.GetAttributeValue <AliasedValue>("count");
var notNullValue = (int?)notNullValueAliased?.Value ?? 0;
result.Results.Add(new DetectionResult
{
Attribute = attribute,
NotNull = notNullValue,
Percentage = allCountValue != 0 ? (double)notNullValue * 100 / allCountValue : 0
});
}
return(result);
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var executeMultipleRequest = (ExecuteMultipleRequest)request;
if (executeMultipleRequest.Settings == null)
{
throw new FaultException <OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Settings' in execute multiple request");
}
if (executeMultipleRequest.Requests == null)
{
throw new FaultException <OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Requests' in execute multiple request");
}
var service = ctx.GetFakedOrganizationService();
var response = new ExecuteMultipleResponse();
response.Results["Responses"] = new ExecuteMultipleResponseItemCollection();
for (var i = 0; i < executeMultipleRequest.Requests.Count; i++)
{
var executeRequest = executeMultipleRequest.Requests[i];
try
{
service.Execute(executeRequest);
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Responses.Add(new ExecuteMultipleResponseItem
{
RequestIndex = i
});
}
}
catch (Exception ex)
{
if (!response.IsFaulted)
{
response.Results["IsFaulted"] = true;
}
response.Responses.Add(new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault {
Message = ex.Message
},
RequestIndex = i
});
if (!executeMultipleRequest.Settings.ContinueOnError)
{
break;
}
}
}
// Implement response behaviour as in https://msdn.microsoft.com/en-us/library/jj863631.aspx
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Results["response.Responses"] = response.Responses;
}
else if (response.Responses.Any(resp => resp.Fault != null))
{
var failures = new ExecuteMultipleResponseItemCollection();
failures.AddRange(response.Responses.Where(resp => resp.Fault != null));
response.Results["response.Responses"] = failures;
}
return(response);
}
protected virtual OrganizationResponse ExecuteOrganisationRequest()
{
var dbCommand = DbCommand;
var orgService = dbCommand.CrmDbConnection.OrganizationService;
// Execute the request and obtain the result.
OrganizationResponse response = null;
// If this operation is part of a batch of operations, then the request,
// is executed allready at the batch level.
if (this.BatchOperation == null)
{
// otherwise, execute the individual request for this operation.
response = orgService.Execute(Request);
}
else
{
// grab the response for this operation from the batch responses.
var multiPart = this as IMultipartOperation;
if (multiPart != null && multiPart.HasMultipleRequests)
{
// rebuild an ExecuteMultipleResponse to contain just the responses for this multipart operation.
var responses = new ExecuteMultipleResponseItemCollection();
ExecuteMultipleResponse multipleResponse = new ExecuteMultipleResponse
{
Results = new ParameterCollection
{
{ "Responses", responses },
{ "IsFaulted", this.BatchOperation.BatchResponse.IsFaulted}
}
};
for (int i = 0; i < multiPart.RequestCount; i++)
{
int reqIndex = this.BatchRequestIndex + i;
var resp = this.BatchOperation.BatchResponse.Responses[reqIndex];
responses.Add(resp);
}
return multipleResponse;
}
return this.BatchOperation.BatchResponse.Responses[this.BatchRequestIndex].Response;
}
// Allow poeople to get access to the response directly via an output paramater.
AssignResponseParameter(dbCommand, response);
return response;
}
public void BatchTest()
{
Mock <IOrganizationService> orgSvc = null;
Mock <MoqHttpMessagehander> fakHttpMethodHander = null;
ServiceClient cli = null;
testSupport.SetupMockAndSupport(out orgSvc, out fakHttpMethodHander, out cli);
CreateResponse createResponse = new CreateResponse();
createResponse.Results = new ParameterCollection();
createResponse.Results.Add("annotationid", testSupport._DefaultId);
ExecuteMultipleResponseItem responseItem = new ExecuteMultipleResponseItem();
responseItem.Response = createResponse;
responseItem.RequestIndex = 0;
ExecuteMultipleResponseItemCollection responseItems = new ExecuteMultipleResponseItemCollection();
responseItems.Add(responseItem);
ExecuteMultipleResponse executeMultipleResponse = new ExecuteMultipleResponse();
executeMultipleResponse.Results = new ParameterCollection();
executeMultipleResponse.Results.Add("Responses", responseItems);
orgSvc.Setup(req1 => req1.Execute(It.IsAny <ExecuteMultipleRequest>())).Returns(executeMultipleResponse);
// Setup a batch
string BatchRequestName = "TestBatch";
Guid batchid = cli.CreateBatchOperationRequest(BatchRequestName);
// use create operation to setup request
Dictionary <string, DataverseDataTypeWrapper> newFields = new Dictionary <string, DataverseDataTypeWrapper>();
newFields.Add("name", new DataverseDataTypeWrapper("CrudTestAccount", DataverseFieldType.String));
newFields.Add("accountnumber", new DataverseDataTypeWrapper("12345", DataverseFieldType.String));
newFields.Add("telephone1", new DataverseDataTypeWrapper("555-555-5555", DataverseFieldType.String));
newFields.Add("donotpostalmail", new DataverseDataTypeWrapper(true, DataverseFieldType.Boolean));
// issue request as a batch:
Guid result = cli.CreateAnnotation("account", testSupport._DefaultId, newFields, batchid);
Assert.Equal <Guid>(Guid.Empty, result);
OrganizationRequest req = cli.GetBatchRequestAtPosition(batchid, 0);
// Executes the batch request.
cli.ExecuteBatch(batchid);
// Request Batch by name
Guid OperationId = cli.GetBatchOperationIdRequestByName(BatchRequestName);
// Request batch back
RequestBatch reqBatch = cli.GetBatchById(batchid);
Assert.NotNull(reqBatch);
Assert.Equal(BatchRequestName, reqBatch.BatchName);
Assert.True(reqBatch.BatchItems.Count == 1);
// Release batch request
cli.ReleaseBatchInfoById(batchid);
}
public void Should_Be_Able_To_Execute_A_Batch_Of_Statements_And_Get_Multiple_Results_Stress()
{
// Arrange
using (var sandbox = ConnectionTestsSandbox.Create())
{
var dbConnection = sandbox.Container.Resolve <CrmDbConnection>();
Guid id = Guid.Parse("9bf20a16-6034-48e2-80b4-8349bb80c3e2");
string insertSql = string.Format("INSERT INTO contact (contactid, firstname, lastname) VALUES ('{0}','billy','bob');", id);
string insertSqlWithOutputClause = "INSERT INTO contact (firstname, lastname) OUTPUT INSERTED.contactid VALUES ('bat','man');";
string updateSql = string.Format("UPDATE contact SET firstname = 'john', lastname = 'doe' WHERE contactid = '{0}';", id);
string updateSqlWithOutputClause = string.Format("UPDATE contact SET firstname = 'johny', lastname = 'doe' OUTPUT INSERTED.modifiedon WHERE contactid = '{0}';", id);
string deleteSql = string.Format("DELETE FROM contact WHERE contactid = '{0}';", id);
string selectSql = "SELECT TOP 10 firstname, lastname FROM contact ORDER BY lastname ASC;";
var sql = insertSql + insertSqlWithOutputClause + updateSql + updateSqlWithOutputClause + deleteSql + selectSql;
var provider = new SqlGenerationCrmOperationProvider(new DynamicsAttributeTypeProvider());
// prepare a fake org service response
DateTime expectedOutputModifiedOnDate = DateTime.UtcNow;
ExecuteMultipleResponseItemCollection fakeOrgServiceResponses = GetFakeOrgServiceResponse(id, expectedOutputModifiedOnDate, sandbox.FakeMetadataProvider);
var executeMultipleResponse = new ExecuteMultipleResponse
{
Results = new ParameterCollection
{
{ "Responses", fakeOrgServiceResponses },
{ "IsFaulted", false }
}
};
// Setup fake org service to return fake response.
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <ExecuteMultipleRequest>())))
.WhenCalled(x =>
{
var request = ((ExecuteMultipleRequest)x.Arguments[0]);
}).Return(executeMultipleResponse);
/// Execute a batch command multiple times..
dbConnection.Open();
for (int i = 0; i < 30; i++)
{
var batchCommand = new CrmDbCommand(dbConnection);
batchCommand.CommandText = sql;
batchCommand.CommandType = System.Data.CommandType.Text;
var orgCommand = provider.GetOperation(batchCommand, System.Data.CommandBehavior.Default);
// Act
var sut = CrmOperationExecutor.Instance;
var commandResult = sut.ExecuteOperation(orgCommand);
// SHould have more results.
Assert.That(commandResult.HasMoreResults);
// First result for insert.
Assert.That(commandResult.ResultSet != null);
// Should have one row containing inserted record id.
var reader = commandResult.GetReader();
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 1);
while (reader.Read())
{
// Assert.That(reader.GetDateTime(0), NUnit.Framework.Is.EqualTo(createdOnDate));
Assert.That(reader.GetGuid(0), NUnit.Framework.Is.EqualTo(id));
}
// Move to second result for insert plus output.
reader.NextResult();
Assert.That(commandResult.ResultSet != null);
// Should have one row containing inserted record id.
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 1);
while (reader.Read())
{
// Assert.That(reader.GetDateTime(0), NUnit.Framework.Is.EqualTo(createdOnDate));
Assert.That(reader.GetGuid(0), NUnit.Framework.Is.Not.Null);
}
// Move to third result for update.
reader.NextResult();
Assert.That(commandResult.ResultSet != null);
// Move to fourth result for update plus output.
reader.NextResult();
Assert.That(commandResult.ResultSet != null);
// Should have one row containing output clause values.
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 1);
while (reader.Read())
{
Assert.That(reader.GetDateTime(0), NUnit.Framework.Is.EqualTo(expectedOutputModifiedOnDate));
//Assert.That(reader.GetGuid(0), NUnit.Framework.Is.EqualTo(id));
}
// Move to fifth result for delete.
reader.NextResult();
Assert.That(commandResult.ResultSet != null);
// no result set..
// Move to sixth result for retrieve multiple.
reader.NextResult();
Assert.That(commandResult.ResultSet != null);
Assert.That(commandResult.ResultSet.ResultCount() == 10);
Assert.That(commandResult.ResultSet.HasColumnMetadata());
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 2);
int recordCount = 0;
while (reader.Read())
{
recordCount++;
Assert.That(reader.GetString(0), NUnit.Framework.Is.Not.Null);
// Assert.That(reader.GetGuid(0), NUnit.Framework.Is.EqualTo(id));
}
Assert.That(recordCount == 10);
}
}
}
public void Should_Be_Able_To_Execute_An_Update_With_Output_Clause_And_Get_Back_Values()
{
// Arrange
using (var sandbox = ConnectionTestsSandbox.Create())
{
var dbConnection = sandbox.Container.Resolve <CrmDbConnection>();
var command = new CrmDbCommand(dbConnection);
command.CommandText = "UPDATE contact SET firstname = 'JO', lastname = 'SCHMO' OUTPUT INSERTED.modifiedon, INSERTED.contactid WHERE contactid = '9bf20a16-6034-48e2-80b4-8349bb80c3e2'";
command.CommandType = System.Data.CommandType.Text;
var provider = new SqlGenerationCrmOperationProvider(new DynamicsAttributeTypeProvider());
var orgCommand = provider.GetOperation(command, System.Data.CommandBehavior.Default);
// This is a fake CreateResponse that will be returned to our sut at test time.
Guid expectedId = Guid.Parse("9bf20a16-6034-48e2-80b4-8349bb80c3e2");
var createResponse = new UpdateResponse
{
Results = new ParameterCollection()
};
// This is a fake RetrieveResponse that will be returned to our sut at test time.
var resultEntity = new Entity("contact");
resultEntity.Id = expectedId;
resultEntity["contactid"] = expectedId;
var modifiedOnDate = DateTime.UtcNow;
resultEntity["modifiedon"] = modifiedOnDate;
var retrieveResponse = new RetrieveResponse
{
Results = new ParameterCollection
{
{ "Entity", resultEntity }
}
};
// This is a fake ExecuteMultipleResponse that will be returned to our sut at test time.
var responses = new ExecuteMultipleResponseItemCollection();
var updateResponseItem = new ExecuteMultipleResponseItem();
updateResponseItem.RequestIndex = 0;
updateResponseItem.Response = createResponse;
responses.Add(updateResponseItem);
var retrieveResponseItem = new ExecuteMultipleResponseItem();
retrieveResponseItem.RequestIndex = 1;
retrieveResponseItem.Response = retrieveResponse;
responses.Add(retrieveResponseItem);
var executeMultipleResponse = new ExecuteMultipleResponse
{
Results = new ParameterCollection
{
{ "Responses", responses },
{ "IsFaulted", false }
}
};
// Setup fake org service to return fake response.
sandbox.FakeOrgService.Stub(f => f.Execute(Arg <OrganizationRequest> .Matches(new OrganizationRequestMessageConstraint <ExecuteMultipleRequest>())))
.WhenCalled(x =>
{
var request = ((ExecuteMultipleRequest)x.Arguments[0]);
}).Return(executeMultipleResponse);
// Act
var sut = CrmOperationExecutor.Instance;
dbConnection.Open();
var commandResult = sut.ExecuteOperation(orgCommand);
var results = commandResult.ResultSet;
//var results = sut.ExecuteCommand(orgCommand, System.Data.CommandBehavior.Default);
// Assert
// Should have 1 result, with the 2 output fields - createdon, and contactid
Assert.That(results.ResultCount() == 1);
Assert.That(results.HasColumnMetadata());
var reader = commandResult.GetReader();
Assert.That(reader.HasRows);
Assert.That(reader.FieldCount == 2);
while (reader.Read())
{
Assert.That(reader.GetDateTime(0), NUnit.Framework.Is.EqualTo(modifiedOnDate));
Assert.That(reader.GetGuid(1), NUnit.Framework.Is.EqualTo(expectedId));
}
}
}
public OrganizationResponse Execute(OrganizationRequest request, XrmFakedContext ctx)
{
var executeMultipleRequest = (ExecuteMultipleRequest)request;
if (executeMultipleRequest.Settings == null)
{
throw new FaultException<OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Settings' in execute multiple request");
}
if (executeMultipleRequest.Requests == null)
{
throw new FaultException<OrganizationServiceFault>(new OrganizationServiceFault(), "You need to pass a value for 'Requests' in execute multiple request");
}
var service = ctx.GetFakedOrganizationService();
var response = new ExecuteMultipleResponse();
response.Results["Responses"] = new ExecuteMultipleResponseItemCollection();
for (var i = 0; i < executeMultipleRequest.Requests.Count; i++)
{
var executeRequest = executeMultipleRequest.Requests[i];
try
{
service.Execute(executeRequest);
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Responses.Add(new ExecuteMultipleResponseItem
{
RequestIndex = i
});
}
}
catch (Exception ex)
{
if (!response.IsFaulted)
{
response.Results["IsFaulted"] = true;
}
response.Responses.Add(new ExecuteMultipleResponseItem
{
Fault = new OrganizationServiceFault { Message = ex.Message },
RequestIndex = i
});
if (!executeMultipleRequest.Settings.ContinueOnError)
{
break;
}
}
}
// Implement response behaviour as in https://msdn.microsoft.com/en-us/library/jj863631.aspx
if (executeMultipleRequest.Settings.ReturnResponses)
{
response.Results["response.Responses"] = response.Responses;
}
else if (response.Responses.Any(resp => resp.Fault != null))
{
var failures = new ExecuteMultipleResponseItemCollection();
failures.AddRange(response.Responses.Where(resp => resp.Fault != null));
response.Results["response.Responses"] = failures;
}
return response;
}
