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

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * dcaegen2-collectors-veshv
   4  * ================================================================================
   5  * Copyright (C) 2018 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.impl
  21
  22 import arrow.core.Either.Companion.left
  23 import arrow.core.Either.Companion.right
  24 import com.nhaarman.mockitokotlin2.doReturn
  25 import com.nhaarman.mockitokotlin2.mock
  26 import org.assertj.core.api.Assertions.assertThat
  27 import org.jetbrains.spek.api.Spek
  28 import org.jetbrains.spek.api.dsl.*
  29 import org.onap.dcae.collectors.veshv.domain.*
  30 import org.onap.dcae.collectors.veshv.model.VesMessage
  31 import org.onap.dcae.collectors.veshv.tests.utils.commonHeader
  32 import org.onap.dcae.collectors.veshv.tests.utils.emptyWireProtocolFrame
  33 import org.onap.dcae.collectors.veshv.tests.utils.wireProtocolFrame
  34 import org.onap.ves.VesEventOuterClass.CommonEventHeader.*
  35 import kotlin.test.assertTrue
  36 import kotlin.test.fail
  37
  38 internal object MessageValidatorTest : Spek({
  39
  40     describe("Message validator") {
  41         val cut = MessageValidator
  42
  43         on("ves hv message including header with fully initialized fields") {
  44             val commonHeader = commonHeader()
  45
  46             it("should accept message with fully initialized message header") {
  47                 val vesMessage = VesMessage(commonHeader, wireProtocolFrame(commonHeader))
  48                 with(cut) {
  49                     assertThat(validateProtobufMessage(vesMessage).isRight())
  50                         .describedAs("message validation result").isTrue()
  51                 }
  52             }
  53
  54             VesEventDomain.values().forEach { domain ->
  55                 it("should accept message with $domain domain") {
  56                     val header = commonHeader(domain)
  57                     val vesMessage = VesMessage(header, wireProtocolFrame(header))
  58                     with(cut) {
  59                         assertThat(validateProtobufMessage(vesMessage).isRight())
  60                             .describedAs("message validation result").isTrue()
  61                     }
  62                 }
  63             }
  64         }
  65
  66         on("ves hv message bytes") {
  67             val vesMessage = VesMessage(getDefaultInstance(), emptyWireProtocolFrame())
  68             it("should not accept message with default header") {
  69
  70                 with(cut) {
  71                     validateProtobufMessage(vesMessage).fold({
  72                         val failMessages = it.invoke()
  73
  74                         val containsAllErrorMessages = failMessages.contains("vesEventListenerVersion mismatch")
  75                                 && failMessages.contains("missing domain field")
  76                                 && failMessages.contains("missing version field")
  77                                 && failMessages.contains("missing priority field")
  78                                 && failMessages.contains("missing eventId field")
  79                                 && failMessages.contains("missing eventName field")
  80                                 && failMessages.contains("missing lastEpochMicrosec field")
  81                                 && failMessages.contains("missing startEpochMicrosec field")
  82                                 && failMessages.contains("missing reportingEntityName field")
  83                                 && failMessages.contains("missing sourceName field")
  84                                 && failMessages.contains("missing vesEventListenerVersion field")
  85
  86                         assertThat(containsAllErrorMessages)
  87                             .describedAs("message validation result").isTrue()
  88                     }, {
  89                         fail()
  90                     })
  91                 }
  92             }
  93         }
  94
  95         given("priority test cases") {
  96             mapOf(
  97                 Priority.PRIORITY_NOT_PROVIDED to false,
  98                 Priority.LOW to true,
  99                 Priority.MEDIUM to true,
 100                 Priority.HIGH to true
 101             ).forEach { value, expectedResult ->
 102                 on("ves hv message including header with priority $value") {
 103                     val commonEventHeader = commonHeader(priority = value)
 104                     val vesMessage = VesMessage(commonEventHeader, wireProtocolFrame(commonEventHeader))
 105
 106                     it("should resolve validation result") {
 107                         with(cut) {
 108                             assertThat(validateProtobufMessage(vesMessage).isRight())
 109                                 .describedAs("message validation results")
 110                                 .isEqualTo(expectedResult)
 111                         }
 112                     }
 113                 }
 114             }
 115         }
 116
 117
 118         on("ves hv message including header with not initialized fields") {
 119             val commonHeader = newBuilder()
 120                 .setVersion("1.9")
 121                 .setEventName("Sample event name")
 122                 .setEventId("Sample event Id")
 123                 .setSourceName("Sample Source")
 124                 .build()
 125             val rawMessageBytes = wireProtocolFrame(commonHeader)
 126
 127             it("should not accept not fully initialized message header") {
 128                 val vesMessage = VesMessage(commonHeader, rawMessageBytes)
 129                 with(cut) {
 130                     validateProtobufMessage(vesMessage).fold({
 131                         val failMessages = it.invoke()
 132
 133                         val containsAllErrorMessages = failMessages.contains("vesEventListenerVersion mismatch")
 134                                 && failMessages.contains("missing domain field")
 135                                 && failMessages.contains("missing priority field")
 136                                 && failMessages.contains("missing lastEpochMicrosec field")
 137                                 && failMessages.contains("missing startEpochMicrosec field")
 138                                 && failMessages.contains("missing reportingEntityName field")
 139                                 && failMessages.contains("missing vesEventListenerVersion field")
 140
 141                         assertThat(containsAllErrorMessages).describedAs("message validation result")
 142                             .isTrue()
 143                     }, {
 144                         fail()
 145                     })
 146                 }
 147             }
 148         }
 149
 150         on("ves hv message including header.vesEventListenerVersion with non-string major part") {
 151             val commonHeader = commonHeader(vesEventListenerVersion = "sample-version")
 152             val rawMessageBytes = wireProtocolFrame(commonHeader)
 153
 154
 155             it("should not accept message header") {
 156                 val vesMessage = VesMessage(commonHeader, rawMessageBytes)
 157                 with(cut) {
 158                     validateProtobufMessage(vesMessage).fold({
 159                         val failMessages = it.invoke()
 160
 161                         assertThat(failMessages.contains("vesEventListenerVersion mismatch"))
 162                             .describedAs("message validation result")
 163                             .isTrue()
 164                     }, {
 165                         fail()
 166                     })
 167                 }
 168             }
 169         }
 170
 171         on("ves hv message including header.vesEventListenerVersion with major part != 7") {
 172             val commonHeader = commonHeader(vesEventListenerVersion = "1.2.3")
 173             val rawMessageBytes = wireProtocolFrame(commonHeader)
 174
 175             it("should not accept message header") {
 176                 val vesMessage = VesMessage(commonHeader, rawMessageBytes)
 177
 178                 with(cut) {
 179                     validateProtobufMessage(vesMessage).fold({
 180                         val failMessages = it.invoke()
 181
 182                         assertThat(failMessages.contains("vesEventListenerVersion mismatch"))
 183                             .describedAs("message validation result")
 184                             .isTrue()
 185                     }, {
 186                         fail()
 187                     })
 188                 }
 189             }
 190         }
 191
 192         on("ves hv message including header.vesEventListenerVersion with minor part not starting with a digit") {
 193             val commonHeader = commonHeader(vesEventListenerVersion = "7.test")
 194             val rawMessageBytes = wireProtocolFrame(commonHeader)
 195
 196             it("should not accept message header") {
 197                 val vesMessage = VesMessage(commonHeader, rawMessageBytes)
 198
 199                 with(cut) {
 200                     validateProtobufMessage(vesMessage).fold({
 201                         val failMessages = it.invoke()
 202
 203                         assertThat(failMessages.contains("vesEventListenerVersion mismatch"))
 204                             .describedAs("message validation result")
 205                             .isTrue()
 206                     }, {
 207                         fail()
 208                     })
 209                 }
 210             }
 211         }
 212
 213         describe("validating messages and converting to Either of string for validation result") {
 214             given("WireFrameMessage") {
 215                 on("valid message as input") {
 216                     val wireFrameMessage = WireFrameMessage("lets pretend it's valid".toByteArray())
 217                     val mockedWireFrameMessage = mock<WireFrameMessage> {
 218                         on { validate() } doReturn right(wireFrameMessage)
 219                     }
 220
 221                     it("should be right") {
 222                         assertTrue(cut.validateFrameMessage(mockedWireFrameMessage).isRight())
 223                     }
 224                 }
 225
 226                 on("invalid message as input") {
 227                     val mockedWireFrameMessage = mock<WireFrameMessage> {
 228                         on { validate() } doReturn left(InvalidMajorVersion(99))
 229                     }
 230
 231                     it("should be left") {
 232                         assertTrue(cut.validateFrameMessage(mockedWireFrameMessage).isLeft())
 233                     }
 234                 }
 235             }
 236
 237             given("VesEvent") {
 238                 with(cut) {
 239                     on("valid message as input") {
 240                         val commonHeader = commonHeader()
 241                         val rawMessageBytes = wireProtocolFrame(commonHeader)
 242                         val vesMessage = VesMessage(commonHeader, rawMessageBytes)
 243
 244                         it("should be right") {
 245                             assertTrue(validateProtobufMessage(vesMessage).isRight())
 246                         }
 247                     }
 248                 }
 249                 on("invalid message as input") {
 250                     val commonHeader = newBuilder().build()
 251                     val rawMessageBytes = wireProtocolFrame(commonHeader)
 252                     val vesMessage = VesMessage(commonHeader, rawMessageBytes)
 253
 254                     it("should be left") {
 255                         assertTrue(cut.validateProtobufMessage(vesMessage).isLeft())
 256                     }
 257                 }
 258             }
 259
 260         }
 261     }
 262 })