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

     1  package systemssync_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  	"time"
     7  
     8  	"github.com/stretchr/testify/mock"
     9  
    10  	"github.com/kyma-incubator/compass/components/director/internal/domain/systemssync"
    11  	"github.com/kyma-incubator/compass/components/director/internal/domain/systemssync/automock"
    12  	"github.com/kyma-incubator/compass/components/director/internal/model"
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  )
    16  
    17  func TestService_List(t *testing.T) {
    18  	ctx := context.TODO()
    19  
    20  	syncTimestamps := []*model.SystemSynchronizationTimestamp{
    21  		fixSystemsSyncModel("id1", "tenant1", "pr", time.Now()),
    22  		fixSystemsSyncModel("id2", "tenant2", "PR", time.Now()),
    23  	}
    24  
    25  	testCases := []struct {
    26  		Name           string
    27  		RepositoryFn   func() *automock.SystemsSyncRepository
    28  		ExpectedResult []*model.SystemSynchronizationTimestamp
    29  		ExpectedErr    error
    30  	}{
    31  		{
    32  			Name: "Success",
    33  			RepositoryFn: func() *automock.SystemsSyncRepository {
    34  				repo := &automock.SystemsSyncRepository{}
    35  				repo.On("List", ctx).Return(syncTimestamps, nil).Once()
    36  				return repo
    37  			},
    38  			ExpectedResult: syncTimestamps,
    39  			ExpectedErr:    nil,
    40  		},
    41  		{
    42  			Name: "Error when listing systems sync timestamps",
    43  			RepositoryFn: func() *automock.SystemsSyncRepository {
    44  				repo := &automock.SystemsSyncRepository{}
    45  				repo.On("List", ctx).Return(nil, testError).Once()
    46  				return repo
    47  			},
    48  			ExpectedResult: nil,
    49  			ExpectedErr:    testError,
    50  		},
    51  	}
    52  
    53  	for _, testCase := range testCases {
    54  		t.Run(testCase.Name, func(t *testing.T) {
    55  			repo := testCase.RepositoryFn()
    56  
    57  			svc := systemssync.NewService(repo)
    58  
    59  			// WHEN
    60  			result, err := svc.List(ctx)
    61  
    62  			// THEN
    63  			if testCase.ExpectedErr != nil {
    64  				require.Error(t, err)
    65  				assert.Contains(t, err.Error(), testCase.ExpectedErr.Error())
    66  			} else {
    67  				require.NoError(t, err)
    68  				assert.Equal(t, testCase.ExpectedResult, result)
    69  			}
    70  
    71  			repo.AssertExpectations(t)
    72  		})
    73  	}
    74  }
    75  
    76  func TestService_Upsert(t *testing.T) {
    77  	ctx := context.TODO()
    78  	syncTimestamp := fixSystemsSyncModel("id1", "tenant1", "pr", time.Now())
    79  
    80  	testCases := []struct {
    81  		Name           string
    82  		RepositoryFn   func() *automock.SystemsSyncRepository
    83  		GetInput       func() *model.SystemSynchronizationTimestamp
    84  		ExpectedResult []*model.SystemSynchronizationTimestamp
    85  		ExpectedErr    error
    86  	}{
    87  		{
    88  			Name: "Success",
    89  			RepositoryFn: func() *automock.SystemsSyncRepository {
    90  				repo := &automock.SystemsSyncRepository{}
    91  				repo.On("Upsert", ctx, mock.Anything).Return(nil).Once()
    92  				return repo
    93  			},
    94  			GetInput: func() *model.SystemSynchronizationTimestamp {
    95  				return syncTimestamp
    96  			},
    97  			ExpectedResult: nil,
    98  			ExpectedErr:    nil,
    99  		},
   100  		{
   101  			Name: "Error when upserting systems sync timestamps",
   102  			RepositoryFn: func() *automock.SystemsSyncRepository {
   103  				repo := &automock.SystemsSyncRepository{}
   104  				repo.On("Upsert", ctx, mock.Anything).Return(testError).Once()
   105  				return repo
   106  			},
   107  			GetInput: func() *model.SystemSynchronizationTimestamp {
   108  				return syncTimestamp
   109  			},
   110  			ExpectedResult: nil,
   111  			ExpectedErr:    testError,
   112  		},
   113  	}
   114  
   115  	for _, testCase := range testCases {
   116  		t.Run(testCase.Name, func(t *testing.T) {
   117  			repo := testCase.RepositoryFn()
   118  
   119  			svc := systemssync.NewService(repo)
   120  
   121  			// WHEN
   122  			err := svc.Upsert(ctx, testCase.GetInput())
   123  
   124  			// THEN
   125  			if testCase.ExpectedErr != nil {
   126  				require.Error(t, err)
   127  				assert.Contains(t, err.Error(), testCase.ExpectedErr.Error())
   128  			} else {
   129  				require.NoError(t, err)
   130  			}
   131  
   132  			repo.AssertExpectations(t)
   133  		})
   134  	}
   135  }