mojo/fetcher/network_fetcher_unittest.cc

// Copyright 2015 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.

#include "base/at_exit.h"
#include "base/auto_reset.h"
#include "base/bind.h"
#include "base/logging.h"
#include "base/macros.h"
#include "base/memory/scoped_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "mojo/fetcher/network_fetcher.h"
#include "mojo/public/cpp/bindings/strong_binding.h"
#include "mojo/runner/context.h"
#include "mojo/services/network/public/interfaces/url_loader.mojom.h"
#include "mojo/services/network/public/interfaces/url_loader_factory.mojom.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace mojo {
namespace fetcher {
namespace {

const char k200Request[] = "http://request_expect_200";
const char k404Request[] = "http://request_expect_404";
const char k504Request[] = "http://request_expect_504";
const char kErrorRequest[] = "http://request_expect_error";

class TestURLLoaderImpl : public URLLoader {
 public:
  explicit TestURLLoaderImpl(InterfaceRequest<URLLoader> request)
      : binding_(this, request.Pass()) {}
  ~TestURLLoaderImpl() override {}

 private:
  // URLLoader implementation.
  void Start(URLRequestPtr request,
             const Callback<void(URLResponsePtr)>& callback) override {
    URLResponsePtr response(URLResponse::New());
    response->url = request->url;
    if (request->url == std::string(k200Request)) {
      response->mime_type = "text/html";
      response->status_code = 200;
    } else if (request->url == std::string(k404Request)) {
      response->mime_type = "text/html";
      response->status_code = 404;
    } else if (request->url == std::string(k504Request)) {
      response->mime_type = "text/html";
      response->status_code = 504;
    } else {
      response->error = NetworkError::New();
      response->error->code = -2;
    }
    callback.Run(response.Pass());
  }
  void FollowRedirect(const Callback<void(URLResponsePtr)>& callback) override {
    NOTREACHED();
  }
  void QueryStatus(
      const Callback<void(URLLoaderStatusPtr)>& callback) override {
    NOTREACHED();
  }

  StrongBinding<URLLoader> binding_;
  DISALLOW_COPY_AND_ASSIGN(TestURLLoaderImpl);
};

class TestURLLoaderFactoryImpl : public URLLoaderFactory {
 public:
  explicit TestURLLoaderFactoryImpl(InterfaceRequest<URLLoaderFactory> request)
      : binding_(this, request.Pass()) {}
  ~TestURLLoaderFactoryImpl() override {}

 private:
  // URLLoaderFactory implementation.
  void CreateURLLoader(InterfaceRequest<URLLoader> loader) override {
    new TestURLLoaderImpl(loader.Pass());
  }

  StrongBinding<URLLoaderFactory> binding_;
  DISALLOW_COPY_AND_ASSIGN(TestURLLoaderFactoryImpl);
};

class FetchCallbackHelper {
 public:
  FetchCallbackHelper() : run_loop_(nullptr) {}
  ~FetchCallbackHelper() {}

  shell::Fetcher::FetchCallback GetCallback() {
    return base::Bind(&FetchCallbackHelper::CallbackHandler,
                      base::Unretained(this));
  }

  void WaitForCallback() {
    base::RunLoop run_loop;
    base::AutoReset<base::RunLoop*> auto_reset(&run_loop_, &run_loop);
    run_loop.Run();
  }

  shell::Fetcher* fetcher() const { return fetcher_.get(); }

 private:
  void CallbackHandler(scoped_ptr<shell::Fetcher> fetcher) {
    fetcher_ = fetcher.Pass();
    if (run_loop_)
      run_loop_->Quit();
  }

  // If it is not null, it points to a stack-allocated base::RunLoop instance in
  // WaitForCallback().
  base::RunLoop* run_loop_;
  scoped_ptr<shell::Fetcher> fetcher_;
  DISALLOW_COPY_AND_ASSIGN(FetchCallbackHelper);
};

class NetworkFetcherTest : public testing::Test {
 public:
  NetworkFetcherTest() {}
  ~NetworkFetcherTest() override {}

 protected:
  // Overridden from testing::Test:
  void SetUp() override {
    runner::Context::EnsureEmbedderIsInitialized();
    // Automatically destroyed when |url_loader_factory_| is closed.
    new TestURLLoaderFactoryImpl(GetProxy(&url_loader_factory_));
  }

  // When |expect_fetch_success| is false, |expected_status_code| is ignored.
  void TestFetchURL(const std::string& url,
                    bool expect_fetch_success,
                    uint32_t expected_status_code) {
    FetchCallbackHelper helper;

    URLRequestPtr request(URLRequest::New());
    request->url = url;
    new NetworkFetcher(true, request.Pass(), url_loader_factory_.get(),
                       helper.GetCallback());
    helper.WaitForCallback();

    if (!expect_fetch_success) {
      ASSERT_FALSE(helper.fetcher());
    } else {
      ASSERT_TRUE(helper.fetcher());
      URLResponsePtr response = helper.fetcher()->AsURLResponse(nullptr, 0);
      ASSERT_TRUE(response);
      EXPECT_EQ(url, response->url);
      EXPECT_EQ(expected_status_code, response->status_code);
    }
  }

 private:
  base::ShadowingAtExitManager at_exit_;
  base::MessageLoop loop_;
  URLLoaderFactoryPtr url_loader_factory_;

  DISALLOW_COPY_AND_ASSIGN(NetworkFetcherTest);
};

TEST_F(NetworkFetcherTest, FetchSucceeded200) {
  TestFetchURL(k200Request, true, 200u);
}

TEST_F(NetworkFetcherTest, FetchSucceeded404) {
  TestFetchURL(k404Request, true, 404u);
}

TEST_F(NetworkFetcherTest, FetchSucceeded504) {
  TestFetchURL(k504Request, true, 504u);
}

TEST_F(NetworkFetcherTest, FetchFailed) {
  TestFetchURL(kErrorRequest, false, 0u);
}

}  // namespace
}  // namespace fetcher
}  // namespace mojo