// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// This test is relatively complicated. Here's the summary of what it does:
//
// - Set up mock D-Bus related objects to mock out D-Bus calls.
// - Set up a mock proxy resolver to mock out the proxy resolution.
// - Create ProxyResolutionServiceProvider by injecting the mocks
// - Start the service provider.
// - Request ProxyResolutionServiceProvider to resolve proxy for kSourceURL.
// - ProxyResolutionServiceProvider will return the result as a signal.
// - Confirm that we receive the signal and check the contents of the signal.

#include "chrome/browser/chromeos/dbus/proxy_resolution_service_provider.h"

#include "base/bind.h"
#include "chrome/browser/chromeos/dbus/service_provider_test_helper.h"
#include "dbus/message.h"
#include "dbus/mock_exported_object.h"
#include "third_party/cros_system_api/dbus/service_constants.h"

using ::testing::_;

namespace chromeos {

// We want to know about the proxy info for the URL.
const char kSourceURL[] = "http://www.gmail.com/";

// ProxyResolutionServiceProvider will return the proxy info as a D-Bus
// signal, to the following signal interface and the signal name.
const char kReturnSignalInterface[] = "org.chromium.TestInterface";
const char kReturnSignalName[] = "TestSignal";

// The returned proxy info.
const char kReturnProxyInfo[] = "PROXY cache.example.com:12345";

// The error message is empty if proxy resolution is successful.
const char kReturnEmptyErrorMessage[] = "";

// Mock for ProxyResolverInterface. We'll inject this to
// ProxyResolutionServiceProvider to mock out the proxy resolution.
class MockProxyResolver : public ProxyResolverInterface {
 public:
  MOCK_METHOD4(ResolveProxy,
               void(const std::string& source_url,
                    const std::string& signal_interface,
                    const std::string& signal_name,
                    scoped_refptr<dbus::ExportedObject> exported_object));
};

class ProxyResolutionServiceProviderTest : public testing::Test {
 public:
  ProxyResolutionServiceProviderTest()
      : signal_received_successfully_(false) {
  }

  virtual void SetUp() OVERRIDE {
    // Create a mock proxy resolver. Will be owned by
    // |proxy_resolution_service|.
    MockProxyResolver* mock_resolver = new MockProxyResolver;
    // |mock_resolver_|'s ResolveProxy() will use MockResolveProxy().
    EXPECT_CALL(*mock_resolver,
                ResolveProxy(kSourceURL, kReturnSignalInterface,
                             kReturnSignalName, _))
        .WillOnce(Invoke(
            this,
            &ProxyResolutionServiceProviderTest::MockResolveProxy));

    // Create the proxy resolution service with the mock bus and the mock
    // resolver injected.
    service_provider_.reset(
        ProxyResolutionServiceProvider::CreateForTesting(mock_resolver));

    test_helper_.SetUp(kResolveNetworkProxy, service_provider_.get());

    // Connect to the signal that will be sent to kReturnSignalInterface and
    // kReturnSignalName. ResolveNetworkProxy() will send the result as a
    // signal. OnSignalReceived() will be called upon the delivery.
    test_helper_.SetUpReturnSignal(
        kReturnSignalInterface,
        kReturnSignalName,
        base::Bind(&ProxyResolutionServiceProviderTest::OnSignalReceived,
                   base::Unretained(this)),
        base::Bind(&ProxyResolutionServiceProviderTest::OnConnectedToSignal,
                   base::Unretained(this)));
  }

  virtual void TearDown() OVERRIDE {
    test_helper_.TearDown();
    service_provider_.reset();
  }

 protected:
  // Called when a signal is received.
  void OnSignalReceived(dbus::Signal* signal) {
    ASSERT_EQ(kReturnSignalInterface, signal->GetInterface());
    ASSERT_EQ(kReturnSignalName, signal->GetMember());

    std::string source_url;
    std::string proxy_info;
    std::string error_message;

    // The signal should contain three strings.
    dbus::MessageReader reader(signal);
    ASSERT_TRUE(reader.PopString(&source_url));
    ASSERT_TRUE(reader.PopString(&proxy_info));
    ASSERT_TRUE(reader.PopString(&error_message));

    // Check the signal contents.
    EXPECT_EQ(kSourceURL, source_url);
    EXPECT_EQ(kReturnProxyInfo, proxy_info);
    EXPECT_EQ(kReturnEmptyErrorMessage, error_message);

    // Mark that the signal is received successfully.
    signal_received_successfully_ = true;
  }

  // Called when connected to a signal.
  void OnConnectedToSignal(const std::string& signal_interface,
                           const std::string& signal_name,
                           bool success){
    ASSERT_EQ(kReturnSignalInterface, signal_interface);
    ASSERT_EQ(kReturnSignalName, signal_name);

    ASSERT_TRUE(success);
  }

  // Behaves as |mock_resolver_|'s ResolveProxy().
  void MockResolveProxy(const std::string& source_url,
                        const std::string& signal_interface,
                        const std::string& signal_name,
                        scoped_refptr<dbus::ExportedObject> exported_object) {
    if (source_url == kSourceURL) {
      dbus::Signal signal(signal_interface,
                          signal_name);
      dbus::MessageWriter writer(&signal);
      writer.AppendString(kSourceURL);
      writer.AppendString(kReturnProxyInfo);
      writer.AppendString(kReturnEmptyErrorMessage);
      // Send the signal back to the requested signal interface and the
      // signal name.
      exported_object->SendSignal(&signal);
      return;
    }

    LOG(ERROR) << "Unexpected source URL: " << source_url;
  }

  bool signal_received_successfully_;
  ServiceProviderTestHelper test_helper_;
  scoped_ptr<CrosDBusService::ServiceProviderInterface> service_provider_;
};

TEST_F(ProxyResolutionServiceProviderTest, ResolveProxy) {
  // The signal is not yet received.
  ASSERT_FALSE(signal_received_successfully_);

  // Create a method call to resolve proxy config for kSourceURL.
  dbus::MethodCall method_call(kLibCrosServiceInterface, kResolveNetworkProxy);
  dbus::MessageWriter writer(&method_call);
  writer.AppendString(kSourceURL);
  writer.AppendString(kReturnSignalInterface);
  writer.AppendString(kReturnSignalName);

  // Call the ResolveNetworkProxy method.
  scoped_ptr<dbus::Response> response(test_helper_.CallMethod(&method_call));

  // An empty response should be returned.
  ASSERT_TRUE(response.get());
  dbus::MessageReader reader(response.get());
  ASSERT_FALSE(reader.HasMoreData());

  // Confirm that the signal is received successfully.
  // The contents of the signal are checked in OnSignalReceived().
  ASSERT_TRUE(signal_received_successfully_);
}

}  // namespace chromeos