feat: add tests for webhook resolvers

server/test/add_webhook_test.go

@@ -1 +1,39 @@
 package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/authorizerdev/authorizer/server/constants"
+	"github.com/authorizerdev/authorizer/server/crypto"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/resolvers"
+	"github.com/stretchr/testify/assert"
+)
+
+func addWebhookTest(t *testing.T, s TestSetup) {
+	t.Helper()
+	t.Run("should add webhook", func(t *testing.T) {
+		req, ctx := createContext(s)
+		adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
+		assert.NoError(t, err)
+		h, err := crypto.EncryptPassword(adminSecret)
+		assert.NoError(t, err)
+		req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
+
+		for _, eventType := range s.TestInfo.TestEventTypes {
+			webhook, err := resolvers.AddWebhookResolver(ctx, model.AddWebhookRequest{
+				EventName: eventType,
+				Endpoint:  s.TestInfo.WebhookEndpoint,
+				Enabled:   true,
+				Headers: map[string]interface{}{
+					"x-test": "foo",
+				},
+			})
+			assert.NoError(t, err)
+			assert.NotNil(t, webhook)
+			assert.NotEmpty(t, webhook.Message)
+		}
+	})
+}

server/test/delete_webhook_test.go

@@ -1 +1,50 @@
 package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/authorizerdev/authorizer/server/constants"
+	"github.com/authorizerdev/authorizer/server/crypto"
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/resolvers"
+	"github.com/stretchr/testify/assert"
+)
+
+func deleteWebhookTest(t *testing.T, s TestSetup) {
+	t.Helper()
+	t.Run("should delete webhook", func(t *testing.T) {
+		req, ctx := createContext(s)
+		adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
+		assert.NoError(t, err)
+		h, err := crypto.EncryptPassword(adminSecret)
+		assert.NoError(t, err)
+		req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
+
+		// get all webhooks
+		webhooks, err := db.Provider.ListWebhook(ctx, model.Pagination{})
+		assert.NoError(t, err)
+
+		for _, w := range webhooks.Webhooks {
+			res, err := resolvers.DeleteWebhookResolver(ctx, model.WebhookRequest{
+				ID: w.ID,
+			})
+
+			assert.NoError(t, err)
+			assert.NotNil(t, res)
+			assert.NotEmpty(t, res.Message)
+		}
+
+		webhooks, err = db.Provider.ListWebhook(ctx, model.Pagination{})
+		assert.NoError(t, err)
+		assert.Len(t, webhooks.Webhooks, 0)
+
+		webhookLogs, err := db.Provider.ListWebhookLogs(ctx, model.Pagination{
+			Limit: 10,
+		}, "")
+		assert.NoError(t, err)
+		assert.Len(t, webhookLogs.WebhookLogs, 0)
+	})
+}

server/test/resolvers_test.go

@@ -3,6 +3,7 @@ package test
 import (
 	"context"
 	"testing"
+	"time"
 
 	"github.com/authorizerdev/authorizer/server/constants"
 	"github.com/authorizerdev/authorizer/server/db"
@@ -13,8 +14,8 @@ import (
 func TestResolvers(t *testing.T) {
 	databases := map[string]string{
 		constants.DbTypeSqlite: "../../data.db",
-		// constants.DbTypeArangodb: "http://localhost:8529",
-		// constants.DbTypeMongodb:  "mongodb://localhost:27017",
+		// constants.DbTypeArangodb:    "http://localhost:8529",
+		// constants.DbTypeMongodb:     "mongodb://localhost:27017",
 		// constants.DbTypeCassandraDB: "127.0.0.1:9042",
 	}
 
@@ -41,9 +42,14 @@ func TestResolvers(t *testing.T) {
 		memorystore.Provider.UpdateEnvVariable(constants.EnvKeyEnv, "test")
 		memorystore.Provider.UpdateEnvVariable(constants.EnvKeyIsProd, false)
 		t.Run("should pass tests for "+dbType, func(t *testing.T) {
-			// admin tests
+			// admin resolvers tests
 			adminSignupTests(t, s)
+			addWebhookTest(t, s) // add webhooks for all the system events
+			testEndpointTest(t, s)
 			verificationRequestsTest(t, s)
+			updateWebhookTest(t, s)
+			webhookTest(t, s)
+			webhooksTest(t, s)
 			usersTest(t, s)
 			deleteUserTest(t, s)
 			updateUserTest(t, s)
@@ -56,7 +62,7 @@ func TestResolvers(t *testing.T) {
 			enableAccessTest(t, s)
 			generateJWTkeyTest(t, s)
 
-			// user tests
+			// user resolvers tests
 			loginTests(t, s)
 			signupTests(t, s)
 			forgotPasswordTest(t, s)
@@ -71,6 +77,10 @@ func TestResolvers(t *testing.T) {
 			metaTests(t, s)
 			inviteUserTest(t, s)
 			validateJwtTokenTest(t, s)
+
+			time.Sleep(5 * time.Second) // add sleep for webhooklogs to get generated as they are async
+			webhookLogsTest(t, s)       // get logs after above resolver tests are done
+			deleteWebhookTest(t, s)     // delete webhooks (admin resolver)
 		})
 	}
 }

server/test/test.go

@@ -21,8 +21,10 @@ import (
 
 // common user data to share across tests
 type TestData struct {
-	Email    string
-	Password string
+	Email           string
+	Password        string
+	WebhookEndpoint string
+	TestEventTypes  []string
 }
 
 type TestSetup struct {
@@ -75,8 +77,10 @@ func createContext(s TestSetup) (*http.Request, context.Context) {
 
 func testSetup() TestSetup {
 	testData := TestData{
-		Email:    fmt.Sprintf("%d_authorizer_tester@yopmail.com", time.Now().Unix()),
-		Password: "Test@123",
+		Email:           fmt.Sprintf("%d_authorizer_tester@yopmail.com", time.Now().Unix()),
+		Password:        "Test@123",
+		WebhookEndpoint: "https://62cbc6738042b16aa7c22df2.mockapi.io/api/v1/webhook",
+		TestEventTypes:  []string{constants.UserAccessEnabledWebhookEvent, constants.UserAccessRevokedWebhookEvent, constants.UserCreatedWebhookEvent, constants.UserDeletedWebhookEvent, constants.UserLoginWebhookEvent, constants.UserSignUpWebhookEvent},
 	}
 
 	err := os.Setenv(constants.EnvKeyEnvPath, "../../.env.test")

server/test/test_endpoint_test.go

@@ -1 +1,37 @@
 package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/authorizerdev/authorizer/server/constants"
+	"github.com/authorizerdev/authorizer/server/crypto"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/resolvers"
+	"github.com/stretchr/testify/assert"
+)
+
+func testEndpointTest(t *testing.T, s TestSetup) {
+	t.Helper()
+	t.Run("should test endpoint", func(t *testing.T) {
+		req, ctx := createContext(s)
+		adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
+		assert.NoError(t, err)
+		h, err := crypto.EncryptPassword(adminSecret)
+		assert.NoError(t, err)
+		req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
+
+		res, err := resolvers.TestEndpointResolver(ctx, model.TestEndpointRequest{
+			Endpoint:  s.TestInfo.WebhookEndpoint,
+			EventName: constants.UserLoginWebhookEvent,
+			Headers: map[string]interface{}{
+				"x-test": "test",
+			},
+		})
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.GreaterOrEqual(t, int64(201), *res.HTTPStatus)
+		assert.NotEmpty(t, res.Response)
+	})
+}

server/test/update_webhook_test.go

@@ -1 +1,60 @@
 package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/authorizerdev/authorizer/server/constants"
+	"github.com/authorizerdev/authorizer/server/crypto"
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/resolvers"
+	"github.com/authorizerdev/authorizer/server/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func updateWebhookTest(t *testing.T, s TestSetup) {
+	t.Helper()
+	t.Run("should update webhook", func(t *testing.T) {
+		req, ctx := createContext(s)
+		adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
+		assert.NoError(t, err)
+		h, err := crypto.EncryptPassword(adminSecret)
+		assert.NoError(t, err)
+		req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
+		// get webhook
+		webhook, err := db.Provider.GetWebhookByEventName(ctx, constants.UserDeletedWebhookEvent)
+		assert.NoError(t, err)
+		assert.NotNil(t, webhook)
+		webhook.Headers["x-new-test"] = "new-test"
+
+		res, err := resolvers.UpdateWebhookResolver(ctx, model.UpdateWebhookRequest{
+			ID:      webhook.ID,
+			Headers: webhook.Headers,
+			Enabled: utils.NewBoolRef(false),
+		})
+
+		assert.NoError(t, err)
+		assert.NotEmpty(t, res)
+		assert.NotEmpty(t, res.Message)
+
+		updatedWebhook, err := db.Provider.GetWebhookByEventName(ctx, constants.UserDeletedWebhookEvent)
+		assert.NoError(t, err)
+		assert.NotNil(t, updatedWebhook)
+		assert.Equal(t, webhook.ID, updatedWebhook.ID)
+		assert.Equal(t, utils.StringValue(webhook.EventName), utils.StringValue(updatedWebhook.EventName))
+		assert.Equal(t, utils.StringValue(webhook.Endpoint), utils.StringValue(updatedWebhook.Endpoint))
+		assert.Len(t, updatedWebhook.Headers, 2)
+		assert.False(t, utils.BoolValue(updatedWebhook.Enabled))
+
+		res, err = resolvers.UpdateWebhookResolver(ctx, model.UpdateWebhookRequest{
+			ID:      webhook.ID,
+			Headers: webhook.Headers,
+			Enabled: utils.NewBoolRef(true),
+		})
+		assert.NoError(t, err)
+		assert.NotEmpty(t, res)
+		assert.NotEmpty(t, res.Message)
+	})
+}

server/test/webhook_logs_test.go

@@ -1 +1,45 @@
 package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/authorizerdev/authorizer/server/constants"
+	"github.com/authorizerdev/authorizer/server/crypto"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/resolvers"
+	"github.com/authorizerdev/authorizer/server/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func webhookLogsTest(t *testing.T, s TestSetup) {
+	t.Helper()
+	t.Run("should get webhook logs", func(t *testing.T) {
+		req, ctx := createContext(s)
+		adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
+		assert.NoError(t, err)
+		h, err := crypto.EncryptPassword(adminSecret)
+		assert.NoError(t, err)
+		req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
+
+		webhooks, err := resolvers.WebhooksResolver(ctx, nil)
+		assert.NoError(t, err)
+		assert.NotEmpty(t, webhooks)
+
+		webhookLogs, err := resolvers.WebhookLogsResolver(ctx, model.ListWebhookLogRequest{})
+		assert.NoError(t, err)
+		assert.Greater(t, len(webhookLogs.WebhookLogs), 1)
+
+		for _, w := range webhooks.Webhooks {
+			webhookLogs, err := resolvers.WebhookLogsResolver(ctx, model.ListWebhookLogRequest{
+				WebhookID: &w.ID,
+			})
+			assert.NoError(t, err)
+			assert.GreaterOrEqual(t, len(webhookLogs.WebhookLogs), 1)
+			for _, wl := range webhookLogs.WebhookLogs {
+				assert.Equal(t, utils.StringValue(wl.WebhookID), w.ID)
+			}
+		}
+	})
+}

server/test/webhook_test.go

@@ -0,0 +1,42 @@
+package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/authorizerdev/authorizer/server/constants"
+	"github.com/authorizerdev/authorizer/server/crypto"
+	"github.com/authorizerdev/authorizer/server/db"
+	"github.com/authorizerdev/authorizer/server/graph/model"
+	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/resolvers"
+	"github.com/authorizerdev/authorizer/server/utils"
+	"github.com/stretchr/testify/assert"
+)
+
+func webhookTest(t *testing.T, s TestSetup) {
+	t.Helper()
+	t.Run("should get webhook", func(t *testing.T) {
+		req, ctx := createContext(s)
+		adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
+		assert.NoError(t, err)
+		h, err := crypto.EncryptPassword(adminSecret)
+		assert.NoError(t, err)
+		req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
+
+		// get webhook by event name
+		webhook, err := db.Provider.GetWebhookByEventName(ctx, constants.UserCreatedWebhookEvent)
+		assert.NoError(t, err)
+		assert.NotNil(t, webhook)
+
+		res, err := resolvers.WebhookResolver(ctx, model.WebhookRequest{
+			ID: webhook.ID,
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, res.ID, webhook.ID)
+		assert.Equal(t, utils.StringValue(res.Endpoint), utils.StringValue(webhook.Endpoint))
+		assert.Equal(t, utils.StringValue(res.EventName), utils.StringValue(webhook.EventName))
+		assert.Equal(t, utils.BoolValue(res.Enabled), utils.BoolValue(webhook.Enabled))
+		assert.Len(t, res.Headers, len(webhook.Headers))
+	})
+}

server/test/webhooks_test.go

@@ -1 +1,29 @@
 package test
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/authorizerdev/authorizer/server/constants"
+	"github.com/authorizerdev/authorizer/server/crypto"
+	"github.com/authorizerdev/authorizer/server/memorystore"
+	"github.com/authorizerdev/authorizer/server/resolvers"
+	"github.com/stretchr/testify/assert"
+)
+
+func webhooksTest(t *testing.T, s TestSetup) {
+	t.Helper()
+	t.Run("should get webhooks", func(t *testing.T) {
+		req, ctx := createContext(s)
+		adminSecret, err := memorystore.Provider.GetStringStoreEnvVariable(constants.EnvKeyAdminSecret)
+		assert.NoError(t, err)
+		h, err := crypto.EncryptPassword(adminSecret)
+		assert.NoError(t, err)
+		req.Header.Set("Cookie", fmt.Sprintf("%s=%s", constants.AdminCookieName, h))
+
+		webhooks, err := resolvers.WebhooksResolver(ctx, nil)
+		assert.NoError(t, err)
+		assert.NotEmpty(t, webhooks)
+		assert.Len(t, webhooks.Webhooks, len(s.TestInfo.TestEventTypes))
+	})
+}