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

     1  package certsubjectmapping_test
     2  
     3  import (
     4  	"database/sql/driver"
     5  	"regexp"
     6  	"testing"
     7  
     8  	"github.com/DATA-DOG/go-sqlmock"
     9  	"github.com/kyma-incubator/compass/components/director/internal/domain/certsubjectmapping"
    10  	"github.com/kyma-incubator/compass/components/director/internal/domain/certsubjectmapping/automock"
    11  	"github.com/kyma-incubator/compass/components/director/internal/model"
    12  	"github.com/kyma-incubator/compass/components/director/internal/repo/testdb"
    13  	"github.com/kyma-incubator/compass/components/director/pkg/pagination"
    14  )
    15  
    16  func TestRepository_Create(t *testing.T) {
    17  	suite := testdb.RepoCreateTestSuite{
    18  		Name:       "Create certificate subject mapping",
    19  		MethodName: "Create",
    20  		SQLQueryDetails: []testdb.SQLQueryDetails{
    21  			{
    22  				Query:       `^INSERT INTO public.cert_subject_mapping \(.+\) VALUES \(.+\)$`,
    23  				Args:        []driver.Value{CertSubjectMappingEntity.ID, CertSubjectMappingEntity.Subject, CertSubjectMappingEntity.ConsumerType, CertSubjectMappingEntity.InternalConsumerID, CertSubjectMappingEntity.TenantAccessLevels},
    24  				ValidResult: sqlmock.NewResult(-1, 1),
    25  			},
    26  		},
    27  		ConverterMockProvider: func() testdb.Mock {
    28  			return &automock.EntityConverter{}
    29  		},
    30  		RepoConstructorFunc:       certsubjectmapping.NewRepository,
    31  		ModelEntity:               CertSubjectMappingModel,
    32  		DBEntity:                  CertSubjectMappingEntity,
    33  		NilModelEntity:            nilModelEntity,
    34  		IsGlobal:                  true,
    35  		DisableConverterErrorTest: false,
    36  	}
    37  
    38  	suite.Run(t)
    39  }
    40  
    41  func TestRepository_Get(t *testing.T) {
    42  	suite := testdb.RepoGetTestSuite{
    43  		Name:       "Get certificate subject mapping by ID",
    44  		MethodName: "Get",
    45  		SQLQueryDetails: []testdb.SQLQueryDetails{
    46  			{
    47  				Query:    regexp.QuoteMeta(`SELECT id, subject, consumer_type, internal_consumer_id, tenant_access_levels FROM public.cert_subject_mapping WHERE id = $1`),
    48  				Args:     []driver.Value{TestID},
    49  				IsSelect: true,
    50  				ValidRowsProvider: func() []*sqlmock.Rows {
    51  					return []*sqlmock.Rows{sqlmock.NewRows(fixColumns()).AddRow(CertSubjectMappingEntity.ID, CertSubjectMappingEntity.Subject, CertSubjectMappingEntity.ConsumerType, CertSubjectMappingEntity.InternalConsumerID, CertSubjectMappingEntity.TenantAccessLevels)}
    52  				},
    53  				InvalidRowsProvider: func() []*sqlmock.Rows {
    54  					return []*sqlmock.Rows{sqlmock.NewRows(fixColumns())}
    55  				},
    56  			},
    57  		},
    58  		ConverterMockProvider: func() testdb.Mock {
    59  			return &automock.EntityConverter{}
    60  		},
    61  		RepoConstructorFunc:       certsubjectmapping.NewRepository,
    62  		ExpectedModelEntity:       CertSubjectMappingModel,
    63  		ExpectedDBEntity:          CertSubjectMappingEntity,
    64  		MethodArgs:                []interface{}{TestID},
    65  		DisableConverterErrorTest: false,
    66  	}
    67  
    68  	suite.Run(t)
    69  }
    70  
    71  func TestRepository_Update(t *testing.T) {
    72  	updateStmt := regexp.QuoteMeta(`UPDATE public.cert_subject_mapping SET subject = ?, consumer_type = ?, internal_consumer_id = ?, tenant_access_levels = ? WHERE id = ?`)
    73  	suite := testdb.RepoUpdateTestSuite{
    74  		Name: "Update certificate subject mapping by ID",
    75  		SQLQueryDetails: []testdb.SQLQueryDetails{
    76  			{
    77  				Query:         updateStmt,
    78  				Args:          []driver.Value{CertSubjectMappingEntity.Subject, CertSubjectMappingEntity.ConsumerType, CertSubjectMappingEntity.InternalConsumerID, CertSubjectMappingEntity.TenantAccessLevels, CertSubjectMappingEntity.ID},
    79  				ValidResult:   sqlmock.NewResult(-1, 1),
    80  				InvalidResult: sqlmock.NewResult(-1, 0),
    81  			},
    82  		},
    83  		RepoConstructorFunc: certsubjectmapping.NewRepository,
    84  		ConverterMockProvider: func() testdb.Mock {
    85  			return &automock.EntityConverter{}
    86  		},
    87  		ModelEntity:    CertSubjectMappingModel,
    88  		DBEntity:       CertSubjectMappingEntity,
    89  		NilModelEntity: nilModelEntity,
    90  		IsGlobal:       true,
    91  	}
    92  
    93  	suite.Run(t)
    94  }
    95  
    96  func TestRepository_Delete(t *testing.T) {
    97  	suite := testdb.RepoDeleteTestSuite{
    98  		Name: "Delete certificate subject mapping by ID",
    99  		SQLQueryDetails: []testdb.SQLQueryDetails{
   100  			{
   101  				Query:         regexp.QuoteMeta(`DELETE FROM public.cert_subject_mapping WHERE id = $1`),
   102  				Args:          []driver.Value{TestID},
   103  				ValidResult:   sqlmock.NewResult(-1, 1),
   104  				InvalidResult: sqlmock.NewResult(-1, 2),
   105  			},
   106  		},
   107  		RepoConstructorFunc: certsubjectmapping.NewRepository,
   108  		ConverterMockProvider: func() testdb.Mock {
   109  			return &automock.EntityConverter{}
   110  		},
   111  		IsGlobal:   true,
   112  		MethodArgs: []interface{}{TestID},
   113  	}
   114  
   115  	suite.Run(t)
   116  }
   117  
   118  func TestRepository_Exists(t *testing.T) {
   119  	suite := testdb.RepoExistTestSuite{
   120  		Name: "Exists certificate subject mapping by ID",
   121  		SQLQueryDetails: []testdb.SQLQueryDetails{
   122  			{
   123  				Query:    regexp.QuoteMeta(`SELECT 1 FROM public.cert_subject_mapping WHERE id = $1`),
   124  				Args:     []driver.Value{TestID},
   125  				IsSelect: true,
   126  				ValidRowsProvider: func() []*sqlmock.Rows {
   127  					return []*sqlmock.Rows{testdb.RowWhenObjectExist()}
   128  				},
   129  				InvalidRowsProvider: func() []*sqlmock.Rows {
   130  					return []*sqlmock.Rows{testdb.RowWhenObjectDoesNotExist()}
   131  				},
   132  			},
   133  		},
   134  		RepoConstructorFunc: certsubjectmapping.NewRepository,
   135  		ConverterMockProvider: func() testdb.Mock {
   136  			return &automock.EntityConverter{}
   137  		},
   138  		TargetID:   TestID,
   139  		IsGlobal:   true,
   140  		MethodName: "Exists",
   141  		MethodArgs: []interface{}{TestID},
   142  	}
   143  
   144  	suite.Run(t)
   145  }
   146  
   147  func TestRepository_List(t *testing.T) {
   148  	suite := testdb.RepoListPageableTestSuite{
   149  		Name:       "List certificate subject mappings with paging",
   150  		MethodName: "List",
   151  		SQLQueryDetails: []testdb.SQLQueryDetails{
   152  			{
   153  				Query:    regexp.QuoteMeta(`SELECT id, subject, consumer_type, internal_consumer_id, tenant_access_levels FROM public.cert_subject_mapping ORDER BY id LIMIT 3 OFFSET 0`),
   154  				IsSelect: true,
   155  				ValidRowsProvider: func() []*sqlmock.Rows {
   156  					return []*sqlmock.Rows{sqlmock.NewRows(fixColumns()).AddRow(CertSubjectMappingEntity.ID, CertSubjectMappingEntity.Subject, CertSubjectMappingEntity.ConsumerType, CertSubjectMappingEntity.InternalConsumerID, CertSubjectMappingEntity.TenantAccessLevels)}
   157  				},
   158  				InvalidRowsProvider: func() []*sqlmock.Rows {
   159  					return []*sqlmock.Rows{sqlmock.NewRows(fixColumns())}
   160  				},
   161  			},
   162  			{
   163  				Query:    regexp.QuoteMeta(`SELECT COUNT(*) FROM public.cert_subject_mapping`),
   164  				IsSelect: true,
   165  				ValidRowsProvider: func() []*sqlmock.Rows {
   166  					return []*sqlmock.Rows{sqlmock.NewRows([]string{"count"}).AddRow(1)}
   167  				},
   168  			},
   169  		},
   170  		Pages: []testdb.PageDetails{
   171  			{
   172  				ExpectedModelEntities: []interface{}{CertSubjectMappingModel},
   173  				ExpectedDBEntities:    []interface{}{CertSubjectMappingEntity},
   174  				ExpectedPage: &model.CertSubjectMappingPage{
   175  					Data: []*model.CertSubjectMapping{CertSubjectMappingModel},
   176  					PageInfo: &pagination.Page{
   177  						StartCursor: "",
   178  						EndCursor:   "",
   179  						HasNextPage: false,
   180  					},
   181  					TotalCount: 1,
   182  				},
   183  			},
   184  		},
   185  		ConverterMockProvider: func() testdb.Mock {
   186  			return &automock.EntityConverter{}
   187  		},
   188  		RepoConstructorFunc:       certsubjectmapping.NewRepository,
   189  		MethodArgs:                []interface{}{3, ""},
   190  		DisableConverterErrorTest: false,
   191  	}
   192  
   193  	suite.Run(t)
   194  }