public void CreateEnvelope_WhenDocumentTypeI9AndLoginTypeCodeGrant_RequestedEnvelopeTemplateWithIdvNotEnabled(
UserDetails userInformation,
UserDetails additionalUser)
{
//Arrange
_userService.Setup(x => x.GetUserDetails(_accountId, _userId, _loginType)).Returns(userInformation);
_accountsApi.Setup(x => x.GetAccountIdentityVerification(_accountId)).Returns(() =>
new AccountIdentityVerificationResponse
{
IdentityVerification = new List <AccountIdentityVerificationWorkflow>
{
new AccountIdentityVerificationWorkflow(WorkflowId: "100")
}
});
_docuSignApiProvider.SetupGet(c => c.AccountsApi).Returns(_accountsApi.Object);
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act
sut.CreateEnvelope(DocumentType.I9, _accountId, _userId, LoginType.CodeGrant, additionalUser, "", "");
//Assert
EnvelopeTemplate templateToExpect = new I9TemplateHandler().BuildTemplate("../../../../DocuSign.MyHR/");
templateToExpect.Recipients.Signers.First().IdentityVerification = null;
_docuSignApiProvider.Verify(mock => mock.TemplatesApi.CreateTemplate(_accountId, templateToExpect), Times.Once());
}
public HttpResponseMessage Index(
[System.Web.Mvc.ModelBinder(typeof(Grit.Utility.Web.Json.JsonNetModelBinder))] Envelope envelope)
{
var client = ClientService.GetClient(envelope.Id);
if (client == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "Client not found"));
}
var decrypted = EnvelopeService.PublicDecrypt(envelope, client.PublicKey);
var req = JsonConvert.DeserializeObject <SettingsRequest>(decrypted);
if (req.Client != envelope.Id)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid client"));
}
var tree = TreeService.GetTree(Constants.TREE_NODE);
SettingsResponse settings = NodeService.GetClientSettings(client, tree)
.Filter(req.Pattern);
string json = JsonConvert.SerializeObject(settings);
Envelope resp = EnvelopeService.Encrypt(client.Name, json, client.PublicKey);
return(Request.CreateResponse(HttpStatusCode.OK, resp));
}
public async Task <SettingsResponse> GetSettings(string client, string api, string pattern, string privateKey)
{
SettingsRequest csr = new SettingsRequest(client, pattern);
string json = JsonConvert.SerializeObject(csr);
var reqEnvelope = EnvelopeService.PrivateEncrypt(client, json, privateKey);
var reqContent = JsonConvert.SerializeObject(reqEnvelope);
using (HttpClient httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri(api);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpRequestMessage req = new HttpRequestMessage(HttpMethod.Post, "");
req.Content = new StringContent(reqContent, Encoding.UTF8, "application/json");
var response = await httpClient.SendAsync(req);
if (!response.IsSuccessStatusCode)
{
return(null);
}
var content = await response.Content.ReadAsStringAsync();
var envelope = JsonConvert.DeserializeObject <Envelope>(content);
string decrypted = EnvelopeService.Decrypt(envelope, privateKey);
return(JsonConvert.DeserializeObject <SettingsResponse>(decrypted));
}
}
public void GetEnvelope_WhenEnvelopeIdIsNull_ThrowsArgumentException()
{
//Arrange
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act - Assert
Assert.Throws <ArgumentNullException>(() => sut.GetEnvelopData(_accountId, null));
}
public void CreateEnvelope_WhenUserIdNull_ThrowsArgumentException(
DocumentType type,
UserDetails additionalUser)
{
//Arrange
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act - Assert
Assert.Throws <ArgumentNullException>(() => sut.CreateEnvelope(type, _accountId, null, LoginType.CodeGrant, additionalUser, "", ""));
}
public void Create_from_EventMessage_can_create_envelope(EnvelopeService sut, EventMessage <FirstTestEvent> testMessage)
{
var envelope = sut.CreateEnvelope(testMessage);
Assert.That(envelope, Is.Not.Null);
Assert.That(envelope.Type, Is.EqualTo(testMessage.Type));
Assert.That(envelope.Headers, Is.SameAs(testMessage.Headers));
Assert.That(envelope.MessageId, Is.EqualTo(testMessage.MessageId));
Assert.That(envelope.MessageType, Is.EqualTo(testMessage.MessageType));
}
public void CreateEnvelope_WhenAdditionalUserNullAndDocumentTypeDirectDepositOrW4_NotThrowsArgumentException(
DocumentType type,
UserDetails userInformation)
{
//Arrange
_userService.Setup(x => x.GetUserDetails(_accountId, _userId, _loginType)).Returns(userInformation);
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act - Assert
sut.CreateEnvelope(type, _accountId, _userId, LoginType.CodeGrant, null, "", "");
}
public void CreateEnvelope_WhenDocumentTypeNone_ThrowsInvalidOperationException(
DocumentType type,
UserDetails userInformation,
UserDetails additionalUser)
{
//Arrange
_userService.Setup(x => x.GetUserDetails(_accountId, _userId, _loginType)).Returns(userInformation);
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act
//Assert
Assert.Throws <InvalidOperationException>(() =>
sut.CreateEnvelope(type, _accountId, _userId, LoginType.CodeGrant, additionalUser, "", ""));
}
public void CreateEnvelope_WhenCorrectParametersAndWhenDocumentTypeI9_ReturnsCorrectResultWithRedirectUrlEmply(
DocumentType type,
UserDetails userInformation,
UserDetails additionalUser)
{
//Arrange
_userService.Setup(x => x.GetUserDetails(_accountId, _userId, _loginType)).Returns(userInformation);
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act
CreateEnvelopeResponse res = sut.CreateEnvelope(type, _accountId, _userId, LoginType.CodeGrant, additionalUser, "", "");
//Assert
res.Should().BeEquivalentTo(new CreateEnvelopeResponse(string.Empty, "1"));
}
public void CreateEnvelope_WhenCorrectParameters_ReturnsCorrectResult(
DocumentType type,
UserDetails userInformation,
UserDetails additionalUser)
{
//Arrange
_userService.Setup(x => x.GetUserDetails(_accountId, _userId, _loginType)).Returns(userInformation);
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act
CreateEnvelopeResponse res = sut.CreateEnvelope(type, _accountId, _userId, LoginType.CodeGrant, additionalUser, "", "");
//Assert
res.Should().BeEquivalentTo(new CreateEnvelopeResponse(
$"accountId={_accountId}&templateId=1&userEmail={userInformation.Email}&userName={userInformation.Name}",
"1"));
}
public void CreateEnvelope_WhenDocumentTypeI9AndLoginTypeJWTButIdvForAccountNotEnabled_ThrowsIDVException(
UserDetails userInformation,
UserDetails additionalUser)
{
//Arrange
_userService.Setup(x => x.GetUserDetails(_accountId, _userId, _loginType)).Returns(userInformation);
_accountsApi.Setup(x => x.GetAccountIdentityVerification(_accountId))
.Returns(() =>
new AccountIdentityVerificationResponse
{
IdentityVerification = new List <AccountIdentityVerificationWorkflow>()
});
_docuSignApiProvider.SetupGet(c => c.AccountsApi).Returns(_accountsApi.Object);
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act
//Assert
Assert.Throws <IDVException>(() => sut.CreateEnvelope(DocumentType.I9, _accountId, _userId, LoginType.JWT, additionalUser, "", ""));
}
public void GetEnvelope_WhenCorrectRequestParameters_ReturnsCorrectFormData()
{
//Arrange
var envelopeId = "1";
_envelopeApi.Setup(x => x.GetFormData(_accountId, envelopeId)).Returns(() => new EnvelopeFormData(string.Empty, "1",
new List <FormDataItem>
{
new FormDataItem {
Name = "Field1", Value = "Value1"
}
}));
_docuSignApiProvider.SetupGet(c => c.EnvelopApi).Returns(_envelopeApi.Object);
var sut = new EnvelopeService(_docuSignApiProvider.Object, _userService.Object, SetupConfiguration());
//Act - Assert
Dictionary <string, string> result = sut.GetEnvelopData(_accountId, envelopeId);
//Assert
result.Should().BeEquivalentTo(new Dictionary <string, string>()
{
{ "Field1", "Value1" }
});
}
public void CreateEventMessage_requires_valid_envelope(EnvelopeService sut, Type type)
{
Assert.Throws <ArgumentNullException>(() => sut.CreateEventMessage(null, type));
}
public void CreateCommandMessage_returns_message_from_Envelope([Frozen] ISerializer serializer, EnvelopeService sut, Envelope envelope, FirstTestCommand testCommand)
{
envelope.MessageType = MessageType.Command;
Mock.Get(serializer).Setup(p => p.DeserializeObject(It.IsAny <string>(), typeof(FirstTestCommand))).Returns(testCommand);
var commandMessage = sut.CreateCommandMessage(envelope, typeof(FirstTestCommand)) as CommandMessage <FirstTestCommand>;
Assert.That(commandMessage, Is.Not.Null);
Assert.That(commandMessage.Command, Is.SameAs(testCommand));
Assert.That(commandMessage.Headers, Is.SameAs(envelope.Headers));
Assert.That(commandMessage.MessageId, Is.EqualTo(envelope.MessageId));
Assert.That(commandMessage.MessageType, Is.EqualTo(envelope.MessageType));
}
public void CreateCommandMessage_requires_valid_commandType(EnvelopeService sut, Envelope envelope)
{
Assert.Throws <ArgumentNullException>(() => sut.CreateCommandMessage(envelope, null));
}
public void Create_from_EventMessage_uses_serializer([Frozen] ISerializer serializer, EnvelopeService sut, EventMessage <FirstTestEvent> testMessage)
{
var envelope = sut.CreateEnvelope(testMessage);
Assert.That(envelope, Is.Not.Null);
Mock.Get(serializer).Verify(p => p.SerializeObject(testMessage.Event), Times.Once);
}
public void Create_from_EventMessage_requires_valid_message(EnvelopeService sut)
{
Assert.Throws <ArgumentNullException>(() => sut.CreateEnvelope((EventMessage <FirstTestEvent>)null));
}
