p71924506
/
aosp12
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
aosp12/external/openscreen/cast/streaming/receiver_session_unittest.cc

696 lines
24 KiB
C++
Raw Blame History

// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cast/streaming/receiver_session.h"
#include <utility>
#include "cast/streaming/mock_environment.h"
#include "cast/streaming/receiver.h"
#include "cast/streaming/testing/simple_message_port.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "platform/base/ip_address.h"
#include "platform/test/fake_clock.h"
#include "platform/test/fake_task_runner.h"
#include "util/chrono_helpers.h"
using ::testing::_;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::StrictMock;
namespace openscreen {
namespace cast {
namespace {
constexpr char kValidOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337,
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": [
{
"index": 31337,
"type": "video_source",
"codecName": "vp9",
"rtpProfile": "cast",
"rtpPayloadType": 127,
"ssrc": 19088743,
"maxFrameRate": "60000/1000",
"timeBase": "1/90000",
"maxBitRate": 5000000,
"profile": "main",
"level": "4",
"aesKey": "bbf109bf84513b456b13a184453b66ce",
"aesIvMask": "edaf9e4536e2b66191f560d9c04b2a69",
"resolutions": [
{
"width": 1280,
"height": 720
}
]
},
{
"index": 31338,
"type": "video_source",
"codecName": "vp8",
"rtpProfile": "cast",
"rtpPayloadType": 127,
"ssrc": 19088745,
"maxFrameRate": "60000/1000",
"timeBase": "1/90000",
"maxBitRate": 5000000,
"profile": "main",
"level": "4",
"aesKey": "040d756791711fd3adb939066e6d8690",
"aesIvMask": "9ff0f022a959150e70a2d05a6c184aed",
"resolutions": [
{
"width": 1280,
"height": 720
}
]
},
{
"index": 1337,
"type": "audio_source",
"codecName": "opus",
"rtpProfile": "cast",
"rtpPayloadType": 97,
"ssrc": 19088747,
"bitRate": 124000,
"timeBase": "1/48000",
"channels": 2,
"aesKey": "51027e4e2347cbcb49d57ef10177aebc",
"aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
}
]
}
})";
constexpr char kNoAudioOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337,
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": [
{
"index": 31338,
"type": "video_source",
"codecName": "vp8",
"rtpProfile": "cast",
"rtpPayloadType": 127,
"ssrc": 19088745,
"maxFrameRate": "60000/1000",
"timeBase": "1/90000",
"maxBitRate": 5000000,
"profile": "main",
"level": "4",
"aesKey": "040d756791711fd3adb939066e6d8690",
"aesIvMask": "9ff0f022a959150e70a2d05a6c184aed",
"resolutions": [
{
"width": 1280,
"height": 720
}
]
}
]
}
})";
constexpr char kInvalidCodecOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337,
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": [
{
"index": 31338,
"type": "video_source",
"codecName": "vp12",
"rtpProfile": "cast",
"rtpPayloadType": 127,
"ssrc": 19088745,
"maxFrameRate": "60000/1000",
"timeBase": "1/90000",
"maxBitRate": 5000000,
"profile": "main",
"level": "4",
"aesKey": "040d756791711fd3adb939066e6d8690",
"aesIvMask": "9ff0f022a959150e70a2d05a6c184aed",
"resolutions": [
{
"width": 1280,
"height": 720
}
]
}
]
}
})";
constexpr char kNoVideoOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337,
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": [
{
"index": 1337,
"type": "audio_source",
"codecName": "opus",
"rtpProfile": "cast",
"rtpPayloadType": 97,
"ssrc": 19088747,
"bitRate": 124000,
"timeBase": "1/48000",
"channels": 2,
"aesKey": "51027e4e2347cbcb49d57ef10177aebc",
"aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
}
]
}
})";
constexpr char kNoAudioOrVideoOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337,
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": []
}
})";
constexpr char kInvalidJsonOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337,
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": [
}
})";
constexpr char kMissingMandatoryFieldOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337
})";
constexpr char kMissingSeqNumOfferMessage[] = R"({
"type": "OFFER",
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": []
}
})";
constexpr char kValidJsonInvalidFormatOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337,
"offer": {
"castMode": "mirroring",
"receiverGetStatus": true,
"supportedStreams": "anything"
}
})";
constexpr char kNullJsonOfferMessage[] = R"({
"type": "OFFER",
"seqNum": 1337
})";
constexpr char kInvalidSequenceNumberMessage[] = R"({
"type": "OFFER",
"seqNum": "not actually a number"
})";
constexpr char kUnknownTypeMessage[] = R"({
"type": "OFFER_VERSION_2",
"seqNum": 1337
})";
constexpr char kInvalidTypeMessage[] = R"({
"type": 39,
"seqNum": 1337
})";
class FakeClient : public ReceiverSession::Client {
public:
MOCK_METHOD(void,
OnMirroringNegotiated,
(const ReceiverSession*, ReceiverSession::ConfiguredReceivers),
(override));
MOCK_METHOD(void,
OnReceiversDestroying,
(const ReceiverSession*, ReceiversDestroyingReason),
(override));
MOCK_METHOD(void, OnError, (const ReceiverSession*, Error error), (override));
};
void ExpectIsErrorAnswerMessage(const ErrorOr<Json::Value>& message_or_error) {
EXPECT_TRUE(message_or_error.is_value());
const Json::Value message = std::move(message_or_error.value());
EXPECT_TRUE(message["answer"].isNull());
EXPECT_EQ("error", message["result"].asString());
EXPECT_EQ(1337, message["seqNum"].asInt());
EXPECT_EQ("ANSWER", message["type"].asString());
const Json::Value& error = message["error"];
EXPECT_TRUE(error.isObject());
EXPECT_GT(error["code"].asInt(), 0);
}
} // namespace
class ReceiverSessionTest : public ::testing::Test {
public:
ReceiverSessionTest() : clock_(Clock::time_point{}), task_runner_(&clock_) {}
std::unique_ptr<MockEnvironment> MakeEnvironment() {
auto environment_ = std::make_unique<NiceMock<MockEnvironment>>(
&FakeClock::now, &task_runner_);
ON_CALL(*environment_, GetBoundLocalEndpoint())
.WillByDefault(Return(IPEndpoint{{127, 0, 0, 1}, 12345}));
environment_->set_socket_state_for_testing(
Environment::SocketState::kReady);
return environment_;
}
void SetUp() {
message_port_ = std::make_unique<SimpleMessagePort>("sender-12345");
environment_ = MakeEnvironment();
session_ = std::make_unique<ReceiverSession>(
&client_, environment_.get(), message_port_.get(),
ReceiverSession::Preferences{});
}
protected:
void AssertGotAnErrorAnswerResponse() {
const auto& messages = message_port_->posted_messages();
ASSERT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
ExpectIsErrorAnswerMessage(message_body);
}
StrictMock<FakeClient> client_;
FakeClock clock_;
std::unique_ptr<MockEnvironment> environment_;
std::unique_ptr<SimpleMessagePort> message_port_;
std::unique_ptr<ReceiverSession> session_;
FakeTaskRunner task_runner_;
};
TEST_F(ReceiverSessionTest, CanNegotiateWithDefaultPreferences) {
InSequence s;
EXPECT_CALL(client_, OnMirroringNegotiated(session_.get(), _))
.WillOnce([](const ReceiverSession* session_,
ReceiverSession::ConfiguredReceivers cr) {
EXPECT_TRUE(cr.audio_receiver);
EXPECT_EQ(cr.audio_receiver->config().sender_ssrc, 19088747u);
EXPECT_EQ(cr.audio_receiver->config().receiver_ssrc, 19088748u);
EXPECT_EQ(cr.audio_receiver->config().channels, 2);
EXPECT_EQ(cr.audio_receiver->config().rtp_timebase, 48000);
// We should have chosen opus
EXPECT_EQ(cr.audio_config.codec, AudioCodec::kOpus);
EXPECT_TRUE(cr.video_receiver);
EXPECT_EQ(cr.video_receiver->config().sender_ssrc, 19088745u);
EXPECT_EQ(cr.video_receiver->config().receiver_ssrc, 19088746u);
EXPECT_EQ(cr.video_receiver->config().channels, 1);
EXPECT_EQ(cr.video_receiver->config().rtp_timebase, 90000);
// We should have chosen vp8
EXPECT_EQ(cr.video_config.codec, VideoCodec::kVp8);
});
EXPECT_CALL(client_,
OnReceiversDestroying(session_.get(),
ReceiverSession::Client::kEndOfSession));
message_port_->ReceiveMessage(kValidOfferMessage);
const auto& messages = message_port_->posted_messages();
ASSERT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
const Json::Value answer = std::move(message_body.value());
EXPECT_EQ("ANSWER", answer["type"].asString());
EXPECT_EQ(1337, answer["seqNum"].asInt());
EXPECT_EQ("ok", answer["result"].asString());
const Json::Value& answer_body = answer["answer"];
EXPECT_TRUE(answer_body.isObject());
// Spot check the answer body fields. We have more in depth testing
// of answer behavior in answer_messages_unittest, but here we can
// ensure that the ReceiverSession properly configured the answer.
EXPECT_EQ(1337, answer_body["sendIndexes"][0].asInt());
EXPECT_EQ(31338, answer_body["sendIndexes"][1].asInt());
EXPECT_LT(0, answer_body["udpPort"].asInt());
EXPECT_GT(65535, answer_body["udpPort"].asInt());
// Get status should always be false, as we have no plans to implement it.
EXPECT_EQ(false, answer_body["receiverGetStatus"].asBool());
// Constraints and display should not be present with no preferences.
EXPECT_TRUE(answer_body["constraints"].isNull());
EXPECT_TRUE(answer_body["display"].isNull());
}
TEST_F(ReceiverSessionTest, CanNegotiateWithCustomCodecPreferences) {
ReceiverSession session(
&client_, environment_.get(), message_port_.get(),
ReceiverSession::Preferences{{VideoCodec::kVp9}, {AudioCodec::kOpus}});
InSequence s;
EXPECT_CALL(client_, OnMirroringNegotiated(&session, _))
.WillOnce([](const ReceiverSession* session_,
ReceiverSession::ConfiguredReceivers cr) {
EXPECT_TRUE(cr.audio_receiver);
EXPECT_EQ(cr.audio_receiver->config().sender_ssrc, 19088747u);
EXPECT_EQ(cr.audio_receiver->config().receiver_ssrc, 19088748u);
EXPECT_EQ(cr.audio_receiver->config().channels, 2);
EXPECT_EQ(cr.audio_receiver->config().rtp_timebase, 48000);
EXPECT_EQ(cr.audio_config.codec, AudioCodec::kOpus);
EXPECT_TRUE(cr.video_receiver);
EXPECT_EQ(cr.video_receiver->config().sender_ssrc, 19088743u);
EXPECT_EQ(cr.video_receiver->config().receiver_ssrc, 19088744u);
EXPECT_EQ(cr.video_receiver->config().channels, 1);
EXPECT_EQ(cr.video_receiver->config().rtp_timebase, 90000);
EXPECT_EQ(cr.video_config.codec, VideoCodec::kVp9);
});
EXPECT_CALL(client_, OnReceiversDestroying(
&session, ReceiverSession::Client::kEndOfSession));
message_port_->ReceiveMessage(kValidOfferMessage);
}
TEST_F(ReceiverSessionTest, CanNegotiateWithCustomConstraints) {
auto constraints = std::make_unique<Constraints>(Constraints{
AudioConstraints{48001, 2, 32001, 32002, milliseconds(3001)},
VideoConstraints{3.14159,
absl::optional<Dimensions>(
Dimensions{320, 240, SimpleFraction{24, 1}}),
Dimensions{1920, 1080, SimpleFraction{144, 1}}, 300000,
90000000, milliseconds(1000)}});
auto display = std::make_unique<DisplayDescription>(DisplayDescription{
absl::optional<Dimensions>(Dimensions{640, 480, SimpleFraction{60, 1}}),
absl::optional<AspectRatio>(AspectRatio{16, 9}),
absl::optional<AspectRatioConstraint>(AspectRatioConstraint::kFixed)});
ReceiverSession session(&client_, environment_.get(), message_port_.get(),
ReceiverSession::Preferences{{VideoCodec::kVp9},
{AudioCodec::kOpus},
std::move(constraints),
std::move(display)});
InSequence s;
EXPECT_CALL(client_, OnMirroringNegotiated(&session, _));
EXPECT_CALL(client_, OnReceiversDestroying(
&session, ReceiverSession::Client::kEndOfSession));
message_port_->ReceiveMessage(kValidOfferMessage);
const auto& messages = message_port_->posted_messages();
ASSERT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
ASSERT_TRUE(message_body.is_value());
const Json::Value answer = std::move(message_body.value());
const Json::Value& answer_body = answer["answer"];
ASSERT_TRUE(answer_body.isObject());
// Constraints and display should be valid with valid preferences.
ASSERT_FALSE(answer_body["constraints"].isNull());
ASSERT_FALSE(answer_body["display"].isNull());
const Json::Value& display_json = answer_body["display"];
EXPECT_EQ("16:9", display_json["aspectRatio"].asString());
EXPECT_EQ("60", display_json["dimensions"]["frameRate"].asString());
EXPECT_EQ(640, display_json["dimensions"]["width"].asInt());
EXPECT_EQ(480, display_json["dimensions"]["height"].asInt());
EXPECT_EQ("sender", display_json["scaling"].asString());
const Json::Value& constraints_json = answer_body["constraints"];
ASSERT_TRUE(constraints_json.isObject());
const Json::Value& audio = constraints_json["audio"];
ASSERT_TRUE(audio.isObject());
EXPECT_EQ(32002, audio["maxBitRate"].asInt());
EXPECT_EQ(2, audio["maxChannels"].asInt());
EXPECT_EQ(3001, audio["maxDelay"].asInt());
EXPECT_EQ(48001, audio["maxSampleRate"].asInt());
EXPECT_EQ(32001, audio["minBitRate"].asInt());
const Json::Value& video = constraints_json["video"];
ASSERT_TRUE(video.isObject());
EXPECT_EQ(90000000, video["maxBitRate"].asInt());
EXPECT_EQ(1000, video["maxDelay"].asInt());
EXPECT_EQ("144", video["maxDimensions"]["frameRate"].asString());
EXPECT_EQ(1920, video["maxDimensions"]["width"].asInt());
EXPECT_EQ(1080, video["maxDimensions"]["height"].asInt());
EXPECT_DOUBLE_EQ(3.14159, video["maxPixelsPerSecond"].asDouble());
EXPECT_EQ(300000, video["minBitRate"].asInt());
EXPECT_EQ("24", video["minDimensions"]["frameRate"].asString());
EXPECT_EQ(320, video["minDimensions"]["width"].asInt());
EXPECT_EQ(240, video["minDimensions"]["height"].asInt());
}
TEST_F(ReceiverSessionTest, HandlesNoValidAudioStream) {
InSequence s;
EXPECT_CALL(client_, OnMirroringNegotiated(session_.get(), _));
EXPECT_CALL(client_,
OnReceiversDestroying(session_.get(),
ReceiverSession::Client::kEndOfSession));
message_port_->ReceiveMessage(kNoAudioOfferMessage);
const auto& messages = message_port_->posted_messages();
EXPECT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
const Json::Value& answer_body = message_body.value()["answer"];
EXPECT_TRUE(answer_body.isObject());
// Should still select video stream.
EXPECT_EQ(1u, answer_body["sendIndexes"].size());
EXPECT_EQ(31338, answer_body["sendIndexes"][0].asInt());
EXPECT_EQ(1u, answer_body["ssrcs"].size());
EXPECT_EQ(19088746, answer_body["ssrcs"][0].asInt());
}
TEST_F(ReceiverSessionTest, HandlesInvalidCodec) {
// We didn't select any streams, but didn't have any errors either.
message_port_->ReceiveMessage(kInvalidCodecOfferMessage);
const auto& messages = message_port_->posted_messages();
EXPECT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
// We should have failed to produce a valid answer message due to not
// selecting any stream.
EXPECT_EQ("error", message_body.value()["result"].asString());
}
TEST_F(ReceiverSessionTest, HandlesNoValidVideoStream) {
InSequence s;
EXPECT_CALL(client_, OnMirroringNegotiated(session_.get(), _));
EXPECT_CALL(client_,
OnReceiversDestroying(session_.get(),
ReceiverSession::Client::kEndOfSession));
message_port_->ReceiveMessage(kNoVideoOfferMessage);
const auto& messages = message_port_->posted_messages();
EXPECT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
const Json::Value& answer_body = message_body.value()["answer"];
EXPECT_TRUE(answer_body.isObject());
// Should still select audio stream.
EXPECT_EQ(1u, answer_body["sendIndexes"].size());
EXPECT_EQ(1337, answer_body["sendIndexes"][0].asInt());
EXPECT_EQ(1u, answer_body["ssrcs"].size());
EXPECT_EQ(19088748, answer_body["ssrcs"][0].asInt());
}
TEST_F(ReceiverSessionTest, HandlesNoValidStreams) {
// We shouldn't call OnMirroringNegotiated if we failed to negotiate any
// streams.
message_port_->ReceiveMessage(kNoAudioOrVideoOfferMessage);
AssertGotAnErrorAnswerResponse();
}
TEST_F(ReceiverSessionTest, HandlesMalformedOffer) {
// Note that unlike when we simply don't select any streams, when the offer
// is not valid JSON we actually have no way of knowing it's an offer at all,
// so we call OnError and do not reply with an Answer.
EXPECT_CALL(client_, OnError(session_.get(), _));
message_port_->ReceiveMessage(kInvalidJsonOfferMessage);
}
TEST_F(ReceiverSessionTest, HandlesMissingSeqNumInOffer) {
// If the OFFER is missing a sequence number it gets rejected before being
// parsed as an OFFER, since the sender expects all messages to come back
// with a sequence number.
message_port_->ReceiveMessage(kMissingSeqNumOfferMessage);
}
TEST_F(ReceiverSessionTest, HandlesOfferMissingMandatoryFields) {
// If the OFFER is missing mandatory fields, we notify the client as well as
// reply with an error-case Answer.
EXPECT_CALL(client_, OnError(session_.get(), _));
message_port_->ReceiveMessage(kMissingMandatoryFieldOfferMessage);
AssertGotAnErrorAnswerResponse();
}
TEST_F(ReceiverSessionTest, HandlesImproperlyFormattedOffer) {
EXPECT_CALL(client_, OnError(session_.get(), _));
message_port_->ReceiveMessage(kValidJsonInvalidFormatOfferMessage);
AssertGotAnErrorAnswerResponse();
}
TEST_F(ReceiverSessionTest, HandlesNullOffer) {
EXPECT_CALL(client_, OnError(session_.get(), _));
message_port_->ReceiveMessage(kNullJsonOfferMessage);
AssertGotAnErrorAnswerResponse();
}
TEST_F(ReceiverSessionTest, HandlesInvalidSequenceNumber) {
// We should just discard messages with an invalid sequence number.
message_port_->ReceiveMessage(kInvalidSequenceNumberMessage);
}
TEST_F(ReceiverSessionTest, HandlesUnknownTypeMessage) {
// We should just discard messages with an unknown message type.
message_port_->ReceiveMessage(kUnknownTypeMessage);
}
TEST_F(ReceiverSessionTest, HandlesInvalidTypeMessage) {
// We should just discard messages with an invalid message type.
message_port_->ReceiveMessage(kInvalidTypeMessage);
}
TEST_F(ReceiverSessionTest, DoesNotCrashOnMessagePortError) {
message_port_->ReceiveError(Error(Error::Code::kUnknownError));
}
TEST_F(ReceiverSessionTest, NotifiesReceiverDestruction) {
InSequence s;
EXPECT_CALL(client_, OnMirroringNegotiated(session_.get(), _));
EXPECT_CALL(client_,
OnReceiversDestroying(session_.get(),
ReceiverSession::Client::kRenegotiated));
EXPECT_CALL(client_, OnMirroringNegotiated(session_.get(), _));
EXPECT_CALL(client_,
OnReceiversDestroying(session_.get(),
ReceiverSession::Client::kEndOfSession));
message_port_->ReceiveMessage(kNoAudioOfferMessage);
message_port_->ReceiveMessage(kValidOfferMessage);
}
TEST_F(ReceiverSessionTest, HandlesInvalidAnswer) {
// Simulate an unbound local endpoint.
EXPECT_CALL(*environment_, GetBoundLocalEndpoint)
.WillOnce(Return(IPEndpoint{}));
message_port_->ReceiveMessage(kValidOfferMessage);
const auto& messages = message_port_->posted_messages();
ASSERT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
const Json::Value answer = std::move(message_body.value());
EXPECT_EQ("ANSWER", answer["type"].asString());
EXPECT_EQ("error", answer["result"].asString());
}
TEST_F(ReceiverSessionTest, DelaysAnswerUntilEnvironmentIsReady) {
environment_->set_socket_state_for_testing(
Environment::SocketState::kStarting);
// We should not have sent an answer yet--the UDP socket is not ready.
message_port_->ReceiveMessage(kValidOfferMessage);
ASSERT_TRUE(message_port_->posted_messages().empty());
// Simulate the environment calling back into us with the socket being ready.
// state() will not be called again--we just need to get the bind event.
EXPECT_CALL(*environment_, GetBoundLocalEndpoint())
.WillOnce(Return(IPEndpoint{{10, 0, 0, 2}, 4567}));
EXPECT_CALL(client_, OnMirroringNegotiated(session_.get(), _));
EXPECT_CALL(client_,
OnReceiversDestroying(session_.get(),
ReceiverSession::Client::kEndOfSession));
session_->OnSocketReady();
const auto& messages = message_port_->posted_messages();
ASSERT_EQ(1u, messages.size());
// We should have set the UDP port based on the ready socket value.
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
const Json::Value& answer_body = message_body.value()["answer"];
EXPECT_TRUE(answer_body.isObject());
EXPECT_EQ(4567, answer_body["udpPort"].asInt());
}
TEST_F(ReceiverSessionTest,
ReturnsErrorAnswerIfEnvironmentIsAlreadyInvalidated) {
environment_->set_socket_state_for_testing(
Environment::SocketState::kInvalid);
// If the environment is already in a bad state, we can respond immediately.
message_port_->ReceiveMessage(kValidOfferMessage);
const auto& messages = message_port_->posted_messages();
ASSERT_EQ(1u, messages.size());
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
EXPECT_EQ("ANSWER", message_body.value()["type"].asString());
EXPECT_EQ("error", message_body.value()["result"].asString());
}
TEST_F(ReceiverSessionTest, ReturnsErrorAnswerIfEnvironmentIsInvalidated) {
environment_->set_socket_state_for_testing(
Environment::SocketState::kStarting);
// We should not have sent an answer yet--the environment is not ready.
message_port_->ReceiveMessage(kValidOfferMessage);
ASSERT_TRUE(message_port_->posted_messages().empty());
// Simulate the environment calling back into us with invalidation.
EXPECT_CALL(client_, OnError(_, _)).Times(1);
session_->OnSocketInvalid(Error::Code::kSocketBindFailure);
const auto& messages = message_port_->posted_messages();
ASSERT_EQ(1u, messages.size());
// We should have an error answer.
auto message_body = json::Parse(messages[0]);
EXPECT_TRUE(message_body.is_value());
EXPECT_EQ("ANSWER", message_body.value()["type"].asString());
EXPECT_EQ("error", message_body.value()["result"].asString());
}
} // namespace cast
} // namespace openscreen
Reference in New Issue View Git Blame Copy Permalink