mock_url_fetcher.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef NET_INSTAWEB_HTTP_PUBLIC_MOCK_URL_FETCHER_H_
#define NET_INSTAWEB_HTTP_PUBLIC_MOCK_URL_FETCHER_H_

#include <map>

#include "net/instaweb/http/public/url_async_fetcher.h"
#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/http/response_headers.h"

namespace net_instaweb {

class AsyncFetch;
class MessageHandler;
class ThreadSystem;
class Timer;

class MockUrlFetcher : public UrlAsyncFetcher {
 public:
  MockUrlFetcher();
  virtual ~MockUrlFetcher();

  void SetResponse(const StringPiece& url,
                   const ResponseHeaders& response_header,
                   const StringPiece& response_body);

  void AddToResponse(const StringPiece& url,
                     const StringPiece& name,
                     const StringPiece& value);

  void SetConditionalResponse(const StringPiece& url,
                              int64 last_modified_date,
                              const GoogleString& etag,
                              const ResponseHeaders& response_header,
                              const StringPiece& response_body);

  virtual void Fetch(const GoogleString& url,
                     MessageHandler* message_handler,
                     AsyncFetch* fetch);

  virtual bool SupportsHttps() const {
    ScopedMutex lock(mutex_.get());
    return supports_https_;
  }

  void set_fetcher_supports_https(bool supports_https) {
    ScopedMutex lock(mutex_.get());
    supports_https_ = supports_https;
  }

  const GoogleString& last_referer() {
    ScopedMutex lock(mutex_.get());
    return last_referer_;
  }

  void SetResponseFailure(const StringPiece& url);

  void Clear();

  void RemoveResponse(const StringPiece& url);

  void Disable() {
    ScopedMutex lock(mutex_.get());
    enabled_ = false;
  }
  void Enable() {
    ScopedMutex lock(mutex_.get());
    enabled_ = true;
  }

  void set_fail_on_unexpected(bool x) {
    ScopedMutex lock(mutex_.get());
    fail_on_unexpected_ = x;
  }

  void set_update_date_headers(bool x) {
    ScopedMutex lock(mutex_.get());
    update_date_headers_ = x;
  }

  void set_omit_empty_writes(bool x) {
    ScopedMutex lock(mutex_.get());
    omit_empty_writes_ = x;
  }

  void set_fail_after_headers(bool x) {
    ScopedMutex lock(mutex_.get());
    fail_after_headers_ = x;
  }

  void set_verify_host_header(bool x) {
    ScopedMutex lock(mutex_.get());
    verify_host_header_ = x;
  }

  void set_verify_pagespeed_header_off(bool x) {
    ScopedMutex lock(mutex_.get());
    verify_pagespeed_header_off_ = x;
  }

  void set_timer(Timer* timer) {
    ScopedMutex lock(mutex_.get());
    timer_ = timer;
  }

  void set_split_writes(bool val) {
    ScopedMutex lock(mutex_.get());
    split_writes_ = val;
  }

  void set_error_message(const GoogleString& msg) {
    ScopedMutex lock(mutex_.get());
    error_message_ = msg;
  }

  void set_strip_query_params(bool strip_query_params) {
    ScopedMutex lock(mutex_.get());
    strip_query_params_ = strip_query_params;
  }

 private:
  class HttpResponse {
   public:
    HttpResponse(int64 last_modified_time, const GoogleString& etag,
                 const ResponseHeaders& in_header, const StringPiece& in_body)
        : last_modified_time_(last_modified_time),
          etag_(etag),
          body_(in_body.data(), in_body.size()),
          success_(true) {
      header_.CopyFrom(in_header);
    }

    const int64 last_modified_time() const { return last_modified_time_; }
    const GoogleString& etag() const { return etag_; }
    const ResponseHeaders& header() const { return header_; }
    ResponseHeaders* mutable_header() { return &header_; }
    const GoogleString& body() const { return body_; }
    void set_success(bool success) { success_ = success; }
    bool success() const { return success_; }

   private:
    int64 last_modified_time_;
    GoogleString etag_;
    ResponseHeaders header_;
    GoogleString body_;
    bool success_;

    
  };
  typedef std::map<const GoogleString, HttpResponse*> ResponseMap;

  ResponseMap response_map_;

  bool enabled_;
  bool fail_on_unexpected_; 
  bool update_date_headers_; 
  bool omit_empty_writes_; 
  bool fail_after_headers_; 
  bool verify_host_header_; 
  bool verify_pagespeed_header_off_; 
  bool split_writes_; 
  bool supports_https_; 
  bool strip_query_params_; 

  GoogleString error_message_; 
  Timer* timer_; 
  GoogleString last_referer_; 
  scoped_ptr<ThreadSystem> thread_system_; 
  scoped_ptr<AbstractMutex> mutex_; 

  
};

}  

#endif