public void AssociateDomain()
{
// Arrange
var domainId = 123L;
var ipAddress = "192.168.77.1";
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.PostAsync($"{ENDPOINT}/domains/{domainId}/subuser", It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(SINGLE_DOMAIN_JSON)
})
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
var result = whitelabel.AssociateDomainAsync(domainId, ipAddress, CancellationToken.None).Result;
// Assert
result.ShouldNotBeNull();
}
public async Task ValidateIpAsync()
{
// Arrange
var id = 1L;
var apiResponse = @"{
'id': 1,
'valid': true,
'validation_results': {
'a_record': {
'valid': true,
'reason': null
}
}
}" ;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Utils.GetSendGridApiUri(ENDPOINT, "ips", id, "validate")).Respond("application/json", apiResponse);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.ValidateIpAsync(id).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
result.IpId.ShouldBe(1);
result.IsValid.ShouldBe(true);
result.ValidationResults.ARecord.IsValid.ShouldBe(true);
result.ValidationResults.ARecord.Reason.ShouldBeNull();
}
public void CreateLink()
{
// Arrange
var domain = "example.com";
var subdomain = "mail";
var isDefault = false;
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.PostAsync($"{ENDPOINT}/links", It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(SINGLE_LINK_JSON)
})
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
var result = whitelabel.CreateLinkAsync(domain, subdomain, isDefault, CancellationToken.None).Result;
// Assert
result.ShouldNotBeNull();
}
public void UpdateLink()
{
// Arrange
var linkId = 123L;
var isDefault = true;
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.PatchAsync($"{ENDPOINT}/links/{linkId}", It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(SINGLE_LINK_JSON)
})
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
var result = whitelabel.UpdateLinkAsync(linkId, isDefault).Result;
// Assert
result.ShouldNotBeNull();
}
public void UpdateDomain()
{
// Arrange
var domainId = 123L;
var customSpf = true;
var isDefault = false;
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.PatchAsync($"{ENDPOINT}/domains/{domainId}", It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(SINGLE_DOMAIN_JSON)
})
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
var result = whitelabel.UpdateDomainAsync(domainId, isDefault, customSpf, CancellationToken.None).Result;
// Assert
result.ShouldNotBeNull();
}
private Client(string apiKey, string username, string password, string baseUri, string apiVersion, HttpClient httpClient)
{
_mustDisposeHttpClient = httpClient == null;
_httpClient = httpClient;
#if DEBUG
Version = "DEBUG";
#else
var assemblyVersion = typeof(Client).GetTypeInfo().Assembly.GetName().Version;
Version = $"{assemblyVersion.Major}.{assemblyVersion.Minor}.{assemblyVersion.Build}";
#endif
_fluentClient = new FluentClient(new Uri($"{baseUri.TrimEnd('/')}/{apiVersion.TrimStart('/')}"), httpClient)
.SetUserAgent($"StrongGrid/{Version} (+https://github.com/Jericho/StrongGrid)")
.SetRequestCoordinator(new SendGridRetryStrategy());
_fluentClient.Filters.Remove <DefaultErrorFilter>();
_fluentClient.Filters.Add(new DiagnosticHandler());
_fluentClient.Filters.Add(new SendGridErrorHandler());
if (!string.IsNullOrEmpty(apiKey))
{
_fluentClient.SetBearerAuthentication(apiKey);
}
if (!string.IsNullOrEmpty(username))
{
_fluentClient.SetBasicAuthentication(username, password);
}
AccessManagement = new AccessManagement(_fluentClient);
Alerts = new Alerts(_fluentClient);
ApiKeys = new ApiKeys(_fluentClient);
Batches = new Batches(_fluentClient);
Blocks = new Blocks(_fluentClient);
Bounces = new Bounces(_fluentClient);
Campaigns = new Campaigns(_fluentClient);
Categories = new Categories(_fluentClient);
Contacts = new Contacts(_fluentClient);
CustomFields = new CustomFields(_fluentClient);
GlobalSuppressions = new GlobalSuppressions(_fluentClient);
InvalidEmails = new InvalidEmails(_fluentClient);
IpAddresses = new IpAddresses(_fluentClient);
IpPools = new IpPools(_fluentClient);
Lists = new Lists(_fluentClient);
Mail = new Mail(_fluentClient);
Segments = new Segments(_fluentClient);
SenderIdentities = new SenderIdentities(_fluentClient);
Settings = new Settings(_fluentClient);
SpamReports = new SpamReports(_fluentClient);
Statistics = new Statistics(_fluentClient);
Subusers = new Subusers(_fluentClient);
Suppressions = new Suppressions(_fluentClient);
Teammates = new Teammates(_fluentClient);
Templates = new Templates(_fluentClient);
UnsubscribeGroups = new UnsubscribeGroups(_fluentClient);
User = new User(_fluentClient);
WebhookSettings = new WebhookSettings(_fluentClient);
WebhookStats = new WebhookStats(_fluentClient);
Whitelabel = new Whitelabel(_fluentClient);
}
public void ValidateDomain()
{
// Arrange
var domainId = 1L;
var apiResponse = @"{
'id': 1,
'valid': true,
'validation_resuts': {
'mail_cname': {
'valid': false,
'reason': 'Expected your MX record to be \'mx.sendgrid.net\' but found \'example.com\'.'
},
'dkim1': {
'valid': true,
'reason': null
},
'dkim2': {
'valid': true,
'reason': null
},
'spf': {
'valid': true,
'reason': null
}
}
}" ;
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.PostAsync($"{ENDPOINT}/domains/{domainId}/validate", It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(apiResponse)
})
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
var result = whitelabel.ValidateDomainAsync(domainId).Result;
// Assert
result.ShouldNotBeNull();
result.DomainId.ShouldBe(1);
result.IsValid.ShouldBe(true);
result.ValidationResults.Dkim1.IsValid.ShouldBe(true);
result.ValidationResults.Dkim1.Reason.ShouldBeNull();
result.ValidationResults.Dkim2.IsValid.ShouldBe(true);
result.ValidationResults.Dkim2.Reason.ShouldBeNull();
result.ValidationResults.Mail.IsValid.ShouldBe(false);
result.ValidationResults.Mail.Reason.ShouldBe("Expected your MX record to be \'mx.sendgrid.net\' but found \'example.com\'.");
result.ValidationResults.Spf.IsValid.ShouldBe(true);
result.ValidationResults.Spf.Reason.ShouldBeNull();
}
public async Task ValidateDomainAsync()
{
// Arrange
var domainId = 1L;
var apiResponse = @"{
'id': 1,
'valid': true,
'validation_resuts': {
'mail_cname': {
'valid': false,
'reason': 'Expected your MX record to be \'mx.sendgrid.net\' but found \'example.com\'.'
},
'dkim1': {
'valid': true,
'reason': null
},
'dkim2': {
'valid': true,
'reason': null
},
'spf': {
'valid': true,
'reason': null
}
}
}" ;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Utils.GetSendGridApiUri(ENDPOINT, $"domains/{domainId}/validate")).Respond("application/json", apiResponse);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.ValidateDomainAsync(domainId).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
result.DomainId.ShouldBe(1);
result.IsValid.ShouldBe(true);
result.ValidationResults.Dkim1.IsValid.ShouldBe(true);
result.ValidationResults.Dkim1.Reason.ShouldBeNull();
result.ValidationResults.Dkim2.IsValid.ShouldBe(true);
result.ValidationResults.Dkim2.Reason.ShouldBeNull();
result.ValidationResults.Mail.IsValid.ShouldBe(false);
result.ValidationResults.Mail.Reason.ShouldBe("Expected your MX record to be \'mx.sendgrid.net\' but found \'example.com\'.");
result.ValidationResults.Spf.IsValid.ShouldBe(true);
result.ValidationResults.Spf.Reason.ShouldBeNull();
}
public void ValidateLink()
{
// Arrange
var linkId = 1L;
var apiResponse = @"{
'id': 1,
'valid': true,
'validation_results': {
'domain_cname': {
'valid': false,
'reason': 'Expected CNAME to match \'sendgrid.net.\' but found \'example.com.\'.'
},
'owner_cname': {
'valid': true,
'reason': null
}
}
}" ;
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.PostAsync($"{ENDPOINT}/links/{linkId}/validate", It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(apiResponse)
})
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
var result = whitelabel.ValidateLinkAsync(linkId).Result;
// Assert
result.ShouldNotBeNull();
result.LinkId.ShouldBe(1);
result.IsValid.ShouldBe(true);
result.ValidationResults.Domain.IsValid.ShouldBe(false);
result.ValidationResults.Domain.Reason.ShouldBe("Expected CNAME to match \'sendgrid.net.\' but found \'example.com.\'.");
result.ValidationResults.Owner.IsValid.ShouldBe(true);
result.ValidationResults.Owner.Reason.ShouldBeNull();
}
private Client(string apiKey, string username, string password, string baseUri, string apiVersion, HttpClient httpClient, IRetryStrategy retryStrategy)
{
_baseUri = new Uri(string.Format("{0}/{1}", baseUri, apiVersion));
_retryStrategy = retryStrategy ?? new SendGridRetryStrategy();
Alerts = new Alerts(this);
ApiKeys = new ApiKeys(this);
Batches = new Batches(this);
Blocks = new Blocks(this);
Campaigns = new Campaigns(this);
Categories = new Categories(this);
Contacts = new Contacts(this);
CustomFields = new CustomFields(this);
GlobalSuppressions = new GlobalSuppressions(this);
InvalidEmails = new InvalidEmails(this);
Lists = new Lists(this);
Mail = new Mail(this);
Segments = new Segments(this);
SenderIdentities = new SenderIdentities(this);
Settings = new Settings(this);
SpamReports = new SpamReports(this);
Statistics = new Statistics(this);
Suppressions = new Suppressions(this);
Templates = new Templates(this);
UnsubscribeGroups = new UnsubscribeGroups(this);
User = new User(this);
Version = typeof(Client).GetTypeInfo().Assembly.GetName().Version.ToString();
Whitelabel = new Whitelabel(this);
_mustDisposeHttpClient = httpClient == null;
_httpClient = httpClient ?? new HttpClient();
_httpClient.BaseAddress = _baseUri;
_httpClient.DefaultRequestHeaders.Accept.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(MEDIA_TYPE));
if (!string.IsNullOrEmpty(apiKey))
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
}
if (!string.IsNullOrEmpty(username))
{
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(Encoding.ASCII.GetBytes(string.Concat(username, ":", password))));
}
_httpClient.DefaultRequestHeaders.TryAddWithoutValidation("User-Agent", string.Format("StrongGrid/{0}", Version));
}
public async Task GetAllDomainsAsync_exclude_subusers()
{
// Arrange
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, Utils.GetSendGridApiUri(ENDPOINT, "domains?exclude_subusers=true&limit=50&offset=0&username=&domain=")).Respond("application/json", MULTIPLE_DOMAINS_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.GetAllDomainsAsync(excludeSubusers : true).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
result.Length.ShouldBe(2);
}
public void DeleteIp()
{
// Arrange
var domainId = 48L;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Delete, Utils.GetSendGridApiUri(ENDPOINT, "ips", domainId)).Respond(HttpStatusCode.OK);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
whitelabel.DeleteIpAsync(domainId, CancellationToken.None).Wait(CancellationToken.None);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
}
public void DisassociateDomain()
{
// Arrange
var username = "******";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Delete, Utils.GetSendGridApiUri(ENDPOINT, $"domains/subuser?username={username}")).Respond(HttpStatusCode.OK);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
whitelabel.DisassociateDomainAsync(username, CancellationToken.None).Wait(CancellationToken.None);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
}
public async Task DeleteLinkAsync()
{
// Arrange
var linkId = 48L;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Delete, Utils.GetSendGridApiUri(ENDPOINT, "links", linkId)).Respond(HttpStatusCode.OK);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
await whitelabel.DeleteLinkAsync(linkId, null, CancellationToken.None).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
}
public async Task GetAllLinksAsync()
{
// Arrange
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, Utils.GetSendGridApiUri(ENDPOINT, "links?limit=50&offset=0&ip=")).Respond("application/json", MULTIPLE_LINKS_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.GetAllLinksAsync().ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
result.Length.ShouldBe(2);
}
public async Task DisassociateLinkAsync()
{
// Arrange
var username = "******";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Delete, Utils.GetSendGridApiUri(ENDPOINT, $"links/subuser?username={username}")).Respond(HttpStatusCode.OK);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
await whitelabel.DisassociateLinkAsync(username, null, CancellationToken.None).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
}
public async Task GetIpAsync()
{
// Arrange
var id = 123L;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, Utils.GetSendGridApiUri(ENDPOINT, $"ips/{id}")).Respond("application/json", SINGLE_IP_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.GetIpAsync(id).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public void GetLink()
{
// Arrange
var linkId = 123L;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, Utils.GetSendGridApiUri(ENDPOINT, "links", linkId)).Respond("application/json", SINGLE_LINK_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = whitelabel.GetLinkAsync(linkId).Result;
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public async Task GetAssociatedLinkAsync()
{
// Arrange
var username = "******";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, Utils.GetSendGridApiUri(ENDPOINT, $"links/subuser?username={username}")).Respond("application/json", SINGLE_LINK_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.GetAssociatedLinkAsync(username, null, CancellationToken.None).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public void GetAssociatedDomain()
{
// Arrange
var username = "******";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, Utils.GetSendGridApiUri(ENDPOINT, $"domains/subuser?username={username}")).Respond("application/json", SINGLE_DOMAIN_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = whitelabel.GetAssociatedDomainAsync(username, CancellationToken.None).Result;
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public async Task GetDefaultLinkAsync()
{
// Arrange
var domain = "example.com";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Get, Utils.GetSendGridApiUri(ENDPOINT, $"links/default?domain={domain}")).Respond("application/json", SINGLE_LINK_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.GetDefaultLinkAsync(domain).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public void DisassociateDomain()
{
// Arrange
var username = "******";
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.DeleteAsync($"{ENDPOINT}/domains/subuser?username={username}", It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK))
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
whitelabel.DisassociateDomainAsync(username, CancellationToken.None).Wait(CancellationToken.None);
// Assert
}
public void DeleteLink()
{
// Arrange
var linkId = 48L;
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.DeleteAsync($"{ENDPOINT}/links/{linkId}", It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK))
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
whitelabel.DeleteLinkAsync(linkId, CancellationToken.None).Wait(CancellationToken.None);
// Assert
}
public async Task ValidateLinkAsync()
{
// Arrange
var linkId = 1L;
var apiResponse = @"{
'id': 1,
'valid': true,
'validation_results': {
'domain_cname': {
'valid': false,
'reason': 'Expected CNAME to match \'sendgrid.net.\' but found \'example.com.\'.'
},
'owner_cname': {
'valid': true,
'reason': null
}
}
}" ;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Utils.GetSendGridApiUri(ENDPOINT, "links", linkId, "validate")).Respond("application/json", apiResponse);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.ValidateLinkAsync(linkId).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
result.LinkId.ShouldBe(1);
result.IsValid.ShouldBe(true);
result.ValidationResults.Domain.IsValid.ShouldBe(false);
result.ValidationResults.Domain.Reason.ShouldBe("Expected CNAME to match \'sendgrid.net.\' but found \'example.com.\'.");
result.ValidationResults.Owner.IsValid.ShouldBe(true);
result.ValidationResults.Owner.Reason.ShouldBeNull();
}
public void DeleteIpAddressFromDomain()
{
// Arrange
var domainId = 48L;
var ipAddress = "192.168.77.1";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Delete, Utils.GetSendGridApiUri(ENDPOINT, $"domains/{domainId}/ips/{ipAddress}")).Respond("application/json", SINGLE_DOMAIN_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = whitelabel.DeleteIpAddressFromDomainAsync(domainId, ipAddress, CancellationToken.None).Result;
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public async Task AssociateDomainAsync()
{
// Arrange
var domainId = 123L;
var ipAddress = "192.168.77.1";
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Utils.GetSendGridApiUri(ENDPOINT, $"domains/{domainId}/subuser")).Respond("application/json", SINGLE_DOMAIN_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.AssociateDomainAsync(domainId, ipAddress, null, CancellationToken.None).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public async Task UpdateLinkAsync()
{
// Arrange
var linkId = 123L;
var isDefault = true;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(new HttpMethod("PATCH"), Utils.GetSendGridApiUri(ENDPOINT, "links", linkId)).Respond("application/json", SINGLE_LINK_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.UpdateLinkAsync(linkId, isDefault).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public async Task UpdateDomainAsync()
{
// Arrange
var domainId = 123L;
var customSpf = true;
var isDefault = false;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(new HttpMethod("PATCH"), Utils.GetSendGridApiUri(ENDPOINT, $"domains/{domainId}")).Respond("application/json", SINGLE_DOMAIN_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.UpdateDomainAsync(domainId, isDefault, customSpf, null, CancellationToken.None).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public async Task CreateLinkAsync()
{
// Arrange
var domain = "example.com";
var subdomain = "mail";
var isDefault = false;
var mockHttp = new MockHttpMessageHandler();
mockHttp.Expect(HttpMethod.Post, Utils.GetSendGridApiUri(ENDPOINT, "links")).Respond("application/json", SINGLE_LINK_JSON);
var client = Utils.GetFluentClient(mockHttp);
var whitelabel = new Whitelabel(client);
// Act
var result = await whitelabel.CreateLinkAsync(domain, subdomain, isDefault, null, CancellationToken.None).ConfigureAwait(false);
// Assert
mockHttp.VerifyNoOutstandingExpectation();
mockHttp.VerifyNoOutstandingRequest();
result.ShouldNotBeNull();
}
public void ValidateIp()
{
// Arrange
var id = 1L;
var apiResponse = @"{
'id': 1,
'valid': true,
'validation_results': {
'a_record': {
'valid': true,
'reason': null
}
}
}" ;
var mockRepository = new MockRepository(MockBehavior.Strict);
var mockClient = mockRepository.Create <IClient>();
mockClient
.Setup(c => c.PostAsync($"{ENDPOINT}/ips/{id}/validate", It.IsAny <JObject>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(apiResponse)
})
.Verifiable();
var whitelabel = new Whitelabel(mockClient.Object, ENDPOINT);
// Act
var result = whitelabel.ValidateIpAsync(id).Result;
// Assert
result.ShouldNotBeNull();
result.IpId.ShouldBe(1);
result.IsValid.ShouldBe(true);
result.ValidationResults.ARecord.IsValid.ShouldBe(true);
result.ValidationResults.ARecord.Reason.ShouldBeNull();
}
