JD2022-TU1/main/extern/Hue/libhuestream/test/TestDefaultAuthenticator.cpp

/*******************************************************************************
 Copyright (c) 2013-2015 Koninklijke Philips N.V.
 All Rights Reserved.
 ********************************************************************************/

#include <huestream/connect/DefaultAuthenticator.h>
#include "gtest/gtest.h"
#include "gmock/gmock.h"

#include "MockHttp.h"

#include <huestream/config/HueConfig.h>

using ::testing::Invoke;
using ::testing::Eq;

namespace huestream {
namespace connectionflow {

static std::string s_username;
static std::string s_clientkey;

static void SetHttpAuthenticateResponseSuccessButWithoutClientKey(HttpRequestPtr req) {
  const string authenticateResponseSuccess = "[{\"success\":{\"username\": \"" + s_username + "\"}}]";
  req->SetSuccess(true);
  req->SetResponse(authenticateResponseSuccess);
}

static void SetHttpAuthenticateResponseSuccess(HttpRequestPtr req) {
  const string authenticateResponseSuccess =
      "[{\"success\":{\"username\": \"" + s_username + "\", \"clientkey\": \"" + s_clientkey + "\"}}]";
  req->SetSuccess(true);
  req->SetResponse(authenticateResponseSuccess);
}


static void SetHttpAuthenticateResponseErrorButtonNotPressed(HttpRequestPtr req) {
  const string authenticateResponseError101 =
      "[{\"error\":{\"type\":101,\"address\":\"\",\"description\":\"link button not pressed\"}}]";
  req->SetSuccess(true);
  req->SetResponse(authenticateResponseError101);
}

static void SetHttpAuthenticateResponseTimeout(HttpRequestPtr req) {
  req->SetSuccess(false);
}

static void SetHttpAuthenticateResponseErrorClientkeyNotAvailable(HttpRequestPtr req) {
  const string authenticateResponseError6 =
    "[{\"error\":{\"type\":6,\"address\":\"/generateclientkey\",\"description\":\"parameter, generateclientkey, not available\"}}]";
  req->SetSuccess(true);
  req->SetResponse(authenticateResponseError6);
}

class TestDefaultAuthenticator: public testing::Test {
 public:
  BridgePtr _bridge;
  std::shared_ptr<MockHttp> _mockHttpPtr;
  std::shared_ptr<DefaultAuthenticator> _defaultAuthenticator;
  std::string _ip;
  std::string _appName;
  std::string _platform;
  const std::string _id = "001788FFFE200646";
  const std::string _apiVersion = "1.18.0";
  const std::string _outdatedApiVersion = "1.14.0";

  virtual void SetUp() {
    _ip = "192.168.1.15";
    s_username = "testUser";
    s_clientkey = "DD129216F1A50E5D1C0CB356325745F2";
    _appName = "AuthenticatorUnitTest";
    _platform = "PC";

    _bridge = std::make_shared<Bridge>();
    _bridge->SetIpAddress(_ip);
    _bridge->SetIsValidIp(true);
    _bridge->SetId(_id);
    _bridge->SetApiversion(_apiVersion);

    _mockHttpPtr = std::make_shared<MockHttp>();
    HueConfig::GetInstance()->SetHttp(_mockHttpPtr);

    auto appSettings = std::make_shared<AppSettings>();
    appSettings->SetName(_appName);
    appSettings->SetPlatform(_platform);
    HueConfig::GetInstance()->SetAppSettings(appSettings);

    auto hueSettings = std::make_shared<HueSettings>();
    HueConfig::GetInstance()->SetHueSettings(hueSettings);

    _defaultAuthenticator = std::make_shared<DefaultAuthenticator>();
  }

  const std::string getAuthUrl() {
    const std::string url = "http://" + _ip + "/api";
    return url;
  }

  const std::string getAuthBodyWithClientKey() {
    const std::string body = "{\"devicetype\": \"" + _appName + "#" + _platform + "\", \"generateclientkey\": true\n}";
    return body;
  }

  const std::string getAuthBodyWithoutClientKey() {
    const std::string body = "{\"devicetype\": \"" + _appName + "#" + _platform + "\"}";
    return body;
  }

  virtual void TearDown() {
    HueConfig::GetInstance()->TearDown();
  }

};


TEST_F(TestDefaultAuthenticator, AuthenticateSuccess) {
  EXPECT_CALL(*_mockHttpPtr,
              Execute(MatchHttpRequest(HTTP_REQUEST_POST, getAuthUrl(), getAuthBodyWithClientKey()))).Times(1).WillOnce(Invoke(
      SetHttpAuthenticateResponseSuccess));

  _defaultAuthenticator->Authenticate(_bridge, [this](BridgePtr b) {
    ASSERT_THAT(b->GetIpAddress(), Eq(_ip));
    ASSERT_THAT(b->GetUser(), Eq(s_username));
    ASSERT_THAT(b->IsValidIp(), Eq(true));
    ASSERT_THAT(b->IsAuthorized(), Eq(true));
    ASSERT_THAT(b->GetClientKey(), Eq(s_clientkey));
    ASSERT_THAT(b->GetId(), Eq(_id));
    ASSERT_THAT(b->GetApiversion(), Eq(_apiVersion));
  });
}

TEST_F(TestDefaultAuthenticator, AuthenticateSuccessWithoutClientKey) {
  _bridge->SetApiversion(_outdatedApiVersion);
  EXPECT_CALL(*_mockHttpPtr,
              Execute(MatchHttpRequest(HTTP_REQUEST_POST, getAuthUrl(), getAuthBodyWithoutClientKey()))).Times(1).WillOnce(Invoke(
      SetHttpAuthenticateResponseSuccessButWithoutClientKey));

  _defaultAuthenticator->Authenticate(_bridge, [this](BridgePtr b) {
    ASSERT_THAT(b->GetIpAddress(), Eq(_ip));
    ASSERT_THAT(b->GetUser(), Eq(s_username));
    ASSERT_THAT(b->IsValidIp(), Eq(true));
    ASSERT_THAT(b->IsAuthorized(), Eq(true));
    ASSERT_THAT(b->GetClientKey(), Eq(""));
    ASSERT_THAT(b->GetId(), Eq(_id));
    ASSERT_THAT(b->GetApiversion(), Eq(_outdatedApiVersion));
  });
}

TEST_F(TestDefaultAuthenticator, AuthenticateFailButtonNotPressed) {
  EXPECT_CALL(*_mockHttpPtr,
              Execute(MatchHttpRequest(HTTP_REQUEST_POST, getAuthUrl(), getAuthBodyWithClientKey()))).Times(1).WillOnce(Invoke(
      SetHttpAuthenticateResponseErrorButtonNotPressed));

  _defaultAuthenticator->Authenticate(_bridge, [this](BridgePtr b) {
    ASSERT_THAT(b->GetIpAddress(), Eq(_ip));
    ASSERT_THAT(b->IsValidIp(), Eq(true));
    ASSERT_THAT(b->IsAuthorized(), Eq(false));
    ASSERT_THAT(b->GetId(), Eq(_id));
    ASSERT_THAT(b->GetApiversion(), Eq(_apiVersion));
  });
}

TEST_F(TestDefaultAuthenticator, AuthenticateFailNoResponse) {
  EXPECT_CALL(*_mockHttpPtr,
              Execute(MatchHttpRequest(HTTP_REQUEST_POST, getAuthUrl(), getAuthBodyWithClientKey()))).Times(1).WillOnce(Invoke(
      SetHttpAuthenticateResponseTimeout));

  _defaultAuthenticator->Authenticate(_bridge, [this](BridgePtr b) {
    ASSERT_THAT(b->GetIpAddress(), Eq(_ip));
    ASSERT_THAT(b->IsValidIp(), Eq(false));
    ASSERT_THAT(b->IsAuthorized(), Eq(false));
    ASSERT_THAT(b->GetId(), Eq(_id));
    ASSERT_THAT(b->GetApiversion(), Eq(_apiVersion));
  });
}

TEST_F(TestDefaultAuthenticator, AuthenticateFailClientkeyNotAvailable) {
  _bridge->SetApiversion("");
  EXPECT_CALL(*_mockHttpPtr,
    Execute(MatchHttpRequest(HTTP_REQUEST_POST, getAuthUrl(), getAuthBodyWithClientKey()))).Times(1).WillOnce(Invoke(
      SetHttpAuthenticateResponseErrorClientkeyNotAvailable));

  _defaultAuthenticator->Authenticate(_bridge, [this](BridgePtr b) {
    ASSERT_THAT(b->GetIpAddress(), Eq(_ip));
    ASSERT_THAT(b->IsValidIp(), Eq(true));
    ASSERT_THAT(b->IsAuthorized(), Eq(false));
    ASSERT_THAT(b->GetId(), Eq(_id));
    ASSERT_THAT(b->GetApiversion(), Eq("0.0.0"));
  });
}

}
}