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