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

     1  package clerk
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"net/http"
     7  	"reflect"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestTemplatesService_List_All_happyPath(t *testing.T) {
    14  	client, mux, _, teardown := setup("token")
    15  	defer teardown()
    16  
    17  	templateType := "email"
    18  
    19  	expectedResponse := "[" + dummyTemplateJSON + "]"
    20  
    21  	url := fmt.Sprintf("/templates/%s", templateType)
    22  
    23  	mux.HandleFunc(url, func(w http.ResponseWriter, req *http.Request) {
    24  		testHttpMethod(t, req, "GET")
    25  		testHeader(t, req, "Authorization", "Bearer token")
    26  		fmt.Fprint(w, expectedResponse)
    27  	})
    28  
    29  	var want []Template
    30  	_ = json.Unmarshal([]byte(expectedResponse), &want)
    31  
    32  	got, err := client.Templates().ListAll(templateType)
    33  	assert.Nil(t, err)
    34  
    35  	if len(got) != len(want) {
    36  		t.Errorf("Was expecting %d user to be returned, instead got %d", len(want), len(got))
    37  	}
    38  
    39  	if !reflect.DeepEqual(got, want) {
    40  		t.Errorf("Response = %v, want %v", got, want)
    41  	}
    42  }
    43  
    44  func TestTemplatesService_Read_happyPath(t *testing.T) {
    45  	token := "token"
    46  	templateType := "email"
    47  	slug := "metalslug"
    48  	expectedResponse := dummyTemplateJSON
    49  
    50  	client, mux, _, teardown := setup(token)
    51  	defer teardown()
    52  
    53  	url := fmt.Sprintf("/templates/%s/%s", templateType, slug)
    54  
    55  	mux.HandleFunc(url, func(w http.ResponseWriter, req *http.Request) {
    56  		testHttpMethod(t, req, "GET")
    57  		testHeader(t, req, "Authorization", "Bearer "+token)
    58  		fmt.Fprint(w, expectedResponse)
    59  	})
    60  
    61  	var want TemplateExtended
    62  	_ = json.Unmarshal([]byte(expectedResponse), &want)
    63  
    64  	got, err := client.Templates().Read(templateType, slug)
    65  	assert.Nil(t, err)
    66  
    67  	if !reflect.DeepEqual(*got, want) {
    68  		t.Errorf("Response = %v, want %v", *got, want)
    69  	}
    70  }
    71  
    72  func TestTemplatesService_Upsert_happyPath(t *testing.T) {
    73  	token := "token"
    74  	templateType := "email"
    75  	slug := "metalslug"
    76  	expectedResponse := dummyTemplateJSON
    77  
    78  	var payload UpsertTemplateRequest
    79  	_ = json.Unmarshal([]byte(dummyUpsertRequestJSON), &payload)
    80  
    81  	client, mux, _, teardown := setup(token)
    82  	defer teardown()
    83  
    84  	url := fmt.Sprintf("/templates/%s/%s", templateType, slug)
    85  
    86  	mux.HandleFunc(url, func(w http.ResponseWriter, req *http.Request) {
    87  		testHttpMethod(t, req, "PUT")
    88  		testHeader(t, req, "Authorization", "Bearer "+token)
    89  		fmt.Fprint(w, expectedResponse)
    90  	})
    91  
    92  	got, err := client.Templates().Upsert(templateType, slug, &payload)
    93  	assert.Nil(t, err)
    94  
    95  	var want TemplateExtended
    96  	_ = json.Unmarshal([]byte(expectedResponse), &want)
    97  
    98  	if !reflect.DeepEqual(*got, want) {
    99  		t.Errorf("Response = %v, want %v", *got, payload)
   100  	}
   101  }
   102  
   103  func TestTemplatesService_RevertToSystemTemplate_happyPath(t *testing.T) {
   104  	token := "token"
   105  	templateType := "email"
   106  	slug := "metalslug"
   107  	expectedResponse := dummyTemplateJSON
   108  
   109  	client, mux, _, teardown := setup(token)
   110  	defer teardown()
   111  
   112  	url := fmt.Sprintf("/templates/%s/%s/revert", templateType, slug)
   113  
   114  	mux.HandleFunc(url, func(w http.ResponseWriter, req *http.Request) {
   115  		testHttpMethod(t, req, "POST")
   116  		testHeader(t, req, "Authorization", "Bearer "+token)
   117  		fmt.Fprint(w, expectedResponse)
   118  	})
   119  
   120  	var want TemplateExtended
   121  	_ = json.Unmarshal([]byte(expectedResponse), &want)
   122  
   123  	got, err := client.Templates().Revert(templateType, slug)
   124  	assert.Nil(t, err)
   125  
   126  	if !reflect.DeepEqual(*got, want) {
   127  		t.Errorf("Response = %v, want %v", *got, want)
   128  	}
   129  }
   130  
   131  func TestTemplatesService_Delete_happyPath(t *testing.T) {
   132  	token := "token"
   133  	templateType := "email"
   134  	slug := "metalslug"
   135  
   136  	client, mux, _, teardown := setup(token)
   137  	defer teardown()
   138  
   139  	url := fmt.Sprintf("/templates/%s/%s", templateType, slug)
   140  
   141  	mux.HandleFunc(url, func(w http.ResponseWriter, req *http.Request) {
   142  		testHttpMethod(t, req, "DELETE")
   143  		testHeader(t, req, "Authorization", "Bearer "+token)
   144  		response := fmt.Sprintf(`{ "deleted": true, "slug": "%v", "object": "template" }`, slug)
   145  		fmt.Fprint(w, response)
   146  	})
   147  
   148  	want := DeleteResponse{Slug: slug, Object: "template", Deleted: true}
   149  
   150  	got, err := client.Templates().Delete(templateType, slug)
   151  	assert.Nil(t, err)
   152  
   153  	if !reflect.DeepEqual(*got, want) {
   154  		t.Errorf("Response = %v, want %v", *got, want)
   155  	}
   156  }
   157  
   158  func TestTemplatesService_Preview_happyPath(t *testing.T) {
   159  	token := "token"
   160  	templateType := "sms"
   161  	slug := "snail"
   162  	expectedResponse := dummyPreviewResponseJSON
   163  
   164  	var payload PreviewTemplateRequest
   165  	_ = json.Unmarshal([]byte(dummyPreviewRequestJSON), &payload)
   166  
   167  	client, mux, _, teardown := setup(token)
   168  	defer teardown()
   169  
   170  	url := fmt.Sprintf("/templates/%s/%s/preview", templateType, slug)
   171  
   172  	mux.HandleFunc(url, func(w http.ResponseWriter, req *http.Request) {
   173  		testHttpMethod(t, req, "POST")
   174  		testHeader(t, req, "Authorization", "Bearer "+token)
   175  		fmt.Fprint(w, expectedResponse)
   176  	})
   177  
   178  	got, err := client.Templates().Preview(templateType, slug, &payload)
   179  	assert.Nil(t, err)
   180  
   181  	var want TemplatePreview
   182  	_ = json.Unmarshal([]byte(expectedResponse), &want)
   183  
   184  	if !reflect.DeepEqual(*got, want) {
   185  		t.Errorf("Response = %v, want %v", *got, payload)
   186  	}
   187  }
   188  
   189  const dummyTemplateJSON = `{
   190      "object": "template",
   191      "slug": "derp",
   192      "resource_type": "user",
   193      "template_type": "email",
   194      "name": "Vin Diesel",
   195      "position": 0,
   196      "created_at": 1633541368454,
   197      "updated_at": 1633541368454,
   198      "subject": "Choo choo train",
   199      "markup": "<p>Hee Hee</p>",
   200      "body": "<p>Ho Ho</p>",
   201  	"from_email_name": "noreply",
   202  	"delivered_by_clerk": true,
   203  	"available_variables": [
   204          "michael",
   205          "jackson"
   206      ],
   207      "required_variables": [
   208          "michael"
   209      ]
   210  }`
   211  
   212  const dummyUpsertRequestJSON = `{
   213  	"name": "Dominic Toretto",
   214  	"subject": "NOS bottles for sale",
   215  	"markup": "<p>Family</p>",
   216  	"body": "<p>One quarter of a mile at a time<p>",
   217  	"from_email_name": "sales",
   218  	"delivered_by_clerk": false
   219  }`
   220  
   221  const dummyPreviewRequestJSON = `{
   222  	"body": "{{OTPCode}} is your code for {{AppName}}, valid for {{TTLMinutes}} minutes"
   223  }`
   224  
   225  const dummyPreviewResponseJSON = `{
   226  	"body": "123456 is your code for ACME, valid for 10 minutes"
   227  }`