public async Task Test1() { //given I have a test server and client Setup(); //given I have a valid request var request = new CreateContactRequest { FirstName = "testfirst", LastName = "testlast", PhoneNumber = 5555555555, Address = "1234 Main Street", City = "San Luis Obispo", State = "CA", Zip = "93401" }; //given I have a contact to return var contact = MapToContactFrom(request); ContactsProviderMock.Setup(a => a.InsertContact(It.IsAny <Contact>())) .Returns(Task.FromResult(contact)); //when I fetch the client var httpResponse = await Client.PostAsJsonAsync(Url, request); //then I expect the response httpResponse.StatusCode.Should().Be(HttpStatusCode.OK); var response = await httpResponse.Content.ReadAsAsync <CreateContactResponse>(); response.FirstName.Should().Be(request.FirstName); response.LastName.Should().Be(request.LastName); }
public async Task CreateContactAsync_TwoIdenticalContacts_ShouldStoreBothContacts() { // Arrange await this.fixture.ClearFactroInstanceAsync(); var contactApi = this.fixture.GetService <IContactApi>(); var firstName = Guid.NewGuid().ToString(); var lastName = Guid.NewGuid().ToString(); var description = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}"; var createContactRequest = new CreateContactRequest(firstName, lastName) { Description = description, }; await contactApi.CreateContactAsync(createContactRequest); // Act Func <Task> act = async() => await contactApi.CreateContactAsync(createContactRequest); // Assert await act.Should().NotThrowAsync(); using (new AssertionScope()) { var contacts = (await contactApi.GetContactsAsync()) .Where(x => x.Description.StartsWith(BaseTestFixture.TestPrefix)).ToList(); var matchingContacts = contacts.Where(x => x.Description == description); matchingContacts.Should().HaveCount(2); } await this.fixture.ClearFactroInstanceAsync(); }
/// <summary> /// Creates the new contact. /// </summary> /// <param name="request">The request.</param> /// <returns></returns> /// <exception cref="System.ArgumentException">create contact request</exception> /// <exception cref="System.Exception"> /// </exception> public Contact CreateNewContact(CreateContactRequest request) { try { #region pre-processing if (request == null) { throw new ArgumentException("create contact request"); } if (string.IsNullOrWhiteSpace(request.Name)) { throw new Exception(PushbulletConstants.CreateContactErrorMessages.ErrorNameProperty); } if (string.IsNullOrWhiteSpace(request.Email)) { throw new Exception(PushbulletConstants.CreateContactErrorMessages.ErrorEmailProperty); } #endregion pre-processing #region processing Contact response = PostRequest <Contact>(string.Concat(PushbulletConstants.BaseUrl, PushbulletConstants.ContactsUrls.Contacts), request); return(response); #endregion processing } catch (Exception) { throw; } }
public async Task Create_ShouldReturnCreatedRecord() { // Arrange await AuthenticationAsync(); // Act var testContact = new CreateContactRequest { FirstName = "Integration", LastName = "Test", CompanyName = "IntegrationTest" }; var response = await httpClient .PostAsJsonAsync( APIRoutes.ContactControllerRoutes.Create, testContact); // Assert response.StatusCode.Should().Be(HttpStatusCode.Created); var returnedContactResponse = await response.Content.ReadAsAsync <ContactResponse>(); returnedContactResponse.FirstName.Should().Be(testContact.FirstName); returnedContactResponse.LastName.Should().Be(testContact.LastName); returnedContactResponse.CompanyName.Should().Be(testContact.CompanyName); }
public async Task CreateContact_UnsuccessfulRequest_ShouldThrowContactApiException() { // Arrange var firstName = Guid.NewGuid().ToString(); var lastName = Guid.NewGuid().ToString(); var createContactRequest = new CreateContactRequest(firstName, lastName); var expectedResponse = new HttpResponseMessage { StatusCode = HttpStatusCode.BadRequest, RequestMessage = new HttpRequestMessage { RequestUri = new Uri("http://www.mock-web-address.com"), }, }; var contactApi = this.fixture.GetContactApi(expectedResponse); // Act Func <Task> act = async() => await contactApi.CreateContactAsync(createContactRequest); // Assert await act.Should().ThrowAsync <FactroApiException>(); }
public Contact CreateNewContact(CreateContactRequest contact) { var metaData = new Metadata(); var result = _contactClient.CreateContact(contact); return(result.Contact); }
public async Task CreateContactAsync_ValidContact_ShouldStoreContact() { // Arrange await this.fixture.ClearFactroInstanceAsync(); var contactApi = this.fixture.GetService <IContactApi>(); var firstName = Guid.NewGuid().ToString(); var lastName = Guid.NewGuid().ToString(); var description = $"{BaseTestFixture.TestPrefix}{Guid.NewGuid().ToString()}"; var createContactRequest = new CreateContactRequest(firstName, lastName) { Description = description, }; var createContactResponse = default(CreateContactResponse); // Act Func <Task> act = async() => createContactResponse = await contactApi.CreateContactAsync(createContactRequest); // Assert await act.Should().NotThrowAsync(); using (new AssertionScope()) { var contacts = (await contactApi.GetContactsAsync()) .Where(x => x.Description.StartsWith(BaseTestFixture.TestPrefix)).ToList(); contacts.Should().ContainEquivalentOf(createContactResponse); } await this.fixture.ClearFactroInstanceAsync(); }
public async Task CreateContact_ValidRequest_ShouldReturnCreatedContact() { // Arrange var firstName = Guid.NewGuid().ToString(); var lastName = Guid.NewGuid().ToString(); var createContactRequest = new CreateContactRequest(firstName, lastName); var expectedContact = new CreateContactResponse { FirstName = firstName, LastName = lastName, }; var expectedResponseContent = new StringContent(JsonConvert.SerializeObject(expectedContact, this.fixture.JsonSerializerSettings)); var expectedResponse = new HttpResponseMessage { Content = expectedResponseContent, }; var contactApi = this.fixture.GetContactApi(expectedResponse); var createContactResponse = default(CreateContactResponse); // Act Func <Task> act = async() => createContactResponse = await contactApi.CreateContactAsync(createContactRequest); // Assert await act.Should().NotThrowAsync(); createContactResponse.Should().BeEquivalentTo(expectedContact); }
public void CreateContact() { moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict); CreateContactRequest request = new CreateContactRequest { ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"), Contact = new Contact(), }; Contact expectedResponse = new Contact { ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"), Email = "email7cf5830c", NotificationCategorySubscriptions = { NotificationCategory.TechnicalIncidents, }, LanguageTag = "language_tag40256b15", ValidationState = ValidationState.Invalid, ValidateTime = new wkt::Timestamp(), }; mockGrpcClient.Setup(x => x.CreateContact(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse); EssentialContactsServiceClient client = new EssentialContactsServiceClientImpl(mockGrpcClient.Object, null); Contact response = client.CreateContact(request.Parent, request.Contact); xunit::Assert.Same(expectedResponse, response); mockGrpcClient.VerifyAll(); }
public async Task <IActionResult> Create([FromBody] CreateContactRequest contactRequest) { var contact = new Contact { FirstName = contactRequest.FirstName, LastName = contactRequest.LastName, CompanyName = contactRequest.CompanyName, OwnerUserId = HttpContext.GetCurrentUserId(), }; await _contactService.CreateAsync(contact); var baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host.ToUriComponent()}"; var createdLocationUri = $"{baseUrl}/{APIRoutes.ContactControllerRoutes.Get.Replace("{contactId}", contact.Id.ToString())}"; var contactResponse = new ContactResponse { Id = contact.Id, FirstName = contact.FirstName, LastName = contact.LastName, CompanyName = contact.CompanyName, }; await _redisCacheService .DeleteCachedResponseAsync( new string[] { HttpContext.Request.Path, APIRoutes.ContactControllerRoutes.GetAll }); return(Created(createdLocationUri, contactResponse)); }
private AddContactResponse Create(CreateContactRequest model) { AddContactResponse synergyResponse = new AddContactResponse(); Synergy.Common.Request.WebClient client = new Common.Request.WebClient(); var requestModel = model.ConvertToCreateContactRequest(); string requestData = GetJson(requestModel); HttpWebResponse response = client.Post(JsonConvert.SerializeObject(requestModel), GetUrl(AgileCRMConstant.Contacts), GetAuthorization(), EnumUtilities.GetDescriptionFromEnumValue(ContentTypes.JSON)); if (response.StatusCode == HttpStatusCode.OK) { var responseStream = response.GetResponseStream(); StreamReader streamReader = new StreamReader(responseStream); string rawResponse = streamReader.ReadToEnd(); var Contact = JsonConvert.DeserializeObject <Contact>(rawResponse); synergyResponse.Status = Status.Success; } else { synergyResponse.Status = Status.Error; var responseStream = response.GetResponseStream(); StreamReader streamReader = new StreamReader(responseStream); string rawResponse = streamReader.ReadToEnd(); synergyResponse.Message = rawResponse; } return(synergyResponse); }
public async stt::Task CreateContactRequestObjectAsync() { moq::Mock <EssentialContactsService.EssentialContactsServiceClient> mockGrpcClient = new moq::Mock <EssentialContactsService.EssentialContactsServiceClient>(moq::MockBehavior.Strict); CreateContactRequest request = new CreateContactRequest { ParentAsProjectName = gagr::ProjectName.FromProject("[PROJECT]"), Contact = new Contact(), }; Contact expectedResponse = new Contact { ContactName = ContactName.FromProjectContact("[PROJECT]", "[CONTACT]"), Email = "email7cf5830c", NotificationCategorySubscriptions = { NotificationCategory.TechnicalIncidents, }, LanguageTag = "language_tag40256b15", ValidationState = ValidationState.Invalid, ValidateTime = new wkt::Timestamp(), }; mockGrpcClient.Setup(x => x.CreateContactAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Contact>(stt::Task.FromResult(expectedResponse), null, null, null, null)); EssentialContactsServiceClient client = new EssentialContactsServiceClientImpl(mockGrpcClient.Object, null); Contact responseCallSettings = await client.CreateContactAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None)); xunit::Assert.Same(expectedResponse, responseCallSettings); Contact responseCancellationToken = await client.CreateContactAsync(request, st::CancellationToken.None); xunit::Assert.Same(expectedResponse, responseCancellationToken); mockGrpcClient.VerifyAll(); }
public async void TestCreateWithTeam() { String accessToken = this.RandomString(); String teamId = this.RandomString(); Models.Contact contact = new Models.Contact(); contact.ContactData = new Models.ContactData(); contact.ContactData.Name = new Models.Fields.Name(); contact.ContactData.Name.FamilyName = this.RandomString(); CreateContactRequest req = new CreateContactRequest(); req.Contact = contact; req.TeamId = teamId; MockAPI <Contacts> mock = this.MockFor <Contacts>( HttpMethod.Post, "/api/v1/contacts.create", m => m.WithContent(req.ToString()) .Respond("application/json", req.ToString()) ); APIResponse <ContactResponseBody> res = await mock.Instance.Create(accessToken, contact, teamId); mock.Handler.VerifyNoOutstandingExpectation(); Assert.Equal(contact.ContactData.Name.FamilyName, res.Body.Contact.ContactData.Name.FamilyName); }
public void Serialize_ValidInput_ShouldSerialize() { var createContactRequest = new CreateContactRequest(); var serializedPayload = _xmlService.Serialize(createContactRequest); serializedPayload.Should().Be("<s:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\" />"); }
public ActionResult AddContact(CreateContactRequest model) { model.UserId = SynergySecurity.GetCurrentUser(); model.Api = ApiTypes.AgileCrm; model.Request = "Create New Contact"; contactApi.AddContact(model); return(RedirectToAction("Contacts")); }
public async Task <Contact> CreateNewContact(CreateContactRequest contact) { _logger.LogInformation("ContactResolver - CreateNewContact"); var metaData = new Metadata(); var result = await _contactClient.CreateContactAsync(contact, metaData); return(result.Contact); }
public void Deserialize_ValidInput_ShouldReturnDeserializedObject() { var serializedPayload = "<s:Envelope xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" xmlns:s=\"http://www.w3.org/2003/05/soap-envelope\" />"; var createContactRequest = new CreateContactRequest(); var deserializedPayload = _xmlService.DeserializeXml <CreateContactRequest>(serializedPayload); deserializedPayload.Should().BeEquivalentTo(createContactRequest); }
public void Arrange() { Setup(); ContactRequest = new CreateContactRequest(Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>()); _validationResult = CreateContactRequestValidator.Validate(ContactRequest); }
/// <summary> /// Records a contact for a person syncronously /// </summary> /// <param name="personId">The ID of the person that was contacted</param> /// <param name="parameters">Options for the contact</param> /// <param name="cancellationToken">Token allowing the request to be cancelled</param> /// <returns>The contact that was created</returns> public Contact Create(int personId, CreateContactParameters parameters, CancellationToken cancellationToken = default(CancellationToken)) { Ensure.IsNotNull(parameters, nameof(parameters)); var url = UrlProvider.GetV1ContactCreateUrl(personId); var request = new CreateContactRequest(parameters); return(PostJson <CreateContactResponse>(url, request, cancellationToken).Payload.Contact); }
public static object ConvertToCreateContactRequest(this CreateContactRequest model) { return(new { star_value = model.StarValue, lead_score = model.LeadScore, tags = model.Tags ?? new string[] { }, properties = model.Property.ConvertToPropertyList(create: true) }); }
public async Task <IActionResult> CreateContact( [FromBody] CreateContactRequest createContactRequest) { _logger.LogInformation("Received Create Contact Request"); var contactResponse = await _mediator.Send(createContactRequest); return(CreatedAtRoute("CreateContact", contactResponse)); }
public async Task <ContactBoolResponse> InviteUser(CreateContactRequest createContactRequest) { using (var request = new HttpRequestMessage(HttpMethod.Post, $"/api/v1/contacts")) { var response = await PostPutRequestWithResponse <CreateContactRequest, ContactBoolResponse>(request, createContactRequest); return(response); } }
private Contact MapToContactFrom(CreateContactRequest request) { return(new Contact { FirstName = request.FirstName, LastName = request.LastName, PhoneNumber = request.PhoneNumber, Address = request.Address, City = request.City, State = request.State, Zip = request.Zip, }); }
public static Domain.Contact ToContact(this CreateContactRequest contactRequest) { return(new Domain.Contact { ContactId = Guid.NewGuid(), ContactType = Domain.ContactType.Contact, FirstName = contactRequest.FirstName, LastName = contactRequest.LastName, Title = contactRequest.Title, Company = contactRequest.Company, Description = contactRequest.Description }); }
private string UpdateCustomerRecord(JToken amCustomers_Result, string suiteConstactId, string logId) { try { if (amCustomers_Result != null && suiteConstactId != null) { var suiteWrapper = new SuiteWrapper(); suitesessionId = suiteWrapper.Login().GetAwaiter().GetResult(); var contactrequest = new CreateContactRequest { Email = Convert.ToString(amCustomers_Result.SelectToken("preferred_email")), Phone = Convert.ToString(amCustomers_Result.SelectToken("phone_number")), FirstName = Convert.ToString(amCustomers_Result.SelectToken("given_name")), LastName = Convert.ToString(amCustomers_Result.SelectToken("family_name")), Salutation = Convert.ToString(amCustomers_Result.SelectToken("title")), Fax = Convert.ToString(amCustomers_Result.SelectToken("fax_number")), Comments = Convert.ToString(amCustomers_Result.SelectToken("notes")), ContactType = "Individual", CompanyName = Convert.ToString(amCustomers_Result.SelectToken("company_name")), AMCustomerId = Convert.ToString(amCustomers_Result.SelectToken("row_id")), Approvalestatus = "Pending_Approval", Id = suiteConstactId }; var request = new InsertRequest { SessionId = suitesessionId, ModuleName = "Contacts", Entity = contactrequest }; var resp = suiteWrapper.Update(request).GetAwaiter().GetResult(); common.InsertSuiteAmIntegrationLogDetail(new CreateTraceLogRequest() { Description = "Updated Customer RecordID :" + resp.Id, Name = "InsertSuiteContact", Entity_c = "Customer" }, logId); SuiteWrapper.WriteTraceLog("InsertSuiteContact", "Updated Customer RecordID :" + resp.Id); return(resp.Id); } } catch (Exception ex) { common.InsertSuiteAmIntegrationLogDetail(new CreateTraceLogRequest() { Description = "Error : " + ex.Message, Name = "InsertSuiteContact", Entity_c = "Customer" }, logId); SuiteWrapper.WriteTraceLog("InsertSuiteContact", "Error : " + ex.Message); } return(""); }
public async Task <CreateContactResponse> CreateTestContactAsync(IContactApi contactApi) { var firstName = Guid.NewGuid().ToString(); var lastName = Guid.NewGuid().ToString(); var description = $"{TestPrefix}{Guid.NewGuid().ToString()}"; var createContactRequest = new CreateContactRequest(firstName, lastName) { Description = description, }; var createContactResponse = await contactApi.CreateContactAsync(createContactRequest); return(createContactResponse); }
/// <summary>Snippet for CreateContact</summary> public void CreateContactRequestObject() { // Snippet: CreateContact(CreateContactRequest, CallSettings) // Create client EssentialContactsServiceClient essentialContactsServiceClient = EssentialContactsServiceClient.Create(); // Initialize request argument(s) CreateContactRequest request = new CreateContactRequest { ParentAsProjectName = ProjectName.FromProject("[PROJECT]"), Contact = new Contact(), }; // Make the request Contact response = essentialContactsServiceClient.CreateContact(request); // End snippet }
public async Task CreateContactAsync_NullLastName_ShouldThrowArgumentNullException() { // Arrange var firstName = Guid.NewGuid().ToString(); var createContactRequest = new CreateContactRequest(firstName, lastName: null); var contactApi = this.fixture.GetContactApi(); // Act Func <Task> act = async() => await contactApi.CreateContactAsync(createContactRequest); // Assert await act.Should().ThrowAsync <ArgumentNullException>(); }
public void Arrange() { Setup(); MappingBootstrapper.Initialize(); var contact = new ContactBoolResponse(true); Mediator.Setup(q => q.Send(Moq.It.IsAny <CreateContactRequest>(), Moq.It.IsAny <CancellationToken>())) .Returns(Task.FromResult((contact))); var contactRequest = new CreateContactRequest(Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>(), Moq.It.IsAny <string>()); _result = ContactController.CreateContact(contactRequest).Result; }
public void PushbulletCreateContactTest() { try { CreateContactRequest request = new CreateContactRequest() { Name = "Some Person", Email = "*****@*****.**" }; var result = Client.CreateNewContact(request); Assert.IsNotNull(result); } catch (Exception ex) { Assert.Fail(ex.Message); } }