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

     1  package certsubjectmapping_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/kyma-incubator/compass/components/director/internal/domain/certsubjectmapping"
     7  	"github.com/kyma-incubator/compass/components/director/internal/domain/certsubjectmapping/automock"
     8  	"github.com/kyma-incubator/compass/components/director/internal/model"
     9  	"github.com/kyma-incubator/compass/components/director/pkg/apperrors"
    10  	"github.com/kyma-incubator/compass/components/director/pkg/resource"
    11  	"github.com/stretchr/testify/mock"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestService_Create(t *testing.T) {
    16  	testCases := []struct {
    17  		Name           string
    18  		Input          *model.CertSubjectMapping
    19  		Repo           func() *automock.CertMappingRepository
    20  		ExpectedOutput string
    21  		ExpectedError  error
    22  	}{
    23  		{
    24  			Name:  "Success",
    25  			Input: CertSubjectMappingModel,
    26  			Repo: func() *automock.CertMappingRepository {
    27  				repo := &automock.CertMappingRepository{}
    28  				repo.On("Create", emptyCtx, CertSubjectMappingModel).Return(nil).Once()
    29  				return repo
    30  			},
    31  			ExpectedOutput: TestID,
    32  		},
    33  		{
    34  			Name:  "Error when creating certificate subject mapping",
    35  			Input: CertSubjectMappingModel,
    36  			Repo: func() *automock.CertMappingRepository {
    37  				repo := &automock.CertMappingRepository{}
    38  				repo.On("Create", emptyCtx, CertSubjectMappingModel).Return(testErr).Once()
    39  				return repo
    40  			},
    41  			ExpectedOutput: "",
    42  			ExpectedError:  testErr,
    43  		},
    44  	}
    45  
    46  	for _, testCase := range testCases {
    47  		t.Run(testCase.Name, func(t *testing.T) {
    48  			repo := testCase.Repo()
    49  
    50  			svc := certsubjectmapping.NewService(repo)
    51  
    52  			// WHEN
    53  			result, err := svc.Create(emptyCtx, testCase.Input)
    54  
    55  			// THEN
    56  			if testCase.ExpectedError != nil {
    57  				require.Error(t, err)
    58  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
    59  			} else {
    60  				require.NoError(t, err)
    61  			}
    62  
    63  			require.Equal(t, testCase.ExpectedOutput, result)
    64  
    65  			mock.AssertExpectationsForObjects(t, repo)
    66  		})
    67  	}
    68  }
    69  
    70  func TestService_Get(t *testing.T) {
    71  	testCases := []struct {
    72  		Name           string
    73  		Repo           func() *automock.CertMappingRepository
    74  		ExpectedOutput *model.CertSubjectMapping
    75  		ExpectedError  error
    76  	}{
    77  		{
    78  			Name: "Success",
    79  			Repo: func() *automock.CertMappingRepository {
    80  				repo := &automock.CertMappingRepository{}
    81  				repo.On("Get", emptyCtx, TestID).Return(CertSubjectMappingModel, nil).Once()
    82  				return repo
    83  			},
    84  			ExpectedOutput: CertSubjectMappingModel,
    85  		},
    86  		{
    87  			Name: "Error when getting certificate subject mapping",
    88  			Repo: func() *automock.CertMappingRepository {
    89  				repo := &automock.CertMappingRepository{}
    90  				repo.On("Get", emptyCtx, TestID).Return(nil, testErr).Once()
    91  				return repo
    92  			},
    93  			ExpectedOutput: nil,
    94  			ExpectedError:  testErr,
    95  		},
    96  	}
    97  
    98  	for _, testCase := range testCases {
    99  		t.Run(testCase.Name, func(t *testing.T) {
   100  			repo := testCase.Repo()
   101  
   102  			svc := certsubjectmapping.NewService(repo)
   103  
   104  			// WHEN
   105  			result, err := svc.Get(emptyCtx, TestID)
   106  
   107  			// THEN
   108  			if testCase.ExpectedError != nil {
   109  				require.Error(t, err)
   110  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   111  			} else {
   112  				require.NoError(t, err)
   113  			}
   114  
   115  			require.Equal(t, testCase.ExpectedOutput, result)
   116  
   117  			mock.AssertExpectationsForObjects(t, repo)
   118  		})
   119  	}
   120  }
   121  
   122  func TestService_Update(t *testing.T) {
   123  	notFoundErr := apperrors.NewNotFoundError(resource.CertSubjectMapping, TestID)
   124  
   125  	testCases := []struct {
   126  		Name          string
   127  		Input         *model.CertSubjectMapping
   128  		Repo          func() *automock.CertMappingRepository
   129  		ExpectedError error
   130  	}{
   131  		{
   132  			Name:  "Success",
   133  			Input: CertSubjectMappingModel,
   134  			Repo: func() *automock.CertMappingRepository {
   135  				repo := &automock.CertMappingRepository{}
   136  				repo.On("Exists", emptyCtx, TestID).Return(true, nil).Once()
   137  				repo.On("Update", emptyCtx, CertSubjectMappingModel).Return(nil).Once()
   138  				return repo
   139  			},
   140  		},
   141  		{
   142  			Name:  "Error when checking for certificate subject mapping existence fails",
   143  			Input: CertSubjectMappingModel,
   144  			Repo: func() *automock.CertMappingRepository {
   145  				repo := &automock.CertMappingRepository{}
   146  				repo.On("Exists", emptyCtx, TestID).Return(false, testErr).Once()
   147  				return repo
   148  			},
   149  			ExpectedError: testErr,
   150  		},
   151  		{
   152  			Name:  "Error when the updated certificate subject mapping is not found",
   153  			Input: CertSubjectMappingModel,
   154  			Repo: func() *automock.CertMappingRepository {
   155  				repo := &automock.CertMappingRepository{}
   156  				repo.On("Exists", emptyCtx, TestID).Return(false, nil).Once()
   157  				return repo
   158  			},
   159  			ExpectedError: notFoundErr,
   160  		},
   161  		{
   162  			Name:  "Error when updating certificate subject mapping fails",
   163  			Input: CertSubjectMappingModel,
   164  			Repo: func() *automock.CertMappingRepository {
   165  				repo := &automock.CertMappingRepository{}
   166  				repo.On("Exists", emptyCtx, TestID).Return(true, nil).Once()
   167  				repo.On("Update", emptyCtx, CertSubjectMappingModel).Return(testErr).Once()
   168  				return repo
   169  			},
   170  			ExpectedError: testErr,
   171  		},
   172  	}
   173  
   174  	for _, testCase := range testCases {
   175  		t.Run(testCase.Name, func(t *testing.T) {
   176  			repo := testCase.Repo()
   177  
   178  			svc := certsubjectmapping.NewService(repo)
   179  
   180  			// WHEN
   181  			err := svc.Update(emptyCtx, testCase.Input)
   182  
   183  			// THEN
   184  			if testCase.ExpectedError != nil {
   185  				require.Error(t, err)
   186  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   187  			} else {
   188  				require.NoError(t, err)
   189  			}
   190  
   191  			mock.AssertExpectationsForObjects(t, repo)
   192  		})
   193  	}
   194  }
   195  
   196  func TestService_Delete(t *testing.T) {
   197  	testCases := []struct {
   198  		Name          string
   199  		Repo          func() *automock.CertMappingRepository
   200  		ExpectedError error
   201  	}{
   202  		{
   203  			Name: "Success",
   204  			Repo: func() *automock.CertMappingRepository {
   205  				repo := &automock.CertMappingRepository{}
   206  				repo.On("Delete", emptyCtx, TestID).Return(nil).Once()
   207  				return repo
   208  			},
   209  		},
   210  		{
   211  			Name: "Error when deleting certificate subject mapping",
   212  			Repo: func() *automock.CertMappingRepository {
   213  				repo := &automock.CertMappingRepository{}
   214  				repo.On("Delete", emptyCtx, TestID).Return(testErr).Once()
   215  				return repo
   216  			},
   217  			ExpectedError: testErr,
   218  		},
   219  	}
   220  
   221  	for _, testCase := range testCases {
   222  		t.Run(testCase.Name, func(t *testing.T) {
   223  			repo := testCase.Repo()
   224  
   225  			svc := certsubjectmapping.NewService(repo)
   226  
   227  			// WHEN
   228  			err := svc.Delete(emptyCtx, TestID)
   229  
   230  			// THEN
   231  			if testCase.ExpectedError != nil {
   232  				require.Error(t, err)
   233  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   234  			} else {
   235  				require.NoError(t, err)
   236  			}
   237  
   238  			mock.AssertExpectationsForObjects(t, repo)
   239  		})
   240  	}
   241  }
   242  
   243  func TestService_Exists(t *testing.T) {
   244  	testCases := []struct {
   245  		Name           string
   246  		Repo           func() *automock.CertMappingRepository
   247  		ExpectedOutput bool
   248  		ExpectedError  error
   249  	}{
   250  		{
   251  			Name: "Success",
   252  			Repo: func() *automock.CertMappingRepository {
   253  				repo := &automock.CertMappingRepository{}
   254  				repo.On("Exists", emptyCtx, TestID).Return(true, nil).Once()
   255  				return repo
   256  			},
   257  			ExpectedOutput: true,
   258  		},
   259  		{
   260  			Name: "Error when checking for existence of certificate subject mapping fails",
   261  			Repo: func() *automock.CertMappingRepository {
   262  				repo := &automock.CertMappingRepository{}
   263  				repo.On("Exists", emptyCtx, TestID).Return(false, testErr).Once()
   264  				return repo
   265  			},
   266  			ExpectedOutput: false,
   267  			ExpectedError:  testErr,
   268  		},
   269  	}
   270  
   271  	for _, testCase := range testCases {
   272  		t.Run(testCase.Name, func(t *testing.T) {
   273  			repo := testCase.Repo()
   274  
   275  			svc := certsubjectmapping.NewService(repo)
   276  
   277  			// WHEN
   278  			result, err := svc.Exists(emptyCtx, TestID)
   279  
   280  			// THEN
   281  			if testCase.ExpectedError != nil {
   282  				require.Error(t, err)
   283  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   284  			} else {
   285  				require.NoError(t, err)
   286  			}
   287  
   288  			require.Equal(t, testCase.ExpectedOutput, result)
   289  
   290  			mock.AssertExpectationsForObjects(t, repo)
   291  		})
   292  	}
   293  }
   294  
   295  func TestService_List(t *testing.T) {
   296  	pageSize := 100
   297  	invalidPageSize := -100
   298  
   299  	certSubjectMappingPage := &model.CertSubjectMappingPage{
   300  		Data:       []*model.CertSubjectMapping{CertSubjectMappingModel},
   301  		PageInfo:   nil,
   302  		TotalCount: 1,
   303  	}
   304  
   305  	invalidDataErr := apperrors.NewInvalidDataError("page size must be between 1 and 300")
   306  
   307  	testCases := []struct {
   308  		Name           string
   309  		Repo           func() *automock.CertMappingRepository
   310  		PageSize       int
   311  		ExpectedOutput *model.CertSubjectMappingPage
   312  		ExpectedError  error
   313  	}{
   314  		{
   315  			Name: "Success",
   316  			Repo: func() *automock.CertMappingRepository {
   317  				repo := &automock.CertMappingRepository{}
   318  				repo.On("List", emptyCtx, pageSize, "").Return(certSubjectMappingPage, nil).Once()
   319  				return repo
   320  			},
   321  			PageSize:       pageSize,
   322  			ExpectedOutput: certSubjectMappingPage,
   323  		},
   324  		{
   325  			Name:           "Error when page size is incorrect",
   326  			Repo:           fixUnusedCertSubjectMappingRepository,
   327  			PageSize:       invalidPageSize,
   328  			ExpectedOutput: nil,
   329  			ExpectedError:  invalidDataErr,
   330  		},
   331  		{
   332  			Name: "Error when listing certificate subject mappings fail",
   333  			Repo: func() *automock.CertMappingRepository {
   334  				repo := &automock.CertMappingRepository{}
   335  				repo.On("List", emptyCtx, pageSize, "").Return(nil, testErr).Once()
   336  				return repo
   337  			},
   338  			PageSize:       pageSize,
   339  			ExpectedOutput: nil,
   340  			ExpectedError:  testErr,
   341  		},
   342  	}
   343  
   344  	for _, testCase := range testCases {
   345  		t.Run(testCase.Name, func(t *testing.T) {
   346  			repo := testCase.Repo()
   347  
   348  			svc := certsubjectmapping.NewService(repo)
   349  
   350  			// WHEN
   351  			result, err := svc.List(emptyCtx, testCase.PageSize, "")
   352  
   353  			// THEN
   354  			if testCase.ExpectedError != nil {
   355  				require.Error(t, err)
   356  				require.Contains(t, err.Error(), testCase.ExpectedError.Error())
   357  			} else {
   358  				require.NoError(t, err)
   359  			}
   360  
   361  			require.Equal(t, testCase.ExpectedOutput, result)
   362  
   363  			mock.AssertExpectationsForObjects(t, repo)
   364  		})
   365  	}
   366  }