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

     1  package formationtemplateconstraintreferences_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/kyma-incubator/compass/components/director/internal/domain/formationtemplateconstraintreferences"
     8  	"github.com/kyma-incubator/compass/components/director/internal/domain/formationtemplateconstraintreferences/automock"
     9  	"github.com/kyma-incubator/compass/components/director/pkg/graphql"
    10  	persistenceautomock "github.com/kyma-incubator/compass/components/director/pkg/persistence/automock"
    11  	"github.com/kyma-incubator/compass/components/director/pkg/persistence/txtest"
    12  	"github.com/pkg/errors"
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/mock"
    15  	"github.com/stretchr/testify/require"
    16  )
    17  
    18  func TestResolver_AttachConstraintToFormationTemplate(t *testing.T) {
    19  	// GIVEN
    20  	ctx := context.TODO()
    21  
    22  	testErr := errors.New("test error")
    23  
    24  	txGen := txtest.NewTransactionContextGenerator(testErr)
    25  
    26  	testCases := []struct {
    27  		Name                         string
    28  		TxFn                         func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
    29  		ConstraintReferenceConverter func() *automock.ConstraintReferenceConverter
    30  		ConstraintReferenceService   func() *automock.ConstraintReferenceService
    31  		ExpectedOutput               *graphql.ConstraintReference
    32  		ExpectedErrorMsg             string
    33  	}{
    34  		{
    35  			Name: "Success",
    36  			TxFn: txGen.ThatSucceeds,
    37  			ConstraintReferenceService: func() *automock.ConstraintReferenceService {
    38  				svc := &automock.ConstraintReferenceService{}
    39  				svc.On("Create", txtest.CtxWithDBMatcher(), constraintReference).Return(nil)
    40  				return svc
    41  			},
    42  			ConstraintReferenceConverter: func() *automock.ConstraintReferenceConverter {
    43  				converter := &automock.ConstraintReferenceConverter{}
    44  				converter.On("ToModel", gqlConstraintReference).Return(constraintReference, nil)
    45  				return converter
    46  			},
    47  			ExpectedOutput:   gqlConstraintReference,
    48  			ExpectedErrorMsg: "",
    49  		},
    50  		{
    51  			Name: "Error wihle creating reference",
    52  			TxFn: txGen.ThatDoesntExpectCommit,
    53  			ConstraintReferenceService: func() *automock.ConstraintReferenceService {
    54  				svc := &automock.ConstraintReferenceService{}
    55  				svc.On("Create", txtest.CtxWithDBMatcher(), constraintReference).Return(testErr)
    56  				return svc
    57  			},
    58  			ConstraintReferenceConverter: func() *automock.ConstraintReferenceConverter {
    59  				converter := &automock.ConstraintReferenceConverter{}
    60  				converter.On("ToModel", gqlConstraintReference).Return(constraintReference, nil)
    61  				return converter
    62  			},
    63  			ExpectedErrorMsg: testErr.Error(),
    64  		},
    65  		{
    66  			Name: "Returns error when failing on the committing of a transaction",
    67  			TxFn: txGen.ThatFailsOnCommit,
    68  			ConstraintReferenceService: func() *automock.ConstraintReferenceService {
    69  				svc := &automock.ConstraintReferenceService{}
    70  				svc.On("Create", txtest.CtxWithDBMatcher(), constraintReference).Return(nil)
    71  				return svc
    72  			},
    73  			ConstraintReferenceConverter: func() *automock.ConstraintReferenceConverter {
    74  				converter := &automock.ConstraintReferenceConverter{}
    75  				converter.On("ToModel", gqlConstraintReference).Return(constraintReference, nil)
    76  				return converter
    77  			},
    78  			ExpectedErrorMsg: testErr.Error(),
    79  		},
    80  		{
    81  			Name:             "Returns error when failing on the beginning of a transaction",
    82  			TxFn:             txGen.ThatFailsOnBegin,
    83  			ExpectedErrorMsg: testErr.Error(),
    84  		},
    85  	}
    86  
    87  	for _, testCase := range testCases {
    88  		t.Run(testCase.Name, func(t *testing.T) {
    89  			persist, transact := testCase.TxFn()
    90  			constraintReferenceSvc := unusedConstraintReferenceService()
    91  			if testCase.ConstraintReferenceService != nil {
    92  				constraintReferenceSvc = testCase.ConstraintReferenceService()
    93  			}
    94  			constraintReferenceConverter := unusedConstraintReferenceConverter()
    95  			if testCase.ConstraintReferenceConverter != nil {
    96  				constraintReferenceConverter = testCase.ConstraintReferenceConverter()
    97  			}
    98  			resolver := formationtemplateconstraintreferences.NewResolver(transact, constraintReferenceConverter, constraintReferenceSvc)
    99  
   100  			// WHEN
   101  			result, err := resolver.AttachConstraintToFormationTemplate(ctx, constraintID, templateID)
   102  
   103  			// THEN
   104  			if testCase.ExpectedErrorMsg != "" {
   105  				require.Error(t, err)
   106  				assert.Contains(t, err.Error(), testCase.ExpectedErrorMsg)
   107  			} else {
   108  				assert.NoError(t, err)
   109  			}
   110  			assert.Equal(t, testCase.ExpectedOutput, result)
   111  
   112  			mock.AssertExpectationsForObjects(t, persist, constraintReferenceSvc, constraintReferenceConverter)
   113  		})
   114  	}
   115  }
   116  
   117  func TestResolver_DetachConstraintFromFormationTemplate(t *testing.T) {
   118  	// GIVEN
   119  	ctx := context.TODO()
   120  
   121  	testErr := errors.New("test error")
   122  
   123  	txGen := txtest.NewTransactionContextGenerator(testErr)
   124  
   125  	testCases := []struct {
   126  		Name                       string
   127  		TxFn                       func() (*persistenceautomock.PersistenceTx, *persistenceautomock.Transactioner)
   128  		ConstraintReferenceService func() *automock.ConstraintReferenceService
   129  		ExpectedOutput             *graphql.ConstraintReference
   130  		ExpectedErrorMsg           string
   131  	}{
   132  		{
   133  			Name: "Success",
   134  			TxFn: txGen.ThatSucceeds,
   135  			ConstraintReferenceService: func() *automock.ConstraintReferenceService {
   136  				svc := &automock.ConstraintReferenceService{}
   137  				svc.On("Delete", txtest.CtxWithDBMatcher(), constraintID, templateID).Return(nil)
   138  				return svc
   139  			},
   140  			ExpectedOutput:   gqlConstraintReference,
   141  			ExpectedErrorMsg: "",
   142  		},
   143  		{
   144  			Name: "Error when delete call in service fails",
   145  			TxFn: txGen.ThatDoesntExpectCommit,
   146  			ConstraintReferenceService: func() *automock.ConstraintReferenceService {
   147  				svc := &automock.ConstraintReferenceService{}
   148  				svc.On("Delete", txtest.CtxWithDBMatcher(), constraintID, templateID).Return(testErr)
   149  				return svc
   150  			},
   151  			ExpectedErrorMsg: testErr.Error(),
   152  		},
   153  		{
   154  			Name: "Returns error when failing on the committing of a transaction",
   155  			TxFn: txGen.ThatFailsOnCommit,
   156  			ConstraintReferenceService: func() *automock.ConstraintReferenceService {
   157  				svc := &automock.ConstraintReferenceService{}
   158  				svc.On("Delete", txtest.CtxWithDBMatcher(), constraintID, templateID).Return(nil)
   159  				return svc
   160  			},
   161  			ExpectedErrorMsg: testErr.Error(),
   162  		},
   163  		{
   164  			Name:             "Returns error when failing on the beginning of a transaction",
   165  			TxFn:             txGen.ThatFailsOnBegin,
   166  			ExpectedErrorMsg: testErr.Error(),
   167  		},
   168  	}
   169  
   170  	for _, testCase := range testCases {
   171  		t.Run(testCase.Name, func(t *testing.T) {
   172  			persist, transact := testCase.TxFn()
   173  			constraintReferenceSvc := unusedConstraintReferenceService()
   174  			if testCase.ConstraintReferenceService != nil {
   175  				constraintReferenceSvc = testCase.ConstraintReferenceService()
   176  			}
   177  			resolver := formationtemplateconstraintreferences.NewResolver(transact, nil, constraintReferenceSvc)
   178  
   179  			// WHEN
   180  			result, err := resolver.DetachConstraintFromFormationTemplate(ctx, constraintID, templateID)
   181  
   182  			// THEN
   183  			if testCase.ExpectedErrorMsg != "" {
   184  				require.Error(t, err)
   185  				assert.Contains(t, err.Error(), testCase.ExpectedErrorMsg)
   186  			} else {
   187  				assert.NoError(t, err)
   188  			}
   189  			assert.Equal(t, testCase.ExpectedOutput, result)
   190  
   191  			mock.AssertExpectationsForObjects(t, persist, constraintReferenceSvc)
   192  		})
   193  	}
   194  }