public async Task TestGetTemplatesWithInvalidApiKeyAsync() { Trace.WriteLine(String.Format("GET /templates with invalid API Key: {0}", INVALID_API_KEY)); // Set the API Key to an invalid key and save the original key var originalApiKey = SendwithusClient.ApiKey; SendwithusClient.ApiKey = INVALID_API_KEY; // Make the API call try { var templates = await Template.GetTemplatesAsync(); } catch (AggregateException exception) { // Make sure the response was HTTP 403 Forbidden SendwithusClientTest.ValidateException(exception, HttpStatusCode.Forbidden); } finally { // Set the API Key back to its original value SendwithusClient.ApiKey = originalApiKey; } }
public async Task TestAddLocaleToTemplateWithAllParmetersAsync() { // Create a new template to add a locale to // Otherwise, if an existing template were used, this test might fail because the new locale could already exist on the template var newTemplate = await BuildAndSendCreateTemplateRequestWithAllParametersAsync(); var templateId = newTemplate.id; // Make the API call Trace.WriteLine(String.Format("POST /templates/{0}/locales", templateId)); var templateVersionName = "Published French Version"; var templateSubject = "Ce est un nouveau modèle!"; var updatedTemplateVersion = new TemplateVersion(templateVersionName, templateSubject); updatedTemplateVersion.html = "<html><head></head><body><h1>Nouveau modèle!</h1></body></html>"; updatedTemplateVersion.text = "un texte"; updatedTemplateVersion.preheader = "A French Preheader"; try { var template = await Template.AddLocaleToTemplate(templateId, ALTERNATE_LOCALE, updatedTemplateVersion); // Validate the response SendwithusClientTest.ValidateResponse(template); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetLogsWithAllParametersAsync() { Trace.WriteLine("GET /logs"); // Build the query parameters Dictionary <string, object> queryParameters = new Dictionary <string, object>(); queryParameters.Add("count", DEFAULT_COUNT); queryParameters.Add("offset", DEFAULT_OFFSET); queryParameters.Add("created_gt", LOG_CREATED_AFTER_TIME); queryParameters.Add("created_gte", LOG_CREATED_AFTER_TIME); queryParameters.Add("created_lt", LOG_CREATED_BEFORE_TIME); queryParameters.Add("created_lte", LOG_CREATED_BEFORE_TIME); // Make the API call try { var logs = await Log.GetLogsAsync(queryParameters); // Validate the response SendwithusClientTest.ValidateResponse(logs); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestActivateDripCampaignAsyncWithAllParameters() { Trace.WriteLine(String.Format("POST /drip_campaigns/{0}/activate with all parameters", DEFAULT_CAMPAIGN_ID)); // Build the drip campaign object var recipient = new EmailRecipient(DEFAULT_RECIPIENT_EMAIL_ADDRESS, DEFAULT_EMAIL_NAME); var dripCampaign = new DripCampaign(recipient); dripCampaign.cc.Add(new EmailRecipient(DEFAULT_CC_EMAIL_ADDRESS_1, DEFAULT_EMAIL_NAME)); dripCampaign.cc.Add(new EmailRecipient(DEFAULT_CC_EMAIL_ADDRESS_2, DEFAULT_EMAIL_NAME)); dripCampaign.bcc.Add(new EmailRecipient(DEFAULT_BCC_EMAIL_ADDRESS_1, DEFAULT_EMAIL_NAME)); dripCampaign.bcc.Add(new EmailRecipient(DEFAULT_BCC_EMAIL_ADDRESS_2, DEFAULT_EMAIL_NAME)); dripCampaign.sender.address = DEFAULT_SENDER_EMAIL_ADDRESS; dripCampaign.sender.name = DEFAULT_SENDER_NAME; dripCampaign.sender.reply_to = DEFAULT_REPLY_TO_EMAIL_ADDRESS; dripCampaign.tags.Add(DEFAULT_TAG_1); dripCampaign.tags.Add(DEFAULT_TAG_2); dripCampaign.tags.Add(DEFAULT_TAG_3); dripCampaign.locale = DEFAULT_LOCALE; dripCampaign.esp_account = DEFAULT_ESP_ACCOUNT_ID; dripCampaign.email_data.Add("amount", "$12.00"); // Make the API call try { var dripCampaignResponse = await dripCampaign.ActivateAsync(DEFAULT_CAMPAIGN_ID); // Validate the response SendwithusClientTest.ValidateResponse(dripCampaignResponse); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestNonDefaultRetryCountAsync() { // Set the timeout low enough that the API call is guaranteed to fail SendwithusClient.SetTimeoutInMilliseconds(FAILURE_TIMEOUT_MILLISECONDS); // Use a non-default number of retries SendwithusClient.RetryCount = NON_DEFAULT_RETRY_COUNT; // Send a GET request try { var response = await Template.GetTemplateAsync(DEFAULT_TEMPLATE_ID); } catch (Exception ex) { SendwithusClientTest.ValidateAggregateException <TaskCanceledException>(NON_DEFAULT_RETRY_COUNT, ex); } finally { // Set the timeout back to its default value SendwithusClient.SetTimeoutInMilliseconds(SendwithusClient.DEFAULT_TIMEOUT_MILLISECONDS); // Set the retry count back to its default value SendwithusClient.RetryCount = SendwithusClient.DEFAULT_RETRY_COUNT; } }
public async Task TestBatchApiRequestsAbortRequestAsync() { Trace.WriteLine("POST /batch"); // Start the batch request BatchApiRequest.StartNewBatchRequest(); try { // Make the API call to be batched await Template.GetTemplatesAsync(); // Abort the batch request BatchApiRequest.AbortBatchRequest(); // Make another API call and make sure it goes through var snippets = await Snippet.GetSnippetsAsync(); SendwithusClientTest.ValidateResponse(snippets); // Make the aborted batch API Reqeust anyways var batchResponses = await BatchApiRequest.SendBatchApiRequest(); // Make sure no API calls were included in the batch request (empty request) ValidateBatchApiCallResponses(batchResponses, 0); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
/// <summary> /// Validates a batch API call response /// Makes sure the reponse is not null, and checks the number of API responses against the number that were expected /// </summary> /// <param name="responses">The collection of BatchApiResponses from the batch API call</param> /// <param name="expectedResponseCount">The expected number of BatchApiResponse</param> private void ValidateBatchApiCallResponses(List <BatchApiResponse> responses, int expectedResponseCount) { // Standard validation of the response (make sure the response isn't null) SendwithusClientTest.ValidateResponse(responses); // Make sure we received the expected number of batch API responses Assert.AreEqual(expectedResponseCount, responses.Count); }
public async Task TestGetCustomerWithInvalidEmailAddressAsync() { // Make the API call Trace.WriteLine(String.Format("GET /customers/{0}", INVALID_CUSTOMER_EMAIL_ADDRESS)); try { var customerResponse = await Customer.GetCustomerAsync(INVALID_CUSTOMER_EMAIL_ADDRESS); Assert.Fail("Failed to throw exception"); } catch (AggregateException exception) { // Make sure the response was HTTP 400 Bad Request SendwithusClientTest.ValidateException(exception, HttpStatusCode.BadRequest); } }
public async Task TestGetCustomerAsync() { // Make the API call Trace.WriteLine(String.Format("GET /customers/{0}", DEFAULT_CUSTOMER_EMAIL_ADDRESS)); try { var customerResponse = await Customer.GetCustomerAsync(DEFAULT_CUSTOMER_EMAIL_ADDRESS); // Validate the response SendwithusClientTest.ValidateResponse(customerResponse); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetTemplateByIdAndLocaleInvalidLocaleAsync() { // Make the API call Trace.WriteLine(String.Format("GET /templates/{0}/locales/{1} with invalid locale", DEFAULT_TEMPLATE_ID, INVALID_LOCALE)); try { var template = await Template.GetTemplateAsync(DEFAULT_TEMPLATE_ID, INVALID_LOCALE); Assert.Fail("Failed to throw exception"); } catch (AggregateException exception) { // Make sure the response was HTTP 400 Bad Request SendwithusClientTest.ValidateException(exception, HttpStatusCode.BadRequest); } }
public async Task TestCreateTemplateWithAllParametersAsync() { // Make the API call Trace.WriteLine(String.Format("PUT /templates/")); try { var template = await BuildAndSendCreateTemplateRequestWithAllParametersAsync(); // Validate the response SendwithusClientTest.ValidateResponse(template); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetTemplateByIdAsync() { // Make the API call Trace.WriteLine(String.Format("GET /templates/{0}", DEFAULT_TEMPLATE_ID)); try { var template = await Template.GetTemplateAsync(DEFAULT_TEMPLATE_ID); // Validate the response SendwithusClientTest.ValidateResponse(template); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetTemplatesAsync() { // Make the API call Trace.WriteLine("GET /templates"); try { var templates = await Template.GetTemplatesAsync(); // Validate the response SendwithusClientTest.ValidateResponse(templates); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetTemplateVersionByIdAndLocaleAsync() { // Make the API call Trace.WriteLine(String.Format("GET /templates/{0}/locales/{1}/versions/{2}", DEFAULT_TEMPLATE_ID, DEFAULT_LOCALE, DEFAULT_VERSION_ID)); try { var templateVersion = await Template.GetTemplateVersionAsync(DEFAULT_TEMPLATE_ID, DEFAULT_LOCALE, DEFAULT_VERSION_ID); // Validate the response SendwithusClientTest.ValidateResponse(templateVersion); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetDripCampaignsAsync() { Trace.WriteLine("GET /drip_campaigns"); // Make the API call try { var dripCampaignDetails = await DripCampaign.GetDripCampaignsAsync(); // Validate the response SendwithusClientTest.ValidateResponse(dripCampaignDetails); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestDeactivateFromAllDripCampaignsAsync() { Trace.WriteLine(String.Format("POST /drip_campaigns/{0}/deactivate", DEFAULT_CAMPAIGN_ID)); // Make the API call try { var dripCampaignDeactivateResponse = await DripCampaign.DeactivateFromAllCampaignsAsync(DEFAULT_RECIPIENT_EMAIL_ADDRESS); // Validate the response SendwithusClientTest.ValidateResponse(dripCampaignDeactivateResponse); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestCreateOrUpdateCustomerWithAllParametersAsync() { Trace.WriteLine("POST /customers"); // Build the new customer and send the create customer request try { var genericApiCallStatus = await BuildAndSendCreateCustomerRequest(); // Validate the response SendwithusClientTest.ValidateResponse(genericApiCallStatus); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestDeleteCustomerAsync() { Trace.WriteLine(String.Format("DELETE /customers", NEW_CUSTOMER_EMAIL_ADDRESS)); // Make the API call try { var genericApiCallStatus = await Customer.DeleteCustomerAsync(NEW_CUSTOMER_EMAIL_ADDRESS); // Validate the response SendwithusClientTest.ValidateResponse(genericApiCallStatus); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetLogsWithNoParametersAsync() { Trace.WriteLine("GET /logs"); // Make the API call try { var logs = await Log.GetLogsAsync(); // Validate the response SendwithusClientTest.ValidateResponse(logs); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetSnippetsAsync() { Trace.WriteLine("GET /snippets"); // Make the API call try { var snippets = await Snippet.GetSnippetsAsync(); // Validate the response SendwithusClientTest.ValidateResponse(snippets); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetSnippetAsync() { Trace.WriteLine(String.Format("GET /snippets/{0}", DEFAULT_SNIPPET_ID)); // Make the API call try { var snippet = await Snippet.GetSnippetAsync(DEFAULT_SNIPPET_ID); // Validate the response SendwithusClientTest.ValidateResponse(snippet); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetEspAccountsWithoutParametersAsync() { Trace.WriteLine("GET /esp_accounts"); // Make the API call try { var espAccounts = await EspAccount.GetAccountsAsync(); // Validate the response SendwithusClientTest.ValidateResponse(espAccounts); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetDripCampaignAsync() { Trace.WriteLine(String.Format("GET /drip_campaigns/{0}", DEFAULT_CAMPAIGN_ID)); // Make the API call try { var response = await DripCampaign.GetDripCampaignAsync(DEFAULT_CAMPAIGN_ID); // Validate the response SendwithusClientTest.ValidateResponse(response); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetSnippetWithInvalidIDAsync() { Trace.WriteLine("GET /snippets with an invalid ID"); // Make the API call try { var snippet = await Snippet.GetSnippetAsync(INVALID_SNIPPET_ID); Assert.Fail("Failed to throw exception"); } catch (AggregateException exception) { // Make sure the response was HTTP 400 Bad Request SendwithusClientTest.ValidateException(exception, HttpStatusCode.BadRequest); } }
public async Task TestResendLogAsync() { Trace.WriteLine("POST /resend"); // Make the API call try { var logResendResponse = await Log.ResendLogAsync(DEFAULT_LOG_ID); // Validate the response SendwithusClientTest.ValidateResponse(logResendResponse); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestSetDefaultEspAccountAsync() { Trace.WriteLine("PUT /esp_accounts/set_default"); // Make the API call try { var espAccountResponse = await EspAccount.SetDefaultEspAccountAsync(DEFAULT_ESP_ACCOUNT_ID); // Validate the response SendwithusClientTest.ValidateResponse(espAccountResponse); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestGetLogEventsAsync() { Trace.WriteLine(String.Format("GET /logs/{0}/events", DEFAULT_LOG_ID)); // Make the API call try { var logEvents = await Log.GetLogEventsAsync(DEFAULT_LOG_ID); // Validate the response SendwithusClientTest.ValidateResponse(logEvents); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestRenderTemplateWithAllParametersNameAsync() { Trace.WriteLine("POST /render"); // Make the API call try { var renderTemplateResponse = await BuildAndSendRenderTemplateRequestWithAllParametersName(); // Validate the response SendwithusClientTest.ValidateResponse(renderTemplateResponse); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestSendEmailWithAllParametersAsync() { Trace.WriteLine("POST /send"); // Construct and send an email with all of the optional data try { var response = await BuildAndSendEmailWithAllParametersAsync(); // Validate the response SendwithusClientTest.ValidateResponse(response); } catch (AggregateException exception) { Assert.Fail(exception.ToString()); } }
public async Task TestActivateDripCampaignWithInvalidParameters() { Trace.WriteLine(String.Format("POST /drip_campaigns/{0}/activate with invalid campaign ID", INVALID_CAMPAIGN_ID)); // Build the drip campaign object var recipient = new EmailRecipient(DEFAULT_RECIPIENT_EMAIL_ADDRESS); var dripCampaign = new DripCampaign(recipient); // Make the API call try { var response = await dripCampaign.ActivateAsync(INVALID_CAMPAIGN_ID); } catch (AggregateException exception) { // Make sure the response was HTTP 400 Bad Request SendwithusClientTest.ValidateException(exception, HttpStatusCode.BadRequest); } }