yosql-codegen/yosql-codegen-files/src/test/java/wtf/metio/yosql/codegen/files/DefaultMethodSettingsConfigurerTest.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.DisplayName;
  12 import org.junit.jupiter.api.Test;
  13 import wtf.metio.yosql.models.constants.sql.ReturningMode;
  14 import wtf.metio.yosql.models.constants.sql.SqlType;
  15 import wtf.metio.yosql.models.immutables.RepositoriesConfiguration;
  16 import wtf.metio.yosql.models.immutables.SqlConfiguration;
  17 import wtf.metio.yosql.testing.configs.RepositoriesConfigurations;
  18
  19 import static org.junit.jupiter.api.Assertions.*;
  20
  21 @DisplayName("DefaultMethodSettingsConfigurer")
  22 class DefaultMethodSettingsConfigurerTest {
  23
  24     private DefaultMethodSettingsConfigurer configurer;
  25     private RepositoriesConfiguration repositories;
  26
  27     @BeforeEach
  28     void setUp() {
  29         repositories = RepositoriesConfigurations.defaults();
  30         configurer = new DefaultMethodSettingsConfigurer(repositories);
  31     }
  32
  33     @Test
  34     void typeKeep() {
  35         final var original = SqlConfiguration.usingDefaults().setType(SqlType.CALLING).build();
  36         final var adapted = configurer.type(original);
  37         assertEquals(original.type(), adapted.type());
  38     }
  39
  40     @Test
  41     void typeChangeReading() {
  42         final var original = SqlConfiguration.usingDefaults()
  43                 .setType(SqlType.UNKNOWN)
  44                 .setName(repositories.allowedReadPrefixes().get(0) + "Something")
  45                 .build();
  46         final var adapted = configurer.type(original);
  47         assertEquals(SqlType.READING, adapted.type());
  48     }
  49
  50     @Test
  51     void typeChangeWriting() {
  52         final var original = SqlConfiguration.usingDefaults()
  53                 .setType(SqlType.UNKNOWN)
  54                 .setName(repositories.allowedWritePrefixes().get(0) + "Something")
  55                 .build();
  56         final var adapted = configurer.type(original);
  57         assertEquals(SqlType.WRITING, adapted.type());
  58     }
  59
  60     @Test
  61     void typeChangeCalling() {
  62         final var original = SqlConfiguration.usingDefaults()
  63                 .setType(SqlType.UNKNOWN)
  64                 .setName(repositories.allowedCallPrefixes().get(0) + "Something")
  65                 .build();
  66         final var adapted = configurer.type(original);
  67         assertEquals(SqlType.CALLING, adapted.type());
  68     }
  69
  70     @Test
  71     void typeChangeUnknown() {
  72         final var original = SqlConfiguration.usingDefaults()
  73                 .setType(SqlType.UNKNOWN)
  74                 .setName("question" + "Something")
  75                 .build();
  76         final var adapted = configurer.type(original);
  77         assertEquals(SqlType.UNKNOWN, adapted.type());
  78     }
  79
  80     @Test
  81     void returningModeKeep() {
  82         final var original = SqlConfiguration.usingDefaults()
  83                 .setReturningMode(ReturningMode.LIST)
  84                 .build();
  85         final var adapted = configurer.returningMode(original);
  86         assertEquals(original.returningMode(), adapted.returningMode());
  87     }
  88
  89     @Test
  90     void returningModeChangeReading() {
  91         final var original = SqlConfiguration.usingDefaults()
  92                 .setReturningMode(ReturningMode.NONE)
  93                 .setType(SqlType.READING)
  94                 .build();
  95         final var adapted = configurer.returningMode(original);
  96         assertEquals(ReturningMode.LIST, adapted.returningMode());
  97     }
  98
  99     @Test
 100     void returningModeChangeCalling() {
 101         final var original = SqlConfiguration.usingDefaults()
 102                 .setReturningMode(ReturningMode.NONE)
 103                 .setType(SqlType.CALLING)
 104                 .build();
 105         final var adapted = configurer.returningMode(original);
 106         assertEquals(ReturningMode.FIRST, adapted.returningMode());
 107     }
 108
 109     @Test
 110     void returningModeChangeWriting() {
 111         final var original = SqlConfiguration.usingDefaults()
 112                 .setReturningMode(ReturningMode.NONE)
 113                 .setType(SqlType.WRITING)
 114                 .build();
 115         final var adapted = configurer.returningMode(original);
 116         assertEquals(ReturningMode.NONE, adapted.returningMode());
 117     }
 118
 119     @Test
 120     void returningModeChangeUnknown() {
 121         final var original = SqlConfiguration.usingDefaults()
 122                 .setReturningMode(ReturningMode.NONE)
 123                 .setType(SqlType.UNKNOWN)
 124                 .build();
 125         final var adapted = configurer.returningMode(original);
 126         assertEquals(ReturningMode.NONE, adapted.returningMode());
 127     }
 128
 129     @Test
 130     void catchAndRethrowKeep() {
 131         final var original = SqlConfiguration.usingDefaults()
 132                 .setCatchAndRethrow(false)
 133                 .build();
 134         final var adapted = configurer.catchAndRethrow(original);
 135         assertEquals(original.catchAndRethrow(), adapted.catchAndRethrow());
 136     }
 137
 138     @Test
 139     void catchAndRethrowChange() {
 140         final var original = SqlConfiguration.usingDefaults()
 141                 // .setCatchAndRethrow(false) // value is NOT set
 142                 .build();
 143         final var adapted = configurer.catchAndRethrow(original);
 144         assertTrue(adapted.catchAndRethrow().isPresent());
 145         assertEquals(repositories.catchAndRethrow(), adapted.catchAndRethrow().get());
 146     }
 147
 148     @Test
 149     void injectConvertersKeep() {
 150         final var original = SqlConfiguration.usingDefaults()
 151                 .setInjectConverters(true)
 152                 .build();
 153         final var adapted = configurer.injectConverters(original);
 154         assertEquals(original.injectConverters(), adapted.injectConverters());
 155     }
 156
 157     @Test
 158     void injectConvertersChange() {
 159         final var original = SqlConfiguration.usingDefaults()
 160                 // .setInjectConverters(true) // value is NOT set
 161                 .build();
 162         final var adapted = configurer.injectConverters(original);
 163         assertTrue(adapted.injectConverters().isPresent());
 164         assertEquals(repositories.injectConverters(), adapted.injectConverters().get());
 165     }
 166
 167     @Test
 168     void keepSettings() {
 169         final var original = SqlConfiguration.usingDefaults()
 170                 .setType(SqlType.CALLING)
 171                 .setReturningMode(ReturningMode.LIST)
 172                 .setCatchAndRethrow(false)
 173                 .setInjectConverters(true)
 174                 .build();
 175         final var adapted = configurer.configureSettings(original);
 176         assertAll(
 177                 () -> assertEquals(original.type(), adapted.type()),
 178                 () -> assertEquals(original.returningMode(), adapted.returningMode()),
 179                 () -> assertEquals(original.catchAndRethrow(), adapted.catchAndRethrow()),
 180                 () -> assertEquals(original.injectConverters(), adapted.injectConverters()));
 181     }
 182
 183     @Test
 184     void changeSettings() {
 185         final var original = SqlConfiguration.usingDefaults()
 186                 .setName(repositories.allowedCallPrefixes().get(0) + "Something")
 187                 .setType(SqlType.UNKNOWN)
 188                 .setReturningMode(ReturningMode.NONE)
 189                 // .setCatchAndRethrow(false) // do NOT set value
 190                 // .setInjectConverters(true) // do NOT set value
 191                 .build();
 192         final var adapted = configurer.configureSettings(original);
 193         assertAll(
 194                 () -> assertEquals(SqlType.CALLING, adapted.type()),
 195                 () -> assertEquals(ReturningMode.FIRST, adapted.returningMode()),
 196                 () -> assertEquals(repositories.catchAndRethrow(), adapted.catchAndRethrow().get()),
 197                 () -> assertEquals(repositories.injectConverters(), adapted.injectConverters().get()));
 198     }
 199
 200 }