gerrit.onap Code Review - dcaegen2/services/sdk.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * DCAEGEN2-SERVICES-SDK
   4  * ================================================================================
   5  * Copyright (C) 2019 Nokia. All rights reserved.
   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
  21 package org.onap.dcaegen2.services.sdk.services.hvves.client.producer.impl.encoders;
  22
  23 import static org.assertj.core.api.Assertions.assertThat;
  24
  25 import io.vavr.control.Try;
  26 import org.junit.jupiter.api.Test;
  27 import io.netty.buffer.ByteBuf;
  28 import io.netty.buffer.ByteBufAllocator;
  29 import org.onap.dcaegen2.services.sdk.services.hvves.client.producer.api.options.ImmutableWireFrameVersion;
  30 import org.onap.dcaegen2.services.sdk.services.hvves.client.producer.api.options.WireFrameVersion;
  31
  32 import java.nio.ByteBuffer;
  33
  34 public class WireFrameEncoderTest {
  35     private static final byte MARKER_BYTE = (byte) 0xAA;
  36     private static final byte SUPPORTED_VERSION_MAJOR = (byte) 0x01;
  37     private static final byte SUPPORTED_VERSION_MINOR = (byte) 0x00;
  38     private static final byte SAMPLE_VERSION_MAJOR = (byte) 0x02;
  39     private static final byte SAMPLE_VERSION_MINOR = (byte) 0x01;
  40     private static final int RESERVED_BYTES_COUNT = 3;
  41     private static final int HEADER_SIZE = 1 * Byte.BYTES +         // marker
  42             2 * Byte.BYTES +                                        // single byte fields (versions)
  43             RESERVED_BYTES_COUNT * java.lang.Byte.BYTES +           // reserved bytes
  44             1 * Short.BYTES +                                       // paylaod type
  45             1 * Integer.BYTES;                                      // payload length
  46
  47     private final WireFrameVersion wireFrameVersion = ImmutableWireFrameVersion.builder().build();
  48     private final WireFrameEncoder wireFrameEncoder = new WireFrameEncoder(ByteBufAllocator.DEFAULT, wireFrameVersion);
  49
  50     @Test
  51     void encode_givenNullPayload_shouldThrowEncodingException() {
  52         final ByteBuffer buffer = null;
  53
  54         Try<ByteBuf> encodedBuffer = wireFrameEncoder.encode(buffer);
  55
  56         assertThat(encodedBuffer.isFailure()).isTrue();
  57         assertThat(encodedBuffer.getCause()).isInstanceOf(WTPEncodingException.class);
  58     }
  59
  60     @Test
  61     void encode_givenEmptyPayload_shouldThrowEncodingException() {
  62         final ByteBuffer buffer = ByteBuffer.allocateDirect(0);
  63
  64         Try<ByteBuf> encodedBuffer = wireFrameEncoder.encode(buffer);
  65
  66         assertThat(encodedBuffer.isFailure()).isTrue();
  67         assertThat(encodedBuffer.getCause()).isInstanceOf(WTPEncodingException.class);
  68     }
  69
  70     @Test
  71     void encode_givenSomePayloadBytes_shouldCreateValidGPBFrameWithPayloadAtTheEnd() {
  72         final byte[] payloadBytes = new byte[]{0x1A, 0x2B, 0x3C};
  73         final int bufferSize = payloadBytes.length;
  74         final ByteBuffer buffer = ByteBuffer.wrap(payloadBytes);
  75
  76         final Try<ByteBuf> encodedBuffer = wireFrameEncoder.encode(buffer);
  77
  78         assertThat(encodedBuffer.isSuccess()).isTrue();
  79         final ByteBuf actualEncodedBuffer = encodedBuffer.get();
  80         assertBufferSizeIs(actualEncodedBuffer, HEADER_SIZE + bufferSize);
  81         assertValidHeaderBeggining(actualEncodedBuffer);
  82         skipReservedBytes(actualEncodedBuffer);
  83         assertNextBytesAreInOrder(actualEncodedBuffer, (byte) 0x00, (byte) 0x01);
  84         assertNextBytesAreInOrder(actualEncodedBuffer, intToBytes(bufferSize));
  85         assertNextBytesAreInOrder(actualEncodedBuffer, payloadBytes);
  86         assertAllBytesVerified(actualEncodedBuffer);
  87     }
  88
  89     @Test
  90     void encode_givenSomePayloadBytes_shouldCreateValidGPBFrameWithSpecifiedWTPVersion() {
  91         // given
  92         WireFrameVersion wireFrameVersion = ImmutableWireFrameVersion.of(SAMPLE_VERSION_MAJOR, SAMPLE_VERSION_MINOR);
  93         final WireFrameEncoder encoder = new WireFrameEncoder(ByteBufAllocator.DEFAULT, wireFrameVersion);
  94         final byte[] payloadBytes = new byte[]{0x1A, 0x2B, 0x3C};
  95         final ByteBuffer buffer = ByteBuffer.wrap(payloadBytes);
  96
  97         // when
  98         final Try<ByteBuf> encodedBuffer = encoder.encode(buffer);
  99
 100         // then
 101         assertThat(encodedBuffer.isSuccess()).isTrue();
 102         final ByteBuf versionBuffer = encodedBuffer.get();
 103         assertValidHeaderBeggining(versionBuffer, SAMPLE_VERSION_MAJOR, SAMPLE_VERSION_MINOR);
 104     }
 105
 106     private void assertNextBytesAreInOrder(ByteBuf encodedBuffer, byte... bytes) {
 107         for (int i = 0; i < bytes.length; i++) {
 108             assertThat(encodedBuffer.readByte())
 109                     .describedAs("byte in " + (i + 1) + " assertion")
 110                     .isEqualTo(bytes[i]);
 111         }
 112     }
 113
 114     private void assertValidHeaderBeggining(ByteBuf encodedBuffer) {
 115         assertValidHeaderBeggining(encodedBuffer, SUPPORTED_VERSION_MAJOR, SUPPORTED_VERSION_MINOR);
 116     }
 117
 118     private void assertValidHeaderBeggining(ByteBuf encodedBuffer, byte majorWTPVersion, byte minorWTPVersion) {
 119         assertNextBytesAreInOrder(encodedBuffer,
 120                 MARKER_BYTE,
 121                 majorWTPVersion,
 122                 minorWTPVersion);
 123     }
 124
 125     private void assertBufferSizeIs(ByteBuf encodedBuffer, int headerSize) {
 126         assertThat(encodedBuffer.readableBytes()).describedAs("buffer's readable bytes").isEqualTo(headerSize);
 127     }
 128
 129     private void skipReservedBytes(ByteBuf encodedBuffer) {
 130         encodedBuffer.readBytes(RESERVED_BYTES_COUNT);
 131     }
 132
 133     private void assertAllBytesVerified(ByteBuf encodedBuffer) {
 134         assertThat(encodedBuffer.readableBytes())
 135                 .describedAs("all bytes should've been asserted")
 136                 .isEqualTo(0);
 137     }
 138
 139     private byte[] intToBytes(int integer) {
 140         return ByteBuffer.allocate(4).putInt(integer).array();
 141     }
 142 }