public async Task ThenItShouldUpsertProviderWhenMessageReceived()
{
var cancellationToken = new CancellationToken();
var message = new ConsumedMessage <string, Provider>
{
Topic = "topic-name",
Partition = 91,
Offset = 28379,
Key = "12345678",
Value = new Provider(),
};
var expectedFeProvider = new FeProvider();
_mapperMock.Setup(m => m.Map <FeProvider>(It.IsAny <Provider>()))
.Returns(expectedFeProvider);
Func <ConsumedMessage <string, Provider>, CancellationToken, Task> messageHandler = null;
_ukrlpConsumerMock.Setup(c => c.SetMessageHandler(It.IsAny <Func <ConsumedMessage <string, Provider>, CancellationToken, Task> >()))
.Callback((Func <ConsumedMessage <string, Provider>, CancellationToken, Task> handler) => { messageHandler = handler; });
_worker = new Worker(
_ukrlpConsumerMock.Object,
_providerManagerMock.Object,
_options,
_mapperMock.Object,
_loggerMock.Object);
var workerTask = _worker.StartAsync(CancellationToken.None);
await messageHandler.Invoke(message, cancellationToken);
await workerTask;
_providerManagerMock.Verify(m => m.UpsertProvider(expectedFeProvider, cancellationToken));
}
public async Task AndProviderFoundThenItShouldReturnProvider()
{
var expected = new FeProvider();
_feProviderRepositoryMock.Setup(repo => repo.RetrieveProviderAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(expected);
var actual = await _manager.RetrieveAsync(12345678, CancellationToken.None);
Assert.AreSame(expected, actual);
}
public void AndUkprnIsNot8DigitsThenItShouldThrowAnInvalidRequestException(int ukprn)
{
var provider = new FeProvider
{
Ukprn = ukprn,
};
var actual = Assert.ThrowsAsync <InvalidRequestException>(async() =>
await _manager.UpsertProvider(provider, CancellationToken.None));
Assert.AreEqual("UKPRN must be an 8 digit number", actual.Message);
}
public async Task ThenItShouldMapResultsToApiFormat()
{
var source = new FeProvider();
_feProviderManagerMock.Setup(manager => manager.RetrieveAsync(It.IsAny <int>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(source);
await _controller.GetAsync("12345678", CancellationToken.None);
_mapperMock.Verify(mapper => mapper.Map <ApiFeProvider>(source),
Times.Once);
}
public async Task ThenItShouldUpsertProviderInRepository()
{
var cancellationToken = new CancellationToken();
var provider = new FeProvider
{
Ukprn = 12345678,
};
await _manager.UpsertProvider(provider, cancellationToken);
_feProviderRepositoryMock.Verify(repo => repo.UpsertProviderAsync(provider, cancellationToken),
Times.Once);
}
public async Task AndTheProviderExistsThenItShouldReturnProvider(FeProvider provider)
{
_feProviders.Add(provider);
var actual = await _repository.RetrieveProviderAsync(provider.Ukprn, CancellationToken.None);
Assert.AreEqual(provider.Ukprn, actual.Ukprn);
Assert.AreEqual(provider.LegalName, actual.LegalName);
Assert.AreEqual(provider.Status, actual.Status);
Assert.AreEqual(provider.PrimaryTradingName, actual.PrimaryTradingName);
Assert.AreEqual(provider.CompanyRegistrationNumber, actual.CompanyRegistrationNumber);
Assert.AreEqual(provider.LegalAddressLine1, actual.LegalAddressLine1);
Assert.AreEqual(provider.LegalAddressLine2, actual.LegalAddressLine2);
Assert.AreEqual(provider.LegalAddressLine3, actual.LegalAddressLine3);
Assert.AreEqual(provider.LegalAddressLine4, actual.LegalAddressLine4);
Assert.AreEqual(provider.LegalAddressTown, actual.LegalAddressTown);
Assert.AreEqual(provider.LegalAddressCounty, actual.LegalAddressCounty);
Assert.AreEqual(provider.LegalAddressPostcode, actual.LegalAddressPostcode);
}
public async Task <bool> UpsertProviderAsync(FeProvider provider, CancellationToken cancellationToken)
{
bool created;
var existingProvider = await _dbContext.FeProviders
.Where(x => x.Ukprn == provider.Ukprn)
.SingleOrDefaultAsync(cancellationToken);
if (existingProvider == null)
{
_dbContext.FeProviders.Add(provider);
created = true;
}
else
{
existingProvider.UpdateFrom(provider);
created = false;
}
await _dbContext.CommitAsync(cancellationToken);
return(created);
}
public async Task UpsertProvider(FeProvider provider, CancellationToken cancellationToken)
{
if (provider.Ukprn < 10000000 || provider.Ukprn > 99999999)
{
throw new InvalidRequestException("UKPRN must be an 8 digit number");
}
var location = !string.IsNullOrEmpty(provider.LegalAddressPostcode)
? await _locationService.GetByPostcodeAsync(provider.LegalAddressPostcode, cancellationToken)
: null;
if (location != null)
{
_logger.LogInformation("Setting region for provider {UKPRN} to {Region} based on postcode {Postcode}",
provider.Ukprn, location.Region, provider.LegalAddressPostcode);
provider.LegalAddressRegion = location.Region;
}
var created = await _feProviderRepository.UpsertProviderAsync(provider, cancellationToken);
_logger.LogInformation("Upsert provider {UKPRN} resulted in the provider being {UpsertAction}",
provider.Ukprn, created ? "CREATED" : "UPDATED");
}
public async Task AndAnExistingProviderDoesExistWithUkprnThenItShouldUpdateProvider(FeProvider updatedProvider, FeProvider existingProvider)
{
existingProvider.Ukprn = updatedProvider.Ukprn;
_feProviders.Add(existingProvider);
var mockDbSet = _feProviders.AsQueryable().BuildMockDbSet();
_dbContext.Setup(db => db.FeProviders)
.Returns(mockDbSet.Object);
var cancellationToken = new CancellationToken();
var created = await _repository.UpsertProviderAsync(updatedProvider, cancellationToken);
Assert.IsFalse(created);
Assert.AreEqual(updatedProvider.LegalName, existingProvider.LegalName);
Assert.AreEqual(updatedProvider.Status, existingProvider.Status);
Assert.AreEqual(updatedProvider.PrimaryTradingName, existingProvider.PrimaryTradingName);
Assert.AreEqual(updatedProvider.CompanyRegistrationNumber, existingProvider.CompanyRegistrationNumber);
Assert.AreEqual(updatedProvider.LegalAddressLine1, existingProvider.LegalAddressLine1);
Assert.AreEqual(updatedProvider.LegalAddressLine2, existingProvider.LegalAddressLine2);
Assert.AreEqual(updatedProvider.LegalAddressLine3, existingProvider.LegalAddressLine3);
Assert.AreEqual(updatedProvider.LegalAddressLine4, existingProvider.LegalAddressLine4);
Assert.AreEqual(updatedProvider.LegalAddressTown, existingProvider.LegalAddressTown);
Assert.AreEqual(updatedProvider.LegalAddressCounty, existingProvider.LegalAddressCounty);
Assert.AreEqual(updatedProvider.LegalAddressPostcode, existingProvider.LegalAddressPostcode);
_dbContext.Verify(context => context.CommitAsync(cancellationToken), Times.Once);
}
public async Task AndAnExistingProviderDoesNotExistWithUkprnThenItShouldCreateProvider(FeProvider provider)
{
var mockDbSet = _feProviders.AsQueryable().BuildMockDbSet();
_dbContext.Setup(db => db.FeProviders)
.Returns(mockDbSet.Object);
var cancellationToken = new CancellationToken();
var created = await _repository.UpsertProviderAsync(provider, cancellationToken);
Assert.IsTrue(created);
mockDbSet.Verify(dbSet => dbSet.Add(provider), Times.Once);
_dbContext.Verify(context => context.CommitAsync(cancellationToken), Times.Once);
}
