// Copyright 2014 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 "buffet/exported_property_set.h"

#include <string>
#include <vector>

#include <base/basictypes.h>
#include <base/bind.h>
#include <dbus/message.h>
#include <dbus/property.h>
#include <dbus/object_path.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>

namespace buffet {

namespace dbus_utils {

namespace {

const char kBoolPropName[] = "BoolProp";
const char kUint8PropName[] = "Uint8Prop";
const char kInt16PropName[] = "Int16Prop";
const char kUint16PropName[] = "Uint16Prop";
const char kInt32PropName[] = "Int32Prop";
const char kUint32PropName[] = "Uint32Prop";
const char kInt64PropName[] = "Int64Prop";
const char kUint64PropName[] = "Uint64Prop";
const char kDoublePropName[] = "DoubleProp";
const char kStringPropName[] = "StringProp";
const char kPathPropName[] = "PathProp";
const char kStringListPropName[] = "StringListProp";
const char kPathListPropName[] = "PathListProp";
const char kUint8ListPropName[] = "Uint8ListProp";

const char kTestInterface1[] = "org.chromium.TestInterface1";
const char kTestInterface2[] = "org.chromium.TestInterface2";
const char kTestInterface3[] = "org.chromium.TestInterface3";

const std::string kTestString("lies");
const dbus::ObjectPath kTestObjectPathInit(std::string("/path_init"));
const dbus::ObjectPath kTestObjectPathUpdate(std::string("/path_update"));

}  // namespace

class ExportedPropertySetTest : public ::testing::Test {
 public:
  ExportedPropertySetTest() {}
  struct Properties : public ExportedPropertySet {
   public:
    ExportedProperty<bool> bool_prop_;
    ExportedProperty<uint8> uint8_prop_;
    ExportedProperty<int16> int16_prop_;
    ExportedProperty<uint16> uint16_prop_;
    ExportedProperty<int32> int32_prop_;
    ExportedProperty<uint32> uint32_prop_;
    ExportedProperty<int64> int64_prop_;
    ExportedProperty<uint64> uint64_prop_;
    ExportedProperty<double> double_prop_;
    ExportedProperty<std::string> string_prop_;
    ExportedProperty<dbus::ObjectPath> path_prop_;
    ExportedProperty<std::vector<std::string>> stringlist_prop_;
    ExportedProperty<std::vector<dbus::ObjectPath>> pathlist_prop_;
    ExportedProperty<std::vector<uint8>> uint8list_prop_;

    Properties() : ExportedPropertySet(nullptr) {
      // The empty string is not a valid value for an ObjectPath.
      path_prop_.SetValue(kTestObjectPathInit);
      RegisterProperty(kTestInterface1, kBoolPropName, &bool_prop_);
      RegisterProperty(kTestInterface1, kUint8PropName, &uint8_prop_);
      RegisterProperty(kTestInterface1, kInt16PropName, &int16_prop_);
      // I chose this weird grouping because N=2 is about all the permutations
      // of GetAll that I want to anticipate.
      RegisterProperty(kTestInterface2, kUint16PropName, &uint16_prop_);
      RegisterProperty(kTestInterface2, kInt32PropName, &int32_prop_);
      RegisterProperty(kTestInterface3, kUint32PropName, &uint32_prop_);
      RegisterProperty(kTestInterface3, kInt64PropName, &int64_prop_);
      RegisterProperty(kTestInterface3, kUint64PropName, &uint64_prop_);
      RegisterProperty(kTestInterface3, kDoublePropName, &double_prop_);
      RegisterProperty(kTestInterface3, kStringPropName, &string_prop_);
      RegisterProperty(kTestInterface3, kPathPropName, &path_prop_);
      RegisterProperty(kTestInterface3, kStringListPropName, &stringlist_prop_);
      RegisterProperty(kTestInterface3, kPathListPropName, &pathlist_prop_);
      RegisterProperty(kTestInterface3, kUint8ListPropName, &uint8list_prop_);
    }
    virtual ~Properties() {}

    void CallHandleGetAll(
        dbus::MethodCall* method_call,
        dbus::ExportedObject::ResponseSender response_sender) {
      HandleGetAll(method_call, response_sender);
    }

    void CallHandleGet(dbus::MethodCall* method_call,
                       dbus::ExportedObject::ResponseSender response_sender) {
      HandleGet(method_call, response_sender);
    }

    void CallHandleSet(dbus::MethodCall* method_call,
                       dbus::ExportedObject::ResponseSender response_sender) {
      HandleSet(method_call, response_sender);
    }

    MOCK_METHOD3(PropertyUpdated, void(const std::string&, const std::string&,
                                       const ExportedPropertyBase*));

   private:
    virtual void HandlePropertyUpdated(
        const std::string& interface,
        const std::string& name,
        const ExportedPropertyBase* property) override {
      PropertyUpdated(interface, name, property);
    }
  };

  void StoreResponse(scoped_ptr<dbus::Response> method_response) {
    last_response_.reset(method_response.release());
  }

  void AssertGetAllReturnsError(dbus::MethodCall* method_call) {
    auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
                                      base::Unretained(this));
    method_call->SetSerial(123);
    p_.CallHandleGetAll(method_call, response_sender);
    ASSERT_NE(dynamic_cast<dbus::ErrorResponse*>(last_response_.get()),
              nullptr);
  }

  void AssertGetReturnsError(dbus::MethodCall* method_call) {
    auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
                                      base::Unretained(this));
    method_call->SetSerial(123);
    p_.CallHandleGet(method_call, response_sender);
    ASSERT_NE(dynamic_cast<dbus::ErrorResponse*>(last_response_.get()),
              nullptr);
  }

  scoped_ptr<dbus::Response> GetPropertyOnInterface(
      const std::string& interface_name, const std::string& property_name) {
    dbus::MethodCall method_call(dbus::kPropertiesInterface,
                                 dbus::kPropertiesGet);
    method_call.SetSerial(123);
    dbus::MessageWriter writer(&method_call);
    writer.AppendString(interface_name);
    writer.AppendString(property_name);
    auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
                                      base::Unretained(this));
    p_.CallHandleGet(&method_call, response_sender);
    return last_response_.Pass();
  }

  scoped_ptr<dbus::Response> last_response_;
  Properties p_;
};

TEST_F(ExportedPropertySetTest, UpdateNotifications) {
  ::testing::InSequence dummy;
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface1, kBoolPropName,
                                  &p_.bool_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface1, kUint8PropName,
                                  &p_.uint8_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface1, kInt16PropName,
                                  &p_.int16_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface2, kUint16PropName,
                                  &p_.uint16_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface2, kInt32PropName,
                                  &p_.int32_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kUint32PropName,
                                  &p_.uint32_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kInt64PropName,
                                  &p_.int64_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kUint64PropName,
                                  &p_.uint64_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kDoublePropName,
                                  &p_.double_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kStringPropName,
                                  &p_.string_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kPathPropName,
                                  &p_.path_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kStringListPropName,
                                  &p_.stringlist_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kPathListPropName,
                                  &p_.pathlist_prop_));
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface3, kUint8ListPropName,
                                  &p_.uint8list_prop_));
  p_.bool_prop_.SetValue(true);
  p_.uint8_prop_.SetValue(1);
  p_.int16_prop_.SetValue(1);
  p_.uint16_prop_.SetValue(1);
  p_.int32_prop_.SetValue(1);
  p_.uint32_prop_.SetValue(1);
  p_.int64_prop_.SetValue(1);
  p_.uint64_prop_.SetValue(1);
  p_.double_prop_.SetValue(1.0);
  p_.string_prop_.SetValue(kTestString);
  p_.path_prop_.SetValue(kTestObjectPathUpdate);
  p_.stringlist_prop_.SetValue({kTestString});
  p_.pathlist_prop_.SetValue({kTestObjectPathUpdate});
  p_.uint8list_prop_.SetValue({1});
}

TEST_F(ExportedPropertySetTest, UpdateToSameValue) {
  EXPECT_CALL(p_, PropertyUpdated(kTestInterface1, kBoolPropName,
                                  &p_.bool_prop_)).Times(1);
  p_.bool_prop_.SetValue(true);
  p_.bool_prop_.SetValue(true);
}

TEST_F(ExportedPropertySetTest, GetAllNoArgs) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGetAll);
  AssertGetAllReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetAllInvalidInterface) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGetAll);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString("org.chromium.BadInterface");
  AssertGetAllReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetAllExtraArgs) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGetAll);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(kTestInterface1);
  writer.AppendString(kTestInterface1);
  AssertGetAllReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetAllCorrectness) {
  dbus::MethodCall method_call(
      dbus::kPropertiesInterface, dbus::kPropertiesGetAll);
  method_call.SetSerial(123);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(kTestInterface2);
  auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
                                    base::Unretained(this));
  p_.CallHandleGetAll(&method_call, response_sender);
  dbus::MessageReader response_reader(last_response_.get());
  dbus::MessageReader dict_reader(nullptr);
  dbus::MessageReader entry_reader(nullptr);
  ASSERT_TRUE(response_reader.PopArray(&dict_reader));
  ASSERT_TRUE(dict_reader.PopDictEntry(&entry_reader));
  std::string property_name;
  ASSERT_TRUE(entry_reader.PopString(&property_name));
  uint16 value16;
  int32 value32;
  if (property_name.compare(kUint16PropName) == 0) {
    ASSERT_TRUE(entry_reader.PopVariantOfUint16(&value16));
    ASSERT_FALSE(entry_reader.HasMoreData());
    ASSERT_TRUE(dict_reader.PopDictEntry(&entry_reader));
    ASSERT_TRUE(entry_reader.PopString(&property_name));
    ASSERT_EQ(property_name.compare(kInt32PropName), 0);
    ASSERT_TRUE(entry_reader.PopVariantOfInt32(&value32));
  } else {
    ASSERT_EQ(property_name.compare(kInt32PropName), 0);
    ASSERT_TRUE(entry_reader.PopVariantOfInt32(&value32));
    ASSERT_FALSE(entry_reader.HasMoreData());
    ASSERT_TRUE(dict_reader.PopDictEntry(&entry_reader));
    ASSERT_TRUE(entry_reader.PopString(&property_name));
    ASSERT_EQ(property_name.compare(kUint16PropName), 0);
    ASSERT_TRUE(entry_reader.PopVariantOfUint16(&value16));
  }
  ASSERT_FALSE(entry_reader.HasMoreData());
  ASSERT_FALSE(dict_reader.HasMoreData());
  ASSERT_FALSE(response_reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetNoArgs) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGet);
  AssertGetReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetInvalidInterface) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGet);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString("org.chromium.BadInterface");
  writer.AppendString(kInt16PropName);
  AssertGetReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetBadPropertyName) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGet);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(kTestInterface1);
  writer.AppendString("IAmNotAProperty");
  AssertGetReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetPropIfMismatch) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGet);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(kTestInterface1);
  writer.AppendString(kStringPropName);
  AssertGetReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetNoPropertyName) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGet);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(kTestInterface1);
  AssertGetReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetExtraArgs) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesGet);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(kTestInterface1);
  writer.AppendString(kBoolPropName);
  writer.AppendString("Extra param");
  AssertGetReturnsError(&method_call);
}

TEST_F(ExportedPropertySetTest, GetWorksWithBool) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface1, kBoolPropName);
  dbus::MessageReader reader(response.get());
  bool value;
  ASSERT_TRUE(reader.PopVariantOfBool(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithUint8) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface1, kUint8PropName);
  dbus::MessageReader reader(response.get());
  uint8 value;
  ASSERT_TRUE(reader.PopVariantOfByte(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithInt16) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface1, kInt16PropName);
  dbus::MessageReader reader(response.get());
  int16 value;
  ASSERT_TRUE(reader.PopVariantOfInt16(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithUint16) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface2, kUint16PropName);
  dbus::MessageReader reader(response.get());
  uint16 value;
  ASSERT_TRUE(reader.PopVariantOfUint16(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithInt32) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface2, kInt32PropName);
  dbus::MessageReader reader(response.get());
  int32 value;
  ASSERT_TRUE(reader.PopVariantOfInt32(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithUint32) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kUint32PropName);
  dbus::MessageReader reader(response.get());
  uint32 value;
  ASSERT_TRUE(reader.PopVariantOfUint32(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithInt64) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kInt64PropName);
  dbus::MessageReader reader(response.get());
  int64 value;
  ASSERT_TRUE(reader.PopVariantOfInt64(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithUint64) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kUint64PropName);
  dbus::MessageReader reader(response.get());
  uint64 value;
  ASSERT_TRUE(reader.PopVariantOfUint64(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithDouble) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kDoublePropName);
  dbus::MessageReader reader(response.get());
  double value;
  ASSERT_TRUE(reader.PopVariantOfDouble(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithString) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kStringPropName);
  dbus::MessageReader reader(response.get());
  std::string value;
  ASSERT_TRUE(reader.PopVariantOfString(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithPath) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kPathPropName);
  dbus::MessageReader reader(response.get());
  dbus::ObjectPath value;
  ASSERT_TRUE(reader.PopVariantOfObjectPath(&value));
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithStringList) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kStringListPropName);
  dbus::MessageReader reader(response.get());
  dbus::MessageReader variant_reader(nullptr);
  std::vector<std::string> value;
  ASSERT_TRUE(reader.PopVariant(&variant_reader));
  ASSERT_TRUE(variant_reader.PopArrayOfStrings(&value));
  ASSERT_FALSE(variant_reader.HasMoreData());
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithPathList) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kPathListPropName);
  dbus::MessageReader reader(response.get());
  dbus::MessageReader variant_reader(nullptr);
  std::vector<dbus::ObjectPath> value;
  ASSERT_TRUE(reader.PopVariant(&variant_reader));
  ASSERT_TRUE(variant_reader.PopArrayOfObjectPaths(&value));
  ASSERT_FALSE(variant_reader.HasMoreData());
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, GetWorksWithUint8List) {
  scoped_ptr<dbus::Response> response = GetPropertyOnInterface(
      kTestInterface3, kPathListPropName);
  dbus::MessageReader reader(response.get());
  dbus::MessageReader variant_reader(nullptr);
  uint8* buffer;
  size_t buffer_len;
  ASSERT_TRUE(reader.PopVariant(&variant_reader));
  // |buffer| remains under the control of the MessageReader.
  ASSERT_TRUE(variant_reader.PopArrayOfBytes(&buffer, &buffer_len));
  ASSERT_FALSE(variant_reader.HasMoreData());
  ASSERT_FALSE(reader.HasMoreData());
}

TEST_F(ExportedPropertySetTest, SetFailsGracefully) {
  dbus::MethodCall method_call(dbus::kPropertiesInterface,
                               dbus::kPropertiesSet);
  method_call.SetSerial(123);
  auto response_sender = base::Bind(&ExportedPropertySetTest::StoreResponse,
                                    base::Unretained(this));
  p_.CallHandleSet(&method_call, response_sender);
  ASSERT_TRUE(
      dynamic_cast<dbus::ErrorResponse*>(last_response_.get()) != nullptr);
}

}  // namespace dbus_utils

}  // namespace buffet