yosql-codegen/src/test/java/wtf/metio/yosql/codegen/dao/JdbcBlocksTCK.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.dao;
   9
  10 import org.junit.jupiter.api.Assertions;
  11 import org.junit.jupiter.api.Test;
  12 import wtf.metio.yosql.internals.testing.configs.SqlConfigurations;
  13 import wtf.metio.yosql.models.configuration.ResultRowConverter;
  14 import wtf.metio.yosql.models.immutables.SqlConfiguration;
  15
  16 /**
  17  * Verifies that {@link JdbcBlocks}s work correctly.
  18  */
  19 abstract class JdbcBlocksTCK {
  20
  21     /**
  22      * @return A new {@link JdbcBlocks}.
  23      */
  24     abstract JdbcBlocks generator();
  25
  26     abstract String getConnectionInlineExpectation();
  27
  28     abstract String prepareStatementInlineExpectation();
  29
  30     abstract String prepareCallInlineExpectation();
  31
  32     abstract String getMetaDataStatementExpectation();
  33
  34     abstract String executeQueryInlineExpectation();
  35
  36     abstract String returnExecuteUpdateWithReturnExpectation();
  37
  38     abstract String returnExecuteUpdateWithoutReturnExpectation();
  39
  40     abstract String executeBatchExpectation();
  41
  42     abstract String closeResultSetExpectation();
  43
  44     abstract String closePrepareStatementExpectation();
  45
  46     abstract String closeConnectionExpectation();
  47
  48     abstract String closeConnectionWithGivenConnectionExpectation();
  49
  50     abstract String executeStatementExpectation();
  51
  52     abstract String executeStatementWithoutPreparationExpectation();
  53
  54     abstract String openConnectionExpectation();
  55
  56     abstract String openConnectionWithoutConnectionExpectation();
  57
  58     abstract String openConnectionWithGivenConnectionWithoutRethrowExpectation();
  59
  60     abstract String tryPrepareCallableExpectation();
  61
  62     abstract String createStatementExpectation();
  63
  64     abstract String createStatementWithoutPreparationExpectation();
  65
  66     abstract String prepareBatchExpectation();
  67
  68     abstract String pickVendorQueryExpectation();
  69
  70     abstract String logExecutedQueryExpectation();
  71
  72     abstract String logExecutedBatchQueryExpectation();
  73
  74     abstract String returnAsMultipleExpectation();
  75
  76     abstract String returnAsSingleExpectation();
  77
  78     abstract String returnAsSingleWithThrowExpectation();
  79
  80     abstract String streamStatefulExpectation();
  81
  82     abstract String streamStatefulWithGivenConnectionExpectation();
  83
  84     abstract String setParametersExpectation();
  85
  86     abstract String setBatchParametersExpectation();
  87
  88     @Test
  89     final void getConnectionInline() {
  90         Assertions.assertEquals(
  91                 getConnectionInlineExpectation(),
  92                 generator().getConnectionInline().toString());
  93     }
  94
  95     @Test
  96     final void prepareStatementInline() {
  97         Assertions.assertEquals(
  98                 prepareStatementInlineExpectation(),
  99                 generator().prepareStatementInline().toString());
 100     }
 101
 102     @Test
 103     final void prepareCallInline() {
 104         Assertions.assertEquals(
 105                 prepareCallInlineExpectation(),
 106                 generator().prepareCallInline().toString());
 107     }
 108
 109     @Test
 110     final void getMetaDataStatement() {
 111         Assertions.assertEquals(
 112                 getMetaDataStatementExpectation(),
 113                 generator().getMetaDataStatement().toString());
 114     }
 115
 116     @Test
 117     final void executeQueryInline() {
 118         Assertions.assertEquals(
 119                 executeQueryInlineExpectation(),
 120                 generator().executeQueryInline().toString());
 121     }
 122
 123     @Test
 124     final void returnExecuteUpdateWithReturn() {
 125         Assertions.assertEquals(
 126                 returnExecuteUpdateWithReturnExpectation(),
 127                 generator().returnExecuteUpdate(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 128                         .withWritesReturnUpdateCount(true)).toString());
 129     }
 130
 131     @Test
 132     final void returnExecuteUpdateWithoutReturn() {
 133         Assertions.assertEquals(
 134                 returnExecuteUpdateWithoutReturnExpectation(),
 135                 generator().returnExecuteUpdate(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 136                         .withWritesReturnUpdateCount(false)).toString());
 137     }
 138
 139     @Test
 140     final void executeBatch() {
 141         Assertions.assertEquals(
 142                 executeBatchExpectation(),
 143                 generator().executeBatch().toString());
 144     }
 145
 146     @Test
 147     final void closeResultSet() {
 148         Assertions.assertEquals(
 149                 closeResultSetExpectation(),
 150                 generator().closeResultSet().toString());
 151     }
 152
 153     @Test
 154     final void closePrepareStatement() {
 155         Assertions.assertEquals(
 156                 closePrepareStatementExpectation(),
 157                 generator().closePrepareStatement().toString());
 158     }
 159
 160     @Test
 161     final void closeConnection() {
 162         Assertions.assertEquals(
 163                 closeConnectionExpectation(),
 164                 generator().closeConnection(SqlConfigurations.sqlConfiguration()).toString());
 165     }
 166
 167     @Test
 168     final void closeConnectionWithGivenConnection() {
 169         Assertions.assertEquals(
 170                 closeConnectionWithGivenConnectionExpectation(),
 171                 generator().closeConnection(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 172                         .withCreateConnection(false)).toString());
 173     }
 174
 175     @Test
 176     final void executeStatement() {
 177         Assertions.assertEquals(
 178                 executeStatementExpectation(),
 179                 generator().executeStatement(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 180                         .withUsePreparedStatement(true)).toString());
 181     }
 182
 183     @Test
 184     final void executeStatementWithoutPreparation() {
 185         Assertions.assertEquals(
 186                 executeStatementWithoutPreparationExpectation(),
 187                 generator().executeStatement(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 188                         .withUsePreparedStatement(false)).toString());
 189     }
 190
 191     @Test
 192     final void openConnection() {
 193         Assertions.assertEquals(
 194                 openConnectionExpectation(),
 195                 generator().openConnection(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 196                         .withCreateConnection(true)).toString());
 197     }
 198
 199     @Test
 200     final void openConnectionWithoutConnection() {
 201         Assertions.assertEquals(
 202                 openConnectionWithoutConnectionExpectation(),
 203                 generator().openConnection(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 204                         .withCreateConnection(false)).toString());
 205     }
 206
 207     @Test
 208     final void openConnectionWithGivenConnectionWithoutRethrow() {
 209         Assertions.assertEquals(
 210                 openConnectionWithGivenConnectionWithoutRethrowExpectation(),
 211                 generator().openConnection(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 212                         .withCreateConnection(false)
 213                         .withCatchAndRethrow(false)).toString());
 214     }
 215
 216     @Test
 217     final void tryPrepareCallable() {
 218         Assertions.assertEquals(
 219                 tryPrepareCallableExpectation(),
 220                 generator().tryPrepareCallable().toString());
 221     }
 222
 223     @Test
 224     final void createStatement() {
 225         Assertions.assertEquals(
 226                 createStatementExpectation(),
 227                 generator().createStatement(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 228                         .withUsePreparedStatement(true)).toString());
 229     }
 230
 231     @Test
 232     final void createStatementWithoutPreparation() {
 233         Assertions.assertEquals(
 234                 createStatementWithoutPreparationExpectation(),
 235                 generator().createStatement(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 236                         .withUsePreparedStatement(false)).toString());
 237     }
 238
 239     @Test
 240     final void prepareBatch() {
 241         Assertions.assertEquals(
 242                 prepareBatchExpectation(),
 243                 generator().prepareBatch(SqlConfigurations.sqlConfiguration()).toString());
 244     }
 245
 246     @Test
 247     final void pickVendorQuery() {
 248         Assertions.assertEquals(
 249                 pickVendorQueryExpectation(),
 250                 generator().pickVendorQuery(SqlConfigurations.sqlStatement()).toString());
 251     }
 252
 253     @Test
 254     final void logExecutedQuery() {
 255         Assertions.assertEquals(
 256                 logExecutedQueryExpectation(),
 257                 generator().logExecutedQuery(SqlConfigurations.sqlConfiguration()).toString());
 258     }
 259
 260     @Test
 261     final void logExecutedBatchQuery() {
 262         Assertions.assertEquals(
 263                 logExecutedBatchQueryExpectation(),
 264                 generator().logExecutedBatchQuery(SqlConfigurations.sqlConfiguration()).toString());
 265     }
 266
 267     @Test
 268     final void returnAsMultiple() {
 269         final var converter = ResultRowConverter.builder()
 270                 .setAlias("converter")
 271                 .setConverterType("com.example.Converter")
 272                 .setMethodName("apply")
 273                 .setResultType("com.example.Domain")
 274                 .build();
 275         Assertions.assertEquals(
 276                 returnAsMultipleExpectation(),
 277                 generator().returnAsMultiple(converter).toString());
 278     }
 279
 280     @Test
 281     final void returnAsSingle() {
 282         Assertions.assertEquals(
 283                 returnAsSingleExpectation(),
 284                 generator().returnAsSingle(SqlConfigurations.sqlConfiguration()).toString());
 285     }
 286
 287     @Test
 288     final void returnAsSingleWithThrow() {
 289         Assertions.assertEquals(
 290                 returnAsSingleWithThrowExpectation(),
 291                 generator().returnAsSingle(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 292                         .withThrowOnMultipleResults(true)).toString());
 293     }
 294
 295     @Test
 296     final void streamStateful() {
 297         Assertions.assertEquals(
 298                 streamStatefulExpectation(),
 299                 generator().streamStateful(SqlConfigurations.sqlConfiguration()).toString());
 300     }
 301
 302     @Test
 303     final void streamStatefulWithGivenConnection() {
 304         Assertions.assertEquals(
 305                 streamStatefulWithGivenConnectionExpectation(),
 306                 generator().streamStateful(SqlConfiguration.copyOf(SqlConfigurations.sqlConfiguration())
 307                         .withCreateConnection(false)).toString());
 308     }
 309
 310     @Test
 311     final void setParameters() {
 312         Assertions.assertEquals(
 313                 setParametersExpectation(),
 314                 generator().setParameters(SqlConfigurations.sqlConfiguration()).toString());
 315     }
 316
 317     @Test
 318     final void setBatchParameters() {
 319         Assertions.assertEquals(
 320                 setBatchParametersExpectation(),
 321                 generator().setBatchParameters(SqlConfigurations.sqlConfiguration()).toString());
 322     }
 323
 324 }