Skip to content

MessageInStream_8ut_8cpp

Jump to bottom Edit New page
github-actions edited this page Mar 15, 2026 · 3 revisions

title: src/Messenger/MessageInStream.ut.cpp

src/Messenger/MessageInStream.ut.cpp

Namespaces

Name
aasdk
aasdk::messenger
aasdk::messenger::ut

Classes

Name
class aasdk::messenger::ut::MessageInStreamUnitTest

Source code

/*
*  This file is part of aasdk library project.
*  Copyright (C) 2018 f1x.studio (Michal Szwaj)
*
*  aasdk is free software: you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation; either version 3 of the License, or
*  (at your option) any later version.

*  aasdk is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*  GNU General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with aasdk. If not, see <http://www.gnu.org/licenses/>.
*/

#include <gtest/gtest.h>
#include <aap_protobuf/service/control/ControlMessageType.pb.h>
#include <aasdk/Messenger/MessageId.hpp>
#include <aasdk/Transport/UT/Transport.mock.hpp>
#include <aasdk/Messenger/UT/Cryptor.mock.hpp>
#include <aasdk/Messenger/UT/ReceivePromiseHandler.mock.hpp>
#include <aasdk/Messenger/Promise.hpp>
#include <aasdk/Messenger/MessageInStream.hpp>


namespace aasdk
{
namespace messenger
{
namespace ut
{

using ::testing::_;
using ::testing::DoAll;
using ::testing::SaveArg;
using ::testing::SetArgReferee;
using ::testing::Return;

class MessageInStreamUnitTest : public testing::Test
{
protected:
    MessageInStreamUnitTest()
        : transport_(&transportMock_, [](auto*) {})
        , cryptor_(&cryptorMock_, [](auto*) {})
        , receivePromise_(ReceivePromise::defer(ioService_))
    {
        receivePromise_->then(std::bind(&ReceivePromiseHandlerMock::onResolve, &receivePromiseHandlerMock_, std::placeholders::_1),
                             std::bind(&ReceivePromiseHandlerMock::onReject, &receivePromiseHandlerMock_, std::placeholders::_1));
    }

    boost::asio::io_service ioService_;
    transport::ut::TransportMock transportMock_;
    transport::ITransport::Pointer transport_;
    CryptorMock cryptorMock_;
    ICryptor::Pointer cryptor_;
    ReceivePromiseHandlerMock receivePromiseHandlerMock_;
    ReceivePromise::Pointer receivePromise_;
};


ACTION(ThrowSSLReadException)
{
    throw error::Error(error::ErrorCode::SSL_READ, 123);
}

TEST_F(MessageInStreamUnitTest, MessageInStream_ReceivePlainMessage)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::BLUETOOTH, FrameType::BULK, EncryptionType::PLAIN, MessageType::SPECIFIC);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data framePayload(1000, 0x5E);
    FrameSize frameSize(framePayload.size());
    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer framePayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(framePayload.size(), _)).WillOnce(SaveArg<1>(&framePayloadTransportPromise));
    frameSizeTransportPromise->resolve(frameSize.getData());

    ioService_.run();
    ioService_.reset();

    Message::Pointer message;
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(_)).Times(0);
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).WillOnce(SaveArg<0>(&message));
    framePayloadTransportPromise->resolve(framePayload);

    ioService_.run();

    EXPECT_TRUE(message->getChannelId() == ChannelId::BLUETOOTH);
    EXPECT_TRUE(message->getEncryptionType() == EncryptionType::PLAIN);
    EXPECT_TRUE(message->getType() == MessageType::SPECIFIC);

    const auto& payload = message->getPayload();
    EXPECT_THAT(payload, testing::ContainerEq(framePayload));
}

TEST_F(MessageInStreamUnitTest, MessageInStream_ReceiveEncryptedMessage)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::MEDIA_SINK_VIDEO, FrameType::BULK, EncryptionType::ENCRYPTED, MessageType::CONTROL);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data framePayload(1000, 0x5E);
    FrameSize frameSize(framePayload.size());
    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Promise::Pointer framePayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(framePayload.size(), _)).WillOnce(SaveArg<1>(&framePayloadTransportPromise));

    common::Data decryptedPayload(500, 0x5F);
    ON_CALL(cryptorMock_, isActive()).WillByDefault(Return(true));
    EXPECT_CALL(cryptorMock_, decrypt(_, _, _)).WillOnce(DoAll(SetArgReferee<0>(decryptedPayload), Return(decryptedPayload.size())));
    frameSizeTransportPromise->resolve(frameSize.getData());

    ioService_.run();
    ioService_.reset();

    Message::Pointer message;
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(_)).Times(0);
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).WillOnce(SaveArg<0>(&message));
    framePayloadTransportPromise->resolve(framePayload);

    ioService_.run();

    EXPECT_TRUE(message->getChannelId() == ChannelId::MEDIA_SINK_VIDEO);
    EXPECT_TRUE(message->getEncryptionType() == EncryptionType::ENCRYPTED);
    EXPECT_TRUE(message->getType() == MessageType::CONTROL);

    const auto& payload = message->getPayload();
    EXPECT_THAT(payload, testing::ContainerEq(decryptedPayload));
}

TEST_F(MessageInStreamUnitTest, MessageInStream_MessageDecryptionFailed)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::MEDIA_SINK_VIDEO, FrameType::BULK, EncryptionType::ENCRYPTED, MessageType::CONTROL);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data framePayload(1000, 0x5E);
    FrameSize frameSize(framePayload.size());
    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer framePayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(framePayload.size(), _)).WillOnce(SaveArg<1>(&framePayloadTransportPromise));

    common::Data decryptedPayload(500, 0x5F);
    ON_CALL(cryptorMock_, isActive()).WillByDefault(Return(true));
    EXPECT_CALL(cryptorMock_, decrypt(_, _, _)).WillOnce(ThrowSSLReadException());
    frameSizeTransportPromise->resolve(frameSize.getData());

    ioService_.run();
    ioService_.reset();

    EXPECT_CALL(receivePromiseHandlerMock_, onReject(error::Error(error::ErrorCode::SSL_READ, 123)));
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).Times(0);
    framePayloadTransportPromise->resolve(framePayload);

    ioService_.run();
}

TEST_F(MessageInStreamUnitTest, MessageInStream_FramePayloadReceiveFailed)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::BLUETOOTH, FrameType::BULK, EncryptionType::PLAIN, MessageType::SPECIFIC);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data framePayload(1000, 0x5E);
    FrameSize frameSize(framePayload.size());
    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer framePayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(framePayload.size(), _)).WillOnce(SaveArg<1>(&framePayloadTransportPromise));
    frameSizeTransportPromise->resolve(frameSize.getData());

    ioService_.run();
    ioService_.reset();

    error::Error e(error::ErrorCode::USB_TRANSFER, 5);
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(e));
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).Times(0);
    framePayloadTransportPromise->reject(e);

    ioService_.run();
}

TEST_F(MessageInStreamUnitTest, MessageInStream_FramePayloadSizeReceiveFailed)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::BLUETOOTH, FrameType::BULK, EncryptionType::PLAIN, MessageType::SPECIFIC);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    error::Error e(error::ErrorCode::USB_TRANSFER, 5);
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(e));
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).Times(0);
    frameSizeTransportPromise->reject(e);

    ioService_.run();
}

TEST_F(MessageInStreamUnitTest, MessageInStream_FrameHeaderReceiveFailed)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::BLUETOOTH, FrameType::BULK, EncryptionType::PLAIN, MessageType::SPECIFIC);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    error::Error e(error::ErrorCode::USB_TRANSFER, 5);
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(e));
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).Times(0);
    frameHeaderTransportPromise->reject(e);

    ioService_.run();
}

TEST_F(MessageInStreamUnitTest, MessageInStream_ReceiveSplittedMessage)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));
    FrameHeader frame1Header(ChannelId::BLUETOOTH, FrameType::FIRST, EncryptionType::PLAIN, MessageType::SPECIFIC);

    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).Times(2).WillRepeatedly(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data frame1Payload(1000, 0x5E);
    common::Data frame2Payload(2000, 0x5F);
    common::Data expectedPayload(frame1Payload.begin(), frame1Payload.end());
    expectedPayload.insert(expectedPayload.end(), frame2Payload.begin(), frame2Payload.end());

    transport::ITransport::ReceivePromise::Pointer frame1SizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::EXTENDED), _)).WillOnce(SaveArg<1>(&frame1SizeTransportPromise));
    frameHeaderTransportPromise->resolve(frame1Header.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer frame1PayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(frame1Payload.size(), _)).WillOnce(SaveArg<1>(&frame1PayloadTransportPromise));
    FrameSize frame1Size(frame1Payload.size(), frame1Payload.size() + frame2Payload.size());
    frame1SizeTransportPromise->resolve(frame1Size.getData());

    ioService_.run();
    ioService_.reset();

    frame1PayloadTransportPromise->resolve(frame1Payload);

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer frame2SizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frame2SizeTransportPromise));

    FrameHeader frame2Header(ChannelId::BLUETOOTH, FrameType::LAST, EncryptionType::PLAIN, MessageType::SPECIFIC);
    frameHeaderTransportPromise->resolve(frame2Header.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer frame2PayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(frame2Payload.size(), _)).WillOnce(SaveArg<1>(&frame2PayloadTransportPromise));
    FrameSize frame2Size(frame2Payload.size());
    frame2SizeTransportPromise->resolve(frame2Size.getData());

    ioService_.run();
    ioService_.reset();

    Message::Pointer message;
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(_)).Times(0);
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).WillOnce(SaveArg<0>(&message));
    frame2PayloadTransportPromise->resolve(frame2Payload);

    ioService_.run();

    EXPECT_TRUE(message->getChannelId() == ChannelId::BLUETOOTH);
    EXPECT_TRUE(message->getEncryptionType() == EncryptionType::PLAIN);
    EXPECT_TRUE(message->getType() == MessageType::SPECIFIC);

    const auto& payload = message->getPayload();
    EXPECT_THAT(payload, testing::ContainerEq(expectedPayload));
}

TEST_F(MessageInStreamUnitTest, MessageInStream_IntertwinedChannelsContinueReceivingWithoutResolving)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));
    FrameHeader frame1Header(ChannelId::BLUETOOTH, FrameType::FIRST, EncryptionType::PLAIN, MessageType::SPECIFIC);

    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    // FrameHeader::getSizeOf() == FrameSize::getSizeOf(SHORT) == 2, so all receive(2,_) calls
    // (3 header reads + 1 SHORT frame-size read) must share a single unified expectation.
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).Times(4).WillRepeatedly(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data frame1Payload(1000, 0x5E);
    common::Data frame2Payload(2000, 0x5F);

    transport::ITransport::ReceivePromise::Pointer frame1SizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::EXTENDED), _)).WillOnce(SaveArg<1>(&frame1SizeTransportPromise));
    frameHeaderTransportPromise->resolve(frame1Header.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer frame1PayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(frame1Payload.size(), _)).WillOnce(SaveArg<1>(&frame1PayloadTransportPromise));
    FrameSize frame1Size(frame1Payload.size(), frame1Payload.size() + frame2Payload.size());
    frame1SizeTransportPromise->resolve(frame1Size.getData());

    ioService_.run();
    ioService_.reset();

    frame1PayloadTransportPromise->resolve(frame1Payload);

    ioService_.run();
    ioService_.reset();

    FrameHeader frame2Header(ChannelId::MEDIA_SINK_VIDEO, FrameType::LAST, EncryptionType::PLAIN, MessageType::SPECIFIC);
    // Resolving frame2Header causes receiveFrameHeaderHandler to request the SHORT frame-size (2 bytes).
    // frameHeaderTransportPromise is reused — after ioService_.run() it will point to the size promise.
    frameHeaderTransportPromise->resolve(frame2Header.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer frame2PayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(frame2Payload.size(), _)).WillOnce(SaveArg<1>(&frame2PayloadTransportPromise));
    FrameSize frame2Size(frame2Payload.size());
    // frameHeaderTransportPromise now holds the SHORT frame-size promise (saved by WillRepeatedly above).
    frameHeaderTransportPromise->resolve(frame2Size.getData());

    ioService_.run();
    ioService_.reset();

    EXPECT_CALL(receivePromiseHandlerMock_, onReject(_)).Times(0);
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).Times(0);
    frame2PayloadTransportPromise->resolve(frame2Payload);

    ioService_.run();
}

TEST_F(MessageInStreamUnitTest, MessageInStream_InactiveCryptorTlsControlPayloadGetsEncapsulatedSslPrefix)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::CONTROL, FrameType::BULK, EncryptionType::ENCRYPTED, MessageType::CONTROL);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data framePayload{0x17, 0x03, 0x03, 0x00, 0x2A};
    FrameSize frameSize(framePayload.size());
    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer framePayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(framePayload.size(), _)).WillOnce(SaveArg<1>(&framePayloadTransportPromise));
    ON_CALL(cryptorMock_, isActive()).WillByDefault(Return(false));
    EXPECT_CALL(cryptorMock_, decrypt(_, _, _)).Times(0);
    frameSizeTransportPromise->resolve(frameSize.getData());

    ioService_.run();
    ioService_.reset();

    Message::Pointer message;
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(_)).Times(0);
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).WillOnce(SaveArg<0>(&message));
    framePayloadTransportPromise->resolve(framePayload);

    ioService_.run();

    common::Data expectedPayload = MessageId(
        aap_protobuf::service::control::message::ControlMessageType::MESSAGE_ENCAPSULATED_SSL).getData();
    expectedPayload.insert(expectedPayload.end(), framePayload.begin(), framePayload.end());
    EXPECT_THAT(message->getPayload(), testing::ContainerEq(expectedPayload));
}

TEST_F(MessageInStreamUnitTest, MessageInStream_InactiveCryptorNonTlsControlPayloadPassesThroughRaw)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::CONTROL, FrameType::BULK, EncryptionType::ENCRYPTED, MessageType::CONTROL);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data framePayload{0x01, 0x02, 0x03, 0x04};
    FrameSize frameSize(framePayload.size());
    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer framePayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(framePayload.size(), _)).WillOnce(SaveArg<1>(&framePayloadTransportPromise));
    ON_CALL(cryptorMock_, isActive()).WillByDefault(Return(false));
    EXPECT_CALL(cryptorMock_, decrypt(_, _, _)).Times(0);
    frameSizeTransportPromise->resolve(frameSize.getData());

    ioService_.run();
    ioService_.reset();

    Message::Pointer message;
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(_)).Times(0);
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).WillOnce(SaveArg<0>(&message));
    framePayloadTransportPromise->resolve(framePayload);

    ioService_.run();

    EXPECT_THAT(message->getPayload(), testing::ContainerEq(framePayload));
}

TEST_F(MessageInStreamUnitTest, MessageInStream_InactiveCryptorTlsVideoPayloadDoesNotSynthesizeControlMessageId)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::MEDIA_SINK_VIDEO, FrameType::BULK, EncryptionType::ENCRYPTED, MessageType::SPECIFIC);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ioService_.run();
    ioService_.reset();

    common::Data framePayload{0x17, 0x03, 0x03, 0x00, 0x10};
    FrameSize frameSize(framePayload.size());
    transport::ITransport::ReceivePromise::Pointer frameSizeTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameSize::getSizeOf(FrameSizeType::SHORT), _)).WillOnce(SaveArg<1>(&frameSizeTransportPromise));
    frameHeaderTransportPromise->resolve(frameHeader.getData());

    ioService_.run();
    ioService_.reset();

    transport::ITransport::ReceivePromise::Pointer framePayloadTransportPromise;
    EXPECT_CALL(transportMock_, receive(framePayload.size(), _)).WillOnce(SaveArg<1>(&framePayloadTransportPromise));
    ON_CALL(cryptorMock_, isActive()).WillByDefault(Return(false));
    EXPECT_CALL(cryptorMock_, decrypt(_, _, _)).Times(0);
    frameSizeTransportPromise->resolve(frameSize.getData());

    ioService_.run();
    ioService_.reset();

    Message::Pointer message;
    EXPECT_CALL(receivePromiseHandlerMock_, onReject(_)).Times(0);
    EXPECT_CALL(receivePromiseHandlerMock_, onResolve(_)).WillOnce(SaveArg<0>(&message));
    framePayloadTransportPromise->resolve(framePayload);

    ioService_.run();

    EXPECT_THAT(message->getPayload(), testing::ContainerEq(framePayload));
}

TEST_F(MessageInStreamUnitTest, MessageInStream_RejectWhenInProgress)
{
    MessageInStream::Pointer messageInStream(std::make_shared<MessageInStream>(ioService_, transport_, cryptor_));

    FrameHeader frameHeader(ChannelId::BLUETOOTH, FrameType::BULK, EncryptionType::PLAIN, MessageType::SPECIFIC);
    transport::ITransport::ReceivePromise::Pointer frameHeaderTransportPromise;
    EXPECT_CALL(transportMock_, receive(FrameHeader::getSizeOf(), _)).WillOnce(SaveArg<1>(&frameHeaderTransportPromise));

    messageInStream->startReceive(std::move(receivePromise_));

    ReceivePromiseHandlerMock secondReceivePromiseHandlerMock;
    auto secondReceivePromise = ReceivePromise::defer(ioService_);

    secondReceivePromise->then(std::bind(&ReceivePromiseHandlerMock::onResolve, &secondReceivePromiseHandlerMock, std::placeholders::_1),
                              std::bind(&ReceivePromiseHandlerMock::onReject, &secondReceivePromiseHandlerMock, std::placeholders::_1));

    EXPECT_CALL(secondReceivePromiseHandlerMock, onReject(error::Error(error::ErrorCode::OPERATION_IN_PROGRESS)));
    EXPECT_CALL(secondReceivePromiseHandlerMock, onResolve(_)).Times(0);
    messageInStream->startReceive(std::move(secondReceivePromise));
    ioService_.run();
}


}
}
}

Updated on 2026-03-15 at 09:02:41 +0000

Add a custom footer
Add a custom sidebar

Clone this wiki locally