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);
}
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);
}
//[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 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 ConnectToSql_FollowUp_Configuration_Wrong_ConnetcioString_Check_Crate_Structure()
{
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = FixtureData.ConnectToSql_InitialConfiguration_Fr8DataDTO();
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
using (var updatableStorage = Crate.GetUpdatableStorage(responseActionDTO))
{
updatableStorage.RemoveByLabel("Configuration_Controls");
updatableStorage.Add(CreateWrongConnectionStringCrate());
}
dataDTO.ActivityDTO = responseActionDTO;
responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
var crateStorage = Crate.FromDto(responseActionDTO.CrateStorage);
Assert.AreEqual(1, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
AssertErrorControls(crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single());
}
private async Task <ActivityDTO> ConfigureMonitorActivity(ActivityDTO activity)
{
using (var updater = Crate.GetUpdatableStorage(activity))
{
var cm = updater.CrateContentsOfType <StandardConfigurationControlsCM>().FirstOrDefault();
Assert.NotNull(cm, "Unable to find StandardConfigurationControlsCM crate");
// Selected ObjectType.
var ddl = cm.FindByName <DropDownList>("SalesforceObjectList");
Assert.NotNull(ddl, "Unable to find SalesforceObjectList DropDownList in ConfigurationControls");
var leadListItem = ddl.ListItems.FirstOrDefault(x => x.Key == "Lead");
Assert.NotNull(leadListItem, "Unable to find Lead list item in SalesforceObjectList items");
ddl.SelectByValue(leadListItem.Value);
// Check Created check-box.
var createdCheckBox = cm.FindByName <CheckBox>("Created");
Assert.NotNull(createdCheckBox, "Unable to find Created CheckBox in ConfigurationControls");
createdCheckBox.Selected = true;
// Check Updated check-box.
var updatedCheckBox = cm.FindByName <CheckBox>("Updated");
Assert.NotNull(updatedCheckBox, "Unable to find Updated CheckBox in ConfigurationControls");
updatedCheckBox.Selected = true;
}
activity = await HttpPostAsync <ActivityDTO, ActivityDTO>(_baseUrl + "activities/save", activity);
activity = await HttpPostAsync <ActivityDTO, ActivityDTO>(_baseUrl + "activities/configure?id=" + activity.Id.ToString(), activity);
return(activity);
}
public async Task ConnectToSql_FollowUp_Configuration_Check_Crate_Structure()
{
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = FixtureData.ConnectToSql_InitialConfiguration_Fr8DataDTO();
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
using (var updatableStorage = Crate.GetUpdatableStorage(responseActionDTO))
{
updatableStorage.RemoveByLabel("Configuration_Controls");
updatableStorage.Add(CreateConnectionStringCrate());
}
dataDTO.ActivityDTO = responseActionDTO;
responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
var crateStorage = Crate.FromDto(responseActionDTO.CrateStorage);
AssertFollowUpCrateTypes(crateStorage);
}
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);
}
private async Task PrepareSaveToLead(PlanDTO plan)
{
var saveActivity = plan.SubPlans.First().Activities.First();
//set lead and do the follow up config
using (var updatableStorage = Crate.GetUpdatableStorage(saveActivity))
{
var ddlb = (DropDownList)updatableStorage.CratesOfType <StandardConfigurationControlsCM>().Single().Content.Controls[0];
ddlb.selectedKey = "Lead";
}
saveActivity = await ConfigureActivity(saveActivity);
Debug.WriteLine("Save to Salesforce Follow up config is successfull with Lead selected.");
//set the lead required fields.
using (var updatableStorage = Crate.GetUpdatableStorage(saveActivity))
{
var requiredControls = updatableStorage.CratesOfType <StandardConfigurationControlsCM>().Single().Content.Controls;
var lastNameControl = (TextSource)requiredControls.Single(c => c.Name.Equals("LastName"));
lastNameControl.ValueSource = "specific";
lastNameControl.TextValue = "Unit";
var companyControl = (TextSource)requiredControls.Single(c => c.Name.Equals("Company"));
companyControl.ValueSource = "specific";
companyControl.TextValue = "Test";
}
saveActivity = await ConfigureActivity(saveActivity);
Debug.WriteLine("Save to Salesforce Follow up config is successfull with required fields set.");
plan.SubPlans.First().Activities[0] = saveActivity;
}
private async Task PrepareGetData(PlanDTO plan)
{
var getDataActivity = plan.SubPlans.First().Activities.Last();
//set lead and do the follow up config
using (var crateStorage = Crate.GetUpdatableStorage(getDataActivity))
{
crateStorage.UpdateControls <Get_Data_v1.ActivityUi>(x =>
{
x.SalesforceObjectSelector.selectedKey = SalesforceObjectType.Lead.ToString();
});
}
getDataActivity = await ConfigureActivity(getDataActivity);
Debug.WriteLine("Get Data Follow up config is successfull with Lead selected");
//set the lead required fields.
using (var crateStorage = Crate.GetUpdatableStorage(getDataActivity))
{
crateStorage.UpdateControls <Get_Data_v1.ActivityUi>(x =>
{
x.SalesforceObjectFilter.Value = JsonConvert.SerializeObject(new List <FilterConditionDTO> {
new FilterConditionDTO {
Field = "LastName", Operator = "eq", Value = "Unit"
}
});
});
}
getDataActivity = await ConfigureActivity(getDataActivity);
Debug.WriteLine("Get Data Follow up config is successfull with selection query fields set.");
plan.SubPlans.First().Activities[1] = getDataActivity;
}
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 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 void SetContainersOptionSelected(ActivityDTO responseActionDTO)
{
using (var crateStorage = Crate.GetUpdatableStorage(responseActionDTO))
{
var controls = crateStorage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.Single();
var dropdownList = (DropDownList)controls.Controls[0];
dropdownList.selectedKey = "Containers";
dropdownList.Value = "21";
}
}
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>());
}
private void SetDuration(ActivityDTO responseActionDTO)
{
using (var crateStorage = Crate.GetUpdatableStorage(responseActionDTO))
{
var controls = crateStorage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.Single();
var duration = (Duration)controls.Controls[0];
duration.Days = 0;
duration.Hours = 0;
duration.Minutes = 2;
}
}
public async Task RunSavesFileToBox()
{
// Arrange
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = FixtureData.SaveToFileTestAction();
var runUrl = GetTerminalRunUrl();
// Act
var responseDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
dataDTO.ActivityDTO = responseDTO;
using (var crateStorage = Crate.GetUpdatableStorage(dataDTO.ActivityDTO))
{
// Add upstream table data
var tableCrate = FixtureData.GetStandardTableDataCM();
AddPayloadCrate(dataDTO, tableCrate);
// Select table data in CrateChooser
var controls = crateStorage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.Single();
var fileChooser = controls.FindByName <CrateChooser>("FileChooser");
fileChooser.CrateDescriptions = new List <CrateDescriptionDTO>()
{
new CrateDescriptionDTO()
{
Label = "", Selected = true
}
};
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
dataDTO.ActivityDTO.AuthToken = FixtureData.GetBoxAuthToken();
}
var payload = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(
runUrl,
dataDTO
);
// Assert
Assert.NotNull(payload);
Assert.NotNull(payload.CrateStorage);
}
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 Write_To_Log_Run_WithInvalidPapertrailUrl_ShouldReturnError()
{
//Arrange
var runUrl = GetTerminalRunUrl();
//prepare the action DTO with valid target URL
var activityDTO = await GetActivityDTO_LogToPapertrailIntegrationTest();
var dataDTO = new Fr8DataDTO {
ActivityDTO = activityDTO
};
//make the target URL as invalid
using (var crateStorage = Crate.GetUpdatableStorage(activityDTO))
{
var controls = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single();
var targetUrlTextBox = (TextBox)controls.Controls[0];
targetUrlTextBox.Value = "InvalidUrl";
}
//add the Log Message in upstream action
AddPayloadCrate(dataDTO,
new StandardLoggingCM
{
Item =
new List <LogItemDTO>
{
new LogItemDTO {
Data = "Integration Test Log Message on " + DateTime.Now, IsLogged = false
}
}
});
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
//Act
var payload = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
var storage = Crate.GetStorage(payload);
var operationalStateCM = storage.CrateContentsOfType <OperationalStateCM>().Single();
ErrorDTO errorMessage;
operationalStateCM.CurrentActivityResponse.TryParseErrorDTO(out errorMessage);
Assert.AreEqual(ActivityResponse.Error.ToString(), operationalStateCM.CurrentActivityResponse.Type);
Assert.AreEqual("Papertrail URL and PORT are not in the correct format. The given URL is InvalidUrl", errorMessage.Message);
}
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);
}
private async Task <ActivityDTO> ConfigureFollowUp()
{
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.FromDto(responseActionDTO.CrateStorage);
SendDocuSignEnvelope_SelectFirstTemplate(storage);
using (var crateStorage = Crate.GetUpdatableStorage(dataDTO.ActivityDTO))
{
crateStorage.Replace(storage);
}
return(await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO));
}
public async Task Write_To_Sql_Server_FollowUp_Configuration_Check_Crate_Structure()
{
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();
controlDefinitionDTO[0].Value = FixtureData.TestConnectionString2().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);
Assert.AreEqual(1, crateStorage.Count);
Assert.AreEqual(1, crateStorage.CratesOfType <StandardConfigurationControlsCM>().Count());
AssertConfigureControls(crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single());
}
private async Task <Tuple <ActivityDTO, string> > GetActivityDTO_WithTemplateValue()
{
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;
string selectedTemplate = null;
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 = false;
radioGroup.Radios[1].Selected = true;
var templateDdl = (DropDownList)radioGroup.Radios[1].Controls[0];
Assert.IsTrue(templateDdl.ListItems.Count > 0);
var selectedItem = templateDdl.ListItems.FirstOrDefault(x => x.Key == TemplateName);
Assert.IsNotNull(selectedItem, $"Template with name '{TemplateName}' doesn't exist");
templateDdl.Value = selectedItem.Value;
selectedTemplate = templateDdl.selectedKey = selectedItem.Key;
}
return(new Tuple <ActivityDTO, string>(responseActionDTO, selectedTemplate));
}
//[ExpectedException(
// ExpectedException = typeof(RestfulServiceException),
// ExpectedMessage = @"{""status"":""terminal_error"",""message"":""No auth token provided.""}"
//)]
public async Task Send_DocuSign_Envelope_Run_NoAuth()
{
var runUrl = GetTerminalRunUrl();
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_SetSpecificRecipient(storage);
using (var crateStorage = Crate.GetUpdatableStorage(dataDTO.ActivityDTO))
{
crateStorage.Replace(storage);
}
dataDTO.ActivityDTO.AuthToken = null;
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
var payload = await HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO);
CheckIfPayloadHasNeedsAuthenticationError(payload);
}
public Task <PayloadDTO> GetPayload(Guid containerId)
{
var payload = new PayloadDTO(containerId)
{
CrateStorage = new CrateStorageDTO()
};
var crateStorage = Crate.GetStorage(ExplicitData);
using (var updatableStorage = Crate.GetUpdatableStorage(payload))
{
var crates = crateStorage
.Where(x => x.Label.StartsWith(LabelPrefix + "_PayloadCrate"))
.ToList();
StripLabelPrefix(crates, LabelPrefix + "_PayloadCrate");
updatableStorage.AddRange(crates);
}
return(Task.FromResult(payload));
}
private async Task <ActivityDTO> GetActivityDTO_LogToPapertrailIntegrationTest()
{
var configureUrl = GetTerminalConfigureUrl();
var requestActionDTO = HealthMonitor_FixtureData.Write_To_Log_v1_InitialConfiguration_Fr8DataDTO();
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
requestActionDTO
);
using (var crateStorage = Crate.GetUpdatableStorage(responseActionDTO))
{
var controls = crateStorage.CrateContentsOfType <StandardConfigurationControlsCM>().Single();
var targetUrlTextBox = (TextBox)controls.Controls[0];
targetUrlTextBox.Value = "logs3.papertrailapp.com:22529";
}
return(responseActionDTO);
}
public async Task Activate_Returns_ActivityDTO()
{
//Arrange
var activateUrl = GetTerminalActivateUrl();
Fr8DataDTO dataDto = HealthMonitor_FixtureData.GetFileListTestFr8DataDTO();
// Add initial configuretion controls
using (var crateStorage = Crate.GetUpdatableStorage(dataDto.ActivityDTO))
{
crateStorage.Add("Configuration_Controls", new StandardConfigurationControlsCM());
}
//Act
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
activateUrl,
dataDto
);
//Assert
Assert.IsNotNull(responseActionDTO);
Assert.IsNotNull(Crate.FromDto(responseActionDTO.CrateStorage));
}
public async Task SaveToSalesforce_And_GetSalesforceData_EndToEnd()
{
AuthorizationTokenDO authTokenDO = null;
AuthorizationToken authorizationToken = null;
Guid initialPlanId = Guid.Empty;
string newLeadId = string.Empty;
try
{
authTokenDO = await Fixtures.HealthMonitor_FixtureData.CreateSalesforceAuthToken();
authorizationToken = new AuthorizationToken
{
UserId = authTokenDO.UserID,
ExternalAccountId = authTokenDO.ExternalAccountId,
ExternalDomainId = authTokenDO.ExternalDomainId,
AdditionalAttributes = authTokenDO.AdditionalAttributes,
Token = authTokenDO.Token,
Id = authTokenDO.Id.ToString()
};
//Create the required plan with all initial activities initial config
initialPlanId = await CreatePlan_SaveAndGetDataFromSalesforce(authTokenDO);
//get the full plan which is created
var plan = await HttpGetAsync <PlanDTO>(_baseUrl + "Plans?include_children=true&id=" + initialPlanId.ToString());
Debug.WriteLine("Created plan with all activities.");
//prepare the two activities with their follow up config
await PrepareSaveToLead(plan);
await PrepareGetData(plan);
//execute the plan
Debug.WriteLine("Executing plan " + plan.Name);
var container = await HttpPostAsync <string, ContainerDTO>(_baseUrl + "plans/run?planId=" + plan.Id.ToString(), null);
Debug.WriteLine("Executing plan " + plan.Name + " successful.");
//get the payload of the executed plan
var payload = await HttpGetAsync <PayloadDTO>(_baseUrl + "Containers/payload?id=" + container.Id.ToString());
Debug.WriteLine("Got the payload for the container " + container.Name);
//Assert
Debug.WriteLine("Asserting initial payload.");
var payloadList = Crate.GetUpdatableStorage(payload).CratesOfType <StandardPayloadDataCM>().ToList();
Assert.AreEqual(1, payloadList.Count, "The payload does not contain all activities payload");
Assert.IsTrue(payloadList.Any(pl => pl.Label.Equals("Lead is saved in Salesforce.com")), "Save Data is Failed to save the lead.");
Debug.WriteLine("Asserting Save To Salesforce payload.");
var savePayload = payloadList[0].Content.PayloadObjects[0].PayloadObject;
Assert.AreEqual(1, savePayload.Count, "Save data payload contains some unwanted fields.");
Assert.IsTrue(savePayload.Any(f => f.Key.Equals("LeadID")), "The newly created lead ID is not populated in the run time.");
newLeadId = savePayload.Single(f => f.Key.Equals("LeadID")).Value;
Debug.WriteLine("Newly created Lead ID is " + newLeadId);
Debug.WriteLine("Deleting newly created lead with " + newLeadId);
var isDeleted = await _container.GetInstance <SalesforceManager>().Delete(SalesforceObjectType.Lead, newLeadId, authorizationToken);
Assert.IsTrue(isDeleted, "The newly created Lead for integration test purpose is not deleted.");
newLeadId = string.Empty;
Debug.WriteLine("Cleaning up.");
await CleanUp(authorizationToken, initialPlanId, newLeadId);
Debug.WriteLine("Cleaning up Successful.");
}
finally
{
await CleanUp(authorizationToken, initialPlanId, newLeadId);
}
}
public async Task Mail_Merge_Into_DocuSign_EndToEnd_Upstream_Values_From_Google_Check_Tabs()
{
//
//Setup Test
//
await RevokeTokens();
var terminalGoogleTestTools = new Fr8.Testing.Integration.Tools.Terminals.IntegrationTestTools_terminalGoogle(this);
var googleActivityTestTools = new Fr8.Testing.Integration.Tools.Activities.IntegrationTestTools_terminalGoogle(this);
var googleAuthTokenId = await terminalGoogleTestTools.ExtractGoogleDefaultToken();
string spreadsheetName = Guid.NewGuid().ToString();
string spreadsheetKeyWord = Guid.NewGuid().ToString();
string worksheetName = "TestSheet";
//create new excel spreadsheet inside google and insert one row of data inside the spreadsheet
//spreadsheetKeyWord is an identifier that will help up later in the test to easily identify specific envelope
var tableFixtureData = FixtureData.TestStandardTableData(TestEmail, spreadsheetKeyWord);
string spreadsheetId = await terminalGoogleTestTools.CreateNewSpreadsheet(googleAuthTokenId, spreadsheetName, worksheetName, tableFixtureData);
//
// Create solution
//
var parameters = await _docuSignActivitiesTestTools.CreateAndConfigure_MailMergeIntoDocuSign_Solution("Get_Google_Sheet_Data",
"Get Google Sheet Data", "a439cedc-92a8-49ad-ab31-e2ee7964b468", "Fr8 Fromentum Registration Form", false);
this.solution = parameters.Item1;
var plan = parameters.Item2;
var tokenGuid = parameters.Item3;
//
// configure Get_Google_Sheet_Data activity
//
var googleSheetActivity = this.solution.ChildrenActivities.Single(a => a.ActivityTemplate.Name.Equals("Get_Google_Sheet_Data", StringComparison.InvariantCultureIgnoreCase));
await googleActivityTestTools.ConfigureGetFromGoogleSheetActivity(googleSheetActivity, spreadsheetName, false, worksheetName);
//
// configure Loop activity
//
var loopActivity = this.solution.ChildrenActivities.Single(a => a.ActivityTemplate.Name.Equals("Loop", StringComparison.InvariantCultureIgnoreCase));
var terminalFr8CoreTools = new IntegrationTestTools_terminalFr8(this);
loopActivity = await terminalFr8CoreTools.ConfigureLoopActivity(loopActivity, "Standard Table Data", "Table Generated From Google Sheet Data");
//
// Configure Send DocuSign Envelope action
//
//
// Initial Configuration
//
var sendEnvelopeAction = loopActivity.ChildrenActivities.Single(a => a.ActivityTemplate.Name == "Send_DocuSign_Envelope");
crateStorage = Crate.FromDto(sendEnvelopeAction.CrateStorage);
var controlsCrate = crateStorage.CratesOfType <StandardConfigurationControlsCM>().First();
var docuSignTemplate = controlsCrate.Content.Controls.OfType <DropDownList>().First();
docuSignTemplate.Value = "a439cedc-92a8-49ad-ab31-e2ee7964b468";
docuSignTemplate.selectedKey = "Fr8 Fromentum Registration Form";
using (var updatableStorage = Crate.GetUpdatableStorage(sendEnvelopeAction))
{
updatableStorage.Remove <StandardConfigurationControlsCM>();
updatableStorage.Add(controlsCrate);
}
sendEnvelopeAction = await HttpPostAsync <ActivityDTO, ActivityDTO>(_baseUrl + "activities/save", sendEnvelopeAction);
sendEnvelopeAction = await HttpPostAsync <ActivityDTO, ActivityDTO>(_baseUrl + "activities/configure", sendEnvelopeAction);
//
// Follow-up Configuration
//
//chosen "Fr8 Fromentum Registration Form" contains 7 specific DocuSign tabs that will be configured with upstream values
crateStorage = Crate.FromDto(sendEnvelopeAction.CrateStorage);
controlsCrate = crateStorage.CratesOfType <StandardConfigurationControlsCM>().First();
var emailField = controlsCrate.Content.Controls.OfType <TextSource>().First(f => f.InitialLabel == "Lead role email");
emailField.ValueSource = "upstream";
emailField.Value = "emailaddress";
emailField.selectedKey = "emailaddress";
var emailNameField = controlsCrate.Content.Controls.OfType <TextSource>().First(f => f.InitialLabel == "Lead role name");
emailNameField.ValueSource = "upstream";
emailNameField.Value = "name";
emailNameField.selectedKey = "name";
var phoneField = controlsCrate.Content.Controls.OfType <TextSource>().First(f => f.InitialLabel == "Phone (Lead)");
phoneField.ValueSource = "upstream";
phoneField.Value = "phone";
phoneField.selectedKey = "phone";
var titleField = controlsCrate.Content.Controls.OfType <TextSource>().First(f => f.InitialLabel == "Title (Lead)");
titleField.ValueSource = "upstream";
titleField.Value = "title";
titleField.selectedKey = "title";
var companyField = controlsCrate.Content.Controls.OfType <TextSource>().First(f => f.InitialLabel == "Company (Lead)");
companyField.ValueSource = "upstream";
companyField.Value = "companyname";
companyField.selectedKey = "companyname";
var radioGroup = controlsCrate.Content.Controls.OfType <RadioButtonGroup>().First(f => f.GroupName == "Registration Type (Lead)");
foreach (var radios in radioGroup.Radios)
{
//reset all preselected radioButtons
radios.Selected = false;
}
var radioButton = radioGroup.Radios.FirstOrDefault(x => x.Name == "Buy 2, Get 3rd Free");
radioButton.Selected = true;
var checkboxField = controlsCrate.Content.Controls.OfType <CheckBox>().First(f => f.Name == "CheckBoxFields_GovernmentEntity? (Lead)");
checkboxField.Selected = true;
var dropdownField = controlsCrate.Content.Controls.OfType <DropDownList>().First(f => f.Name == "DropDownListFields_Size of Company (Lead)");
dropdownField.Value = "Medium (51-250)";
dropdownField.selectedKey = "Medium (51-250)";
using (var updatableStorage = Crate.GetUpdatableStorage(sendEnvelopeAction))
{
updatableStorage.Remove <StandardConfigurationControlsCM>();
updatableStorage.Add(controlsCrate);
}
sendEnvelopeAction = await HttpPostAsync <ActivityDTO, ActivityDTO>(_baseUrl + "activities/save", sendEnvelopeAction);
crateStorage = Crate.FromDto(sendEnvelopeAction.CrateStorage);
controlsCrate = crateStorage.CratesOfType <StandardConfigurationControlsCM>().First();
docuSignTemplate = controlsCrate.Content.Controls.OfType <DropDownList>().First();
Assert.AreEqual("a439cedc-92a8-49ad-ab31-e2ee7964b468", docuSignTemplate.Value, "Selected DocuSign Template did not save on Send DocuSign Envelope action.");
Assert.AreEqual("Fr8 Fromentum Registration Form", docuSignTemplate.selectedKey, "Selected DocuSign Template did not save on Send DocuSign Envelope action.");
//
// Activate and run plan
//
var container = await HttpPostAsync <string, ContainerDTO>(_baseUrl + "plans/run?planId=" + plan.Id, null);
Assert.AreEqual(container.State, State.Completed, "Container state is not equal to completed on Mail_Merge e2e test");
//
// Assert
//
var authorizationTokenDO = _terminalDocuSignTestTools.GetDocuSignAuthToken(tokenGuid);
var authorizationToken = new AuthorizationToken()
{
Token = authorizationTokenDO.Token,
};
var configuration = new DocuSignManager().SetUp(authorizationToken);
//find the envelope on the Docusign Account
var folderItems = DocuSignFolders.GetFolderItems(configuration, new DocuSignQuery()
{
Status = "sent",
SearchText = spreadsheetKeyWord
});
var envelope = folderItems.FirstOrDefault();
Assert.IsNotNull(envelope, "Cannot find created Envelope in sent folder of DocuSign Account");
var envelopeApi = new EnvelopesApi(configuration.Configuration);
//get the recipient that receive this sent envelope
var envelopeSigner = envelopeApi.ListRecipients(configuration.AccountId, envelope.EnvelopeId).Signers.FirstOrDefault();
Assert.IsNotNull(envelopeSigner, "Envelope does not contain signer as recipient. Send_DocuSign_Envelope activity failed to provide any signers");
//get the tabs for the envelope that this recipient received
var tabs = envelopeApi.ListTabs(configuration.AccountId, envelope.EnvelopeId, envelopeSigner.RecipientId);
Assert.IsNotNull(tabs, "Envelope does not contain any tabs. Check for problems in DocuSignManager and HandleTemplateData");
//check all tabs and their values for received envelope, and compare them to those from the google sheet configured into Mail_Merge_Into_Docusign solution
var titleRecipientTab = tabs.TextTabs.FirstOrDefault(x => x.TabLabel == "Title");
Assert.IsNotNull(titleRecipientTab, "Envelope does not contain Title tab. Check for problems in DocuSignManager and HandleTemplateData");
Assert.AreEqual(tableFixtureData.Table[1].Row.FirstOrDefault(x => x.Cell.Key == "title").Cell.Value, titleRecipientTab.Value, "Provided value for Title in document for recipient after finishing mail merge plan is incorrect");
var companyRecipientTab = tabs.TextTabs.FirstOrDefault(x => x.TabLabel == "Company");
Assert.IsNotNull(companyRecipientTab, "Envelope does not contain Company tab. Check for problems in DocuSignManager and HandleTemplateData");
Assert.AreEqual(tableFixtureData.Table[1].Row.FirstOrDefault(x => x.Cell.Key == "companyname").Cell.Value, companyRecipientTab.Value, "Provided value for CompanyName in document for recipient after finishing mail merge plan is incorrect");
var phoneRecipientTab = tabs.TextTabs.FirstOrDefault(x => x.TabLabel == "Phone");
Assert.IsNotNull(phoneRecipientTab, "Envelope does not contain phone tab. Check for problems in DocuSignManager and HandleTemplateData");
Assert.AreEqual(tableFixtureData.Table[1].Row.FirstOrDefault(x => x.Cell.Key == "phone").Cell.Value, phoneRecipientTab.Value, "Provided value for phone in document for recipient after finishing mail merge plan is incorrect");
var listRecipientTab = tabs.ListTabs.FirstOrDefault(x => x.TabLabel == "Size of Company");
Assert.IsNotNull(listRecipientTab, "Envelope does not contain List Tab for Size of Company tab. Check for problems in DocuSignManager and HandleTemplateData");
Assert.AreEqual("Medium (51-250)", listRecipientTab.Value, "Provided value for Size of Company(Lead) in document for recipient after finishing mail merge plan is incorrect");
var checkboxRecipientTab = tabs.CheckboxTabs.FirstOrDefault(x => x.TabLabel == "GovernmentEntity?");
Assert.IsNotNull(checkboxRecipientTab, "Envelope does not contain Checkbox for Goverment Entity tab. Check for problems in DocuSignManager and HandleTemplateData");
Assert.AreEqual("true", checkboxRecipientTab.Selected, "Provided value for GovernmentEntity? in document for recipient after finishing mail merge plan is incorrect");
var radioButtonGroupTab = tabs.RadioGroupTabs.FirstOrDefault(x => x.GroupName == "Registration Type");
Assert.IsNotNull(radioButtonGroupTab, "Envelope does not contain RadioGroup tab for registration. Check for problems in DocuSignManager and HandleTemplateData");
Assert.AreEqual("Buy 2, Get 3rd Free", radioButtonGroupTab.Radios.FirstOrDefault(x => x.Selected == "true").Value, "Provided value for Registration Type in document for recipient after finishing mail merge plan is incorrect");
// Verify that test email has been received
EmailAssert.EmailReceived("*****@*****.**", "Test Message from Fr8");
//
// Cleanup
//
//delete spreadsheet
await terminalGoogleTestTools.DeleteSpreadSheet(googleAuthTokenId, spreadsheetId);
//
// Deactivate plan
//
await HttpPostAsync <string, string>(_baseUrl + "plans/deactivate?planId=" + plan.Id, null);
//
// Delete plan
//
//await HttpDeleteAsync(_baseUrl + "plans?id=" + plan.Id);
}
