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

     1  package operation_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"github.com/kyma-incubator/compass/components/director/internal/domain/operation"
     8  	"github.com/kyma-incubator/compass/components/director/internal/domain/operation/automock"
     9  	"github.com/kyma-incubator/compass/components/director/internal/model"
    10  	"github.com/pkg/errors"
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/mock"
    13  	"github.com/stretchr/testify/require"
    14  )
    15  
    16  func TestService_Create(t *testing.T) {
    17  	// GIVEN
    18  	testErr := errors.New("Test error")
    19  
    20  	opInput := fixOperationInput(ordOpType, model.OperationStatusScheduled)
    21  	opModel := fixOperationModel(ordOpType, model.OperationStatusScheduled)
    22  	ctx := context.TODO()
    23  
    24  	testCases := []struct {
    25  		Name         string
    26  		RepositoryFn func() *automock.OperationRepository
    27  		UIDServiceFn func() *automock.UIDService
    28  		Input        model.OperationInput
    29  		ExpectedErr  error
    30  	}{
    31  		{
    32  			Name: "Success",
    33  			RepositoryFn: func() *automock.OperationRepository {
    34  				repo := &automock.OperationRepository{}
    35  				repo.On("Create", ctx, opModel).Return(nil).Once()
    36  				return repo
    37  			},
    38  			UIDServiceFn: func() *automock.UIDService {
    39  				svc := &automock.UIDService{}
    40  				svc.On("Generate").Return(operationID)
    41  				return svc
    42  			},
    43  			Input: *opInput,
    44  		},
    45  		{
    46  			Name: "Error - Operation creation",
    47  			RepositoryFn: func() *automock.OperationRepository {
    48  				repo := &automock.OperationRepository{}
    49  				repo.On("Create", ctx, opModel).Return(testErr).Once()
    50  				return repo
    51  			},
    52  			UIDServiceFn: func() *automock.UIDService {
    53  				svc := &automock.UIDService{}
    54  				svc.On("Generate").Return(operationID)
    55  				return svc
    56  			},
    57  			Input:       *opInput,
    58  			ExpectedErr: testErr,
    59  		},
    60  	}
    61  
    62  	for _, testCase := range testCases {
    63  		t.Run(testCase.Name, func(t *testing.T) {
    64  			// GIVEN
    65  			repo := testCase.RepositoryFn()
    66  			uidService := testCase.UIDServiceFn()
    67  
    68  			svc := operation.NewService(repo, uidService)
    69  
    70  			// WHEN
    71  			err := svc.Create(ctx, &testCase.Input)
    72  
    73  			// THEN
    74  			if testCase.ExpectedErr != nil {
    75  				require.Error(t, err)
    76  				assert.Contains(t, err.Error(), testCase.ExpectedErr.Error())
    77  			} else {
    78  				assert.Nil(t, err)
    79  			}
    80  
    81  			mock.AssertExpectationsForObjects(t, repo, uidService)
    82  		})
    83  	}
    84  }
    85  
    86  func TestService_CreateMultiple(t *testing.T) {
    87  	// GIVEN
    88  	testErr := errors.New("Test error")
    89  
    90  	opInput := fixOperationInput(ordOpType, model.OperationStatusScheduled)
    91  	opModel := fixOperationModel(ordOpType, model.OperationStatusScheduled)
    92  
    93  	ctx := context.TODO()
    94  
    95  	testCases := []struct {
    96  		Name         string
    97  		RepositoryFn func() *automock.OperationRepository
    98  		UIDServiceFn func() *automock.UIDService
    99  		Input        []*model.OperationInput
   100  		ExpectedErr  error
   101  	}{
   102  		{
   103  			Name: "Success",
   104  			RepositoryFn: func() *automock.OperationRepository {
   105  				repo := &automock.OperationRepository{}
   106  				repo.On("Create", ctx, opModel).Return(nil).Once()
   107  				return repo
   108  			},
   109  			UIDServiceFn: func() *automock.UIDService {
   110  				svc := &automock.UIDService{}
   111  				svc.On("Generate").Return(operationID)
   112  				return svc
   113  			},
   114  			Input: []*model.OperationInput{opInput},
   115  		},
   116  		{
   117  			Name: "Success - nil operation input",
   118  			RepositoryFn: func() *automock.OperationRepository {
   119  				repo := &automock.OperationRepository{}
   120  				repo.On("Create", ctx, opModel).Return(nil).Once()
   121  				return repo
   122  			},
   123  			UIDServiceFn: func() *automock.UIDService {
   124  				svc := &automock.UIDService{}
   125  				svc.On("Generate").Return(operationID)
   126  				return svc
   127  			},
   128  			Input: []*model.OperationInput{opInput, nil},
   129  		},
   130  		{
   131  			Name: "Nil operation inputs",
   132  			RepositoryFn: func() *automock.OperationRepository {
   133  				return &automock.OperationRepository{}
   134  			},
   135  			UIDServiceFn: func() *automock.UIDService {
   136  				return &automock.UIDService{}
   137  			},
   138  			Input: nil,
   139  		},
   140  		{
   141  			Name: "Error - Operation creation",
   142  			RepositoryFn: func() *automock.OperationRepository {
   143  				repo := &automock.OperationRepository{}
   144  				repo.On("Create", ctx, opModel).Return(testErr).Once()
   145  				return repo
   146  			},
   147  			UIDServiceFn: func() *automock.UIDService {
   148  				svc := &automock.UIDService{}
   149  				svc.On("Generate").Return(operationID)
   150  				return svc
   151  			},
   152  			Input:       []*model.OperationInput{opInput},
   153  			ExpectedErr: testErr,
   154  		},
   155  	}
   156  
   157  	for _, testCase := range testCases {
   158  		t.Run(testCase.Name, func(t *testing.T) {
   159  			// GIVEN
   160  			repo := testCase.RepositoryFn()
   161  			uidService := testCase.UIDServiceFn()
   162  
   163  			svc := operation.NewService(repo, uidService)
   164  
   165  			// WHEN
   166  			err := svc.CreateMultiple(ctx, testCase.Input)
   167  
   168  			// THEN
   169  			if testCase.ExpectedErr != nil {
   170  				require.Error(t, err)
   171  				assert.Contains(t, err.Error(), testCase.ExpectedErr.Error())
   172  			} else {
   173  				assert.Nil(t, err)
   174  			}
   175  
   176  			mock.AssertExpectationsForObjects(t, repo, uidService)
   177  		})
   178  	}
   179  }
   180  
   181  func TestService_DeleteOlderThan(t *testing.T) {
   182  	// GIVEN
   183  	testErr := errors.New("Test error")
   184  	ctx := context.TODO()
   185  
   186  	testCases := []struct {
   187  		Name         string
   188  		RepositoryFn func() *automock.OperationRepository
   189  		OpType       string
   190  		OpStatus     model.OperationStatus
   191  		Days         int
   192  		ExpectedErr  error
   193  	}{
   194  		{
   195  			Name: "Success",
   196  			RepositoryFn: func() *automock.OperationRepository {
   197  				repo := &automock.OperationRepository{}
   198  				repo.On("DeleteOlderThan", ctx, ordOpType, model.OperationStatusScheduled, mock.AnythingOfType("Time")).Return(nil).Once()
   199  				return repo
   200  			},
   201  			OpType:   ordOpType,
   202  			OpStatus: model.OperationStatusScheduled,
   203  			Days:     1,
   204  		},
   205  		{
   206  			Name: "Error while deleting operations",
   207  			RepositoryFn: func() *automock.OperationRepository {
   208  				repo := &automock.OperationRepository{}
   209  				repo.On("DeleteOlderThan", ctx, ordOpType, model.OperationStatusScheduled, mock.AnythingOfType("Time")).Return(testErr).Once()
   210  				return repo
   211  			},
   212  			OpType:      ordOpType,
   213  			OpStatus:    model.OperationStatusScheduled,
   214  			Days:        1,
   215  			ExpectedErr: testErr,
   216  		},
   217  	}
   218  
   219  	for _, testCase := range testCases {
   220  		t.Run(testCase.Name, func(t *testing.T) {
   221  			// GIVEN
   222  			repo := testCase.RepositoryFn()
   223  
   224  			svc := operation.NewService(repo, nil)
   225  
   226  			// WHEN
   227  			err := svc.DeleteOlderThan(ctx, testCase.OpType, testCase.OpStatus, testCase.Days)
   228  
   229  			// THEN
   230  			if testCase.ExpectedErr != nil {
   231  				require.Error(t, err)
   232  				assert.Contains(t, err.Error(), testCase.ExpectedErr.Error())
   233  			} else {
   234  				assert.Nil(t, err)
   235  			}
   236  
   237  			mock.AssertExpectationsForObjects(t, repo)
   238  		})
   239  	}
   240  }