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

     1  package certsubjectmapping_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
     8  	"github.com/pkg/errors"
     9  	"github.com/stretchr/testify/mock"
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/kyma-incubator/compass/components/director/internal/domain/certsubjectmapping"
    13  	"github.com/kyma-incubator/compass/components/director/internal/domain/certsubjectmapping/automock"
    14  	persistenceautomock "github.com/kyma-incubator/compass/components/director/pkg/persistence/automock"
    15  	"github.com/kyma-incubator/compass/components/director/pkg/persistence/txtest"
    16  )
    17  
    18  var (
    19  	emptyCtx        = context.Background()
    20  	txGen           = txtest.NewTransactionContextGenerator(testErr)
    21  	testErr         = errors.New("test error")
    22  	invalidInputErr = errors.New("subject: cannot be blank")
    23  )
    24  
    25  func TestResolver_CertificateSubjectMapping(t *testing.T) {
    26  	testCases := []struct {
    27  		Name                    string
    28  		TransactionerFn         func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
    29  		ConverterFn             func() *automock.Converter
    30  		CertSubjectMappingSvcFn func() *automock.CertSubjectMappingService
    31  		ExpectedOutput          *graphql.CertificateSubjectMapping
    32  		ExpectedError           error
    33  	}{
    34  		{
    35  			Name:            "Success",
    36  			TransactionerFn: txGen.ThatSucceeds,
    37  			ConverterFn: func() *automock.Converter {
    38  				conv := &automock.Converter{}
    39  				conv.On("ToGraphQL", CertSubjectMappingModel).Return(CertSubjectMappingGQLModel).Once()
    40  				return conv
    41  			},
    42  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
    43  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
    44  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
    45  				return certSubjectMappingSvc
    46  			},
    47  			ExpectedOutput: CertSubjectMappingGQLModel,
    48  		},
    49  		{
    50  			Name:            "Error when transaction fails to begin",
    51  			TransactionerFn: txGen.ThatFailsOnBegin,
    52  			ExpectedOutput:  nil,
    53  			ExpectedError:   testErr,
    54  		},
    55  		{
    56  			Name:            "Error when getting certificate subject mapping fails",
    57  			TransactionerFn: txGen.ThatDoesntExpectCommit,
    58  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
    59  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
    60  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(nil, testErr).Once()
    61  				return certSubjectMappingSvc
    62  			},
    63  			ExpectedOutput: nil,
    64  			ExpectedError:  testErr,
    65  		},
    66  		{
    67  			Name:            "Error when committing the transaction fails",
    68  			TransactionerFn: txGen.ThatFailsOnCommit,
    69  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
    70  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
    71  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
    72  				return certSubjectMappingSvc
    73  			},
    74  			ExpectedOutput: nil,
    75  			ExpectedError:  testErr,
    76  		},
    77  	}
    78  
    79  	for _, testCase := range testCases {
    80  		t.Run(testCase.Name, func(t *testing.T) {
    81  			// GIVEN
    82  			persist, transact := fixUnusedTransactioner()
    83  			if testCase.TransactionerFn != nil {
    84  				persist, transact = testCase.TransactionerFn()
    85  			}
    86  
    87  			conv := fixUnusedConverter()
    88  			if testCase.ConverterFn != nil {
    89  				conv = testCase.ConverterFn()
    90  			}
    91  
    92  			certSubjectMappingSvc := fixUnusedCertSubjectMappingSvc()
    93  			if testCase.CertSubjectMappingSvcFn != nil {
    94  				certSubjectMappingSvc = testCase.CertSubjectMappingSvcFn()
    95  			}
    96  
    97  			uidSvc := fixUnusedUIDService()
    98  
    99  			defer mock.AssertExpectationsForObjects(t, persist, transact, conv, certSubjectMappingSvc, uidSvc)
   100  
   101  			resolver := certsubjectmapping.NewResolver(transact, conv, certSubjectMappingSvc, uidSvc)
   102  
   103  			// WHEN
   104  			result, err := resolver.CertificateSubjectMapping(emptyCtx, TestID)
   105  
   106  			// THEN
   107  			if testCase.ExpectedError != nil {
   108  				require.Error(t, err)
   109  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   110  			} else {
   111  				require.NoError(t, err)
   112  			}
   113  
   114  			require.Equal(t, testCase.ExpectedOutput, result)
   115  		})
   116  	}
   117  }
   118  
   119  func TestResolver_CertificateSubjectMappings(t *testing.T) {
   120  	first := 2
   121  	after := "testAfter"
   122  	gqlAfter := graphql.PageCursor(after)
   123  
   124  	testCases := []struct {
   125  		Name                    string
   126  		TransactionerFn         func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   127  		ConverterFn             func() *automock.Converter
   128  		CertSubjectMappingSvcFn func() *automock.CertSubjectMappingService
   129  		First                   *int
   130  		ExpectedOutput          *graphql.CertificateSubjectMappingPage
   131  		ExpectedErrorMsg        string
   132  	}{
   133  		{
   134  			Name:            "Success",
   135  			TransactionerFn: txGen.ThatSucceeds,
   136  			ConverterFn: func() *automock.Converter {
   137  				conv := &automock.Converter{}
   138  				conv.On("MultipleToGraphQL", CertificateSubjectMappingModelPage.Data).Return(CertificateSubjectMappingsGQL).Once()
   139  				return conv
   140  			},
   141  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   142  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   143  				certSubjectMappingSvc.On("List", txtest.CtxWithDBMatcher(), first, after).Return(CertificateSubjectMappingModelPage, nil).Once()
   144  				return certSubjectMappingSvc
   145  			},
   146  			First:          &first,
   147  			ExpectedOutput: CertificateSubjectMappingGQLPage,
   148  		},
   149  		{
   150  			Name:             "Error when missing first parameter",
   151  			ExpectedOutput:   nil,
   152  			ExpectedErrorMsg: "Invalid data [reason=missing required parameter 'first']",
   153  		},
   154  		{
   155  			Name:             "Error when transaction fails to begin",
   156  			TransactionerFn:  txGen.ThatFailsOnBegin,
   157  			First:            &first,
   158  			ExpectedOutput:   nil,
   159  			ExpectedErrorMsg: testErr.Error(),
   160  		},
   161  		{
   162  			Name:            "Error when getting certificate subject mapping fails",
   163  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   164  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   165  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   166  				certSubjectMappingSvc.On("List", txtest.CtxWithDBMatcher(), first, after).Return(nil, testErr).Once()
   167  				return certSubjectMappingSvc
   168  			},
   169  			First:            &first,
   170  			ExpectedOutput:   nil,
   171  			ExpectedErrorMsg: testErr.Error(),
   172  		},
   173  		{
   174  			Name:            "Error when committing the transaction fails",
   175  			TransactionerFn: txGen.ThatFailsOnCommit,
   176  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   177  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   178  				certSubjectMappingSvc.On("List", txtest.CtxWithDBMatcher(), first, after).Return(CertificateSubjectMappingModelPage, nil).Once()
   179  				return certSubjectMappingSvc
   180  			},
   181  			First:            &first,
   182  			ExpectedOutput:   nil,
   183  			ExpectedErrorMsg: testErr.Error(),
   184  		},
   185  	}
   186  
   187  	for _, testCase := range testCases {
   188  		t.Run(testCase.Name, func(t *testing.T) {
   189  			// GIVEN
   190  			persist, transact := fixUnusedTransactioner()
   191  			if testCase.TransactionerFn != nil {
   192  				persist, transact = testCase.TransactionerFn()
   193  			}
   194  
   195  			conv := fixUnusedConverter()
   196  			if testCase.ConverterFn != nil {
   197  				conv = testCase.ConverterFn()
   198  			}
   199  
   200  			certSubjectMappingSvc := fixUnusedCertSubjectMappingSvc()
   201  			if testCase.CertSubjectMappingSvcFn != nil {
   202  				certSubjectMappingSvc = testCase.CertSubjectMappingSvcFn()
   203  			}
   204  
   205  			uidSvc := fixUnusedUIDService()
   206  
   207  			defer mock.AssertExpectationsForObjects(t, persist, transact, conv, certSubjectMappingSvc, uidSvc)
   208  
   209  			resolver := certsubjectmapping.NewResolver(transact, conv, certSubjectMappingSvc, uidSvc)
   210  
   211  			// WHEN
   212  			result, err := resolver.CertificateSubjectMappings(emptyCtx, testCase.First, &gqlAfter)
   213  
   214  			// THEN
   215  			if testCase.ExpectedErrorMsg != "" {
   216  				require.Error(t, err)
   217  				require.Contains(t, err.Error(), testCase.ExpectedErrorMsg)
   218  			} else {
   219  				require.NoError(t, err)
   220  			}
   221  
   222  			require.Equal(t, testCase.ExpectedOutput, result)
   223  		})
   224  	}
   225  }
   226  
   227  func TestResolver_CreateCertificateSubjectMapping(t *testing.T) {
   228  	testCases := []struct {
   229  		Name                    string
   230  		Input                   graphql.CertificateSubjectMappingInput
   231  		TransactionerFn         func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   232  		ConverterFn             func() *automock.Converter
   233  		CertSubjectMappingSvcFn func() *automock.CertSubjectMappingService
   234  		UIDSvcFn                func() *automock.UIDService
   235  		ExpectedOutput          *graphql.CertificateSubjectMapping
   236  		ExpectedError           error
   237  	}{
   238  		{
   239  			Name:            "Success",
   240  			Input:           CertSubjectMappingGQLModelInput,
   241  			TransactionerFn: txGen.ThatSucceeds,
   242  			ConverterFn: func() *automock.Converter {
   243  				conv := &automock.Converter{}
   244  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   245  				conv.On("ToGraphQL", CertSubjectMappingModel).Return(CertSubjectMappingGQLModel).Once()
   246  				return conv
   247  			},
   248  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   249  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   250  				certSubjectMappingSvc.On("Create", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return(TestID, nil).Once()
   251  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
   252  				return certSubjectMappingSvc
   253  			},
   254  			UIDSvcFn: func() *automock.UIDService {
   255  				uidSvc := &automock.UIDService{}
   256  				uidSvc.On("Generate").Return(TestID).Once()
   257  				return uidSvc
   258  			},
   259  			ExpectedOutput: CertSubjectMappingGQLModel,
   260  		},
   261  		{
   262  			Name:            "Error when transaction fails to begin",
   263  			TransactionerFn: txGen.ThatFailsOnBegin,
   264  			ExpectedOutput:  nil,
   265  			ExpectedError:   testErr,
   266  		},
   267  		{
   268  			Name:            "Error when certificate subject mapping input validation fails",
   269  			Input:           CertSubjectMappingGQLInvalidInput,
   270  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   271  			ExpectedOutput:  nil,
   272  			ExpectedError:   invalidInputErr,
   273  		},
   274  		{
   275  			Name:            "Error when creating certificate subject mapping fails",
   276  			Input:           CertSubjectMappingGQLModelInput,
   277  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   278  			ConverterFn: func() *automock.Converter {
   279  				conv := &automock.Converter{}
   280  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   281  				return conv
   282  			},
   283  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   284  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   285  				certSubjectMappingSvc.On("Create", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return("", testErr).Once()
   286  				return certSubjectMappingSvc
   287  			},
   288  			UIDSvcFn: func() *automock.UIDService {
   289  				uidSvc := &automock.UIDService{}
   290  				uidSvc.On("Generate").Return(TestID).Once()
   291  				return uidSvc
   292  			},
   293  			ExpectedOutput: nil,
   294  			ExpectedError:  testErr,
   295  		},
   296  		{
   297  			Name:            "Error when getting certificate subject mapping fails",
   298  			Input:           CertSubjectMappingGQLModelInput,
   299  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   300  			ConverterFn: func() *automock.Converter {
   301  				conv := &automock.Converter{}
   302  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   303  				return conv
   304  			},
   305  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   306  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   307  				certSubjectMappingSvc.On("Create", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return(TestID, nil).Once()
   308  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(nil, testErr).Once()
   309  				return certSubjectMappingSvc
   310  			},
   311  			UIDSvcFn: func() *automock.UIDService {
   312  				uidSvc := &automock.UIDService{}
   313  				uidSvc.On("Generate").Return(TestID).Once()
   314  				return uidSvc
   315  			},
   316  			ExpectedOutput: nil,
   317  			ExpectedError:  testErr,
   318  		},
   319  		{
   320  			Name:            "Error when committing the transaction fails",
   321  			Input:           CertSubjectMappingGQLModelInput,
   322  			TransactionerFn: txGen.ThatFailsOnCommit,
   323  			ConverterFn: func() *automock.Converter {
   324  				conv := &automock.Converter{}
   325  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   326  				return conv
   327  			},
   328  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   329  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   330  				certSubjectMappingSvc.On("Create", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return(TestID, nil).Once()
   331  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
   332  				return certSubjectMappingSvc
   333  			},
   334  			UIDSvcFn: func() *automock.UIDService {
   335  				uidSvc := &automock.UIDService{}
   336  				uidSvc.On("Generate").Return(TestID).Once()
   337  				return uidSvc
   338  			},
   339  			ExpectedOutput: nil,
   340  			ExpectedError:  testErr,
   341  		},
   342  	}
   343  
   344  	for _, testCase := range testCases {
   345  		t.Run(testCase.Name, func(t *testing.T) {
   346  			// GIVEN
   347  			persist, transact := fixUnusedTransactioner()
   348  			if testCase.TransactionerFn != nil {
   349  				persist, transact = testCase.TransactionerFn()
   350  			}
   351  
   352  			conv := fixUnusedConverter()
   353  			if testCase.ConverterFn != nil {
   354  				conv = testCase.ConverterFn()
   355  			}
   356  
   357  			certSubjectMappingSvc := fixUnusedCertSubjectMappingSvc()
   358  			if testCase.CertSubjectMappingSvcFn != nil {
   359  				certSubjectMappingSvc = testCase.CertSubjectMappingSvcFn()
   360  			}
   361  
   362  			uidSvc := fixUnusedUIDService()
   363  			if testCase.UIDSvcFn != nil {
   364  				uidSvc = testCase.UIDSvcFn()
   365  			}
   366  
   367  			defer mock.AssertExpectationsForObjects(t, persist, transact, conv, certSubjectMappingSvc, uidSvc)
   368  
   369  			resolver := certsubjectmapping.NewResolver(transact, conv, certSubjectMappingSvc, uidSvc)
   370  
   371  			// WHEN
   372  			result, err := resolver.CreateCertificateSubjectMapping(emptyCtx, testCase.Input)
   373  
   374  			// THEN
   375  			if testCase.ExpectedError != nil {
   376  				require.Error(t, err)
   377  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   378  			} else {
   379  				require.NoError(t, err)
   380  			}
   381  
   382  			require.Equal(t, testCase.ExpectedOutput, result)
   383  		})
   384  	}
   385  }
   386  
   387  func TestResolver_UpdateCertificateSubjectMapping(t *testing.T) {
   388  	testCases := []struct {
   389  		Name                    string
   390  		Input                   graphql.CertificateSubjectMappingInput
   391  		TransactionerFn         func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   392  		ConverterFn             func() *automock.Converter
   393  		CertSubjectMappingSvcFn func() *automock.CertSubjectMappingService
   394  		ExpectedOutput          *graphql.CertificateSubjectMapping
   395  		ExpectedError           error
   396  	}{
   397  		{
   398  			Name:            "Success",
   399  			Input:           CertSubjectMappingGQLModelInput,
   400  			TransactionerFn: txGen.ThatSucceeds,
   401  			ConverterFn: func() *automock.Converter {
   402  				conv := &automock.Converter{}
   403  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   404  				conv.On("ToGraphQL", CertSubjectMappingModel).Return(CertSubjectMappingGQLModel).Once()
   405  				return conv
   406  			},
   407  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   408  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   409  				certSubjectMappingSvc.On("Update", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return(nil).Once()
   410  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
   411  				return certSubjectMappingSvc
   412  			},
   413  			ExpectedOutput: CertSubjectMappingGQLModel,
   414  		},
   415  		{
   416  			Name:            "Error when transaction fails to begin",
   417  			TransactionerFn: txGen.ThatFailsOnBegin,
   418  			ExpectedOutput:  nil,
   419  			ExpectedError:   testErr,
   420  		},
   421  		{
   422  			Name:            "Error when certificate subject mapping input validation fails",
   423  			Input:           CertSubjectMappingGQLInvalidInput,
   424  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   425  			ExpectedOutput:  nil,
   426  			ExpectedError:   invalidInputErr,
   427  		},
   428  		{
   429  			Name:            "Error when updating certificate subject mapping fails",
   430  			Input:           CertSubjectMappingGQLModelInput,
   431  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   432  			ConverterFn: func() *automock.Converter {
   433  				conv := &automock.Converter{}
   434  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   435  				return conv
   436  			},
   437  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   438  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   439  				certSubjectMappingSvc.On("Update", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return(testErr).Once()
   440  				return certSubjectMappingSvc
   441  			},
   442  			ExpectedOutput: nil,
   443  			ExpectedError:  testErr,
   444  		},
   445  		{
   446  			Name:            "Error when getting certificate subject mapping fails",
   447  			Input:           CertSubjectMappingGQLModelInput,
   448  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   449  			ConverterFn: func() *automock.Converter {
   450  				conv := &automock.Converter{}
   451  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   452  				return conv
   453  			},
   454  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   455  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   456  				certSubjectMappingSvc.On("Update", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return(nil).Once()
   457  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(nil, testErr).Once()
   458  				return certSubjectMappingSvc
   459  			},
   460  			ExpectedOutput: nil,
   461  			ExpectedError:  testErr,
   462  		},
   463  		{
   464  			Name:            "Error when committing the transaction fails",
   465  			Input:           CertSubjectMappingGQLModelInput,
   466  			TransactionerFn: txGen.ThatFailsOnCommit,
   467  			ConverterFn: func() *automock.Converter {
   468  				conv := &automock.Converter{}
   469  				conv.On("FromGraphql", TestID, CertSubjectMappingGQLModelInput).Return(CertSubjectMappingModel).Once()
   470  				return conv
   471  			},
   472  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   473  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   474  				certSubjectMappingSvc.On("Update", txtest.CtxWithDBMatcher(), CertSubjectMappingModel).Return(nil).Once()
   475  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
   476  				return certSubjectMappingSvc
   477  			},
   478  			ExpectedOutput: nil,
   479  			ExpectedError:  testErr,
   480  		},
   481  	}
   482  
   483  	for _, testCase := range testCases {
   484  		t.Run(testCase.Name, func(t *testing.T) {
   485  			// GIVEN
   486  			persist, transact := fixUnusedTransactioner()
   487  			if testCase.TransactionerFn != nil {
   488  				persist, transact = testCase.TransactionerFn()
   489  			}
   490  
   491  			conv := fixUnusedConverter()
   492  			if testCase.ConverterFn != nil {
   493  				conv = testCase.ConverterFn()
   494  			}
   495  
   496  			certSubjectMappingSvc := fixUnusedCertSubjectMappingSvc()
   497  			if testCase.CertSubjectMappingSvcFn != nil {
   498  				certSubjectMappingSvc = testCase.CertSubjectMappingSvcFn()
   499  			}
   500  
   501  			uidSvc := fixUnusedUIDService()
   502  
   503  			defer mock.AssertExpectationsForObjects(t, persist, transact, conv, certSubjectMappingSvc, uidSvc)
   504  
   505  			resolver := certsubjectmapping.NewResolver(transact, conv, certSubjectMappingSvc, uidSvc)
   506  
   507  			// WHEN
   508  			result, err := resolver.UpdateCertificateSubjectMapping(emptyCtx, TestID, testCase.Input)
   509  
   510  			// THEN
   511  			if testCase.ExpectedError != nil {
   512  				require.Error(t, err)
   513  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   514  			} else {
   515  				require.NoError(t, err)
   516  			}
   517  
   518  			require.Equal(t, testCase.ExpectedOutput, result)
   519  		})
   520  	}
   521  }
   522  
   523  func TestResolver_DeleteCertificateSubjectMapping(t *testing.T) {
   524  	testCases := []struct {
   525  		Name                    string
   526  		TransactionerFn         func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   527  		ConverterFn             func() *automock.Converter
   528  		CertSubjectMappingSvcFn func() *automock.CertSubjectMappingService
   529  		ExpectedOutput          *graphql.CertificateSubjectMapping
   530  		ExpectedError           error
   531  	}{
   532  		{
   533  			Name:            "Success",
   534  			TransactionerFn: txGen.ThatSucceeds,
   535  			ConverterFn: func() *automock.Converter {
   536  				conv := &automock.Converter{}
   537  				conv.On("ToGraphQL", CertSubjectMappingModel).Return(CertSubjectMappingGQLModel).Once()
   538  				return conv
   539  			},
   540  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   541  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   542  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
   543  				certSubjectMappingSvc.On("Delete", txtest.CtxWithDBMatcher(), TestID).Return(nil).Once()
   544  				return certSubjectMappingSvc
   545  			},
   546  			ExpectedOutput: CertSubjectMappingGQLModel,
   547  		},
   548  		{
   549  			Name:            "Error when transaction fails to begin",
   550  			TransactionerFn: txGen.ThatFailsOnBegin,
   551  			ExpectedOutput:  nil,
   552  			ExpectedError:   testErr,
   553  		},
   554  		{
   555  			Name:            "Error when getting certificate subject mapping fails",
   556  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   557  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   558  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   559  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(nil, testErr).Once()
   560  				return certSubjectMappingSvc
   561  			},
   562  			ExpectedOutput: nil,
   563  			ExpectedError:  testErr,
   564  		},
   565  		{
   566  			Name:            "Error when deleting certificate subject mapping fails",
   567  			TransactionerFn: txGen.ThatDoesntExpectCommit,
   568  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   569  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   570  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
   571  				certSubjectMappingSvc.On("Delete", txtest.CtxWithDBMatcher(), TestID).Return(testErr).Once()
   572  				return certSubjectMappingSvc
   573  			},
   574  			ExpectedOutput: nil,
   575  			ExpectedError:  testErr,
   576  		},
   577  		{
   578  			Name:            "Error when committing the transaction fails",
   579  			TransactionerFn: txGen.ThatFailsOnCommit,
   580  			CertSubjectMappingSvcFn: func() *automock.CertSubjectMappingService {
   581  				certSubjectMappingSvc := &automock.CertSubjectMappingService{}
   582  				certSubjectMappingSvc.On("Get", txtest.CtxWithDBMatcher(), TestID).Return(CertSubjectMappingModel, nil).Once()
   583  				certSubjectMappingSvc.On("Delete", txtest.CtxWithDBMatcher(), TestID).Return(nil).Once()
   584  				return certSubjectMappingSvc
   585  			},
   586  			ExpectedOutput: nil,
   587  			ExpectedError:  testErr,
   588  		},
   589  	}
   590  
   591  	for _, testCase := range testCases {
   592  		t.Run(testCase.Name, func(t *testing.T) {
   593  			// GIVEN
   594  			persist, transact := fixUnusedTransactioner()
   595  			if testCase.TransactionerFn != nil {
   596  				persist, transact = testCase.TransactionerFn()
   597  			}
   598  
   599  			conv := fixUnusedConverter()
   600  			if testCase.ConverterFn != nil {
   601  				conv = testCase.ConverterFn()
   602  			}
   603  
   604  			certSubjectMappingSvc := fixUnusedCertSubjectMappingSvc()
   605  			if testCase.CertSubjectMappingSvcFn != nil {
   606  				certSubjectMappingSvc = testCase.CertSubjectMappingSvcFn()
   607  			}
   608  
   609  			uidSvc := fixUnusedUIDService()
   610  
   611  			defer mock.AssertExpectationsForObjects(t, persist, transact, conv, certSubjectMappingSvc, uidSvc)
   612  
   613  			resolver := certsubjectmapping.NewResolver(transact, conv, certSubjectMappingSvc, uidSvc)
   614  
   615  			// WHEN
   616  			result, err := resolver.DeleteCertificateSubjectMapping(emptyCtx, TestID)
   617  
   618  			// THEN
   619  			if testCase.ExpectedError != nil {
   620  				require.Error(t, err)
   621  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   622  			} else {
   623  				require.NoError(t, err)
   624  			}
   625  
   626  			require.Equal(t, testCase.ExpectedOutput, result)
   627  		})
   628  	}
   629  }