gerrit.onap Code Review - dcaegen2/collectors/hv-ves.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * dcaegen2-collectors-veshv
   4  * ================================================================================
   5  * Copyright (C) 2019 NOKIA
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20 package org.onap.dcae.collectors.veshv.config.impl
  21
  22 import arrow.core.None
  23 import arrow.core.Option
  24 import arrow.core.Some
  25 import org.assertj.core.api.Assertions.*
  26 import org.jetbrains.spek.api.Spek
  27 import org.jetbrains.spek.api.dsl.describe
  28 import org.jetbrains.spek.api.dsl.given
  29 import org.jetbrains.spek.api.dsl.it
  30 import org.onap.dcae.collectors.veshv.config.api.model.ValidationException
  31 import org.onap.dcae.collectors.veshv.utils.logging.LogLevel
  32 import org.onap.dcaegen2.services.sdk.model.streams.dmaap.KafkaSink
  33
  34 internal object ConfigurationValidatorTest : Spek({
  35     describe("ConfigurationValidator") {
  36         val cut = ConfigurationValidator()
  37
  38         describe("validating partial configuration with missing fields") {
  39             val config = PartialConfiguration(listenPort = Some(5))
  40
  41             it("should return ValidationException with missing required fields description") {
  42                 val result = cut.validate(config)
  43                 result.fold({
  44                     assertThat(it.message).doesNotContain(PartialConfiguration::listenPort.name)
  45
  46                     assertThat(it.message).contains(PartialConfiguration::idleTimeoutSec.name)
  47                     assertThat(it.message).contains(PartialConfiguration::firstRequestDelaySec.name)
  48                     assertThat(it.message).contains(PartialConfiguration::requestIntervalSec.name)
  49                     assertThat(it.message).contains(PartialConfiguration::streamPublishers.name)
  50                     assertThat(it.message).contains(PartialConfiguration::keyStoreFile.name)
  51                     assertThat(it.message).contains(PartialConfiguration::keyStorePasswordFile.name)
  52                     assertThat(it.message).contains(PartialConfiguration::trustStoreFile.name)
  53                     assertThat(it.message).contains(PartialConfiguration::trustStorePasswordFile.name)
  54
  55                     assertThat(it.message).doesNotContain(PartialConfiguration::logLevel.name)
  56                     assertThat(it.message).doesNotContain(PartialConfiguration::sslDisable.name)
  57                 }, { fail("Should be ValidationException") })
  58             }
  59         }
  60
  61         describe("validating complete valid configuration") {
  62             val config = PartialConfiguration(
  63                     listenPort = Some(defaultListenPort),
  64                     idleTimeoutSec = Some(defaultIdleTimeoutSec),
  65                     firstRequestDelaySec = Some(defaultFirstReqDelaySec),
  66                     requestIntervalSec = Some(defaultRequestIntervalSec),
  67                     sslDisable = Some(false),
  68                     keyStoreFile = Some(KEYSTORE),
  69                     keyStorePasswordFile = Some(KEYSTORE_PASSWORD),
  70                     trustStoreFile = Some(TRUSTSTORE),
  71                     trustStorePasswordFile = Some(TRUSTSTORE_PASSWORD),
  72                     streamPublishers = Some(sampleStreamsDefinition),
  73                     logLevel = Some(LogLevel.TRACE)
  74             )
  75
  76             it("should create validated configuration") {
  77                 val result = cut.validate(config)
  78                 result.fold(
  79                         {
  80                             fail("Configuration should have been created successfully")
  81                         },
  82                         {
  83                             assertThat(it.listenPort)
  84                                     .isEqualTo(defaultListenPort)
  85                             assertThat(it.idleTimeoutSec)
  86                                     .isEqualTo(defaultIdleTimeoutSec)
  87
  88                             it.securityConfiguration.fold({
  89                                 fail("Should have been validated successfully")
  90                             }, {
  91                                 assertThat(it.keyStoreFile).isEqualTo(KEYSTORE)
  92                                 assertThat(it.keyStorePasswordFile).isEqualTo(KEYSTORE_PASSWORD)
  93                                 assertThat(it.trustStoreFile).isEqualTo(TRUSTSTORE)
  94                                 assertThat(it.trustStorePasswordFile).isEqualTo(TRUSTSTORE_PASSWORD)
  95                             })
  96
  97                             assertThat(it.cbsConfiguration.firstRequestDelaySec).isEqualTo(defaultFirstReqDelaySec)
  98                             assertThat(it.cbsConfiguration.requestIntervalSec).isEqualTo(defaultRequestIntervalSec)
  99
 100                             assertThat(it.streamPublishers).isEqualTo(sampleStreamsDefinition)
 101
 102                             assertThat(it.logLevel).isEqualTo(Some(LogLevel.TRACE))
 103                         }
 104                 )
 105             }
 106         }
 107
 108         describe("validating configuration with security disabled") {
 109             val config = partialConfiguration(
 110                     sslDisable = Some(true),
 111                     keyStoreFile = Some(""),
 112                     keyStorePasswordFile = None,
 113                     trustStoreFile = None,
 114                     trustStorePasswordFile = Some("")
 115             )
 116
 117             it("should return validated configuration regardless of security keys presence") {
 118                 val result = cut.validate(config)
 119                 result.fold(
 120                         {
 121                             fail("Configuration should have been created successfully but was $it")
 122                         },
 123                         {
 124                             assertThat(it.idleTimeoutSec).isEqualTo(defaultIdleTimeoutSec)
 125
 126                             assertThat(it.securityConfiguration.isEmpty()).isTrue()
 127
 128                             assertThat(it.cbsConfiguration.firstRequestDelaySec).isEqualTo(defaultFirstReqDelaySec)
 129                             assertThat(it.cbsConfiguration.requestIntervalSec).isEqualTo(defaultRequestIntervalSec)
 130
 131                             assertThat(it.streamPublishers).isEqualTo(sampleStreamsDefinition)
 132                         }
 133                 )
 134             }
 135         }
 136
 137         describe("validating configuration with ssl disable missing") {
 138             val config = partialConfiguration(
 139                     sslDisable = None
 140             )
 141
 142             it("should return validated configuration") {
 143                 val result = cut.validate(config)
 144                 result.fold(
 145                         {
 146                             fail("Configuration should have been created successfully but was $it")
 147                         },
 148                         {
 149                             it.securityConfiguration.fold({
 150                                 fail("Should have been validated successfully")
 151                             }, {
 152                                 assertThat(it.keyStoreFile).isEqualTo(KEYSTORE)
 153                                 assertThat(it.keyStorePasswordFile).isEqualTo(KEYSTORE_PASSWORD)
 154                                 assertThat(it.trustStoreFile).isEqualTo(TRUSTSTORE)
 155                                 assertThat(it.trustStorePasswordFile).isEqualTo(TRUSTSTORE_PASSWORD)
 156                             })
 157
 158                         }
 159                 )
 160             }
 161         }
 162
 163         describe("validating configuration with ssl enabled, but not all required security fields set") {
 164             val config = partialConfiguration(
 165                     sslDisable = Some(false),
 166                     keyStoreFile = Some(KEYSTORE),
 167                     keyStorePasswordFile = None,
 168                     trustStoreFile = None,
 169                     trustStorePasswordFile = Some(TRUSTSTORE_PASSWORD)
 170             )
 171
 172             it("should return validated configuration") {
 173                 val result = cut.validate(config)
 174
 175                 assertThat(result.isLeft())
 176                         .describedAs("security validation result")
 177                         .isTrue()
 178             }
 179         }
 180
 181         describe("validating CBS configuration from partial") {
 182             given("valid CBS configuration") {
 183                 val config = partialConfiguration()
 184
 185                 it("should returned validated config") {
 186                     val result = cut.validatedCbsConfiguration(config)
 187
 188                     assertThat(result.firstRequestDelaySec).isEqualTo(defaultFirstReqDelaySec)
 189                     assertThat(result.requestIntervalSec).isEqualTo(defaultRequestIntervalSec)
 190                 }
 191
 192             }
 193
 194             given("missing firstReqDelaySec") {
 195                 val config = partialConfiguration(
 196                         firstReqDelaySec = None
 197                 )
 198
 199                 it("should throw validation exception") {
 200                     assertThatExceptionOfType(ValidationException::class.java).isThrownBy {
 201                         cut.validatedCbsConfiguration(config)
 202                     }.withMessageContaining(PartialConfiguration::firstRequestDelaySec.name)
 203                 }
 204             }
 205
 206             given("missing requestIntervalSec") {
 207                 val config = partialConfiguration(
 208                         requestIntervalSec = None)
 209
 210                 it("should throw validation exception") {
 211                     assertThatExceptionOfType(ValidationException::class.java).isThrownBy {
 212                         cut.validatedCbsConfiguration(config)
 213                     }.withMessageContaining(PartialConfiguration::requestIntervalSec.name)
 214                 }
 215             }
 216         }
 217     }
 218 })
 219
 220 private fun partialConfiguration(listenPort: Option<Int> = Some(defaultListenPort),
 221                                  idleTimeoutSec: Option<Long> = Some(defaultIdleTimeoutSec),
 222                                  firstReqDelaySec: Option<Long> = Some(defaultFirstReqDelaySec),
 223                                  requestIntervalSec: Option<Long> = Some(defaultRequestIntervalSec),
 224                                  sslDisable: Option<Boolean> = Some(false),
 225                                  keyStoreFile: Option<String> = Some(KEYSTORE),
 226                                  keyStorePasswordFile: Option<String> = Some(KEYSTORE_PASSWORD),
 227                                  trustStoreFile: Option<String> = Some(TRUSTSTORE),
 228                                  trustStorePasswordFile: Option<String> = Some(TRUSTSTORE_PASSWORD),
 229                                  streamPublishers: Option<List<KafkaSink>> = Some(sampleStreamsDefinition),
 230                                  logLevel: Option<LogLevel> = Some(LogLevel.INFO)
 231 ) = PartialConfiguration(
 232         listenPort = listenPort,
 233         idleTimeoutSec = idleTimeoutSec,
 234         firstRequestDelaySec = firstReqDelaySec,
 235         requestIntervalSec = requestIntervalSec,
 236         sslDisable = sslDisable,
 237         keyStoreFile = keyStoreFile,
 238         keyStorePasswordFile = keyStorePasswordFile,
 239         trustStoreFile = trustStoreFile,
 240         trustStorePasswordFile = trustStorePasswordFile,
 241         streamPublishers = streamPublishers,
 242         logLevel = logLevel
 243 )