[core] move retry logic to DefaultFileSource

19 files changed, 124 insertions, 103 deletions

diff --git a/test/fixtures/database/cache.db b/test/fixtures/database/cache.db
index c358381f1f..04bbdbb34b 100644
--- a/test/fixtures/database/cache.db
+++ b/test/fixtures/database/cache.db
diff --git a/test/fixtures/database/invalid.db b/test/fixtures/database/invalid.db
index f07e4af03d..b068b15465 100644
--- a/test/fixtures/database/invalid.db
+++ b/test/fixtures/database/invalid.db
diff --git a/test/fixtures/mock_file_source.cpp b/test/fixtures/mock_file_source.cpp
index 407f54408f..5049b5c001 100644
--- a/test/fixtures/mock_file_source.cpp
+++ b/test/fixtures/mock_file_source.cpp
@@ -52,13 +52,11 @@ private:
 
 void MockFileSource::Impl::replyWithSuccess(Request* req) const {
     std::shared_ptr<Response> res = std::make_shared<Response>();
-    res->status = Response::Status::Successful;
 
     try {
         res->data = std::make_shared<const std::string>(std::move(util::read_file(req->resource.url)));
     } catch (const std::exception& err) {
-        res->status = Response::Status::Error;
-        res->message = err.what();
+        res->error = std::make_unique<Response::Error>(Response::Error::Reason::Other, err.what());
     }
 
     req->notify(res);
@@ -81,8 +79,7 @@ void MockFileSource::Impl::replyWithFailure(Request* req) const {
     }
 
     std::shared_ptr<Response> res = std::make_shared<Response>();
-    res->status = Response::Status::Error;
-    res->message = "Failed by the test case";
+    res->error = std::make_unique<Response::Error>(Response::Error::Reason::Other, "Failed by the test case");
 
     req->notify(res);
 }
@@ -94,7 +91,6 @@ void MockFileSource::Impl::replyWithCorruptedData(Request* req) const {
     }
 
     std::shared_ptr<Response> res = std::make_shared<Response>();
-    res->status = Response::Status::Successful;
     auto data = std::make_shared<std::string>(std::move(util::read_file(req->resource.url)));
     data->insert(0, "CORRUPTED");
     res->data = std::move(data);
diff --git a/test/storage/cache_response.cpp b/test/storage/cache_response.cpp
index 5b0923900e..f70557e6e0 100644
--- a/test/storage/cache_response.cpp
+++ b/test/storage/cache_response.cpp
@@ -18,14 +18,13 @@ TEST_F(Storage, CacheResponse) {
 
     Request* req = fs.request(resource, uv_default_loop(), [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Response 1", *res.data);
         EXPECT_LT(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
         response = res;
     });
 
@@ -35,14 +34,13 @@ TEST_F(Storage, CacheResponse) {
     // again, we'd get different values.
     req = fs.request(resource, uv_default_loop(), [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(response.status, res.status);
+        EXPECT_EQ(response.error, res.error);
         EXPECT_EQ(response.stale, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ(*response.data, *res.data);
         EXPECT_EQ(response.expires, res.expires);
         EXPECT_EQ(response.modified, res.modified);
         EXPECT_EQ(response.etag, res.etag);
-        EXPECT_EQ(response.message, res.message);
 
         CacheResponse.finish();
     });
diff --git a/test/storage/cache_revalidate.cpp b/test/storage/cache_revalidate.cpp
index d7dcbe71cd..6d9d30a3ec 100644
--- a/test/storage/cache_revalidate.cpp
+++ b/test/storage/cache_revalidate.cpp
@@ -25,14 +25,13 @@ TEST_F(Storage, CacheRevalidateSame) {
         }
         first = false;
 
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Response", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("snowfall", res.etag);
-        EXPECT_EQ("", res.message);
 
         req2 = fs.request(revalidateSame, uv_default_loop(), [&, res](const Response &res2) {
             if (res2.stale) {
@@ -48,8 +47,8 @@ TEST_F(Storage, CacheRevalidateSame) {
             fs.cancel(req2);
             req2 = nullptr;
 
-            EXPECT_EQ(Response::Successful, res2.status);
-            EXPECT_EQ(false, res.stale);
+            EXPECT_EQ(nullptr, res2.error);
+            EXPECT_EQ(false, res2.stale);
             ASSERT_TRUE(res2.data.get());
             EXPECT_EQ(res.data, res2.data);
             EXPECT_EQ("Response", *res2.data);
@@ -58,7 +57,6 @@ TEST_F(Storage, CacheRevalidateSame) {
             EXPECT_EQ(0, res2.modified);
             // We're not sending the ETag in the 304 reply, but it should still be there.
             EXPECT_EQ("snowfall", res2.etag);
-            EXPECT_EQ("", res2.message);
 
             CacheRevalidateSame.finish();
         });
@@ -88,14 +86,13 @@ TEST_F(Storage, CacheRevalidateModified) {
         }
         first = false;
 
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Response", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(1420070400, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
 
         req2 = fs.request(revalidateModified, uv_default_loop(), [&, res](const Response &res2) {
             if (res2.stale) {
@@ -111,7 +108,7 @@ TEST_F(Storage, CacheRevalidateModified) {
             fs.cancel(req2);
             req2 = nullptr;
 
-            EXPECT_EQ(Response::Successful, res2.status);
+            EXPECT_EQ(nullptr, res2.error);
             EXPECT_EQ(false, res2.stale);
             ASSERT_TRUE(res2.data.get());
             EXPECT_EQ("Response", *res2.data);
@@ -120,7 +117,6 @@ TEST_F(Storage, CacheRevalidateModified) {
             EXPECT_LT(0, res2.expires);
             EXPECT_EQ(1420070400, res2.modified);
             EXPECT_EQ("", res2.etag);
-            EXPECT_EQ("", res2.message);
 
             CacheRevalidateModified.finish();
         });
@@ -149,14 +145,13 @@ TEST_F(Storage, CacheRevalidateEtag) {
         }
         first = false;
 
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Response 1", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("response-1", res.etag);
-        EXPECT_EQ("", res.message);
 
         req2 = fs.request(revalidateEtag, uv_default_loop(), [&, res](const Response &res2) {
             if (res2.stale) {
@@ -172,15 +167,14 @@ TEST_F(Storage, CacheRevalidateEtag) {
             fs.cancel(req2);
             req2 = nullptr;
 
-            EXPECT_EQ(Response::Successful, res2.status);
-            EXPECT_EQ(false, res.stale);
+            EXPECT_EQ(nullptr, res2.error);
+            EXPECT_EQ(false, res2.stale);
             ASSERT_TRUE(res2.data.get());
             EXPECT_NE(res.data, res2.data);
             EXPECT_EQ("Response 2", *res2.data);
             EXPECT_EQ(0, res2.expires);
             EXPECT_EQ(0, res2.modified);
             EXPECT_EQ("response-2", res2.etag);
-            EXPECT_EQ("", res2.message);
 
             CacheRevalidateEtag.finish();
         });
diff --git a/test/storage/directory_reading.cpp b/test/storage/directory_reading.cpp
index f101252761..c30f504f3d 100644
--- a/test/storage/directory_reading.cpp
+++ b/test/storage/directory_reading.cpp
@@ -18,16 +18,17 @@ TEST_F(Storage, AssetReadDirectory) {
     Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage" }, uv_default_loop(),
                [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Error, res.status);
+        ASSERT_NE(nullptr, res.error);
+        EXPECT_EQ(Response::Error::Reason::NotFound, res.error->reason);
         EXPECT_EQ(false, res.stale);
         ASSERT_FALSE(res.data.get());
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
 #ifdef MBGL_ASSET_ZIP
-        EXPECT_EQ("No such file", res.message);
+        EXPECT_EQ("No such file", res.error->message);
 #elif MBGL_ASSET_FS
-        EXPECT_EQ("illegal operation on a directory", res.message);
+        EXPECT_EQ("illegal operation on a directory", res.error->message);
 #endif
         ReadDirectory.finish();
     });
diff --git a/test/storage/file_reading.cpp b/test/storage/file_reading.cpp
index ab7ba326ad..c1b7f27a98 100644
--- a/test/storage/file_reading.cpp
+++ b/test/storage/file_reading.cpp
@@ -19,14 +19,13 @@ TEST_F(Storage, AssetEmptyFile) {
     Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/empty" }, uv_default_loop(),
                [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_LT(1420000000, res.modified);
         EXPECT_NE("", res.etag);
-        EXPECT_EQ("", res.message);
         EmptyFile.finish();
     });
 
@@ -47,14 +46,13 @@ TEST_F(Storage, AssetNonEmptyFile) {
     Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/nonempty" },
                uv_default_loop(), [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("content is here\n", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_LT(1420000000, res.modified);
         EXPECT_NE("", res.etag);
-        EXPECT_EQ("", res.message);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("content is here\n", *res.data);
         NonEmptyFile.finish();
@@ -77,16 +75,17 @@ TEST_F(Storage, AssetNonExistentFile) {
     Request* req = fs.request({ Resource::Unknown, "asset://TEST_DATA/fixtures/storage/does_not_exist" },
                uv_default_loop(), [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Error, res.status);
+        ASSERT_NE(nullptr, res.error);
+        EXPECT_EQ(Response::Error::Reason::NotFound, res.error->reason);
         EXPECT_EQ(false, res.stale);
         ASSERT_FALSE(res.data.get());
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
 #ifdef MBGL_ASSET_ZIP
-        EXPECT_EQ("No such file", res.message);
+        EXPECT_EQ("No such file", res.error->message);
 #elif MBGL_ASSET_FS
-        EXPECT_EQ("no such file or directory", res.message);
+        EXPECT_EQ("no such file or directory", res.error->message);
 #endif
         NonExistentFile.finish();
     });
diff --git a/test/storage/http_cancel.cpp b/test/storage/http_cancel.cpp
index 7dfe9c58d5..cbe273e05d 100644
--- a/test/storage/http_cancel.cpp
+++ b/test/storage/http_cancel.cpp
@@ -38,14 +38,13 @@ TEST_F(Storage, HTTPCancelMultiple) {
     });
     Request* req = fs.request(resource, uv_default_loop(), [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
         HTTPCancelMultiple.finish();
     });
     fs.cancel(req2);
diff --git a/test/storage/http_coalescing.cpp b/test/storage/http_coalescing.cpp
index 2748fb8757..ab776eebfb 100644
--- a/test/storage/http_coalescing.cpp
+++ b/test/storage/http_coalescing.cpp
@@ -26,13 +26,12 @@ TEST_F(Storage, HTTPCoalescing) {
             EXPECT_EQ(&res, reference);
         }
 
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
 
         if (counter >= total) {
             HTTPCoalescing.finish();
@@ -69,13 +68,12 @@ TEST_F(Storage, HTTPMultiple) {
         reference = &res;
 
         // Do not cancel the request right away.
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(2147483647, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
 
         // Start a second request for the same resource after the first one has been completed.
         req2 = fs.request(resource, uv_default_loop(), [&] (const Response &res2) {
@@ -86,13 +84,12 @@ TEST_F(Storage, HTTPMultiple) {
             fs.cancel(req1);
             fs.cancel(req2);
 
-            EXPECT_EQ(Response::Successful, res2.status);
+            EXPECT_EQ(nullptr, res2.error);
             ASSERT_TRUE(res2.data.get());
             EXPECT_EQ("Hello World!", *res2.data);
             EXPECT_EQ(2147483647, res2.expires);
             EXPECT_EQ(0, res2.modified);
             EXPECT_EQ("", res2.etag);
-            EXPECT_EQ("", res2.message);
 
             HTTPMultiple.finish();
         });
@@ -117,14 +114,13 @@ TEST_F(Storage, HTTPStale) {
     Request* req2 = nullptr;
     req1 = fs.request(resource, uv_default_loop(), [&] (const Response &res) {
         // Do not cancel the request right away.
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(false, res.stale);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
 
         // Don't start the request twice in case this callback gets fired multiple times.
         if (req2) {
@@ -135,13 +131,12 @@ TEST_F(Storage, HTTPStale) {
 
         // Start a second request for the same resource after the first one has been completed.
         req2 = fs.request(resource, uv_default_loop(), [&] (const Response &res2) {
-            EXPECT_EQ(Response::Successful, res2.status);
+            EXPECT_EQ(nullptr, res2.error);
             ASSERT_TRUE(res2.data.get());
             EXPECT_EQ("Hello World!", *res2.data);
             EXPECT_EQ(0, res2.expires);
             EXPECT_EQ(0, res2.modified);
             EXPECT_EQ("", res2.etag);
-            EXPECT_EQ("", res2.message);
 
             if (res2.stale) {
                 EXPECT_EQ(0, stale);
diff --git a/test/storage/http_error.cpp b/test/storage/http_error.cpp
index 85bc70e546..00deeb063a 100644
--- a/test/storage/http_error.cpp
+++ b/test/storage/http_error.cpp
@@ -19,67 +19,80 @@ TEST_F(Storage, HTTPError) {
 
     using namespace mbgl;
 
-    uv_timer_t statusChange;
-    uv_timer_init(uv_default_loop(), &statusChange);
-    uv_timer_start(&statusChange, [](UV_TIMER_PARAMS) {
-        NetworkStatus::Reachable();
-    }, 500, 500);
-    uv_unref((uv_handle_t *)&statusChange);
-
     DefaultFileSource fs(nullptr);
 
-    auto start = uv_hrtime();
+    const auto start = uv_hrtime();
 
     Request* req1 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/temporary-error" }, uv_default_loop(),
                [&](const Response &res) {
-        fs.cancel(req1);
-        const auto duration = double(uv_hrtime() - start) / 1e9;
-        EXPECT_LT(1, duration) << "Backoff timer didn't wait 1 second";
-        EXPECT_GT(1.2, duration) << "Backoff timer fired too late";
-        EXPECT_EQ(Response::Successful, res.status);
-        EXPECT_EQ(false, res.stale);
-        ASSERT_TRUE(res.data.get());
-        EXPECT_EQ("Hello World!", *res.data);
-        EXPECT_EQ(0, res.expires);
-        EXPECT_EQ(0, res.modified);
-        EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
-
-        HTTPTemporaryError.finish();
+        static int counter = 0;
+        switch (counter++) {
+        case 0: {
+            const auto duration = double(uv_hrtime() - start) / 1e9;
+            EXPECT_GT(0.2, duration) << "Initial error request took too long";
+            ASSERT_NE(nullptr, res.error);
+            EXPECT_EQ(Response::Error::Reason::Server, res.error->reason);
+            EXPECT_EQ("HTTP status code 500", res.error->message);
+            EXPECT_EQ(false, res.stale);
+            ASSERT_TRUE(res.data.get());
+            EXPECT_EQ("", *res.data);
+            EXPECT_EQ(0, res.expires);
+            EXPECT_EQ(0, res.modified);
+            EXPECT_EQ("", res.etag);
+        } break;
+        case 1: {
+            fs.cancel(req1);
+            const auto duration = double(uv_hrtime() - start) / 1e9;
+            EXPECT_LT(0.99, duration) << "Backoff timer didn't wait 1 second";
+            EXPECT_GT(1.2, duration) << "Backoff timer fired too late";
+            EXPECT_EQ(nullptr, res.error);
+            EXPECT_EQ(false, res.stale);
+            ASSERT_TRUE(res.data.get());
+            EXPECT_EQ("Hello World!", *res.data);
+            EXPECT_EQ(0, res.expires);
+            EXPECT_EQ(0, res.modified);
+            EXPECT_EQ("", res.etag);
+            HTTPTemporaryError.finish();
+        } break;
+        }
     });
 
     Request* req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3001/" }, uv_default_loop(),
                [&](const Response &res) {
-        fs.cancel(req2);
+        static int counter = 0;
+        static int wait = 0;
         const auto duration = double(uv_hrtime() - start) / 1e9;
-        // 1.5 seconds == 4 retries, with a 500ms timeout (see above).
-        EXPECT_LT(1.4, duration) << "Resource wasn't retried the correct number of times";
-        EXPECT_GT(1.7, duration) << "Resource wasn't retried the correct number of times";
-        EXPECT_EQ(Response::Error, res.status);
-        EXPECT_EQ(false, res.stale);
+        EXPECT_LT(wait - 0.01, duration) << "Backoff timer didn't wait 1 second";
+        EXPECT_GT(wait + 0.2, duration) << "Backoff timer fired too late";
+        ASSERT_NE(nullptr, res.error);
+        EXPECT_EQ(Response::Error::Reason::Connection, res.error->reason);
 #ifdef MBGL_HTTP_NSURL
-        EXPECT_TRUE(res.message ==
-                        "The operation couldn’t be completed. (NSURLErrorDomain error -1004.)" ||
-                    res.message == "Could not connect to the server.")
-            << "Full message is: \"" << res.message << "\"";
+        EXPECT_TRUE(res.error->message ==
+                     "The operation couldn’t be completed. (NSURLErrorDomain error -1004.)" ||
+                 res.error->message == "Could not connect to the server.")
+         << "Full message is: \"" << res.error->message << "\"";
 #elif MBGL_HTTP_CURL
         const std::string prefix { "Couldn't connect to server: " };
-        EXPECT_STREQ(prefix.c_str(), res.message.substr(0, prefix.size()).c_str()) << "Full message is: \"" << res.message << "\"";
+        EXPECT_STREQ(prefix.c_str(), res.error->message.substr(0, prefix.size()).c_str()) << "Full message is: \"" << res.error->message << "\"";
 #else
         FAIL();
 #endif
+        EXPECT_EQ(false, res.stale);
         ASSERT_FALSE(res.data.get());
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        HTTPConnectionError.finish();
+
+        if (counter == 2) {
+            fs.cancel(req2);
+            HTTPConnectionError.finish();
+        }
+        wait += (1 << counter);
+        counter++;
     });
 
     uv_run(uv_default_loop(), UV_RUN_DEFAULT);
 
-    uv_timer_stop(&statusChange);
-    uv_close(reinterpret_cast<uv_handle_t *>(&statusChange), nullptr);
-
     // Run again so that the timer handle can be properly closed.
     uv_run(uv_default_loop(), UV_RUN_DEFAULT);
 }
diff --git a/test/storage/http_header_parsing.cpp b/test/storage/http_header_parsing.cpp
index 17c3ce16cf..aab8711ea0 100644
--- a/test/storage/http_header_parsing.cpp
+++ b/test/storage/http_header_parsing.cpp
@@ -19,14 +19,13 @@ TEST_F(Storage, HTTPHeaderParsing) {
                  "http://127.0.0.1:3000/test?modified=1420794326&expires=1420797926&etag=foo" },
                uv_default_loop(), [&](const Response &res) {
         fs.cancel(req1);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(1420797926, res.expires);
         EXPECT_EQ(1420794326, res.modified);
         EXPECT_EQ("foo", res.etag);
-        EXPECT_EQ("", res.message);
         HTTPExpiresTest.finish();
     });
 
@@ -36,14 +35,13 @@ TEST_F(Storage, HTTPHeaderParsing) {
     Request* req2 = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test?cachecontrol=max-age=120" },
                uv_default_loop(), [&](const Response &res) {
         fs.cancel(req2);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_GT(2, std::abs(res.expires - now - 120)) << "Expiration date isn't about 120 seconds in the future";
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
         HTTPCacheControlTest.finish();
     });
 
diff --git a/test/storage/http_issue_1369.cpp b/test/storage/http_issue_1369.cpp
index c5135b3ab9..c6f0929feb 100644
--- a/test/storage/http_issue_1369.cpp
+++ b/test/storage/http_issue_1369.cpp
@@ -32,14 +32,13 @@ TEST_F(Storage, HTTPIssue1369) {
     fs.cancel(req);
     req = fs.request(resource, uv_default_loop(), [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
         HTTPIssue1369.finish();
     });
 
diff --git a/test/storage/http_load.cpp b/test/storage/http_load.cpp
index 987e463507..ece859c6d3 100644
--- a/test/storage/http_load.cpp
+++ b/test/storage/http_load.cpp
@@ -24,14 +24,13 @@ TEST_F(Storage, HTTPLoad) {
                    uv_default_loop(), [&, i, current](const Response &res) {
             fs.cancel(reqs[i]);
             reqs[i] = nullptr;
-            EXPECT_EQ(Response::Successful, res.status);
+            EXPECT_EQ(nullptr, res.error);
             EXPECT_EQ(false, res.stale);
             ASSERT_TRUE(res.data.get());
             EXPECT_EQ(std::string("Request ") +  std::to_string(current), *res.data);
             EXPECT_EQ(0, res.expires);
             EXPECT_EQ(0, res.modified);
             EXPECT_EQ("", res.etag);
-            EXPECT_EQ("", res.message);
 
             if (number <= max) {
                 req(i);
diff --git a/test/storage/http_other_loop.cpp b/test/storage/http_other_loop.cpp
index f6e805285f..b00d54eb7b 100644
--- a/test/storage/http_other_loop.cpp
+++ b/test/storage/http_other_loop.cpp
@@ -15,14 +15,13 @@ TEST_F(Storage, HTTPOtherLoop) {
     Request* req = fs.request({ Resource::Unknown, "http://127.0.0.1:3000/test" }, uv_default_loop(),
                [&](const Response &res) {
         fs.cancel(req);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
         HTTPOtherLoop.finish();
     });
 
diff --git a/test/storage/http_reading.cpp b/test/storage/http_reading.cpp
index 468ba33248..1c0df9df73 100644
--- a/test/storage/http_reading.cpp
+++ b/test/storage/http_reading.cpp
@@ -22,14 +22,13 @@ TEST_F(Storage, HTTPReading) {
                [&](const Response &res) {
         fs.cancel(req1);
         EXPECT_EQ(uv_thread_self(), mainThread);
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
         HTTPTest.finish();
     });
 
@@ -37,11 +36,12 @@ TEST_F(Storage, HTTPReading) {
                [&](const Response &res) {
         fs.cancel(req2);
         EXPECT_EQ(uv_thread_self(), mainThread);
-        EXPECT_EQ(Response::NotFound, res.status);
+        ASSERT_NE(nullptr, res.error);
+        EXPECT_EQ(Response::Error::Reason::NotFound, res.error->reason);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Cannot GET /doesnotexist\n", *res.data);
-        EXPECT_EQ("", res.message);
+        EXPECT_EQ("HTTP status code 404", res.error->message);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
@@ -52,11 +52,12 @@ TEST_F(Storage, HTTPReading) {
                [&](const Response &res) {
         fs.cancel(req3);
         EXPECT_EQ(uv_thread_self(), mainThread);
-        EXPECT_EQ(Response::Error, res.status);
+        ASSERT_NE(nullptr, res.error);
+        EXPECT_EQ(Response::Error::Reason::Server, res.error->reason);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Server Error!", *res.data);
-        EXPECT_EQ("HTTP status code 500", res.message);
+        EXPECT_EQ("HTTP status code 500", res.error->message);
         EXPECT_EQ(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
diff --git a/test/storage/http_retry_network_status.cpp b/test/storage/http_retry_network_status.cpp
index 14cdae02c7..d0209e0bf6 100644
--- a/test/storage/http_retry_network_status.cpp
+++ b/test/storage/http_retry_network_status.cpp
@@ -24,14 +24,13 @@ TEST_F(Storage, HTTPNetworkStatusChange) {
     // This request takes 200 milliseconds to answer.
     Request* req = fs.request(resource, uv_default_loop(), [&](const Response& res) {
          fs.cancel(req);
-         EXPECT_EQ(Response::Successful, res.status);
+         EXPECT_EQ(nullptr, res.error);
          EXPECT_EQ(false, res.stale);
          ASSERT_TRUE(res.data.get());
          EXPECT_EQ("Response", *res.data);
          EXPECT_EQ(0, res.expires);
          EXPECT_EQ(0, res.modified);
          EXPECT_EQ("", res.etag);
-         EXPECT_EQ("", res.message);
          HTTPNetworkStatusChange.finish();
     });
 
diff --git a/test/storage/http_timeout.cpp b/test/storage/http_timeout.cpp
index b5cd877e76..92a6671d7e 100644
--- a/test/storage/http_timeout.cpp
+++ b/test/storage/http_timeout.cpp
@@ -18,14 +18,13 @@ TEST_F(Storage, HTTPTimeout) {
     const Resource resource { Resource::Unknown, "http://127.0.0.1:3000/test?cachecontrol=max-age=1" };
     Request* req = fs.request(resource, uv_default_loop(), [&](const Response &res) {
         counter++;
-        EXPECT_EQ(Response::Successful, res.status);
+        EXPECT_EQ(nullptr, res.error);
         EXPECT_EQ(false, res.stale);
         ASSERT_TRUE(res.data.get());
         EXPECT_EQ("Hello World!", *res.data);
         EXPECT_LT(0, res.expires);
         EXPECT_EQ(0, res.modified);
         EXPECT_EQ("", res.etag);
-        EXPECT_EQ("", res.message);
         if (counter == 4) {
             fs.cancel(req);
             HTTPTimeout.finish();
diff --git a/test/storage/server.js b/test/storage/server.js
index 249c6a124b..cd8c5e3958 100755
--- a/test/storage/server.js
+++ b/test/storage/server.js
@@ -9,6 +9,19 @@ var app = express();
 // We're manually setting Etag headers.
 app.disable('etag');
 
+// Terminate after a certain time of inactivity.
+function terminate() {
+    console.warn('Server terminated due to inactivity');
+    process.exit(0);
+};
+var inactivity = 5000; // milliseconds
+var timeout = setTimeout(terminate, inactivity);
+app.use(function(req, res, next) {
+    clearTimeout(timeout);
+    timeout = setTimeout(terminate, inactivity);
+    next();
+});
+
 app.get('/test', function (req, res) {
     if (req.query.modified) {
         res.setHeader('Last-Modified', (new Date(req.query.modified * 1000)).toUTCString());
diff --git a/test/storage/storage.hpp b/test/storage/storage.hpp
index d2402166a0..4c14746c6a 100644
--- a/test/storage/storage.hpp
+++ b/test/storage/storage.hpp
@@ -2,7 +2,9 @@
 #define MBGL_TEST_STORAGE_STORAGE
 
 #include "../fixtures/util.hpp"
+#include <mbgl/storage/response.hpp>
 #include <uv.h>
+#include <iostream>
 
 class Storage : public testing::Test {
 public:
@@ -13,4 +15,21 @@ protected:
     static pid_t pid;
 };
 
+namespace mbgl {
+
+inline std::ostream& operator<<(std::ostream& os, Response::Error::Reason r) {
+    // Special case
+    if (uint8_t(r) == 1) return os << "Response::Error::Reason::Success";
+    switch (r) {
+        case Response::Error::Reason::NotFound: return os << "Response::Error::Reason::NotFound";
+        case Response::Error::Reason::Server: return os << "Response::Error::Reason::Server";
+        case Response::Error::Reason::Connection: return os << "Response::Error::Reason::Connection";
+        case Response::Error::Reason::Canceled: return os << "Response::Error::Reason::Canceled";
+        case Response::Error::Reason::Other: return os << "Response::Error::Reason::Other";
+        default: return os << "<Unknown>";
+    }
+}
+
+} // namespace mbgl
+
 #endif