...

Source file src/edge-infra.dev/pkg/edge/api/graph/integration/tenant_queries_test.go

Documentation: edge-infra.dev/pkg/edge/api/graph/integration

     1  package integration_test
     2  
     3  import (
     4  	"edge-infra.dev/pkg/edge/api/graph/model"
     5  	"edge-infra.dev/test/framework/integration"
     6  
     7  	guuid "github.com/google/uuid"
     8  	"github.com/udacity/graphb"
     9  )
    10  
    11  func (s *Suite) TestTenant() {
    12  	var response struct {
    13  		Tenant *model.Tenant
    14  	}
    15  
    16  	tenantEdgeID := guuid.New().String()
    17  	orgID := guuid.New().String()
    18  	orgName := guuid.New().String()
    19  	_, err := s.DB.Exec("INSERT INTO tenants (tenant_edge_id, org_id, org_name) VALUES ($1, $2, $3);", tenantEdgeID, orgID, orgName)
    20  	s.NoError(err)
    21  
    22  	query := getTenantQuery(tenantEdgeID)
    23  	ResolverClient.MustPost(query, &response, WithAuth(s.Resolver, orgID, s.Config.TestUsername, s.Config.TestPassword, string(model.RoleEdgeOrgAdmin)))
    24  	s.NotNil(response.Tenant)
    25  
    26  	s.Equal(tenantEdgeID, response.Tenant.TenantEdgeID)
    27  	s.Equal(orgID, response.Tenant.TenantBSLId)
    28  	s.Equal(orgName, response.Tenant.OrgName)
    29  
    30  	if integration.IsIntegrationTest() {
    31  		_, err := s.DB.Exec("DELETE FROM tenants WHERE tenant_edge_id = $1", tenantEdgeID)
    32  		s.NoError(err)
    33  	}
    34  }
    35  
    36  func (s *Suite) TestTenants() {
    37  	var response struct {
    38  		Tenants []*model.Tenant
    39  	}
    40  
    41  	tenantEdgeID := guuid.New().String()
    42  	orgID := guuid.New().String()
    43  	orgName := guuid.New().String()
    44  	_, err := s.DB.Exec("INSERT INTO tenants (tenant_edge_id, org_id, org_name) VALUES ($1, $2, $3);", tenantEdgeID, orgID, orgName)
    45  	s.NoError(err)
    46  
    47  	query := getTenantsQuery()
    48  	ResolverClient.MustPost(query, &response, WithAuth(s.Resolver, orgID, s.Config.TestUsername, s.Config.TestPassword, string(model.RoleEdgeOrgAdmin)))
    49  	s.NotNil(response.Tenants)
    50  
    51  	tenantExists := false
    52  	for _, tenant := range response.Tenants {
    53  		if tenant.TenantEdgeID == tenantEdgeID {
    54  			tenantExists = true
    55  			s.Equal(orgID, tenant.TenantBSLId)
    56  			s.Equal(orgName, tenant.OrgName)
    57  			break
    58  		}
    59  	}
    60  	s.True(tenantExists)
    61  
    62  	if integration.IsIntegrationTest() {
    63  		_, err := s.DB.Exec("DELETE FROM tenants WHERE tenant_edge_id = $1", tenantEdgeID)
    64  		s.NoError(err)
    65  	}
    66  }
    67  
    68  func (s *Suite) TestGetOktaTenants() {
    69  	testOktaToken := "test-okta-token"
    70  	var response struct {
    71  		TenantsForOktaToken []*model.Tenant
    72  	}
    73  	tenantsSeed := []struct {
    74  		orgName string
    75  		orgID   string
    76  	}{
    77  		{
    78  			orgName: "test-bsl-org-1",
    79  			orgID:   guuid.New().String(),
    80  		},
    81  		{
    82  			orgName: "test-bsl-org-2",
    83  			orgID:   guuid.New().String(),
    84  		},
    85  		{
    86  			orgName: "test-bsl-org-3",
    87  			orgID:   guuid.New().String(),
    88  		},
    89  	}
    90  	for _, tenantSeed := range tenantsSeed {
    91  		_, err := s.DB.Exec("INSERT INTO tenants (org_id, org_name) VALUES ($1, $2);", tenantSeed.orgID, tenantSeed.orgName)
    92  		s.NoError(err)
    93  	}
    94  	query := getOktaTenantsQuery(testOktaToken)
    95  	ResolverClient.MustPost(query, &response)
    96  	s.NotNil(response.TenantsForOktaToken)
    97  }
    98  
    99  func getTenantQuery(tenantEdgeID string) string {
   100  	return MustParse(graphb.Query{
   101  		Type: graphb.TypeQuery,
   102  		Fields: []*graphb.Field{
   103  			{
   104  				Name: "tenant",
   105  				Arguments: []graphb.Argument{
   106  					graphb.ArgumentString("tenantEdgeId", tenantEdgeID),
   107  				},
   108  				Fields: graphb.Fields("orgName", "tenantBSLId", "tenantEdgeId"),
   109  			},
   110  		},
   111  	})
   112  }
   113  
   114  func getTenantsQuery() string {
   115  	return MustParse(graphb.Query{
   116  		Type: graphb.TypeQuery,
   117  		Fields: []*graphb.Field{
   118  			{
   119  				Name:   "tenants",
   120  				Fields: graphb.Fields("orgName", "tenantBSLId", "tenantEdgeId"),
   121  			},
   122  		},
   123  	})
   124  }
   125  
   126  func getOktaTenantsQuery(oktaToken string) string {
   127  	return MustParse(graphb.Query{
   128  		Type: graphb.TypeQuery,
   129  		Fields: []*graphb.Field{
   130  			{
   131  				Name: "tenantsForOktaToken",
   132  				Arguments: []graphb.Argument{
   133  					graphb.ArgumentString("oktaToken", oktaToken),
   134  				},
   135  				Fields: graphb.Fields("orgName", "tenantBSLId", "tenantEdgeId"),
   136  			},
   137  		},
   138  	})
   139  }
   140  

View as plain text