//[ExpectedException(
// ExpectedException = typeof(RestfulServiceException),
// ExpectedMessage = @"{""status"":""terminal_error"",""message"":""One or more errors occurred.""}"
//)]
public async Task Send_DocuSign_Envelope_FollowUp_Configuration_NoAuth()
{
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = await HealthMonitor_FixtureData.Send_DocuSign_Envelope_v1_Example_Fr8DataDTO(this);
var responseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO);
var storage = Crate.GetStorage(responseActionDTO);
SendDocuSignEnvelope_SelectFirstTemplate(storage);
using (var crateStorage = Crate.GetUpdatableStorage(dataDTO.ActivityDTO))
{
crateStorage.Replace(storage);
}
dataDTO.ActivityDTO.AuthToken = null;
var response = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO);
Assert.NotNull(response);
Assert.NotNull(response.CrateStorage);
Assert.NotNull(response.CrateStorage.Crates);
Assert.True(response.CrateStorage.Crates.Any(x => x.ManifestType == "Standard Authentication"));
}
public async Task SendEmailViaSendGrid_Run_Returns_Payload()
{
//Arrange
var runUrl = GetTerminalRunUrl();
var dataDTO = HealthMonitor_FixtureData.SendEmailViaSendGrid_v1_InitialConfiguration_Fr8DataDTO();
using (var updatableStorage = Crate.GetUpdatableStorage(dataDTO.ActivityDTO))
{
updatableStorage.Add(CreateCrates());
}
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
AddPayloadCrate(
dataDTO,
new StandardPayloadDataCM()
{
}
);
//Act
var responsePayloadDTO =
await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
//Assert
var crateStorage = Crate.FromDto(responsePayloadDTO.CrateStorage);
var StandardPayloadDataCM = crateStorage.CrateContentsOfType <StandardPayloadDataCM>().SingleOrDefault();
Assert.IsNotNull(StandardPayloadDataCM);
}
private async Task <ActivityDTO> PerformInitialConfiguration()
{
//get the terminal configure URL
string terminalConfigureUrl = GetTerminalConfigureUrl();
//prepare the create account action DTO
var requestActionDTO = HealthMonitor_FixtureData.Post_To_Chatter_v1_InitialConfiguration_Fr8DataDTO();
//perform post request to terminal and return the result
var resultActionDto = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(terminalConfigureUrl, requestActionDTO);
using (var crateStorage = Crate.GetUpdatableStorage(resultActionDto))
{
crateStorage.UpdateControls <Post_To_Chatter_v1.ActivityUi>(x =>
{
x.UseUserOrGroupOption.Selected = true;
var selectedUser = x.UserOrGroupSelector.ListItems.First(y => y.Key == "Fr8 Admin");
x.UserOrGroupSelector.selectedKey = selectedUser.Key;
x.UserOrGroupSelector.Value = selectedUser.Value;
x.FeedTextSource.ValueSource = "specific";
x.FeedTextSource.TextValue = "IntegrationTestFeed";
});
}
return(resultActionDto);
}
private async Task <ActivityDTO> CompleteInitialConfiguration()
{
var configureUrl = GetTerminalConfigureUrl();
var requestDataDTO = HealthMonitor_FixtureData.Monitor_Jira_Events_v1_InitialConfiguration_Fr8DataDTO();
return(await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestDataDTO));
}
public async Task SendEmailViaSendGrid_Initial_Configuration_Check_Crate_Structure()
{
//Arrange
var configureUrl = GetTerminalConfigureUrl();
var requestActionDTO = HealthMonitor_FixtureData.SendEmailViaSendGrid_v1_InitialConfiguration_Fr8DataDTO();
//Act
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
requestActionDTO
);
//Assert
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
var crateStorage = Crate.FromDto(responseActionDTO.CrateStorage);
activityDTOInit = responseActionDTO;
Assert.IsNotNull(crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().SingleOrDefault());
// There is no FieldDescriptionsCM in the create storage;
// TODO: UPDATE TEST
// Assert.AreEqual(1, crateStorage.CrateContentsOfType<FieldDescriptionsCM>().Count());
var standardConfigurationControlCM = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>();
Assert.AreEqual(1, standardConfigurationControlCM.Where(w => w.FindByName("EmailAddress") != null).Count());
Assert.AreEqual(1, standardConfigurationControlCM.Where(w => w.FindByName("EmailSubject") != null).Count());
Assert.AreEqual(1, standardConfigurationControlCM.Where(w => w.FindByName("EmailBody") != null).Count());
}
public async Task Write_To_Log_FollowUp_Configuration_Check_Crate_Structure()
{
//Arrange
var configureUrl = GetTerminalConfigureUrl();
var requestActionDTO = HealthMonitor_FixtureData.Write_To_Log_v1_InitialConfiguration_Fr8DataDTO();
//Act
//Call first time for the initial configuration
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
requestActionDTO
);
//Call second time for the follow up configuration
responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
requestActionDTO
);
//Assert
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
var crateStorage = Crate.FromDto(responseActionDTO.CrateStorage);
AssertCrateTypes(crateStorage);
AssertControls(crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single());
}
public async Task Get_Jira_Issue_v1_Run_CheckPayloadDTO()
{
var activityDTO = await ConfigureFollowUp();
activityDTO.AuthToken = HealthMonitor_FixtureData.Jira_AuthToken();
var runUrl = GetTerminalRunUrl();
var data = new Fr8DataDTO()
{
ActivityDTO = activityDTO
};
AddPayloadCrate(data, new OperationalStateCM());
var payload = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, data);
Assert.IsNotNull(payload);
Assert.IsNotNull(payload.CrateStorage);
var crateStorage = Crate.FromDto(payload.CrateStorage);
Assert.AreEqual(2, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <OperationalStateCM>().Count());
Assert.AreEqual(1, crateStorage.CratesOfType <StandardPayloadDataCM>().Count());
var payloadData = crateStorage.CrateContentsOfType <StandardPayloadDataCM>().First();
Assert.IsNotNull(payloadData.PayloadObjects);
Assert.AreEqual(1, payloadData.PayloadObjects.Count);
Assert.AreEqual("FR-1245", payloadData.PayloadObjects[0].GetValue("Key"));
}
public async Task Load_Excel_File_v1_FollowUp_Configuration_WithFileSelected_OneRow_CheckCrateStructure()
{
// Act
var responseFollowUpActionDTO = await ConfigureFollowUp(true, HealthMonitor_FixtureData.GetFilePath_OneRowWithWithHeader());
// Assert
Assert.NotNull(responseFollowUpActionDTO, "Response from followup configuration request is null");
Assert.NotNull(responseFollowUpActionDTO.CrateStorage, "Response from followup configuration request doesn't contain crate storage");
Assert.NotNull(responseFollowUpActionDTO.CrateStorage.Crates, "Response from followup configuration request doesn't contain crates in storage");
var crateStorage = _crateManager.GetStorage(responseFollowUpActionDTO);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count(), "Activity storage doesn't contain configuration controls");
Assert.AreEqual(1, crateStorage.CratesOfType <CrateDescriptionCM>().Count(), "Activity storage doesn't contain description of runtime available crates");
/* Assert.AreEqual(3, crateStorage.CratesOfType<FieldDescriptionsCM>().Count(), "Although one-row table is supplied, there seems to be no FieldDescriptionsCM crate with fields from the first row");
* Assert.AreEqual(2,
* crateStorage.CratesOfType<FieldDescriptionsCM>().Count(x => x.Availability == AvailabilityType.Always),
* "Activity storage doesn't contain crate with column headers that is avaialbe both at design time and runtime");
*/
// Load file with multiple rows: crate with extracted fields must disappear
responseFollowUpActionDTO = await ConfigureFollowUp(true, null, responseFollowUpActionDTO);
crateStorage = _crateManager.GetStorage(responseFollowUpActionDTO);
// Assert.AreEqual(2, crateStorage.CratesOfType<FieldDescriptionsCM>().Count(), "Although a multi-row table has been uploaded, the crate with extracted fields did not seem to have disappeared");
}
private async Task <ActivityDTO> ConfigureFollowUp(bool setFileName = false, string fileUri = null, ActivityDTO existingActivity = null)
{
if (string.IsNullOrEmpty(fileUri))
{
fileUri = HealthMonitor_FixtureData.GetFilePath();
}
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = HealthMonitor_FixtureData.Load_Excel_File_v1_InitialConfiguration_Fr8DataDTO(Guid.NewGuid());
if (existingActivity == null)
{
existingActivity = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO);
}
if (setFileName)
{
using (var storage = _crateManager.GetUpdatableStorage(existingActivity))
{
var activityUi = new Load_Excel_File_v1.ActivityUi();
var controlsCrate = _crateManager.GetStorage(existingActivity).FirstCrate <StandardConfigurationControlsCM>();
activityUi.SyncWith(controlsCrate.Content);
activityUi.FilePicker.Value = fileUri;
storage.ReplaceByLabel(Fr8.Infrastructure.Data.Crates.Crate.FromContent(controlsCrate.Label, new StandardConfigurationControlsCM(activityUi.Controls.ToArray())));
}
}
dataDTO.ActivityDTO = existingActivity;
return(await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO));
}
private async Task <ActivityDTO> GetActivityDTO_WithRecipientValue()
{
var configureUrl = GetTerminalConfigureUrl();
var requestActionDTO = await HealthMonitor_FixtureData.Monitor_DocuSign_v1_InitialConfiguration_Fr8DataDTO(this);
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
requestActionDTO
);
responseActionDTO.AuthToken = requestActionDTO.ActivityDTO.AuthToken;
using (var crateStorage = Crate.GetUpdatableStorage(responseActionDTO))
{
var controls = crateStorage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.Single();
//Part of FR-2474: mark first checkbox as selected so activity will pass validation
var checkBox = controls.Controls.OfType <CheckBox>().First();
checkBox.Selected = true;
var radioGroup = (RadioButtonGroup)controls.Controls[4];
radioGroup.Radios[0].Selected = true;
radioGroup.Radios[1].Selected = false;
var recipientTextBox = (TextBox)radioGroup.Radios[0].Controls[0];
recipientTextBox.Value = "*****@*****.**";
}
return(responseActionDTO);
}
public async Task Write_To_Sql_Server_Run()
{
var runUrl = GetTerminalRunUrl();
var fr8DataDTO = HealthMonitor_FixtureData.Write_To_Sql_Server_v1_InitialConfiguration_Fr8DataDTO();
using (var crateStorage = Crate.GetUpdatableStorage(fr8DataDTO.ActivityDTO))
{
crateStorage.Add(CreateConnectionStringCrate());
}
AddOperationalStateCrate(fr8DataDTO, new OperationalStateCM());
AddPayloadCrate(fr8DataDTO,
new StandardPayloadDataCM(
new KeyValueDTO("Field1", "[Customer].[Physician]"),
new KeyValueDTO("Field2", "[Customer].[CurrentMedicalCondition]")
),
"MappedFields"
);
AddPayloadCrate(fr8DataDTO,
new StandardPayloadDataCM(
new KeyValueDTO("Field1", "test physician"),
new KeyValueDTO("Field2", "teststring")
),
"TableData"
);
var responsePayloadDTO = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, fr8DataDTO);
Assert.NotNull(responsePayloadDTO);
Assert.NotNull(responsePayloadDTO.CrateStorage);
Assert.NotNull(responsePayloadDTO.CrateStorage.Crates);
}
public async Task Run_WhenPayloadHasEventAndItPassFilters_ReturnsSuccess()
{
var activity = New <Monitor_Channel_v2>();
var activityContext = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage()
},
AuthorizationToken = AuthorizationToken
};
var executionContext = new ContainerExecutionContext
{
PayloadStorage = HealthMonitor_FixtureData.GetDirectMessageEventPayload()
};
await activity.Configure(activityContext);
activityContext.ActivityPayload.CrateStorage.UpdateControls <Monitor_Channel_v2.ActivityUi>(x =>
{
x.MonitorDirectMessagesOption.Selected = true;
x.MonitorChannelsOption.Selected = false;
});
await activity.Run(activityContext, executionContext);
var operationalState = executionContext.PayloadStorage.FirstCrateContentOrDefault <OperationalStateCM>();
Assert.AreEqual(ActivityResponse.Success.ToString(), operationalState.CurrentActivityResponse.Type, "RequestTerminate response was not produced when event didn't match monitoring options");
Assert.IsNotNull(executionContext.PayloadStorage.FirstCrateOrDefault <StandardPayloadDataCM>(), "Activity didn't produce crate with payload data");
}
public async Task Monitor_DocuSign_Activate_Returns_ActivityDTO()
{
//Arrange
var configureUrl = GetTerminalActivateUrl();
HealthMonitor_FixtureData fixture = new HealthMonitor_FixtureData();
var requestDataDTO = await HealthMonitor_FixtureData.Mail_Merge_Into_DocuSign_v1_InitialConfiguration_Fr8DataDTO(this);
using (var crateStorage = Crate.GetUpdatableStorage(requestDataDTO.ActivityDTO))
{
crateStorage.Add("Configuration_Controls", new StandardConfigurationControlsCM());
}
//Act
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
requestDataDTO
);
//Assert
Assert.IsNotNull(responseActionDTO);
Assert.IsNotNull(Crate.FromDto(responseActionDTO.CrateStorage));
}
public async Task Post_To_Yammer_Run_Return_Payload()
{
//Arrange
var runUrl = GetTerminalRunUrl();
var activityDTO = await ConfigurationRequest();
var dataDTO = new Fr8DataDTO {
ActivityDTO = activityDTO
};
AddPayloadCrate(
dataDTO,
new StandardPayloadDataCM(
new KeyValueDTO("message", "Hello")
),
"Payload crate"
);
activityDTO.AuthToken = HealthMonitor_FixtureData.Yammer_AuthToken();
//Act
var responsePayloadDTO = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
//Assert
var crateStorage = Crate.FromDto(responsePayloadDTO.CrateStorage);
var StandardPayloadDataCM = crateStorage.CrateContentsOfType <StandardPayloadDataCM>().SingleOrDefault();
Assert.IsNotNull(StandardPayloadDataCM);
}
public async Task Run_Returns_ActivityDTO()
{
//Arrange
var runUrl = GetTerminalRunUrl();
Fr8DataDTO dataDto = HealthMonitor_FixtureData.GetFileListTestFr8DataDTO();
// Add initial configuretion controls
using (var crateStorage = Crate.GetUpdatableStorage(dataDto.ActivityDTO))
{
crateStorage.Add("Configuration_Controls", new StandardConfigurationControlsCM());
}
// Add operational state crate
AddOperationalStateCrate(dataDto, new OperationalStateCM());
//Act
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, PayloadDTO>(
runUrl,
dataDto
);
//Assert
Assert.IsNotNull(responseActionDTO);
var crateFromDTO = Crate.FromDto(responseActionDTO.CrateStorage);
Assert.IsNotNull(crateFromDTO);
Assert.Greater(crateFromDTO.CratesOfType <StandardFileListCM>().Count(), 0);
}
public async Task Prepare_DocuSign_Events_For_Storage_Envelope_Run()
{
var runUrl = GetTerminalRunUrl();
var dataDTO = await HealthMonitor_FixtureData.Prepare_DocuSign_Events_For_Storage_v1_InitialConfiguration_Fr8DataDTO(this);
var date = DateTime.Now.ToString(DateTimeFormatInfo.InvariantInfo.ShortDatePattern);
var envelopeId = Guid.NewGuid().ToString();
var accountId = "*****@*****.**";
var eventId = Guid.NewGuid().ToString();
var recipientId = Guid.NewGuid().ToString();
var envelopePayload = HealthMonitor_FixtureData.GetEnvelopePayload();
AddPayloadCrate(
dataDTO,
new EventReportCM()
{
EventPayload = envelopePayload,
EventNames = "Receive Envelope"
}
);
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
var responsePayloadDTO =
await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
var crateStorage = Crate.GetStorage(responsePayloadDTO);
Assert.AreEqual(1, crateStorage.CrateContentsOfType <DocuSignEnvelopeCM_v2>(x => x.Label == "DocuSign Envelope").Count());
}
public override void SetUp()
{
base.SetUp();
TerminalBootstrapper.ConfigureTest();
var salesforceManagerMock = new Mock <ISalesforceManager>();
salesforceManagerMock.Setup(x => x.Query(SalesforceObjectType.Account, It.IsAny <IList <FieldDTO> >(), It.IsAny <string>(), It.IsAny <AuthorizationToken>()))
.Returns(Task.FromResult(new StandardTableDataCM
{
Table = new List <TableRowDTO>
{
new TableRowDTO {
Row = new List <TableCellDTO> {
new TableCellDTO {
Cell = new KeyValueDTO("Id", "1")
}
}
}
}
}));
salesforceManagerMock.Setup(x => x.PostToChatter(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <AuthorizationToken>()))
.Returns(Task.FromResult("feedid"));
ObjectFactory.Container.Inject(salesforceManagerMock);
ObjectFactory.Container.Inject(salesforceManagerMock.Object);
var hubCommunicatorMock = new Mock <IHubCommunicator>();
ObjectFactory.Container.Inject(hubCommunicatorMock);
ObjectFactory.Container.Inject(hubCommunicatorMock.Object);
HealthMonitor_FixtureData.ConfigureHubToReturnEmptyPayload();
}
private async Task <ActivityDTO> ConfigureInitial()
{
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = HealthMonitor_FixtureData
.Get_Jira_Issue_v1_InitialConfiguration_Fr8DataDTO();
var activityDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
Assert.IsNotNull(activityDTO);
Assert.IsNotNull(activityDTO.CrateStorage);
var crateStorage = Crate.FromDto(activityDTO.CrateStorage);
Assert.AreEqual(2, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
var controls = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().First();
Assert.AreEqual(1, controls.Controls.Count);
Assert.AreEqual("TextSource", controls.Controls[0].Type);
Assert.AreEqual("IssueNumber", controls.Controls[0].Name);
return(activityDTO);
}
private async Task <ActivityDTO> ConfigureInitial(bool isAuthToken = true)
{
var configureUrl = GetTerminalConfigureUrl();
var requestActionDTO = HealthMonitor_FixtureData.Publish_To_Slack_v1_InitialConfiguration_Fr8DataDTO(isAuthToken);
var responseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestActionDTO);
return(responseActionDTO);
}
private async Task <ActivityDTO> ConfigureInitial()
{
var configureUrl = GetTerminalConfigureUrl();
var requestActionDTO = await HealthMonitor_FixtureData.Send_DocuSign_Envelope_v1_Example_Fr8DataDTO(this);
var responseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestActionDTO);
return(responseActionDTO);
}
public async Task Prepare_DocuSign_Events_For_Storage_Run_NoAuth()
{
var runUrl = GetTerminalRunUrl();
var dataDTO = await HealthMonitor_FixtureData.Prepare_DocuSign_Events_For_Storage_v1_InitialConfiguration_Fr8DataDTO(this);
dataDTO.ActivityDTO.AuthToken = null;
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
var payload = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
CheckIfPayloadHasNeedsAuthenticationError(payload);
}
public async Task MonitorChannel_InitialConfigurationWithoutAuth_ReturnAuthenticationCrate()
{
var configureUrl = GetTerminalConfigureUrl();
var requestDataDTO = HealthMonitor_FixtureData.Monitor_Channel_v1_InitialConfiguration_Fr8DataDTO();
requestDataDTO.ActivityDTO.AuthToken = null;
var responseActivityDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestDataDTO);
var authCrate = Crate.GetStorage(responseActivityDTO).FirstCrateOrDefault <StandardAuthenticationCM>();
Assert.IsNotNull(authCrate, "Authentication crate is not found in unauthenticated request response");
}
public async Task Convert_TableData_To_AccountingTransactions()
{
//Arrange
var configureUrl = GetTerminalConfigureUrl();
var runUrl = GetTerminalRunUrl();
var dataDTO =
HealthMonitor_FixtureData.Convert_TableData_To_AccountingTransactions_v1_InitialConfiguration_Fr8DataDTO();
var firstResponseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
dataDTO.ActivityDTO = firstResponseActionDTO;
var curAccountsCrate = HealthMonitor_FixtureData.ChartOfAccounts_Test1();
var curTableDataCrate = HealthMonitor_FixtureData.StandardTableData_Test1();
AddUpstreamCrate(dataDTO, curTableDataCrate, "DocuSignTableDataMappedToQuickbooks");
using (var crateStorage = Crate.GetUpdatableStorage(dataDTO.ActivityDTO))
{
crateStorage.Add(Fr8.Infrastructure.Data.Crates.Crate.FromContent("ChartOfAccounts", curAccountsCrate));
}
//Act
using (var crateStorage = Crate.GetUpdatableStorage(dataDTO.ActivityDTO))
{
var controls = crateStorage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.Single();
//Set the button group data
var radioGroup = (RadioButtonGroup)controls.FindByName("DebitCredit");
radioGroup.Radios[0].Selected = true;
radioGroup.Radios[1].Selected = false;
//Set first distribution line data to controls
var firstLineGroup = (RadioButtonGroup)controls.FindByName("Line1");
firstLineGroup.Radios[0].Selected = true;
firstLineGroup.Radios[1].Selected = false;
//Set debit account name to the control
firstLineGroup.Radios[0].Controls[0].Value = "Accounts Payable";
//Set memo
var memoTextBox = controls.FindByName("Memo");
memoTextBox.Value = "The testing transactions";
crateStorage.Remove <StandardAccountingTransactionCM>();
crateStorage.Add(Fr8.Infrastructure.Data.Crates.Crate.FromContent("StandardConfigurationControlsCM", controls));
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
dataDTO.ActivityDTO.AuthToken = HealthMonitor_FixtureData.QuickBooks_AuthTokenDTO();
}
var payloadDTO = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
AssertControls(Crate.GetStorage(payloadDTO).FirstCrateContentOrDefault <StandardAccountingTransactionCM>());
}
public async Task Send_Via_Twilio_Run_Send_SMS_With_Correct_Number()
{
//Arrange
var configureUrl = GetTerminalConfigureUrl();
var runUrl = GetTerminalRunUrl();
var dataDTO = HealthMonitor_FixtureData.Send_Via_Twilio_v1_InitialConfiguration_Fr8DataDTO();
//Act
var responseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO);
var crateManager = new CrateManager();
using (var updatableStorage = crateManager.GetUpdatableStorage(responseActionDTO))
{
var curNumberTextSource =
(TextSource)
updatableStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single().Controls[0];
curNumberTextSource.ValueSource = "specific";
curNumberTextSource.TextValue = ConfigurationManager.AppSettings["TestPhoneNumber"];
var curBodyTextSource =
(TextSource)
updatableStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single().Controls[1];
curBodyTextSource.ValueSource = "specific";
curBodyTextSource.TextValue = "That is the body of the message";
}
dataDTO.ActivityDTO = responseActionDTO;
//OperationalStateCM crate is required to be added,
//as upon return the Run method takes this crate and updates the status to "Success"
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
var payloadDTO = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
//Assert
//After Configure Test
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
var crateStorage = Crate.FromDto(responseActionDTO.CrateStorage);
var controls = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single();
Assert.NotNull(controls.Controls[0] is TextSource);
Assert.NotNull(controls.Controls[1] is TextSource);
Assert.AreEqual(false, controls.Controls[0].Selected);
//After Run Test
var payload = Crate.FromDto(payloadDTO.CrateStorage).CrateContentsOfType <StandardPayloadDataCM>().Single();
Assert.AreEqual("Status", payload.PayloadObjects[0].PayloadObject[0].Key);
Assert.AreNotEqual("failed", payload.PayloadObjects[0].PayloadObject[0].Value);
Assert.AreNotEqual("undelivered", payload.PayloadObjects[0].PayloadObject[0].Value);
}
public async Task Write_To_Sql_Server_FollowUp_Configuration_Check_Crate_Structure_Incorrect_ConnectionString()
{
var configureUrl = GetTerminalConfigureUrl();
var fr8DataDTO = HealthMonitor_FixtureData.Write_To_Sql_Server_v1_InitialConfiguration_Fr8DataDTO();
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
fr8DataDTO
);
var storage = Crate.GetStorage(responseActionDTO);
var controlDefinitionDTO =
storage.CratesOfType <StandardConfigurationControlsCM>()
.Select(x => x.Content.FindByName("connection_string")).ToArray();
//provide incorrect connection string
controlDefinitionDTO[0].Value = FixtureData.TestConnectionString3().Value;
using (var updatableStorage = Crate.GetUpdatableStorage(responseActionDTO))
{
updatableStorage.Replace(storage);
}
fr8DataDTO.ActivityDTO = responseActionDTO;
responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
fr8DataDTO
);
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
var crateStorage = Crate.FromDto(responseActionDTO.CrateStorage);
//There will be no DesignTimeCrate only Configuration crate
Assert.AreEqual(1, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
var controls = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single();
AssertConfigureControls(controls);
//Check that Error message is shown
var connStringTextBox = (TextBox)controls.Controls[0];
Assert.AreEqual("Incorrect Connection String", connStringTextBox.Value);
}
public async Task GetFileList_InitialConfig_ReturnsActivity()
{
//Arrange
var configureUrl = GetTerminalConfigureUrl();
Fr8DataDTO requestActionDTO = HealthMonitor_FixtureData.GetFileListTestFr8DataDTO();
//Act
var responseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
requestActionDTO
);
// Assert
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
}
public async Task Monitor_Channel_Deactivate_Returns_ActionDTO()
{
//Arrange
var configureUrl = GetTerminalDeactivateUrl();
var requestActionDTO = HealthMonitor_FixtureData.Monitor_Channel_v1_InitialConfiguration_Fr8DataDTO();
using (var storage = Crate.GetUpdatableStorage(requestActionDTO.ActivityDTO))
{
storage.Add(Fr8.Infrastructure.Data.Crates.Crate.FromContent(ExplicitTerminalActivity.ConfigurationControlsLabel, new Monitor_Channel_v1.ActivityUi()));
}
//Act
var responseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestActionDTO);
//Assert
Assert.IsNotNull(responseActionDTO);
Assert.IsNotNull(Crate.FromDto(responseActionDTO.CrateStorage));
}
private async Task <ActivityDTO> ConfigurationRequest()
{
var configureUrl = GetTerminalConfigureUrl();
var requestDataDTO = HealthMonitor_FixtureData.Publish_To_Slack_v1_InitialConfiguration_Fr8DataDTO();
var responseActionDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestDataDTO);
var storage = Crate.GetStorage(responseActionDTO);
using (var crateStorage = Crate.GetUpdatableStorage(requestDataDTO.ActivityDTO))
{
crateStorage.Replace(storage);
}
return(await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestDataDTO));
}
private async Task <Fr8DataDTO> GetConfiguredActivityWithChannelSelected(string selectedChannel = null)
{
selectedChannel = selectedChannel ?? string.Empty;
var configureUrl = GetTerminalConfigureUrl();
var requestDataDTO = HealthMonitor_FixtureData.Monitor_Channel_v1_InitialConfiguration_Fr8DataDTO();
var activityDTO = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestDataDTO);
requestDataDTO.ActivityDTO = activityDTO;
activityDTO.AuthToken = HealthMonitor_FixtureData.Slack_AuthToken();
AddPayloadCrate(
requestDataDTO,
new EventReportCM()
{
EventPayload = new CrateStorage()
{
Fr8.Infrastructure.Data.Crates.Crate.FromContent(
"EventReport",
new StandardPayloadDataCM(HealthMonitor_FixtureData.SlackEventFields()
)
)
}
}
);
using (var storage = Crate.GetUpdatableStorage(activityDTO))
{
selectedChannel = selectedChannel.StartsWith("#") ? selectedChannel : $"#{selectedChannel}";
storage.UpdateControls <Monitor_Channel_v1.ActivityUi>(x =>
{
if (string.IsNullOrEmpty(selectedChannel))
{
x.AllChannelsOption.Selected = true;
x.SpecificChannelOption.Selected = false;
}
else
{
x.AllChannelsOption.Selected = false;
x.SpecificChannelOption.Selected = true;
var channelListItem = x.ChannelList.ListItems.FirstOrDefault(y => y.Key == selectedChannel);
x.ChannelList.selectedKey = channelListItem?.Key;
x.ChannelList.Value = channelListItem?.Value;
}
});
}
return(requestDataDTO);
}
public async Task Prepare_DocuSign_Events_For_Storage_Initial_Configuration_NoAuth()
{
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = await HealthMonitor_FixtureData.Prepare_DocuSign_Events_For_Storage_v1_InitialConfiguration_Fr8DataDTO(this);
dataDTO.ActivityDTO.AuthToken = null;
var response = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
Assert.NotNull(response);
Assert.NotNull(response.CrateStorage);
Assert.NotNull(response.CrateStorage.Crates);
Assert.True(response.CrateStorage.Crates.Any(x => x.ManifestType == "Standard Authentication"));
}
