public async Task ThrowsNotFoundException_WhenSmpConfigurationDoesntExist()
{
SmpConfigurationDetail fixture = CreateFixture();
// Act / Assert
await Assert.ThrowsAsync <NotFoundException>(() => SmpConfigurationService.UpdateAsync(int.MaxValue, fixture));
}
private void ValidateSmpConfiguration(SmpConfigurationDetail smpConfiguration)
{
EnsureArg.IsTrue(smpConfiguration.EncryptAlgorithmKeySize >= 0, nameof(smpConfiguration.EncryptAlgorithmKeySize));
EnsureArg.IsNotNullOrWhiteSpace(smpConfiguration.PartyRole, nameof(smpConfiguration.PartyRole));
EnsureArg.IsNotNullOrWhiteSpace(smpConfiguration.PartyType, nameof(smpConfiguration.PartyType));
EnsureArg.IsNotNullOrWhiteSpace(smpConfiguration.ToPartyId, nameof(smpConfiguration.ToPartyId));
EnsureArg.IsNotNullOrWhiteSpace(smpConfiguration.Url, nameof(smpConfiguration.Url));
if (!String.IsNullOrEmpty(smpConfiguration.EncryptPublicKeyCertificate) &&
String.IsNullOrEmpty(smpConfiguration.EncryptPublicKeyCertificateName))
{
throw new BusinessException(
"EncryptPublicKeyCertificateName needs to be provided when EncryptPublicKeyCertificate is not empty!");
}
}
/// <summary>
/// Create an e new <see cref="N:Eu.EDelivery.AS4.Fe.Model.SmpConfigurationDetail" />
/// </summary>
/// <param name="detail">The SMP configuration.</param>
/// <returns></returns>
public async Task <SmpConfigurationDetail> CreateAsync(SmpConfigurationDetail detail)
{
EnsureArg.IsNotNull(detail, nameof(detail));
ValidateSmpConfiguration(detail);
var configuration = _mapper.Map <Entities.SmpConfiguration>(detail);
configuration.EncryptPublicKeyCertificate =
DeserializePublicKeyCertificate(detail.EncryptPublicKeyCertificate);
await _datastoreContext.SmpConfigurations.AddAsync(configuration);
await _datastoreContext.SaveChangesAsync();
return(ToDetail(configuration));
}
public async Task ThrowsBusinessException_WhenKeyIsProvidedWithoutFileName()
{
// Arrange
SmpConfigurationDetail dbSmpConfiguration = await SmpConfigurationService.CreateAsync(_smpConfiguration);
Assert.NotNull(dbSmpConfiguration.Id);
_smpConfiguration.EncryptPublicKeyCertificate = Convert.ToBase64String(new byte[] { 1, 2, 3 });
SmpConfigurationDetail smpConfiguration = CreateFixture();
smpConfiguration.EncryptPublicKeyCertificate = "not empty";
// Act
var exception = await Assert.ThrowsAsync <BusinessException>(() => SmpConfigurationService.UpdateAsync(dbSmpConfiguration.Id.Value, smpConfiguration));
// Assert
Assert.Equal("EncryptPublicKeyCertificateName needs to be provided when EncryptPublicKeyCertificate is not empty!", exception.Message);
}
public SmpConfigurationServiceTest()
{
_smpConfiguration = new SmpConfigurationDetail
{
Action = "Action",
EncryptAlgorithm = "EncryptAlgorithm",
EncryptAlgorithmKeySize = 10,
EncryptKeyDigestAlgorithm = "EncryptKeyDigestAlgorithm",
EncryptKeyMgfAlorithm = "EncryptKeyMgfAlorithm",
EncryptKeyTransportAlgorithm = "EncryptKeyTransportAlgorithm",
EncryptPublicKeyCertificateName = "AccessPointA.cer",
EncryptPublicKeyCertificate = Base64CertHeader + EncryptionCertificateContents,
EncryptionEnabled = true,
FinalRecipient = "FinalRecipient",
PartyRole = "PartyRole",
PartyType = "PartyType",
ServiceType = "ServiceType",
ServiceValue = "ServiceValue",
TlsEnabled = true,
ToPartyId = "ToPartyId",
Url = "Url"
};
Options = new DbContextOptionsBuilder <DatastoreContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using (var store = new DatastoreContext(Options, StubConfig.Default))
{
store.Database.EnsureCreated();
}
CreateNewDbContext();
MapperConfig = new MapperConfiguration(cfg => { cfg.AddProfile(new SmpConfigurationAutoMapperProfile()); });
CreateNewSmpConfigurationService();
}
/// <summary>
/// Update an existing <see cref="N:Eu.EDelivery.AS4.Fe.Model.SmpConfigurationDetail" /> by id
/// </summary>
/// <param name="id">The id of the SmpConfiguration</param>
/// <param name="detail">SMP configuration data to be updated</param>
/// <returns></returns>
/// <exception cref="NotFoundException"></exception>
public async Task UpdateAsync(long id, SmpConfigurationDetail detail)
{
EnsureArg.IsNotNull(detail, nameof(detail));
EnsureArg.IsTrue(id > 0, nameof(id));
ValidateSmpConfiguration(detail);
Entities.SmpConfiguration existing =
await _datastoreContext
.SmpConfigurations
.FirstOrDefaultAsync(c => c.Id == id);
if (existing == null)
{
throw new NotFoundException($"No smp configuration with id {id} found.");
}
_mapper.Map(detail, existing);
existing.EncryptPublicKeyCertificate =
DeserializePublicKeyCertificate(detail.EncryptPublicKeyCertificate);
_datastoreContext.Entry(existing).State = EntityState.Modified;
await _datastoreContext.SaveChangesAsync();
}
public async Task <IActionResult> Put(int id, [FromBody] SmpConfigurationDetail smpConfiguration)
{
await _smpConfiguration.UpdateAsync(id, smpConfiguration);
return(new OkResult());
}
public async Task <IActionResult> Post([FromBody] SmpConfigurationDetail smpConfiguration)
{
SmpConfigurationDetail configuration = await _smpConfiguration.CreateAsync(smpConfiguration);
return(new OkObjectResult(configuration));
}
