Source file src/github.com/okta/okta-sdk-golang/v2/tests/integration/application_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  	"fmt"
    22  	"os"
    23  	"path"
    24  	"strings"
    25  	"testing"
    26  
    27  	"github.com/okta/okta-sdk-golang/v2/okta/query"
    28  
    29  	"github.com/stretchr/testify/assert"
    30  	"github.com/stretchr/testify/require"
    31  
    32  	"github.com/okta/okta-sdk-golang/v2/okta"
    33  
    34  	"github.com/okta/okta-sdk-golang/v2/tests"
    35  )
    36  
    37  func TestCanGetApplicationByID(t *testing.T) {
    38  	ctx, client, err := tests.NewClient(context.TODO())
    39  	require.NoError(t, err)
    40  
    41  	basicApplication := okta.NewBasicAuthApplication()
    42  	basicApplication.Settings = &okta.BasicApplicationSettings{
    43  		App: &okta.BasicApplicationSettingsApplication{
    44  			AuthURL: "https://example.com/auth.html",
    45  			Url:     "https://example.com/auth.html",
    46  		},
    47  	}
    48  
    49  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
    50  	require.NoError(t, err, "Creating an application should not error")
    51  
    52  	appId := application.(*okta.BasicAuthApplication).Id
    53  
    54  	foundApplication, _, err := client.Application.GetApplication(ctx, appId, okta.NewBasicAuthApplication(), nil)
    55  	require.NoError(t, err, "Should not error when getting an applicaiton by id")
    56  
    57  	assert.Equal(t, appId, foundApplication.(*okta.BasicAuthApplication).Id, "Application found was not correct")
    58  
    59  	client.Application.DeactivateApplication(ctx, appId)
    60  	_, err = client.Application.DeleteApplication(ctx, appId)
    61  
    62  	require.NoError(t, err, "Deleting an application should not error")
    63  }
    64  
    65  func TestCanUpdateApplication(t *testing.T) {
    66  	ctx, client, err := tests.NewClient(context.TODO())
    67  	require.NoError(t, err)
    68  
    69  	basicApplication := okta.NewBasicAuthApplication()
    70  	basicApplication.Settings = &okta.BasicApplicationSettings{
    71  		App: &okta.BasicApplicationSettingsApplication{
    72  			AuthURL: "https://example.com/auth.html",
    73  			Url:     "https://example.com/auth.html",
    74  		},
    75  	}
    76  
    77  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
    78  	require.NoError(t, err, "Creating an application should not error")
    79  
    80  	appId := application.(*okta.BasicAuthApplication).Id
    81  
    82  	newBasicApplication := okta.NewBasicAuthApplication()
    83  	newBasicApplication.Settings = &okta.BasicApplicationSettings{
    84  		App: &okta.BasicApplicationSettingsApplication{
    85  			AuthURL: "https://example.org/auth.html",
    86  			Url:     "https://example.org/auth.html",
    87  		},
    88  	}
    89  
    90  	newApp, _, err := client.Application.UpdateApplication(ctx, appId, newBasicApplication)
    91  	require.NoError(t, err, "Updating an application caused an error")
    92  
    93  	assert.Equal(t, "https://example.org/auth.html", newApp.(*okta.BasicAuthApplication).Settings.App.Url, "The application did not update")
    94  
    95  	_, err = client.Application.DeactivateApplication(ctx, appId)
    96  	require.NoError(t, err, "Deactivating an application should not error")
    97  
    98  	_, err = client.Application.DeleteApplication(ctx, appId)
    99  
   100  	require.NoError(t, err, "Deleting an application should not error")
   101  }
   102  
   103  func TestCanCreateABookmarkApplication(t *testing.T) {
   104  	ctx, client, err := tests.NewClient(context.TODO())
   105  	require.NoError(t, err)
   106  
   107  	bookmarkApplication := okta.NewBookmarkApplication()
   108  	bookmarkApplication.Settings = &okta.BookmarkApplicationSettings{
   109  		App: &okta.BookmarkApplicationSettingsApplication{
   110  			RequestIntegration: new(bool),
   111  			Url:                "https://example.com/bookmark.htm",
   112  		},
   113  	}
   114  
   115  	assert.Empty(t, bookmarkApplication.Id)
   116  	application, _, err := client.Application.CreateApplication(ctx, bookmarkApplication, nil)
   117  	require.NoError(t, err, "Creating an application should not error")
   118  
   119  	assert.IsType(t, &okta.BookmarkApplication{}, application, "Application type returned was incorrect")
   120  	assert.NotEmpty(t, application.(*okta.BookmarkApplication).Id)
   121  
   122  	client.Application.DeactivateApplication(ctx, application.(*okta.BookmarkApplication).Id)
   123  	_, err = client.Application.DeleteApplication(ctx, application.(*okta.BookmarkApplication).Id)
   124  
   125  	require.NoError(t, err, "Deleting an application should not error")
   126  }
   127  
   128  func TestCanCreateABasicAuthenticationApplication(t *testing.T) {
   129  	ctx, client, err := tests.NewClient(context.TODO())
   130  	require.NoError(t, err)
   131  
   132  	basicApplication := okta.NewBasicAuthApplication()
   133  	basicApplication.Settings = &okta.BasicApplicationSettings{
   134  		App: &okta.BasicApplicationSettingsApplication{
   135  			AuthURL: "https://example.com/auth.html",
   136  			Url:     "https://example.com/auth.html",
   137  		},
   138  	}
   139  
   140  	assert.Empty(t, basicApplication.Id)
   141  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
   142  	require.NoError(t, err, "Creating an application should not error")
   143  
   144  	assert.IsType(t, &okta.BasicAuthApplication{}, application, "Application type returned was incorrect")
   145  	assert.NotEmpty(t, application.(*okta.BasicAuthApplication).Id)
   146  	assert.NotEmpty(t, basicApplication.Id)
   147  
   148  	client.Application.DeactivateApplication(ctx, application.(*okta.BasicAuthApplication).Id)
   149  	_, err = client.Application.DeleteApplication(ctx, application.(*okta.BasicAuthApplication).Id)
   150  
   151  	require.NoError(t, err, "Deleting an application should not error")
   152  }
   153  
   154  func TestListApplicationAllowsCastingToCorrectType(t *testing.T) {
   155  	ctx, client, err := tests.NewClient(context.TODO())
   156  	require.NoError(t, err)
   157  
   158  	basicApplication := okta.NewBasicAuthApplication()
   159  	basicApplication.Settings = &okta.BasicApplicationSettings{
   160  		App: &okta.BasicApplicationSettingsApplication{
   161  			AuthURL: "https://example.com/auth.html",
   162  			Url:     "https://example.com/auth.html",
   163  		},
   164  	}
   165  
   166  	app1, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
   167  	require.NoError(t, err, "Creating an application should not error")
   168  
   169  	bookmarkApplication := okta.NewBookmarkApplication()
   170  	bookmarkApplication.Settings = &okta.BookmarkApplicationSettings{
   171  		App: &okta.BookmarkApplicationSettingsApplication{
   172  			RequestIntegration: new(bool),
   173  			Url:                "https://example.com/bookmark.htm",
   174  		},
   175  	}
   176  
   177  	app2, _, err := client.Application.CreateApplication(ctx, bookmarkApplication, nil)
   178  	require.NoError(t, err, "Creating an application should not error")
   179  
   180  	applist, _, err := client.Application.ListApplications(ctx, nil)
   181  	require.NoError(t, err, "List applications should not error")
   182  
   183  	for _, a := range applist {
   184  		if a.(*okta.Application).Name == "bookmark" {
   185  			if a.(*okta.Application).Id == app2.(*okta.BookmarkApplication).Id {
   186  				ba, _, _ := client.Application.GetApplication(ctx, a.(*okta.Application).Id, okta.NewBookmarkApplication(), nil)
   187  				requestIntegration := ba.(*okta.BookmarkApplication).Settings.App.RequestIntegration
   188  				assert.False(t, *requestIntegration)
   189  			}
   190  		}
   191  	}
   192  
   193  	client.Application.DeactivateApplication(ctx, app1.(*okta.BasicAuthApplication).Id)
   194  	_, err = client.Application.DeleteApplication(ctx, app1.(*okta.BasicAuthApplication).Id)
   195  
   196  	require.NoError(t, err, "Deleting an application should not error")
   197  
   198  	client.Application.DeactivateApplication(ctx, app2.(*okta.BookmarkApplication).Id)
   199  	_, err = client.Application.DeleteApplication(ctx, app2.(*okta.BookmarkApplication).Id)
   200  
   201  	require.NoError(t, err, "Deleting an application should not error")
   202  }
   203  
   204  func TestCanActivateApplication(t *testing.T) {
   205  	ctx, client, err := tests.NewClient(context.TODO())
   206  	require.NoError(t, err)
   207  
   208  	basicApplication := okta.NewBasicAuthApplication()
   209  	basicApplication.Settings = &okta.BasicApplicationSettings{
   210  		App: &okta.BasicApplicationSettingsApplication{
   211  			AuthURL: "https://example.com/auth.html",
   212  			Url:     "https://example.com/auth.html",
   213  		},
   214  	}
   215  
   216  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, query.NewQueryParams(query.WithActivate(false)))
   217  	require.NoError(t, err, "Creating an application should not error")
   218  
   219  	appId := application.(*okta.BasicAuthApplication).Id
   220  
   221  	assert.Equal(t, "INACTIVE", application.(*okta.BasicAuthApplication).Status, "Application is not inactive")
   222  
   223  	_, err = client.Application.ActivateApplication(ctx, appId)
   224  	require.NoError(t, err, "Activationg an application should not error")
   225  	application, _, _ = client.Application.GetApplication(ctx, appId, okta.NewBasicAuthApplication(), nil)
   226  	assert.Equal(t, "ACTIVE", application.(*okta.BasicAuthApplication).Status, "Application is not inactive")
   227  
   228  	client.Application.DeactivateApplication(ctx, appId)
   229  	_, err = client.Application.DeleteApplication(ctx, appId)
   230  
   231  	require.NoError(t, err, "Deleting an application should not error")
   232  }
   233  
   234  func TestCanDeactivateApplication(t *testing.T) {
   235  	ctx, client, err := tests.NewClient(context.TODO())
   236  	require.NoError(t, err)
   237  
   238  	basicApplication := okta.NewBasicAuthApplication()
   239  	basicApplication.Settings = &okta.BasicApplicationSettings{
   240  		App: &okta.BasicApplicationSettingsApplication{
   241  			AuthURL: "https://example.com/auth.html",
   242  			Url:     "https://example.com/auth.html",
   243  		},
   244  	}
   245  
   246  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, query.NewQueryParams(query.WithActivate(true)))
   247  	require.NoError(t, err, "Creating an application should not error")
   248  
   249  	appId := application.(*okta.BasicAuthApplication).Id
   250  
   251  	assert.Equal(t, "ACTIVE", application.(*okta.BasicAuthApplication).Status, "Application is not inactive")
   252  
   253  	_, err = client.Application.DeactivateApplication(ctx, appId)
   254  	require.NoError(t, err, "Deactivating an application should not error")
   255  	application, _, err = client.Application.GetApplication(ctx, appId, okta.NewBasicAuthApplication(), nil)
   256  	assert.Equal(t, "INACTIVE", application.(*okta.BasicAuthApplication).Status, "Application is not inactive")
   257  
   258  	_, err = client.Application.DeleteApplication(ctx, appId)
   259  
   260  	require.NoError(t, err, "Deleting an application should not error")
   261  }
   262  
   263  func TestCanAddAndRemoveApplicationUsers(t *testing.T) {
   264  	ctx, client, err := tests.NewClient(context.TODO())
   265  	require.NoError(t, err)
   266  
   267  	basicApplication := okta.NewBasicAuthApplication()
   268  	basicApplication.Settings = &okta.BasicApplicationSettings{
   269  		App: &okta.BasicApplicationSettingsApplication{
   270  			AuthURL: "https://example.com/auth.html",
   271  			Url:     "https://example.com/auth.html",
   272  		},
   273  	}
   274  
   275  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
   276  	require.NoError(t, err, "Creating an application should not error")
   277  
   278  	appId := application.(*okta.BasicAuthApplication).Id
   279  
   280  	appUserList, _, _ := client.Application.ListApplicationUsers(ctx, appId, nil)
   281  	assert.Empty(t, appUserList, "App Users should be empty")
   282  
   283  	p := &okta.PasswordCredential{
   284  		Value: "Abcd1234",
   285  	}
   286  	uc := &okta.UserCredentials{
   287  		Password: p,
   288  	}
   289  	profile := okta.UserProfile{}
   290  	profile["firstName"] = "John"
   291  	profile["lastName"] = "Get-User"
   292  	profile["email"] = randomEmail()
   293  	profile["login"] = profile["email"]
   294  	u := &okta.CreateUserRequest{
   295  		Credentials: uc,
   296  		Profile:     &profile,
   297  	}
   298  	qp := query.NewQueryParams(query.WithActivate(false))
   299  
   300  	user, _, err := client.User.CreateUser(ctx, *u, qp)
   301  	require.NoError(t, err, "Creating a new user should not error")
   302  
   303  	req := okta.AppUser{
   304  		Credentials: &okta.AppUserCredentials{
   305  			Password: &okta.AppUserPasswordCredential{
   306  				Value: "abcd1234",
   307  			},
   308  			UserName: "appUser",
   309  		},
   310  		Id: user.Id,
   311  	}
   312  
   313  	appUser, _, err := client.Application.AssignUserToApplication(ctx, appId, req)
   314  	require.NoError(t, err, "Assigning user to application show not error")
   315  
   316  	assert.IsType(t, okta.AppUser{}, *appUser, "Type returned from assigning user to application was incorrect")
   317  
   318  	appUserList, _, _ = client.Application.ListApplicationUsers(ctx, appId, nil)
   319  	assert.NotEmpty(t, appUserList, "App Users should not be empty")
   320  
   321  	client.Application.DeleteApplicationUser(ctx, appId, appUser.Id, nil)
   322  	client.GetRequestExecutor().RefreshNext()
   323  	appUserList, _, _ = client.Application.ListApplicationUsers(ctx, appId, nil)
   324  	assert.Empty(t, appUserList, "App Users should be empty after deleting")
   325  
   326  	client.Application.DeactivateApplication(ctx, appId)
   327  	_, err = client.Application.DeleteApplication(ctx, appId)
   328  
   329  	require.NoError(t, err, "Deleting an application should not error")
   330  
   331  	client.User.DeactivateUser(ctx, user.Id, nil)
   332  	client.User.DeactivateOrDeleteUser(ctx, user.Id, nil)
   333  }
   334  
   335  func TestCanSetApplicationSettingsDuringCreation(t *testing.T) {
   336  	ctx, client, err := tests.NewClient(context.TODO())
   337  	require.NoError(t, err)
   338  
   339  	basicApplication := okta.NewBasicAuthApplication()
   340  	basicApplication.Settings = &okta.BasicApplicationSettings{
   341  		App: &okta.BasicApplicationSettingsApplication{
   342  			AuthURL: "https://example.com/auth.html",
   343  			Url:     "https://example.com/auth.html",
   344  		},
   345  	}
   346  
   347  	assert.Empty(t, basicApplication.Id)
   348  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
   349  	require.NoError(t, err, "Creating an application should not error")
   350  
   351  	assert.IsType(t, okta.BasicApplicationSettingsApplication{}, *application.(*okta.BasicAuthApplication).Settings.App, "The returned type of application settings application was not correct type")
   352  	assert.Equal(t, "https://example.com/auth.html", application.(*okta.BasicAuthApplication).Settings.App.Url)
   353  
   354  	appId := application.(*okta.BasicAuthApplication).Id
   355  	client.Application.DeactivateApplication(ctx, appId)
   356  	_, err = client.Application.DeleteApplication(ctx, appId)
   357  
   358  	require.NoError(t, err, "Deleting an application should not error")
   359  }
   360  
   361  func TestCanSetApplicationSettingsDuringUpdate(t *testing.T) {
   362  	ctx, client, err := tests.NewClient(context.TODO())
   363  	require.NoError(t, err)
   364  
   365  	basicApplication := okta.NewBasicAuthApplication()
   366  	basicApplication.Settings = &okta.BasicApplicationSettings{
   367  		App: &okta.BasicApplicationSettingsApplication{
   368  			AuthURL: "https://example.com/auth.html",
   369  			Url:     "https://example.com/auth.html",
   370  		},
   371  	}
   372  
   373  	assert.Empty(t, basicApplication.Id)
   374  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
   375  	require.NoError(t, err, "Creating an application should not error")
   376  
   377  	appId := application.(*okta.BasicAuthApplication).Id
   378  
   379  	myApp, _, err := client.Application.GetApplication(ctx, appId, okta.NewBasicAuthApplication(), nil)
   380  	app := myApp.(*okta.BasicAuthApplication)
   381  	myAppId := app.Id
   382  	myAppSettingsApp := app.Settings.App
   383  
   384  	myAppSettingsApp.Url = "https://okta.com/auth"
   385  
   386  	_, _, _ = client.Application.UpdateApplication(ctx, myAppId, app)
   387  
   388  	updatedApp, _, err := client.Application.GetApplication(ctx, appId, okta.NewBasicAuthApplication(), nil)
   389  	assert.Equal(t, "https://okta.com/auth", updatedApp.(*okta.BasicAuthApplication).Settings.App.Url, "The URL was not updated'")
   390  
   391  	client.Application.DeactivateApplication(ctx, appId)
   392  	_, err = client.Application.DeleteApplication(ctx, appId)
   393  
   394  	require.NoError(t, err, "Deleting an application should not error")
   395  }
   396  
   397  func TestCanCreateCSRForApplication(t *testing.T) {
   398  	ctx, client, err := tests.NewClient(context.TODO())
   399  	require.NoError(t, err)
   400  
   401  	application := createBasicAuthApplication(t)
   402  
   403  	subject := okta.CsrMetadataSubject{
   404  		CountryName:            "US",
   405  		StateOrProvinceName:    "California",
   406  		LocalityName:           "San Francisco",
   407  		OrganizationName:       "Okta, Inc",
   408  		OrganizationalUnitName: "Dev",
   409  		CommonName:             "SP Issuer",
   410  	}
   411  
   412  	subjectAltNames := okta.CsrMetadataSubjectAltNames{
   413  		DnsNames: []string{"dev.okta.com"},
   414  	}
   415  
   416  	csr := okta.CsrMetadata{
   417  		Subject:         &subject,
   418  		SubjectAltNames: &subjectAltNames,
   419  	}
   420  
   421  	csrs, _, err := client.Application.GenerateCsrForApplication(ctx, application.Id, csr)
   422  	require.NoError(t, err, "Creating an application Csr should not error")
   423  
   424  	assert.IsType(t, &okta.Csr{}, csrs, "did not return a `okta.Csr` object")
   425  
   426  	client.Application.DeactivateApplication(ctx, application.Id)
   427  	_, err = client.Application.DeleteApplication(ctx, application.Id)
   428  
   429  	require.NoError(t, err, "Deleting an application should not error")
   430  }
   431  
   432  func TestGetDefaultProvisioningConnectionForApplication(t *testing.T) {
   433  	ctx, client, err := tests.NewClient(context.TODO())
   434  	require.NoError(t, err)
   435  
   436  	application := createOrg2OrgApplication(t)
   437  
   438  	conn, _, err := client.Application.GetDefaultProvisioningConnectionForApplication(ctx, application.Id)
   439  	require.NoError(t, err, "getting default provisioning connection for application should not error.")
   440  	assert.NotEmpty(t, conn.AuthScheme, "connection auth scheme shouldn't be empty")
   441  	assert.NotEmpty(t, conn.Status, "connection status shouldn't be empty")
   442  
   443  	client.Application.DeactivateApplication(ctx, application.Id)
   444  	_, err = client.Application.DeleteApplication(ctx, application.Id)
   445  	require.NoError(t, err, "Deleting an application should not error")
   446  }
   447  
   448  func TestSetDefaultProvisioningConnectionForApplication(t *testing.T) {
   449  	ctx, client, err := tests.NewClient(context.TODO())
   450  	require.NoError(t, err)
   451  
   452  	application := createOrg2OrgApplication(t)
   453  
   454  	provisionConnectionRequest := okta.ProvisioningConnectionRequest{
   455  		Profile: &okta.ProvisioningConnectionProfile{
   456  			AuthScheme: "TOKEN",
   457  			Token:      "TEST",
   458  		},
   459  	}
   460  
   461  	conn, _, err := client.Application.SetDefaultProvisioningConnectionForApplication(ctx, application.Id, provisionConnectionRequest, query.NewQueryParams(query.WithActivate(false)))
   462  	require.NoError(t, err, "setting default provisioning connection for application should not error.")
   463  	assert.Equal(t, "TOKEN", conn.AuthScheme, "expected auth scheme %q, go %q", "TOKEN", conn.AuthScheme)
   464  
   465  	client.Application.DeactivateApplication(ctx, application.Id)
   466  	_, err = client.Application.DeleteApplication(ctx, application.Id)
   467  	require.NoError(t, err, "Deleting an application should not error")
   468  }
   469  
   470  func TestListFeaturesForApplication(t *testing.T) {
   471  	t.Skip("listing application features is specific to an org2org")
   472  
   473  	ctx, client, err := tests.NewClient(context.TODO())
   474  	require.NoError(t, err)
   475  
   476  	application := createOrg2OrgApplication(t)
   477  
   478  	// FIXME this needs a second org to run against for this IT to work
   479  	// need to activate a provisioning connection between orgs
   480  	provisionConnectionRequest := okta.ProvisioningConnectionRequest{
   481  		Profile: &okta.ProvisioningConnectionProfile{
   482  			AuthScheme: "TOKEN",
   483  			Token:      "FIXME_WITH_REAL_ORG_TOKEN",
   484  		},
   485  	}
   486  	_, _, err = client.Application.SetDefaultProvisioningConnectionForApplication(ctx, application.Id, provisionConnectionRequest, query.NewQueryParams(query.WithActivate(false)))
   487  	require.NoError(t, err, "setting default provisioning connection for application should not error.")
   488  
   489  	features, _, err := client.Application.ListFeaturesForApplication(ctx, application.Id)
   490  	require.NoError(t, err, "listing features for application should not error.")
   491  
   492  	foundUserProvisiontingFeature := false
   493  	for _, feature := range features {
   494  		// NOTE: Provisioning must be enabled for the application. To activate
   495  		// provisioning, see Provisioning Connections. The only application
   496  		// Feature currently supported is USER_PROVISIONING.
   497  		// https://developer.okta.com/docs/reference/api/apps/#list-features-for-application
   498  		if feature.Name == "USER_PROVISIONING" {
   499  			foundUserProvisiontingFeature = true
   500  			break
   501  		}
   502  	}
   503  	if !foundUserProvisiontingFeature {
   504  		assert.FailNow(t, "the org2org application should at least have USER_PROVISIONING feature")
   505  	}
   506  
   507  	client.Application.DeactivateApplication(ctx, application.Id)
   508  	_, err = client.Application.DeleteApplication(ctx, application.Id)
   509  	require.NoError(t, err, "Deleting an application should not error")
   510  }
   511  
   512  func TestUploadApplicationLogo(t *testing.T) {
   513  	ctx, client, err := tests.NewClient(context.TODO())
   514  	require.NoError(t, err)
   515  
   516  	application := createBasicAuthApplication(t)
   517  
   518  	fileDir, _ := os.Getwd()
   519  	fileName := "../fixtures/logo.png"
   520  	filePath := path.Join(fileDir, fileName)
   521  	_, err = client.Application.UploadApplicationLogo(ctx, application.Id, filePath)
   522  	require.NoError(t, err, "uploading application logo should not error.")
   523  
   524  	client.Application.DeactivateApplication(ctx, application.Id)
   525  	_, err = client.Application.DeleteApplication(ctx, application.Id)
   526  	require.NoError(t, err, "Deleting an application should not error")
   527  }
   528  
   529  func createBasicAuthApplication(t *testing.T) *okta.BasicAuthApplication {
   530  	ctx, client, err := tests.NewClient(context.TODO())
   531  	require.NoError(t, err)
   532  
   533  	basicApplication := okta.NewBasicAuthApplication()
   534  	basicApplication.Settings = &okta.BasicApplicationSettings{
   535  		App: &okta.BasicApplicationSettingsApplication{
   536  			AuthURL: "https://example.com/auth.html",
   537  			Url:     "https://example.com/auth.html",
   538  		},
   539  	}
   540  
   541  	application, _, err := client.Application.CreateApplication(ctx, basicApplication, nil)
   542  	require.NoError(t, err, "Creating an application should not error")
   543  
   544  	return application.(*okta.BasicAuthApplication)
   545  }
   546  
   547  func createOrg2OrgApplication(t *testing.T) *okta.Org2OrgApplication {
   548  	ctx, client, err := tests.NewClient(context.TODO())
   549  	require.NoError(t, err)
   550  
   551  	application := okta.NewOrg2OrgApplication()
   552  	application.Label = "Sample Okta Org2Org App"
   553  	application.Name = "okta_org2org"
   554  	application.Settings = &okta.Org2OrgApplicationSettings{
   555  		App: &okta.Org2OrgApplicationSettingsApp{
   556  			AcsUrl:         "https://example.okta.com/sso/saml2/exampleid",
   557  			AudRestriction: "https://www.okta.com/saml2/service-provider/exampleid",
   558  			BaseUrl:        "https://example.okta.com",
   559  		},
   560  	}
   561  
   562  	app, _, err := client.Application.CreateApplication(ctx, application, query.NewQueryParams(query.WithActivate(true)))
   563  	require.NoError(t, err, "Creating an application should not error")
   564  
   565  	return app.(*okta.Org2OrgApplication)
   566  }
   567  
   568  func deleteAllApps(t *testing.T) {
   569  	ctx, client, err := tests.NewClient(context.TODO())
   570  	require.NoError(t, err)
   571  
   572  	applicationList, _, err := client.Application.ListApplications(ctx, nil)
   573  	if err != nil {
   574  		fmt.Printf("%+v\n", err)
   575  	}
   576  
   577  	for _, a := range applicationList {
   578  		if strings.HasPrefix(a.(*okta.Application).Label, "Template Basic Auth App") ||
   579  			strings.HasPrefix(a.(*okta.Application).Label, "Bookmark App") {
   580  			client.Application.DeactivateApplication(ctx, a.(*okta.Application).Id)
   581  			client.Application.DeleteApplication(ctx, a.(*okta.Application).Id)
   582  		}
   583  	}
   584  }
   585  

View as plain text