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)); }