github.com/kyma-incubator/compass/components/director@v0.0.0-20230623144113-d764f56ff805/internal/domain/spec/repository_test.go (about) 1 package spec_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/spec" 10 "github.com/kyma-incubator/compass/components/director/internal/domain/spec/automock" 11 "github.com/kyma-incubator/compass/components/director/internal/model" 12 "github.com/kyma-incubator/compass/components/director/internal/repo/testdb" 13 ) 14 15 func TestRepository_GetByID(t *testing.T) { 16 apiSpecModel := fixModelAPISpec() 17 apiSpecEntity := fixAPISpecEntity() 18 eventSpecModel := fixModelEventSpec() 19 eventSpecEntity := fixEventSpecEntity() 20 21 apiSpecSuite := testdb.RepoGetTestSuite{ 22 Name: "Get API Spec By ID", 23 SQLQueryDetails: []testdb.SQLQueryDetails{ 24 { 25 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE id = $1 AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $2))`), 26 Args: []driver.Value{specID, tenant}, 27 IsSelect: true, 28 ValidRowsProvider: func() []*sqlmock.Rows { 29 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixAPISpecRow()...)} 30 }, 31 InvalidRowsProvider: func() []*sqlmock.Rows { 32 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 33 }, 34 }, 35 }, 36 ConverterMockProvider: func() testdb.Mock { 37 return &automock.Converter{} 38 }, 39 RepoConstructorFunc: spec.NewRepository, 40 ExpectedModelEntity: apiSpecModel, 41 ExpectedDBEntity: apiSpecEntity, 42 MethodArgs: []interface{}{tenant, specID, model.APISpecReference}, 43 } 44 45 eventSpecSuite := testdb.RepoGetTestSuite{ 46 Name: "Get Event Spec By ID", 47 SQLQueryDetails: []testdb.SQLQueryDetails{ 48 { 49 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE id = $1 AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $2))`), 50 Args: []driver.Value{specID, tenant}, 51 IsSelect: true, 52 ValidRowsProvider: func() []*sqlmock.Rows { 53 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixEventSpecRow()...)} 54 }, 55 InvalidRowsProvider: func() []*sqlmock.Rows { 56 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 57 }, 58 }, 59 }, 60 ConverterMockProvider: func() testdb.Mock { 61 return &automock.Converter{} 62 }, 63 RepoConstructorFunc: spec.NewRepository, 64 ExpectedModelEntity: eventSpecModel, 65 ExpectedDBEntity: eventSpecEntity, 66 MethodArgs: []interface{}{tenant, specID, model.EventSpecReference}, 67 } 68 69 apiSpecSuite.Run(t) 70 eventSpecSuite.Run(t) 71 } 72 73 func TestRepository_GetByIDGlobal(t *testing.T) { 74 apiSpecModel := fixModelAPISpec() 75 apiSpecEntity := fixAPISpecEntity() 76 eventSpecModel := fixModelEventSpec() 77 eventSpecEntity := fixEventSpecEntity() 78 79 apiSpecSuite := testdb.RepoGetTestSuite{ 80 Name: "Get API Spec By ID Global", 81 SQLQueryDetails: []testdb.SQLQueryDetails{ 82 { 83 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE id = $1`), 84 Args: []driver.Value{specID}, 85 IsSelect: true, 86 ValidRowsProvider: func() []*sqlmock.Rows { 87 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixAPISpecRow()...)} 88 }, 89 InvalidRowsProvider: func() []*sqlmock.Rows { 90 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 91 }, 92 }, 93 }, 94 ConverterMockProvider: func() testdb.Mock { 95 return &automock.Converter{} 96 }, 97 RepoConstructorFunc: spec.NewRepository, 98 ExpectedModelEntity: apiSpecModel, 99 ExpectedDBEntity: apiSpecEntity, 100 MethodArgs: []interface{}{specID}, 101 MethodName: "GetByIDGlobal", 102 } 103 104 eventSpecSuite := testdb.RepoGetTestSuite{ 105 Name: "Get Event Spec By ID Global", 106 SQLQueryDetails: []testdb.SQLQueryDetails{ 107 { 108 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE id = $1`), 109 Args: []driver.Value{specID}, 110 IsSelect: true, 111 ValidRowsProvider: func() []*sqlmock.Rows { 112 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixEventSpecRow()...)} 113 }, 114 InvalidRowsProvider: func() []*sqlmock.Rows { 115 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 116 }, 117 }, 118 }, 119 ConverterMockProvider: func() testdb.Mock { 120 return &automock.Converter{} 121 }, 122 RepoConstructorFunc: spec.NewRepository, 123 ExpectedModelEntity: eventSpecModel, 124 ExpectedDBEntity: eventSpecEntity, 125 MethodArgs: []interface{}{specID}, 126 MethodName: "GetByIDGlobal", 127 } 128 129 apiSpecSuite.Run(t) 130 eventSpecSuite.Run(t) 131 } 132 133 func TestRepository_Create(t *testing.T) { 134 var nilSpecModel *model.Spec 135 apiSpecModel := fixModelAPISpec() 136 apiSpecEntity := fixAPISpecEntity() 137 eventSpecModel := fixModelEventSpec() 138 eventSpecEntity := fixEventSpecEntity() 139 140 apiSpecSuite := testdb.RepoCreateTestSuite{ 141 Name: "Create API Specification", 142 SQLQueryDetails: []testdb.SQLQueryDetails{ 143 { 144 Query: regexp.QuoteMeta("SELECT 1 FROM api_definitions_tenants WHERE tenant_id = $1 AND id = $2 AND owner = $3"), 145 Args: []driver.Value{tenant, apiID, true}, 146 IsSelect: true, 147 ValidRowsProvider: func() []*sqlmock.Rows { 148 return []*sqlmock.Rows{testdb.RowWhenObjectExist()} 149 }, 150 InvalidRowsProvider: func() []*sqlmock.Rows { 151 return []*sqlmock.Rows{testdb.RowWhenObjectDoesNotExist()} 152 }, 153 }, 154 { 155 Query: `^INSERT INTO public.specifications \(.+\) VALUES \(.+\)$`, 156 Args: fixAPISpecCreateArgs(apiSpecModel), 157 ValidResult: sqlmock.NewResult(-1, 1), 158 }, 159 }, 160 ConverterMockProvider: func() testdb.Mock { 161 return &automock.Converter{} 162 }, 163 RepoConstructorFunc: spec.NewRepository, 164 ModelEntity: apiSpecModel, 165 DBEntity: apiSpecEntity, 166 NilModelEntity: nilSpecModel, 167 TenantID: tenant, 168 DisableConverterErrorTest: true, 169 } 170 171 eventSpecSuite := testdb.RepoCreateTestSuite{ 172 Name: "Create Event Specification", 173 SQLQueryDetails: []testdb.SQLQueryDetails{ 174 { 175 Query: regexp.QuoteMeta("SELECT 1 FROM event_api_definitions_tenants WHERE tenant_id = $1 AND id = $2 AND owner = $3"), 176 Args: []driver.Value{tenant, eventID, true}, 177 IsSelect: true, 178 ValidRowsProvider: func() []*sqlmock.Rows { 179 return []*sqlmock.Rows{testdb.RowWhenObjectExist()} 180 }, 181 InvalidRowsProvider: func() []*sqlmock.Rows { 182 return []*sqlmock.Rows{testdb.RowWhenObjectDoesNotExist()} 183 }, 184 }, 185 { 186 Query: `^INSERT INTO public.specifications \(.+\) VALUES \(.+\)$`, 187 Args: fixEventSpecCreateArgs(eventSpecModel), 188 ValidResult: sqlmock.NewResult(-1, 1), 189 }, 190 }, 191 ConverterMockProvider: func() testdb.Mock { 192 return &automock.Converter{} 193 }, 194 RepoConstructorFunc: spec.NewRepository, 195 ModelEntity: eventSpecModel, 196 DBEntity: eventSpecEntity, 197 NilModelEntity: nilSpecModel, 198 TenantID: tenant, 199 DisableConverterErrorTest: true, 200 } 201 202 apiSpecSuite.Run(t) 203 eventSpecSuite.Run(t) 204 } 205 206 func TestRepository_CreateGlobal(t *testing.T) { 207 var nilSpecModel *model.Spec 208 apiSpecModel := fixModelAPISpec() 209 apiSpecEntity := fixAPISpecEntity() 210 eventSpecModel := fixModelEventSpec() 211 eventSpecEntity := fixEventSpecEntity() 212 213 apiSpecSuite := testdb.RepoCreateTestSuite{ 214 Name: "Create API Specification Global", 215 SQLQueryDetails: []testdb.SQLQueryDetails{ 216 { 217 Query: `^INSERT INTO public.specifications \(.+\) VALUES \(.+\)$`, 218 Args: fixAPISpecCreateArgs(apiSpecModel), 219 ValidResult: sqlmock.NewResult(-1, 1), 220 }, 221 }, 222 ConverterMockProvider: func() testdb.Mock { 223 return &automock.Converter{} 224 }, 225 RepoConstructorFunc: spec.NewRepository, 226 ModelEntity: apiSpecModel, 227 DBEntity: apiSpecEntity, 228 NilModelEntity: nilSpecModel, 229 DisableConverterErrorTest: true, 230 IsGlobal: true, 231 MethodName: "CreateGlobal", 232 } 233 234 eventSpecSuite := testdb.RepoCreateTestSuite{ 235 Name: "Create Event Specification Global", 236 SQLQueryDetails: []testdb.SQLQueryDetails{ 237 { 238 Query: `^INSERT INTO public.specifications \(.+\) VALUES \(.+\)$`, 239 Args: fixEventSpecCreateArgs(eventSpecModel), 240 ValidResult: sqlmock.NewResult(-1, 1), 241 }, 242 }, 243 ConverterMockProvider: func() testdb.Mock { 244 return &automock.Converter{} 245 }, 246 RepoConstructorFunc: spec.NewRepository, 247 ModelEntity: eventSpecModel, 248 DBEntity: eventSpecEntity, 249 NilModelEntity: nilSpecModel, 250 DisableConverterErrorTest: true, 251 IsGlobal: true, 252 MethodName: "CreateGlobal", 253 } 254 255 apiSpecSuite.Run(t) 256 eventSpecSuite.Run(t) 257 } 258 259 func TestRepository_ListIDByReferenceObjectID(t *testing.T) { 260 idOne := "1" 261 idTwo := "2" 262 apiSpecSuite := testdb.RepoListTestSuite{ 263 Name: "List API Spec IDs By Ref Object ID", 264 SQLQueryDetails: []testdb.SQLQueryDetails{ 265 { 266 Query: regexp.QuoteMeta(`SELECT id FROM public.specifications WHERE api_def_id = $1 AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $2))`), 267 Args: []driver.Value{apiID, tenant}, 268 IsSelect: true, 269 ValidRowsProvider: func() []*sqlmock.Rows { 270 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixAPISpecRowWithID("1")...).AddRow(fixAPISpecRowWithID("2")...)} 271 }, 272 InvalidRowsProvider: func() []*sqlmock.Rows { 273 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 274 }, 275 }, 276 }, 277 ConverterMockProvider: func() testdb.Mock { 278 return &automock.Converter{} 279 }, 280 ShouldSkipMockFromEntity: true, 281 RepoConstructorFunc: spec.NewRepository, 282 ExpectedModelEntities: []interface{}{&idOne, &idTwo}, 283 ExpectedDBEntities: []interface{}{idOne, idTwo}, 284 MethodArgs: []interface{}{tenant, model.APISpecReference, apiID}, 285 MethodName: "ListIDByReferenceObjectID", 286 DisableConverterErrorTest: true, 287 } 288 289 eventSpecSuite := testdb.RepoListTestSuite{ 290 Name: "List Event Spec IDs By Ref Object ID", 291 SQLQueryDetails: []testdb.SQLQueryDetails{ 292 { 293 Query: regexp.QuoteMeta(`SELECT id FROM public.specifications WHERE event_def_id = $1 AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $2))`), 294 Args: []driver.Value{apiID, tenant}, 295 IsSelect: true, 296 ValidRowsProvider: func() []*sqlmock.Rows { 297 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixEventSpecRowWithID("1")...).AddRow(fixEventSpecRowWithID("2")...)} 298 }, 299 InvalidRowsProvider: func() []*sqlmock.Rows { 300 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 301 }, 302 }, 303 }, 304 ConverterMockProvider: func() testdb.Mock { 305 return &automock.Converter{} 306 }, 307 ShouldSkipMockFromEntity: true, 308 RepoConstructorFunc: spec.NewRepository, 309 ExpectedModelEntities: []interface{}{&idOne, &idTwo}, 310 ExpectedDBEntities: []interface{}{idOne, idTwo}, 311 MethodArgs: []interface{}{tenant, model.EventSpecReference, apiID}, 312 MethodName: "ListIDByReferenceObjectID", 313 DisableConverterErrorTest: true, 314 } 315 316 apiSpecSuite.Run(t) 317 eventSpecSuite.Run(t) 318 } 319 320 func TestRepository_ListIDByReferenceObjectIDGlobal(t *testing.T) { 321 idOne := "1" 322 idTwo := "2" 323 apiSpecSuite := testdb.RepoListTestSuite{ 324 Name: "List API Spec IDs By Ref Object ID Global", 325 SQLQueryDetails: []testdb.SQLQueryDetails{ 326 { 327 Query: regexp.QuoteMeta(`SELECT id FROM public.specifications WHERE api_def_id = $1`), 328 Args: []driver.Value{apiID}, 329 IsSelect: true, 330 ValidRowsProvider: func() []*sqlmock.Rows { 331 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixAPISpecRowWithID("1")...).AddRow(fixAPISpecRowWithID("2")...)} 332 }, 333 InvalidRowsProvider: func() []*sqlmock.Rows { 334 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 335 }, 336 }, 337 }, 338 ConverterMockProvider: func() testdb.Mock { 339 return &automock.Converter{} 340 }, 341 ShouldSkipMockFromEntity: true, 342 RepoConstructorFunc: spec.NewRepository, 343 ExpectedModelEntities: []interface{}{&idOne, &idTwo}, 344 ExpectedDBEntities: []interface{}{idOne, idTwo}, 345 MethodArgs: []interface{}{model.APISpecReference, apiID}, 346 MethodName: "ListIDByReferenceObjectIDGlobal", 347 DisableConverterErrorTest: true, 348 } 349 350 eventSpecSuite := testdb.RepoListTestSuite{ 351 Name: "List Event Spec IDs By Ref Object ID", 352 SQLQueryDetails: []testdb.SQLQueryDetails{ 353 { 354 Query: regexp.QuoteMeta(`SELECT id FROM public.specifications WHERE event_def_id = $1 AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $2))`), 355 Args: []driver.Value{apiID, tenant}, 356 IsSelect: true, 357 ValidRowsProvider: func() []*sqlmock.Rows { 358 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixEventSpecRowWithID("1")...).AddRow(fixEventSpecRowWithID("2")...)} 359 }, 360 InvalidRowsProvider: func() []*sqlmock.Rows { 361 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 362 }, 363 }, 364 }, 365 ConverterMockProvider: func() testdb.Mock { 366 return &automock.Converter{} 367 }, 368 ShouldSkipMockFromEntity: true, 369 RepoConstructorFunc: spec.NewRepository, 370 ExpectedModelEntities: []interface{}{&idOne, &idTwo}, 371 ExpectedDBEntities: []interface{}{idOne, idTwo}, 372 MethodArgs: []interface{}{tenant, model.EventSpecReference, apiID}, 373 MethodName: "ListIDByReferenceObjectID", 374 DisableConverterErrorTest: true, 375 } 376 377 apiSpecSuite.Run(t) 378 eventSpecSuite.Run(t) 379 } 380 381 func TestRepository_ListByReferenceObjectID(t *testing.T) { 382 apiSpecModel1 := fixModelAPISpecWithID("1") 383 apiSpecModel2 := fixModelAPISpecWithID("2") 384 apiSpecEntity1 := fixAPISpecEntityWithID("1") 385 apiSpecEntity2 := fixAPISpecEntityWithID("2") 386 387 apiSpecSuite := testdb.RepoListTestSuite{ 388 Name: "List API Specs By Ref Object ID", 389 SQLQueryDetails: []testdb.SQLQueryDetails{ 390 { 391 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE api_def_id = $1 AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $2))`), 392 Args: []driver.Value{apiID, tenant}, 393 IsSelect: true, 394 ValidRowsProvider: func() []*sqlmock.Rows { 395 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixAPISpecRowWithID("1")...).AddRow(fixAPISpecRowWithID("2")...)} 396 }, 397 InvalidRowsProvider: func() []*sqlmock.Rows { 398 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 399 }, 400 }, 401 }, 402 ConverterMockProvider: func() testdb.Mock { 403 return &automock.Converter{} 404 }, 405 RepoConstructorFunc: spec.NewRepository, 406 ExpectedModelEntities: []interface{}{apiSpecModel1, apiSpecModel2}, 407 ExpectedDBEntities: []interface{}{&apiSpecEntity1, &apiSpecEntity2}, 408 MethodArgs: []interface{}{tenant, model.APISpecReference, apiID}, 409 MethodName: "ListByReferenceObjectID", 410 } 411 412 eventSpecModel1 := fixModelEventSpecWithID("1") 413 eventSpecModel2 := fixModelEventSpecWithID("2") 414 eventSpecEntity1 := fixEventSpecEntityWithID("1") 415 eventSpecEntity2 := fixEventSpecEntityWithID("2") 416 417 eventSpecSuite := testdb.RepoListTestSuite{ 418 Name: "List Event Specs By Ref Object ID", 419 SQLQueryDetails: []testdb.SQLQueryDetails{ 420 { 421 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE event_def_id = $1 AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $2))`), 422 Args: []driver.Value{apiID, tenant}, 423 IsSelect: true, 424 ValidRowsProvider: func() []*sqlmock.Rows { 425 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixEventSpecRowWithID("1")...).AddRow(fixEventSpecRowWithID("2")...)} 426 }, 427 InvalidRowsProvider: func() []*sqlmock.Rows { 428 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 429 }, 430 }, 431 }, 432 ConverterMockProvider: func() testdb.Mock { 433 return &automock.Converter{} 434 }, 435 RepoConstructorFunc: spec.NewRepository, 436 ExpectedModelEntities: []interface{}{eventSpecModel1, eventSpecModel2}, 437 ExpectedDBEntities: []interface{}{&eventSpecEntity1, &eventSpecEntity2}, 438 MethodArgs: []interface{}{tenant, model.EventSpecReference, apiID}, 439 MethodName: "ListByReferenceObjectID", 440 } 441 442 apiSpecSuite.Run(t) 443 eventSpecSuite.Run(t) 444 } 445 446 func TestRepository_ListByReferenceObjectIDGlobal(t *testing.T) { 447 apiSpecModel1 := fixModelAPISpecWithID("1") 448 apiSpecModel2 := fixModelAPISpecWithID("2") 449 apiSpecEntity1 := fixAPISpecEntityWithID("1") 450 apiSpecEntity2 := fixAPISpecEntityWithID("2") 451 452 apiSpecSuite := testdb.RepoListTestSuite{ 453 Name: "List API Specs By Ref Object ID Global", 454 SQLQueryDetails: []testdb.SQLQueryDetails{ 455 { 456 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE api_def_id = $1`), 457 Args: []driver.Value{apiID}, 458 IsSelect: true, 459 ValidRowsProvider: func() []*sqlmock.Rows { 460 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixAPISpecRowWithID("1")...).AddRow(fixAPISpecRowWithID("2")...)} 461 }, 462 InvalidRowsProvider: func() []*sqlmock.Rows { 463 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 464 }, 465 }, 466 }, 467 ConverterMockProvider: func() testdb.Mock { 468 return &automock.Converter{} 469 }, 470 RepoConstructorFunc: spec.NewRepository, 471 ExpectedModelEntities: []interface{}{apiSpecModel1, apiSpecModel2}, 472 ExpectedDBEntities: []interface{}{&apiSpecEntity1, &apiSpecEntity2}, 473 MethodArgs: []interface{}{model.APISpecReference, apiID}, 474 MethodName: "ListByReferenceObjectIDGlobal", 475 } 476 477 eventSpecModel1 := fixModelEventSpecWithID("1") 478 eventSpecModel2 := fixModelEventSpecWithID("2") 479 eventSpecEntity1 := fixEventSpecEntityWithID("1") 480 eventSpecEntity2 := fixEventSpecEntityWithID("2") 481 482 eventSpecSuite := testdb.RepoListTestSuite{ 483 Name: "List Event Specs By Ref Object ID Global", 484 SQLQueryDetails: []testdb.SQLQueryDetails{ 485 { 486 Query: regexp.QuoteMeta(`SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications WHERE event_def_id = $1`), 487 Args: []driver.Value{apiID}, 488 IsSelect: true, 489 ValidRowsProvider: func() []*sqlmock.Rows { 490 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixEventSpecRowWithID("1")...).AddRow(fixEventSpecRowWithID("2")...)} 491 }, 492 InvalidRowsProvider: func() []*sqlmock.Rows { 493 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 494 }, 495 }, 496 }, 497 ConverterMockProvider: func() testdb.Mock { 498 return &automock.Converter{} 499 }, 500 RepoConstructorFunc: spec.NewRepository, 501 ExpectedModelEntities: []interface{}{eventSpecModel1, eventSpecModel2}, 502 ExpectedDBEntities: []interface{}{&eventSpecEntity1, &eventSpecEntity2}, 503 MethodArgs: []interface{}{model.EventSpecReference, apiID}, 504 MethodName: "ListByReferenceObjectIDGlobal", 505 } 506 507 apiSpecSuite.Run(t) 508 eventSpecSuite.Run(t) 509 } 510 511 func TestRepository_ListByReferenceObjectIDs(t *testing.T) { 512 firstFrID := "111111111-1111-1111-1111-111111111111" 513 firstRefID := "refID1" 514 secondFrID := "222222222-2222-2222-2222-222222222222" 515 secondRefID := "refID2" 516 517 apiSpecModel1 := fixModelAPISpecWithIDs(firstFrID, firstRefID) 518 apiSpecModel2 := fixModelAPISpecWithIDs(secondFrID, secondRefID) 519 apiSpecEntity1 := fixAPISpecEntityWithIDs(firstFrID, firstRefID) 520 apiSpecEntity2 := fixAPISpecEntityWithIDs(secondFrID, secondRefID) 521 522 apiSpecSuite := testdb.RepoListTestSuite{ 523 Name: "List API Specifications by Object IDs", 524 SQLQueryDetails: []testdb.SQLQueryDetails{ 525 { 526 Query: regexp.QuoteMeta(`(SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications 527 WHERE api_def_id IS NOT NULL AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $1)) AND api_def_id = $2 ORDER BY created_at ASC, id ASC LIMIT $3 OFFSET $4) 528 UNION 529 (SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications 530 WHERE api_def_id IS NOT NULL AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $5)) AND api_def_id = $6 ORDER BY created_at ASC, id ASC LIMIT $7 OFFSET $8)`), 531 Args: []driver.Value{tenant, firstRefID, 1, 0, tenant, secondRefID, 1, 0}, 532 IsSelect: true, 533 ValidRowsProvider: func() []*sqlmock.Rows { 534 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixAPISpecRowWithIDs(firstFrID, firstRefID)...).AddRow(fixAPISpecRowWithIDs(secondFrID, secondRefID)...)} 535 }, 536 InvalidRowsProvider: func() []*sqlmock.Rows { 537 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 538 }, 539 }, 540 { 541 Query: regexp.QuoteMeta(`SELECT api_def_id AS id, COUNT(*) AS total_count FROM public.specifications WHERE api_def_id IS NOT NULL AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $1)) GROUP BY api_def_id ORDER BY api_def_id ASC`), 542 Args: []driver.Value{tenant}, 543 IsSelect: true, 544 ValidRowsProvider: func() []*sqlmock.Rows { 545 return []*sqlmock.Rows{sqlmock.NewRows([]string{"id", "total_count"}).AddRow(firstRefID, 1).AddRow(secondRefID, 1)} 546 }, 547 InvalidRowsProvider: func() []*sqlmock.Rows { 548 return []*sqlmock.Rows{sqlmock.NewRows([]string{"id", "total_count"}).AddRow(firstRefID, 0).AddRow(secondRefID, 0)} 549 }, 550 }, 551 }, 552 ConverterMockProvider: func() testdb.Mock { 553 return &automock.Converter{} 554 }, 555 RepoConstructorFunc: spec.NewRepository, 556 ExpectedModelEntities: []interface{}{apiSpecModel1, apiSpecModel2}, 557 ExpectedDBEntities: []interface{}{&apiSpecEntity1, &apiSpecEntity2}, 558 MethodArgs: []interface{}{tenant, model.APISpecReference, []string{firstRefID, secondRefID}}, 559 MethodName: "ListByReferenceObjectIDs", 560 } 561 562 eventSpecModel1 := fixModelEventSpecWithIDs(firstFrID, firstRefID) 563 eventSpecModel2 := fixModelEventSpecWithIDs(secondFrID, secondRefID) 564 eventSpecEntity1 := fixEventSpecEntityWithIDs(firstFrID, firstRefID) 565 eventSpecEntity2 := fixEventSpecEntityWithIDs(secondFrID, secondRefID) 566 567 eventSpecSuite := testdb.RepoListTestSuite{ 568 Name: "List Event Specifications by Object IDs", 569 SQLQueryDetails: []testdb.SQLQueryDetails{ 570 { 571 Query: regexp.QuoteMeta(`(SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications 572 WHERE event_def_id IS NOT NULL AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $1)) AND event_def_id = $2 ORDER BY created_at ASC, id ASC LIMIT $3 OFFSET $4) 573 UNION 574 (SELECT id, api_def_id, event_def_id, spec_data, api_spec_format, api_spec_type, event_spec_format, event_spec_type, custom_type FROM public.specifications 575 WHERE event_def_id IS NOT NULL AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $5)) AND event_def_id = $6 ORDER BY created_at ASC, id ASC LIMIT $7 OFFSET $8)`), 576 Args: []driver.Value{tenant, firstRefID, 1, 0, tenant, secondRefID, 1, 0}, 577 IsSelect: true, 578 ValidRowsProvider: func() []*sqlmock.Rows { 579 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns()).AddRow(fixEventSpecRowWithIDs(firstFrID, firstRefID)...).AddRow(fixEventSpecRowWithIDs(secondFrID, secondRefID)...)} 580 }, 581 InvalidRowsProvider: func() []*sqlmock.Rows { 582 return []*sqlmock.Rows{sqlmock.NewRows(fixSpecColumns())} 583 }, 584 }, 585 { 586 Query: regexp.QuoteMeta(`SELECT event_def_id AS id, COUNT(*) AS total_count FROM public.specifications WHERE event_def_id IS NOT NULL AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $1)) GROUP BY event_def_id ORDER BY event_def_id ASC`), 587 Args: []driver.Value{tenant}, 588 IsSelect: true, 589 ValidRowsProvider: func() []*sqlmock.Rows { 590 return []*sqlmock.Rows{sqlmock.NewRows([]string{"id", "total_count"}).AddRow(firstRefID, 1).AddRow(secondRefID, 1)} 591 }, 592 InvalidRowsProvider: func() []*sqlmock.Rows { 593 return []*sqlmock.Rows{sqlmock.NewRows([]string{"id", "total_count"}).AddRow(firstRefID, 0).AddRow(secondRefID, 0)} 594 }, 595 }, 596 }, 597 ConverterMockProvider: func() testdb.Mock { 598 return &automock.Converter{} 599 }, 600 RepoConstructorFunc: spec.NewRepository, 601 ExpectedModelEntities: []interface{}{eventSpecModel1, eventSpecModel2}, 602 ExpectedDBEntities: []interface{}{&eventSpecEntity1, &eventSpecEntity2}, 603 MethodArgs: []interface{}{tenant, model.EventSpecReference, []string{firstRefID, secondRefID}}, 604 MethodName: "ListByReferenceObjectIDs", 605 } 606 607 apiSpecSuite.Run(t) 608 eventSpecSuite.Run(t) 609 } 610 611 func TestRepository_Delete(t *testing.T) { 612 apiSpecSuite := testdb.RepoDeleteTestSuite{ 613 Name: "API Spec Delete", 614 SQLQueryDetails: []testdb.SQLQueryDetails{ 615 { 616 Query: regexp.QuoteMeta(`DELETE FROM public.specifications WHERE id = $1 AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $2 AND owner = true))`), 617 Args: []driver.Value{specID, tenant}, 618 ValidResult: sqlmock.NewResult(-1, 1), 619 InvalidResult: sqlmock.NewResult(-1, 2), 620 }, 621 }, 622 ConverterMockProvider: func() testdb.Mock { 623 return &automock.Converter{} 624 }, 625 RepoConstructorFunc: spec.NewRepository, 626 MethodArgs: []interface{}{tenant, specID, model.APISpecReference}, 627 } 628 629 eventSpecSuite := testdb.RepoDeleteTestSuite{ 630 Name: "Event Spec Delete", 631 SQLQueryDetails: []testdb.SQLQueryDetails{ 632 { 633 Query: regexp.QuoteMeta(`DELETE FROM public.specifications WHERE id = $1 AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $2 AND owner = true))`), 634 Args: []driver.Value{specID, tenant}, 635 ValidResult: sqlmock.NewResult(-1, 1), 636 InvalidResult: sqlmock.NewResult(-1, 2), 637 }, 638 }, 639 ConverterMockProvider: func() testdb.Mock { 640 return &automock.Converter{} 641 }, 642 RepoConstructorFunc: spec.NewRepository, 643 MethodArgs: []interface{}{tenant, specID, model.EventSpecReference}, 644 } 645 646 apiSpecSuite.Run(t) 647 eventSpecSuite.Run(t) 648 } 649 650 func TestRepository_DeleteByReferenceObjectID(t *testing.T) { 651 apiSpecSuite := testdb.RepoDeleteTestSuite{ 652 Name: "API Spec DeleteByReferenceObjectID", 653 SQLQueryDetails: []testdb.SQLQueryDetails{ 654 { 655 Query: regexp.QuoteMeta(`DELETE FROM public.specifications WHERE api_def_id = $1 AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $2 AND owner = true))`), 656 Args: []driver.Value{apiID, tenant}, 657 ValidResult: sqlmock.NewResult(-1, 1), 658 InvalidResult: sqlmock.NewResult(-1, 2), 659 }, 660 }, 661 ConverterMockProvider: func() testdb.Mock { 662 return &automock.Converter{} 663 }, 664 RepoConstructorFunc: spec.NewRepository, 665 MethodArgs: []interface{}{tenant, model.APISpecReference, apiID}, 666 MethodName: "DeleteByReferenceObjectID", 667 IsDeleteMany: true, 668 } 669 670 eventSpecSuite := testdb.RepoDeleteTestSuite{ 671 Name: "Event Spec DeleteByReferenceObjectID", 672 SQLQueryDetails: []testdb.SQLQueryDetails{ 673 { 674 Query: regexp.QuoteMeta(`DELETE FROM public.specifications WHERE event_def_id = $1 AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $2 AND owner = true))`), 675 Args: []driver.Value{eventID, tenant}, 676 ValidResult: sqlmock.NewResult(-1, 1), 677 InvalidResult: sqlmock.NewResult(-1, 2), 678 }, 679 }, 680 ConverterMockProvider: func() testdb.Mock { 681 return &automock.Converter{} 682 }, 683 RepoConstructorFunc: spec.NewRepository, 684 MethodArgs: []interface{}{tenant, model.EventSpecReference, eventID}, 685 MethodName: "DeleteByReferenceObjectID", 686 IsDeleteMany: true, 687 } 688 689 apiSpecSuite.Run(t) 690 eventSpecSuite.Run(t) 691 } 692 693 func TestRepository_DeleteByReferenceObjectIDGlobal(t *testing.T) { 694 apiSpecSuite := testdb.RepoDeleteTestSuite{ 695 Name: "API Spec DeleteByReferenceObjectIDGlobal", 696 SQLQueryDetails: []testdb.SQLQueryDetails{ 697 { 698 Query: regexp.QuoteMeta(`DELETE FROM public.specifications WHERE api_def_id = $1`), 699 Args: []driver.Value{apiID}, 700 ValidResult: sqlmock.NewResult(-1, 1), 701 InvalidResult: sqlmock.NewResult(-1, 2), 702 }, 703 }, 704 ConverterMockProvider: func() testdb.Mock { 705 return &automock.Converter{} 706 }, 707 RepoConstructorFunc: spec.NewRepository, 708 MethodArgs: []interface{}{model.APISpecReference, apiID}, 709 MethodName: "DeleteByReferenceObjectIDGlobal", 710 IsDeleteMany: true, 711 } 712 713 eventSpecSuite := testdb.RepoDeleteTestSuite{ 714 Name: "Event Spec DeleteByReferenceObjectIDGlobal", 715 SQLQueryDetails: []testdb.SQLQueryDetails{ 716 { 717 Query: regexp.QuoteMeta(`DELETE FROM public.specifications WHERE event_def_id = $1`), 718 Args: []driver.Value{eventID}, 719 ValidResult: sqlmock.NewResult(-1, 1), 720 InvalidResult: sqlmock.NewResult(-1, 2), 721 }, 722 }, 723 ConverterMockProvider: func() testdb.Mock { 724 return &automock.Converter{} 725 }, 726 RepoConstructorFunc: spec.NewRepository, 727 MethodArgs: []interface{}{model.EventSpecReference, eventID}, 728 MethodName: "DeleteByReferenceObjectIDGlobal", 729 IsDeleteMany: true, 730 } 731 732 apiSpecSuite.Run(t) 733 eventSpecSuite.Run(t) 734 } 735 736 func TestRepository_Update(t *testing.T) { 737 var nilSpecModel *model.Spec 738 apiSpecModel := fixModelAPISpec() 739 apiSpecEntity := fixAPISpecEntity() 740 eventSpecModel := fixModelEventSpec() 741 eventSpecEntity := fixEventSpecEntity() 742 743 apiSpecSuite := testdb.RepoUpdateTestSuite{ 744 Name: "Update API Spec", 745 SQLQueryDetails: []testdb.SQLQueryDetails{ 746 { 747 Query: regexp.QuoteMeta(`UPDATE public.specifications SET spec_data = ?, api_spec_format = ?, api_spec_type = ?, event_spec_format = ?, event_spec_type = ? WHERE id = ? AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = ? AND owner = true))`), 748 Args: []driver.Value{apiSpecEntity.SpecData, apiSpecEntity.APISpecFormat, apiSpecEntity.APISpecType, apiSpecEntity.EventSpecFormat, apiSpecEntity.EventSpecType, apiSpecEntity.ID, tenant}, 749 ValidResult: sqlmock.NewResult(-1, 1), 750 InvalidResult: sqlmock.NewResult(-1, 0), 751 }, 752 }, 753 ConverterMockProvider: func() testdb.Mock { 754 return &automock.Converter{} 755 }, 756 RepoConstructorFunc: spec.NewRepository, 757 ModelEntity: apiSpecModel, 758 DBEntity: apiSpecEntity, 759 NilModelEntity: nilSpecModel, 760 TenantID: tenant, 761 DisableConverterErrorTest: true, 762 } 763 764 eventSpecSuite := testdb.RepoUpdateTestSuite{ 765 Name: "Update Event Spec", 766 SQLQueryDetails: []testdb.SQLQueryDetails{ 767 { 768 Query: regexp.QuoteMeta(`UPDATE public.specifications SET spec_data = ?, api_spec_format = ?, api_spec_type = ?, event_spec_format = ?, event_spec_type = ? WHERE id = ? AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = ? AND owner = true))`), 769 Args: []driver.Value{eventSpecEntity.SpecData, eventSpecEntity.APISpecFormat, eventSpecEntity.APISpecType, eventSpecEntity.EventSpecFormat, eventSpecEntity.EventSpecType, eventSpecEntity.ID, tenant}, 770 ValidResult: sqlmock.NewResult(-1, 1), 771 InvalidResult: sqlmock.NewResult(-1, 0), 772 }, 773 }, 774 ConverterMockProvider: func() testdb.Mock { 775 return &automock.Converter{} 776 }, 777 RepoConstructorFunc: spec.NewRepository, 778 ModelEntity: eventSpecModel, 779 DBEntity: eventSpecEntity, 780 NilModelEntity: nilSpecModel, 781 TenantID: tenant, 782 DisableConverterErrorTest: true, 783 } 784 785 apiSpecSuite.Run(t) 786 eventSpecSuite.Run(t) 787 } 788 789 func TestRepository_UpdateGlobal(t *testing.T) { 790 var nilSpecModel *model.Spec 791 apiSpecModel := fixModelAPISpec() 792 apiSpecEntity := fixAPISpecEntity() 793 eventSpecModel := fixModelEventSpec() 794 eventSpecEntity := fixEventSpecEntity() 795 796 apiSpecSuite := testdb.RepoUpdateTestSuite{ 797 Name: "Update API Spec", 798 SQLQueryDetails: []testdb.SQLQueryDetails{ 799 { 800 Query: regexp.QuoteMeta(`UPDATE public.specifications SET spec_data = ?, api_spec_format = ?, api_spec_type = ?, event_spec_format = ?, event_spec_type = ? WHERE id = ?`), 801 Args: []driver.Value{apiSpecEntity.SpecData, apiSpecEntity.APISpecFormat, apiSpecEntity.APISpecType, apiSpecEntity.EventSpecFormat, apiSpecEntity.EventSpecType, apiSpecEntity.ID}, 802 ValidResult: sqlmock.NewResult(-1, 1), 803 InvalidResult: sqlmock.NewResult(-1, 0), 804 }, 805 }, 806 ConverterMockProvider: func() testdb.Mock { 807 return &automock.Converter{} 808 }, 809 RepoConstructorFunc: spec.NewRepository, 810 ModelEntity: apiSpecModel, 811 DBEntity: apiSpecEntity, 812 NilModelEntity: nilSpecModel, 813 DisableConverterErrorTest: true, 814 IsGlobal: true, 815 UpdateMethodName: "UpdateGlobal", 816 } 817 818 eventSpecSuite := testdb.RepoUpdateTestSuite{ 819 Name: "Update Event Spec", 820 SQLQueryDetails: []testdb.SQLQueryDetails{ 821 { 822 Query: regexp.QuoteMeta(`UPDATE public.specifications SET spec_data = ?, api_spec_format = ?, api_spec_type = ?, event_spec_format = ?, event_spec_type = ? WHERE id = ?`), 823 Args: []driver.Value{eventSpecEntity.SpecData, eventSpecEntity.APISpecFormat, eventSpecEntity.APISpecType, eventSpecEntity.EventSpecFormat, eventSpecEntity.EventSpecType, eventSpecEntity.ID}, 824 ValidResult: sqlmock.NewResult(-1, 1), 825 InvalidResult: sqlmock.NewResult(-1, 0), 826 }, 827 }, 828 ConverterMockProvider: func() testdb.Mock { 829 return &automock.Converter{} 830 }, 831 RepoConstructorFunc: spec.NewRepository, 832 ModelEntity: eventSpecModel, 833 DBEntity: eventSpecEntity, 834 NilModelEntity: nilSpecModel, 835 DisableConverterErrorTest: true, 836 IsGlobal: true, 837 UpdateMethodName: "UpdateGlobal", 838 } 839 840 apiSpecSuite.Run(t) 841 eventSpecSuite.Run(t) 842 } 843 844 func TestRepository_Exists(t *testing.T) { 845 apiSpecSuite := testdb.RepoExistTestSuite{ 846 Name: "API Specification Exists", 847 SQLQueryDetails: []testdb.SQLQueryDetails{ 848 { 849 Query: regexp.QuoteMeta(`SELECT 1 FROM public.specifications WHERE id = $1 AND (id IN (SELECT id FROM api_specifications_tenants WHERE tenant_id = $2))`), 850 Args: []driver.Value{specID, tenant}, 851 IsSelect: true, 852 ValidRowsProvider: func() []*sqlmock.Rows { 853 return []*sqlmock.Rows{testdb.RowWhenObjectExist()} 854 }, 855 InvalidRowsProvider: func() []*sqlmock.Rows { 856 return []*sqlmock.Rows{testdb.RowWhenObjectDoesNotExist()} 857 }, 858 }, 859 }, 860 ConverterMockProvider: func() testdb.Mock { 861 return &automock.Converter{} 862 }, 863 RepoConstructorFunc: spec.NewRepository, 864 TargetID: specID, 865 TenantID: tenant, 866 RefEntity: model.APISpecReference, 867 MethodName: "Exists", 868 MethodArgs: []interface{}{tenant, specID, model.APISpecReference}, 869 } 870 871 eventSpecSuite := testdb.RepoExistTestSuite{ 872 Name: "Event Specification Exists", 873 SQLQueryDetails: []testdb.SQLQueryDetails{ 874 { 875 Query: regexp.QuoteMeta(`SELECT 1 FROM public.specifications WHERE id = $1 AND (id IN (SELECT id FROM event_specifications_tenants WHERE tenant_id = $2))`), 876 Args: []driver.Value{specID, tenant}, 877 IsSelect: true, 878 ValidRowsProvider: func() []*sqlmock.Rows { 879 return []*sqlmock.Rows{testdb.RowWhenObjectExist()} 880 }, 881 InvalidRowsProvider: func() []*sqlmock.Rows { 882 return []*sqlmock.Rows{testdb.RowWhenObjectDoesNotExist()} 883 }, 884 }, 885 }, 886 ConverterMockProvider: func() testdb.Mock { 887 return &automock.Converter{} 888 }, 889 RepoConstructorFunc: spec.NewRepository, 890 TargetID: specID, 891 TenantID: tenant, 892 RefEntity: model.EventSpecReference, 893 MethodName: "Exists", 894 MethodArgs: []interface{}{tenant, specID, model.EventSpecReference}, 895 } 896 897 apiSpecSuite.Run(t) 898 eventSpecSuite.Run(t) 899 }