github.com/kyma-incubator/compass/components/director@v0.0.0-20230623144113-d764f56ff805/internal/domain/onetimetoken/resolver_test.go (about)

     1  package onetimetoken_test
     2  
     3  import (
     4  	"context"
     5  	"encoding/base64"
     6  	"errors"
     7  	"testing"
     8  
     9  	pkgmodel "github.com/kyma-incubator/compass/components/director/pkg/model"
    10  
    11  	"github.com/stretchr/testify/mock"
    12  
    13  	"github.com/kyma-incubator/compass/components/director/internal/domain/onetimetoken"
    14  	"github.com/kyma-incubator/compass/components/director/internal/domain/onetimetoken/automock"
    15  	"github.com/kyma-incubator/compass/components/director/internal/model"
    16  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
    17  	"github.com/kyma-incubator/compass/components/director/pkg/persistence/txtest"
    18  	"github.com/stretchr/testify/assert"
    19  	"github.com/stretchr/testify/require"
    20  )
    21  
    22  const suggestTokenHeaderKey = "suggest_token"
    23  
    24  var systemID string = ""
    25  
    26  func TestResolver_GenerateOneTimeTokenForApp(t *testing.T) {
    27  	testErr := errors.New("test error")
    28  	txGen := txtest.NewTransactionContextGenerator(testErr)
    29  	appID := "08d805a5-87f0-4194-adc7-277ec10de2ef"
    30  	ctx := context.TODO()
    31  	tokenModel := &model.OneTimeToken{Token: "Token", ConnectorURL: "connectorURL"}
    32  	expectedToken := graphql.OneTimeTokenForApplication{TokenWithURL: graphql.TokenWithURL{Token: "Token", ConnectorURL: "connectorURL"}}
    33  	t.Run("Success", func(t *testing.T) {
    34  		// GIVEN
    35  		svc := &automock.TokenService{}
    36  		svc.On("GenerateOneTimeToken", txtest.CtxWithDBMatcher(), appID, pkgmodel.ApplicationReference).Return(tokenModel, nil)
    37  		conv := &automock.TokenConverter{}
    38  		conv.On("ToGraphQLForApplication", *tokenModel).Return(expectedToken, nil)
    39  		persist, transact := txGen.ThatSucceeds()
    40  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
    41  
    42  		// WHEN
    43  		oneTimeToken, err := r.RequestOneTimeTokenForApplication(ctx, appID, nil)
    44  
    45  		// THEN
    46  		require.NoError(t, err)
    47  		require.NotNil(t, oneTimeToken)
    48  		assert.Equal(t, expectedToken, *oneTimeToken)
    49  		mock.AssertExpectationsForObjects(t, persist, transact, svc, conv)
    50  	})
    51  
    52  	t.Run("Success with system auth id", func(t *testing.T) {
    53  		// GIVEN
    54  		svc := &automock.TokenService{}
    55  		svc.On("RegenerateOneTimeToken", txtest.CtxWithDBMatcher(), systemID).Return(tokenModel, nil)
    56  		conv := &automock.TokenConverter{}
    57  		conv.On("ToGraphQLForApplication", *tokenModel).Return(expectedToken, nil)
    58  		persist, transact := txGen.ThatSucceeds()
    59  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
    60  
    61  		// WHEN
    62  		oneTimeToken, err := r.RequestOneTimeTokenForApplication(ctx, appID, &systemID)
    63  
    64  		// THEN
    65  		require.NoError(t, err)
    66  		require.NotNil(t, oneTimeToken)
    67  		assert.Equal(t, expectedToken, *oneTimeToken)
    68  		mock.AssertExpectationsForObjects(t, persist, transact, svc, conv)
    69  	})
    70  
    71  	t.Run("Error - transaction commit failed", func(t *testing.T) {
    72  		// GIVEN
    73  		svc := &automock.TokenService{}
    74  		svc.On("GenerateOneTimeToken", txtest.CtxWithDBMatcher(), appID, pkgmodel.ApplicationReference).Return(tokenModel, nil)
    75  		persist, transact := txGen.ThatFailsOnCommit()
    76  		conv := &automock.TokenConverter{}
    77  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
    78  
    79  		// WHEN
    80  		_, err := r.RequestOneTimeTokenForApplication(ctx, appID, nil)
    81  
    82  		// THEN
    83  		require.Error(t, err)
    84  		mock.AssertExpectationsForObjects(t, persist, transact, svc, conv)
    85  	})
    86  
    87  	t.Run("Error - service return error", func(t *testing.T) {
    88  		// GIVEN
    89  		svc := &automock.TokenService{}
    90  		svc.On("GenerateOneTimeToken", txtest.CtxWithDBMatcher(), appID, pkgmodel.ApplicationReference).Return(tokenModel, testErr)
    91  		persist, transact := txGen.ThatDoesntExpectCommit()
    92  		conv := &automock.TokenConverter{}
    93  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
    94  
    95  		// WHEN
    96  		_, err := r.RequestOneTimeTokenForApplication(ctx, appID, nil)
    97  
    98  		// THEN
    99  		require.Error(t, err)
   100  		mock.AssertExpectationsForObjects(t, persist, transact, svc, conv)
   101  	})
   102  
   103  	t.Run("Error - begin transaction failed", func(t *testing.T) {
   104  		// GIVEN
   105  		svc := &automock.TokenService{}
   106  		persist, transact := txGen.ThatFailsOnBegin()
   107  		conv := &automock.TokenConverter{}
   108  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
   109  
   110  		// WHEN
   111  		_, err := r.RequestOneTimeTokenForApplication(ctx, appID, nil)
   112  
   113  		// THEN
   114  		require.Error(t, err)
   115  		mock.AssertExpectationsForObjects(t, persist, transact, svc, conv)
   116  	})
   117  
   118  	t.Run("Error - converter returns error", func(t *testing.T) {
   119  		// GIVEN
   120  		svc := &automock.TokenService{}
   121  		svc.On("GenerateOneTimeToken", txtest.CtxWithDBMatcher(), appID, pkgmodel.ApplicationReference).Return(tokenModel, nil)
   122  		conv := &automock.TokenConverter{}
   123  		conv.On("ToGraphQLForApplication", *tokenModel).Return(graphql.OneTimeTokenForApplication{}, errors.New("some-error"))
   124  		persist, transact := txGen.ThatSucceeds()
   125  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
   126  
   127  		// WHEN
   128  		_, err := r.RequestOneTimeTokenForApplication(ctx, appID, nil)
   129  
   130  		// THEN
   131  		require.EqualError(t, err, "while converting one-time token to graphql: some-error")
   132  		mock.AssertExpectationsForObjects(t, persist, transact, svc, conv)
   133  	})
   134  }
   135  
   136  func TestResolver_GenerateOneTimeTokenForRuntime(t *testing.T) {
   137  	testErr := errors.New("test error")
   138  	txGen := txtest.NewTransactionContextGenerator(testErr)
   139  	runtimeID := "08d805a5-87f0-4194-adc7-277ec10de2ef"
   140  	ctx := context.TODO()
   141  	tokenModel := &model.OneTimeToken{Token: "Token", ConnectorURL: "connectorURL"}
   142  	expectedToken := graphql.OneTimeTokenForRuntime{TokenWithURL: graphql.TokenWithURL{Token: "Token", ConnectorURL: "connectorURL"}}
   143  	t.Run("Success", func(t *testing.T) {
   144  		// GIVEN
   145  		svc := &automock.TokenService{}
   146  		svc.On("GenerateOneTimeToken", txtest.CtxWithDBMatcher(), runtimeID, pkgmodel.RuntimeReference).Return(tokenModel, nil)
   147  		persist, transact := txGen.ThatSucceeds()
   148  		conv := &automock.TokenConverter{}
   149  		conv.On("ToGraphQLForRuntime", *tokenModel).Return(expectedToken)
   150  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
   151  
   152  		// WHEN
   153  		oneTimeToken, err := r.RequestOneTimeTokenForRuntime(ctx, runtimeID, nil)
   154  
   155  		// THEN
   156  		require.NoError(t, err)
   157  		require.NotNil(t, oneTimeToken)
   158  		assert.Equal(t, expectedToken, *oneTimeToken)
   159  		persist.AssertExpectations(t)
   160  		transact.AssertExpectations(t)
   161  		svc.AssertExpectations(t)
   162  		conv.AssertExpectations(t)
   163  	})
   164  
   165  	t.Run("Error - transaction commit failed", func(t *testing.T) {
   166  		// GIVEN
   167  		svc := &automock.TokenService{}
   168  		svc.On("GenerateOneTimeToken", txtest.CtxWithDBMatcher(), runtimeID, pkgmodel.RuntimeReference).Return(tokenModel, nil)
   169  		persist, transact := txGen.ThatFailsOnCommit()
   170  		conv := &automock.TokenConverter{}
   171  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
   172  
   173  		// WHEN
   174  		_, err := r.RequestOneTimeTokenForRuntime(ctx, runtimeID, nil)
   175  
   176  		// THEN
   177  		require.Error(t, err)
   178  		persist.AssertExpectations(t)
   179  		transact.AssertExpectations(t)
   180  		svc.AssertExpectations(t)
   181  		conv.AssertExpectations(t)
   182  	})
   183  
   184  	t.Run("Error - service return error", func(t *testing.T) {
   185  		// GIVEN
   186  		svc := &automock.TokenService{}
   187  		svc.On("GenerateOneTimeToken", txtest.CtxWithDBMatcher(), runtimeID, pkgmodel.RuntimeReference).Return(tokenModel, testErr)
   188  		persist, transact := txGen.ThatDoesntExpectCommit()
   189  		conv := &automock.TokenConverter{}
   190  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
   191  
   192  		// WHEN
   193  		_, err := r.RequestOneTimeTokenForRuntime(ctx, runtimeID, nil)
   194  
   195  		// THEN
   196  		require.Error(t, err)
   197  		persist.AssertExpectations(t)
   198  		transact.AssertExpectations(t)
   199  		svc.AssertExpectations(t)
   200  		conv.AssertExpectations(t)
   201  	})
   202  
   203  	t.Run("Error - begin transaction failed", func(t *testing.T) {
   204  		// GIVEN
   205  		svc := &automock.TokenService{}
   206  		persist, transact := txGen.ThatFailsOnBegin()
   207  		conv := &automock.TokenConverter{}
   208  		r := onetimetoken.NewTokenResolver(transact, svc, conv, suggestTokenHeaderKey)
   209  
   210  		// WHEN
   211  		_, err := r.RequestOneTimeTokenForRuntime(ctx, runtimeID, nil)
   212  
   213  		// THEN
   214  		require.Error(t, err)
   215  		persist.AssertExpectations(t)
   216  		transact.AssertExpectations(t)
   217  		svc.AssertExpectations(t)
   218  		conv.AssertExpectations(t)
   219  	})
   220  }
   221  
   222  func TestResolver_RawEncoded(t *testing.T) {
   223  	ctx := context.TODO()
   224  	tokenGraphql := graphql.OneTimeTokenForApplication{TokenWithURL: graphql.TokenWithURL{Token: "Token", ConnectorURL: "connectorURL", Used: false, Type: graphql.OneTimeTokenTypeApplication, ScenarioGroups: []string{"test_scenario_group"}}, LegacyConnectorURL: "legacyConnectorURL"}
   225  	expectedRawToken := "{\"token\":\"Token\"," +
   226  		"\"connectorURL\":\"connectorURL\",\"used\":false,\"expiresAt\":null,\"createdAt\":null,\"usedAt\":null,\"type\":\"Application\",\"scenario_groups\":[\"test_scenario_group\"]}"
   227  	expectedBaseToken := base64.StdEncoding.EncodeToString([]byte(expectedRawToken))
   228  	t.Run("Success", func(t *testing.T) {
   229  		// GIVEN
   230  		r := onetimetoken.NewTokenResolver(nil, nil, nil, "")
   231  		// WHEN
   232  		baseEncodedToken, err := r.RawEncoded(ctx, &tokenGraphql.TokenWithURL)
   233  
   234  		// THEN
   235  		require.NoError(t, err)
   236  		assert.Equal(t, &expectedBaseToken, baseEncodedToken)
   237  	})
   238  
   239  	t.Run("Error - nil token", func(t *testing.T) {
   240  		// GIVEN
   241  		r := onetimetoken.NewTokenResolver(nil, nil, nil, suggestTokenHeaderKey)
   242  
   243  		// WHEN
   244  		_, err := r.RawEncoded(ctx, nil)
   245  
   246  		// THEN
   247  		require.Error(t, err)
   248  	})
   249  }
   250  
   251  func TestResolver_Raw(t *testing.T) {
   252  	ctx := context.TODO()
   253  	tokenGraphql := graphql.OneTimeTokenForApplication{TokenWithURL: graphql.TokenWithURL{Token: "Token", ConnectorURL: "connectorURL", Type: graphql.OneTimeTokenTypeApplication, ScenarioGroups: []string{"test_scenario_group"}}, LegacyConnectorURL: "legacyConnectorURL"}
   254  	expectedRawToken := "{\"token\":\"Token\"," +
   255  		"\"connectorURL\":\"connectorURL\",\"used\":false,\"expiresAt\":null,\"createdAt\":null,\"usedAt\":null,\"type\":\"Application\",\"scenario_groups\":[\"test_scenario_group\"]}"
   256  
   257  	t.Run("Success", func(t *testing.T) {
   258  		// GIVEN
   259  		r := onetimetoken.NewTokenResolver(nil, nil, nil, suggestTokenHeaderKey)
   260  
   261  		// WHEN
   262  		baseEncodedToken, err := r.Raw(ctx, &tokenGraphql.TokenWithURL)
   263  
   264  		// THEN
   265  		require.NoError(t, err)
   266  		assert.Equal(t, &expectedRawToken, baseEncodedToken)
   267  	})
   268  
   269  	t.Run("Error - nil token", func(t *testing.T) {
   270  		// GIVEN
   271  		r := onetimetoken.NewTokenResolver(nil, nil, nil, suggestTokenHeaderKey)
   272  
   273  		// WHEN
   274  		_, err := r.Raw(ctx, nil)
   275  
   276  		// THEN
   277  		require.Error(t, err)
   278  	})
   279  }