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 com.nhaarman.mockitokotlin2.mock
  26 import org.assertj.core.api.Assertions.assertThat
  27 import org.assertj.core.api.Assertions.fail
  28 import org.jetbrains.spek.api.Spek
  29 import org.jetbrains.spek.api.dsl.describe
  30 import org.jetbrains.spek.api.dsl.it
  31 import org.onap.dcae.collectors.veshv.config.api.model.Routing
  32 import org.onap.dcae.collectors.veshv.config.impl.ConfigurationValidator.Companion.DEFAULT_LOG_LEVEL
  33 import org.onap.dcae.collectors.veshv.utils.logging.LogLevel
  34 import org.onap.dcaegen2.services.sdk.security.ssl.SecurityKeys
  35 import java.time.Duration
  36
  37 internal object ConfigurationValidatorTest : Spek({
  38     describe("ConfigurationValidator") {
  39         val cut = ConfigurationValidator()
  40
  41         describe("validating partial configuration with missing fields") {
  42             val config = PartialConfiguration(
  43                     Some(PartialServerConfig(listenPort = Some(1)))
  44             )
  45
  46             it("should return ValidationError") {
  47                 val result = cut.validate(config)
  48                 assertThat(result.isLeft()).isTrue()
  49             }
  50         }
  51
  52         describe("validating configuration with empty log level") {
  53             val config = PartialConfiguration(
  54                     Some(PartialServerConfig(
  55                             Some(1),
  56                             Some(2),
  57                             Some(3)
  58                     )),
  59                     Some(PartialCbsConfig(
  60                             Some(5),
  61                             Some(3)
  62                     )),
  63                     Some(PartialSecurityConfig(
  64                             Some(mock())
  65                     )),
  66 // TOD0: retrieve when ConfigurationMerger is implemented
  67 //                    Some(PartialCollectorConfig(
  68 //                            Some(4),
  69 //                            Some(emptyList()),
  70 //                            someFromEmptyRouting
  71 //                    )),
  72                     None
  73             )
  74
  75             it("should use default log level") {
  76                 val result = cut.validate(config)
  77                 result.fold(
  78                         {
  79                             fail("Configuration should have been created successfully")
  80                         },
  81                         {
  82                             assertThat(it.logLevel).isEqualTo(DEFAULT_LOG_LEVEL)
  83                         }
  84                 )
  85             }
  86         }
  87
  88         describe("validating complete configuration") {
  89             val idleTimeoutSec = 10
  90             val firstReqDelaySec = 10
  91             val securityKeys = Some(mock<SecurityKeys>())
  92
  93             val config = PartialConfiguration(
  94                     Some(PartialServerConfig(
  95                             Some(1),
  96                             Some(idleTimeoutSec),
  97                             Some(2)
  98                     )),
  99                     Some(PartialCbsConfig(
 100                             Some(firstReqDelaySec),
 101                             Some(3)
 102                     )),
 103                     Some(PartialSecurityConfig(
 104                             securityKeys
 105                     )),
 106 // TOD0: retrieve when ConfigurationMerger is implemented
 107 //                    Some(PartialCollectorConfig(
 108 //                            Some(4),
 109 //                            Some(emptyList()),
 110 //                            someFromEmptyRouting
 111 //                    )),
 112                     Some(LogLevel.INFO)
 113             )
 114
 115             it("should create valid configuration") {
 116                 val result = cut.validate(config)
 117                 result.fold(
 118                         {
 119                             fail("Configuration should have been created successfully")
 120                         },
 121                         {
 122                             assertThat(it.server.idleTimeout)
 123                                     .isEqualTo(Duration.ofSeconds(idleTimeoutSec.toLong()))
 124
 125                             assertThat(it.security.keys)
 126                                     .isEqualTo(securityKeys)
 127
 128                             assertThat(it.cbs.firstRequestDelay)
 129                                     .isEqualTo(Duration.ofSeconds(firstReqDelaySec.toLong()))
 130
 131 // TOD0: retrieve when ConfigurationMerger is implemented
 132 //                            assertThat(it.collector.routing)
 133 //                                    .isEqualTo(emptyRouting)
 134                         }
 135                 )
 136             }
 137         }
 138
 139         describe("validating configuration with security disabled") {
 140             val idleTimeoutSec = 10
 141             val firstReqDelaySec = 10
 142             val securityKeys: Option<SecurityKeys> = None
 143
 144             val config = PartialConfiguration(
 145                     Some(PartialServerConfig(
 146                             Some(1),
 147                             Some(idleTimeoutSec),
 148                             Some(2)
 149                     )),
 150                     Some(PartialCbsConfig(
 151                             Some(firstReqDelaySec),
 152                             Some(3)
 153                     )),
 154                     Some(PartialSecurityConfig(
 155                             securityKeys
 156                     )),
 157 // TOD0: retrieve when ConfigurationMerger is implemented
 158 //                    Some(PartialCollectorConfig(
 159 //                            Some(4),
 160 //                            Some(emptyList()),
 161 //                            someFromEmptyRouting
 162 //                    )),
 163                     Some(LogLevel.INFO)
 164             )
 165
 166             it("should create valid configuration") {
 167                 val result = cut.validate(config)
 168                 result.fold(
 169                         {
 170                             fail("Configuration should have been created successfully but was $it")
 171                         },
 172                         {
 173                             assertThat(it.server.idleTimeout)
 174                                     .isEqualTo(Duration.ofSeconds(idleTimeoutSec.toLong()))
 175
 176                             assertThat(it.security.keys)
 177                                     .isEqualTo(securityKeys)
 178
 179                             assertThat(it.cbs.firstRequestDelay)
 180                                     .isEqualTo(Duration.ofSeconds(firstReqDelaySec.toLong()))
 181
 182 // TOD0: retrieve when ConfigurationMerger is implemented
 183 //                            assertThat(it.collector.routing)
 184 //                                    .isEqualTo(emptyRouting)
 185                         }
 186                 )
 187             }
 188         }
 189
 190     }
 191 })
 192
 193 // TOD0: retrieve when ConfigurationMerger is implemented
 194 //val emptyRouting = Routing(emptyList())
 195 //val someFromEmptyRouting = Some(emptyRouting)