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

     1  package apptemplateversion_test
     2  
     3  import (
     4  	"context"
     5  	"database/sql/driver"
     6  	"regexp"
     7  	"testing"
     8  
     9  	"github.com/DATA-DOG/go-sqlmock"
    10  	"github.com/kyma-incubator/compass/components/director/internal/domain/apptemplateversion"
    11  	"github.com/kyma-incubator/compass/components/director/internal/domain/apptemplateversion/automock"
    12  	"github.com/kyma-incubator/compass/components/director/internal/repo/testdb"
    13  	"github.com/kyma-incubator/compass/components/director/pkg/persistence"
    14  	"github.com/stretchr/testify/assert"
    15  	"github.com/stretchr/testify/require"
    16  )
    17  
    18  func TestRepository_Create(t *testing.T) {
    19  	t.Run("Success", func(t *testing.T) {
    20  		// GIVEN
    21  		appTemplateVersionModel := fixModelApplicationTemplateVersion(appTemplateVersionID)
    22  		appTemplateVersionEntity := fixEntityApplicationTemplateVersion(t, appTemplateVersionID)
    23  
    24  		mockConverter := &automock.EntityConverter{}
    25  		defer mockConverter.AssertExpectations(t)
    26  		mockConverter.On("ToEntity", appTemplateVersionModel).Return(appTemplateVersionEntity, nil).Once()
    27  		db, dbMock := testdb.MockDatabase(t)
    28  		defer dbMock.AssertExpectations(t)
    29  		dbMock.ExpectExec(regexp.QuoteMeta(`INSERT INTO public.app_template_versions ( id, version, title, correlation_ids, release_date, created_at, app_template_id ) VALUES ( ?, ?, ?, ?, ?, ?, ? )`)).
    30  			WithArgs(fixAppTemplateVersionCreateArgs(*appTemplateVersionEntity)...).
    31  			WillReturnResult(sqlmock.NewResult(-1, 1))
    32  
    33  		ctx := persistence.SaveToContext(context.TODO(), db)
    34  		appTemplateVersionRepo := apptemplateversion.NewRepository(mockConverter)
    35  
    36  		// WHEN
    37  		err := appTemplateVersionRepo.Create(ctx, *appTemplateVersionModel)
    38  
    39  		// THEN
    40  		require.NoError(t, err)
    41  	})
    42  
    43  	t.Run("Error when creating", func(t *testing.T) {
    44  		// GIVEN
    45  		appTemplateVersionModel := fixModelApplicationTemplateVersion(appTemplateVersionID)
    46  		appTemplateVersionEntity := fixEntityApplicationTemplateVersion(t, appTemplateVersionID)
    47  
    48  		mockConverter := &automock.EntityConverter{}
    49  		defer mockConverter.AssertExpectations(t)
    50  		mockConverter.On("ToEntity", appTemplateVersionModel).Return(appTemplateVersionEntity, nil).Once()
    51  		db, dbMock := testdb.MockDatabase(t)
    52  		defer dbMock.AssertExpectations(t)
    53  		dbMock.ExpectExec(regexp.QuoteMeta(`INSERT INTO public.app_template_versions ( id, version, title, correlation_ids, release_date, created_at, app_template_id ) VALUES ( ?, ?, ?, ?, ?, ?, ? )`)).
    54  			WithArgs(fixAppTemplateVersionCreateArgs(*appTemplateVersionEntity)...).
    55  			WillReturnError(testError)
    56  
    57  		ctx := persistence.SaveToContext(context.TODO(), db)
    58  		appTemplateRepo := apptemplateversion.NewRepository(mockConverter)
    59  
    60  		// WHEN
    61  		err := appTemplateRepo.Create(ctx, *appTemplateVersionModel)
    62  
    63  		// THEN
    64  		require.Error(t, err)
    65  		assert.EqualError(t, err, "Internal Server Error: Unexpected error while executing SQL query")
    66  	})
    67  }
    68  
    69  func TestRepository_GetByAppTemplateIDAndVersion(t *testing.T) {
    70  	t.Run("Success", func(t *testing.T) {
    71  		// GIVEN
    72  		appTemplateVersionModel := fixModelApplicationTemplateVersion(appTemplateVersionID)
    73  		appTemplateVersionEntity := fixEntityApplicationTemplateVersion(t, appTemplateVersionID)
    74  
    75  		mockConverter := &automock.EntityConverter{}
    76  		defer mockConverter.AssertExpectations(t)
    77  		mockConverter.On("FromEntity", appTemplateVersionEntity).Return(appTemplateVersionModel, nil).Once()
    78  		db, dbMock := testdb.MockDatabase(t)
    79  		defer dbMock.AssertExpectations(t)
    80  
    81  		rowsToReturn := fixSQLRows([]apptemplateversion.Entity{*appTemplateVersionEntity})
    82  		dbMock.ExpectQuery(regexp.QuoteMeta(`SELECT id, version, title, correlation_ids, release_date, created_at, app_template_id FROM public.app_template_versions WHERE app_template_id = $1 AND version = $2`)).
    83  			WithArgs(appTemplateID, testVersion).
    84  			WillReturnRows(rowsToReturn)
    85  
    86  		ctx := persistence.SaveToContext(context.TODO(), db)
    87  		appTemplateVersionRepo := apptemplateversion.NewRepository(mockConverter)
    88  
    89  		// WHEN
    90  		result, err := appTemplateVersionRepo.GetByAppTemplateIDAndVersion(ctx, appTemplateID, testVersion)
    91  
    92  		// THEN
    93  		require.NoError(t, err)
    94  		require.NotNil(t, result)
    95  		assert.Equal(t, appTemplateVersionModel, result)
    96  	})
    97  
    98  	t.Run("Error when getting", func(t *testing.T) {
    99  		// GIVEN
   100  		mockConverter := &automock.EntityConverter{}
   101  		defer mockConverter.AssertExpectations(t)
   102  		db, dbMock := testdb.MockDatabase(t)
   103  		defer dbMock.AssertExpectations(t)
   104  		dbMock.ExpectQuery(regexp.QuoteMeta(`SELECT id, version, title, correlation_ids, release_date, created_at, app_template_id FROM public.app_template_versions WHERE app_template_id = $1 AND version = $2`)).
   105  			WithArgs(appTemplateID, testVersion).
   106  			WillReturnError(testError)
   107  
   108  		ctx := persistence.SaveToContext(context.TODO(), db)
   109  		appTemplateVersionRepo := apptemplateversion.NewRepository(mockConverter)
   110  
   111  		// WHEN
   112  		_, err := appTemplateVersionRepo.GetByAppTemplateIDAndVersion(ctx, appTemplateID, testVersion)
   113  
   114  		// THEN
   115  		require.Error(t, err)
   116  		assert.EqualError(t, err, "Internal Server Error: Unexpected error while executing SQL query")
   117  	})
   118  }
   119  
   120  func TestRepository_ListByAppTemplateID(t *testing.T) {
   121  	appTemplateVersionModel := fixModelApplicationTemplateVersion(appTemplateVersionID)
   122  	appTemplateVersionEntity := fixEntityApplicationTemplateVersion(t, appTemplateVersionID)
   123  	suite := testdb.RepoListTestSuite{
   124  		Name:       "List Application Template Versions by App Template ID",
   125  		MethodName: "ListByAppTemplateID",
   126  		SQLQueryDetails: []testdb.SQLQueryDetails{
   127  			{
   128  				Query:    regexp.QuoteMeta(`SELECT id, version, title, correlation_ids, release_date, created_at, app_template_id FROM public.app_template_versions WHERE app_template_id = $1`),
   129  				IsSelect: true,
   130  				ValidRowsProvider: func() []*sqlmock.Rows {
   131  					return []*sqlmock.Rows{sqlmock.NewRows(fixColumns()).AddRow(appTemplateVersionEntity.ID, appTemplateVersionEntity.Version, appTemplateVersionEntity.Title, appTemplateVersionEntity.CorrelationIDs, appTemplateVersionEntity.ReleaseDate, appTemplateVersionEntity.CreatedAt, appTemplateVersionEntity.ApplicationTemplateID)}
   132  				},
   133  				InvalidRowsProvider: func() []*sqlmock.Rows {
   134  					return []*sqlmock.Rows{sqlmock.NewRows(fixColumns())}
   135  				},
   136  				Args: []driver.Value{appTemplateID},
   137  			},
   138  		},
   139  		ExpectedModelEntities: []interface{}{appTemplateVersionModel},
   140  		ExpectedDBEntities:    []interface{}{appTemplateVersionEntity},
   141  		ConverterMockProvider: func() testdb.Mock {
   142  			return &automock.EntityConverter{}
   143  		},
   144  		RepoConstructorFunc:       apptemplateversion.NewRepository,
   145  		MethodArgs:                []interface{}{appTemplateID},
   146  		DisableConverterErrorTest: true,
   147  	}
   148  
   149  	suite.Run(t)
   150  }
   151  
   152  func TestRepository_Exists(t *testing.T) {
   153  	t.Run("Success", func(t *testing.T) {
   154  		// GIVEN
   155  		db, dbMock := testdb.MockDatabase(t)
   156  		defer dbMock.AssertExpectations(t)
   157  		dbMock.ExpectQuery(regexp.QuoteMeta(`SELECT 1 FROM public.app_template_versions WHERE id = $1`)).
   158  			WithArgs(appTemplateVersionID).
   159  			WillReturnRows(testdb.RowWhenObjectExist())
   160  
   161  		ctx := persistence.SaveToContext(context.TODO(), db)
   162  		appTemplateVersionRepo := apptemplateversion.NewRepository(nil)
   163  
   164  		// WHEN
   165  		result, err := appTemplateVersionRepo.Exists(ctx, appTemplateVersionID)
   166  
   167  		// THEN
   168  		require.NoError(t, err)
   169  		require.NotNil(t, result)
   170  		assert.True(t, result)
   171  	})
   172  
   173  	t.Run("Error when checking existence", func(t *testing.T) {
   174  		// GIVEN
   175  		db, dbMock := testdb.MockDatabase(t)
   176  		defer dbMock.AssertExpectations(t)
   177  		dbMock.ExpectQuery(regexp.QuoteMeta(`SELECT 1 FROM public.app_template_versions WHERE id = $1`)).
   178  			WithArgs(appTemplateVersionID).
   179  			WillReturnError(testError)
   180  
   181  		ctx := persistence.SaveToContext(context.TODO(), db)
   182  		appTemplateVersionRepo := apptemplateversion.NewRepository(nil)
   183  
   184  		// WHEN
   185  		result, err := appTemplateVersionRepo.Exists(ctx, appTemplateVersionID)
   186  
   187  		// THEN
   188  		require.Error(t, err)
   189  		assert.Contains(t, err.Error(), "Internal Server Error: Unexpected error while executing SQL query")
   190  		assert.False(t, result)
   191  	})
   192  }
   193  
   194  func TestRepository_Update(t *testing.T) {
   195  	t.Run("Success", func(t *testing.T) {
   196  		// GIVEN
   197  		appTemplateVersionModel := fixModelApplicationTemplateVersion(appTemplateVersionID)
   198  		appTemplateVersionEntity := fixEntityApplicationTemplateVersion(t, appTemplateVersionID)
   199  
   200  		mockConverter := &automock.EntityConverter{}
   201  		defer mockConverter.AssertExpectations(t)
   202  		mockConverter.On("ToEntity", appTemplateVersionModel).Return(appTemplateVersionEntity, nil).Once()
   203  		db, dbMock := testdb.MockDatabase(t)
   204  		defer dbMock.AssertExpectations(t)
   205  		dbMock.ExpectExec(regexp.QuoteMeta(`UPDATE public.app_template_versions SET title = ?,  correlation_ids = ? WHERE id = ?`)).
   206  			WithArgs(appTemplateVersionEntity.Title, appTemplateVersionEntity.CorrelationIDs, appTemplateVersionID).
   207  			WillReturnResult(sqlmock.NewResult(-1, 1))
   208  
   209  		ctx := persistence.SaveToContext(context.TODO(), db)
   210  		appTemplateVersionRepo := apptemplateversion.NewRepository(mockConverter)
   211  
   212  		// WHEN
   213  		err := appTemplateVersionRepo.Update(ctx, *appTemplateVersionModel)
   214  
   215  		// THEN
   216  		require.NoError(t, err)
   217  	})
   218  
   219  	t.Run("Error when updating", func(t *testing.T) {
   220  		// GIVEN
   221  		appTemplateVersionModel := fixModelApplicationTemplateVersion(appTemplateVersionID)
   222  		appTemplateVersionEntity := fixEntityApplicationTemplateVersion(t, appTemplateVersionID)
   223  
   224  		mockConverter := &automock.EntityConverter{}
   225  		defer mockConverter.AssertExpectations(t)
   226  		mockConverter.On("ToEntity", appTemplateVersionModel).Return(appTemplateVersionEntity, nil).Once()
   227  		db, dbMock := testdb.MockDatabase(t)
   228  		defer dbMock.AssertExpectations(t)
   229  		dbMock.ExpectExec(regexp.QuoteMeta(`UPDATE public.app_template_versions SET title = ?,  correlation_ids = ? WHERE id = ?`)).
   230  			WithArgs(appTemplateVersionEntity.Title, appTemplateVersionEntity.CorrelationIDs, appTemplateVersionID).
   231  			WillReturnError(testError)
   232  
   233  		ctx := persistence.SaveToContext(context.TODO(), db)
   234  		appTemplateVersionRepo := apptemplateversion.NewRepository(mockConverter)
   235  
   236  		// WHEN
   237  		err := appTemplateVersionRepo.Update(ctx, *appTemplateVersionModel)
   238  
   239  		// THEN
   240  		require.Error(t, err)
   241  		assert.EqualError(t, err, "Internal Server Error: Unexpected error while executing SQL query")
   242  	})
   243  }