[tests] Refactor and make MockFileSource more general

Now it works more like StubStyleObserver: you can assign std::functions to specific slots based on resource type.

Rewrite resource loading tests in that style, making them less like integration tests of Style and more like unit tests of Source, GlyphStore, and SpriteStore.

1 files changed, 98 insertions, 36 deletions

diff --git a/test/sprite/sprite_store.cpp b/test/sprite/sprite_store.cpp
index ca5f0ed9e4..08977eac4f 100644
--- a/test/sprite/sprite_store.cpp
+++ b/test/sprite/sprite_store.cpp
@@ -1,10 +1,12 @@
 #include "../fixtures/util.hpp"
 #include "../fixtures/fixture_log_observer.hpp"
-#include "../fixtures/mock_file_source.hpp"
+#include "../fixtures/stub_file_source.hpp"
 #include "../fixtures/stub_style_observer.hpp"
 
 #include <mbgl/sprite/sprite_store.hpp>
 #include <mbgl/util/run_loop.hpp>
+#include <mbgl/util/string.hpp>
+#include <mbgl/util/io.hpp>
 
 #include <utility>
 
@@ -151,17 +153,16 @@ TEST(SpriteStore, ReplaceWithDifferentDimensions) {
 
 class SpriteStoreTest {
 public:
-    SpriteStoreTest(MockFileSource::Type type, const std::string& resource)
-        : fileSource(type, resource),
-          spriteStore(1.0) {}
+    SpriteStoreTest()
+        : spriteStore(1.0) {}
 
     util::ThreadContext context { "Map", util::ThreadType::Map, util::ThreadPriority::Regular };
     util::RunLoop loop;
-    MockFileSource fileSource;
+    StubFileSource fileSource;
     StubStyleObserver observer;
     SpriteStore spriteStore;
 
-    void run(const std::string& url) {
+    void run() {
         // Squelch logging.
         Log::setObserver(std::make_unique<Log::NullObserver>());
 
@@ -169,7 +170,7 @@ public:
         util::ThreadContext::setFileSource(&fileSource);
 
         spriteStore.setObserver(&observer);
-        spriteStore.setURL(url);
+        spriteStore.setURL("test/fixtures/resources/sprite");
 
         loop.run();
     }
@@ -179,70 +180,131 @@ public:
     }
 };
 
+Response successfulSpriteImageResponse(const Resource& resource) {
+    EXPECT_EQ("test/fixtures/resources/sprite.png", resource.url);
+    Response response;
+    response.data = std::make_shared<std::string>(util::read_file(resource.url));
+    return response;
+};
+
+Response successfulSpriteJSONResponse(const Resource& resource) {
+    EXPECT_EQ("test/fixtures/resources/sprite.json", resource.url);
+    Response response;
+    response.data = std::make_shared<std::string>(util::read_file(resource.url));
+    return response;
+};
+
+Response failedSpriteResponse(const Resource&) {
+    Response response;
+    response.error = std::make_unique<Response::Error>(
+        Response::Error::Reason::Other,
+        "Failed by the test case");
+    return response;
+};
+
+Response corruptSpriteResponse(const Resource&) {
+    Response response;
+    response.data = std::make_shared<std::string>("CORRUPT");
+    return response;
+};
+
 TEST(SpriteStore, LoadingSuccess) {
-    SpriteStoreTest test(MockFileSource::Success, "");
+    SpriteStoreTest test;
 
-    test.observer.spriteError = [&] (std::exception_ptr) {
-        FAIL();
+    test.fileSource.spriteImageResponse = successfulSpriteImageResponse;
+    test.fileSource.spriteJSONResponse = successfulSpriteJSONResponse;
+
+    test.observer.spriteError = [&] (std::exception_ptr error) {
+        FAIL() << util::toString(error);
         test.end();
     };
 
     test.observer.spriteLoaded = [&] () {
-        ASSERT_TRUE(!test.spriteStore.getDirty().empty());
-        ASSERT_EQ(test.spriteStore.pixelRatio, 1.0);
-        ASSERT_TRUE(test.spriteStore.isLoaded());
+        EXPECT_TRUE(!test.spriteStore.getDirty().empty());
+        EXPECT_EQ(1.0, test.spriteStore.pixelRatio);
+        EXPECT_TRUE(test.spriteStore.isLoaded());
         test.end();
     };
 
-    test.run("test/fixtures/resources/sprite");
+    test.run();
 }
 
-TEST(SpriteStore, LoadingFail) {
-    SpriteStoreTest test(MockFileSource::RequestFail, "sprite.json");
+TEST(SpriteStore, JSONLoadingFail) {
+    SpriteStoreTest test;
+
+    test.fileSource.spriteImageResponse = successfulSpriteImageResponse;
+    test.fileSource.spriteJSONResponse = failedSpriteResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
-        ASSERT_TRUE(error != nullptr);
-        ASSERT_FALSE(test.spriteStore.isLoaded());
+        EXPECT_TRUE(error != nullptr);
+        EXPECT_EQ("Failed by the test case", util::toString(error));
+        EXPECT_FALSE(test.spriteStore.isLoaded());
         test.end();
     };
 
-    test.run("test/fixtures/resources/sprite");
+    test.run();
 }
 
-TEST(SpriteStore, LoadingCorrupted) {
-    SpriteStoreTest test(MockFileSource::RequestWithCorruptedData, "sprite.json");
+TEST(SpriteStore, ImageLoadingFail) {
+    SpriteStoreTest test;
+
+    test.fileSource.spriteImageResponse = failedSpriteResponse;
+    test.fileSource.spriteJSONResponse = successfulSpriteJSONResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
-        ASSERT_TRUE(error != nullptr);
-        ASSERT_FALSE(test.spriteStore.isLoaded());
+        EXPECT_TRUE(error != nullptr);
+        EXPECT_EQ("Failed by the test case", util::toString(error));
+        EXPECT_FALSE(test.spriteStore.isLoaded());
         test.end();
     };
 
-    test.run("test/fixtures/resources/sprite");
+    test.run();
 }
 
-TEST(SpriteStore, LoadingCancel) {
-    SpriteStoreTest test(MockFileSource::Success, "sprite.json");
+TEST(SpriteStore, JSONLoadingCorrupted) {
+    SpriteStoreTest test;
 
-    test.observer.spriteLoaded = [&] () {
-        FAIL() << "Should never be called";
-    };
+    test.fileSource.spriteImageResponse = successfulSpriteImageResponse;
+    test.fileSource.spriteJSONResponse = corruptSpriteResponse;
 
-    test.fileSource.requestEnqueuedCallback = [&]{
+    test.observer.spriteError = [&] (std::exception_ptr error) {
+        EXPECT_TRUE(error != nullptr);
+        EXPECT_EQ("Failed to parse JSON: Invalid value. at offset 0", util::toString(error));
+        EXPECT_FALSE(test.spriteStore.isLoaded());
         test.end();
     };
 
-    test.run("test/fixtures/resources/sprite");
+    test.run();
 }
 
-TEST(SpriteStore, InvalidURL) {
-    SpriteStoreTest test(MockFileSource::Success, "");
+TEST(SpriteStore, ImageLoadingCorrupted) {
+    SpriteStoreTest test;
+
+    test.fileSource.spriteImageResponse = corruptSpriteResponse;
+    test.fileSource.spriteJSONResponse = successfulSpriteJSONResponse;
 
     test.observer.spriteError = [&] (std::exception_ptr error) {
-        ASSERT_TRUE(error != nullptr);
-        ASSERT_EQ(test.spriteStore.isLoaded(), false);
+        EXPECT_TRUE(error != nullptr);
+        // Not asserting on platform-specific error text.
+        EXPECT_FALSE(test.spriteStore.isLoaded());
+        test.end();
+    };
+
+    test.run();
+}
+
+TEST(SpriteStore, LoadingCancel) {
+    SpriteStoreTest test;
+
+    test.fileSource.spriteImageResponse =
+    test.fileSource.spriteJSONResponse = [&] (const Resource&) {
         test.end();
+        return Response();
+    };
+
+    test.observer.spriteLoaded = [&] () {
+        FAIL() << "Should never be called";
     };
 
-    test.run("foo bar");
+    test.run();
 }