...

Source file src/edge-infra.dev/pkg/edge/api/graph/resolver/helm_schema_queries.resolvers_test.go

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

     1  package resolver
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/golang/mock/gomock"
     8  	"github.com/stretchr/testify/assert"
     9  	"helm.sh/helm/v3/pkg/repo"
    10  
    11  	bsltypes "edge-infra.dev/pkg/edge/api/bsl/types"
    12  	"edge-infra.dev/pkg/edge/api/graph/mapper"
    13  	"edge-infra.dev/pkg/edge/api/graph/model"
    14  	"edge-infra.dev/pkg/edge/api/middleware"
    15  	"edge-infra.dev/pkg/edge/api/mocks"
    16  	"edge-infra.dev/pkg/edge/api/types"
    17  	"edge-infra.dev/pkg/edge/constants"
    18  	"edge-infra.dev/pkg/edge/externalsecrets"
    19  )
    20  
    21  var pID = "projectID"
    22  
    23  func TestCreateHelmRepo(t *testing.T) {
    24  	defaultWorkload := string(constants.TenantNamespaceSelector)
    25  	name := "test-secret-name"
    26  	url := "test-url"
    27  	mock := gomock.NewController(t)
    28  	gcpService := mocks.NewMockGCPService(mock)
    29  	gcpService.EXPECT().AddSecret(gomock.Any(), name, constants.DefaultOwnerFilter, constants.HelmRepositorySecretType, gomock.Any(), pID, &defaultWorkload, nil).
    30  		Return(nil).Times(1)
    31  
    32  	bannerService := mocks.NewMockBannerService(mock)
    33  	bannerService.EXPECT().GetBannerProjectID(gomock.Any(), "bannerEdgeID").
    34  		Return(pID, nil).Times(2)
    35  
    36  	helmService := mocks.NewMockHelmService(mock)
    37  	helmService.EXPECT().GetHelmRepositoryIndex(url, pID, pID).
    38  		Return(&repo.IndexFile{}, nil).Times(1)
    39  	helmService.EXPECT().GenerateHelmReleaseExternalSecrets(gomock.Any(), pID, mapper.HelmReleaseNamespace, []string{"test-secret-name"}).
    40  		Return([]*externalsecrets.ExternalSecret{}, nil).Times(1)
    41  	helmService.EXPECT().SendExternalSecretToChariot(gomock.Any(), pID, "", gomock.Any()).
    42  		Return(nil).Times(1)
    43  	helmService.EXPECT().CreateBannerHelmRepository(gomock.Any(), name, url, &name, pID).
    44  		Return(nil).Times(1)
    45  
    46  	c := &types.Config{BSP: bsltypes.BSPConfig{OrganizationPrefix: "test_prefix-"}}
    47  	r := &Resolver{
    48  		GCPService:    gcpService,
    49  		BannerService: bannerService,
    50  		HelmService:   helmService,
    51  		Config:        c,
    52  	}
    53  
    54  	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
    55  		Username:     "test-user",
    56  		Organization: "organization",
    57  	})
    58  	resp, err := r.Mutation().CreateHelmRepository(ctx, name, "bannerEdgeID", url, &pID, &pID)
    59  	assert.NoError(t, err)
    60  	assert.True(t, resp)
    61  	resp, err = r.Mutation().CreateHelmRepository(ctx, constants.NCRCharts, "bannerEdgeID", url, &pID, &pID)
    62  	assert.Error(t, err)
    63  	assert.False(t, resp)
    64  }
    65  
    66  func TestDeleteHelmRepo(t *testing.T) {
    67  	name := "test-secret-name"
    68  	mock := gomock.NewController(t)
    69  	gcpService := mocks.NewMockGCPService(mock)
    70  	gcpService.EXPECT().DeleteSecret(gomock.Any(), name, pID).
    71  		Return(true, nil).Times(1)
    72  
    73  	bannerService := mocks.NewMockBannerService(mock)
    74  	bannerService.EXPECT().GetBannerProjectID(gomock.Any(), "bannerEdgeID").
    75  		Return(pID, nil).Times(1)
    76  
    77  	helmService := mocks.NewMockHelmService(mock)
    78  	helmService.EXPECT().DeleteHelmRepo(gomock.Any(), name, pID, "bannerEdgeID").
    79  		Return(nil).Times(1)
    80  
    81  	c := &types.Config{BSP: bsltypes.BSPConfig{OrganizationPrefix: "test_prefix-"}}
    82  	r := &Resolver{
    83  		GCPService:    gcpService,
    84  		BannerService: bannerService,
    85  		HelmService:   helmService,
    86  		Config:        c,
    87  	}
    88  
    89  	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
    90  		Username:     "test-user",
    91  		Organization: "organization",
    92  	})
    93  	resp, err := r.Mutation().DeleteHelmRepository(ctx, name, "bannerEdgeID")
    94  	assert.NoError(t, err)
    95  	assert.True(t, resp)
    96  	resp, err = r.Mutation().DeleteHelmRepository(ctx, constants.NCRCharts, "bannerEdgeID")
    97  	assert.Error(t, err)
    98  	assert.False(t, resp)
    99  }
   100  
   101  func TestGetHelmRepos(t *testing.T) {
   102  	defaultOwnerFilter := constants.DefaultOwnerFilter
   103  	helmRepoType := constants.HelmRepositorySecretType
   104  	helmRepo1 := mapper.GetTestHelmRepositorySecret()
   105  	helmRepo2 := mapper.GetTestHelmRepositorySecret()
   106  	repos := []*model.SecretManagerResponse{helmRepo1, helmRepo2}
   107  	mock := gomock.NewController(t)
   108  	gcpService := mocks.NewMockGCPService(mock)
   109  	//GetSecrets(ctx, nil, &defaultOwnerFilter, &helmRepoType, true, projectID)
   110  	gcpService.EXPECT().GetSecrets(gomock.Any(), nil, &defaultOwnerFilter, &helmRepoType, true, pID).
   111  		Return(repos, nil).Times(1)
   112  
   113  	bannerService := mocks.NewMockBannerService(mock)
   114  	bannerService.EXPECT().GetBannerProjectID(gomock.Any(), "bannerEdgeID").
   115  		Return(pID, nil).Times(1)
   116  
   117  	c := &types.Config{BSP: bsltypes.BSPConfig{OrganizationPrefix: "test_prefix-"}}
   118  	r := &Resolver{
   119  		GCPService:    gcpService,
   120  		BannerService: bannerService,
   121  		Config:        c,
   122  	}
   123  
   124  	ctx := middleware.NewContext(context.Background(), &bsltypes.AuthUser{
   125  		Username:     "test-user",
   126  		Organization: "organization",
   127  	})
   128  	resp, err := r.Query().HelmRepositories(ctx, "bannerEdgeID")
   129  	assert.NoError(t, err)
   130  	assert.Equal(t, 2, len(resp))
   131  	for i, releaseModel := range resp {
   132  		mapper.VerifyHelmRepositoryEqualModel(repos[i], releaseModel, t)
   133  	}
   134  }
   135  

View as plain text