client.TestWebhooksService_Delete - Code Metrics - Inspection of "Add webhook tests" - NdoleStudio/lemonsqueezy-go - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — main ( 2b8b96...6e7fbc )

by Acho

created 2023-06-21 14:41 UTC

client.TestWebhooksService_Delete A

↳ Parent: webhooks_service_test.go

Complexity

Conditions

Size

Total Lines	18
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	8
nop	1
dl	0
loc	18
rs	10
c	0
b	0
f	0

package client

import (
	"context"
	"net/http"
	"testing"

	"github.com/NdoleStudio/lemonsqueezy-go/internal/helpers"

	"github.com/NdoleStudio/lemonsqueezy-go/internal/stubs"
	"github.com/stretchr/testify/assert"
)

func TestWebhooksService_Verify(t *testing.T) {
	// Arrange
	signingSecret := "signing-secret"
	client := New(WithSigningSecret(signingSecret))

	// Act
	isValid := client.Webhooks.Verify(context.Background(), "743c0dcfaab3a3d06198183501fb92cc82e548febc80937f3fb236a4932f748f", stubs.WebhookRequestOrderCreated())

	// Assert
	assert.True(t, isValid)
}

func TestWebhooksService_Create(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusCreated, stubs.WebhookGetResponse())
	client := New(WithBaseURL(server.URL))

	// Act
	webhook, response, err := client.Webhooks.Create(context.Background(), &WebhookCreateParams{
		URL:     "https://mysite.com/webhooks/",
		Events:  []string{"order_created", "subscription_created"},
		Secret:  "SIGNING_SECRET",
		StoreID: "1",
	})

	// Assert
	assert.Nil(t, err)

	assert.Equal(t, http.StatusCreated, response.HTTPResponse.StatusCode)
	assert.Equal(t, stubs.WebhookGetResponse(), *response.Body)
	assert.Equal(t, "1", webhook.Data.ID)

	// Teardown
	server.Close()
}

func TestWebhooksService_CreateWithError(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
	client := New(WithBaseURL(server.URL))

	// Act
	_, response, err := client.Webhooks.Create(context.Background(), &WebhookCreateParams{
		URL:     "https://mysite.com/webhooks/",
		Events:  []string{"order_created", "subscription_created"},
		Secret:  "SIGNING_SECRET",
		StoreID: "1",
	})

	// Assert
	assert.NotNil(t, err)

	assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)

	// Teardown
	server.Close()
}

func TestWebhooksService_Get(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusOK, stubs.WebhookGetResponse())
	client := New(WithBaseURL(server.URL))

	// Act
	webhook, response, err := client.Webhooks.Get(context.Background(), "1")

	// Assert
	assert.Nil(t, err)

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
	assert.Equal(t, stubs.WebhookGetResponse(), *response.Body)
	assert.Equal(t, "1", webhook.Data.ID)

	// Teardown
	server.Close()
}

func TestWebhooksService_GetWithError(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
	client := New(WithBaseURL(server.URL))

	// Act
	_, response, err := client.Webhooks.Get(context.Background(), "1")

	// Assert
	assert.NotNil(t, err)

	assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)

	// Teardown
	server.Close()
}

func TestWebhooksService_Delete(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusNoContent, nil)
	client := New(WithBaseURL(server.URL))

	// Act
	response, err := client.Webhooks.Delete(context.Background(), "1")

	// Assert
	assert.Nil(t, err)

	assert.Equal(t, http.StatusNoContent, response.HTTPResponse.StatusCode)

	// Teardown
	server.Close()
}

func TestWebhooksService_DeleteWithError(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
	client := New(WithBaseURL(server.URL))

	// Act
	response, err := client.Webhooks.Delete(context.Background(), "1")

	// Assert
	assert.NotNil(t, err)

	assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)

	// Teardown
	server.Close()
}

func TestWebhooksService_List(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusOK, stubs.WebhooksListResponse())
	client := New(WithBaseURL(server.URL))

	// Act
	webhooks, response, err := client.Webhooks.List(context.Background())

	// Assert
	assert.Nil(t, err)

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
	assert.Equal(t, stubs.WebhooksListResponse(), *response.Body)
	assert.Equal(t, 1, len(webhooks.Data))

	// Teardown
	server.Close()
}

func TestWebhooksService_ListWithError(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
	client := New(WithBaseURL(server.URL))

	// Act
	_, response, err := client.Webhooks.List(context.Background())

	// Assert
	assert.NotNil(t, err)

	assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)

	// Teardown
	server.Close()
}

func TestWebhooksService_Update(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusOK, stubs.WebhookGetResponse())
	client := New(WithBaseURL(server.URL))

	// Act
	webhook, response, err := client.Webhooks.Update(context.Background(), &WebhookUpdateParams{
		ID:     "1",
		Events: []string{"order_created", "subscription_created"},
		Secret: "SIGNING_SECRET",
	})

	// Assert
	assert.Nil(t, err)

	assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
	assert.Equal(t, stubs.WebhookGetResponse(), *response.Body)
	assert.Equal(t, "1", webhook.Data.ID)

	// Teardown
	server.Close()
}

func TestWebhooksService_UpdateWithError(t *testing.T) {
	// Setup
	t.Parallel()

	// Arrange
	server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
	client := New(WithBaseURL(server.URL))

	// Act
	_, response, err := client.Webhooks.Update(context.Background(), &WebhookUpdateParams{})

	// Assert
	assert.NotNil(t, err)

	assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)

	// Teardown
	server.Close()
}


1			package client
2
3			import (
4			"context"
5			"net/http"
6			"testing"
7
8			"github.com/NdoleStudio/lemonsqueezy-go/internal/helpers"
9
10			"github.com/NdoleStudio/lemonsqueezy-go/internal/stubs"
11			"github.com/stretchr/testify/assert"
12			)
13
14			func TestWebhooksService_Verify(t *testing.T) {
15			// Arrange
16			signingSecret := "signing-secret"
17			client := New(WithSigningSecret(signingSecret))
18
19			// Act
20			isValid := client.Webhooks.Verify(context.Background(), "743c0dcfaab3a3d06198183501fb92cc82e548febc80937f3fb236a4932f748f", stubs.WebhookRequestOrderCreated())
21
22			// Assert
23			assert.True(t, isValid)
24			}
25
26			func TestWebhooksService_Create(t *testing.T) {
27			// Setup
28			t.Parallel()
29
30			// Arrange
31			server := helpers.MakeTestServer(http.StatusCreated, stubs.WebhookGetResponse())
32			client := New(WithBaseURL(server.URL))
33
34			// Act
35			webhook, response, err := client.Webhooks.Create(context.Background(), &WebhookCreateParams{
36			URL: "https://mysite.com/webhooks/",
37			Events: []string{"order_created", "subscription_created"},
38			Secret: "SIGNING_SECRET",
39			StoreID: "1",
40			})
41
42			// Assert
43			assert.Nil(t, err)
44
45			assert.Equal(t, http.StatusCreated, response.HTTPResponse.StatusCode)
46			assert.Equal(t, stubs.WebhookGetResponse(), *response.Body)
47			assert.Equal(t, "1", webhook.Data.ID)
48
49			// Teardown
50			server.Close()
51			}
52
53			func TestWebhooksService_CreateWithError(t *testing.T) {
54			// Setup
55			t.Parallel()
56
57			// Arrange
58			server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
59			client := New(WithBaseURL(server.URL))
60
61			// Act
62			_, response, err := client.Webhooks.Create(context.Background(), &WebhookCreateParams{
63			URL: "https://mysite.com/webhooks/",
64			Events: []string{"order_created", "subscription_created"},
65			Secret: "SIGNING_SECRET",
66			StoreID: "1",
67			})
68
69			// Assert
70			assert.NotNil(t, err)
71
72			assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)
73
74			// Teardown
75			server.Close()
76			}
77
78			func TestWebhooksService_Get(t *testing.T) {
79			// Setup
80			t.Parallel()
81
82			// Arrange
83			server := helpers.MakeTestServer(http.StatusOK, stubs.WebhookGetResponse())
84			client := New(WithBaseURL(server.URL))
85
86			// Act
87			webhook, response, err := client.Webhooks.Get(context.Background(), "1")
88
89			// Assert
90			assert.Nil(t, err)
91
92			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
93			assert.Equal(t, stubs.WebhookGetResponse(), *response.Body)
94			assert.Equal(t, "1", webhook.Data.ID)
95
96			// Teardown
97			server.Close()
98			}
99
100			func TestWebhooksService_GetWithError(t *testing.T) {
101			// Setup
102			t.Parallel()
103
104			// Arrange
105			server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
106			client := New(WithBaseURL(server.URL))
107
108			// Act
109			_, response, err := client.Webhooks.Get(context.Background(), "1")
110
111			// Assert
112			assert.NotNil(t, err)
113
114			assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)
115
116			// Teardown
117			server.Close()
118			}
119
120			func TestWebhooksService_Delete(t *testing.T) {
121			// Setup
122			t.Parallel()
123
124			// Arrange
125			server := helpers.MakeTestServer(http.StatusNoContent, nil)
126			client := New(WithBaseURL(server.URL))
127
128			// Act
129			response, err := client.Webhooks.Delete(context.Background(), "1")
130
131			// Assert
132			assert.Nil(t, err)
133
134			assert.Equal(t, http.StatusNoContent, response.HTTPResponse.StatusCode)
135
136			// Teardown
137			server.Close()
138			}
139
140			func TestWebhooksService_DeleteWithError(t *testing.T) {
141			// Setup
142			t.Parallel()
143
144			// Arrange
145			server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
146			client := New(WithBaseURL(server.URL))
147
148			// Act
149			response, err := client.Webhooks.Delete(context.Background(), "1")
150
151			// Assert
152			assert.NotNil(t, err)
153
154			assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)
155
156			// Teardown
157			server.Close()
158			}
159
160			func TestWebhooksService_List(t *testing.T) {
161			// Setup
162			t.Parallel()
163
164			// Arrange
165			server := helpers.MakeTestServer(http.StatusOK, stubs.WebhooksListResponse())
166			client := New(WithBaseURL(server.URL))
167
168			// Act
169			webhooks, response, err := client.Webhooks.List(context.Background())
170
171			// Assert
172			assert.Nil(t, err)
173
174			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
175			assert.Equal(t, stubs.WebhooksListResponse(), *response.Body)
176			assert.Equal(t, 1, len(webhooks.Data))
177
178			// Teardown
179			server.Close()
180			}
181
182			func TestWebhooksService_ListWithError(t *testing.T) {
183			// Setup
184			t.Parallel()
185
186			// Arrange
187			server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
188			client := New(WithBaseURL(server.URL))
189
190			// Act
191			_, response, err := client.Webhooks.List(context.Background())
192
193			// Assert
194			assert.NotNil(t, err)
195
196			assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)
197
198			// Teardown
199			server.Close()
200			}
201
202			func TestWebhooksService_Update(t *testing.T) {
203			// Setup
204			t.Parallel()
205
206			// Arrange
207			server := helpers.MakeTestServer(http.StatusOK, stubs.WebhookGetResponse())
208			client := New(WithBaseURL(server.URL))
209
210			// Act
211			webhook, response, err := client.Webhooks.Update(context.Background(), &WebhookUpdateParams{
212			ID: "1",
213			Events: []string{"order_created", "subscription_created"},
214			Secret: "SIGNING_SECRET",
215			})
216
217			// Assert
218			assert.Nil(t, err)
219
220			assert.Equal(t, http.StatusOK, response.HTTPResponse.StatusCode)
221			assert.Equal(t, stubs.WebhookGetResponse(), *response.Body)
222			assert.Equal(t, "1", webhook.Data.ID)
223
224			// Teardown
225			server.Close()
226			}
227
228			func TestWebhooksService_UpdateWithError(t *testing.T) {
229			// Setup
230			t.Parallel()
231
232			// Arrange
233			server := helpers.MakeTestServer(http.StatusInternalServerError, nil)
234			client := New(WithBaseURL(server.URL))
235
236			// Act
237			_, response, err := client.Webhooks.Update(context.Background(), &WebhookUpdateParams{})
238
239			// Assert
240			assert.NotNil(t, err)
241
242			assert.Equal(t, http.StatusInternalServerError, response.HTTPResponse.StatusCode)
243
244			// Teardown
245			server.Close()
246			}
247

NdoleStudio / lemonsqueezy-go

Push — main ( 2b8b96...6e7fbc )

client.TestWebhooksService_Delete A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like