event_hooks_test.go

Documentation: github.com/okta/okta-sdk-golang/v2/tests/integration

     1  /*
     2   * Copyright 2018 - Present Okta, Inc.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *      http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package integration
    18  
    19  import (
    20  	"context"
    21  	"testing"
    22  	"time"
    23  
    24  	"github.com/okta/okta-sdk-golang/v2/okta"
    25  	"github.com/okta/okta-sdk-golang/v2/tests"
    26  
    27  	"github.com/stretchr/testify/assert"
    28  	"github.com/stretchr/testify/require"
    29  )
    30  
    31  func Test_create_an_event_hook(t *testing.T) {
    32  	ctx, client, err := tests.NewClient(context.TODO())
    33  	require.NoError(t, err)
    34  
    35  	eventHookRequest := createEventHookRequestObject("Create an event hook")
    36  
    37  	eventHook, response, err := client.EventHook.CreateEventHook(ctx, eventHookRequest)
    38  
    39  	require.NoError(t, err, "creating an event hook should not error")
    40  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks")
    41  
    42  	assert_event_hook_model(t, eventHook)
    43  
    44  	_, _, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
    45  	require.NoError(t, err, "deactivating an event hook should not error")
    46  	_, err = client.EventHook.DeleteEventHook(ctx, eventHook.Id)
    47  	require.NoError(t, err, "deleting an event hook should not error")
    48  }
    49  
    50  func Test_get_an_event_hook(t *testing.T) {
    51  	ctx, client, err := tests.NewClient(context.TODO())
    52  	require.NoError(t, err)
    53  
    54  	eventHookRequest := createEventHookRequestObject("get an event hook")
    55  
    56  	eventHook, response, err := client.EventHook.CreateEventHook(ctx, eventHookRequest)
    57  
    58  	require.NoError(t, err, "creating an event hook should not error")
    59  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks")
    60  
    61  	foundEventHook, response, err := client.EventHook.GetEventHook(ctx, eventHook.Id)
    62  
    63  	require.NoError(t, err, "get an event hook should not error")
    64  	tests.AssertResponse(t, response, "GET", "/api/v1/eventHooks/"+eventHook.Id)
    65  
    66  	assert_event_hook_model(t, foundEventHook)
    67  	require.Equal(t, eventHook.Id, foundEventHook.Id, "did not find the same event hook from id")
    68  
    69  	_, _, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
    70  	require.NoError(t, err, "deactivating an event hook should not error")
    71  	_, err = client.EventHook.DeleteEventHook(ctx, eventHook.Id)
    72  	require.NoError(t, err, "deleting an event hook should not error")
    73  }
    74  
    75  func Test_update_an_event_hook(t *testing.T) {
    76  	ctx, client, err := tests.NewClient(context.TODO())
    77  	require.NoError(t, err)
    78  
    79  	eventHookRequest := createEventHookRequestObject("Create an event hook")
    80  
    81  	eventHook, response, err := client.EventHook.CreateEventHook(ctx, eventHookRequest)
    82  
    83  	require.NoError(t, err, "creating an event hook should not error")
    84  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks")
    85  
    86  	eventHook.Name = "GO SDK: Updated Event Hook"
    87  	updatedEventHook, response, err := client.EventHook.UpdateEventHook(ctx, eventHook.Id, *eventHook)
    88  
    89  	assert_event_hook_model(t, updatedEventHook)
    90  	require.Equal(t, eventHook.Name, updatedEventHook.Name, "update of event hook did not work")
    91  
    92  	_, _, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
    93  	require.NoError(t, err, "deactivating an event hook should not error")
    94  	_, err = client.EventHook.DeleteEventHook(ctx, eventHook.Id)
    95  	require.NoError(t, err, "deleting an event hook should not error")
    96  }
    97  
    98  func Test_deactivate_and_delete_an_event_hook(t *testing.T) {
    99  	ctx, client, err := tests.NewClient(context.TODO())
   100  	require.NoError(t, err)
   101  
   102  	eventHookRequest := createEventHookRequestObject("deactivate and delete an event hook")
   103  
   104  	eventHook, response, err := client.EventHook.CreateEventHook(ctx, eventHookRequest)
   105  
   106  	require.NoError(t, err, "creating an event hook should not error")
   107  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks")
   108  
   109  	assert_event_hook_model(t, eventHook)
   110  	require.Equal(t, "ACTIVE", eventHook.Status, "event hook was not active")
   111  
   112  	_, response, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
   113  	require.NoError(t, err, "deactivating an event hook should not error")
   114  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks/"+eventHook.Id+"/lifecycle/deactivate")
   115  
   116  	foundEventHook, _, err := client.EventHook.GetEventHook(ctx, eventHook.Id)
   117  
   118  	require.NoError(t, err, "get an event hook should not error")
   119  	require.Equal(t, "INACTIVE", foundEventHook.Status, "event hook was not inactive after deactivate")
   120  
   121  	response, err = client.EventHook.DeleteEventHook(ctx, eventHook.Id)
   122  	require.NoError(t, err, "deleting an event hook should not error")
   123  	tests.AssertResponse(t, response, "DELETE", "/api/v1/eventHooks/"+eventHook.Id)
   124  }
   125  
   126  func Test_activate_an_event_hook(t *testing.T) {
   127  	ctx, client, err := tests.NewClient(context.TODO())
   128  	require.NoError(t, err)
   129  
   130  	eventHookRequest := createEventHookRequestObject("activate an event hook")
   131  
   132  	eventHook, response, err := client.EventHook.CreateEventHook(ctx, eventHookRequest)
   133  
   134  	require.NoError(t, err, "creating an event hook should not error")
   135  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks")
   136  
   137  	assert_event_hook_model(t, eventHook)
   138  	require.Equal(t, "ACTIVE", eventHook.Status, "event hook was not active")
   139  
   140  	eventHook, response, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
   141  	require.NoError(t, err, "deactivating an event hook should not error")
   142  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks/"+eventHook.Id+"/lifecycle/deactivate")
   143  	require.Equal(t, "INACTIVE", eventHook.Status, "event hook was not active")
   144  
   145  	eventHook, response, err = client.EventHook.ActivateEventHook(ctx, eventHook.Id)
   146  	require.NoError(t, err, "activating an event hook should not error")
   147  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks/"+eventHook.Id+"/lifecycle/activate")
   148  	require.Equal(t, "ACTIVE", eventHook.Status, "event hook was not active")
   149  
   150  	_, _, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
   151  	require.NoError(t, err, "deactivating an event hook should not error")
   152  	response, err = client.EventHook.DeleteEventHook(ctx, eventHook.Id)
   153  	require.NoError(t, err, "deleting an event hook should not error")
   154  }
   155  
   156  func Test_list_event_hooks(t *testing.T) {
   157  	ctx, client, err := tests.NewClient(context.TODO())
   158  	require.NoError(t, err)
   159  
   160  	eventHookRequest := createEventHookRequestObject("List event hooks")
   161  
   162  	eventHook, response, err := client.EventHook.CreateEventHook(ctx, eventHookRequest)
   163  
   164  	require.NoError(t, err, "creating an event hook should not error")
   165  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks")
   166  
   167  	eventHookList, response, err := client.EventHook.ListEventHooks(ctx)
   168  	assert.IsType(t, []*okta.EventHook{}, eventHookList, "did not return a list of eventHook objects")
   169  
   170  	found := false
   171  	for _, eh := range eventHookList {
   172  		if eh.Id == eventHook.Id {
   173  			found = true
   174  		}
   175  	}
   176  
   177  	assert.True(t, found, "did not find the eventHook in the list")
   178  
   179  	_, _, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
   180  	require.NoError(t, err, "deactivating an event hook should not error")
   181  	_, err = client.EventHook.DeleteEventHook(ctx, eventHook.Id)
   182  	require.NoError(t, err, "deleting an event hook should not error")
   183  }
   184  
   185  func Test_verify_an_event_hook(t *testing.T) {
   186  	ctx, client, err := tests.NewClient(context.TODO())
   187  	require.NoError(t, err)
   188  
   189  	eventHookRequest := createEventHookRequestObject("Verify an event hook")
   190  
   191  	eventHook, response, err := client.EventHook.CreateEventHook(ctx, eventHookRequest)
   192  
   193  	require.NoError(t, err, "creating an event hook should not error")
   194  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks")
   195  
   196  	_, response, err = client.EventHook.VerifyEventHook(ctx, eventHook.Id)
   197  
   198  	// We expect this call to error.  Our test is just making sure we have the correct endpoint.
   199  	// To fully test this, we have to have an acutal endpoint that will respond to event hooks.
   200  	require.Error(t, err, "should have thrown an error because our event hook uri does not actually exist")
   201  	require.Equal(t, 400, response.StatusCode, "Should have errored with a 400 status code")
   202  	tests.AssertResponse(t, response, "POST", "/api/v1/eventHooks/"+eventHook.Id+"/lifecycle/verify")
   203  
   204  	_, _, err = client.EventHook.DeactivateEventHook(ctx, eventHook.Id)
   205  	require.NoError(t, err, "deactivating an event hook should not error")
   206  	_, err = client.EventHook.DeleteEventHook(ctx, eventHook.Id)
   207  	require.NoError(t, err, "deleting an event hook should not error")
   208  }
   209  
   210  func createEventHookRequestObject(name string) okta.EventHook {
   211  	eventHookEvent := okta.EventSubscriptions{
   212  		Type: "EVENT_TYPE",
   213  		Items: []string{
   214  			"user.lifecycle.create",
   215  			"user.lifecycle.activate",
   216  		},
   217  	}
   218  
   219  	eventHookChannelConfigHeader := okta.EventHookChannelConfigHeader{
   220  		Key:   "X-Other-Header",
   221  		Value: "some-other-value",
   222  	}
   223  
   224  	eventHookChannelConfigAuthScheme := okta.EventHookChannelConfigAuthScheme{
   225  		Type:  "HEADER",
   226  		Key:   "Authorization",
   227  		Value: "MyApiKey",
   228  	}
   229  
   230  	eventHookChannelConfig := okta.EventHookChannelConfig{
   231  		Uri: "https://www.example.com/eventHooks",
   232  		Headers: []*okta.EventHookChannelConfigHeader{
   233  			&eventHookChannelConfigHeader,
   234  		},
   235  		AuthScheme: &eventHookChannelConfigAuthScheme,
   236  	}
   237  
   238  	eventHookChannel := okta.EventHookChannel{
   239  		Type:    "HTTP",
   240  		Version: "1.0.0",
   241  		Config:  &eventHookChannelConfig,
   242  	}
   243  
   244  	eventHookRequest := okta.EventHook{
   245  		Name:    "GO SDK: " + name,
   246  		Events:  &eventHookEvent,
   247  		Channel: &eventHookChannel,
   248  	}
   249  
   250  	return eventHookRequest
   251  }
   252  
   253  func assert_event_hook_model(t *testing.T, eventHook *okta.EventHook) {
   254  	require.IsType(t, &okta.EventHook{}, eventHook, "did not return `*okta.EventHook` type as first variable")
   255  	assert.NotEmpty(t, eventHook.Links, "links should not be empty")
   256  	assert.NotEmpty(t, eventHook.Channel, "created should not be empty")
   257  	assert.IsType(t, &okta.EventHookChannel{}, eventHook.Channel, "channel should be of type `*okta.EventHookChannel`")
   258  	assert.NotEmpty(t, eventHook.Created, "created should not be empty")
   259  	assert.IsType(t, &time.Time{}, eventHook.Created, "created should not be of type `*time.Time`")
   260  	assert.NotEmpty(t, eventHook.CreatedBy, "createdBy should not be empty")
   261  	assert.NotEmpty(t, eventHook.Events, "events should not be empty")
   262  	assert.IsType(t, &okta.EventSubscriptions{}, eventHook.Events, "events should be of type `*okta.EventSubscriptions`")
   263  	assert.NotEmpty(t, eventHook.Id, "id should not be empty")
   264  	assert.NotEmpty(t, eventHook.LastUpdated, "lastUpdated should not be empty")
   265  	assert.IsType(t, &time.Time{}, eventHook.LastUpdated, "lastUpdated should not be of type `*time.Time`")
   266  	assert.NotEmpty(t, eventHook.Name, "name should not be empty")
   267  	assert.NotEmpty(t, eventHook.Status, "status should not be empty")
   268  	assert.NotEmpty(t, eventHook.VerificationStatus, "verificationStatus should not be empty")
   269  }
   270
View as plain text