public async Task Run_Check_PayloadDTO_ForObjectData()
{
//Arrange
var authToken = await FixtureData.Salesforce_AuthToken();
var activityContext = await FixtureData.GetFileListTestActivityContext1();
var executionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
//perform initial configuration
await _getData_v1.Configure(activityContext);
activityContext = SelectSalesforceAccount(activityContext);
//perform follow up configuration
await _getData_v1.Configure(activityContext);
activityContext.ActivityPayload.CrateStorage.CratesOfType <StandardConfigurationControlsCM>()
.Single()
.Content.Controls.Single(control => control.Type == ControlTypes.QueryBuilder)
//.Value = JsonConvert.SerializeObject(new FilterDataDTO() {Conditions = new List<FilterConditionDTO>()});
.Value = JsonConvert.SerializeObject(new List <FilterConditionDTO>());
//Act
await _getData_v1.Run(activityContext, executionContext);
//Assert
var stroage = executionContext.PayloadStorage;
Assert.AreEqual(2, stroage.Count, "Number of Payload crates not populated correctly");
Assert.IsNotNull(stroage.CratesOfType <StandardTableDataCM>().Single(), "Not able to get the required salesforce object");
}
public async Task Configure_FollowUpConfig_CheckObjectFields()
{
// Arrange
var activityContext = await FixtureData.GetFileListTestActivityContext2();
await _getData_v1.Configure(activityContext);
SelectSalesforceAccount(activityContext);
Mock <ISalesforceManager> salesforceIntegrationMock = Mock.Get(ObjectFactory.GetInstance <ISalesforceManager>());
// Act
await _getData_v1.Configure(activityContext);
// Assert
var storage = activityContext.ActivityPayload.CrateStorage;
Assert.AreEqual(5, storage.Count, "Number of configuration crates not populated correctly");
// Assert.IsNotNull(storage.FirstCrateOrDefault<TypedFieldsCM>(x => x.Label == Get_Data_v1.QueryFilterCrateLabel),
// "There is not crate with query fields descriptions and expected label in activity storage");
Assert.IsNotNull(storage.FirstCrateOrDefault <StandardConfigurationControlsCM>(), "There is not crate with controls in activity storage");
Assert.IsNotNull(storage.FirstCrateOrDefault <CrateDescriptionCM>(), "There is no crate with runtime crates descriptions in activity storage");
Assert.IsNotNull(storage.FirstCrateOrDefault <FieldDescriptionsCM>(x => x.Label == "Queryable Criteria"),
"There is no crate with field descriptions of selected Salesforce object in activity storage");
salesforceIntegrationMock.Verify(s => s.GetProperties(SalesforceObjectType.Account, It.IsAny <AuthorizationToken>(), false, null), Times.Exactly(1));
}
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 void Activity_CanGetDownstreamActivities()
{
//load tree
//set cur activity to id 57
//verify that the count of upstream activities is 10
//print out the list of activity ids
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
uow.PlanRepository.Add(new PlanDO()
{
Name = "name",
PlanState = PlanState.Executing,
ChildNodes = { FixtureData.TestActivityTree() }
});
uow.SaveChanges();
PlanNodeDO curActivity = FixtureData.TestActivity57();
List <PlanNodeDO> downstreamActivities = _planNode.GetDownstreamActivities(uow, uow.PlanRepository.GetById <PlanNodeDO>(curActivity.Id));
foreach (var activity in downstreamActivities)
{
Debug.WriteLine(FixtureData.GetTestIdByGuid(activity.Id));
}
Assert.AreEqual(9, downstreamActivities.Count());
}
}
public async Task ConnectToSql_FollowUp_Configuration_No_Connection_String_Check_Crate_Structure()
{
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = FixtureData.ConnectToSql_InitialConfiguration_Fr8DataDTO();
var responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
dataDTO.ActivityDTO = responseActionDTO;
responseActionDTO =
await HttpPostAsync <Fr8DataDTO, ActivityDTO>(
configureUrl,
dataDTO
);
Assert.NotNull(responseActionDTO);
Assert.NotNull(responseActionDTO.CrateStorage);
var crateStorage = Crate.FromDto(responseActionDTO.CrateStorage);
AssertConfigureCrate(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());
}
public void CanGetDisplayNameWithEmailAddressDO()
{
_dockyardAccountDO.EmailAddress = FixtureData.TestEmailAddress1();
string displayName = "Alex";
Assert.AreEqual(displayName, _fr8Account.GetDisplayName(_dockyardAccountDO));
}
public void FailsUserUpdatedIfNoExistingDockyardAccount()
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
_fr8Account.Update(uow, FixtureData.TestDockyardAccount4(), null);
}
}
public async Task PrepareToExecute_WithMockedExecute_WithoutPayload()
{
ActivityDO activityDo = FixtureData.TestActivityStateInProcess();
activityDo.CrateStorage = JsonConvert.SerializeObject(new ActivityDTO());
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
uow.ActivityTemplateRepository.Add(activityDo.ActivityTemplate);
uow.PlanRepository.Add(new PlanDO()
{
Name = "sdfsdf",
PlanState = PlanState.Executing,
ChildNodes = { activityDo }
});
uow.SaveChanges();
}
Activity _activity = ObjectFactory.GetInstance <Action>();
ContainerDO containerDO = FixtureData.TestContainer1();
EventManager.EventActionStarted += EventManager_EventActivityStarted;
var executeActionMock = new Mock <IActivity>();
executeActionMock.Setup(s => s.Run(It.IsAny <IUnitOfWork>(), activityDo, It.IsAny <ActivityExecutionMode>(), containerDO)).Returns <Task <PayloadDTO> >(null);
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
await _activity.Run(uow, activityDo, ActivityExecutionMode.InitialRun, containerDO);
}
Assert.IsNull(containerDO.CrateStorage);
Assert.IsTrue(_eventReceived);
// Assert.AreEqual(actionDo.ActionState, ActionState.Active);
}
public async Task ActivityStarted_EventRaisedSuccessfully()
{
ActivityDO activityDo = FixtureData.TestActivityStateInProcess();
activityDo.CrateStorage = JsonConvert.SerializeObject(new ActivityDTO());
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
uow.ActivityTemplateRepository.Add(activityDo.ActivityTemplate);
uow.PlanRepository.Add(new PlanDO
{
Name = "name",
PlanState = PlanState.Executing,
ChildNodes = { activityDo }
});
uow.SaveChanges();
}
Activity activity = ObjectFactory.GetInstance <Activity>();
ContainerDO containerDO = FixtureData.TestContainer1();
EventManager.EventActionStarted += EventManager_EventActivityStarted;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
await activity.Run(uow, activityDo, ActivityExecutionMode.InitialRun, containerDO);
}
Assert.IsTrue(_eventReceived, "Unable to receive event about activity start");
}
public void Process_ActivityUnstarted_ShouldBeCompleted()
{
//Arrange
ActivityDO activityDo = FixtureData.TestActivityUnstarted();
activityDo.ActivityTemplate.Terminal.Endpoint = "http://localhost:53234/activities/configure";
activityDo.CrateStorage = JsonConvert.SerializeObject(new ActivityDTO());
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
uow.ActivityTemplateRepository.Add(activityDo.ActivityTemplate);
uow.PlanRepository.Add(new PlanDO()
{
Name = "name",
PlanState = PlanState.Executing,
ChildNodes = { activityDo }
});
uow.SaveChanges();
}
ActivityDTO activityDto = Mapper.Map <ActivityDTO>(activityDo);
TerminalTransmitterMock.Setup(rc => rc.PostAsync(It.IsAny <Uri>(), It.IsAny <object>(), It.IsAny <string>(), It.IsAny <Dictionary <string, string> >()))
.Returns(() => Task.FromResult <string>(JsonConvert.SerializeObject(activityDto)));
ContainerDO containerDO = FixtureData.TestContainer1();
//Act
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var task = _activity.Run(uow, activityDo, ActivityExecutionMode.InitialRun, containerDO);
//Assert
Assert.That(task.Status, Is.EqualTo(TaskStatus.RanToCompletion));
}
}
public async Task ActivityWithNestedUpdated_StructureUnchanged()
{
var tree = FixtureData.CreateTestActivityTreeWithOnlyActivityDo();
var updatedTree = FixtureData.CreateTestActivityTreeWithOnlyActivityDo();
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var plan = new PlanDO
{
PlanState = PlanState.Executing,
Name = "name",
ChildNodes = { tree }
};
uow.PlanRepository.Add(plan);
uow.SaveChanges();
Visit(updatedTree, x => x.Label = string.Format("We were here {0}", x.Id));
}
await _activity.SaveOrUpdateActivity(updatedTree);
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var result = uow.PlanRepository.GetById <ActivityDO>(tree.Id);
Compare(updatedTree, result, (r, a) =>
{
if (r.Label != a.Label)
{
throw new Exception("Update failed");
}
});
}
}
public async Task Run_Always_ProducesExpectedCrate()
{
ObjectFactory.Container.ConfigureHubToReturnEmptyPayload();
ObjectFactory.Container.GetInstance <Mock <IDocuSignFolders> >().Setup(x => x.GetFolderItems(It.IsAny <DocuSignApiConfiguration>(), It.IsAny <DocuSignQuery>()))
.Returns(new[] { new FolderItem() });
var activity = ObjectFactory.Container.GetInstance <Query_DocuSign_v2>();
var activityContext = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage(),
},
AuthorizationToken = new AuthorizationToken {
Token = FakeToken.Token
}
};
await activity.Configure(activityContext);
var executionContext = FixtureData.ContainerExecutionContext1();
await activity.Run(activityContext, executionContext);
var payloadStorage = executionContext.PayloadStorage;
var resultManifest = payloadStorage.FirstCrateOrDefault <DocuSignEnvelopeCM_v3>()?.Content;
Assert.IsNotNull(resultManifest, "Run didn't produce crate with expected manifest");
Assert.AreEqual(1, resultManifest.Envelopes.Count, "Run didn't get expected number of envelopes");
}
public async Task PlanService_CanDelete()
{
Guid planId;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var curPlanDO = FixtureData.TestPlanWithStartingSubPlans_ID0();
uow.PlanRepository.Add(curPlanDO);
uow.SaveChanges();
Assert.AreNotEqual(curPlanDO.Id, 0);
planId = curPlanDO.Id;
}
await Plan.Delete(planId);
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var result = uow.PlanRepository.GetById <PlanDO>(planId);
Assert.NotNull(result);
}
}
public async Task Events_Multiplefr8AccountsAssociatedWithSameExternalAccountId_ShouldCheckPlansForAllUsers()
{
//Arrange
var fr8AccountMock = new Mock <IFr8Account>();
fr8AccountMock.Setup(x => x.GetSystemUser())
.Returns(() => new Fr8AccountDO()
{
UserName = "******", EmailAddress = new EmailAddressDO()
});
ObjectFactory.Container.Inject(typeof(IFr8Account), fr8AccountMock.Object);
var externalAccountId = "*****@*****.**";
var plan1 = FixtureData.TestPlanWithSubscribeEvent(FixtureData.TestDockyardAccount1());
var plan2 = FixtureData.TestPlanWithSubscribeEvent(FixtureData.TestDeveloperAccount(), 23);
FixtureData.AddAuthorizationToken(FixtureData.TestDockyardAccount1(), externalAccountId);
FixtureData.AddAuthorizationToken(FixtureData.TestDeveloperAccount(), externalAccountId);
var planNode = new PlanNodeMock(plan1, plan2);
var activity = new ActivityMock(ObjectFactory.GetInstance <IActivity>(), planNode.PlanNodes);
ObjectFactory.Container.Inject(typeof(IPlanNode), planNode);
ObjectFactory.Container.Inject(typeof(IActivity), activity);
//Act
var eventService = new Event();
var curCrateStandardEventReport = ObjectFactory.GetInstance <ICrateManager>().FromDto(FixtureData.CrateDTOForEvents(externalAccountId));
await eventService.ProcessInboundEvents(curCrateStandardEventReport);
Assert.AreEqual(2, activity.Processed);
}
public void Startup()
{
var tokenUrl = "http://token.asana.com/";
var anyUrl = "http://asana.com";
_restClientMock = new Mock <IRestfulServiceClient>();
_restClient = _restClientMock.Object;
_parametersMock = new Mock <IAsanaParameters>();
_parametersMock.Setup(x => x.MinutesBeforeTokenRenewal).Returns("10");
// Url`s setup
_parametersMock.Setup(x => x.AsanaOAuthTokenUrl).Returns(tokenUrl);
_parametersMock.Setup(x => x.WorkspacesUrl).Returns(anyUrl);
_parametersMock.Setup(x => x.UsersInWorkspaceUrl).Returns(anyUrl + "/workspaces");
_parametersMock.Setup(x => x.UsersMeUrl).Returns(anyUrl + "/me");
_parametersMock.Setup(x => x.UsersUrl).Returns(anyUrl + "/users");
_parametersMock.Setup(x => x.TasksUrl).Returns(anyUrl + "/tasks");
_parametersMock.Setup(x => x.StoriesUrl).Returns(anyUrl + "/stories");
_parameters = _parametersMock.Object;
//for token refreshing
_restClientMock.Setup(
x => x.PostAsync <JObject>(It.Is <Uri>(y => y.AbsoluteUri.Equals(tokenUrl)),
It.IsAny <HttpContent>(),
It.IsAny <string>(),
It.IsAny <Dictionary <string, string> >()))
.ReturnsAsync(JObject.Parse(FixtureData.SampleAsanaOauthTokenResponse()));
}
public override void SetUp()
{
base.SetUp();
var hubCommunicatorMock = new Mock <IHubCommunicator>();
ObjectFactory.Container.Inject(hubCommunicatorMock);
ObjectFactory.Container.Inject(hubCommunicatorMock.Object);
FixtureData.ConfigureHubToReturnEmptyPayload();
var statXIntegrationMock = new Mock <IStatXIntegration>();
statXIntegrationMock.Setup(x => x.GetGroups(It.IsAny <StatXAuthDTO>()))
.Returns(
Task.FromResult(new List <StatXGroupDTO>
{
new StatXGroupDTO()
{
Id = Guid.NewGuid().ToString(), Name = "Test Group"
}
}));
statXIntegrationMock.Setup(x => x.GetStatsForGroup(It.IsAny <StatXAuthDTO>(), It.IsAny <string>()))
.Returns(
Task.FromResult(new List <BaseStatDTO>
{
new GeneralStatWithItemsDTO()
{
Id = Guid.NewGuid().ToString(), Title = "Test Stat"
}
}));
ObjectFactory.Container.Inject(statXIntegrationMock);
ObjectFactory.Container.Inject(statXIntegrationMock.Object);
ObjectFactory.Container.Inject(new Mock <IStatXPolling>().Object);
}
private async Task <ActivityDTO> CompleteInitialConfiguration()
{
var configureUrl = GetTerminalConfigureUrl();
var requestDataDTO = FixtureData.MonitorForNewMediaPosted_InitialConfiguration_Fr8DataDTO();
return(await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, requestDataDTO));
}
public async void ProcessController_Will_Return_All_When_Get_Invoked_With_Null()
{
//Arrange
var PlanController = CreatePlanController(_testUserAccount.Id, _testUserAccount.EmailAddress.Address);
for (var i = 0; i < 2; i++)
{
var PlanDto = FixtureData.CreateTestPlanDTO();
// Commented out by yakov.gnusin:
// Do we really need to provider DockyardAccountDO inside PlanDTO?
// We do override DockyardAccountDO in PlanController.Post action.
// switch (i)
// {
// case 0:
// processTemplateDto.DockyardAccount = FixtureData.TestDockyardAccount1();
// break;
// case 1:
// processTemplateDto.DockyardAccount = FixtureData.TestDockyardAccount2();
// break;
// default:
// break;
// }
PlanController.Post(PlanDto);
}
//Act
var actionResult = await PlanController.Get(new PlansGetParams()) as OkNegotiatedContentResult <IList <PlanNoChildrenDTO> >;
//Assert
Assert.NotNull(actionResult);
Assert.AreEqual(2, actionResult.Content.Count());
}
private void SetMockFixtures()
{
MockFixtures = new Mock <DbSet <Fixture> >().SetupData(FixtureData.Data());
MockFixtures.Setup(x => x.Find(It.IsAny <object[]>())).Returns <object[]>(ids => FixtureData.Data().FirstOrDefault(d => d.FixtureId == (int)ids[0]));
MockFixtures.Setup(x => x.FindAsync(It.IsAny <object[]>())).Returns <object[]>(ids => Task.FromResult(FixtureData.Data().FirstOrDefault(d => d.FixtureId == (int)ids[0])));
MockContext.Setup(x => x.Fixtures).Returns(MockFixtures.Object);
}
public async Task ActivityController_Save_WithActionNotExisting_NewActionShouldBeCreated()
{
SubplanDO subplan;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var plan = FixtureData.TestPlan1();
uow.PlanRepository.Add(plan);
subplan = FixtureData.TestSubPlanDO1();
plan.ChildNodes.Add(subplan);
var activityTemplate = FixtureData.TestActivityTemplateDTOV2();
var activityTemplateDO = new ActivityTemplateDO
{
Name = activityTemplate.Name,
Version = activityTemplate.Version,
Terminal = new TerminalDO
{
Name = activityTemplate.TerminalName,
Version = activityTemplate.TerminalVersion,
TerminalStatus = TerminalStatus.Active,
Label = "dummy",
ParticipationState = ParticipationState.Approved,
OperationalState = OperationalState.Active,
Endpoint = "http://localhost:11111"
}
};
uow.ActivityTemplateRepository.Add(activityTemplateDO);
//Arrange
//Add one test action
var activity = FixtureData.TestActivity1();
subplan.ChildNodes.Add(activity);
uow.SaveChanges();
}
//Act
var actualAction = CreateActivityWithId(FixtureData.GetTestGuidById(2));
actualAction.ParentPlanNodeId = subplan.Id;
var controller = ObjectFactory.GetInstance <ActivitiesController>();
var result = (OkNegotiatedContentResult <ActivityDTO>) await controller.Save(actualAction);
var savedAction = result.Content;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
//Assert
Assert.IsNotNull(uow.PlanRepository);
Assert.AreEqual(2, uow.PlanRepository.GetActivityQueryUncached().Count());
//Still there is only one action as the update happened.
var expectedAction = uow.PlanRepository.GetById <ActivityDO>(actualAction.Id);
Assert.IsNotNull(expectedAction);
Assert.AreEqual(actualAction.Id, expectedAction.Id);
}
}
public void CanUpdate()
{
GenerateSeedData();
var template = CreateActivityTemplate(FixtureData.GetTestGuidById(1), CreateTerminal(FixtureData.GetTestGuidById(1)), CreateWebService(234234));
template.Id = Guid.NewGuid();
var terminalService = ObjectFactory.GetInstance <Terminal>();
template.Terminal = terminalService.RegisterOrUpdate(template.Terminal, false);
template.TerminalId = template.Terminal.Id;
var service = ObjectFactory.GetInstance <ActivityTemplate>();
service.RegisterOrUpdate(template);
var storedTemplate = service.GetQuery().First(x => x.Name == template.Name);
CheckIntegrity(storedTemplate);
AreEqual(template, storedTemplate, true);
CheckIfInSyncWithDd(service, 21);
}
public void TestDBMocking()
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var curUser = FixtureData.TestUser1();
curUser.Id = "1";
uow.UserRepository.Add(curUser);
using (var subUow = ObjectFactory.GetInstance <IUnitOfWork>())
{
Assert.AreEqual(0, subUow.UserRepository.GetQuery().Count());
Assert.AreEqual(0, subUow.UserRepository.DBSet.Local.Count());
}
Assert.AreEqual(0, uow.UserRepository.GetQuery().Count());
Assert.AreEqual(1, uow.UserRepository.DBSet.Local.Count());
uow.SaveChanges();
using (var subUow = ObjectFactory.GetInstance <IUnitOfWork>())
{
Assert.AreEqual(1, subUow.UserRepository.GetQuery().Count());
Assert.AreEqual(0, subUow.UserRepository.DBSet.Local.Count());
}
}
}
public async Task <ActivityDTO> AddAndConfigureSaveToFr8Warehouse(PlanDTO plan, int ordering)
{
var activityName = "Save_To_Fr8_Warehouse";
var saveToFr8WarehouseActivity = FixtureData.Save_To_Fr8_Warehouse_InitialConfiguration();
var activityCategoryParam = ActivityCategories.ProcessId.ToString();
var activityTemplates = await _baseHubITest.HttpGetAsync <List <WebServiceActivitySetDTO> >(_baseHubITest.GetHubApiBaseUrl() + "webservices?id=" + activityCategoryParam);
var apmActivityTemplate = activityTemplates
.SelectMany(a => a.Activities)
.Select(x => new ActivityTemplateSummaryDTO
{
Name = x.Name,
Version = x.Version,
TerminalName = x.Terminal.Name,
TerminalVersion = x.Terminal.Version
})
.Single(a => a.Name == activityName);
saveToFr8WarehouseActivity.ActivityTemplate = apmActivityTemplate;
//connect current activity with a plan
var subPlan = plan.SubPlans.FirstOrDefault();
saveToFr8WarehouseActivity.ParentPlanNodeId = subPlan.SubPlanId;
saveToFr8WarehouseActivity.RootPlanNodeId = plan.Id;
saveToFr8WarehouseActivity.Ordering = ordering;
//call initial configuration to server
saveToFr8WarehouseActivity = await _baseHubITest.HttpPostAsync <ActivityDTO, ActivityDTO>(_baseHubITest.GetHubApiBaseUrl() + "activities/save", saveToFr8WarehouseActivity);
//this call is without authtoken
saveToFr8WarehouseActivity = await _baseHubITest.HttpPostAsync <ActivityDTO, ActivityDTO>(_baseHubITest.GetHubApiBaseUrl() + "activities/configure", saveToFr8WarehouseActivity);
return(saveToFr8WarehouseActivity);
}
private ActivityTemplateDO[] GenerateSeedData()
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var terminals = GenerateTerminals(5).ToArray();
foreach (var terminal in terminals)
{
uow.TerminalRepository.Add(terminal);
}
var webServices = new ActivityCategoryDO[5];
for (int i = 1; i <= 5; i++)
{
webServices[i - 1] = CreateWebService(i);
uow.ActivityCategoryRepository.Add(webServices[i - 1]);
}
uow.SaveChanges();
var templates = new ActivityTemplateDO[20];
for (int i = 1; i <= 20; i++)
{
templates[i - 1] = CreateActivityTemplate(FixtureData.GetTestGuidById(i), terminals[i % 5], webServices[i % 5]);
uow.ActivityTemplateRepository.Add(templates[i - 1]);
}
uow.SaveChanges();
return(templates);
}
}
public void CanNotifyUser()
{
Fr8AccountDO user1;
Fr8AccountDO user2;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
user1 = FixtureData.TestUser1();
user1.UserName = "******";
uow.UserRepository.Add(user1);
user2 = FixtureData.TestUser2();
user2.UserName = "******";
uow.UserRepository.Add(user2);
uow.SaveChanges();
}
_provider.SetOverheatingUsers(user1.Id);
var pusherMock = new PusherMock();
ObjectFactory.Container.Inject(typeof(IPusherNotifier), pusherMock);
var rateLimiter = ObjectFactory.GetInstance <IActivityExecutionRateLimitingService>(); // to trigger service initialization
_provider.SetOverheatingResults(new OverheatingUsersUpdateResults(new [] { user2.Id }, new [] { user1.Id }));
_timerService.Tick();
Assert.AreEqual(1, pusherMock.Notifications.Count, "Invalid number of push notifications");
Assert.IsTrue(pusherMock.Notifications[0].Message.Contains("You are running more Activities than your capacity right now."), "Unexpected notification message");
}
public void Run_With_Plan_Payload()
{
var configureUrl = GetTerminalConfigureUrl();
var requestActivityDTO = FixtureData.MonitorFr8Event_InitialConfiguration_ActivityDTO();
var dataDTO = new Fr8DataDTO {
ActivityDTO = requestActivityDTO
};
var responseActivityDTO = HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO).Result;
var runUrl = GetTerminalRunUrl();
dataDTO.ActivityDTO = responseActivityDTO;
AddPayloadCrate(
dataDTO,
new EventReportCM()
{
EventPayload = new CrateStorage()
{
Fr8.Infrastructure.Data.Crates.Crate.FromContent(
"RouteActivatedReport",
RouteActivated()
)
},
EventNames = "RouteActivated"
}
);
AddOperationalStateCrate(dataDTO, new OperationalStateCM());
var runResponse = HttpPostAsync <Fr8DataDTO, PayloadDTO>(runUrl, dataDTO).Result;
Assert.NotNull(runResponse);
}
public async void PlanController_CanDelete()
{
//Arrange
var PlanDto = FixtureData.CreateTestPlanDTO();
var PlanController = CreatePlanController(_testUserAccount.Id, _testUserAccount.EmailAddress.Address);
var postResult = PlanController.Post(PlanDto).Result as OkNegotiatedContentResult <PlanNoChildrenDTO>;
Assert.NotNull(postResult);
//Act
var deleteResult = await PlanController.Delete(postResult.Content.Id) as OkNegotiatedContentResult <int>;
Assert.NotNull(deleteResult);
//Assert
//After delete, if we get the same process template, it should be null
var afterDeleteAttemptResult =
await PlanController.Get(new PlansGetParams()
{
id = postResult.Content.Id
}) as OkNegotiatedContentResult <PlanNoChildrenDTO>;
Assert.IsNull(afterDeleteAttemptResult);
}
public void Setup()
{
StructureMapBootStrapper.ConfigureDependencies(StructureMapBootStrapper.DependencyType.TEST);
ObjectFactory.Configure(cfg => cfg.For <AuthorizationRepTestSupportService>().Use(new AuthorizationRepTestSupportService()).Singleton());
ObjectFactory.Configure(cfg => cfg.For <IAuthorizationTokenRepository>().Use <AuthorizationRepositorySecurePartTester>());
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
uow.TerminalRepository.Add(new TerminalDO
{
TerminalStatus = TerminalStatus.Active,
Id = FixtureData.GetTestGuidById(1),
Version = "v1",
Name = "Test terminal",
Label = "Test",
Secret = Guid.NewGuid().ToString(),
Endpoint = "http://localhost",
OperationalState = OperationalState.Active,
ParticipationState = ParticipationState.Approved
});
uow.SaveChanges();
}
ObjectFactory.GetInstance <AuthorizationRepTestSupportService>().Reset();
}
public IEnumerable <TerminalDO> GenerateTerminals(int count, string prefix = "")
{
for (int id = 1; id <= count; id++)
{
yield return(CreateTerminal(FixtureData.GetTestGuidById(id), prefix));
}
}
private void SetFixtureData(Fixture fixture, FixtureData fixtureData)
{
if (fixtureData.Restitution.HasValue)
fixture.Restitution = anonymousFixtureData.Restitution.Value;
if (fixtureData.Friction.HasValue)
fixture.Friction = anonymousFixtureData.Friction.Value;
if (fixtureData.CollisionCategories.HasValue)
fixture.CollisionCategories = anonymousFixtureData.CollisionCategories.Value;
if (fixtureData.CollidesWith.HasValue)
fixture.CollidesWith = anonymousFixtureData.CollidesWith.Value;
if (fixtureData.IgnoreCCDWith.HasValue)
fixture.IgnoreCCDWith = anonymousFixtureData.IgnoreCCDWith.Value;
if (fixtureData.CollisionGroup.HasValue)
fixture.CollisionGroup = anonymousFixtureData.CollisionGroup.Value;
if (fixtureData.IsSensor.HasValue)
fixture.IsSensor = anonymousFixtureData.IsSensor.Value;
if (fixtureData.AfterCollision != null)
fixture.AfterCollision = anonymousFixtureData.AfterCollision;
if (fixtureData.BeforeCollision != null)
fixture.BeforeCollision = anonymousFixtureData.BeforeCollision;
if (fixtureData.OnCollision != null)
fixture.OnCollision = anonymousFixtureData.OnCollision;
if (fixtureData.OnSeparation != null)
fixture.OnSeparation = anonymousFixtureData.OnSeparation;
}
public BodyConstructor WithShape(string fixtureName, Shape shape)
{
if (fixtureBuilderData.ContainsKey(fixtureName))
{
var newData = new FixtureData { Shape = shape };
fixtureBuilderData.Add(fixtureName, newData);
}
else
fixtureBuilderData[fixtureName].Shape = shape;
return this;
}
public BodyConstructor WithRestitution(string fixtureName, float restitution)
{
if (fixtureBuilderData.ContainsKey(fixtureName))
{
var newData = new FixtureData { Restitution = restitution };
fixtureBuilderData.Add(fixtureName, newData);
}
else
fixtureBuilderData[fixtureName].Restitution = restitution;
return this;
}
public BodyConstructor WithOnSeparation(string fixtureName, OnSeparationEventHandler handler)
{
if (fixtureBuilderData.ContainsKey(fixtureName))
{
var newData = new FixtureData { OnSeparation = handler };
fixtureBuilderData.Add(fixtureName, newData);
}
else
fixtureBuilderData[fixtureName].OnSeparation = handler;
return this;
}
public BodyConstructor IgnoresCCDWith(string fixtureName, Category category)
{
if (fixtureBuilderData.ContainsKey(fixtureName))
{
var newData = new FixtureData { IgnoreCCDWith = category };
fixtureBuilderData.Add(fixtureName, newData);
}
else
fixtureBuilderData[fixtureName].IgnoreCCDWith = category;
return this;
}
public BodyConstructor WithCollisionCategories(string fixtureName, Category category)
{
if (fixtureBuilderData.ContainsKey(fixtureName))
{
var newData = new FixtureData { CollisionCategories = category };
fixtureBuilderData.Add(fixtureName, newData);
}
else
fixtureBuilderData[fixtureName].CollisionCategories = category;
return this;
}
public BodyConstructor WithCollisionGroup(string fixtureName, short collisionGroup)
{
if (fixtureBuilderData.ContainsKey(fixtureName))
{
var newData = new FixtureData { CollisionGroup = collisionGroup };
fixtureBuilderData.Add(fixtureName, newData);
}
else
fixtureBuilderData[fixtureName].CollisionGroup = collisionGroup;
return this;
}
public BodyConstructor AsSensor(string fixtureName)
{
if (fixtureBuilderData.ContainsKey(fixtureName))
{
var newData = new FixtureData { IsSensor = true };
fixtureBuilderData.Add(fixtureName, newData);
}
else
fixtureBuilderData[fixtureName].IsSensor = true;
return this;
}
