github.com/kyma-incubator/compass/components/director@v0.0.0-20230623144113-d764f56ff805/pkg/graphql_client/director_client_test.go (about)

     1  package graphqlclient_test
     2  
     3  import (
     4  	"context"
     5  	"strings"
     6  	"testing"
     7  
     8  	graphqlclient "github.com/kyma-incubator/compass/components/director/pkg/graphql_client"
     9  	gcli "github.com/machinebox/graphql"
    10  
    11  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
    12  	"github.com/kyma-incubator/compass/components/director/pkg/graphql_client/automock"
    13  	"github.com/kyma-incubator/compass/components/director/pkg/str"
    14  	"github.com/pkg/errors"
    15  	"github.com/stretchr/testify/mock"
    16  	"github.com/stretchr/testify/require"
    17  )
    18  
    19  func TestDirector_WriteTenants(t *testing.T) {
    20  	tenantsInput := []graphql.BusinessTenantMappingInput{
    21  		{
    22  			Name:           "0283bc56-406b-11ec-9356-0242ac130003",
    23  			ExternalTenant: "123",
    24  			Parent:         str.Ptr(""),
    25  			Subdomain:      str.Ptr("subdomain1"),
    26  			Region:         str.Ptr("region1"),
    27  			Type:           "account",
    28  			Provider:       "provider1",
    29  		},
    30  		{
    31  			Name:           "109534be-406b-11ec-9356-0242ac130003",
    32  			ExternalTenant: "456",
    33  			Parent:         str.Ptr(""),
    34  			Subdomain:      str.Ptr("subdomain2"),
    35  			Region:         str.Ptr("region2"),
    36  			Type:           "type2",
    37  			Provider:       "account",
    38  		},
    39  	}
    40  	expectedQuery := "mutation { writeTenants(in:[{name: \"0283bc56-406b-11ec-9356-0242ac130003\",externalTenant: \"123\",parent: \"\", region:\"region1\", subdomain: \"subdomain1\",type:\"account\",provider: \"provider1\"},{name: \"109534be-406b-11ec-9356-0242ac130003\",externalTenant: \"456\",parent: \"\", region:\"region2\", subdomain: \"subdomain2\",type:\"type2\",provider: \"account\"}])}"
    41  	testErr := errors.New("Test error")
    42  
    43  	testCases := []struct {
    44  		Name        string
    45  		GQLClient   func() *automock.GraphQLClient
    46  		Input       []graphql.BusinessTenantMappingInput
    47  		ExpectedErr error
    48  	}{
    49  		{
    50  			Name: "Success",
    51  			GQLClient: func() *automock.GraphQLClient {
    52  				gqlClient := &automock.GraphQLClient{}
    53  				gqlClient.On("Run", mock.Anything, mock.MatchedBy(func(req *gcli.Request) bool {
    54  					return strings.EqualFold(removeWhitespaces(req.Query()), removeWhitespaces(expectedQuery))
    55  				}), mock.Anything).Return(nil)
    56  				return gqlClient
    57  			},
    58  			Input:       tenantsInput,
    59  			ExpectedErr: nil,
    60  		},
    61  		{
    62  			Name: "Returns error when Run fails",
    63  			GQLClient: func() *automock.GraphQLClient {
    64  				gqlClient := &automock.GraphQLClient{}
    65  				gqlClient.On("Run", mock.Anything, mock.Anything, mock.Anything).Return(testErr)
    66  				return gqlClient
    67  			},
    68  			Input:       tenantsInput,
    69  			ExpectedErr: errors.New("while executing gql query"),
    70  		},
    71  	}
    72  
    73  	for _, testCase := range testCases {
    74  		t.Run(testCase.Name, func(t *testing.T) {
    75  			//GIVEN
    76  			ctx := context.TODO()
    77  			gqlClient := testCase.GQLClient()
    78  			director := graphqlclient.NewDirector(gqlClient)
    79  
    80  			//WHEN
    81  			err := director.WriteTenants(ctx, testCase.Input)
    82  
    83  			//THEN
    84  			if testCase.ExpectedErr == nil {
    85  				require.NoError(t, err)
    86  			} else {
    87  				require.Error(t, err)
    88  				require.Contains(t, err.Error(), testCase.ExpectedErr.Error())
    89  			}
    90  		})
    91  	}
    92  }
    93  
    94  func TestDirector_DeleteTenants(t *testing.T) {
    95  	tenantsInput := []graphql.BusinessTenantMappingInput{
    96  		{
    97  			Name:           "0283bc56-406b-11ec-9356-0242ac130003",
    98  			ExternalTenant: "123",
    99  			Parent:         str.Ptr(""),
   100  			Subdomain:      str.Ptr("subdomain1"),
   101  			Region:         str.Ptr("region1"),
   102  			Type:           "account",
   103  			Provider:       "provider1",
   104  		},
   105  		{
   106  			Name:           "109534be-406b-11ec-9356-0242ac130003",
   107  			ExternalTenant: "456",
   108  			Parent:         str.Ptr(""),
   109  			Subdomain:      str.Ptr("subdomain2"),
   110  			Region:         str.Ptr("region2"),
   111  			Type:           "type2",
   112  			Provider:       "account",
   113  		},
   114  	}
   115  	expectedQuery := `mutation { deleteTenants(in:["123", "456"])}`
   116  	testErr := errors.New("Test error")
   117  
   118  	testCases := []struct {
   119  		Name        string
   120  		GQLClient   func() *automock.GraphQLClient
   121  		Input       []graphql.BusinessTenantMappingInput
   122  		ExpectedErr error
   123  	}{
   124  		{
   125  			Name: "Success",
   126  			GQLClient: func() *automock.GraphQLClient {
   127  				gqlClient := &automock.GraphQLClient{}
   128  				gqlClient.On("Run", mock.Anything, mock.MatchedBy(func(req *gcli.Request) bool {
   129  					return strings.EqualFold(removeWhitespaces(req.Query()), removeWhitespaces(expectedQuery))
   130  				}), mock.Anything).Return(nil)
   131  				return gqlClient
   132  			},
   133  			Input:       tenantsInput,
   134  			ExpectedErr: nil,
   135  		},
   136  		{
   137  			Name: "Returns error when Run fails",
   138  			GQLClient: func() *automock.GraphQLClient {
   139  				gqlClient := &automock.GraphQLClient{}
   140  				gqlClient.On("Run", mock.Anything, mock.Anything, mock.Anything).Return(testErr)
   141  				return gqlClient
   142  			},
   143  			Input:       tenantsInput,
   144  			ExpectedErr: errors.New("while executing gql query"),
   145  		},
   146  	}
   147  
   148  	for _, testCase := range testCases {
   149  		t.Run(testCase.Name, func(t *testing.T) {
   150  			//GIVEN
   151  			ctx := context.TODO()
   152  			gqlClient := testCase.GQLClient()
   153  			director := graphqlclient.NewDirector(gqlClient)
   154  
   155  			//WHEN
   156  			err := director.DeleteTenants(ctx, testCase.Input)
   157  
   158  			//THEN
   159  			if testCase.ExpectedErr == nil {
   160  				require.NoError(t, err)
   161  			} else {
   162  				require.Error(t, err)
   163  				require.Contains(t, err.Error(), testCase.ExpectedErr.Error())
   164  			}
   165  		})
   166  	}
   167  }
   168  
   169  func TestDirector_UpdateTenant(t *testing.T) {
   170  	tenantID := "id1"
   171  	tenantInput := graphql.BusinessTenantMappingInput{
   172  		Name:           "0283bc56-406b-11ec-9356-0242ac130003",
   173  		ExternalTenant: "123",
   174  		Parent:         str.Ptr(""),
   175  		Subdomain:      str.Ptr("subdomain1"),
   176  		Region:         str.Ptr("region1"),
   177  		Type:           "account",
   178  		Provider:       "provider1",
   179  	}
   180  	expectedQuery := `mutation { updateTenant(id: "id1", in:{
   181  		name: "0283bc56-406b-11ec-9356-0242ac130003",
   182  		externalTenant: "123",
   183  		parent: "",
   184  		region: "region1",
   185  		subdomain: "subdomain1",
   186  		type: "account",
   187  		provider: "provider1"
   188  	}) {
   189  		id
   190  		internalID
   191  		name
   192  		initialized
   193  		labels
   194  		parentID
   195  		type
   196  	}}`
   197  	testErr := errors.New("Test error")
   198  
   199  	testCases := []struct {
   200  		Name        string
   201  		GQLClient   func() *automock.GraphQLClient
   202  		TenantID    string
   203  		Input       graphql.BusinessTenantMappingInput
   204  		ExpectedErr error
   205  	}{
   206  		{
   207  			Name: "Success",
   208  			GQLClient: func() *automock.GraphQLClient {
   209  				gqlClient := &automock.GraphQLClient{}
   210  				gqlClient.On("Run", mock.Anything, mock.MatchedBy(func(req *gcli.Request) bool {
   211  					return strings.EqualFold(removeWhitespaces(req.Query()), removeWhitespaces(expectedQuery))
   212  				}), mock.Anything).Return(nil)
   213  				return gqlClient
   214  			},
   215  			TenantID:    tenantID,
   216  			Input:       tenantInput,
   217  			ExpectedErr: nil,
   218  		},
   219  		{
   220  			Name: "Returns error when Run fails",
   221  			GQLClient: func() *automock.GraphQLClient {
   222  				gqlClient := &automock.GraphQLClient{}
   223  				gqlClient.On("Run", mock.Anything, mock.Anything, mock.Anything).Return(testErr)
   224  				return gqlClient
   225  			},
   226  			TenantID:    tenantID,
   227  			Input:       tenantInput,
   228  			ExpectedErr: errors.New("while executing gql query"),
   229  		},
   230  	}
   231  
   232  	for _, testCase := range testCases {
   233  		t.Run(testCase.Name, func(t *testing.T) {
   234  			//GIVEN
   235  			ctx := context.TODO()
   236  			gqlClient := testCase.GQLClient()
   237  			director := graphqlclient.NewDirector(gqlClient)
   238  
   239  			//WHEN
   240  			err := director.UpdateTenant(ctx, testCase.TenantID, testCase.Input)
   241  
   242  			//THEN
   243  			if testCase.ExpectedErr == nil {
   244  				require.NoError(t, err)
   245  			} else {
   246  				require.Error(t, err)
   247  				require.Contains(t, err.Error(), testCase.ExpectedErr.Error())
   248  			}
   249  		})
   250  	}
   251  }
   252  
   253  func removeWhitespaces(s string) string {
   254  	s = strings.ReplaceAll(s, " ", "")
   255  	s = strings.ReplaceAll(s, "\r", "")
   256  	s = strings.ReplaceAll(s, "\n", "")
   257  	s = strings.ReplaceAll(s, "\t", "")
   258  	return s
   259  }