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