src/privet/privet_handler_unittest.cc

// Copyright 2015 The Weave 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 "src/privet/privet_handler.h"

#include <set>
#include <string>
#include <utility>

#include <base/bind.h>
#include <base/json/json_reader.h>
#include <base/json/json_writer.h>
#include <base/strings/string_util.h>
#include <base/values.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <weave/test/unittest_utils.h>

#include "src/privet/constants.h"
#include "src/privet/mock_delegates.h"
#include "src/test/mock_clock.h"

using testing::_;
using testing::DoAll;
using testing::Invoke;
using testing::Return;
using testing::SetArgPointee;
using testing::SaveArg;
using testing::WithArgs;

namespace weave {
namespace privet {

namespace {

void LoadTestJson(const std::string& test_json,
                  base::DictionaryValue* dictionary) {
  std::string json = test_json;
  base::ReplaceChars(json, "'", "\"", &json);
  int error = 0;
  std::string message;
  std::unique_ptr<base::Value> value(
      base::JSONReader::ReadAndReturnError(json, base::JSON_PARSE_RFC, &error,
                                           &message)
          .release());
  EXPECT_TRUE(value.get()) << "\nError: " << message << "\n" << json;
  base::DictionaryValue* dictionary_ptr = nullptr;
  if (value->GetAsDictionary(&dictionary_ptr))
    dictionary->MergeDictionary(dictionary_ptr);
}

struct CodeWithReason {
  CodeWithReason(int code_in, const std::string& reason_in)
      : code(code_in), reason(reason_in) {}
  int code;
  std::string reason;
};

std::ostream& operator<<(std::ostream& stream, const CodeWithReason& error) {
  return stream << "{" << error.code << ", " << error.reason << "}";
}

bool IsEqualError(const CodeWithReason& expected,
                  const base::DictionaryValue& dictionary) {
  std::string reason;
  int code = 0;
  return dictionary.GetInteger("error.http_status", &code) &&
         code == expected.code && dictionary.GetString("error.code", &reason) &&
         reason == expected.reason;
}

// Some error sections in response JSON objects contained debugging information
// which is of no interest for this test. So, remove the debug info from the
// JSON before running validation logic on it.
std::unique_ptr<base::DictionaryValue> StripDebugErrorDetails(
    const std::string& path_to_error_object,
    const base::DictionaryValue& value) {
  std::unique_ptr<base::DictionaryValue> result{value.DeepCopy()};
  base::DictionaryValue* error_dict = nullptr;
  EXPECT_TRUE(result->GetDictionary(path_to_error_object, &error_dict));
  scoped_ptr<base::Value> dummy;
  error_dict->RemovePath("error.debugInfo", &dummy);
  error_dict->RemovePath("error.message", &dummy);
  return result;
}

}  // namespace

class PrivetHandlerTest : public testing::Test {
 public:
  PrivetHandlerTest() {}

 protected:
  void SetUp() override {
    EXPECT_CALL(clock_, Now())
        .WillRepeatedly(Return(base::Time::FromTimeT(1410000001)));

    auth_header_ = "Privet anonymous";
    handler_.reset(
        new PrivetHandler(&cloud_, &device_, &security_, &wifi_, &clock_));
  }

  const base::DictionaryValue& HandleRequest(
      const std::string& api,
      const base::DictionaryValue* input) {
    output_.Clear();
    handler_->HandleRequest(api, auth_header_, input,
                            base::Bind(&PrivetHandlerTest::HandlerCallback,
                                       base::Unretained(this)));
    return output_;
  }

  const base::DictionaryValue& HandleRequest(const std::string& api,
                                             const std::string& json_input) {
    base::DictionaryValue dictionary;
    LoadTestJson(json_input, &dictionary);
    return HandleRequest(api, &dictionary);
  }

  void HandleUnknownRequest(const std::string& api) {
    output_.Clear();
    base::DictionaryValue dictionary;
    handler_->HandleRequest(api, auth_header_, &dictionary,
                            base::Bind(&PrivetHandlerTest::HandlerNoFound));
  }

  const base::DictionaryValue& GetResponse() const { return output_; }
  int GetResponseCount() const { return response_count_; }

  void SetNoWifiAndGcd() {
    handler_.reset(
        new PrivetHandler(&cloud_, &device_, &security_, nullptr, &clock_));
    EXPECT_CALL(cloud_, GetCloudId()).WillRepeatedly(Return(""));
    EXPECT_CALL(cloud_, GetConnectionState())
        .WillRepeatedly(ReturnRef(gcd_disabled_state_));
    auto set_error = [](const std::string&, const std::string&,
                        ErrorPtr* error) {
      Error::AddTo(error, FROM_HERE, "setupUnavailable", "");
    };
    EXPECT_CALL(cloud_, Setup(_, _, _))
        .WillRepeatedly(DoAll(Invoke(set_error), Return(false)));
  }

  test::MockClock clock_;
  testing::StrictMock<MockCloudDelegate> cloud_;
  testing::StrictMock<MockDeviceDelegate> device_;
  testing::StrictMock<MockSecurityDelegate> security_;
  testing::StrictMock<MockWifiDelegate> wifi_;
  std::string auth_header_;

 private:
  void HandlerCallback(int status, const base::DictionaryValue& output) {
    output_.Clear();
    ++response_count_;
    output_.MergeDictionary(&output);
    if (!output_.HasKey("error")) {
      EXPECT_EQ(200, status);
      return;
    }
    EXPECT_NE(200, status);
    output_.SetInteger("error.http_status", status);
  }

  static void HandlerNoFound(int status, const base::DictionaryValue&) {
    EXPECT_EQ(404, status);
  }

  std::unique_ptr<PrivetHandler> handler_;
  base::DictionaryValue output_;
  int response_count_{0};
  ConnectionState gcd_disabled_state_{ConnectionState::kDisabled};
};

TEST_F(PrivetHandlerTest, UnknownApi) {
  HandleUnknownRequest("/privet/foo");
}

TEST_F(PrivetHandlerTest, InvalidFormat) {
  auth_header_ = "";
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidFormat"),
               HandleRequest("/privet/info", nullptr));
}

TEST_F(PrivetHandlerTest, MissingAuth) {
  auth_header_ = "";
  EXPECT_PRED2(IsEqualError, CodeWithReason(401, "missingAuthorization"),
               HandleRequest("/privet/info", "{}"));
}

TEST_F(PrivetHandlerTest, InvalidAuth) {
  auth_header_ = "foo";
  EXPECT_PRED2(IsEqualError, CodeWithReason(401, "invalidAuthorization"),
               HandleRequest("/privet/info", "{}"));
}

TEST_F(PrivetHandlerTest, ExpiredAuth) {
  auth_header_ = "Privet 123";
  EXPECT_CALL(security_, ParseAccessToken(_, _, _))
      .WillRepeatedly(WithArgs<2>(Invoke([](ErrorPtr* error) {
        return Error::AddTo(error, FROM_HERE, "authorizationExpired", "");
      })));
  EXPECT_PRED2(IsEqualError, CodeWithReason(403, "authorizationExpired"),
               HandleRequest("/privet/info", "{}"));
}

TEST_F(PrivetHandlerTest, InvalidAuthScope) {
  EXPECT_PRED2(IsEqualError, CodeWithReason(403, "invalidAuthorizationScope"),
               HandleRequest("/privet/v3/setup/start", "{}"));
}

TEST_F(PrivetHandlerTest, InfoMinimal) {
  SetNoWifiAndGcd();
  EXPECT_CALL(security_, GetPairingTypes())
      .WillRepeatedly(Return(std::set<PairingType>{}));
  EXPECT_CALL(security_, GetCryptoTypes())
      .WillRepeatedly(Return(std::set<CryptoType>{}));
  EXPECT_CALL(security_, GetAuthTypes())
      .WillRepeatedly(Return(std::set<AuthType>{}));

  const char kExpected[] = R"({
    'version': '3.0',
    'id': 'TestId',
    'name': 'TestDevice',
    'services': [ "developmentBoard" ],
    'modelManifestId': "ABMID",
    'basicModelManifest': {
      'uiDeviceKind': 'developmentBoard',
      'oemName': 'Chromium',
      'modelName': 'Brillo'
    },
    'endpoints': {
      'httpPort': 0,
      'httpUpdatesPort': 0,
      'httpsPort': 0,
      'httpsUpdatesPort': 0
    },
    'authentication': {
      'anonymousMaxScope': 'user',
      'mode': [
      ],
      'pairing': [
      ],
      'crypto': [
      ]
    },
    'gcd': {
      'id': '',
      'status': 'disabled'
    },
    'time': 1410000001000.0,
    'sessionId': 'SessionId'
  })";
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/info", "{}"));
}

TEST_F(PrivetHandlerTest, Info) {
  EXPECT_CALL(cloud_, GetDescription())
      .WillRepeatedly(Return("TestDescription"));
  EXPECT_CALL(cloud_, GetLocation()).WillRepeatedly(Return("TestLocation"));
  EXPECT_CALL(device_, GetHttpEnpoint())
      .WillRepeatedly(Return(std::make_pair(80, 10080)));
  EXPECT_CALL(device_, GetHttpsEnpoint())
      .WillRepeatedly(Return(std::make_pair(443, 10443)));
  EXPECT_CALL(wifi_, GetHostedSsid())
      .WillRepeatedly(Return("Test_device.BBABCLAprv"));

  const char kExpected[] = R"({
    'version': '3.0',
    'id': 'TestId',
    'name': 'TestDevice',
    'description': 'TestDescription',
    'location': 'TestLocation',
    'services': [ "developmentBoard" ],
    'modelManifestId': "ABMID",
    'basicModelManifest': {
      'uiDeviceKind': 'developmentBoard',
      'oemName': 'Chromium',
      'modelName': 'Brillo'
    },
    'endpoints': {
      'httpPort': 80,
      'httpUpdatesPort': 10080,
      'httpsPort': 443,
      'httpsUpdatesPort': 10443
    },
    'authentication': {
      'anonymousMaxScope': 'none',
      'mode': [
        'anonymous',
        'pairing',
        'local'
      ],
      'pairing': [
        'pinCode',
        'embeddedCode'
      ],
      'crypto': [
        'p224_spake2'
      ]
    },
    'wifi': {
      'capabilities': [
        '2.4GHz'
      ],
      'ssid': 'TestSsid',
      'hostedSsid': 'Test_device.BBABCLAprv',
      'status': 'offline'
    },
    'gcd': {
      'id': 'TestCloudId',
      'status': 'online'
    },
    'time': 1410000001000.0,
    'sessionId': 'SessionId'
  })";
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/info", "{}"));
}

TEST_F(PrivetHandlerTest, PairingStartInvalidParams) {
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
               HandleRequest("/privet/v3/pairing/start",
                             "{'pairing':'embeddedCode','crypto':'crypto'}"));

  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
               HandleRequest("/privet/v3/pairing/start",
                             "{'pairing':'code','crypto':'p224_spake2'}"));
}

TEST_F(PrivetHandlerTest, PairingStart) {
  EXPECT_JSON_EQ(
      "{'deviceCommitment': 'testCommitment', 'sessionId': 'testSession'}",
      HandleRequest("/privet/v3/pairing/start",
                    "{'pairing': 'embeddedCode', 'crypto': 'p224_spake2'}"));
}

TEST_F(PrivetHandlerTest, PairingConfirm) {
  EXPECT_JSON_EQ(
      "{'certFingerprint':'testFingerprint','certSignature':'testSignature'}",
      HandleRequest(
          "/privet/v3/pairing/confirm",
          "{'sessionId':'testSession','clientCommitment':'testCommitment'}"));
}

TEST_F(PrivetHandlerTest, PairingCancel) {
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/pairing/cancel",
                                     "{'sessionId': 'testSession'}"));
}

TEST_F(PrivetHandlerTest, AuthErrorNoType) {
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidAuthMode"),
               HandleRequest("/privet/v3/auth", "{}"));
}

TEST_F(PrivetHandlerTest, AuthErrorInvalidType) {
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidAuthMode"),
               HandleRequest("/privet/v3/auth", "{'mode':'unknown'}"));
}

TEST_F(PrivetHandlerTest, AuthErrorNoScope) {
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidRequestedScope"),
               HandleRequest("/privet/v3/auth", "{'mode':'anonymous'}"));
}

TEST_F(PrivetHandlerTest, AuthErrorInvalidScope) {
  EXPECT_PRED2(
      IsEqualError, CodeWithReason(400, "invalidRequestedScope"),
      HandleRequest("/privet/v3/auth",
                    "{'mode':'anonymous','requestedScope':'unknown'}"));
}

TEST_F(PrivetHandlerTest, AuthErrorAccessDenied) {
  EXPECT_PRED2(IsEqualError, CodeWithReason(403, "accessDenied"),
               HandleRequest("/privet/v3/auth",
                             "{'mode':'anonymous','requestedScope':'owner'}"));
}

TEST_F(PrivetHandlerTest, AuthErrorInvalidAuthCode) {
  auto set_error = [](ErrorPtr* error) {
    return Error::AddTo(error, FROM_HERE, "invalidAuthCode", "");
  };
  EXPECT_CALL(security_, CreateAccessToken(_, "testToken", _, _, _, _, _))
      .WillRepeatedly(WithArgs<6>(Invoke(set_error)));
  const char kInput[] = R"({
    'mode': 'pairing',
    'requestedScope': 'user',
    'authCode': 'testToken'
  })";
  EXPECT_PRED2(IsEqualError, CodeWithReason(403, "invalidAuthCode"),
               HandleRequest("/privet/v3/auth", kInput));
}

TEST_F(PrivetHandlerTest, AuthAnonymous) {
  const char kExpected[] = R"({
    'accessToken': 'GuestAccessToken',
    'expiresIn': 15,
    'scope': 'viewer',
    'tokenType': 'Privet'
  })";
  EXPECT_JSON_EQ(kExpected,
                 HandleRequest("/privet/v3/auth",
                               "{'mode':'anonymous','requestedScope':'auto'}"));
}

TEST_F(PrivetHandlerTest, AuthPairing) {
  EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
      .WillRepeatedly(DoAll(SetArgPointee<3>("OwnerAccessToken"),
                            SetArgPointee<4>(AuthScope::kOwner),
                            SetArgPointee<5>(base::TimeDelta::FromSeconds(15)),
                            Return(true)));
  const char kInput[] = R"({
    'mode': 'pairing',
    'requestedScope': 'owner',
    'authCode': 'testToken'
  })";
  const char kExpected[] = R"({
    'accessToken': 'OwnerAccessToken',
    'expiresIn': 15,
    'scope': 'owner',
    'tokenType': 'Privet'
  })";
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/auth", kInput));
}

TEST_F(PrivetHandlerTest, AuthLocalAuto) {
  EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
      .WillRepeatedly(DoAll(SetArgPointee<3>("UserAccessToken"),
                            SetArgPointee<4>(AuthScope::kUser),
                            SetArgPointee<5>(base::TimeDelta::FromSeconds(15)),
                            Return(true)));
  const char kInput[] = R"({
    'mode': 'local',
    'requestedScope': 'auto',
    'authCode': 'localAuthToken'
  })";
  const char kExpected[] = R"({
    'accessToken': 'UserAccessToken',
    'expiresIn': 15,
    'scope': 'user',
    'tokenType': 'Privet'
  })";
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/auth", kInput));
}

TEST_F(PrivetHandlerTest, AuthLocal) {
  EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
      .WillRepeatedly(DoAll(SetArgPointee<3>("ManagerAccessToken"),
                            SetArgPointee<4>(AuthScope::kManager),
                            SetArgPointee<5>(base::TimeDelta::FromSeconds(15)),
                            Return(true)));
  const char kInput[] = R"({
    'mode': 'local',
    'requestedScope': 'manager',
    'authCode': 'localAuthToken'
  })";
  const char kExpected[] = R"({
    'accessToken': 'ManagerAccessToken',
    'expiresIn': 15,
    'scope': 'manager',
    'tokenType': 'Privet'
  })";
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/auth", kInput));
}

TEST_F(PrivetHandlerTest, AuthLocalHighScope) {
  EXPECT_CALL(security_, CreateAccessToken(_, _, _, _, _, _, _))
      .WillRepeatedly(DoAll(SetArgPointee<3>("UserAccessToken"),
                            SetArgPointee<4>(AuthScope::kUser),
                            SetArgPointee<5>(base::TimeDelta::FromSeconds(1)),
                            Return(true)));
  const char kInput[] = R"({
    'mode': 'local',
    'requestedScope': 'manager',
    'authCode': 'localAuthToken'
  })";
  EXPECT_PRED2(IsEqualError, CodeWithReason(403, "accessDenied"),
               HandleRequest("/privet/v3/auth", kInput));
}

class PrivetHandlerTestWithAuth : public PrivetHandlerTest {
 public:
  void SetUp() override {
    PrivetHandlerTest::SetUp();
    auth_header_ = "Privet 123";
    EXPECT_CALL(security_, ParseAccessToken(_, _, _))
        .WillRepeatedly(DoAll(
            SetArgPointee<1>(UserInfo{AuthScope::kOwner, TestUserId{"1"}}),
            Return(true)));
  }
};

class PrivetHandlerSetupTest : public PrivetHandlerTestWithAuth {};

TEST_F(PrivetHandlerSetupTest, StatusEmpty) {
  SetNoWifiAndGcd();
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/setup/status", "{}"));
}

TEST_F(PrivetHandlerSetupTest, StatusWifi) {
  wifi_.setup_state_ = SetupState{SetupState::kSuccess};

  const char kExpected[] = R"({
    'wifi': {
        'ssid': 'TestSsid',
        'status': 'success'
     }
  })";
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/status", "{}"));
}

TEST_F(PrivetHandlerSetupTest, StatusWifiError) {
  ErrorPtr error;
  Error::AddTo(&error, FROM_HERE, "invalidPassphrase", "");
  wifi_.setup_state_ = SetupState{std::move(error)};

  const char kExpected[] = R"({
    'wifi': {
        'status': 'error',
        'error': {
          'code': 'invalidPassphrase'
        }
     }
  })";
  EXPECT_JSON_EQ(kExpected,
                 *StripDebugErrorDetails(
                     "wifi", HandleRequest("/privet/v3/setup/status", "{}")));
}

TEST_F(PrivetHandlerSetupTest, StatusGcd) {
  cloud_.setup_state_ = SetupState{SetupState::kSuccess};

  const char kExpected[] = R"({
    'gcd': {
        'id': 'TestCloudId',
        'status': 'success'
     }
  })";
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/status", "{}"));
}

TEST_F(PrivetHandlerSetupTest, StatusGcdError) {
  ErrorPtr error;
  Error::AddTo(&error, FROM_HERE, "invalidTicket", "");
  cloud_.setup_state_ = SetupState{std::move(error)};

  const char kExpected[] = R"({
    'gcd': {
        'status': 'error',
        'error': {
          'code': 'invalidTicket'
        }
     }
  })";
  EXPECT_JSON_EQ(kExpected,
                 *StripDebugErrorDetails(
                     "gcd", HandleRequest("/privet/v3/setup/status", "{}")));
}

TEST_F(PrivetHandlerSetupTest, SetupNameDescriptionLocation) {
  EXPECT_CALL(cloud_,
              UpdateDeviceInfo("testName", "testDescription", "testLocation"))
      .Times(1);
  const char kInput[] = R"({
    'name': 'testName',
    'description': 'testDescription',
    'location': 'testLocation'
  })";
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/setup/start", kInput));
}

TEST_F(PrivetHandlerSetupTest, InvalidParams) {
  const char kInputWifi[] = R"({
    'wifi': {
      'ssid': ''
    }
  })";
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
               HandleRequest("/privet/v3/setup/start", kInputWifi));

  const char kInputRegistration[] = R"({
    'gcd': {
      'ticketId': ''
    }
  })";
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "invalidParams"),
               HandleRequest("/privet/v3/setup/start", kInputRegistration));
}

TEST_F(PrivetHandlerSetupTest, WifiSetupUnavailable) {
  SetNoWifiAndGcd();
  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "setupUnavailable"),
               HandleRequest("/privet/v3/setup/start", "{'wifi': {}}"));
}

TEST_F(PrivetHandlerSetupTest, WifiSetup) {
  const char kInput[] = R"({
    'wifi': {
      'ssid': 'testSsid',
      'passphrase': 'testPass'
    }
  })";
  auto set_error = [](const std::string&, const std::string&, ErrorPtr* error) {
    return Error::AddTo(error, FROM_HERE, "deviceBusy", "");
  };
  EXPECT_CALL(wifi_, ConfigureCredentials(_, _, _)).WillOnce(Invoke(set_error));
  EXPECT_PRED2(IsEqualError, CodeWithReason(503, "deviceBusy"),
               HandleRequest("/privet/v3/setup/start", kInput));

  const char kExpected[] = R"({
    'wifi': {
      'status': 'inProgress'
    }
  })";
  wifi_.setup_state_ = SetupState{SetupState::kInProgress};
  EXPECT_CALL(wifi_, ConfigureCredentials("testSsid", "testPass", _))
      .WillOnce(Return(true));
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/start", kInput));
}

TEST_F(PrivetHandlerSetupTest, GcdSetupUnavailable) {
  SetNoWifiAndGcd();
  const char kInput[] = R"({
    'gcd': {
      'ticketId': 'testTicket',
      'user': 'testUser'
    }
  })";

  EXPECT_PRED2(IsEqualError, CodeWithReason(400, "setupUnavailable"),
               HandleRequest("/privet/v3/setup/start", kInput));
}

TEST_F(PrivetHandlerSetupTest, GcdSetup) {
  const char kInput[] = R"({
    'gcd': {
      'ticketId': 'testTicket',
      'user': 'testUser'
    }
  })";

  auto set_error = [](const std::string&, const std::string&, ErrorPtr* error) {
    return Error::AddTo(error, FROM_HERE, "deviceBusy", "");
  };
  EXPECT_CALL(cloud_, Setup(_, _, _)).WillOnce(Invoke(set_error));
  EXPECT_PRED2(IsEqualError, CodeWithReason(503, "deviceBusy"),
               HandleRequest("/privet/v3/setup/start", kInput));

  const char kExpected[] = R"({
    'gcd': {
      'status': 'inProgress'
    }
  })";
  cloud_.setup_state_ = SetupState{SetupState::kInProgress};
  EXPECT_CALL(cloud_, Setup("testTicket", "testUser", _))
      .WillOnce(Return(true));
  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/setup/start", kInput));
}

TEST_F(PrivetHandlerSetupTest, GcdSetupAsMaster) {
  EXPECT_CALL(security_, ParseAccessToken(_, _, _))
      .WillRepeatedly(DoAll(
          SetArgPointee<1>(UserInfo{AuthScope::kManager, TestUserId{"1"}}),
          Return(true)));
  const char kInput[] = R"({
    'gcd': {
      'ticketId': 'testTicket',
      'user': 'testUser'
    }
  })";

  EXPECT_PRED2(IsEqualError, CodeWithReason(403, "invalidAuthorizationScope"),
               HandleRequest("/privet/v3/setup/start", kInput));
}

TEST_F(PrivetHandlerTestWithAuth, ClaimAccessControl) {
  EXPECT_JSON_EQ("{'clientToken': 'RootClientAuthToken'}",
                 HandleRequest("/privet/v3/accessControl/claim", "{}"));
}

TEST_F(PrivetHandlerTestWithAuth, ConfirmAccessControl) {
  EXPECT_JSON_EQ("{}",
                 HandleRequest("/privet/v3/accessControl/confirm",
                               "{'clientToken': 'DerivedClientAuthToken'}"));
}

TEST_F(PrivetHandlerTestWithAuth, State) {
  EXPECT_JSON_EQ("{'state': {'test': {}}, 'fingerprint': '1'}",
                 HandleRequest("/privet/v3/state", "{}"));

  cloud_.NotifyOnStateChanged();

  EXPECT_JSON_EQ("{'state': {'test': {}}, 'fingerprint': '2'}",
                 HandleRequest("/privet/v3/state", "{}"));
}

TEST_F(PrivetHandlerTestWithAuth, CommandsDefs) {
  EXPECT_JSON_EQ("{'commands': {'test':{}}, 'fingerprint': '1'}",
                 HandleRequest("/privet/v3/commandDefs", "{}"));

  cloud_.NotifyOnTraitDefsChanged();

  EXPECT_JSON_EQ("{'commands': {'test':{}}, 'fingerprint': '2'}",
                 HandleRequest("/privet/v3/commandDefs", "{}"));
}

TEST_F(PrivetHandlerTestWithAuth, Traits) {
  EXPECT_JSON_EQ("{'traits': {'test': {}}, 'fingerprint': '1'}",
                 HandleRequest("/privet/v3/traits", "{}"));

  cloud_.NotifyOnTraitDefsChanged();

  EXPECT_JSON_EQ("{'traits': {'test': {}}, 'fingerprint': '2'}",
                 HandleRequest("/privet/v3/traits", "{}"));
}

TEST_F(PrivetHandlerTestWithAuth, Components) {
  EXPECT_JSON_EQ("{'components': {'test': {}}, 'fingerprint': '1'}",
                 HandleRequest("/privet/v3/components", "{}"));

  cloud_.NotifyOnComponentTreeChanged();

  EXPECT_JSON_EQ("{'components': {'test': {}}, 'fingerprint': '2'}",
                 HandleRequest("/privet/v3/components", "{}"));

  // State change will also change the components fingerprint.
  cloud_.NotifyOnStateChanged();

  EXPECT_JSON_EQ("{'components': {'test': {}}, 'fingerprint': '3'}",
                 HandleRequest("/privet/v3/components", "{}"));
}

TEST_F(PrivetHandlerTestWithAuth, ComponentsWithFiltersAndPaths) {
  const char kComponents[] = R"({
    "comp1": {
      "traits": ["a", "b"],
      "state": {
        "a" : {
          "prop": 1
        }
      },
      "components": {
        "comp2": {
          "traits": ["c"],
          "components": {
            "comp4": {
              "traits": ["d"]
            }
          }
        },
        "comp3": {
          "traits": ["e"]
        }
      }
    }
  })";
  base::DictionaryValue components;
  LoadTestJson(kComponents, &components);
  EXPECT_CALL(cloud_, FindComponent(_, _)).WillRepeatedly(Return(nullptr));
  EXPECT_CALL(cloud_, GetComponents()).WillRepeatedly(ReturnRef(components));
  const char kExpected1[] = R"({
    "components": {
      "comp1": {
        "state": {
          "a" : {
            "prop": 1
          }
        }
      }
    },
    "fingerprint": "1"
  })";
  EXPECT_JSON_EQ(kExpected1, HandleRequest("/privet/v3/components",
                                           "{'filter':['state']}"));

  const char kExpected2[] = R"({
    "components": {
      "comp1": {
        "traits": ["a", "b"]
      }
    },
    "fingerprint": "1"
  })";
  EXPECT_JSON_EQ(kExpected2, HandleRequest("/privet/v3/components",
                                           "{'filter':['traits']}"));

  const char kExpected3[] = R"({
    "components": {
      "comp1": {
        "components": {
          "comp2": {
            "components": {
              "comp4": {}
            }
          },
          "comp3": {}
        }
      }
    },
    "fingerprint": "1"
  })";
  EXPECT_JSON_EQ(kExpected3, HandleRequest("/privet/v3/components",
                                           "{'filter':['components']}"));

  const char kExpected4[] = R"({
    "components": {
      "comp1": {
        "traits": ["a", "b"],
        "state": {
          "a" : {
            "prop": 1
          }
        },
        "components": {
          "comp2": {
            "traits": ["c"],
            "components": {
              "comp4": {
                "traits": ["d"]
              }
            }
          },
          "comp3": {
            "traits": ["e"]
          }
        }
      }
    },
    "fingerprint": "1"
  })";
  EXPECT_JSON_EQ(kExpected4,
                 HandleRequest("/privet/v3/components",
                               "{'filter':['traits', 'components', 'state']}"));

  const base::DictionaryValue* comp2 = nullptr;
  ASSERT_TRUE(components.GetDictionary("comp1.components.comp2", &comp2));
  EXPECT_CALL(cloud_, FindComponent("comp1.comp2", _)).WillOnce(Return(comp2));

  const char kExpected5[] = R"({
    "components": {
      "comp2": {
        "traits": ["c"],
        "components": {
          "comp4": {
            "traits": ["d"]
          }
        }
      }
    },
    "fingerprint": "1"
  })";
  EXPECT_JSON_EQ(
      kExpected5,
      HandleRequest(
          "/privet/v3/components",
          "{'path':'comp1.comp2', 'filter':['traits', 'components']}"));

  auto error_handler = [](ErrorPtr* error) -> const base::DictionaryValue* {
    return Error::AddTo(error, FROM_HERE, "componentNotFound", "");
  };
  EXPECT_CALL(cloud_, FindComponent("comp7", _))
      .WillOnce(WithArgs<1>(Invoke(error_handler)));

  EXPECT_PRED2(
      IsEqualError, CodeWithReason(500, "componentNotFound"),
      HandleRequest("/privet/v3/components",
                    "{'path':'comp7', 'filter':['traits', 'components']}"));
}

TEST_F(PrivetHandlerTestWithAuth, CommandsExecute) {
  const char kInput[] = "{'name': 'test'}";
  base::DictionaryValue command;
  LoadTestJson(kInput, &command);
  LoadTestJson("{'id':'5'}", &command);
  EXPECT_CALL(cloud_, AddCommand(_, _, _))
      .WillOnce(WithArgs<2>(Invoke(
          [&command](const CloudDelegate::CommandDoneCallback& callback) {
            callback.Run(command, nullptr);
          })));

  EXPECT_JSON_EQ("{'name':'test', 'id':'5'}",
                 HandleRequest("/privet/v3/commands/execute", kInput));
}

TEST_F(PrivetHandlerTestWithAuth, CommandsStatus) {
  const char kInput[] = "{'id': '5'}";
  base::DictionaryValue command;
  LoadTestJson(kInput, &command);
  LoadTestJson("{'name':'test'}", &command);
  EXPECT_CALL(cloud_, GetCommand(_, _, _))
      .WillOnce(WithArgs<2>(Invoke(
          [&command](const CloudDelegate::CommandDoneCallback& callback) {
            callback.Run(command, nullptr);
          })));

  EXPECT_JSON_EQ("{'name':'test', 'id':'5'}",
                 HandleRequest("/privet/v3/commands/status", kInput));

  ErrorPtr error;
  Error::AddTo(&error, FROM_HERE, "notFound", "");
  EXPECT_CALL(cloud_, GetCommand(_, _, _))
      .WillOnce(WithArgs<2>(
          Invoke([&error](const CloudDelegate::CommandDoneCallback& callback) {
            callback.Run({}, std::move(error));
          })));

  EXPECT_PRED2(IsEqualError, CodeWithReason(404, "notFound"),
               HandleRequest("/privet/v3/commands/status", "{'id': '15'}"));
}

TEST_F(PrivetHandlerTestWithAuth, CommandsCancel) {
  const char kExpected[] = "{'id': '5', 'name':'test', 'state':'cancelled'}";
  base::DictionaryValue command;
  LoadTestJson(kExpected, &command);
  EXPECT_CALL(cloud_, CancelCommand(_, _, _))
      .WillOnce(WithArgs<2>(Invoke(
          [&command](const CloudDelegate::CommandDoneCallback& callback) {
            callback.Run(command, nullptr);
          })));

  EXPECT_JSON_EQ(kExpected,
                 HandleRequest("/privet/v3/commands/cancel", "{'id': '8'}"));

  ErrorPtr error;
  Error::AddTo(&error, FROM_HERE, "notFound", "");
  EXPECT_CALL(cloud_, CancelCommand(_, _, _))
      .WillOnce(WithArgs<2>(
          Invoke([&error](const CloudDelegate::CommandDoneCallback& callback) {
            callback.Run({}, std::move(error));
          })));

  EXPECT_PRED2(IsEqualError, CodeWithReason(404, "notFound"),
               HandleRequest("/privet/v3/commands/cancel", "{'id': '11'}"));
}

TEST_F(PrivetHandlerTestWithAuth, CommandsList) {
  const char kExpected[] = R"({
    'commands' : [
        {'id':'5', 'state':'cancelled'},
        {'id':'15', 'state':'inProgress'}
     ]})";

  base::DictionaryValue commands;
  LoadTestJson(kExpected, &commands);

  EXPECT_CALL(cloud_, ListCommands(_, _))
      .WillOnce(WithArgs<1>(Invoke(
          [&commands](const CloudDelegate::CommandDoneCallback& callback) {
            callback.Run(commands, nullptr);
          })));

  EXPECT_JSON_EQ(kExpected, HandleRequest("/privet/v3/commands/list", "{}"));
}

class PrivetHandlerCheckForUpdatesTest : public PrivetHandlerTestWithAuth {};

TEST_F(PrivetHandlerCheckForUpdatesTest, NoInput) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  cloud_.NotifyOnTraitDefsChanged();
  cloud_.NotifyOnComponentTreeChanged();
  cloud_.NotifyOnStateChanged();
  const char kInput[] = "{}";
  const char kExpected[] = R"({
   'commandsFingerprint': '2',
   'stateFingerprint': '2',
   'traitsFingerprint': '2',
   'componentsFingerprint': '3'
  })";
  EXPECT_JSON_EQ(kExpected,
                 HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(1, GetResponseCount());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, AlreadyChanged) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  cloud_.NotifyOnTraitDefsChanged();
  cloud_.NotifyOnComponentTreeChanged();
  cloud_.NotifyOnStateChanged();
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  const char kExpected[] = R"({
   'commandsFingerprint': '2',
   'stateFingerprint': '2',
   'traitsFingerprint': '2',
   'componentsFingerprint': '3'
  })";
  EXPECT_JSON_EQ(kExpected,
                 HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(1, GetResponseCount());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollCommands) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnTraitDefsChanged();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '2',
   'stateFingerprint': '1',
   'traitsFingerprint': '2',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollTraits) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnTraitDefsChanged();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '2',
   'stateFingerprint': '1',
   'traitsFingerprint': '2',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollState) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnStateChanged();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '2',
   'traitsFingerprint': '1',
   'componentsFingerprint': '2'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollComponents) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnComponentTreeChanged();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '2'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollIgnoreTraits) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'stateFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnTraitDefsChanged();
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnComponentTreeChanged();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '2',
   'stateFingerprint': '1',
   'traitsFingerprint': '2',
   'componentsFingerprint': '2'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, LongPollIgnoreState) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'traitsFingerprint': '1'
  })";
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnStateChanged();
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnComponentTreeChanged();
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnTraitDefsChanged();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '2',
   'stateFingerprint': '2',
   'traitsFingerprint': '2',
   'componentsFingerprint': '3'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, InstantTimeout) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1',
   'waitTimeout': 0
  })";
  const char kExpected[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kExpected,
                 HandleRequest("/privet/v3/checkForUpdates", kInput));
}

TEST_F(PrivetHandlerCheckForUpdatesTest, UserTimeout) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1',
   'waitTimeout': 3
  })";
  base::Closure callback;
  EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(3)))
      .WillOnce(SaveArg<1>(&callback));
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  callback.Run();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, ServerTimeout) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::FromMinutes(1)));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  base::Closure callback;
  EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(50)))
      .WillOnce(SaveArg<1>(&callback));
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  callback.Run();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, VeryShortServerTimeout) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::FromSeconds(5)));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kInput, HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(1, GetResponseCount());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, ServerAndUserTimeout) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::FromMinutes(1)));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1',
   'waitTimeout': 10
  })";
  base::Closure callback;
  EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(10)))
      .WillOnce(SaveArg<1>(&callback));
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  callback.Run();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
}

TEST_F(PrivetHandlerCheckForUpdatesTest, ChangeBeforeTimeout) {
  EXPECT_CALL(device_, GetHttpRequestTimeout())
      .WillOnce(Return(base::TimeDelta::Max()));
  const char kInput[] = R"({
   'commandsFingerprint': '1',
   'stateFingerprint': '1',
   'traitsFingerprint': '1',
   'componentsFingerprint': '1',
   'waitTimeout': 10
  })";
  base::Closure callback;
  EXPECT_CALL(device_, PostDelayedTask(_, _, base::TimeDelta::FromSeconds(10)))
      .WillOnce(SaveArg<1>(&callback));
  EXPECT_JSON_EQ("{}", HandleRequest("/privet/v3/checkForUpdates", kInput));
  EXPECT_EQ(0, GetResponseCount());
  cloud_.NotifyOnTraitDefsChanged();
  EXPECT_EQ(1, GetResponseCount());
  const char kExpected[] = R"({
   'commandsFingerprint': '2',
   'stateFingerprint': '1',
   'traitsFingerprint': '2',
   'componentsFingerprint': '1'
  })";
  EXPECT_JSON_EQ(kExpected, GetResponse());
  callback.Run();
  EXPECT_EQ(1, GetResponseCount());
}

}  // namespace privet
}  // namespace weave