Merge pull request #1342 from stripe/remi-add-webhook-endpoint

Add support for the Webhook Endpoint resource

Author: remi-stripe

src/Stripe.net/Entities/WebhookEndpoints/WebhookEndpoint.cs

@@ -0,0 +1,43 @@
+namespace Stripe
+{
+    using System;
+    using System.Collections.Generic;
+    using Newtonsoft.Json;
+    using Stripe.Infrastructure;
+
+    public class WebhookEndpoint : StripeEntity, IHasId, IHasObject
+    {
+        [JsonProperty("id")]
+        public string Id { get; set; }
+
+        [JsonProperty("object")]
+        public string Object { get; set; }
+
+        [JsonProperty("application")]
+        public string ApplicationId { get; set; }
+
+        [JsonProperty("connect")]
+        public bool Connect { get; set; }
+
+        [JsonProperty("created")]
+        public DateTime Created { get; set; }
+
+        [JsonProperty("deleted")]
+        public bool Deleted { get; set; }
+
+        [JsonProperty("enabled_events")]
+        public string[] EnabledEvents { get; set; }
+
+        [JsonProperty("livemode")]
+        public bool Livemode { get; set; }
+
+        [JsonProperty("secret")]
+        public string Secret { get; set; }
+
+        [JsonProperty("status")]
+        public string Status { get; set; }
+
+        [JsonProperty("url")]
+        public string Url { get; set; }
+    }
+}

src/Stripe.net/Services/WebhookEndpoints/WebhookEndpointCreateOptions.cs

@@ -0,0 +1,13 @@
+namespace Stripe
+{
+    using System;
+    using System.Collections.Generic;
+    using Newtonsoft.Json;
+    using Stripe.Infrastructure;
+
+    public class WebhookEndpointCreateOptions : WebhookEndpointSharedOptions
+    {
+        [JsonProperty("connect")]
+        public bool? Connect { get; set; }
+    }
+}

src/Stripe.net/Services/WebhookEndpoints/WebhookEndpointListOptions.cs

@@ -0,0 +1,8 @@
+namespace Stripe
+{
+    using Newtonsoft.Json;
+
+    public class WebhookEndpointListOptions : ListOptionsWithCreated
+    {
+    }
+}

src/Stripe.net/Services/WebhookEndpoints/WebhookEndpointService.cs

@@ -0,0 +1,78 @@
+namespace Stripe
+{
+    using System.Collections.Generic;
+    using System.Net;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Stripe.Infrastructure;
+
+    public class WebhookEndpointService : Service<WebhookEndpoint>,
+        ICreatable<WebhookEndpoint, WebhookEndpointCreateOptions>,
+        IDeletable<WebhookEndpoint>,
+        IListable<WebhookEndpoint, WebhookEndpointListOptions>,
+        IRetrievable<WebhookEndpoint>,
+        IUpdatable<WebhookEndpoint, WebhookEndpointUpdateOptions>
+    {
+        public WebhookEndpointService()
+            : base(null)
+        {
+        }
+
+        public WebhookEndpointService(string apiKey)
+            : base(apiKey)
+        {
+        }
+
+        public override string BasePath => "/webhook_endpoints";
+
+        public virtual WebhookEndpoint Create(WebhookEndpointCreateOptions options, RequestOptions requestOptions = null)
+        {
+            return this.CreateEntity(options, requestOptions);
+        }
+
+        public virtual Task<WebhookEndpoint> CreateAsync(WebhookEndpointCreateOptions options, RequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return this.CreateEntityAsync(options, requestOptions, cancellationToken);
+        }
+
+        public virtual WebhookEndpoint Delete(string endpointId, RequestOptions requestOptions = null)
+        {
+            return this.DeleteEntity(endpointId, null, requestOptions);
+        }
+
+        public virtual Task<WebhookEndpoint> DeleteAsync(string endpointId, RequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return this.DeleteEntityAsync(endpointId, null, requestOptions, cancellationToken);
+        }
+
+        public virtual WebhookEndpoint Get(string endpointId, RequestOptions requestOptions = null)
+        {
+            return this.GetEntity(endpointId, null, requestOptions);
+        }
+
+        public virtual Task<WebhookEndpoint> GetAsync(string endpointId, RequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return this.GetEntityAsync(endpointId, null, requestOptions, cancellationToken);
+        }
+
+        public virtual StripeList<WebhookEndpoint> List(WebhookEndpointListOptions options = null, RequestOptions requestOptions = null)
+        {
+            return this.ListEntities(options, requestOptions);
+        }
+
+        public virtual Task<StripeList<WebhookEndpoint>> ListAsync(WebhookEndpointListOptions options = null, RequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return this.ListEntitiesAsync(options, requestOptions, cancellationToken);
+        }
+
+        public virtual WebhookEndpoint Update(string endpointId, WebhookEndpointUpdateOptions options, RequestOptions requestOptions = null)
+        {
+            return this.UpdateEntity(endpointId, options, requestOptions);
+        }
+
+        public virtual Task<WebhookEndpoint> UpdateAsync(string endpointId, WebhookEndpointUpdateOptions options, RequestOptions requestOptions = null, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            return this.UpdateEntityAsync(endpointId, options, requestOptions, cancellationToken);
+        }
+    }
+}

src/Stripe.net/Services/WebhookEndpoints/WebhookEndpointSharedOptions.cs

@@ -0,0 +1,14 @@
+namespace Stripe
+{
+    using System.Collections.Generic;
+    using Newtonsoft.Json;
+
+    public abstract class WebhookEndpointSharedOptions : BaseOptions
+    {
+        [JsonProperty("enabled_events")]
+        public string[] EnabledEvents { get; set; }
+
+        [JsonProperty("url")]
+        public string Url { get; set; }
+    }
+}

src/Stripe.net/Services/WebhookEndpoints/WebhookEndpointUpdateOptions.cs

@@ -0,0 +1,11 @@
+namespace Stripe
+{
+    using System.Collections.Generic;
+    using Newtonsoft.Json;
+
+    public class WebhookEndpointUpdateOptions : WebhookEndpointSharedOptions
+    {
+        [JsonProperty("disabled")]
+        public bool? Disabled { get; set; }
+    }
+}

src/StripeTests/Entities/WebhookEndpoints/WebhookEndpointTest.cs

@@ -0,0 +1,24 @@
+namespace StripeTests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+
+    using Newtonsoft.Json;
+    using Stripe;
+    using Xunit;
+
+    public class WebhookEndpointTest : BaseStripeTest
+    {
+        [Fact]
+        public void Deserialize()
+        {
+            string json = GetFixture("/v1/webhook_endpoints/we_123");
+            var endpoint = Mapper<WebhookEndpoint>.MapFromJson(json);
+            Assert.NotNull(endpoint);
+            Assert.IsType<WebhookEndpoint>(endpoint);
+            Assert.NotNull(endpoint.Id);
+            Assert.Equal("webhook_endpoint", endpoint.Object);
+        }
+    }
+}

src/StripeTests/Services/WebhookEndpoints/WebhookEndpointServiceTest.cs

@@ -0,0 +1,138 @@
+namespace StripeTests
+{
+    using System.Collections.Generic;
+    using System.Net.Http;
+    using System.Threading.Tasks;
+
+    using Stripe;
+    using Xunit;
+
+    public class WebhookEndpointServiceTest : BaseStripeTest
+    {
+        private const string WebhookEndpointId = "we_123";
+
+        private WebhookEndpointService service;
+        private WebhookEndpointCreateOptions createOptions;
+        private WebhookEndpointUpdateOptions updateOptions;
+        private WebhookEndpointListOptions listOptions;
+
+        public WebhookEndpointServiceTest()
+        {
+            this.service = new WebhookEndpointService();
+
+            this.createOptions = new WebhookEndpointCreateOptions()
+            {
+                EnabledEvents = new string[]
+                {
+                    "charge.succeeded",
+                },
+                Url = "https://stripe.com",
+            };
+
+            this.updateOptions = new WebhookEndpointUpdateOptions()
+            {
+                EnabledEvents = new string[]
+                {
+                    "charge.succeeded",
+                },
+            };
+
+            this.listOptions = new WebhookEndpointListOptions()
+            {
+                Limit = 1,
+            };
+        }
+
+        [Fact]
+        public void Create()
+        {
+            var endpoint = this.service.Create(this.createOptions);
+            this.AssertRequest(HttpMethod.Post, "/v1/webhook_endpoints");
+            Assert.NotNull(endpoint);
+            Assert.Equal("webhook_endpoint", endpoint.Object);
+        }
+
+        [Fact]
+        public async Task CreateAsync()
+        {
+            var endpoint = await this.service.CreateAsync(this.createOptions);
+            this.AssertRequest(HttpMethod.Post, "/v1/webhook_endpoints");
+            Assert.NotNull(endpoint);
+            Assert.Equal("webhook_endpoint", endpoint.Object);
+        }
+
+        [Fact]
+        public void Delete()
+        {
+            var deleted = this.service.Delete(WebhookEndpointId);
+            this.AssertRequest(HttpMethod.Delete, "/v1/webhook_endpoints/we_123");
+            Assert.NotNull(deleted);
+        }
+
+        [Fact]
+        public async Task DeleteAsync()
+        {
+            var deleted = await this.service.DeleteAsync(WebhookEndpointId);
+            this.AssertRequest(HttpMethod.Delete, "/v1/webhook_endpoints/we_123");
+            Assert.NotNull(deleted);
+        }
+
+        [Fact]
+        public void Get()
+        {
+            var endpoint = this.service.Get(WebhookEndpointId);
+            this.AssertRequest(HttpMethod.Get, "/v1/webhook_endpoints/we_123");
+            Assert.NotNull(endpoint);
+            Assert.Equal("webhook_endpoint", endpoint.Object);
+        }
+
+        [Fact]
+        public async Task GetAsync()
+        {
+            var endpoint = await this.service.GetAsync(WebhookEndpointId);
+            this.AssertRequest(HttpMethod.Get, "/v1/webhook_endpoints/we_123");
+            Assert.NotNull(endpoint);
+            Assert.Equal("webhook_endpoint", endpoint.Object);
+        }
+
+        [Fact]
+        public void List()
+        {
+            var endpoints = this.service.List(this.listOptions);
+            this.AssertRequest(HttpMethod.Get, "/v1/webhook_endpoints");
+            Assert.NotNull(endpoints);
+            Assert.Equal("list", endpoints.Object);
+            Assert.Single(endpoints.Data);
+            Assert.Equal("webhook_endpoint", endpoints.Data[0].Object);
+        }
+
+        [Fact]
+        public async Task ListAsync()
+        {
+            var endpoints = await this.service.ListAsync(this.listOptions);
+            this.AssertRequest(HttpMethod.Get, "/v1/webhook_endpoints");
+            Assert.NotNull(endpoints);
+            Assert.Equal("list", endpoints.Object);
+            Assert.Single(endpoints.Data);
+            Assert.Equal("webhook_endpoint", endpoints.Data[0].Object);
+        }
+
+        [Fact]
+        public void Update()
+        {
+            var endpoint = this.service.Update(WebhookEndpointId, this.updateOptions);
+            this.AssertRequest(HttpMethod.Post, "/v1/webhook_endpoints/we_123");
+            Assert.NotNull(endpoint);
+            Assert.Equal("webhook_endpoint", endpoint.Object);
+        }
+
+        [Fact]
+        public async Task UpdateAsync()
+        {
+            var endpoint = await this.service.UpdateAsync(WebhookEndpointId, this.updateOptions);
+            this.AssertRequest(HttpMethod.Post, "/v1/webhook_endpoints/we_123");
+            Assert.NotNull(endpoint);
+            Assert.Equal("webhook_endpoint", endpoint.Object);
+        }
+    }
+}