//
// Copyright (C) 2012 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#include "shill/static_ip_parameters.h"

#include <base/strings/string_number_conversions.h>
#include <chromeos/dbus/service_constants.h>
#include <gtest/gtest.h>

#include "shill/ipconfig.h"
#include "shill/mock_store.h"
#include "shill/property_store.h"

using std::string;
using std::vector;
using testing::_;
using testing::DoAll;
using testing::Return;
using testing::SetArgPointee;
using testing::StrictMock;
using testing::Test;

namespace shill {

namespace {

const char kAddress[] = "10.0.0.1";
const char kGateway[] = "10.0.0.254";
const int32_t kMtu = 512;

const char kNameServer0[] = "10.0.1.253";
const char kNameServer1[] = "10.0.1.252";
const char kNameServers[] = "10.0.1.253,10.0.1.252";

const char kSearchDomains[] = "example.com,chromium.org";
const char kSearchDomain0[] = "example.com";
const char kSearchDomain1[] = "chromium.org";

const char kPeerAddress[] = "10.0.0.2";
const int32_t kPrefixLen = 24;

const char kExcludedRoutes[] = "192.168.1.0/24,192.168.2.0/24";
const char kExcludedRoute0[] = "192.168.1.0/24";
const char kExcludedRoute1[] = "192.168.2.0/24";

const char kIncludedRoutes[] = "0.0.0.0/0";
const IPConfig::Route kIncludedRoute0("0.0.0.0", 0, "10.0.0.254");

}  // namespace

class StaticIPParametersTest : public Test {
 public:
  StaticIPParametersTest() {}

  void ExpectEmptyIPConfig() {
    EXPECT_TRUE(ipconfig_props_.address.empty());
    EXPECT_TRUE(ipconfig_props_.gateway.empty());
    EXPECT_EQ(IPConfig::kUndefinedMTU, ipconfig_props_.mtu);
    EXPECT_TRUE(ipconfig_props_.dns_servers.empty());
    EXPECT_TRUE(ipconfig_props_.domain_search.empty());
    EXPECT_TRUE(ipconfig_props_.peer_address.empty());
    EXPECT_FALSE(ipconfig_props_.subnet_prefix);
    EXPECT_TRUE(ipconfig_props_.exclusion_list.empty());
    EXPECT_TRUE(ipconfig_props_.routes.empty());
  }
  // Modify an IP address string in some predictable way.  There's no need
  // for the output string to be valid from a networking perspective.
  string VersionedAddress(const string& address, int version) {
    string returned_address = address;
    CHECK(returned_address.length());
    returned_address[returned_address.length() - 1] += version;
    return returned_address;
  }
  void ExpectPopulatedIPConfigWithVersion(int version) {
    EXPECT_EQ(VersionedAddress(kAddress, version), ipconfig_props_.address);
    EXPECT_EQ(VersionedAddress(kGateway, version), ipconfig_props_.gateway);
    EXPECT_EQ(kMtu + version, ipconfig_props_.mtu);

    EXPECT_EQ(2, ipconfig_props_.dns_servers.size());
    EXPECT_EQ(VersionedAddress(kNameServer0, version),
              ipconfig_props_.dns_servers[0]);
    EXPECT_EQ(VersionedAddress(kNameServer1, version),
              ipconfig_props_.dns_servers[1]);

    // VersionedAddress() increments the final character of each domain
    // name.
    EXPECT_EQ(2, ipconfig_props_.domain_search.size());
    EXPECT_EQ(VersionedAddress(kSearchDomain0, version),
              ipconfig_props_.domain_search[0]);
    EXPECT_EQ(VersionedAddress(kSearchDomain1, version),
              ipconfig_props_.domain_search[1]);

    EXPECT_EQ(VersionedAddress(kPeerAddress, version),
              ipconfig_props_.peer_address);
    EXPECT_EQ(kPrefixLen + version, ipconfig_props_.subnet_prefix);

    EXPECT_EQ(2, ipconfig_props_.exclusion_list.size());
    EXPECT_EQ(VersionedAddress(kExcludedRoute0, version),
              ipconfig_props_.exclusion_list[0]);
    EXPECT_EQ(VersionedAddress(kExcludedRoute1, version),
              ipconfig_props_.exclusion_list[1]);

    // VersionedAddress() increments the final digit of the prefix on
    // the IncludedRoutes property, and the final digit of the IP address
    // on the Gateway property.
    EXPECT_EQ(1, ipconfig_props_.routes.size());
    EXPECT_EQ(kIncludedRoute0.host, ipconfig_props_.routes[0].host);
    EXPECT_EQ(kIncludedRoute0.prefix + version,
              ipconfig_props_.routes[0].prefix);
    EXPECT_EQ(VersionedAddress(kIncludedRoute0.gateway, version),
              ipconfig_props_.routes[0].gateway);
  }
  void ExpectPopulatedIPConfig() { ExpectPopulatedIPConfigWithVersion(0); }
  void ExpectPropertiesWithVersion(PropertyStore* store,
                                        const string& property_prefix,
                                        int version) {
    string string_value;
    Error unused_error;
    EXPECT_TRUE(store->GetStringProperty(property_prefix + ".Address",
                                         &string_value,
                                         &unused_error));
    EXPECT_EQ(VersionedAddress(kAddress, version), string_value);
    EXPECT_TRUE(store->GetStringProperty(property_prefix + ".Gateway",
                                         &string_value,
                                         &unused_error));
    EXPECT_EQ(VersionedAddress(kGateway, version), string_value);
    int32_t int_value;
    EXPECT_TRUE(store->GetInt32Property(property_prefix + ".Mtu", &int_value,
                                        &unused_error));
    EXPECT_EQ(kMtu + version, int_value);
    EXPECT_TRUE(store->GetStringProperty(property_prefix + ".NameServers",
                                         &string_value,
                                         &unused_error));
    EXPECT_EQ(VersionedAddress(kNameServer0, version) + "," +
              VersionedAddress(kNameServer1, version),
              string_value);
    EXPECT_TRUE(store->GetStringProperty(property_prefix + ".SearchDomains",
                                         &string_value,
                                         &unused_error));
    EXPECT_EQ(VersionedAddress(kSearchDomain0, version) + "," +
              VersionedAddress(kSearchDomain1, version),
              string_value);
    EXPECT_TRUE(store->GetStringProperty(property_prefix + ".PeerAddress",
                                         &string_value,
                                         &unused_error));
    EXPECT_EQ(VersionedAddress(kPeerAddress, version), string_value);
    EXPECT_TRUE(store->GetInt32Property(property_prefix + ".Prefixlen",
                                        &int_value,
                                        &unused_error));
    EXPECT_EQ(kPrefixLen + version, int_value);
    EXPECT_TRUE(store->GetStringProperty(property_prefix + ".ExcludedRoutes",
                                         &string_value,
                                         &unused_error));
    EXPECT_EQ(VersionedAddress(kExcludedRoute0, version) + "," +
              VersionedAddress(kExcludedRoute1, version),
              string_value);
    EXPECT_TRUE(store->GetStringProperty(property_prefix + ".IncludedRoutes",
                                         &string_value,
                                         &unused_error));
    EXPECT_EQ(VersionedAddress(kIncludedRoutes, version),
              string_value);
  }
  void ExpectProperties(PropertyStore* store, const string& property_prefix) {
    ExpectPropertiesWithVersion(store, property_prefix, 0);
  }
  void PopulateIPConfig() {
    ipconfig_props_.address = kAddress;
    ipconfig_props_.gateway = kGateway;
    ipconfig_props_.mtu = kMtu;
    ipconfig_props_.dns_servers.push_back(kNameServer0);
    ipconfig_props_.dns_servers.push_back(kNameServer1);
    ipconfig_props_.domain_search.push_back(kSearchDomain0);
    ipconfig_props_.domain_search.push_back(kSearchDomain1);
    ipconfig_props_.peer_address = kPeerAddress;
    ipconfig_props_.subnet_prefix = kPrefixLen;
    ipconfig_props_.exclusion_list.push_back(kExcludedRoute0);
    ipconfig_props_.exclusion_list.push_back(kExcludedRoute1);
    ipconfig_props_.routes.push_back(kIncludedRoute0);
  }
  void SetStaticPropertiesWithVersion(PropertyStore* store, int version) {
    Error error;
    store->SetStringProperty(
        "StaticIP.Address", VersionedAddress(kAddress, version), &error);
    store->SetStringProperty(
        "StaticIP.Gateway", VersionedAddress(kGateway, version), &error);
    store->SetInt32Property(
        "StaticIP.Mtu", kMtu + version, &error);
    store->SetStringProperty(
        "StaticIP.NameServers",
        VersionedAddress(kNameServer0, version) + "," +
        VersionedAddress(kNameServer1, version),
        &error);
    store->SetStringProperty(
        "StaticIP.SearchDomains",
        VersionedAddress(kSearchDomain0, version) + "," +
        VersionedAddress(kSearchDomain1, version),
        &error);
    store->SetStringProperty(
        "StaticIP.PeerAddress",
        VersionedAddress(kPeerAddress, version),
        &error);
    store->SetInt32Property("StaticIP.Prefixlen", kPrefixLen + version, &error);
    store->SetStringProperty(
        "StaticIP.ExcludedRoutes",
        VersionedAddress(kExcludedRoute0, version) + "," +
        VersionedAddress(kExcludedRoute1, version),
        &error);
    store->SetStringProperty(
        "StaticIP.IncludedRoutes",
        VersionedAddress(kIncludedRoutes, version),
        &error);
  }
  void SetStaticProperties(PropertyStore* store) {
    SetStaticPropertiesWithVersion(store, 0);
  }
  void SetStaticDictPropertiesWithVersion(PropertyStore* store, int version) {
    KeyValueStore args;
    args.SetString(kAddressProperty, VersionedAddress(kAddress, version));
    args.SetString(kGatewayProperty, VersionedAddress(kGateway, version));
    args.SetInt(kMtuProperty, kMtu + version);

    vector<string> name_servers;
    name_servers.push_back(VersionedAddress(kNameServer0, version));
    name_servers.push_back(VersionedAddress(kNameServer1, version));
    args.SetStrings(kNameServersProperty, name_servers);

    vector<string> search_domains;
    search_domains.push_back(VersionedAddress(kSearchDomain0, version));
    search_domains.push_back(VersionedAddress(kSearchDomain1, version));
    args.SetStrings(kSearchDomainsProperty, search_domains);

    args.SetString(kPeerAddressProperty,
                   VersionedAddress(kPeerAddress, version));
    args.SetInt(kPrefixlenProperty, kPrefixLen + version);

    vector<string> excluded_routes;
    excluded_routes.push_back(VersionedAddress(kExcludedRoute0, version));
    excluded_routes.push_back(VersionedAddress(kExcludedRoute1, version));
    args.SetStrings(kExcludedRoutesProperty, excluded_routes);

    vector<string> included_routes;
    included_routes.push_back(VersionedAddress(kIncludedRoutes, version));
    args.SetStrings(kIncludedRoutesProperty, included_routes);

    Error error;
    store->SetKeyValueStoreProperty(kStaticIPConfigProperty, args, &error);
  }

 protected:
  StaticIPParameters static_params_;
  IPConfig::Properties ipconfig_props_;
};

TEST_F(StaticIPParametersTest, InitState) {
  ExpectEmptyIPConfig();

  // Applying an empty set of parameters on an empty set of properties should
  // be a no-op.
  static_params_.ApplyTo(&ipconfig_props_);
  ExpectEmptyIPConfig();
}

TEST_F(StaticIPParametersTest, ApplyEmptyParameters) {
  PopulateIPConfig();
  static_params_.ApplyTo(&ipconfig_props_);
  ExpectPopulatedIPConfig();
}

TEST_F(StaticIPParametersTest, ControlInterface) {
  PropertyStore store;
  static_params_.PlumbPropertyStore(&store);
  SetStaticProperties(&store);
  static_params_.ApplyTo(&ipconfig_props_);
  ExpectPopulatedIPConfig();

  EXPECT_TRUE(static_params_.ContainsAddress());
  Error unused_error;
  store.ClearProperty("StaticIP.Address", &unused_error);
  EXPECT_FALSE(static_params_.ContainsAddress());
  store.ClearProperty("StaticIP.Mtu", &unused_error);
  IPConfig::Properties props;
  const string kTestAddress("test_address");
  props.address = kTestAddress;
  const int32_t kTestMtu = 256;
  props.mtu = kTestMtu;
  static_params_.ApplyTo(&props);
  EXPECT_EQ(kTestAddress, props.address);
  EXPECT_EQ(kTestMtu, props.mtu);

  {
    Error error;
    EXPECT_FALSE(store.GetStringProperty("StaticIP.Address", nullptr, &error));
    EXPECT_EQ(Error::kNotFound, error.type());
  }
  string string_value;
  EXPECT_TRUE(store.GetStringProperty("StaticIP.Gateway", &string_value,
                                      &unused_error));
  EXPECT_EQ(kGateway, string_value);
  {
    Error error;
    EXPECT_FALSE(store.GetInt32Property("StaticIP.Mtu", nullptr, &error));
    EXPECT_EQ(Error::kNotFound, error.type());
  }
  EXPECT_TRUE(store.GetStringProperty("StaticIP.NameServers", &string_value,
                                      &unused_error));
  EXPECT_EQ(kNameServers, string_value);
  EXPECT_TRUE(store.GetStringProperty("StaticIP.SearchDomains", &string_value,
                                      &unused_error));
  EXPECT_EQ(kSearchDomains, string_value);
  EXPECT_TRUE(store.GetStringProperty("StaticIP.PeerAddress", &string_value,
                                      &unused_error));
  EXPECT_EQ(kPeerAddress, string_value);
  int32_t int_value;
  EXPECT_TRUE(store.GetInt32Property("StaticIP.Prefixlen", &int_value,
                                     &unused_error));
  EXPECT_EQ(kPrefixLen, int_value);
  EXPECT_TRUE(store.GetStringProperty("StaticIP.ExcludedRoutes", &string_value,
                                      &unused_error));
  EXPECT_EQ(kExcludedRoutes, string_value);
  EXPECT_TRUE(store.GetStringProperty("StaticIP.IncludedRoutes", &string_value,
                                      &unused_error));
  EXPECT_EQ(kIncludedRoutes, string_value);
}

TEST_F(StaticIPParametersTest, Profile) {
  StrictMock<MockStore> store;
  const string kID = "storage_id";
  EXPECT_CALL(store, GetString(kID, "StaticIP.Address", _))
      .WillOnce(DoAll(SetArgPointee<2>(string(kAddress)), Return(true)));
  EXPECT_CALL(store, GetString(kID, "StaticIP.Gateway", _))
      .WillOnce(DoAll(SetArgPointee<2>(string(kGateway)), Return(true)));
  EXPECT_CALL(store, GetInt(kID, "StaticIP.Mtu", _))
      .WillOnce(DoAll(SetArgPointee<2>(kMtu), Return(true)));
  EXPECT_CALL(store, GetString(kID, "StaticIP.NameServers", _))
      .WillOnce(DoAll(SetArgPointee<2>(string(kNameServers)),
                      Return(true)));
  EXPECT_CALL(store, GetString(kID, "StaticIP.SearchDomains", _))
      .WillOnce(DoAll(SetArgPointee<2>(string(kSearchDomains)),
                      Return(true)));
  EXPECT_CALL(store, GetString(kID, "StaticIP.PeerAddress", _))
      .WillOnce(DoAll(SetArgPointee<2>(string(kPeerAddress)),
                      Return(true)));
  EXPECT_CALL(store, GetInt(kID, "StaticIP.Prefixlen", _))
      .WillOnce(DoAll(SetArgPointee<2>(kPrefixLen), Return(true)));
  EXPECT_CALL(store, GetString(kID, "StaticIP.ExcludedRoutes", _))
      .WillOnce(DoAll(SetArgPointee<2>(string(kExcludedRoutes)),
                      Return(true)));
  EXPECT_CALL(store, GetString(kID, "StaticIP.IncludedRoutes", _))
      .WillOnce(DoAll(SetArgPointee<2>(string(kIncludedRoutes)),
                      Return(true)));
  static_params_.Load(&store, kID);
  static_params_.ApplyTo(&ipconfig_props_);
  ExpectPopulatedIPConfig();

  EXPECT_CALL(store, SetString(kID, "StaticIP.Address", kAddress))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetString(kID, "StaticIP.Gateway", kGateway))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetInt(kID, "StaticIP.Mtu", kMtu))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetString(kID, "StaticIP.NameServers", kNameServers))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetString(kID, "StaticIP.SearchDomains", kSearchDomains))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetString(kID, "StaticIP.PeerAddress", kPeerAddress))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetInt(kID, "StaticIP.Prefixlen", kPrefixLen))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetString(kID, "StaticIP.ExcludedRoutes", kExcludedRoutes))
      .WillOnce(Return(true));
  EXPECT_CALL(store, SetString(kID, "StaticIP.IncludedRoutes", kIncludedRoutes))
      .WillOnce(Return(true));
  static_params_.Save(&store, kID);
}

TEST_F(StaticIPParametersTest, SavedParameters) {
  // Calling RestoreTo() when no parameters are set should not crash or
  // add any entries.
  static_params_.RestoreTo(&ipconfig_props_);
  ExpectEmptyIPConfig();

  PopulateIPConfig();
  PropertyStore static_params_props;
  static_params_.PlumbPropertyStore(&static_params_props);
  SetStaticPropertiesWithVersion(&static_params_props, 1);
  static_params_.ApplyTo(&ipconfig_props_);

  // The version 0 properties in |ipconfig_props_| are now in SavedIP.*
  // properties, while the version 1 StaticIP parameters are now in
  // |ipconfig_props_|.
  ExpectPropertiesWithVersion(&static_params_props, "SavedIP", 0);
  ExpectPopulatedIPConfigWithVersion(1);

  // Clear all "StaticIP" parameters.
  static_params_.args_.Clear();

  // Another ApplyTo() call rotates the version 1 properties in
  // |ipconfig_props_| over to SavedIP.*.  Since there are no StaticIP
  // parameters, |ipconfig_props_| should remain populated with version 1
  // parameters.
  static_params_.ApplyTo(&ipconfig_props_);
  ExpectPropertiesWithVersion(&static_params_props, "SavedIP", 1);
  ExpectPopulatedIPConfigWithVersion(1);

  // Reset |ipconfig_props_| to version 0.
  PopulateIPConfig();

  // A RestoreTo() call moves the version 1 "SavedIP" parameters into
  // |ipconfig_props_|.
  SetStaticPropertiesWithVersion(&static_params_props, 2);
  static_params_.RestoreTo(&ipconfig_props_);
  ExpectPopulatedIPConfigWithVersion(1);

  // All "SavedIP" parameters should be cleared.
  EXPECT_TRUE(static_params_.saved_args_.IsEmpty());

  // Static IP parameters should be unchanged.
  ExpectPropertiesWithVersion(&static_params_props, "StaticIP", 2);
}

TEST_F(StaticIPParametersTest, SavedParametersDict) {
  // Calling RestoreTo() when no parameters are set should not crash or
  // add any entries.
  static_params_.RestoreTo(&ipconfig_props_);
  ExpectEmptyIPConfig();

  PopulateIPConfig();
  PropertyStore static_params_props;
  static_params_.PlumbPropertyStore(&static_params_props);
  SetStaticDictPropertiesWithVersion(&static_params_props, 1);
  static_params_.ApplyTo(&ipconfig_props_);

  // The version 0 properties in |ipconfig_props_| are now in SavedIP.*
  // properties, while the version 1 StaticIP parameters are now in
  // |ipconfig_props_|.
  ExpectPropertiesWithVersion(&static_params_props, "SavedIP", 0);
  ExpectPopulatedIPConfigWithVersion(1);

  // Clear all "StaticIP" parameters.
  static_params_.args_.Clear();

  // Another ApplyTo() call rotates the version 1 properties in
  // |ipconfig_props_| over to SavedIP.*.  Since there are no StaticIP
  // parameters, |ipconfig_props_| should remain populated with version 1
  // parameters.
  static_params_.ApplyTo(&ipconfig_props_);
  ExpectPropertiesWithVersion(&static_params_props, "SavedIP", 1);
  ExpectPopulatedIPConfigWithVersion(1);

  // Reset |ipconfig_props_| to version 0.
  PopulateIPConfig();

  // A RestoreTo() call moves the version 1 "SavedIP" parameters into
  // |ipconfig_props_|.
  SetStaticDictPropertiesWithVersion(&static_params_props, 2);
  static_params_.RestoreTo(&ipconfig_props_);
  ExpectPopulatedIPConfigWithVersion(1);

  // All "SavedIP" parameters should be cleared.
  EXPECT_TRUE(static_params_.saved_args_.IsEmpty());

  // Static IP parameters should be unchanged.
  ExpectPropertiesWithVersion(&static_params_props, "StaticIP", 2);
}

}  // namespace shill