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

     1  package bundleinstanceauth_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/kyma-incubator/compass/components/director/pkg/str"
     8  	"github.com/stretchr/testify/require"
     9  
    10  	pkgmock "github.com/kyma-incubator/compass/components/director/internal/domain/bundle/automock"
    11  	"github.com/kyma-incubator/compass/components/director/internal/domain/bundleinstanceauth"
    12  	"github.com/kyma-incubator/compass/components/director/internal/domain/bundleinstanceauth/automock"
    13  	"github.com/kyma-incubator/compass/components/director/internal/model"
    14  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
    15  	persistenceautomock "github.com/kyma-incubator/compass/components/director/pkg/persistence/automock"
    16  	"github.com/kyma-incubator/compass/components/director/pkg/persistence/txtest"
    17  
    18  	"github.com/pkg/errors"
    19  	"github.com/stretchr/testify/assert"
    20  	"github.com/stretchr/testify/mock"
    21  )
    22  
    23  func TestResolver_DeleteBundleInstanceAuth(t *testing.T) {
    24  	// GIVEN
    25  	testErr := errors.New("Test error")
    26  
    27  	id := "bar"
    28  	modelInstanceAuth := fixSimpleModelBundleInstanceAuth(id)
    29  	gqlInstanceAuth := fixSimpleGQLBundleInstanceAuth(id)
    30  
    31  	txGen := txtest.NewTransactionContextGenerator(testErr)
    32  
    33  	testCases := []struct {
    34  		Name              string
    35  		TransactionerFn   func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
    36  		ServiceFn         func() *automock.Service
    37  		ConverterFn       func() *automock.Converter
    38  		BundleConverterFn func() *pkgmock.BundleConverter
    39  		ExpectedResult    *graphql.BundleInstanceAuth
    40  		ExpectedErr       error
    41  	}{
    42  		{
    43  			Name:            "Success",
    44  			TransactionerFn: txGen.ThatSucceeds,
    45  			ServiceFn: func() *automock.Service {
    46  				svc := &automock.Service{}
    47  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
    48  				svc.On("Delete", txtest.CtxWithDBMatcher(), id).Return(nil).Once()
    49  				return svc
    50  			},
    51  			ConverterFn: func() *automock.Converter {
    52  				conv := &automock.Converter{}
    53  				conv.On("ToGraphQL", modelInstanceAuth).Return(gqlInstanceAuth, nil).Once()
    54  				return conv
    55  			},
    56  			BundleConverterFn: func() *pkgmock.BundleConverter {
    57  				return &pkgmock.BundleConverter{}
    58  			},
    59  			ExpectedResult: gqlInstanceAuth,
    60  			ExpectedErr:    nil,
    61  		},
    62  		{
    63  			Name:            "Return error when starting transaction fails",
    64  			TransactionerFn: txGen.ThatFailsOnBegin,
    65  			ServiceFn: func() *automock.Service {
    66  				svc := &automock.Service{}
    67  				return svc
    68  			},
    69  			ConverterFn: func() *automock.Converter {
    70  				conv := &automock.Converter{}
    71  				return conv
    72  			},
    73  			BundleConverterFn: func() *pkgmock.BundleConverter {
    74  				return &pkgmock.BundleConverter{}
    75  			},
    76  			ExpectedResult: nil,
    77  			ExpectedErr:    testErr,
    78  		},
    79  		{
    80  			Name:            "Returns error when Instance Auth retrieval failed",
    81  			TransactionerFn: txGen.ThatDoesntExpectCommit,
    82  			ServiceFn: func() *automock.Service {
    83  				svc := &automock.Service{}
    84  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(nil, testErr).Once()
    85  				return svc
    86  			},
    87  			ConverterFn: func() *automock.Converter {
    88  				conv := &automock.Converter{}
    89  				return conv
    90  			},
    91  			BundleConverterFn: func() *pkgmock.BundleConverter {
    92  				return &pkgmock.BundleConverter{}
    93  			},
    94  			ExpectedResult: nil,
    95  			ExpectedErr:    testErr,
    96  		},
    97  		{
    98  			Name:            "Returns error when Instance Auth deletion failed",
    99  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   100  			ServiceFn: func() *automock.Service {
   101  				svc := &automock.Service{}
   102  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
   103  				svc.On("Delete", txtest.CtxWithDBMatcher(), id).Return(testErr).Once()
   104  				return svc
   105  			},
   106  			ConverterFn: func() *automock.Converter {
   107  				conv := &automock.Converter{}
   108  				return conv
   109  			},
   110  			BundleConverterFn: func() *pkgmock.BundleConverter {
   111  				return &pkgmock.BundleConverter{}
   112  			},
   113  			ExpectedResult: nil,
   114  			ExpectedErr:    testErr,
   115  		},
   116  		{
   117  			Name:            "Return error when commit transaction fails",
   118  			TransactionerFn: txGen.ThatFailsOnCommit,
   119  			ServiceFn: func() *automock.Service {
   120  				svc := &automock.Service{}
   121  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
   122  				svc.On("Delete", txtest.CtxWithDBMatcher(), id).Return(nil).Once()
   123  				return svc
   124  			},
   125  			ConverterFn: func() *automock.Converter {
   126  				conv := &automock.Converter{}
   127  				return conv
   128  			},
   129  			BundleConverterFn: func() *pkgmock.BundleConverter {
   130  				return &pkgmock.BundleConverter{}
   131  			},
   132  			ExpectedResult: nil,
   133  			ExpectedErr:    testErr,
   134  		},
   135  	}
   136  
   137  	for _, testCase := range testCases {
   138  		t.Run(testCase.Name, func(t *testing.T) {
   139  			// GIVEN
   140  			persist, transact := testCase.TransactionerFn()
   141  			svc := testCase.ServiceFn()
   142  			converter := testCase.ConverterFn()
   143  			bndlConverter := testCase.BundleConverterFn()
   144  
   145  			resolver := bundleinstanceauth.NewResolver(transact, svc, nil, converter, bndlConverter)
   146  
   147  			// WHEN
   148  			result, err := resolver.DeleteBundleInstanceAuth(context.TODO(), id)
   149  
   150  			// THEN
   151  			assert.Equal(t, testCase.ExpectedResult, result)
   152  			assert.Equal(t, testCase.ExpectedErr, err)
   153  
   154  			svc.AssertExpectations(t)
   155  			converter.AssertExpectations(t)
   156  			transact.AssertExpectations(t)
   157  			persist.AssertExpectations(t)
   158  		})
   159  	}
   160  }
   161  
   162  func TestResolver_RequestBundleInstanceAuthCreation(t *testing.T) {
   163  	// GIVEN
   164  	modelBundle := fixModelBundle(testBundleID, nil, nil)
   165  	gqlRequestInput := fixGQLRequestInput()
   166  	modelRequestInput := fixModelRequestInput()
   167  
   168  	modelInstanceAuth := fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, nil, &testRuntimeID)
   169  	gqlInstanceAuth := fixGQLBundleInstanceAuthWithoutContextAndInputParams(testID, nil, nil, &testRuntimeID)
   170  
   171  	txGen := txtest.NewTransactionContextGenerator(testError)
   172  
   173  	testCases := []struct {
   174  		Name              string
   175  		TransactionerFn   func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   176  		ServiceFn         func() *automock.Service
   177  		BndlServiceFn     func() *automock.BundleService
   178  		ConverterFn       func() *automock.Converter
   179  		BundleConverterFn func() *pkgmock.BundleConverter
   180  		ExpectedResult    *graphql.BundleInstanceAuth
   181  		ExpectedErr       error
   182  	}{
   183  		{
   184  			Name:            "Success",
   185  			TransactionerFn: txGen.ThatSucceeds,
   186  			ServiceFn: func() *automock.Service {
   187  				svc := &automock.Service{}
   188  				svc.On("Create", txtest.CtxWithDBMatcher(), testBundleID, *modelRequestInput, modelInstanceAuth.Auth, modelInstanceAuth.InputParams).Return(testID, nil).Once()
   189  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   190  				return svc
   191  			},
   192  			BndlServiceFn: func() *automock.BundleService {
   193  				svc := &automock.BundleService{}
   194  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   195  				return svc
   196  			},
   197  			ConverterFn: func() *automock.Converter {
   198  				conv := &automock.Converter{}
   199  				conv.On("RequestInputFromGraphQL", *gqlRequestInput).Return(*modelRequestInput).Once()
   200  				conv.On("ToGraphQL", modelInstanceAuth).Return(gqlInstanceAuth, nil).Once()
   201  				return conv
   202  			},
   203  			BundleConverterFn: func() *pkgmock.BundleConverter {
   204  				return &pkgmock.BundleConverter{}
   205  			},
   206  			ExpectedResult: gqlInstanceAuth,
   207  			ExpectedErr:    nil,
   208  		},
   209  		{
   210  			Name:            "Return error when starting transaction fails",
   211  			TransactionerFn: txGen.ThatFailsOnBegin,
   212  			ServiceFn: func() *automock.Service {
   213  				svc := &automock.Service{}
   214  				return svc
   215  			},
   216  			BndlServiceFn: func() *automock.BundleService {
   217  				svc := &automock.BundleService{}
   218  				return svc
   219  			},
   220  			ConverterFn: func() *automock.Converter {
   221  				conv := &automock.Converter{}
   222  				return conv
   223  			},
   224  			BundleConverterFn: func() *pkgmock.BundleConverter {
   225  				return &pkgmock.BundleConverter{}
   226  			},
   227  			ExpectedResult: nil,
   228  			ExpectedErr:    testError,
   229  		},
   230  		{
   231  			Name:            "Return error when commit transaction fails",
   232  			TransactionerFn: txGen.ThatFailsOnCommit,
   233  			ServiceFn: func() *automock.Service {
   234  				svc := &automock.Service{}
   235  				svc.On("Create", txtest.CtxWithDBMatcher(), testBundleID, *modelRequestInput, modelInstanceAuth.Auth, modelInstanceAuth.InputParams).Return(testID, nil).Once()
   236  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   237  				return svc
   238  			},
   239  			BndlServiceFn: func() *automock.BundleService {
   240  				svc := &automock.BundleService{}
   241  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   242  				return svc
   243  			},
   244  			ConverterFn: func() *automock.Converter {
   245  				conv := &automock.Converter{}
   246  				conv.On("RequestInputFromGraphQL", *gqlRequestInput).Return(*modelRequestInput, nil).Once()
   247  				return conv
   248  			},
   249  			BundleConverterFn: func() *pkgmock.BundleConverter {
   250  				return &pkgmock.BundleConverter{}
   251  			},
   252  			ExpectedResult: nil,
   253  			ExpectedErr:    testError,
   254  		},
   255  		{
   256  			Name:            "Returns error when Bundle retrieval failed",
   257  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   258  			ServiceFn: func() *automock.Service {
   259  				svc := &automock.Service{}
   260  				return svc
   261  			},
   262  			BndlServiceFn: func() *automock.BundleService {
   263  				svc := &automock.BundleService{}
   264  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(nil, testError).Once()
   265  				return svc
   266  			},
   267  			ConverterFn: func() *automock.Converter {
   268  				conv := &automock.Converter{}
   269  				return conv
   270  			},
   271  			BundleConverterFn: func() *pkgmock.BundleConverter {
   272  				return &pkgmock.BundleConverter{}
   273  			},
   274  			ExpectedResult: nil,
   275  			ExpectedErr:    testError,
   276  		},
   277  		{
   278  			Name:            "Returns error when Instance Auth creation failed",
   279  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   280  			ServiceFn: func() *automock.Service {
   281  				svc := &automock.Service{}
   282  				svc.On("Create", txtest.CtxWithDBMatcher(), testBundleID, *modelRequestInput, modelInstanceAuth.Auth, modelInstanceAuth.InputParams).Return("", testError).Once()
   283  				return svc
   284  			},
   285  			BndlServiceFn: func() *automock.BundleService {
   286  				svc := &automock.BundleService{}
   287  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   288  				return svc
   289  			},
   290  			ConverterFn: func() *automock.Converter {
   291  				conv := &automock.Converter{}
   292  				conv.On("RequestInputFromGraphQL", *gqlRequestInput).Return(*modelRequestInput, nil).Once()
   293  				return conv
   294  			},
   295  			BundleConverterFn: func() *pkgmock.BundleConverter {
   296  				return &pkgmock.BundleConverter{}
   297  			},
   298  			ExpectedResult: nil,
   299  			ExpectedErr:    testError,
   300  		},
   301  		{
   302  			Name:            "Returns error when Instance Auth retrieval failed",
   303  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   304  			ServiceFn: func() *automock.Service {
   305  				svc := &automock.Service{}
   306  				svc.On("Create", txtest.CtxWithDBMatcher(), testBundleID, *modelRequestInput, modelInstanceAuth.Auth, modelInstanceAuth.InputParams).Return(testID, nil).Once()
   307  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(nil, testError).Once()
   308  				return svc
   309  			},
   310  			BndlServiceFn: func() *automock.BundleService {
   311  				svc := &automock.BundleService{}
   312  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   313  				return svc
   314  			},
   315  			ConverterFn: func() *automock.Converter {
   316  				conv := &automock.Converter{}
   317  				conv.On("RequestInputFromGraphQL", *gqlRequestInput).Return(*modelRequestInput, nil).Once()
   318  				return conv
   319  			},
   320  			BundleConverterFn: func() *pkgmock.BundleConverter {
   321  				return &pkgmock.BundleConverter{}
   322  			},
   323  			ExpectedResult: nil,
   324  			ExpectedErr:    testError,
   325  		},
   326  	}
   327  
   328  	for _, testCase := range testCases {
   329  		t.Run(testCase.Name, func(t *testing.T) {
   330  			// GIVEN
   331  			persist, transact := testCase.TransactionerFn()
   332  			svc := testCase.ServiceFn()
   333  			bndlSvc := testCase.BndlServiceFn()
   334  			converter := testCase.ConverterFn()
   335  			bndlConverter := testCase.BundleConverterFn()
   336  
   337  			resolver := bundleinstanceauth.NewResolver(transact, svc, bndlSvc, converter, bndlConverter)
   338  
   339  			result, err := resolver.RequestBundleInstanceAuthCreation(context.TODO(), testBundleID, *gqlRequestInput)
   340  
   341  			// THEN
   342  			assert.Equal(t, testCase.ExpectedResult, result)
   343  			assert.Equal(t, testCase.ExpectedErr, err)
   344  
   345  			mock.AssertExpectationsForObjects(t, persist, transact, svc, bndlSvc, converter)
   346  		})
   347  	}
   348  }
   349  
   350  func TestResolver_CreateBundleInstanceAuth(t *testing.T) {
   351  	// GIVEN
   352  	modelBundle := fixModelBundle(testBundleID, nil, nil)
   353  	gqlCreateInput := *fixGQLCreateInput()
   354  	modelCreateInput := *fixModelCreateInput()
   355  
   356  	modelInstanceAuth := fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, nil, &testRuntimeID)
   357  	gqlInstanceAuth := fixGQLBundleInstanceAuthWithoutContextAndInputParams(testID, nil, nil, &testRuntimeID)
   358  
   359  	txGen := txtest.NewTransactionContextGenerator(testError)
   360  
   361  	testCases := []struct {
   362  		Name            string
   363  		TransactionerFn func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   364  		ServiceFn       func() *automock.Service
   365  		BndlServiceFn   func() *automock.BundleService
   366  		ConverterFn     func() *automock.Converter
   367  		ExpectedResult  *graphql.BundleInstanceAuth
   368  		ExpectedErr     error
   369  	}{
   370  		{
   371  			Name:            "Success",
   372  			TransactionerFn: txGen.ThatSucceeds,
   373  			ServiceFn: func() *automock.Service {
   374  				svc := &automock.Service{}
   375  				svc.On("CreateBundleInstanceAuth", txtest.CtxWithDBMatcher(), testBundleID, modelCreateInput, modelInstanceAuth.InputParams).Return(testID, nil).Once()
   376  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   377  				return svc
   378  			},
   379  			BndlServiceFn: func() *automock.BundleService {
   380  				svc := &automock.BundleService{}
   381  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   382  				return svc
   383  			},
   384  			ConverterFn: func() *automock.Converter {
   385  				conv := &automock.Converter{}
   386  				conv.On("CreateInputFromGraphQL", gqlCreateInput).Return(modelCreateInput, nil).Once()
   387  				conv.On("ToGraphQL", modelInstanceAuth).Return(gqlInstanceAuth, nil).Once()
   388  				return conv
   389  			},
   390  			ExpectedResult: gqlInstanceAuth,
   391  		},
   392  		{
   393  			Name:            "Return error when starting transaction fails",
   394  			TransactionerFn: txGen.ThatFailsOnBegin,
   395  			ExpectedErr:     testError,
   396  		},
   397  		{
   398  			Name:            "Return error when commit transaction fails",
   399  			TransactionerFn: txGen.ThatFailsOnCommit,
   400  			ServiceFn: func() *automock.Service {
   401  				svc := &automock.Service{}
   402  				svc.On("CreateBundleInstanceAuth", txtest.CtxWithDBMatcher(), testBundleID, modelCreateInput, modelInstanceAuth.InputParams).Return(testID, nil).Once()
   403  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   404  				return svc
   405  			},
   406  			BndlServiceFn: func() *automock.BundleService {
   407  				svc := &automock.BundleService{}
   408  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   409  				return svc
   410  			},
   411  			ConverterFn: func() *automock.Converter {
   412  				conv := &automock.Converter{}
   413  				conv.On("CreateInputFromGraphQL", gqlCreateInput).Return(modelCreateInput, nil).Once()
   414  				return conv
   415  			},
   416  			ExpectedErr: testError,
   417  		},
   418  		{
   419  			Name:            "Returns error when Instance Auth retrieval failed",
   420  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   421  			ServiceFn: func() *automock.Service {
   422  				svc := &automock.Service{}
   423  				svc.On("CreateBundleInstanceAuth", txtest.CtxWithDBMatcher(), testBundleID, modelCreateInput, modelInstanceAuth.InputParams).Return(testID, nil).Once()
   424  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(nil, testError).Once()
   425  				return svc
   426  			},
   427  			BndlServiceFn: func() *automock.BundleService {
   428  				svc := &automock.BundleService{}
   429  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   430  				return svc
   431  			},
   432  			ConverterFn: func() *automock.Converter {
   433  				conv := &automock.Converter{}
   434  				conv.On("CreateInputFromGraphQL", gqlCreateInput).Return(modelCreateInput, nil).Once()
   435  				return conv
   436  			},
   437  			ExpectedErr: testError,
   438  		},
   439  		{
   440  			Name:            "Returns error when Instance Auth creation failed",
   441  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   442  			ServiceFn: func() *automock.Service {
   443  				svc := &automock.Service{}
   444  				svc.On("CreateBundleInstanceAuth", txtest.CtxWithDBMatcher(), testBundleID, modelCreateInput, modelInstanceAuth.InputParams).Return("", testError).Once()
   445  				return svc
   446  			},
   447  			BndlServiceFn: func() *automock.BundleService {
   448  				svc := &automock.BundleService{}
   449  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   450  				return svc
   451  			},
   452  			ConverterFn: func() *automock.Converter {
   453  				conv := &automock.Converter{}
   454  				conv.On("CreateInputFromGraphQL", gqlCreateInput).Return(modelCreateInput, nil).Once()
   455  				return conv
   456  			},
   457  			ExpectedErr: testError,
   458  		},
   459  		{
   460  			Name:            "Returns error when converting input to graphql failed",
   461  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   462  			BndlServiceFn: func() *automock.BundleService {
   463  				svc := &automock.BundleService{}
   464  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   465  				return svc
   466  			},
   467  			ConverterFn: func() *automock.Converter {
   468  				conv := &automock.Converter{}
   469  				conv.On("CreateInputFromGraphQL", gqlCreateInput).Return(model.BundleInstanceAuthCreateInput{}, testError).Once()
   470  				return conv
   471  			},
   472  			ExpectedErr: testError,
   473  		},
   474  		{
   475  			Name:            "Returns error when Bundle retrieval failed",
   476  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   477  			BndlServiceFn: func() *automock.BundleService {
   478  				svc := &automock.BundleService{}
   479  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(nil, testError).Once()
   480  				return svc
   481  			},
   482  			ExpectedErr: testError,
   483  		},
   484  	}
   485  
   486  	for _, testCase := range testCases {
   487  		t.Run(testCase.Name, func(t *testing.T) {
   488  			// GIVEN
   489  			persist, transact := testCase.TransactionerFn()
   490  			svc := &automock.Service{}
   491  			if testCase.ServiceFn != nil {
   492  				svc = testCase.ServiceFn()
   493  			}
   494  			bndlSvc := &automock.BundleService{}
   495  			if testCase.BndlServiceFn != nil {
   496  				bndlSvc = testCase.BndlServiceFn()
   497  			}
   498  			converter := &automock.Converter{}
   499  			if testCase.ConverterFn != nil {
   500  				converter = testCase.ConverterFn()
   501  			}
   502  
   503  			resolver := bundleinstanceauth.NewResolver(transact, svc, bndlSvc, converter, nil)
   504  
   505  			result, err := resolver.CreateBundleInstanceAuth(context.TODO(), testBundleID, gqlCreateInput)
   506  
   507  			// THEN
   508  			if testCase.ExpectedErr == nil {
   509  				require.Equal(t, testCase.ExpectedResult, result)
   510  				require.Nil(t, err)
   511  			} else {
   512  				require.Contains(t, err.Error(), testCase.ExpectedErr.Error())
   513  				require.Nil(t, result)
   514  			}
   515  			mock.AssertExpectationsForObjects(t, persist, transact, svc, bndlSvc, converter)
   516  		})
   517  	}
   518  }
   519  
   520  func TestResolver_UpdateBundleInstanceAuth(t *testing.T) {
   521  	// GIVEN
   522  	modelBundle := fixModelBundle(testBundleID, nil, nil)
   523  	gqlUpdateInput := *fixGQLUpdateInput()
   524  	modelUpdateInput := *fixModelUpdateInput()
   525  
   526  	modelBundleWithSchema := fixModelBundle(testBundleID, str.Ptr("{\"type\": \"string\"}"), nil)
   527  	invalidInputParams := graphql.JSON(`"{"`)
   528  	gqlUpdateInputWithInvalidParams := graphql.BundleInstanceAuthUpdateInput{
   529  		Context:     gqlUpdateInput.Context,
   530  		InputParams: &invalidInputParams,
   531  		Auth:        gqlUpdateInput.Auth,
   532  	}
   533  	modelUpdateInputWithInvalidParams := model.BundleInstanceAuthUpdateInput{
   534  		Context:     modelUpdateInput.Context,
   535  		InputParams: str.Ptr("{"),
   536  		Auth:        modelUpdateInput.Auth,
   537  	}
   538  
   539  	modelInstanceAuth := fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, nil, &testRuntimeID)
   540  	updatedModelInstanceAuth := fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, nil, &testRuntimeID)
   541  	updatedModelInstanceAuth.Context = modelUpdateInput.Context
   542  	updatedModelInstanceAuth.InputParams = modelUpdateInput.InputParams
   543  	updatedModelInstanceAuth.Auth = modelUpdateInput.Auth.ToAuth()
   544  
   545  	gqlInstanceAuth := fixGQLBundleInstanceAuthWithoutContextAndInputParams(testID, nil, nil, &testRuntimeID)
   546  
   547  	txGen := txtest.NewTransactionContextGenerator(testError)
   548  
   549  	testCases := []struct {
   550  		Name            string
   551  		TransactionerFn func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   552  		ServiceFn       func() *automock.Service
   553  		BndlServiceFn   func() *automock.BundleService
   554  		ConverterFn     func() *automock.Converter
   555  		Input           graphql.BundleInstanceAuthUpdateInput
   556  		ExpectedResult  *graphql.BundleInstanceAuth
   557  		ExpectedErr     error
   558  	}{
   559  		{
   560  			Name:            "Success",
   561  			TransactionerFn: txGen.ThatSucceeds,
   562  			ServiceFn: func() *automock.Service {
   563  				svc := &automock.Service{}
   564  				svc.On("Update", txtest.CtxWithDBMatcher(), updatedModelInstanceAuth).Return(nil).Once()
   565  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Twice()
   566  				return svc
   567  			},
   568  			BndlServiceFn: func() *automock.BundleService {
   569  				svc := &automock.BundleService{}
   570  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   571  				return svc
   572  			},
   573  			ConverterFn: func() *automock.Converter {
   574  				conv := &automock.Converter{}
   575  				conv.On("UpdateInputFromGraphQL", gqlUpdateInput).Return(modelUpdateInput, nil).Once()
   576  				conv.On("ToGraphQL", modelInstanceAuth).Return(gqlInstanceAuth, nil).Once()
   577  				return conv
   578  			},
   579  			Input:          gqlUpdateInput,
   580  			ExpectedResult: gqlInstanceAuth,
   581  		},
   582  		{
   583  			Name:            "Return error when starting transaction fails",
   584  			TransactionerFn: txGen.ThatFailsOnBegin,
   585  			Input:           gqlUpdateInput,
   586  			ExpectedErr:     testError,
   587  		},
   588  		{
   589  			Name:            "Return error when commit transaction fails",
   590  			TransactionerFn: txGen.ThatFailsOnCommit,
   591  			ServiceFn: func() *automock.Service {
   592  				svc := &automock.Service{}
   593  				svc.On("Update", txtest.CtxWithDBMatcher(), updatedModelInstanceAuth).Return(nil).Once()
   594  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Twice()
   595  				return svc
   596  			},
   597  			BndlServiceFn: func() *automock.BundleService {
   598  				svc := &automock.BundleService{}
   599  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   600  				return svc
   601  			},
   602  			ConverterFn: func() *automock.Converter {
   603  				conv := &automock.Converter{}
   604  				conv.On("UpdateInputFromGraphQL", gqlUpdateInput).Return(modelUpdateInput, nil).Once()
   605  				return conv
   606  			},
   607  			Input:       gqlUpdateInput,
   608  			ExpectedErr: testError,
   609  		},
   610  		{
   611  			Name:            "Returns error when Instance Auth retrieval after update failed",
   612  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   613  			ServiceFn: func() *automock.Service {
   614  				svc := &automock.Service{}
   615  				svc.On("Update", txtest.CtxWithDBMatcher(), updatedModelInstanceAuth).Return(nil).Once()
   616  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   617  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(nil, testError).Once()
   618  				return svc
   619  			},
   620  			BndlServiceFn: func() *automock.BundleService {
   621  				svc := &automock.BundleService{}
   622  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   623  				return svc
   624  			},
   625  			ConverterFn: func() *automock.Converter {
   626  				conv := &automock.Converter{}
   627  				conv.On("UpdateInputFromGraphQL", gqlUpdateInput).Return(modelUpdateInput, nil).Once()
   628  				return conv
   629  			},
   630  			Input:       gqlUpdateInput,
   631  			ExpectedErr: testError,
   632  		},
   633  		{
   634  			Name:            "Returns error when input params are not valid",
   635  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   636  			ServiceFn: func() *automock.Service {
   637  				svc := &automock.Service{}
   638  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   639  				return svc
   640  			},
   641  			BndlServiceFn: func() *automock.BundleService {
   642  				svc := &automock.BundleService{}
   643  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundleWithSchema, nil).Once()
   644  				return svc
   645  			},
   646  			ConverterFn: func() *automock.Converter {
   647  				conv := &automock.Converter{}
   648  				conv.On("UpdateInputFromGraphQL", gqlUpdateInputWithInvalidParams).Return(modelUpdateInputWithInvalidParams, nil).Once()
   649  				return conv
   650  			},
   651  			Input:       gqlUpdateInputWithInvalidParams,
   652  			ExpectedErr: errors.New("while validating BundleInstanceAuth"),
   653  		},
   654  		{
   655  			Name:            "Returns error when Instance Auth update failed",
   656  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   657  			ServiceFn: func() *automock.Service {
   658  				svc := &automock.Service{}
   659  				svc.On("Update", txtest.CtxWithDBMatcher(), updatedModelInstanceAuth).Return(testError).Once()
   660  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   661  				return svc
   662  			},
   663  			BndlServiceFn: func() *automock.BundleService {
   664  				svc := &automock.BundleService{}
   665  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   666  				return svc
   667  			},
   668  			ConverterFn: func() *automock.Converter {
   669  				conv := &automock.Converter{}
   670  				conv.On("UpdateInputFromGraphQL", gqlUpdateInput).Return(modelUpdateInput, nil).Once()
   671  				return conv
   672  			},
   673  			Input:       gqlUpdateInput,
   674  			ExpectedErr: testError,
   675  		},
   676  		{
   677  			Name:            "Returns error when Instance Auth retrieval before update failed",
   678  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   679  			ServiceFn: func() *automock.Service {
   680  				svc := &automock.Service{}
   681  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(nil, testError).Once()
   682  				return svc
   683  			},
   684  			BndlServiceFn: func() *automock.BundleService {
   685  				svc := &automock.BundleService{}
   686  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   687  				return svc
   688  			},
   689  			ConverterFn: func() *automock.Converter {
   690  				conv := &automock.Converter{}
   691  				conv.On("UpdateInputFromGraphQL", gqlUpdateInput).Return(modelUpdateInput, nil).Once()
   692  				return conv
   693  			},
   694  			Input:       gqlUpdateInput,
   695  			ExpectedErr: testError,
   696  		},
   697  		{
   698  			Name:            "Returns error when converting input to graphql failed",
   699  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   700  			BndlServiceFn: func() *automock.BundleService {
   701  				svc := &automock.BundleService{}
   702  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBundle, nil).Once()
   703  				return svc
   704  			},
   705  			ConverterFn: func() *automock.Converter {
   706  				conv := &automock.Converter{}
   707  				conv.On("UpdateInputFromGraphQL", gqlUpdateInput).Return(model.BundleInstanceAuthUpdateInput{}, testError).Once()
   708  				return conv
   709  			},
   710  			Input:       gqlUpdateInput,
   711  			ExpectedErr: testError,
   712  		},
   713  		{
   714  			Name:            "Returns error when Bundle retrieval failed",
   715  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   716  			BndlServiceFn: func() *automock.BundleService {
   717  				svc := &automock.BundleService{}
   718  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(nil, testError).Once()
   719  				return svc
   720  			},
   721  			Input:       gqlUpdateInput,
   722  			ExpectedErr: testError,
   723  		},
   724  	}
   725  
   726  	for _, testCase := range testCases {
   727  		t.Run(testCase.Name, func(t *testing.T) {
   728  			// GIVEN
   729  			persist, transact := testCase.TransactionerFn()
   730  			svc := &automock.Service{}
   731  			if testCase.ServiceFn != nil {
   732  				svc = testCase.ServiceFn()
   733  			}
   734  			bndlSvc := &automock.BundleService{}
   735  			if testCase.BndlServiceFn != nil {
   736  				bndlSvc = testCase.BndlServiceFn()
   737  			}
   738  			converter := &automock.Converter{}
   739  			if testCase.ConverterFn != nil {
   740  				converter = testCase.ConverterFn()
   741  			}
   742  
   743  			resolver := bundleinstanceauth.NewResolver(transact, svc, bndlSvc, converter, nil)
   744  
   745  			result, err := resolver.UpdateBundleInstanceAuth(context.TODO(), testID, testBundleID, testCase.Input)
   746  
   747  			// THEN
   748  			if testCase.ExpectedErr == nil {
   749  				require.Equal(t, testCase.ExpectedResult, result)
   750  				require.Nil(t, err)
   751  			} else {
   752  				require.Contains(t, err.Error(), testCase.ExpectedErr.Error())
   753  				require.Nil(t, result)
   754  			}
   755  
   756  			mock.AssertExpectationsForObjects(t, persist, transact, svc, bndlSvc, converter)
   757  		})
   758  	}
   759  }
   760  
   761  func TestResolver_SetBundleInstanceAuth(t *testing.T) {
   762  	// GIVEN
   763  
   764  	testAuthID := "foo"
   765  
   766  	modelSetInput := fixModelSetInput()
   767  	gqlSetInput := fixGQLSetInput()
   768  
   769  	modelInstanceAuth := fixModelBundleInstanceAuthWithoutContextAndInputParams(testID, testBundleID, testTenant, nil, nil, nil)
   770  	gqlInstanceAuth := fixGQLBundleInstanceAuthWithoutContextAndInputParams(testID, nil, nil, nil)
   771  
   772  	txGen := txtest.NewTransactionContextGenerator(testError)
   773  
   774  	testCases := []struct {
   775  		Name              string
   776  		TransactionerFn   func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   777  		ServiceFn         func() *automock.Service
   778  		ConverterFn       func() *automock.Converter
   779  		BundleConverterFn func() *pkgmock.BundleConverter
   780  		ExpectedResult    *graphql.BundleInstanceAuth
   781  		ExpectedErr       error
   782  	}{
   783  		{
   784  			Name:            "Success",
   785  			TransactionerFn: txGen.ThatSucceeds,
   786  			ServiceFn: func() *automock.Service {
   787  				svc := &automock.Service{}
   788  				svc.On("SetAuth", txtest.CtxWithDBMatcher(), testID, *modelSetInput).Return(nil).Once()
   789  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   790  				return svc
   791  			},
   792  			ConverterFn: func() *automock.Converter {
   793  				conv := &automock.Converter{}
   794  				conv.On("SetInputFromGraphQL", *gqlSetInput).Return(*modelSetInput, nil).Once()
   795  				conv.On("ToGraphQL", modelInstanceAuth).Return(gqlInstanceAuth, nil).Once()
   796  				return conv
   797  			},
   798  			BundleConverterFn: func() *pkgmock.BundleConverter {
   799  				return &pkgmock.BundleConverter{}
   800  			},
   801  			ExpectedResult: gqlInstanceAuth,
   802  			ExpectedErr:    nil,
   803  		},
   804  		{
   805  			Name:            "Return error when starting transaction fails",
   806  			TransactionerFn: txGen.ThatFailsOnBegin,
   807  			ServiceFn: func() *automock.Service {
   808  				svc := &automock.Service{}
   809  				return svc
   810  			},
   811  			ConverterFn: func() *automock.Converter {
   812  				conv := &automock.Converter{}
   813  				return conv
   814  			},
   815  			BundleConverterFn: func() *pkgmock.BundleConverter {
   816  				return &pkgmock.BundleConverter{}
   817  			},
   818  			ExpectedResult: nil,
   819  			ExpectedErr:    testError,
   820  		},
   821  		{
   822  			Name:            "Return error when commit transaction fails",
   823  			TransactionerFn: txGen.ThatFailsOnCommit,
   824  			ServiceFn: func() *automock.Service {
   825  				svc := &automock.Service{}
   826  				svc.On("SetAuth", txtest.CtxWithDBMatcher(), testID, *modelSetInput).Return(nil).Once()
   827  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(modelInstanceAuth, nil).Once()
   828  				return svc
   829  			},
   830  			ConverterFn: func() *automock.Converter {
   831  				conv := &automock.Converter{}
   832  				conv.On("SetInputFromGraphQL", *gqlSetInput).Return(*modelSetInput, nil).Once()
   833  				return conv
   834  			},
   835  			BundleConverterFn: func() *pkgmock.BundleConverter {
   836  				return &pkgmock.BundleConverter{}
   837  			},
   838  			ExpectedResult: nil,
   839  			ExpectedErr:    testError,
   840  		},
   841  		{
   842  			Name:            "Returns error when setting Instance Auth failed",
   843  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   844  			ServiceFn: func() *automock.Service {
   845  				svc := &automock.Service{}
   846  				svc.On("SetAuth", txtest.CtxWithDBMatcher(), testID, *modelSetInput).Return(testError).Once()
   847  				return svc
   848  			},
   849  			ConverterFn: func() *automock.Converter {
   850  				conv := &automock.Converter{}
   851  				conv.On("SetInputFromGraphQL", *gqlSetInput).Return(*modelSetInput, nil).Once()
   852  				return conv
   853  			},
   854  			BundleConverterFn: func() *pkgmock.BundleConverter {
   855  				return &pkgmock.BundleConverter{}
   856  			},
   857  			ExpectedResult: nil,
   858  			ExpectedErr:    testError,
   859  		},
   860  		{
   861  			Name:            "Returns error when Instance Auth retrieval failed",
   862  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   863  			ServiceFn: func() *automock.Service {
   864  				svc := &automock.Service{}
   865  				svc.On("SetAuth", txtest.CtxWithDBMatcher(), testID, *modelSetInput).Return(nil).Once()
   866  				svc.On("Get", txtest.CtxWithDBMatcher(), testID).Return(nil, testError).Once()
   867  				return svc
   868  			},
   869  			ConverterFn: func() *automock.Converter {
   870  				conv := &automock.Converter{}
   871  				conv.On("SetInputFromGraphQL", *gqlSetInput).Return(*modelSetInput, nil).Once()
   872  				return conv
   873  			},
   874  			BundleConverterFn: func() *pkgmock.BundleConverter {
   875  				return &pkgmock.BundleConverter{}
   876  			},
   877  			ExpectedResult: nil,
   878  			ExpectedErr:    testError,
   879  		},
   880  	}
   881  
   882  	for _, testCase := range testCases {
   883  		t.Run(testCase.Name, func(t *testing.T) {
   884  			// GIVEN
   885  			persist, transact := testCase.TransactionerFn()
   886  			svc := testCase.ServiceFn()
   887  			converter := testCase.ConverterFn()
   888  			bndlConverter := testCase.BundleConverterFn()
   889  
   890  			resolver := bundleinstanceauth.NewResolver(transact, svc, nil, converter, bndlConverter)
   891  
   892  			// WHEN
   893  			result, err := resolver.SetBundleInstanceAuth(context.TODO(), testAuthID, *gqlSetInput)
   894  
   895  			// THEN
   896  			assert.Equal(t, testCase.ExpectedResult, result)
   897  			assert.Equal(t, testCase.ExpectedErr, err)
   898  
   899  			mock.AssertExpectationsForObjects(t, persist, transact, svc, converter)
   900  		})
   901  	}
   902  }
   903  
   904  func TestResolver_RequestBundleInstanceAuthDeletion(t *testing.T) {
   905  	// GIVEN
   906  	testErr := errors.New("Test error")
   907  
   908  	id := "bar"
   909  	modelInstanceAuth := fixSimpleModelBundleInstanceAuth(id)
   910  	gqlInstanceAuth := fixSimpleGQLBundleInstanceAuth(id)
   911  
   912  	modelBndl := &model.Bundle{
   913  		DefaultInstanceAuth: fixModelAuth(),
   914  		BaseEntity: &model.BaseEntity{
   915  			ID: testBundleID,
   916  		},
   917  	}
   918  
   919  	txGen := txtest.NewTransactionContextGenerator(testErr)
   920  
   921  	testCases := []struct {
   922  		Name              string
   923  		TransactionerFn   func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   924  		ServiceFn         func() *automock.Service
   925  		BundleServiceFn   func() *automock.BundleService
   926  		ConverterFn       func() *automock.Converter
   927  		BundleConverterFn func() *pkgmock.BundleConverter
   928  		ExpectedResult    *graphql.BundleInstanceAuth
   929  		ExpectedErr       error
   930  	}{
   931  		{
   932  			Name:            "Success - Deleted",
   933  			TransactionerFn: txGen.ThatSucceeds,
   934  			ServiceFn: func() *automock.Service {
   935  				svc := &automock.Service{}
   936  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
   937  				svc.On("RequestDeletion", txtest.CtxWithDBMatcher(), modelInstanceAuth, modelBndl.DefaultInstanceAuth).Return(true, nil).Once()
   938  				return svc
   939  			},
   940  			BundleServiceFn: func() *automock.BundleService {
   941  				svc := &automock.BundleService{}
   942  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBndl, nil).Once()
   943  				return svc
   944  			},
   945  			ConverterFn: func() *automock.Converter {
   946  				conv := &automock.Converter{}
   947  				conv.On("ToGraphQL", modelInstanceAuth).Return(gqlInstanceAuth, nil).Once()
   948  				return conv
   949  			},
   950  			BundleConverterFn: func() *pkgmock.BundleConverter {
   951  				return &pkgmock.BundleConverter{}
   952  			},
   953  			ExpectedResult: gqlInstanceAuth,
   954  			ExpectedErr:    nil,
   955  		},
   956  		{
   957  			Name:            "Success - Not Deleted",
   958  			TransactionerFn: txGen.ThatSucceeds,
   959  			ServiceFn: func() *automock.Service {
   960  				svc := &automock.Service{}
   961  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Twice()
   962  				svc.On("RequestDeletion", txtest.CtxWithDBMatcher(), modelInstanceAuth, modelBndl.DefaultInstanceAuth).Return(false, nil).Once()
   963  				return svc
   964  			},
   965  			BundleServiceFn: func() *automock.BundleService {
   966  				svc := &automock.BundleService{}
   967  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBndl, nil).Once()
   968  				return svc
   969  			},
   970  			ConverterFn: func() *automock.Converter {
   971  				conv := &automock.Converter{}
   972  				conv.On("ToGraphQL", modelInstanceAuth).Return(gqlInstanceAuth, nil).Once()
   973  				return conv
   974  			},
   975  			BundleConverterFn: func() *pkgmock.BundleConverter {
   976  				return &pkgmock.BundleConverter{}
   977  			},
   978  			ExpectedResult: gqlInstanceAuth,
   979  			ExpectedErr:    nil,
   980  		},
   981  		{
   982  			Name:            "Error - Get Instance Auth",
   983  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   984  			ServiceFn: func() *automock.Service {
   985  				svc := &automock.Service{}
   986  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(nil, testErr).Once()
   987  				return svc
   988  			},
   989  			BundleServiceFn: func() *automock.BundleService {
   990  				return &automock.BundleService{}
   991  			},
   992  			ConverterFn: func() *automock.Converter {
   993  				return &automock.Converter{}
   994  			},
   995  			BundleConverterFn: func() *pkgmock.BundleConverter {
   996  				return &pkgmock.BundleConverter{}
   997  			},
   998  			ExpectedResult: nil,
   999  			ExpectedErr:    testErr,
  1000  		},
  1001  		{
  1002  			Name:            "Error - Get Bundle",
  1003  			TransactionerFn: txGen.ThatDoesntExpectCommit,
  1004  			ServiceFn: func() *automock.Service {
  1005  				svc := &automock.Service{}
  1006  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
  1007  				return svc
  1008  			},
  1009  			BundleServiceFn: func() *automock.BundleService {
  1010  				svc := &automock.BundleService{}
  1011  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(nil, testErr).Once()
  1012  				return svc
  1013  			},
  1014  			ConverterFn: func() *automock.Converter {
  1015  				return &automock.Converter{}
  1016  			},
  1017  			BundleConverterFn: func() *pkgmock.BundleConverter {
  1018  				return &pkgmock.BundleConverter{}
  1019  			},
  1020  			ExpectedResult: nil,
  1021  			ExpectedErr:    testErr,
  1022  		},
  1023  		{
  1024  			Name:            "Error - Request Deletion",
  1025  			TransactionerFn: txGen.ThatDoesntExpectCommit,
  1026  			ServiceFn: func() *automock.Service {
  1027  				svc := &automock.Service{}
  1028  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
  1029  				svc.On("RequestDeletion", txtest.CtxWithDBMatcher(), modelInstanceAuth, modelBndl.DefaultInstanceAuth).Return(false, testErr).Once()
  1030  				return svc
  1031  			},
  1032  			BundleServiceFn: func() *automock.BundleService {
  1033  				svc := &automock.BundleService{}
  1034  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBndl, nil).Once()
  1035  				return svc
  1036  			},
  1037  			ConverterFn: func() *automock.Converter {
  1038  				return &automock.Converter{}
  1039  			},
  1040  			BundleConverterFn: func() *pkgmock.BundleConverter {
  1041  				return &pkgmock.BundleConverter{}
  1042  			},
  1043  			ExpectedResult: nil,
  1044  			ExpectedErr:    testErr,
  1045  		},
  1046  		{
  1047  			Name:            "Error - Get After Setting Status",
  1048  			TransactionerFn: txGen.ThatDoesntExpectCommit,
  1049  			ServiceFn: func() *automock.Service {
  1050  				svc := &automock.Service{}
  1051  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
  1052  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(nil, testErr).Once()
  1053  				svc.On("RequestDeletion", txtest.CtxWithDBMatcher(), modelInstanceAuth, modelBndl.DefaultInstanceAuth).Return(false, nil).Once()
  1054  				return svc
  1055  			},
  1056  			BundleServiceFn: func() *automock.BundleService {
  1057  				svc := &automock.BundleService{}
  1058  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBndl, nil).Once()
  1059  				return svc
  1060  			},
  1061  			ConverterFn: func() *automock.Converter {
  1062  				return &automock.Converter{}
  1063  			},
  1064  			BundleConverterFn: func() *pkgmock.BundleConverter {
  1065  				return &pkgmock.BundleConverter{}
  1066  			},
  1067  			ExpectedResult: nil,
  1068  			ExpectedErr:    testErr,
  1069  		},
  1070  		{
  1071  			Name:            "Error - Transaction Begin",
  1072  			TransactionerFn: txGen.ThatFailsOnBegin,
  1073  			ServiceFn: func() *automock.Service {
  1074  				return &automock.Service{}
  1075  			},
  1076  			BundleServiceFn: func() *automock.BundleService {
  1077  				return &automock.BundleService{}
  1078  			},
  1079  			ConverterFn: func() *automock.Converter {
  1080  				return &automock.Converter{}
  1081  			},
  1082  			BundleConverterFn: func() *pkgmock.BundleConverter {
  1083  				return &pkgmock.BundleConverter{}
  1084  			},
  1085  			ExpectedResult: nil,
  1086  			ExpectedErr:    testErr,
  1087  		},
  1088  		{
  1089  			Name:            "Error - Transaction Commit",
  1090  			TransactionerFn: txGen.ThatFailsOnCommit,
  1091  			ServiceFn: func() *automock.Service {
  1092  				svc := &automock.Service{}
  1093  				svc.On("Get", txtest.CtxWithDBMatcher(), id).Return(modelInstanceAuth, nil).Once()
  1094  				svc.On("RequestDeletion", txtest.CtxWithDBMatcher(), modelInstanceAuth, modelBndl.DefaultInstanceAuth).Return(true, nil).Once()
  1095  				return svc
  1096  			},
  1097  			BundleServiceFn: func() *automock.BundleService {
  1098  				svc := &automock.BundleService{}
  1099  				svc.On("Get", txtest.CtxWithDBMatcher(), testBundleID).Return(modelBndl, nil).Once()
  1100  				return svc
  1101  			},
  1102  			ConverterFn: func() *automock.Converter {
  1103  				return &automock.Converter{}
  1104  			},
  1105  			BundleConverterFn: func() *pkgmock.BundleConverter {
  1106  				return &pkgmock.BundleConverter{}
  1107  			},
  1108  			ExpectedResult: nil,
  1109  			ExpectedErr:    testErr,
  1110  		},
  1111  	}
  1112  
  1113  	for _, testCase := range testCases {
  1114  		t.Run(testCase.Name, func(t *testing.T) {
  1115  			// GIVEN
  1116  			persist, transact := testCase.TransactionerFn()
  1117  			svc := testCase.ServiceFn()
  1118  			bundleSvc := testCase.BundleServiceFn()
  1119  			converter := testCase.ConverterFn()
  1120  			bndlConverter := testCase.BundleConverterFn()
  1121  
  1122  			resolver := bundleinstanceauth.NewResolver(transact, svc, bundleSvc, converter, bndlConverter)
  1123  
  1124  			// WHEN
  1125  			result, err := resolver.RequestBundleInstanceAuthDeletion(context.TODO(), id)
  1126  
  1127  			// THEN
  1128  			assert.Equal(t, testCase.ExpectedResult, result)
  1129  			assert.Equal(t, testCase.ExpectedErr, err)
  1130  
  1131  			mock.AssertExpectationsForObjects(t, svc, converter, transact, persist, bundleSvc)
  1132  		})
  1133  	}
  1134  }