yosql-models/yosql-models-immutables/src/test/java/wtf/metio/yosql/models/immutables/SqlConfigurationTest.java

   1 /*
   2  * This file is part of yosql. It is subject to the license terms in the LICENSE file found in the top-level
   3  * directory of this distribution and at https://creativecommons.org/publicdomain/zero/1.0/. No part of yosql,
   4  * including this file, may be copied, modified, propagated, or distributed except according to the terms contained
   5  * in the LICENSE file.
   6  */
   7
   8 package wtf.metio.yosql.models.immutables;
   9
  10 import org.junit.jupiter.api.Assertions;
  11 import org.junit.jupiter.api.DisplayName;
  12 import org.junit.jupiter.api.Test;
  13 import wtf.metio.yosql.models.configuration.*;
  14
  15 import java.util.List;
  16
  17 @DisplayName("SqlConfiguration")
  18 class SqlConfigurationTest {
  19
  20     @Test
  21     void fromStatements() {
  22         // TODO: write test that ensures that the name of a SqlStatement is transferred to its SqlConfiguration(s)
  23     }
  24
  25     @Test
  26     void mergeRepositoryFirst() {
  27         final var first = SqlConfiguration.usingDefaults()
  28                 .setRepository("com.example.Repository")
  29                 .build();
  30         final var second = SqlConfiguration.usingDefaults().build();
  31
  32         final var merged = SqlConfiguration.merge(first, second);
  33
  34         Assertions.assertEquals(first.repository(), merged.repository());
  35     }
  36
  37     @Test
  38     void mergeRepositorySecond() {
  39         final var first = SqlConfiguration.usingDefaults().build();
  40         final var second = SqlConfiguration.usingDefaults()
  41                 .setRepository("com.example.Repository")
  42                 .build();
  43
  44         final var merged = SqlConfiguration.merge(first, second);
  45
  46         Assertions.assertEquals(second.repository(), merged.repository());
  47     }
  48
  49     @Test
  50     void mergeRepositoryMissing() {
  51         final var first = SqlConfiguration.usingDefaults().build();
  52         final var second = SqlConfiguration.usingDefaults().build();
  53
  54         final var merged = SqlConfiguration.merge(first, second);
  55
  56         Assertions.assertTrue(merged.repository().isEmpty());
  57     }
  58
  59     @Test
  60     void mergeRepositoryInterfaceFirst() {
  61         final var first = SqlConfiguration.usingDefaults()
  62                 .setRepositoryInterface("com.example.Repository")
  63                 .build();
  64         final var second = SqlConfiguration.usingDefaults().build();
  65
  66         final var merged = SqlConfiguration.merge(first, second);
  67
  68         Assertions.assertEquals(first.repositoryInterface(), merged.repositoryInterface());
  69     }
  70
  71     @Test
  72     void mergeRepositoryInterfaceSecond() {
  73         final var first = SqlConfiguration.usingDefaults().build();
  74         final var second = SqlConfiguration.usingDefaults()
  75                 .setRepositoryInterface("com.example.Repository")
  76                 .build();
  77
  78         final var merged = SqlConfiguration.merge(first, second);
  79
  80         Assertions.assertEquals(second.repositoryInterface(), merged.repositoryInterface());
  81     }
  82
  83     @Test
  84     void mergeRepositoryInterfaceMissing() {
  85         final var first = SqlConfiguration.usingDefaults().build();
  86         final var second = SqlConfiguration.usingDefaults().build();
  87
  88         final var merged = SqlConfiguration.merge(first, second);
  89
  90         Assertions.assertTrue(merged.repositoryInterface().isEmpty());
  91     }
  92
  93     @Test
  94     void mergeNameFirst() {
  95         final var first = SqlConfiguration.usingDefaults()
  96                 .setName("name")
  97                 .build();
  98         final var second = SqlConfiguration.usingDefaults().build();
  99
 100         final var merged = SqlConfiguration.merge(first, second);
 101
 102         Assertions.assertEquals(first.name(), merged.name());
 103     }
 104
 105     @Test
 106     void mergeNameSecond() {
 107         final var first = SqlConfiguration.usingDefaults().build();
 108         final var second = SqlConfiguration.usingDefaults()
 109                 .setName("name")
 110                 .build();
 111
 112         final var merged = SqlConfiguration.merge(first, second);
 113
 114         Assertions.assertEquals(second.name(), merged.name());
 115     }
 116
 117     @Test
 118     void mergeNameMissing() {
 119         final var first = SqlConfiguration.usingDefaults().build();
 120         final var second = SqlConfiguration.usingDefaults().build();
 121
 122         final var merged = SqlConfiguration.merge(first, second);
 123
 124         Assertions.assertTrue(merged.name().isEmpty());
 125     }
 126
 127     @Test
 128     void mergeDescriptionFirst() {
 129         final var first = SqlConfiguration.usingDefaults()
 130                 .setDescription("some description")
 131                 .build();
 132         final var second = SqlConfiguration.usingDefaults().build();
 133
 134         final var merged = SqlConfiguration.merge(first, second);
 135
 136         Assertions.assertEquals(first.description(), merged.description());
 137     }
 138
 139     @Test
 140     void mergeDescriptionSecond() {
 141         final var first = SqlConfiguration.usingDefaults().build();
 142         final var second = SqlConfiguration.usingDefaults()
 143                 .setDescription("some description")
 144                 .build();
 145
 146         final var merged = SqlConfiguration.merge(first, second);
 147
 148         Assertions.assertEquals(second.description(), merged.description());
 149     }
 150
 151     @Test
 152     void mergeDescriptionMissing() {
 153         final var first = SqlConfiguration.usingDefaults().build();
 154         final var second = SqlConfiguration.usingDefaults().build();
 155
 156         final var merged = SqlConfiguration.merge(first, second);
 157
 158         Assertions.assertTrue(merged.description().isEmpty());
 159     }
 160
 161     @Test
 162     void mergeVendorFirst() {
 163         final var first = SqlConfiguration.usingDefaults()
 164                 .setVendor("H2 Database")
 165                 .build();
 166         final var second = SqlConfiguration.usingDefaults().build();
 167
 168         final var merged = SqlConfiguration.merge(first, second);
 169
 170         Assertions.assertEquals(first.vendor(), merged.vendor());
 171     }
 172
 173     @Test
 174     void mergeVendorSecond() {
 175         final var first = SqlConfiguration.usingDefaults().build();
 176         final var second = SqlConfiguration.usingDefaults()
 177                 .setVendor("H2 Database")
 178                 .build();
 179
 180         final var merged = SqlConfiguration.merge(first, second);
 181
 182         Assertions.assertEquals(second.vendor(), merged.vendor());
 183     }
 184
 185     @Test
 186     void mergeVendorMissing() {
 187         final var first = SqlConfiguration.usingDefaults().build();
 188         final var second = SqlConfiguration.usingDefaults().build();
 189
 190         final var merged = SqlConfiguration.merge(first, second);
 191
 192         Assertions.assertTrue(merged.vendor().isEmpty());
 193     }
 194
 195     @Test
 196     void mergeTypeFirst() {
 197         final var first = SqlConfiguration.usingDefaults()
 198                 .setType(SqlStatementType.READING)
 199                 .build();
 200         final var second = SqlConfiguration.usingDefaults().build();
 201
 202         final var merged = SqlConfiguration.merge(first, second);
 203
 204         Assertions.assertEquals(first.type(), merged.type());
 205     }
 206
 207     @Test
 208     void mergeTypeSecond() {
 209         final var first = SqlConfiguration.usingDefaults().build();
 210         final var second = SqlConfiguration.usingDefaults()
 211                 .setType(SqlStatementType.READING)
 212                 .build();
 213
 214         final var merged = SqlConfiguration.merge(first, second);
 215
 216         Assertions.assertEquals(second.type(), merged.type());
 217     }
 218
 219     @Test
 220     void mergeTypeMissing() {
 221         final var first = SqlConfiguration.usingDefaults().build();
 222         final var second = SqlConfiguration.usingDefaults().build();
 223
 224         final var merged = SqlConfiguration.merge(first, second);
 225
 226         Assertions.assertTrue(merged.type().isEmpty());
 227     }
 228
 229     @Test
 230     void mergeReturningModeFirst() {
 231         final var first = SqlConfiguration.usingDefaults()
 232                 .setReturningMode(ReturningMode.SINGLE)
 233                 .build();
 234         final var second = SqlConfiguration.usingDefaults().build();
 235
 236         final var merged = SqlConfiguration.merge(first, second);
 237
 238         Assertions.assertEquals(first.returningMode(), merged.returningMode());
 239     }
 240
 241     @Test
 242     void mergeReturningModeSecond() {
 243         final var first = SqlConfiguration.usingDefaults().build();
 244         final var second = SqlConfiguration.usingDefaults()
 245                 .setReturningMode(ReturningMode.SINGLE)
 246                 .build();
 247
 248         final var merged = SqlConfiguration.merge(first, second);
 249
 250         Assertions.assertEquals(second.returningMode(), merged.returningMode());
 251     }
 252
 253     @Test
 254     void mergeReturningModeMissing() {
 255         final var first = SqlConfiguration.usingDefaults().build();
 256         final var second = SqlConfiguration.usingDefaults().build();
 257
 258         final var merged = SqlConfiguration.merge(first, second);
 259
 260         Assertions.assertTrue(merged.returningMode().isEmpty());
 261     }
 262
 263     @Test
 264     void mergeStandardPrefixFirst() {
 265         final var first = SqlConfiguration.usingDefaults()
 266                 .setStandardPrefix("prefix")
 267                 .build();
 268         final var second = SqlConfiguration.usingDefaults().build();
 269
 270         final var merged = SqlConfiguration.merge(first, second);
 271
 272         Assertions.assertEquals(first.standardPrefix(), merged.standardPrefix());
 273     }
 274
 275     @Test
 276     void mergeStandardPrefixSecond() {
 277         final var first = SqlConfiguration.usingDefaults().build();
 278         final var second = SqlConfiguration.usingDefaults()
 279                 .setStandardPrefix("prefix")
 280                 .build();
 281
 282         final var merged = SqlConfiguration.merge(first, second);
 283
 284         Assertions.assertEquals(second.standardPrefix(), merged.standardPrefix());
 285     }
 286
 287     @Test
 288     void mergeStandardPrefixMissing() {
 289         final var first = SqlConfiguration.usingDefaults().build();
 290         final var second = SqlConfiguration.usingDefaults().build();
 291
 292         final var merged = SqlConfiguration.merge(first, second);
 293
 294         Assertions.assertTrue(merged.standardPrefix().isEmpty());
 295     }
 296
 297     @Test
 298     void mergeStandardSuffixFirst() {
 299         final var first = SqlConfiguration.usingDefaults()
 300                 .setStandardSuffix("suffix")
 301                 .build();
 302         final var second = SqlConfiguration.usingDefaults().build();
 303
 304         final var merged = SqlConfiguration.merge(first, second);
 305
 306         Assertions.assertEquals(first.standardSuffix(), merged.standardSuffix());
 307     }
 308
 309     @Test
 310     void mergeStandardSuffixSecond() {
 311         final var first = SqlConfiguration.usingDefaults().build();
 312         final var second = SqlConfiguration.usingDefaults()
 313                 .setStandardSuffix("suffix")
 314                 .build();
 315
 316         final var merged = SqlConfiguration.merge(first, second);
 317
 318         Assertions.assertEquals(second.standardSuffix(), merged.standardSuffix());
 319     }
 320
 321     @Test
 322     void mergeStandardSuffixMissing() {
 323         final var first = SqlConfiguration.usingDefaults().build();
 324         final var second = SqlConfiguration.usingDefaults().build();
 325
 326         final var merged = SqlConfiguration.merge(first, second);
 327
 328         Assertions.assertTrue(merged.standardSuffix().isEmpty());
 329     }
 330
 331     @Test
 332     void mergeBatchPrefixFirst() {
 333         final var first = SqlConfiguration.usingDefaults()
 334                 .setBatchPrefix("prefix")
 335                 .build();
 336         final var second = SqlConfiguration.usingDefaults().build();
 337
 338         final var merged = SqlConfiguration.merge(first, second);
 339
 340         Assertions.assertEquals(first.batchPrefix(), merged.batchPrefix());
 341     }
 342
 343     @Test
 344     void mergeBatchPrefixSecond() {
 345         final var first = SqlConfiguration.usingDefaults().build();
 346         final var second = SqlConfiguration.usingDefaults()
 347                 .setBatchPrefix("prefix")
 348                 .build();
 349
 350         final var merged = SqlConfiguration.merge(first, second);
 351
 352         Assertions.assertEquals(second.batchPrefix(), merged.batchPrefix());
 353     }
 354
 355     @Test
 356     void mergeBatchPrefixMissing() {
 357         final var first = SqlConfiguration.usingDefaults().build();
 358         final var second = SqlConfiguration.usingDefaults().build();
 359
 360         final var merged = SqlConfiguration.merge(first, second);
 361
 362         Assertions.assertTrue(merged.batchPrefix().isEmpty());
 363     }
 364
 365     @Test
 366     void mergeBatchSuffixFirst() {
 367         final var first = SqlConfiguration.usingDefaults()
 368                 .setBatchSuffix("suffix")
 369                 .build();
 370         final var second = SqlConfiguration.usingDefaults().build();
 371
 372         final var merged = SqlConfiguration.merge(first, second);
 373
 374         Assertions.assertEquals(first.batchSuffix(), merged.batchSuffix());
 375     }
 376
 377     @Test
 378     void mergeBatchSuffixSecond() {
 379         final var first = SqlConfiguration.usingDefaults().build();
 380         final var second = SqlConfiguration.usingDefaults()
 381                 .setBatchSuffix("suffix")
 382                 .build();
 383
 384         final var merged = SqlConfiguration.merge(first, second);
 385
 386         Assertions.assertEquals(second.batchSuffix(), merged.batchSuffix());
 387     }
 388
 389     @Test
 390     void mergeBatchSuffixMissing() {
 391         final var first = SqlConfiguration.usingDefaults().build();
 392         final var second = SqlConfiguration.usingDefaults().build();
 393
 394         final var merged = SqlConfiguration.merge(first, second);
 395
 396         Assertions.assertTrue(merged.batchSuffix().isEmpty());
 397     }
 398
 399     @Test
 400     void mergeGenerateStandardApiFirst() {
 401         final var first = SqlConfiguration.usingDefaults()
 402                 .setGenerateStandardApi(true)
 403                 .build();
 404         final var second = SqlConfiguration.usingDefaults().build();
 405
 406         final var merged = SqlConfiguration.merge(first, second);
 407
 408         Assertions.assertEquals(first.generateStandardApi(), merged.generateStandardApi());
 409     }
 410
 411     @Test
 412     void mergeGenerateStandardApiSecond() {
 413         final var first = SqlConfiguration.usingDefaults().build();
 414         final var second = SqlConfiguration.usingDefaults()
 415                 .setGenerateStandardApi(true)
 416                 .build();
 417
 418         final var merged = SqlConfiguration.merge(first, second);
 419
 420         Assertions.assertEquals(second.generateStandardApi(), merged.generateStandardApi());
 421     }
 422
 423     @Test
 424     void mergeGenerateStandardApiMissing() {
 425         final var first = SqlConfiguration.usingDefaults().build();
 426         final var second = SqlConfiguration.usingDefaults().build();
 427
 428         final var merged = SqlConfiguration.merge(first, second);
 429
 430         Assertions.assertTrue(merged.generateStandardApi().isEmpty());
 431     }
 432
 433     @Test
 434     void mergeGenerateBatchApiFirst() {
 435         final var first = SqlConfiguration.usingDefaults()
 436                 .setGenerateBatchApi(true)
 437                 .build();
 438         final var second = SqlConfiguration.usingDefaults().build();
 439
 440         final var merged = SqlConfiguration.merge(first, second);
 441
 442         Assertions.assertEquals(first.generateBatchApi(), merged.generateBatchApi());
 443     }
 444
 445     @Test
 446     void mergeGenerateBatchApiSecond() {
 447         final var first = SqlConfiguration.usingDefaults().build();
 448         final var second = SqlConfiguration.usingDefaults()
 449                 .setGenerateBatchApi(true)
 450                 .build();
 451
 452         final var merged = SqlConfiguration.merge(first, second);
 453
 454         Assertions.assertEquals(second.generateBatchApi(), merged.generateBatchApi());
 455     }
 456
 457     @Test
 458     void mergeGenerateBatchApiMissing() {
 459         final var first = SqlConfiguration.usingDefaults().build();
 460         final var second = SqlConfiguration.usingDefaults().build();
 461
 462         final var merged = SqlConfiguration.merge(first, second);
 463
 464         Assertions.assertTrue(merged.generateStandardApi().isEmpty());
 465     }
 466
 467     @Test
 468     void mergeUsePreparedStatementFirst() {
 469         final var first = SqlConfiguration.usingDefaults()
 470                 .setUsePreparedStatement(true)
 471                 .build();
 472         final var second = SqlConfiguration.usingDefaults().build();
 473
 474         final var merged = SqlConfiguration.merge(first, second);
 475
 476         Assertions.assertEquals(first.usePreparedStatement(), merged.usePreparedStatement());
 477     }
 478
 479     @Test
 480     void mergeUsePreparedStatementSecond() {
 481         final var first = SqlConfiguration.usingDefaults().build();
 482         final var second = SqlConfiguration.usingDefaults()
 483                 .setUsePreparedStatement(true)
 484                 .build();
 485
 486         final var merged = SqlConfiguration.merge(first, second);
 487
 488         Assertions.assertEquals(second.usePreparedStatement(), merged.usePreparedStatement());
 489     }
 490
 491     @Test
 492     void mergeUsePreparedStatementMissing() {
 493         final var first = SqlConfiguration.usingDefaults().build();
 494         final var second = SqlConfiguration.usingDefaults().build();
 495
 496         final var merged = SqlConfiguration.merge(first, second);
 497
 498         Assertions.assertTrue(merged.usePreparedStatement().isEmpty());
 499     }
 500
 501     @Test
 502     void mergeCatchAndRethrowFirst() {
 503         final var first = SqlConfiguration.usingDefaults()
 504                 .setCatchAndRethrow(true)
 505                 .build();
 506         final var second = SqlConfiguration.usingDefaults().build();
 507
 508         final var merged = SqlConfiguration.merge(first, second);
 509
 510         Assertions.assertEquals(first.catchAndRethrow(), merged.catchAndRethrow());
 511     }
 512
 513     @Test
 514     void mergeCatchAndRethrowSecond() {
 515         final var first = SqlConfiguration.usingDefaults().build();
 516         final var second = SqlConfiguration.usingDefaults()
 517                 .setCatchAndRethrow(true)
 518                 .build();
 519
 520         final var merged = SqlConfiguration.merge(first, second);
 521
 522         Assertions.assertEquals(second.catchAndRethrow(), merged.catchAndRethrow());
 523     }
 524
 525     @Test
 526     void mergeCatchAndRethrowMissing() {
 527         final var first = SqlConfiguration.usingDefaults().build();
 528         final var second = SqlConfiguration.usingDefaults().build();
 529
 530         final var merged = SqlConfiguration.merge(first, second);
 531
 532         Assertions.assertTrue(merged.catchAndRethrow().isEmpty());
 533     }
 534
 535     @Test
 536     void mergeThrowOnMultipleResultsForSingleFirst() {
 537         final var first = SqlConfiguration.usingDefaults()
 538                 .setThrowOnMultipleResultsForSingle(true)
 539                 .build();
 540         final var second = SqlConfiguration.usingDefaults().build();
 541
 542         final var merged = SqlConfiguration.merge(first, second);
 543
 544         Assertions.assertEquals(first.throwOnMultipleResultsForSingle(), merged.throwOnMultipleResultsForSingle());
 545     }
 546
 547     @Test
 548     void mergeThrowOnMultipleResultsForSingleSecond() {
 549         final var first = SqlConfiguration.usingDefaults().build();
 550         final var second = SqlConfiguration.usingDefaults()
 551                 .setThrowOnMultipleResultsForSingle(true)
 552                 .build();
 553
 554         final var merged = SqlConfiguration.merge(first, second);
 555
 556         Assertions.assertEquals(second.throwOnMultipleResultsForSingle(), merged.throwOnMultipleResultsForSingle());
 557     }
 558
 559     @Test
 560     void mergeThrowOnMultipleResultsForSingleMissing() {
 561         final var first = SqlConfiguration.usingDefaults().build();
 562         final var second = SqlConfiguration.usingDefaults().build();
 563
 564         final var merged = SqlConfiguration.merge(first, second);
 565
 566         Assertions.assertTrue(merged.throwOnMultipleResultsForSingle().isEmpty());
 567     }
 568
 569     @Test
 570     void mergeInjectConvertersFirst() {
 571         final var first = SqlConfiguration.usingDefaults()
 572                 .setInjectConverters(true)
 573                 .build();
 574         final var second = SqlConfiguration.usingDefaults().build();
 575
 576         final var merged = SqlConfiguration.merge(first, second);
 577
 578         Assertions.assertEquals(first.injectConverters(), merged.injectConverters());
 579     }
 580
 581     @Test
 582     void mergeInjectConvertersSecond() {
 583         final var first = SqlConfiguration.usingDefaults().build();
 584         final var second = SqlConfiguration.usingDefaults()
 585                 .setInjectConverters(true)
 586                 .build();
 587
 588         final var merged = SqlConfiguration.merge(first, second);
 589
 590         Assertions.assertEquals(second.injectConverters(), merged.injectConverters());
 591     }
 592
 593     @Test
 594     void mergeInjectConvertersMissing() {
 595         final var first = SqlConfiguration.usingDefaults().build();
 596         final var second = SqlConfiguration.usingDefaults().build();
 597
 598         final var merged = SqlConfiguration.merge(first, second);
 599
 600         Assertions.assertTrue(merged.injectConverters().isEmpty());
 601     }
 602
 603     @Test
 604     void mergeResultRowConverterFirst() {
 605         final var first = SqlConfiguration.usingDefaults()
 606                 .setResultRowConverter(ResultRowConverter.builder().build())
 607                 .build();
 608         final var second = SqlConfiguration.usingDefaults().build();
 609
 610         final var merged = SqlConfiguration.merge(first, second);
 611
 612         Assertions.assertEquals(first.resultRowConverter(), merged.resultRowConverter());
 613     }
 614
 615     @Test
 616     void mergeResultRowConverterSecond() {
 617         final var first = SqlConfiguration.usingDefaults().build();
 618         final var second = SqlConfiguration.usingDefaults()
 619                 .setResultRowConverter(ResultRowConverter.builder().build())
 620                 .build();
 621
 622         final var merged = SqlConfiguration.merge(first, second);
 623
 624         Assertions.assertEquals(second.resultRowConverter(), merged.resultRowConverter());
 625     }
 626
 627     @Test
 628     void mergeResultRowConverterMissing() {
 629         final var first = SqlConfiguration.usingDefaults().build();
 630         final var second = SqlConfiguration.usingDefaults().build();
 631
 632         final var merged = SqlConfiguration.merge(first, second);
 633
 634         Assertions.assertTrue(merged.resultRowConverter().isEmpty());
 635     }
 636
 637     @Test
 638     void mergeParametersFirst() {
 639         final var first = SqlConfiguration.usingDefaults()
 640                 .setParameters(List.of(SqlParameter.builder().setName("first").build()))
 641                 .build();
 642         final var second = SqlConfiguration.usingDefaults().build();
 643
 644         final var merged = SqlConfiguration.merge(first, second);
 645
 646         Assertions.assertEquals(first.parameters(), merged.parameters());
 647     }
 648
 649     @Test
 650     void mergeParametersSecond() {
 651         final var first = SqlConfiguration.usingDefaults().build();
 652         final var second = SqlConfiguration.usingDefaults()
 653                 .setParameters(List.of(SqlParameter.builder().setName("second").build()))
 654                 .build();
 655
 656         final var merged = SqlConfiguration.merge(first, second);
 657
 658         Assertions.assertEquals(second.parameters(), merged.parameters());
 659     }
 660
 661     @Test
 662     void mergeParametersMixed() {
 663         final var parameters = List.of(
 664                 SqlParameter.builder().setName("first").build(),
 665                 SqlParameter.builder().setName("second").build());
 666         final var first = SqlConfiguration.usingDefaults()
 667                 .setParameters(List.of(parameters.get(0)))
 668                 .build();
 669         final var second = SqlConfiguration.usingDefaults()
 670                 .setParameters(List.of(parameters.get(1)))
 671                 .build();
 672
 673         final var merged = SqlConfiguration.merge(first, second);
 674
 675         Assertions.assertEquals(parameters, merged.parameters());
 676     }
 677
 678     @Test
 679     void mergeParametersMixedDuplicatedFirst() {
 680         final List<SqlParameter> parameters = List.of(
 681                 SqlParameter.builder().setName("first").build(),
 682                 SqlParameter.builder().setName("second").build());
 683         final var first = SqlConfiguration.usingDefaults()
 684                 .setParameters(parameters)
 685                 .build();
 686         final var second = SqlConfiguration.usingDefaults()
 687                 .setParameters(List.of(SqlParameter.builder().setName("second").build()))
 688                 .build();
 689
 690         final var merged = SqlConfiguration.merge(first, second);
 691
 692         Assertions.assertEquals(parameters, merged.parameters());
 693     }
 694
 695     @Test
 696     void mergeParametersMixedDuplicatedSecond() {
 697         final List<SqlParameter> parameters = List.of(
 698                 SqlParameter.builder().setName("first").build(),
 699                 SqlParameter.builder().setName("second").build());
 700         final var first = SqlConfiguration.usingDefaults()
 701                 .setParameters(List.of(SqlParameter.builder().setName("first").build()))
 702                 .build();
 703         final var second = SqlConfiguration.usingDefaults()
 704                 .setParameters(parameters)
 705                 .build();
 706
 707         final var merged = SqlConfiguration.merge(first, second);
 708
 709         Assertions.assertEquals(parameters, merged.parameters());
 710     }
 711
 712     @Test
 713     void mergeParametersDuplicated() {
 714         final var first = SqlConfiguration.usingDefaults()
 715                 .setParameters(List.of(SqlParameter.builder()
 716                         .setName("name")
 717                         .setType("java.lang.String")
 718                         .setIndices(new int[]{1})
 719                         .build()))
 720                 .build();
 721         final var second = SqlConfiguration.usingDefaults()
 722                 .setParameters(List.of(SqlParameter.builder()
 723                         .setName("name")
 724                         .setType("java.lang.String")
 725                         .setIndices(new int[]{1})
 726                         .build()))
 727                 .build();
 728
 729         final var merged = SqlConfiguration.merge(first, second);
 730
 731         Assertions.assertEquals(1, merged.parameters().size());
 732         Assertions.assertEquals("name", merged.parameters().get(0).name().orElse(""));
 733         Assertions.assertEquals("java.lang.String", merged.parameters().get(0).type().orElse(""));
 734     }
 735
 736     @Test
 737     void mergeParametersDuplicatedNamesMissingTypeFirst() {
 738         final var first = SqlConfiguration.usingDefaults()
 739                 .setParameters(List.of(SqlParameter.builder()
 740                         .setName("name")
 741                         .setIndices(new int[]{1})
 742                         .build()))
 743                 .build();
 744         final var second = SqlConfiguration.usingDefaults()
 745                 .setParameters(List.of(SqlParameter.builder()
 746                         .setName("name")
 747                         .setType("java.lang.String")
 748                         .setIndices(new int[]{1})
 749                         .build()))
 750                 .build();
 751
 752         final var merged = SqlConfiguration.merge(first, second);
 753
 754         Assertions.assertEquals(1, merged.parameters().size());
 755         Assertions.assertEquals("name", merged.parameters().get(0).name().orElse(""));
 756         Assertions.assertEquals("java.lang.String", merged.parameters().get(0).type().orElse(""));
 757     }
 758
 759     @Test
 760     void mergeParametersDuplicatedNamesMissingTypeSecond() {
 761         final var first = SqlConfiguration.usingDefaults()
 762                 .setParameters(List.of(SqlParameter.builder()
 763                         .setName("name")
 764                         .setType("java.lang.String")
 765                         .setIndices(new int[]{1})
 766                         .build()))
 767                 .build();
 768         final var second = SqlConfiguration.usingDefaults()
 769                 .setParameters(List.of(SqlParameter.builder()
 770                         .setName("name")
 771                         .setIndices(new int[]{1})
 772                         .build()))
 773                 .build();
 774
 775         final var merged = SqlConfiguration.merge(first, second);
 776
 777         Assertions.assertEquals(1, merged.parameters().size());
 778         Assertions.assertEquals("name", merged.parameters().get(0).name().orElse(""));
 779         Assertions.assertEquals("java.lang.String", merged.parameters().get(0).type().orElse(""));
 780     }
 781
 782     @Test
 783     void mergeParametersMissing() {
 784         final var first = SqlConfiguration.usingDefaults().build();
 785         final var second = SqlConfiguration.usingDefaults().build();
 786
 787         final var merged = SqlConfiguration.merge(first, second);
 788
 789         Assertions.assertTrue(merged.parameters().isEmpty());
 790     }
 791
 792     @Test
 793     void mergeAnnotationsMissing() {
 794         final var first = SqlConfiguration.usingDefaults().build();
 795         final var second = SqlConfiguration.usingDefaults().build();
 796
 797         final var merged = SqlConfiguration.merge(first, second);
 798
 799         Assertions.assertTrue(merged.annotations().isEmpty());
 800     }
 801
 802     @Test
 803     void mergeAnnotationsFirst() {
 804         final var first = SqlConfiguration.usingDefaults()
 805                 .setAnnotations(List.of(Annotation.builder().setType("com.example.MyAnnotation").build()))
 806                 .build();
 807         final var second = SqlConfiguration.usingDefaults().build();
 808
 809         final var merged = SqlConfiguration.merge(first, second);
 810
 811         Assertions.assertEquals(first.annotations(), merged.annotations());
 812     }
 813
 814     @Test
 815     void mergeAnnotationsSecond() {
 816         final var first = SqlConfiguration.usingDefaults()
 817                 .build();
 818         final var second = SqlConfiguration.usingDefaults()
 819                 .setAnnotations(List.of(Annotation.builder().setType("com.example.MyAnnotation").build()))
 820                 .build();
 821
 822         final var merged = SqlConfiguration.merge(first, second);
 823
 824         Assertions.assertEquals(second.annotations(), merged.annotations());
 825     }
 826
 827 }