yosql-codegen/yosql-codegen-files/src/test/java/wtf/metio/yosql/codegen/files/DefaultMethodApiConfigurerTest.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.codegen.files;
   9
  10 import org.junit.jupiter.api.BeforeEach;
  11 import org.junit.jupiter.api.Test;
  12 import wtf.metio.yosql.models.constants.sql.SqlType;
  13 import wtf.metio.yosql.models.immutables.RepositoriesConfiguration;
  14 import wtf.metio.yosql.models.immutables.SqlConfiguration;
  15 import wtf.metio.yosql.testing.configs.RepositoriesConfigurations;
  16
  17 import static org.junit.jupiter.api.Assertions.*;
  18
  19 class DefaultMethodApiConfigurerTest {
  20
  21     private DefaultMethodApiConfigurer configurer;
  22     private RepositoriesConfiguration repositories;
  23
  24     @BeforeEach
  25     void setUp() {
  26         repositories = RepositoriesConfigurations.defaults();
  27         configurer = new DefaultMethodApiConfigurer(repositories);
  28     }
  29
  30     @Test
  31     void batchKeep() {
  32         final var original = SqlConfiguration.usingDefaults()
  33                 .setGenerateBatchApi(false)
  34                 .build();
  35         final var adapted = configurer.batch(original);
  36         assertEquals(original.generateBatchApi(), adapted.generateBatchApi());
  37     }
  38
  39     @Test
  40     void batchChangedToRepositoryDefault() {
  41         final var original = SqlConfiguration.usingDefaults()
  42                 // .setGenerateBatchApi(true) // value is NOT set
  43                 .build();
  44         final var adapted = configurer.batch(original);
  45         assertTrue(adapted.generateBatchApi().isPresent());
  46         assertEquals(repositories.generateBatchApi(), adapted.generateBatchApi().get());
  47     }
  48
  49     @Test
  50     void batchForcedDisabledForReads() {
  51         final var original = SqlConfiguration.usingDefaults()
  52                 .setGenerateBatchApi(true)
  53                 .setType(SqlType.READING)
  54                 .build();
  55         final var adapted = configurer.batch(original);
  56         assertTrue(adapted.generateBatchApi().isPresent());
  57         assertFalse(adapted.generateBatchApi().get());
  58     }
  59
  60     @Test
  61     void blockingKeep() {
  62         final var original = SqlConfiguration.usingDefaults()
  63                 .setGenerateBlockingApi(false)
  64                 .build();
  65         final var adapted = configurer.blocking(original);
  66         assertEquals(original.generateBlockingApi(), adapted.generateBlockingApi());
  67     }
  68
  69     @Test
  70     void blockingChangedToRepositoryDefault() {
  71         final var original = SqlConfiguration.usingDefaults()
  72                 // .setGenerateBlockingApi(true) // value is NOT set
  73                 .build();
  74         final var adapted = configurer.blocking(original);
  75         assertTrue(adapted.generateBlockingApi().isPresent());
  76         assertEquals(repositories.generateBlockingApi(), adapted.generateBlockingApi().get());
  77     }
  78
  79     @Test
  80     void mutinyKeep() {
  81         final var original = SqlConfiguration.usingDefaults()
  82                 .setGenerateMutinyApi(false)
  83                 .build();
  84         final var adapted = configurer.mutiny(original);
  85         assertEquals(original.generateMutinyApi(), adapted.generateMutinyApi());
  86     }
  87
  88     @Test
  89     void mutinyChangedToRepositoryDefault() {
  90         final var original = SqlConfiguration.usingDefaults()
  91                 // .setGenerateMutinyApi(true) // value is NOT set
  92                 .build();
  93         final var adapted = configurer.mutiny(original);
  94         assertTrue(adapted.generateMutinyApi().isPresent());
  95         assertEquals(repositories.generateMutinyApi(), adapted.generateMutinyApi().get());
  96     }
  97
  98     @Test
  99     void reactorKeep() {
 100         final var original = SqlConfiguration.usingDefaults()
 101                 .setGenerateReactorApi(false)
 102                 .build();
 103         final var adapted = configurer.reactor(original);
 104         assertEquals(original.generateReactorApi(), adapted.generateReactorApi());
 105     }
 106
 107     @Test
 108     void reactorChangedToRepositoryDefault() {
 109         final var original = SqlConfiguration.usingDefaults()
 110                 // .setGenerateReactorApi(true) // value is NOT set
 111                 .build();
 112         final var adapted = configurer.reactor(original);
 113         assertTrue(adapted.generateReactorApi().isPresent());
 114         assertEquals(repositories.generateReactorApi(), adapted.generateReactorApi().get());
 115     }
 116
 117     @Test
 118     void rxJavaKeep() {
 119         final var original = SqlConfiguration.usingDefaults()
 120                 .setGenerateRxJavaApi(false)
 121                 .build();
 122         final var adapted = configurer.rxJava(original);
 123         assertEquals(original.generateRxJavaApi(), adapted.generateRxJavaApi());
 124     }
 125
 126     @Test
 127     void rxJavaChangedToRepositoryDefault() {
 128         final var original = SqlConfiguration.usingDefaults()
 129                 // .setGenerateRxJavaApi(true) // value is NOT set
 130                 .build();
 131         final var adapted = configurer.rxJava(original);
 132         assertTrue(adapted.generateRxJavaApi().isPresent());
 133         assertEquals(repositories.generateRxJavaApi(), adapted.generateRxJavaApi().get());
 134     }
 135
 136     @Test
 137     void streamEagerKeep() {
 138         final var original = SqlConfiguration.usingDefaults()
 139                 .setGenerateStreamEagerApi(false)
 140                 .build();
 141         final var adapted = configurer.streamEager(original);
 142         assertEquals(original.generateStreamEagerApi(), adapted.generateStreamEagerApi());
 143     }
 144
 145     @Test
 146     void streamEagerForcedDisabledForWrites() {
 147         final var original = SqlConfiguration.usingDefaults()
 148                 .setGenerateStreamEagerApi(true)
 149                 .setType(SqlType.WRITING)
 150                 .build();
 151         final var adapted = configurer.streamEager(original);
 152         assertTrue(adapted.generateStreamEagerApi().isPresent());
 153         assertFalse(adapted.generateStreamEagerApi().get());
 154     }
 155
 156     @Test
 157     void streamEagerChangedToRepositoryDefault() {
 158         final var original = SqlConfiguration.usingDefaults()
 159                 // .setGenerateStreamEagerApi(true) // value is NOT set
 160                 .build();
 161         final var adapted = configurer.streamEager(original);
 162         assertTrue(adapted.generateStreamEagerApi().isPresent());
 163         assertEquals(repositories.generateStreamEagerApi(), adapted.generateStreamEagerApi().get());
 164     }
 165
 166     @Test
 167     void streamLazyKeep() {
 168         final var original = SqlConfiguration.usingDefaults()
 169                 .setGenerateStreamLazyApi(false)
 170                 .build();
 171         final var adapted = configurer.streamLazy(original);
 172         assertEquals(original.generateStreamLazyApi(), adapted.generateStreamLazyApi());
 173     }
 174
 175     @Test
 176     void streamLazyForcedDisabledForWrites() {
 177         final var original = SqlConfiguration.usingDefaults()
 178                 .setGenerateStreamLazyApi(true)
 179                 .setType(SqlType.WRITING)
 180                 .build();
 181         final var adapted = configurer.streamLazy(original);
 182         assertTrue(adapted.generateStreamLazyApi().isPresent());
 183         assertFalse(adapted.generateStreamLazyApi().get());
 184     }
 185
 186     @Test
 187     void streamLazyChangedToRepositoryDefault() {
 188         final var original = SqlConfiguration.usingDefaults()
 189                 // .setGenerateStreamLazyApi(true) // value is NOT set
 190                 .build();
 191         final var adapted = configurer.streamLazy(original);
 192         assertTrue(adapted.generateStreamLazyApi().isPresent());
 193         assertEquals(repositories.generateStreamLazyApi(), adapted.generateStreamLazyApi().get());
 194     }
 195
 196     @Test
 197     void keepApis() {
 198         final var original = SqlConfiguration.usingDefaults()
 199                 .setGenerateBatchApi(false)
 200                 .setGenerateBlockingApi(false)
 201                 .setGenerateMutinyApi(false)
 202                 .setGenerateReactorApi(false)
 203                 .setGenerateRxJavaApi(false)
 204                 .setGenerateStreamEagerApi(false)
 205                 .setGenerateStreamLazyApi(false)
 206                 .build();
 207         final var adapted = configurer.configureApis(original);
 208         assertAll(
 209                 () -> assertEquals(original.generateBatchApi(), adapted.generateBatchApi()),
 210                 () -> assertEquals(original.generateBlockingApi(), adapted.generateBlockingApi()),
 211                 () -> assertEquals(original.generateMutinyApi(), adapted.generateMutinyApi()),
 212                 () -> assertEquals(original.generateReactorApi(), adapted.generateReactorApi()),
 213                 () -> assertEquals(original.generateRxJavaApi(), adapted.generateRxJavaApi()),
 214                 () -> assertEquals(original.generateStreamLazyApi(), adapted.generateStreamLazyApi()),
 215                 () -> assertEquals(original.generateStreamLazyApi(), adapted.generateStreamLazyApi()));
 216     }
 217
 218     @Test
 219     void changeApis() {
 220         final var original = SqlConfiguration.usingDefaults().build();
 221         final var adapted = configurer.configureApis(original);
 222         assertAll(
 223                 () -> assertEquals(repositories.generateBatchApi(), adapted.generateBatchApi().get()),
 224                 () -> assertEquals(repositories.generateBlockingApi(), adapted.generateBlockingApi().get()),
 225                 () -> assertEquals(repositories.generateMutinyApi(), adapted.generateMutinyApi().get()),
 226                 () -> assertEquals(repositories.generateReactorApi(), adapted.generateReactorApi().get()),
 227                 () -> assertEquals(repositories.generateRxJavaApi(), adapted.generateRxJavaApi().get()),
 228                 () -> assertEquals(repositories.generateStreamLazyApi(), adapted.generateStreamLazyApi().get()),
 229                 () -> assertEquals(repositories.generateStreamLazyApi(), adapted.generateStreamLazyApi().get()));
 230     }
 231
 232 }