main_test.go

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

     1  package integration
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"log"
     7  	"math/rand"
     8  	"os"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/okta/okta-sdk-golang/v2/okta"
    13  	"github.com/okta/okta-sdk-golang/v2/okta/query"
    14  	"github.com/okta/okta-sdk-golang/v2/tests"
    15  )
    16  
    17  func init() {
    18  	rand.Seed(time.Now().UTC().UnixNano())
    19  }
    20  
    21  func TestMain(m *testing.M) {
    22  	err := sweep()
    23  	if err != nil {
    24  		log.Printf("failed to clean up organization before integration tests: %v", err)
    25  	}
    26  	exitVal := m.Run()
    27  	err = sweep()
    28  	if err != nil {
    29  		log.Printf("failed to clean up organization after integration tests: %v", err)
    30  	}
    31  	os.Exit(exitVal)
    32  }
    33  
    34  // sweep the resources before running integration tests
    35  func sweep() error {
    36  	log.Println("[INFO] sweeping test users, groups and rules")
    37  	ctx, client, err := tests.NewClient(context.Background())
    38  	if err != nil {
    39  		return err
    40  	}
    41  	err = sweepUsers(ctx, client)
    42  	if err != nil {
    43  		return err
    44  	}
    45  	err = sweepGroups(ctx, client)
    46  	if err != nil {
    47  		return err
    48  	}
    49  	return sweepGroupRules(ctx, client)
    50  }
    51  
    52  func sweepGroups(ctx context.Context, client *okta.Client) error {
    53  	groups, _, err := client.Group.ListGroups(ctx, &query.Params{Q: "SDK_TEST"})
    54  	if err != nil {
    55  		return err
    56  	}
    57  	for _, g := range groups {
    58  		_, err = client.Group.DeleteGroup(ctx, g.Id)
    59  		if err != nil {
    60  			return err
    61  		}
    62  	}
    63  	return nil
    64  }
    65  
    66  func sweepGroupRules(ctx context.Context, client *okta.Client) error {
    67  	groupRules, _, err := client.Group.ListGroupRules(ctx, &query.Params{Q: "SDK_TEST"})
    68  	if err != nil {
    69  		return err
    70  	}
    71  	for _, g := range groupRules {
    72  		if g.Status == "ACTIVE" {
    73  			_, err = client.Group.DeactivateGroupRule(ctx, g.Id)
    74  			if err != nil {
    75  				return err
    76  			}
    77  		}
    78  		_, err = client.Group.DeleteGroupRule(ctx, g.Id, &query.Params{})
    79  		if err != nil {
    80  			return err
    81  		}
    82  	}
    83  	return nil
    84  }
    85  
    86  func sweepUsers(ctx context.Context, client *okta.Client) error {
    87  	users, resp, err := client.User.ListUsers(ctx, &query.Params{Q: "SDK_TEST", Limit: 200})
    88  	if err != nil {
    89  		return err
    90  	}
    91  	for _, u := range users {
    92  		if err := ensureUserDelete(ctx, client, u.Id, u.Status); err != nil {
    93  			return err
    94  		}
    95  	}
    96  	for resp.HasNextPage() {
    97  		var users []*okta.User
    98  		resp, err = resp.Next(ctx, &users)
    99  		if err != nil {
   100  			return err
   101  		}
   102  		for _, u := range users {
   103  			if err := ensureUserDelete(ctx, client, u.Id, u.Status); err != nil {
   104  				return err
   105  			}
   106  		}
   107  	}
   108  	return nil
   109  }
   110  
   111  func ensureUserDelete(ctx context.Context, client *okta.Client, id, status string) error {
   112  	// only deprovisioned users can be deleted fully from okta
   113  	// make two passes on the user if they aren't deprovisioned already to deprovision them first
   114  	passes := 2
   115  	if status == "DEPROVISIONED" {
   116  		passes = 1
   117  	}
   118  	for i := 0; i < passes; i++ {
   119  		_, err := client.User.DeactivateOrDeleteUser(ctx, id, nil)
   120  		if err != nil {
   121  			return fmt.Errorf("failed to deprovision or delete user: %w", err)
   122  		}
   123  	}
   124  	return nil
   125  }
   126  
   127  const (
   128  	charSetAlphaUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   129  	charSetAlphaLower = "abcdefghijklmnopqrstuvwxyz"
   130  	charSetNumeric    = "0123456789"
   131  	charSetAlpha      = charSetAlphaLower + charSetAlphaUpper + charSetNumeric
   132  	testPrefix        = "SDK_TEST_"
   133  )
   134  
   135  func randomEmail() string {
   136  	return randomTestString() + "@example.com"
   137  }
   138  
   139  // randStringFromCharSet generates a random string of 15 lower case letters
   140  func randomTestString() string {
   141  	result := make([]byte, 15)
   142  	for i := 0; i < 15; i++ {
   143  		result[i] = charSetAlphaLower[rand.Intn(len(charSetAlphaLower))]
   144  	}
   145  	return testPrefix + string(result)
   146  }
   147  
   148  // testPassword generates a random string of at least 4 characters in length
   149  func testPassword(length int) string {
   150  	if length < 5 {
   151  		length = 4
   152  	}
   153  	result := make([]byte, length)
   154  	result[0] = charSetAlphaLower[rand.Intn(len(charSetAlphaLower))]
   155  	result[1] = charSetAlphaUpper[rand.Intn(len(charSetAlphaUpper))]
   156  	result[2] = charSetNumeric[rand.Intn(len(charSetNumeric))]
   157  	for i := 3; i < length; i++ {
   158  		result[i] = charSetAlpha[rand.Intn(len(charSetAlpha))]
   159  	}
   160  	return string(result)
   161  }
   162  
   163  func testName(name string) string {
   164  	s := fmt.Sprintf("%s %s", randomTestString(), name)
   165  	if len(s) > 50 {
   166  		s = s[:50]
   167  	}
   168  	return s
   169  }
   170
View as plain text