github.com/clerkinc/clerk-sdk-go@v1.49.1/clerk/instances_test.go (about)

     1  package clerk
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"net/http"
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  )
    11  
    12  func TestInstanceService_Update_happyPath(t *testing.T) {
    13  	token := "token"
    14  	client, mux, _, teardown := setup(token)
    15  	defer teardown()
    16  
    17  	mux.HandleFunc("/instance", func(w http.ResponseWriter, req *http.Request) {
    18  		testHttpMethod(t, req, http.MethodPatch)
    19  		testHeader(t, req, "Authorization", "Bearer "+token)
    20  		w.WriteHeader(http.StatusNoContent)
    21  	})
    22  
    23  	enabled := true
    24  	supportEmail := "support@clerk.dev"
    25  	clerkJSVersion := "42"
    26  	err := client.Instances().Update(UpdateInstanceParams{
    27  		TestMode:                    &enabled,
    28  		HIBP:                        &enabled,
    29  		EnhancedEmailDeliverability: &enabled,
    30  		SupportEmail:                &supportEmail,
    31  		ClerkJSVersion:              &clerkJSVersion,
    32  	})
    33  
    34  	if err != nil {
    35  		t.Errorf("expected no error to be returned, found %v instead", err)
    36  	}
    37  }
    38  
    39  func TestInstanceService_Update_invalidServer(t *testing.T) {
    40  	client, _ := NewClient("token")
    41  
    42  	enabled := true
    43  	supportEmail := "support@clerk.dev"
    44  	clerkJSVersion := "999"
    45  	err := client.Instances().Update(UpdateInstanceParams{
    46  		TestMode:                    &enabled,
    47  		HIBP:                        &enabled,
    48  		EnhancedEmailDeliverability: &enabled,
    49  		SupportEmail:                &supportEmail,
    50  		ClerkJSVersion:              &clerkJSVersion,
    51  	})
    52  	if err == nil {
    53  		t.Errorf("Expected error to be returned")
    54  	}
    55  }
    56  
    57  func TestInstanceService_UpdateRestrictions_happyPath(t *testing.T) {
    58  	token := "token"
    59  	dummyRestrictionsResponseJSON := `{
    60  		"allowlist": true,
    61  		"blocklist": true,
    62  		"block_email_subaddresses": true,
    63  		"block_disposable_email_domains": true
    64  	}`
    65  	var restrictionsResponse InstanceRestrictionsResponse
    66  	err := json.Unmarshal([]byte(dummyRestrictionsResponseJSON), &restrictionsResponse)
    67  	assert.NoError(t, err)
    68  
    69  	client, mux, _, teardown := setup(token)
    70  	defer teardown()
    71  
    72  	mux.HandleFunc("/instance/restrictions", func(w http.ResponseWriter, req *http.Request) {
    73  		testHttpMethod(t, req, http.MethodPatch)
    74  		testHeader(t, req, "Authorization", "Bearer "+token)
    75  		fmt.Fprint(w, dummyRestrictionsResponseJSON)
    76  	})
    77  
    78  	enabled := true
    79  	got, _ := client.Instances().UpdateRestrictions(UpdateRestrictionsParams{
    80  		Allowlist:                   &enabled,
    81  		Blocklist:                   &enabled,
    82  		BlockEmailSubaddresses:      &enabled,
    83  		BlockDisposableEmailDomains: &enabled,
    84  		IgnoreDotsForGmailAddresses: &enabled,
    85  	})
    86  
    87  	assert.Equal(t, &restrictionsResponse, got)
    88  }
    89  
    90  func TestInstanceService_UpdateRestrictions_invalidServer(t *testing.T) {
    91  	client, _ := NewClient("token")
    92  
    93  	enabled := true
    94  	_, err := client.Instances().UpdateRestrictions(UpdateRestrictionsParams{
    95  		Allowlist: &enabled,
    96  		Blocklist: &enabled,
    97  	})
    98  	if err == nil {
    99  		t.Errorf("Expected error to be returned")
   100  	}
   101  }
   102  
   103  func TestInstanceService_UpdateOrganizationSettings_happyPath(t *testing.T) {
   104  	token := "token"
   105  	dummyOrganizationSettingsResponseJSON := `{
   106  		"enabled": true,
   107  		"max_allowed_memberships": 2,
   108  		"max_allowed_roles": 10,
   109  		"max_allowed_permissions": 50,
   110  		"creator_role": "org:custom_admin",
   111  		"admin_delete_enabled": true,
   112  		"domains_enabled": true,
   113  		"domains_enrollment_modes": [
   114  			"manual_invitation",
   115  			"automatic_invitation",
   116  			"automatic_suggestion"
   117  		],
   118  		"domains_default_role": "org:custom_domains"
   119  	}`
   120  	var organizationSettingsResponse OrganizationSettingsResponse
   121  	_ = json.Unmarshal([]byte(dummyOrganizationSettingsResponseJSON), &organizationSettingsResponse)
   122  
   123  	client, mux, _, teardown := setup(token)
   124  	defer teardown()
   125  
   126  	mux.HandleFunc("/instance/organization_settings", func(w http.ResponseWriter, req *http.Request) {
   127  		testHttpMethod(t, req, http.MethodPatch)
   128  		testHeader(t, req, "Authorization", "Bearer "+token)
   129  		fmt.Fprint(w, dummyOrganizationSettingsResponseJSON)
   130  	})
   131  
   132  	enabled := true
   133  	got, _ := client.Instances().UpdateOrganizationSettings(UpdateOrganizationSettingsParams{
   134  		Enabled:              &enabled,
   135  		CreatorRoleID:        stringToPtr("role_2XcSZn6swGCjX59Nk0XbGer22jb"),
   136  		DomainsDefaultRoleID: stringToPtr("role_2XZCQwxfLbXOz2hoBXKFVRjwmGc"),
   137  	})
   138  
   139  	assert.Equal(t, &organizationSettingsResponse, got)
   140  }
   141  
   142  func TestInstanceService_UpdateOrganizationSettings_invalidServer(t *testing.T) {
   143  	client, _ := NewClient("token")
   144  
   145  	enabled := true
   146  	_, err := client.Instances().UpdateOrganizationSettings(UpdateOrganizationSettingsParams{
   147  		Enabled: &enabled,
   148  	})
   149  	if err == nil {
   150  		t.Errorf("Expected error to be returned")
   151  	}
   152  }