Introduced TestURLFetcher::DelegateForTests interface to allow event-driven end-to-end tests of cla…

net/url_request/test_url_fetcher_factory.h

 // 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.
 
 #ifndef NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_
 #define NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_
 #pragma once
 
 #include <list>
 #include <map>
@@ skipping 41 matching lines @@
 //   fetcher->delegate()->OnURLFetchComplete(...);
 //   // Make sure consumer of URLFetcher does the right thing.
 //   ...
 //
 // Note: if you don't know when your request objects will be created you
 // might want to use the FakeURLFetcher and FakeURLFetcherFactory classes
 // below.
 
 class TestURLFetcher : public URLFetcher {
  public:
+  // Interface for tests to intercept production code classes using URLFetcher.
+  // Allows even-driven mock server classes to analyze the correctness of
+  // requests / uploads events and forge responses back at the right moment.
+  class DelegateForTests {
+   public:
+    // Callback issued correspondingly to the call to the |Start()| method.
+    virtual void OnRequestStart(int fetcher_id) = 0;
+
+    // Callback issued correspondingly to the call to |AppendChunkToUpload|.
+    // Uploaded chunks can be retrieved with the |upload_chunks()| getter.
+    virtual void OnChunkUpload(int fetcher_id) = 0;
+
+    // Callback issued correspondingly to the destructor.
+    virtual void OnRequestEnd(int fetcher_id) = 0;
+  };
+
   TestURLFetcher(int id,
                  const GURL& url,
                  URLFetcherDelegate* d);
   virtual ~TestURLFetcher();
 
   // URLFetcher implementation
   virtual void SetUploadData(const std::string& upload_content_type,
                              const std::string& upload_content) OVERRIDE;
   virtual void SetChunkedUpload(
       const std::string& upload_content_type) OVERRIDE;
@@ skipping 50 matching lines @@
 
   // Unique ID in our factory.
   int id() const { return id_; }
 
   // Returns the data uploaded on this URLFetcher.
   const std::string& upload_data() const { return upload_data_; }
 
   // Returns the chunks of data uploaded on this URLFetcher.
   const std::list<std::string>& upload_chunks() const { return chunks_; }
 
+  // Checks whether the last call to |AppendChunkToUpload(...)| was final.
+  bool did_receive_last_chunk() const { return did_receive_last_chunk_; }
+
   // Returns the delegate installed on the URLFetcher.
   URLFetcherDelegate* delegate() const { return delegate_; }
 
   void set_url(const GURL& url) { fake_url_ = url; }
   void set_status(const URLRequestStatus& status);
   void set_response_code(int response_code) {
     fake_response_code_ = response_code;
   }
   void set_cookies(const ResponseCookies& c) { fake_cookies_ = c; }
   void set_was_fetched_via_proxy(bool flag);
   void set_response_headers(scoped_refptr<HttpResponseHeaders> headers);
   void set_backoff_delay(base::TimeDelta backoff_delay);
+  void SetDelegateForTests(DelegateForTests* delegate_for_tests);
 
   // Set string data.
   void SetResponseString(const std::string& response);
 
   // Set File data.
   void SetResponseFilePath(const FilePath& path);
 
  private:
   enum ResponseDestinationType {
     STRING,  // Default: In a std::string
     TEMP_FILE  // Write to a temp file
   };
 
   const int id_;
   const GURL original_url_;
   URLFetcherDelegate* delegate_;
+  DelegateForTests* delegate_for_tests_;
   std::string upload_data_;
   std::list<std::string> chunks_;
   bool did_receive_last_chunk_;
 
   // User can use set_* methods to provide values returned by getters.
   // Setting the real values is not possible, because the real class
   // has no setters. The data is a private member of a class defined
   // in a .cc file, so we can't get at it with friendship.
   int fake_load_flags_;
   GURL fake_url_;
   URLRequestStatus fake_status_;
   int fake_response_code_;
   ResponseCookies fake_cookies_;
   ResponseDestinationType fake_response_destination_;
   std::string fake_response_string_;
   FilePath fake_response_file_path_;
   bool fake_was_fetched_via_proxy_;
   scoped_refptr<HttpResponseHeaders> fake_response_headers_;
   HttpRequestHeaders fake_extra_request_headers_;
   int fake_max_retries_;
   base::TimeDelta fake_backoff_delay_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLFetcher);
 };
 
+typedef TestURLFetcher::DelegateForTests TestURLFetcherDelegateForTests;
+
 // Simple URLFetcherFactory method that creates TestURLFetchers. All fetchers
 // are registered in a map by the id passed to the create method.
 class TestURLFetcherFactory : public URLFetcherFactory,
                               public ScopedURLFetcherFactory {
  public:
   TestURLFetcherFactory();
   virtual ~TestURLFetcherFactory();
 
   virtual URLFetcher* CreateURLFetcher(
       int id,
       const GURL& url,
       URLFetcher::RequestType request_type,
       URLFetcherDelegate* d) OVERRIDE;
   TestURLFetcher* GetFetcherByID(int id) const;
   void RemoveFetcherFromMap(int id);
+  void SetDelegateForTests(TestURLFetcherDelegateForTests* delegate_for_tests);
 
  private:
   // Maps from id passed to create to the returned URLFetcher.
   typedef std::map<int, TestURLFetcher*> Fetchers;
   Fetchers fetchers_;
+  TestURLFetcherDelegateForTests* delegate_for_tests_;
 
   DISALLOW_COPY_AND_ASSIGN(TestURLFetcherFactory);
 };
 
 // The FakeURLFetcher and FakeURLFetcherFactory classes are similar to the
 // ones above but don't require you to know when exactly the URLFetcher objects
 // will be created.
 //
 // These classes let you set pre-baked HTTP responses for particular URLs.
 // E.g., if the user requests http://a.com/ then respond with an HTTP/500.
@@ skipping 75 matching lines @@
       int id,
       const GURL& url,
       URLFetcher::RequestType request_type,
       URLFetcherDelegate* d) OVERRIDE;
 
 };
 
 }  // namespace net
 
 #endif  // NET_URL_REQUEST_TEST_URL_FETCHER_FACTORY_H_