Delegate isAllowed to the ApiClient

- Add allowed/denied unit tests at the Authorizer
- Ensure that the authorizer can have an injected ApiClient
- Ensure that ApiClient::isAllowed is virtual to enable mocking
- Add ApiClient mock class and mock isAllowed method
- Replace literal implementation of Authorizer::isAllowed with
  delegation to the injected ApiClient
- Prepare Authorizer somewhat for injection/mocking with virtual
  declarations and adding destructor

apache/client/include/lauth/api_client.hpp

@@ -6,7 +6,8 @@
 namespace mlibrary::lauth {
   class ApiClient {
     public:
-      bool isAllowed(Request req);
+      virtual bool isAllowed(Request req);
+      virtual ~ApiClient() = default;
   };
 }
 

apache/client/include/lauth/authorizer.hpp

@@ -13,10 +13,13 @@ namespace mlibrary::lauth {
       Authorizer() : client(std::make_unique<ApiClient>()) {};
       Authorizer(std::unique_ptr<ApiClient>&& client) : client(std::move(client)) {};
       Authorizer(const Authorizer&) = delete;
+      Authorizer& operator=(const Authorizer&) = delete;
       Authorizer(Authorizer&&) = delete;
+      Authorizer& operator=(const Authorizer&&) = delete;
+      virtual ~Authorizer() = default;
 
       bool isPasswordOnly(std::string url);
-      bool isAllowed(Request req);
+      virtual bool isAllowed(Request req);
 
     protected:
       std::unique_ptr<ApiClient> client;

apache/client/src/lauth/authorizer.cpp

@@ -8,7 +8,6 @@ namespace mlibrary::lauth {
   }
 
   bool Authorizer::isAllowed(Request req) {
-    // return (req.user == "lauth-allowed");
     return client->isAllowed(req);
   }
 }

apache/client/test/lauth/authorizer_test.cpp

@@ -1,14 +1,48 @@
-#include <memory>
 #include "lauth/authorizer.hpp"
+
+#include <memory>
+
 #include "lauth/request.hpp"
 #include "lauth/api_client.hpp"
 
 #include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "mocks.hpp"
+
+using ::testing::Return;
+using ::testing::_;
 
 using mlibrary::lauth::ApiClient;
 using mlibrary::lauth::Authorizer;
 
-TEST(Authorizer, inject_api_client) {
+TEST(AuthorizerTest, inject_api_client) {
   auto client = std::make_unique<ApiClient>();
   Authorizer authorizer(std::move(client));
 }
+
+TEST(AuthorizerTest, AllowsAccessWhenApiSaysAuthorized) {
+  auto client = std::make_unique<MockApiClient>();
+  EXPECT_CALL(*client, isAllowed(_)).WillOnce(Return(true));
+  Authorizer authorizer(std::move(client));
+
+  Request req {
+    .user = "lauth-allowed"
+  };
+  auto allowed = authorizer.isAllowed(req);
+
+  EXPECT_THAT(allowed, true);
+}
+
+TEST(AuthorizerTest, DeniesAccessWhenApiSaysUnauthorized) {
+  auto client = std::make_unique<MockApiClient>();
+  EXPECT_CALL(*client, isAllowed(_)).WillOnce(Return(false));
+  Authorizer authorizer(std::move(client));
+
+  Request req {
+    .user = "lauth-denied"
+  };
+  auto allowed = authorizer.isAllowed(req);
+
+  EXPECT_THAT(allowed, false);
+}

apache/client/test/lauth/mocks.hpp

@@ -0,0 +1,13 @@
+#ifndef _LAUTH_TEST_MOCKS_HPP_
+#define _LAUTH_TEST_MOCKS_HPP_
+
+#include <lauth/api_client.hpp>
+
+using namespace mlibrary::lauth;
+
+class MockApiClient : public ApiClient {
+    public:
+    MOCK_METHOD(bool, isAllowed, (Request), (override));
+};
+
+#endif