public void ShouldSendRentalViewModelMessageWithContinueRentalPropertyIfDriverHasActiveRental()
{
//assign
var driverId = Guid.NewGuid();
var driverViewModel = new DriverViewModel()
{
Id = driverId
};
var activeRentalDto = new RentalDTO();
_rentalServiceMock.GetActiveRentalForDriver(driverId).Returns(activeRentalDto);
var activeRentalViewModel = new RentalViewModel();
_rentalViewModelMapperMock.Map(activeRentalDto).Returns(activeRentalViewModel);
//act
var sut = new RentCarViewModel(_carServiceMock, _rentalServiceMock, _carViewModelMapperMock, _rentalViewModelMapperMock, _messengerServiceMock);
sut.AssignLoggedInDriver(driverViewModel);
//assert
_messengerServiceMock.Received().Send(Arg.Is <RentalViewModelMessage>(message => message.RentalViewModel == activeRentalViewModel && message.MessageType == RentalViewModelMessageType.ContinueRental));
_messengerServiceMock.Received().Send(Arg.Is <NotificationMessage>(message => message.Notification == "Start Car Rental"));
}
public void ShouldShowSummaryAndStopTimerWhenReturnCar()
{
var elapsedTimer = Substitute.For <ITimer>();
var elapsedCostTimer = Substitute.For <ITimer>();
_timerFactoryMock.CreateTimer().Returns(elapsedTimer, elapsedCostTimer);
var rentalId = Guid.NewGuid();
_rentalServiceMock.GetRental(rentalId).Returns(new RentalDTO {
Total = 10
});
var sut = new ActiveRentalSessionViewModel(_timerFactoryMock, _rentalServiceMock, _dialogServiceMock,
_messengerServiceMock)
{
CurrentRental = new RentalViewModel
{
RentalId = rentalId,
PricePerMinute = "2.5"
}
};
sut.StopRentalCommand.Execute(null);
_rentalServiceMock.Received().ReturnCar(rentalId, Arg.Any <DateTime>());
Assert.Null(sut.ErrorString);
_messengerServiceMock.Received()
.Send(Arg.Is <RefreshRentalsMessage>(m => m.Notification == "Rental Stopped!"));
Assert.True(sut.IsRentalStopped);
elapsedCostTimer.Received().Stop();
elapsedTimer.Received().Stop();
_rentalServiceMock.Received().GetRental(rentalId);
_dialogServiceMock.Received().ShowMessage(Arg.Any <string>());
}
public void ShouldSendNavigateToAdminViewMessage()
{
var sut = new LoginViewModel(_driverServiceMock, _driverViewModelMapperMock, _messengerServiceMock);
sut.AdminLoginCommand.Execute(null);
_messengerServiceMock.Received()
.Send(Arg.Is <NotificationMessage>(m => m.Notification == "GoToAdminMainView"));
}
public void ShouldSendLogoutMessage()
{
var sut = new MainViewModel(_messengerServiceMock);
sut.LogoutCommand.Execute(null);
_messengerServiceMock.Received().Send(Arg.Is <NotificationMessage>(m => m.Notification == "Logout"));
}
public async Task SendNotification_WhenAllPropertiesSet_AddsMessageToTopic()
{
// Arrange
IDictionary <string, string> topicMessageProperties = null;
IMessengerService messengerService = CreateMessengerService();
await messengerService.SendToTopic(Arg.Any <string>(), Arg.Any <JobNotification>(), Arg.Do <IDictionary <string, string> >(p => topicMessageProperties = p));
ILogger logger = CreateLogger();
INotificationService notificationService = CreateNotificationService(messengerService, logger);
JobNotification jobNotification = CreateJobNotification();
// Act
await notificationService.SendNotification(jobNotification);
// Assert
await messengerService
.Received(1)
.SendToTopic(Arg.Is(ServiceBusConstants.TopicNames.JobNotifications), Arg.Is(jobNotification), Arg.Any <IDictionary <string, string> >());
topicMessageProperties.Should().NotBeNull();
topicMessageProperties["jobId"].Should().Be(jobNotification.JobId, "JobId");
topicMessageProperties["jobType"].Should().Be(jobNotification.JobType, "JobType");
topicMessageProperties["entityId"].Should().Be(jobNotification.Trigger.EntityId, "EntityId");
topicMessageProperties["specificationId"].Should().Be(jobNotification.SpecificationId, "SpecficationId");
topicMessageProperties["parentJobId"].Should().Be(jobNotification.ParentJobId, "ParentJobId");
logger
.Received(1)
.Information(Arg.Is("Sent notification for job with id '{JobId}' of type '{JobType}' for entity '{EntityType}' with id '{EntityId} and status '{CompletionStatus}"), Arg.Is(jobNotification.JobId), Arg.Is(jobNotification.JobType), Arg.Is(jobNotification.Trigger.EntityType), Arg.Is(jobNotification.Trigger.EntityId), Arg.Is(jobNotification.CompletionStatus));
}
public async Task Run_WhenSmokeTestRunAgainstSmokeMessageInDevelopment_SmokeResponseSentToQueue()
{
GivenSmokeTestCreatedInDevelopment();
string expectedInvocationId = NewRandomString();
await WhenMessageReceivedBySmokeTest(expectedInvocationId);
await _messengerService
.Received(1)
.SendToQueue(expectedInvocationId,
Arg.Is <SmokeResponse>(_ => _.InvocationId == expectedInvocationId &&
_.BuildNumber == _expectedFileVersion),
Arg.Is <Dictionary <string, string> >(_ =>
_["listener"] == SmokeFunction.FunctionName));
}
public async Task WaitForJobsToCompleteWithJobsFailed_ReturnsFalse(bool useServiceBus)
{
IJobsApiClient jobsApiClient = Substitute.For <IJobsApiClient>();
JobManagementResiliencePolicies policies = new JobManagementResiliencePolicies
{
JobsApiClient = Policy.NoOpAsync()
};
IMessengerService messengerService = null;
if (useServiceBus)
{
messengerService = Substitute.For <IMessengerService, IServiceBusService>();
}
else
{
messengerService = Substitute.For <IMessengerService, IQueueService>();
}
ILogger logger = Substitute.For <ILogger>();
JobManagement jobManagement = new JobManagement(jobsApiClient, logger, policies, messengerService);
string jobId = "3456";
jobsApiClient
.GetLatestJobsForSpecification("specificationId", Arg.Is <string[]>(_ => _.Single() == "PopulateScopedProviders"))
.Returns(new ApiResponse <IDictionary <string, JobSummary> >(HttpStatusCode.OK, new Dictionary <string, JobSummary> {
{ string.Empty, new JobSummary {
RunningStatus = RunningStatus.Completed, CompletionStatus = CompletionStatus.Failed, JobId = jobId
} }
}));
messengerService
.ReceiveMessage("topic/Subscriptions/correlationId", Arg.Any <Predicate <JobSummary> >(), TimeSpan.FromMilliseconds(600000))
.Returns(new JobSummary
{
CompletionStatus = CompletionStatus.Failed
});
//Act
bool jobsComplete = await jobManagement.QueueJobAndWait(async() => await Task.Run(() => { return(true); }), "PopulateScopedProviders", "specificationId", "correlationId", "topic");
//Assert
if (useServiceBus)
{
await((IServiceBusService)messengerService)
.Received(1)
.CreateSubscription("topic", "correlationId", Arg.Is <TimeSpan>(_ => _.Days == 1));
await messengerService
.Received(1)
.ReceiveMessage("topic/Subscriptions/correlationId", Arg.Any <Predicate <JobSummary> >(), TimeSpan.FromMilliseconds(600000));
}
jobsComplete
.Should()
.BeFalse();
}
public async Task QueueCsvGenerationMessages_GivenSpecificationSummariesFoundAndHasNewResults_CreatesNewMessage()
{
//Arrange
IEnumerable <SpecificationSummary> specificationSummaries = new[]
{
new SpecificationSummary {
Id = "spec-1"
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationSummaries()
.Returns(specificationSummaries);
ICalculationResultsRepository calculationResultsRepository = CreateResultsRepository();
calculationResultsRepository
.CheckHasNewResultsForSpecificationIdAndTimePeriod(
Arg.Is("spec-1"),
Arg.Any <DateTimeOffset>(),
Arg.Any <DateTimeOffset>())
.Returns(true);
ILogger logger = CreateLogger();
IMessengerService messengerService = CreateMessengerService();
ResultsService resultsService = CreateResultsService(
logger,
specificationsRepository: specificationsRepository,
resultsRepository: calculationResultsRepository,
messengerService: messengerService);
//Act
await resultsService.QueueCsvGenerationMessages();
//Assert
await
messengerService
.Received(1)
.SendToQueue(
Arg.Is(ServiceBusConstants.QueueNames.CalculationResultsCsvGeneration),
Arg.Is(string.Empty),
Arg.Is <Dictionary <string, string> >(m => m["specification-id"] == "spec-1"), Arg.Is(false));
logger
.Received()
.Information($"Found new calculation results for specification id 'spec-1'");
}
public void ShouldExecuteRegisterCommandWhenDriverIsValid()
{
var sut = new RegisterDriverViewModel(_driverServiceMock, _driverViewModelMapperMock,
_messengerServiceMock);
sut.CurrentDriver.FirstName = "Valid";
sut.CurrentDriver.LastName = "Valid";
sut.CurrentDriver.LicenseNumber = "Valid";
sut.RegisterDriverCommand.Execute(null);
_driverViewModelMapperMock.Received().Map(sut.CurrentDriver);
_driverServiceMock.Received().CreateDriver(Arg.Any <DriverDTO>());
_messengerServiceMock.Received()
.Send(Arg.Is <NotificationMessage>(m => m.Notification == "Close Register Window"));
}
public async Task ReIndexAllocationNotificationFeeds_GivenRequest_AddsServiceBusMessage()
{
//Arrange
string userId = "1234";
string userName = "******";
ClaimsPrincipal principle = new ClaimsPrincipal(new[]
{
new ClaimsIdentity(new [] { new Claim(ClaimTypes.Sid, userId), new Claim(ClaimTypes.Name, userName) })
});
HttpContext context = Substitute.For <HttpContext>();
context
.User
.Returns(principle);
HttpRequest request = Substitute.For <HttpRequest>();
request
.HttpContext
.Returns(context);
IMessengerService messengerService = CreateMessengerService();
PublishedResultsService resultsService = CreateResultsService(messengerService: messengerService);
//Act
IActionResult actionResult = await resultsService.ReIndexAllocationNotificationFeeds(request);
//Assert
actionResult
.Should()
.BeAssignableTo <NoContentResult>();
await
messengerService
.Received(1)
.SendToQueue(
Arg.Is(ServiceBusConstants.QueueNames.ReIndexAllocationNotificationFeedIndex),
Arg.Is(string.Empty),
Arg.Is <IDictionary <string, string> >(m => m["user-id"] == userId && m["user-name"] == userName));
}
async public Task SaveDefinition_GivenValidYamlAndDoesContainsExistingItemWithModelUpdates_ThenAddsMessageToTopicAndReturnsOK()
{
//Arrange
string yaml = CreateRawDefinition();
string definitionId = "9183";
byte[] byteArray = Encoding.UTF8.GetBytes(yaml);
MemoryStream stream = new MemoryStream(byteArray);
IHeaderDictionary headerDictionary = new HeaderDictionary();
headerDictionary
.Add("yaml-file", new StringValues(yamlFile));
HttpRequest request = Substitute.For <HttpRequest>();
request
.Headers
.Returns(headerDictionary);
request
.Body
.Returns(stream);
ILogger logger = CreateLogger();
HttpStatusCode statusCode = HttpStatusCode.Created;
DatasetDefinition existingDatasetDefinition = new DatasetDefinition
{
Id = definitionId
};
IDatasetRepository datasetsRepository = CreateDataSetsRepository();
datasetsRepository
.SaveDefinition(Arg.Any <DatasetDefinition>())
.Returns(statusCode);
datasetsRepository
.GetDatasetDefinition(Arg.Is(definitionId))
.Returns(existingDatasetDefinition);
byte[] excelAsBytes = new byte[100];
IExcelWriter <DatasetDefinition> excelWriter = CreateExcelWriter();
excelWriter
.Write(Arg.Any <DatasetDefinition>())
.Returns(excelAsBytes);
ICloudBlob blob = Substitute.For <ICloudBlob>();
IBlobClient blobClient = CreateBlobClient();
blobClient
.GetBlockBlobReference(Arg.Any <string>())
.Returns(blob);
DatasetDefinitionChanges datasetDefinitionChanges = new DatasetDefinitionChanges();
datasetDefinitionChanges.DefinitionChanges.Add(DefinitionChangeType.DefinitionName);
IDefinitionChangesDetectionService definitionChangesDetectionService = CreateChangesDetectionService();
definitionChangesDetectionService
.DetectChanges(Arg.Any <DatasetDefinition>(), Arg.Is(existingDatasetDefinition))
.Returns(datasetDefinitionChanges);
IMessengerService messengerService = CreateMessengerService();
DefinitionsService service = CreateDefinitionsService(
logger,
datasetsRepository,
excelWriter: excelWriter,
blobClient: blobClient,
definitionChangesDetectionService: definitionChangesDetectionService,
messengerService: messengerService);
//Act
IActionResult result = await service.SaveDefinition(request);
//Assert
result
.Should()
.BeOfType <OkResult>();
await
messengerService
.Received(1)
.SendToTopic(
Arg.Is(ServiceBusConstants.TopicNames.DataDefinitionChanges),
Arg.Is(datasetDefinitionChanges),
Arg.Any <IDictionary <string, string> >());
}
public async Task EditPolicy_WhenValidModelAndUpdateCosmosAndIsASubPolicy_SendsMessageAndReturnsOK()
{
// Arrange
PolicyEditModel policyEditModel = new PolicyEditModel
{
SpecificationId = SpecificationId,
Name = "new policy name",
Description = "new policy description",
ParentPolicyId = "parent-policy-id"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "policyId", new StringValues(PolicyId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[]
{
new Policy
{
Id = "parent-policy-id",
Name = "policy name",
SubPolicies = new[] { new Policy {
Id = PolicyId, Name = PolicyName
} }
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
IMessengerService messengerService = CreateMessengerService();
ISearchRepository <SpecificationIndex> mockSearchRepository = CreateSearchRepository();
mockSearchRepository
.Index(Arg.Any <IEnumerable <SpecificationIndex> >())
.Returns(new List <IndexError>());
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
Policy editedNewSubpolicy = newSpecVersion.Policies.First().SubPolicies.First();
editedNewSubpolicy.Name = policyEditModel.Name;
newSpecVersion.PublishStatus = PublishStatus.Updated;
IVersionRepository <SpecificationVersion> mockVersionRepository = CreateVersionRepository();
mockVersionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
messengerService: messengerService, searchRepository: mockSearchRepository, specificationVersionRepository: mockVersionRepository);
// Act
IActionResult result = await specificationsService.EditPolicy(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>()
.Which
.Value
.Should()
.BeOfType <Policy>()
.Which
.Description
.Should()
.Be("new policy description");
await
messengerService
.Received(1)
.SendToTopic(Arg.Is(ServiceBusConstants.TopicNames.EditSpecification),
Arg.Is <SpecificationVersionComparisonModel>(
m => m.Id == SpecificationId
), Arg.Any <IDictionary <string, string> >(), Arg.Is(true));
await
mockSearchRepository
.Received(1)
.Index(Arg.Is <IEnumerable <SpecificationIndex> >(
m => m.First().Id == SpecificationId &&
m.First().Status == newSpecVersion.PublishStatus.ToString()
));
}
public async Task EditSpecification_GivenChangesAndSpecContainsPoliciesAndCalculations_UpdatesSearchAndSendsMessage()
{
//Arrange
SpecificationEditModel specificationEditModel = new SpecificationEditModel
{
FundingPeriodId = "fp10",
Name = "new spec name",
FundingStreamIds = new[] { "fs11" }
};
Period fundingPeriod = new Period
{
Id = "fp10",
Name = "fp 10"
};
IEnumerable <FundingStream> fundingStreams = new[]
{
new FundingStream {
AllocationLines = new List <AllocationLine>
{
new AllocationLine {
Id = "al1", Name = "al2"
}
}
}
};
string json = JsonConvert.SerializeObject(specificationEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
ILogger logger = CreateLogger();
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[]
{
new Policy
{
Calculations = new[]
{
new Calculation {
AllocationLine = new AllocationLine {
Id = "oldallocationlineid"
}
}
}
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.GetPeriodById(Arg.Is(fundingPeriod.Id))
.Returns(fundingPeriod);
specificationsRepository
.GetFundingStreams(Arg.Any <Expression <Func <FundingStream, bool> > >())
.Returns(fundingStreams);
specificationsRepository
.UpdateSpecification(Arg.Any <Specification>())
.Returns(HttpStatusCode.OK);
ISearchRepository <SpecificationIndex> searchRepository = CreateSearchRepository();
ICacheProvider cacheProvider = CreateCacheProvider();
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Name = specificationEditModel.Name;
newSpecVersion.FundingPeriod.Id = specificationEditModel.FundingPeriodId;
newSpecVersion.FundingStreams = new[] { new FundingStream {
Id = "fs11"
} };
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(
logs: logger, specificationsRepository: specificationsRepository, searchRepository: searchRepository,
cacheProvider: cacheProvider, messengerService: messengerService, specificationVersionRepository: versionRepository);
//Act
IActionResult result = await service.EditSpecification(request);
//Arrange
await
searchRepository
.Received(1)
.Index(Arg.Is <IEnumerable <SpecificationIndex> >(
m => m.First().Id == SpecificationId &&
m.First().Name == "new spec name" &&
m.First().FundingPeriodId == "fp10" &&
m.First().FundingStreamIds.Count() == 1
));
await
cacheProvider
.Received(1)
.RemoveAsync <SpecificationSummary>(Arg.Is($"{CacheKeys.SpecificationSummaryById}{specification.Id}"));
await
messengerService
.Received(1)
.SendToTopic(Arg.Is(ServiceBusConstants.TopicNames.EditSpecification),
Arg.Is <SpecificationVersionComparisonModel>(
m => m.Id == SpecificationId &&
m.Current.Name == "new spec name" &&
m.Previous.Name == "Spec name"
), Arg.Any <IDictionary <string, string> >(), Arg.Is(true));
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
public async Task EditCalculation_WhenCalcInSubPolicyButNotTopLevelPolicyUpdatesCosmos_SendsMessageReturnsOk()
{
// Arrange
CalculationEditModel policyEditModel = new CalculationEditModel
{
Name = "new calc name",
CalculationType = CalculationType.Funding,
Description = "test description",
PolicyId = "policy-id-2"
};
string json = JsonConvert.SerializeObject(policyEditModel);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
HttpContext context = Substitute.For <HttpContext>();
HttpRequest request = Substitute.For <HttpRequest>();
IQueryCollection queryStringValues = new QueryCollection(new Dictionary <string, StringValues>
{
{ "specificationId", new StringValues(SpecificationId) },
{ "calculationId", new StringValues(CalculationId) },
});
request
.Query
.Returns(queryStringValues);
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
Specification specification = CreateSpecification();
specification
.Current
.Policies = new[] {
new Policy {
Id = PolicyId, Name = PolicyName, SubPolicies = new[] { new Policy {
Id = "policy-id-2", Name = "sub-policy", Calculations = new[] { new Calculation {
Id = CalculationId, Name = "Old name"
} }
} }
}
};
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
ICacheProvider cacheProvider = CreateCacheProvider();
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.Policies.First().SubPolicies.First().Calculations = new[] { new Calculation {
Id = CalculationId, Name = "new calc name"
} };
IVersionRepository <SpecificationVersion> versionRepository = CreateVersionRepository();
versionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService specificationsService = CreateService(specificationsRepository: specificationsRepository,
cacheProvider: cacheProvider, messengerService: messengerService, specificationVersionRepository: versionRepository);
// Act
IActionResult result = await specificationsService.EditCalculation(request);
// Assert
result
.Should()
.BeOfType <OkObjectResult>();
specification
.Current
.Policies
.First()
.SubPolicies
.First()
.Calculations
.First()
.Name
.Should()
.Be("new calc name");
await
messengerService
.Received(1)
.SendToTopic(Arg.Is(ServiceBusConstants.TopicNames.EditCalculation),
Arg.Is <CalculationVersionComparisonModel>(
m => m.CalculationId == CalculationId &&
m.SpecificationId == SpecificationId
), Arg.Any <IDictionary <string, string> >());
await
versionRepository
.Received(1)
.SaveVersion(Arg.Is(newSpecVersion));
}
public async Task CreateCalculation_GivenValidModelForSubPolicyAndSubPolicyFoundAndUpdated_ReturnsOK()
{
//Arrange
AllocationLine allocationLine = new AllocationLine
{
Id = "02a6eeaf-e1a0-476e-9cf9-8aa5d9129345",
Name = "test alloctaion"
};
List <FundingStream> fundingStreams = new List <FundingStream>();
FundingStream fundingStream = new FundingStream
{
AllocationLines = new List <AllocationLine>
{
allocationLine
},
Id = FundingStreamId
};
fundingStreams.Add(fundingStream);
Policy policy = new Policy
{
Id = PolicyId,
Name = PolicyName,
};
Specification specification = CreateSpecification();
specification.Current.Policies = new[] { policy };
specification.Current.FundingStreams = new List <Reference>()
{
new Reference {
Id = FundingStreamId
}
};
CalculationCreateModel model = new CalculationCreateModel
{
SpecificationId = SpecificationId,
PolicyId = PolicyId,
AllocationLineId = AllocationLineId
};
string json = JsonConvert.SerializeObject(model);
byte[] byteArray = Encoding.UTF8.GetBytes(json);
MemoryStream stream = new MemoryStream(byteArray);
ClaimsPrincipal principle = new ClaimsPrincipal(new[]
{
new ClaimsIdentity(new [] { new Claim(ClaimTypes.Sid, UserId), new Claim(ClaimTypes.Name, Username) })
});
HttpContext context = Substitute.For <HttpContext>();
context
.User
.Returns(principle);
HttpRequest request = Substitute.For <HttpRequest>();
request
.Body
.Returns(stream);
request
.HttpContext
.Returns(context);
IHeaderDictionary headerDictionary = new HeaderDictionary();
headerDictionary
.Add("sfa-correlationId", new StringValues(SfaCorrelationId));
request
.Headers
.Returns(headerDictionary);
ILogger logger = CreateLogger();
ISpecificationsRepository specificationsRepository = CreateSpecificationsRepository();
specificationsRepository
.GetSpecificationById(Arg.Is(SpecificationId))
.Returns(specification);
specificationsRepository
.GetFundingStreams(Arg.Any <Expression <Func <FundingStream, bool> > >())
.Returns(fundingStreams);
specificationsRepository
.UpdateSpecification(Arg.Is(specification))
.Returns(HttpStatusCode.OK);
Calculation calculation = new Calculation
{
AllocationLine = new Reference()
};
IMapper mapper = CreateMapper();
mapper
.Map <Calculation>(Arg.Any <CalculationCreateModel>())
.Returns(calculation);
IMessengerService messengerService = CreateMessengerService();
SpecificationVersion newSpecVersion = specification.Current.Clone() as SpecificationVersion;
newSpecVersion.PublishStatus = PublishStatus.Updated;
newSpecVersion.Version = 2;
IVersionRepository <SpecificationVersion> mockVersionRepository = CreateVersionRepository();
mockVersionRepository
.CreateVersion(Arg.Any <SpecificationVersion>(), Arg.Any <SpecificationVersion>())
.Returns(newSpecVersion);
SpecificationsService service = CreateService(logs: logger, specificationsRepository: specificationsRepository,
mapper: mapper, messengerService: messengerService, specificationVersionRepository: mockVersionRepository);
//Act
IActionResult result = await service.CreateCalculation(request);
//Assert
result
.Should()
.BeOfType <OkObjectResult>();
await
messengerService
.Received(1)
.SendToQueue(Arg.Is("calc-events-create-draft"),
Arg.Is <Models.Calcs.Calculation>(m =>
m.CalculationSpecification.Id == calculation.Id &&
m.CalculationSpecification.Name == calculation.Name &&
m.Name == calculation.Name &&
!string.IsNullOrEmpty(m.Id) &&
m.AllocationLine.Id == allocationLine.Id &&
m.AllocationLine.Name == allocationLine.Name),
Arg.Is <IDictionary <string, string> >(m =>
m["user-id"] == UserId &&
m["user-name"] == Username &&
m["sfa-correlationId"] == SfaCorrelationId));
}
private static void CheckServiceBusCalls(IMessengerService messengerService, string uniqueId, string queueName, string topicName, string entityPathBase, bool useSession)
{
if (!IsDevelopment && topicName != null)
{
if (useSession)
{
messengerService
.Received(1)
.SendToTopic(topicName,
uniqueId,
Arg.Any <Dictionary <string, string> >(),
sessionId: uniqueId);
}
else
{
messengerService
.Received(1)
.SendToTopic(topicName,
uniqueId,
Arg.Any <Dictionary <string, string> >());
}
}
else
{
if (useSession)
{
messengerService
.Received(1)
.SendToQueue(queueName,
uniqueId,
Arg.Any <Dictionary <string, string> >(),
sessionId: uniqueId);
}
else
{
messengerService
.Received(1)
.SendToQueue(queueName,
uniqueId,
Arg.Any <Dictionary <string, string> >());
}
}
if (!IsDevelopment)
{
((IServiceBusService)messengerService)
.Received(1)
.CreateSubscription("smoketest", uniqueId, Arg.Is <TimeSpan>(_ => _.Days == 1));
((IServiceBusService)messengerService)
.Received(1)
.DeleteSubscription("smoketest", uniqueId);
}
else
{
((IQueueService)messengerService)
.Received(1)
.DeleteQueue(uniqueId);
}
messengerService
.Received(1)
.ReceiveMessage <SmokeResponse>(entityPathBase,
Arg.Any <Predicate <SmokeResponse> >(),
_timeout);
}
