// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chromeos/ash/components/network/network_sms_handler.h"

#include <memory>
#include <set>
#include <string>

#include "base/command_line.h"
#include "base/containers/contains.h"
#include "base/memory/raw_ptr.h"
#include "base/run_loop.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "base/values.h"
#include "chromeos/ash/components/dbus/shill/fake_sms_client.h"
#include "chromeos/ash/components/dbus/shill/modem_messaging_client.h"
#include "chromeos/ash/components/dbus/shill/shill_clients.h"
#include "chromeos/ash/components/dbus/shill/shill_device_client.h"
#include "chromeos/ash/components/dbus/shill/shill_service_client.h"
#include "chromeos/dbus/constants/dbus_switches.h"
#include "dbus/object_path.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"

namespace ash {

namespace {

const char kCellularDevicePath[] = "/org/freedesktop/ModemManager1/stub/0";
const char kCellularDeviceObjectPath1[] =
    "/org/freedesktop/ModemManager1/stub/0/Modem/0";
const char kCellularDeviceObjectPath2[] =
    "/org/freedesktop/ModemManager1/stub/0/Modem/1";
const char kSmsPath[] = "/SMS/0";
constexpr char kTestCellularServicePath1[] = "/service/stub/0";
constexpr char kTestCellularServicePath2[] = "/service/stub/1";
constexpr char kTestGuid1[] = "1";
constexpr char kTestGuid2[] = "2";
constexpr char kTestIccid1[] = "000000000000000000";
constexpr char kTestIccid2[] = "000000000000000001";

class TestObserver : public NetworkSmsHandler::Observer {
 public:
  TestObserver() = default;
  ~TestObserver() override = default;

  void MessageReceived(const base::Value::Dict& message) override {
    const std::string* text = message.FindString(NetworkSmsHandler::kTextKey);
    if (text)
      messages_.insert(*text);
  }

  void MessageReceivedFromNetwork(const std::string& guid,
                                  const TextMessageData& mesage_data) override {
    if (mesage_data.text.has_value()) {
      messages_.insert(*mesage_data.text);
      guid_messages_map_[guid].insert(*mesage_data.text);
    }
    if (mesage_data.number.has_value()) {
      EXPECT_EQ(FakeSMSClient::kNumber, *mesage_data.number);
    }

    if (mesage_data.timestamp.has_value()) {
      EXPECT_EQ(FakeSMSClient::kTimestamp, *mesage_data.timestamp);
    }
  }

  void ClearMessages() {
    messages_.clear();
    guid_messages_map_.clear();
  }

  // Returns the count for messages received across all cellular networks.
  int message_count() { return messages_.size(); }

  // Returns all received messages.
  const std::set<std::string>& messages() const {
    return messages_;
  }

  // Returns messages for the network with the given |guid|.
  const std::set<std::string>& messages(const std::string& guid) {
    return guid_messages_map_[guid];
  }

 private:
  std::set<std::string> messages_;
  base::flat_map<std::string, std::set<std::string>> guid_messages_map_;
};

}  // namespace

class NetworkSmsHandlerTest : public testing::Test {
 public:
  NetworkSmsHandlerTest()
      : task_environment_(
            base::test::SingleThreadTaskEnvironment::MainThreadType::UI,
            base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
  ~NetworkSmsHandlerTest() override = default;

  void SetUp() override {
    // Append '--sms-test-messages' to the command line to tell
    // SMSClientStubImpl to generate a series of test SMS messages.
    base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
    command_line->AppendSwitch(chromeos::switches::kSmsTestMessages);

    shill_clients::InitializeFakes();
    fake_sms_client_ = static_cast<FakeSMSClient*>(SMSClient::Get());
    device_test_ = ShillDeviceClient::Get()->GetTestInterface();
    ASSERT_TRUE(device_test_);
    service_test_ = ShillServiceClient::Get()->GetTestInterface();
    // We want to have only 1 cellular device.
    device_test_->ClearDevices();
    device_test_->AddDevice(kCellularDevicePath, shill::kTypeCellular,
                            "stub_cellular_device2");
    device_test_->SetDeviceProperty(
        kCellularDevicePath, shill::kDBusObjectProperty,
        base::Value(kCellularDeviceObjectPath1), /*notify_changed=*/false);
    SetupCellularModem(kCellularDeviceObjectPath1, kTestCellularServicePath1,
                       kTestGuid1, kTestIccid1, shill::kStateOnline);
    modem_messaging_test_ = ModemMessagingClient::Get()->GetTestInterface();

    // This relies on the stub dbus implementations for ShillManagerClient,
    // ShillDeviceClient, ModemMessagingClient and SMSClient.
    network_sms_handler_.reset(new NetworkSmsHandler());
    network_state_handler_ = NetworkStateHandler::InitializeForTest();
      network_sms_handler_->Init(network_state_handler_.get());

    test_observer_ = std::make_unique<TestObserver>();
    network_sms_handler_->AddObserver(test_observer_.get());
    network_sms_handler_->RequestUpdate();
    base::RunLoop().RunUntilIdle();
  }

  void TearDown() override {
    network_sms_handler_->RemoveObserver(test_observer_.get());
    network_sms_handler_.reset();
    network_state_handler_.reset();
    service_test_ = nullptr;  // Destroyed by shill_clients::Shutdown() below.
    shill_clients::Shutdown();
  }

  void ReceiveSms(const dbus::ObjectPath& object_path,
                  const dbus::ObjectPath& sms_path) {
    modem_messaging_test_->ReceiveSms(object_path, sms_path);
  }

  void CompleteReceiveSms() { fake_sms_client_->CompleteGetAll(); }

  void FastForwardReceiveSmsTimeout() {
    task_environment_.FastForwardBy(NetworkSmsHandler::kFetchSmsDetailsTimeout);
  }

  void SetupCellularModem(const std::string& object_path,
                          const std::string& service_path,
                          const std::string& guid,
                          const std::string& iccid,
                          const std::string& state) {
    device_test_->SetDeviceProperty(
        kCellularDevicePath, shill::kDBusObjectProperty,
        base::Value(object_path), /*notify_changed=*/true);
    device_test_->SetDeviceProperty(kCellularDevicePath, shill::kIccidProperty,
                                    base::Value(iccid),
                                    /*notify_changed=*/true);
    service_test_->AddService(service_path, guid, "", shill::kTypeCellular,
                              state,
                              /*visible=*/true);
    service_test_->SetServiceProperty(service_path, shill::kIccidProperty,
                                      base::Value(iccid));
  }

  void UpdateNetworkState(const std::string& service_path,
                          const std::string& state) {
    service_test_->SetServiceProperty(service_path, shill::kStateProperty,
                                      base::Value(state));
  }

 protected:
  base::test::SingleThreadTaskEnvironment task_environment_;
  raw_ptr<ShillDeviceClient::TestInterface, DanglingUntriaged> device_test_;
  raw_ptr<ModemMessagingClient::TestInterface, DanglingUntriaged>
      modem_messaging_test_;
  raw_ptr<ShillServiceClient::TestInterface> service_test_;
  std::unique_ptr<NetworkSmsHandler> network_sms_handler_;
  std::unique_ptr<TestObserver> test_observer_;

 private:
  std::unique_ptr<NetworkStateHandler> network_state_handler_;
  base::test::ScopedFeatureList features_;
  raw_ptr<FakeSMSClient, DanglingUntriaged> fake_sms_client_;
};

TEST_F(NetworkSmsHandlerTest, DbusStub) {
  EXPECT_EQ(test_observer_->message_count(), 0);

  // Test that no messages have been received yet
  const std::set<std::string>& messages(test_observer_->messages());
  // Note: The following string corresponds to values in
  // ModemMessagingClientStubImpl and SmsClientStubImpl.
  // TODO(stevenjb): Use a TestInterface to set this up to remove dependency.
  const char kMessage1[] = "FakeSMSClient: Test Message: /SMS/0";
  EXPECT_FALSE(base::Contains(messages, kMessage1));

  // Test for messages delivered by signals.
  test_observer_->ClearMessages();
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(kSmsPath));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();

  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(test_observer_->message_count(), 1);
  EXPECT_TRUE(base::Contains(messages, kMessage1));

  // There should be a request to delete the message after the message has been
  // received. Complete the request.
  EXPECT_EQ(kSmsPath, modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();

  // There should be no more messages to delete.
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());

  // Receive two more messages. We shouldn't attempt to delete messages until
  // after we've finished receiving all messages.
  const std::string sms_path_1 = "/SMS/1";
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(sms_path_1));
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());
  const std::string sms_path_2 = "/SMS/2";
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(sms_path_2));
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());

  // Simulate no more messages being received. The last SMS added should be the
  // first one attempted to be deleted.
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(sms_path_2,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(test_observer_->message_count(), 3);

  // Complete the deletion, another delete request should occur.
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(sms_path_1,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());

  // Receive another message before completing the delete request.
  const std::string sms_path_3 = "/SMS/3";
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(sms_path_3));
  CompleteReceiveSms();
  EXPECT_EQ(sms_path_1,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(test_observer_->message_count(), 4);

  // Complete the deletion, the last delete request should occur.
  EXPECT_EQ(sms_path_1,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(sms_path_3,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());

  // Complete the last delete request.
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(test_observer_->message_count(), 4);
}

TEST_F(NetworkSmsHandlerTest, DeleteFailure) {
  EXPECT_EQ(test_observer_->message_count(), 0);

  // Test that no messages have been received yet
  const std::set<std::string>& messages(test_observer_->messages());
  // Note: The following string corresponds to values in
  // ModemMessagingClientStubImpl and SmsClientStubImpl.
  const char kMessage1[] = "FakeSMSClient: Test Message: /SMS/0";
  EXPECT_FALSE(base::Contains(messages, kMessage1));

  // Test for messages delivered by signals.
  test_observer_->ClearMessages();
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(kSmsPath));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();

  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_GE(test_observer_->message_count(), 1);
  EXPECT_TRUE(base::Contains(messages, kMessage1));

  // There should be a request to delete the message after the message has been
  // received.
  EXPECT_EQ(kSmsPath, modem_messaging_test_->GetPendingDeleteRequestSmsPath());

  // Simulate the deletion failing. The delete request should be placed back in
  // the queue, but not invoked.
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/false);
  base::RunLoop().RunUntilIdle();
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());

  // Receive two more messages. We shouldn't attempt to delete messages until
  // after we've finished receiving all messages.
  const std::string sms_path_1 = "/SMS/1";
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(sms_path_1));
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());
  const std::string sms_path_2 = "/SMS/2";
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(sms_path_2));
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());

  // Simulate no more messages being received. The last SMS added should be the
  // first one attempted to be deleted.
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(sms_path_2,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_GE(test_observer_->message_count(), 3);

  // Simulate the deletion failing, the SMS should be placed back in the queue,
  // but no deletion invoked.
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/false);
  base::RunLoop().RunUntilIdle();
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());

  // Receive another message, it should be the first message attempted to be
  // deleted.
  const std::string sms_path_3 = "/SMS/3";
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(sms_path_3));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(sms_path_3,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_GE(test_observer_->message_count(), 4);

  // Simulate the deletion succeeding, the second SMS should be attempted to be
  // deleted.
  EXPECT_EQ(sms_path_3,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(sms_path_1,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());

  // Simulate the deletion succeeding, the first SMS should be attempted to be
  // deleted.
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(kSmsPath, modem_messaging_test_->GetPendingDeleteRequestSmsPath());

  // Simulate the deletion succeeding, the third SMS should be attempted to be
  // deleted.
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(sms_path_2,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
}

TEST_F(NetworkSmsHandlerTest, ReceiveSmsTimeout) {
  EXPECT_EQ(test_observer_->message_count(), 0);

  // Test that no messages have been received yet
  const std::set<std::string>& messages(test_observer_->messages());
  // Note: The following string corresponds to values in
  // ModemMessagingClientStubImpl and SmsClientStubImpl.
  // TODO(stevenjb): Use a TestInterface to set this up to remove dependency.
  const char kMessage1[] = "FakeSMSClient: Test Message: /SMS/0";
  EXPECT_FALSE(base::Contains(messages, kMessage1));

  // Receive 2 SMSes.
  test_observer_->ClearMessages();
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(kSmsPath));
  const std::string sms_path_2 = "/SMS/2";
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(sms_path_2));
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());

  // Simulate the timeout passing for the first SMS. The next SMS in the queue
  // should be processed.
  FastForwardReceiveSmsTimeout();

  // Complete fetching the second SMS' details.
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();

  // The second SMS should be found in |messages| but not the first SMS.
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(test_observer_->message_count(), 1);
  EXPECT_FALSE(base::Contains(messages, kMessage1));
  EXPECT_TRUE(base::Contains(messages, "FakeSMSClient: Test Message: /SMS/2"));

  // There should be a request to delete the second SMS. Complete the request.
  EXPECT_EQ(sms_path_2,
            modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();

  // There should be a request to delete the first SMS. Complete the request.
  EXPECT_EQ(kSmsPath, modem_messaging_test_->GetPendingDeleteRequestSmsPath());
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();

  // There should be no more messages to delete.
  EXPECT_TRUE(modem_messaging_test_->GetPendingDeleteRequestSmsPath().empty());
}

TEST_F(NetworkSmsHandlerTest, EmptyDbusObjectPath) {
  // This test verifies no crash should occur when the device dbus object path
  // is an empty value.
  device_test_->SetDeviceProperty(kCellularDevicePath,
                                  shill::kDBusObjectProperty, base::Value(""),
                                  /*notify_changed=*/true);
  base::RunLoop().RunUntilIdle();
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(test_observer_->message_count(), 0);
}

TEST_F(NetworkSmsHandlerTest, DeviceObjectPathChange) {
  // Fake the SIM being switched to a different SIM.
  device_test_->SetDeviceProperty(
      kCellularDevicePath, shill::kDBusObjectProperty,
      base::Value(kCellularDeviceObjectPath2), /*notify_changed=*/true);
  base::RunLoop().RunUntilIdle();
  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();

  EXPECT_EQ(test_observer_->message_count(), 0);

  // Test that no messages have been received yet
  const std::set<std::string>& messages(test_observer_->messages());
  // Note: The following string corresponds to values in
  // ModemMessagingClientStubImpl and SmsClientStubImpl.
  // TODO(stevenjb): Use a TestInterface to set this up to remove dependency.
  const char kMessage1[] = "FakeSMSClient: Test Message: /SMS/0";
  EXPECT_FALSE(base::Contains(messages, kMessage1));

  // Test for messages delivered by signals.
  test_observer_->ClearMessages();
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath2),
             dbus::ObjectPath(kSmsPath));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();

  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_GE(test_observer_->message_count(), 1);
  EXPECT_TRUE(base::Contains(messages, kMessage1));
}

TEST_F(NetworkSmsHandlerTest, NetworkGuidTest) {
  // Test that no messages have been received yet
  EXPECT_EQ(test_observer_->message_count(), 0);

  const char kMessage1[] = "FakeSMSClient: Test Message: /SMS/0";
  const char kMessage2[] = "FakeSMSClient: Test Message: /SMS/1";
  EXPECT_EQ(test_observer_->messages().find(kMessage1),
            test_observer_->messages().end());

  // Test for messages for the first network.
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath1),
             dbus::ObjectPath(kSmsPath));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();

  network_sms_handler_->RequestUpdate();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(1u, test_observer_->messages(kTestGuid1).size());
  EXPECT_NE(test_observer_->messages(kTestGuid1).find(kMessage1),
            test_observer_->messages(kTestGuid1).end());
  modem_messaging_test_->CompletePendingDeleteRequest(/*success=*/true);
  base::RunLoop().RunUntilIdle();

  // Switch to a different modem.
  UpdateNetworkState(kTestCellularServicePath1, shill::kStateDisconnecting);
  SetupCellularModem(kCellularDeviceObjectPath2, kTestCellularServicePath2,
                     kTestGuid2, kTestIccid2, shill::kStateOnline);

  base::RunLoop().RunUntilIdle();
  network_sms_handler_->RequestUpdate();

  // Test for messages for messages from the second network.
  EXPECT_EQ(0u, test_observer_->messages(kTestGuid2).size());
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath2),
             dbus::ObjectPath("/SMS/1"));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(2u, test_observer_->messages().size());
  EXPECT_EQ(1u, test_observer_->messages(kTestGuid2).size());
  EXPECT_NE(test_observer_->messages(kTestGuid2).find(kMessage2),
            test_observer_->messages(kTestGuid2).end());
  EXPECT_EQ(test_observer_->messages(kTestGuid1).find(kMessage2),
            test_observer_->messages(kTestGuid1).end());
}

TEST_F(NetworkSmsHandlerTest, NetworkDelayedActiveNetworkTest) {
  SetupCellularModem(kCellularDeviceObjectPath2, kTestCellularServicePath2,
                     kTestGuid2, kTestIccid2, shill::kStateIdle);
  base::RunLoop().RunUntilIdle();
  network_sms_handler_->RequestUpdate();
  EXPECT_EQ(0u, test_observer_->messages().size());
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath2),
             dbus::ObjectPath(kSmsPath));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  // The message will be sent with the GUID of the currently connected
  // network which is kTestGuid1.
  EXPECT_EQ(1u, test_observer_->messages(kTestGuid1).size());
  EXPECT_EQ(0u, test_observer_->messages(kTestGuid2).size());

  UpdateNetworkState(kTestCellularServicePath1, shill::kStateDisconnecting);
  base::RunLoop().RunUntilIdle();
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath2),
             dbus::ObjectPath("/SMS/1"));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  // No connected network, the GUID of the last connected
  // network will be used.
  EXPECT_EQ(2u, test_observer_->messages(kTestGuid1).size());
  EXPECT_EQ(0u, test_observer_->messages(kTestGuid2).size());

  UpdateNetworkState(kTestCellularServicePath2, shill::kStateOnline);
  base::RunLoop().RunUntilIdle();

  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath2),
             dbus::ObjectPath("/SMS/2"));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  // After updating the state, we see that the message is sent with the GUID
  // associated with the last active network.
  EXPECT_EQ(2u, test_observer_->messages(kTestGuid1).size());
  EXPECT_EQ(1u, test_observer_->messages(kTestGuid2).size());
}

TEST_F(NetworkSmsHandlerTest, MessageReceivedNeverConnectedNetwork) {
  UpdateNetworkState(kTestCellularServicePath1, shill::kStateDisconnecting);
  SetupCellularModem(kCellularDeviceObjectPath2, kTestCellularServicePath2,
                     kTestGuid2, kTestIccid2, shill::kStateDisconnecting);

  base::RunLoop().RunUntilIdle();
  network_sms_handler_->RequestUpdate();
  EXPECT_EQ(0u, test_observer_->messages().size());
  ReceiveSms(dbus::ObjectPath(kCellularDeviceObjectPath2),
             dbus::ObjectPath(kSmsPath));
  CompleteReceiveSms();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(1u, test_observer_->messages(kTestGuid2).size());
}

}  // namespace ash