public void Not_supported_private_key_creation()
{
//ARRANGE
var client = PrepareClient <AppSettings>((options) =>
{
var addressGenerator = new Mock <IAddressGenerator>();
var transactionSigner = new Mock <ITransactionSigner>();
addressGenerator.Setup(x => x.CreateAddressAsync())
.ThrowsAsync(new OperationNotSupportedException("Address creation is not supported"));
options.IntegrationName = $"{nameof(SignServiceClientTests)}+{nameof(Can_create_private_key)}";
options.AddressGeneratorFactory = (context) => addressGenerator.Object;
options.TransactionSignerFactory = (context) => transactionSigner.Object;
});
//ACT && ASSERT
var base64EncryptionKey = MyPublicKey;
var request = new CreateAddressRequest(base64EncryptionKey);
Assert.ThrowsAsync <NotImplementedWebApiException>(async() =>
{
CreateAddressResponse result = await client.CreateAddressAsync(request);
result?.PrivateKey?.DecryptToString(MyPrivateKey);
});
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
CreateAddressResponse response = new CreateAddressResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("AddressId", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.AddressId = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
public async Task <ActionResult <CreateAddressResponse> > CreateAddress(CreateAddressRequest request)
{
var creationResult = await _addressGenerator.CreateAddressAsync();
if (creationResult == null)
{
throw new InvalidOperationException("Not null creation result object expected");
}
var encryptedPrivateKey = creationResult.PrivateKey.Encrypt(request.EncryptionPublicKey);
var response = new CreateAddressResponse
(
encryptedPrivateKey,
creationResult.Address,
creationResult.AddressContext
);
return(Ok(response));
}
public CreateAddressResponse SaveAddress(CreateAddressRequest addressRequest)
{
var createAddressResponse = new CreateAddressResponse();
var address = _messageMapper.MapToAddress(addressRequest.Address);
try
{
_addressRepository.SaveAddress(address);
var addressDto = _messageMapper.MapToAddressDto(address);
createAddressResponse.Address = addressDto;
createAddressResponse.Messages.Add("Successfully saved the address");
createAddressResponse.StatusCode = HttpStatusCode.Created;
}
catch (Exception e)
{
var error = e.ToString();
createAddressResponse.Messages.Add(error);
createAddressResponse.StatusCode = HttpStatusCode.InternalServerError;
}
return(createAddressResponse);
}
public async Task Can_create_private_key()
{
//ARRANGE
var address = Guid.NewGuid().ToString();
var privateKey = Guid.NewGuid().ToString();
var addressContext = "AddressContext";
var client = PrepareClient <AppSettings>((options) =>
{
Mock <IAddressGenerator> addressGenerator = new Mock <IAddressGenerator>();
Mock <ITransactionSigner> transactionSigner = new Mock <ITransactionSigner>();
addressGenerator.Setup(x => x.CreateAddressAsync())
.ReturnsAsync(new AddressCreationResult(
address,
privateKey,
Base64String.Encode(addressContext)));
options.IntegrationName = $"{nameof(SignServiceClientTests)}+{nameof(Can_create_private_key)}";
options.AddressGeneratorFactory = (context) => addressGenerator.Object;
options.TransactionSignerFactory = (context) => transactionSigner.Object;
});
//ACT
var base64EncryptionKey = MyPublicKey;
var request = new CreateAddressRequest(base64EncryptionKey);
CreateAddressResponse result = await client.CreateAddressAsync(request);
var decryptedPk = result?.PrivateKey?.DecryptToString(MyPrivateKey);
//ASSERT
Assert.True(result != null);
Assert.True(!string.IsNullOrEmpty(result.Address.Value));
Assert.True(result.Address.Value == address);
Assert.True(decryptedPk == privateKey);
Assert.True(result.AddressContext?.DecodeToString() == addressContext);
}
