shill/cellular/modem_test.cc

// Copyright 2018 The Chromium OS 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 "shill/cellular/modem.h"

#include <tuple>
#include <utility>

#include <ModemManager/ModemManager.h>
#include <net/if.h>
#include <sys/ioctl.h>

#include <base/stl_util.h>
#include <base/strings/string_util.h>
#include <base/strings/stringprintf.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

#include "shill/cellular/cellular.h"
#include "shill/cellular/cellular_capability.h"
#include "shill/cellular/mock_cellular.h"
#include "shill/cellular/mock_modem_info.h"
#include "shill/dbus/dbus_properties_proxy.h"
#include "shill/mock_control.h"
#include "shill/mock_device_info.h"
#include "shill/mock_manager.h"
#include "shill/mock_metrics.h"
#include "shill/net/mock_rtnl_handler.h"
#include "shill/net/rtnl_handler.h"
#include "shill/test_event_dispatcher.h"

using std::string;
using testing::_;
using testing::AnyNumber;
using testing::ByMove;
using testing::DoAll;
using testing::NiceMock;
using testing::Return;
using testing::SetArgPointee;
using testing::StrEq;
using testing::Test;

namespace shill {

namespace {

const int kTestInterfaceIndex = 5;
const char kLinkName[] = "usb0";
const char kService[] = "org.freedesktop.ModemManager1";
const RpcIdentifier kPath("/org/freedesktop/ModemManager1/Modem/0");
const unsigned char kAddress[] = {0xa0, 0xb1, 0xc2, 0xd3, 0xe4, 0xf5};
const char kAddressAsString[] = "A0B1C2D3E4F5";

}  // namespace

class TestDeviceInfo : public MockDeviceInfo {
 public:
  explicit TestDeviceInfo(Manager* manager) : MockDeviceInfo(manager) {}
  TestDeviceInfo(const TestDeviceInfo&) = delete;
  TestDeviceInfo& operator=(const TestDeviceInfo&) = delete;

  // DeviceInfo override:
  CellularRefPtr GetCellularDevice(int interface_index,
                                   const std::string& mac_address,
                                   Modem* modem) override {
    CellularRefPtr cellular;
    if (use_mock_) {
      cellular = new NiceMock<MockCellular>(
          manager()->modem_info(), kLinkName, mac_address, interface_index,
          Cellular::kType3gpp, kService, kPath);
    } else {
      cellular = new Cellular(manager()->modem_info(), kLinkName, mac_address,
                              interface_index, modem->type(), modem->service(),
                              modem->path());
      cellular->CreateCapability(manager()->modem_info());
    }
    return cellular;
  }

  void set_use_mock(bool use_mock) { use_mock_ = use_mock; }

 private:
  bool use_mock_ = true;
};

class ModemTest : public Test {
 public:
  ModemTest()
      : manager_(&control_, &dispatcher_, &metrics_),
        modem_info_(&control_, &manager_),
        device_info_(&manager_),
        modem_(new Modem(kService, kPath, &modem_info_)) {
    modem_->set_rtnl_handler_for_testing(&rtnl_handler_);
  }

  void SetUp() {
    expected_address_ = ByteString(kAddress, base::size(kAddress));

    EXPECT_CALL(rtnl_handler_, GetInterfaceIndex(kLinkName))
        .WillRepeatedly(Return(kTestInterfaceIndex));

    EXPECT_CALL(manager_, device_info()).WillRepeatedly(Return(&device_info_));
    EXPECT_CALL(manager_, modem_info()).WillRepeatedly(Return(&modem_info_));
  }

  void TearDown() { modem_.reset(); }

 protected:
  void SetUseRealCellular() { device_info_.set_use_mock(false); }

  void SetDeviceInfoExpectations() {
    EXPECT_CALL(device_info_, IsDeviceBlocked(kLinkName))
        .WillRepeatedly(Return(false));
    EXPECT_CALL(device_info_, GetByteCounts(kTestInterfaceIndex, _, _))
        .WillRepeatedly(Return(true));
    EXPECT_CALL(device_info_, RegisterDevice(_)).Times(AnyNumber());
  }

  InterfaceToProperties GeInterfaceProperties() {
    InterfaceToProperties properties;
    KeyValueStore modem_properties;
    modem_properties.Set<uint32_t>(MM_MODEM_PROPERTY_UNLOCKREQUIRED,
                                   MM_MODEM_LOCK_NONE);
    std::vector<std::tuple<std::string, uint32_t>> ports = {
        std::make_tuple(kLinkName, MM_MODEM_PORT_TYPE_NET)};
    modem_properties.SetVariant(MM_MODEM_PROPERTY_PORTS, brillo::Any(ports));
    properties[MM_DBUS_INTERFACE_MODEM] = modem_properties;

    return properties;
  }

  void CreateDeviceFromModemProperties(
      const InterfaceToProperties& properties) {
    modem_->CreateDeviceFromModemProperties(properties);
  }

  bool GetDeviceParams(std::string* mac_address, int* interface_index) {
    return modem_->GetDeviceParams(mac_address, interface_index);
  }

  EventDispatcherForTest dispatcher_;
  NiceMock<MockControl> control_;
  MockMetrics metrics_;
  NiceMock<MockManager> manager_;
  MockModemInfo modem_info_;
  TestDeviceInfo device_info_;
  std::unique_ptr<Modem> modem_;
  MockRTNLHandler rtnl_handler_;
  ByteString expected_address_;
};

MATCHER_P2(HasPropertyWithValueU32, key, value, "") {
  return arg.template Contains<uint32_t>(key) &&
         value == arg.template Get<uint32_t>(key);
}

TEST_F(ModemTest, PendingDevicePropertiesAndCreate) {
  ASSERT_FALSE(modem_->device_for_testing());

  SetDeviceInfoExpectations();

  // The first time we call CreateDeviceFromModemProperties, expect
  // GetMacAddress to fail.
  EXPECT_CALL(device_info_, GetMacAddress(kTestInterfaceIndex, _))
      .WillOnce(Return(false));
  CreateDeviceFromModemProperties(GeInterfaceProperties());
  EXPECT_FALSE(modem_->device_for_testing());
  EXPECT_TRUE(modem_->has_pending_device_info_for_testing());

  // When OnDeviceInfoAvailable gets called, CreateDeviceFromModemProperties
  // will get called again. GetMacAddress is now expected to succeed, so a
  // device will get created.
  EXPECT_CALL(device_info_, GetMacAddress(kTestInterfaceIndex, _))
      .WillOnce(DoAll(SetArgPointee<1>(expected_address_), Return(true)));
  modem_->OnDeviceInfoAvailable(kLinkName);
  EXPECT_TRUE(modem_->device_for_testing());
  EXPECT_EQ(base::ToLowerASCII(kAddressAsString),
            modem_->device_for_testing()->mac_address());
}

TEST_F(ModemTest, EarlyDeviceProperties) {
  // OnDeviceInfoAvailable called before CreateDeviceFromModemProperties does
  // nothing
  modem_->OnDeviceInfoAvailable(kLinkName);
  EXPECT_FALSE(modem_->device_for_testing());
}

TEST_F(ModemTest, CreateDeviceEarlyFailures) {
  InterfaceToProperties properties;

  // No modem interface properties:  no device created
  CreateDeviceFromModemProperties(properties);
  EXPECT_FALSE(modem_->device_for_testing());

  properties = GeInterfaceProperties();

  // Link name, but no ifindex: no device created
  EXPECT_CALL(rtnl_handler_, GetInterfaceIndex(StrEq(kLinkName)))
      .WillOnce(Return(-1));
  CreateDeviceFromModemProperties(properties);
  EXPECT_FALSE(modem_->device_for_testing());

  // The params are good, but the device is blocked.
  EXPECT_CALL(rtnl_handler_, GetInterfaceIndex(StrEq(kLinkName)))
      .WillOnce(Return(kTestInterfaceIndex));
  EXPECT_CALL(device_info_, GetMacAddress(kTestInterfaceIndex, _))
      .WillOnce(DoAll(SetArgPointee<1>(expected_address_), Return(true)));
  EXPECT_CALL(device_info_, IsDeviceBlocked(kLinkName))
      .WillRepeatedly(Return(true));
  CreateDeviceFromModemProperties(properties);
  EXPECT_FALSE(modem_->device_for_testing());

  // No link name: see CreateDevicePPP.
}

TEST_F(ModemTest, CreateDevicePPP) {
  InterfaceToProperties properties;
  properties[MM_DBUS_INTERFACE_MODEM] = KeyValueStore();

  // MM_MODEM_PROPERTY_PORTS is unset, so GetLinkName will fail. Modem will
  // assume a PPP dongle and CreateDeviceFromModemProperties will succeed.
  EXPECT_CALL(device_info_, IsDeviceBlocked(_)).WillRepeatedly(Return(false));
  EXPECT_CALL(device_info_, GetByteCounts(_, _, _))
      .WillRepeatedly(Return(true));
  CreateDeviceFromModemProperties(properties);
  EXPECT_TRUE(modem_->device_for_testing());
  EXPECT_EQ(modem_->device_for_testing()->interface_index(),
            Modem::kFakeDevInterfaceIndex);
  EXPECT_EQ(modem_->device_for_testing()->mac_address(),
            Modem::kFakeDevAddress);
}

TEST_F(ModemTest, GetDeviceParams) {
  string mac_address;
  int interface_index = 2;
  EXPECT_CALL(rtnl_handler_, GetInterfaceIndex(_)).WillOnce(Return(-1));
  EXPECT_CALL(device_info_, GetMacAddress(_, _))
      .Times(AnyNumber())
      .WillRepeatedly(Return(false));
  EXPECT_FALSE(GetDeviceParams(&mac_address, &interface_index));
  EXPECT_EQ(-1, interface_index);

  EXPECT_CALL(rtnl_handler_, GetInterfaceIndex(_)).WillOnce(Return(-2));
  EXPECT_CALL(device_info_, GetMacAddress(_, _))
      .Times(AnyNumber())
      .WillRepeatedly(Return(false));
  EXPECT_FALSE(GetDeviceParams(&mac_address, &interface_index));
  EXPECT_EQ(-2, interface_index);

  EXPECT_CALL(rtnl_handler_, GetInterfaceIndex(_)).WillOnce(Return(1));
  EXPECT_CALL(device_info_, GetMacAddress(_, _)).WillOnce(Return(false));
  EXPECT_FALSE(GetDeviceParams(&mac_address, &interface_index));
  EXPECT_EQ(1, interface_index);

  EXPECT_CALL(rtnl_handler_, GetInterfaceIndex(_)).WillOnce(Return(2));
  EXPECT_CALL(device_info_, GetMacAddress(2, _))
      .WillOnce(DoAll(SetArgPointee<1>(expected_address_), Return(true)));
  EXPECT_TRUE(GetDeviceParams(&mac_address, &interface_index));
  EXPECT_EQ(2, interface_index);
  EXPECT_EQ(kAddressAsString, mac_address);
}

TEST_F(ModemTest, CreateDeviceMM1) {
  SetUseRealCellular();
  SetDeviceInfoExpectations();
  EXPECT_CALL(device_info_, GetMacAddress(kTestInterfaceIndex, _))
      .WillOnce(DoAll(SetArgPointee<1>(expected_address_), Return(true)));

  InterfaceToProperties properties = GeInterfaceProperties();

  KeyValueStore modem3gpp_properties;
  modem3gpp_properties.Set<uint32_t>(
      MM_MODEM_MODEM3GPP_PROPERTY_REGISTRATIONSTATE,
      MM_MODEM_3GPP_REGISTRATION_STATE_HOME);
  properties[MM_DBUS_INTERFACE_MODEM_MODEM3GPP] = modem3gpp_properties;

  std::unique_ptr<DBusPropertiesProxy> dbus_properties_proxy =
      DBusPropertiesProxy::CreateDBusPropertiesProxyForTesting();
  EXPECT_CALL(control_, CreateDBusPropertiesProxy(kPath, kService))
      .WillOnce(Return(ByMove(std::move(dbus_properties_proxy))));

  modem_->CreateDeviceMM1(properties);
  Cellular* device = modem_->device_for_testing();
  ASSERT_TRUE(device);
  CellularCapability* capability = device->capability_for_testing();
  ASSERT_TRUE(capability);
  EXPECT_TRUE(capability->IsRegistered());
}

}  // namespace shill