Pass HashFunction to BazelApi

1 files changed, 115 insertions, 21 deletions

diff --git a/test/buildtool/execution_api/bazel/bazel_api.test.cpp b/test/buildtool/execution_api/bazel/bazel_api.test.cpp
index c774f034..42d4880e 100644
--- a/test/buildtool/execution_api/bazel/bazel_api.test.cpp
+++ b/test/buildtool/execution_api/bazel/bazel_api.test.cpp
@@ -17,6 +17,8 @@
 
 #include "catch2/catch_test_macros.hpp"
 #include "src/buildtool/common/remote/retry_config.hpp"
+#include "src/buildtool/compatibility/compatibility.hpp"
+#include "src/buildtool/crypto/hash_function.hpp"
 #include "src/buildtool/execution_api/remote/bazel/bazel_api.hpp"
 #include "src/buildtool/execution_api/remote/config.hpp"
 #include "test/buildtool/execution_api/common/api_test.hpp"
@@ -25,19 +27,31 @@
 
 namespace {
 
-auto const kApiFactory = []() {
-    auto remote_config = TestRemoteConfig::ReadFromEnvironment();
-    REQUIRE(remote_config);
-    REQUIRE(remote_config->remote_address);
-    auto auth_config = TestAuthConfig::ReadFromEnvironment();
-    REQUIRE(auth_config);
-    static RetryConfig retry_config{};  // default retry config
-    return IExecutionApi::Ptr{new BazelApi{"remote-execution",
-                                           remote_config->remote_address->host,
-                                           remote_config->remote_address->port,
-                                           &*auth_config,
-                                           &retry_config,
-                                           {}}};
+class FactoryApi final {
+  public:
+    explicit FactoryApi(
+        gsl::not_null<ServerAddress const*> const& server_address,
+        gsl::not_null<Auth const*> const& auth,
+        HashFunction hash_function) noexcept
+        : address_{*server_address},
+          auth_{*auth},
+          hash_function_{hash_function} {}
+
+    [[nodiscard]] auto operator()() const -> IExecutionApi::Ptr {
+        static RetryConfig retry_config{};  // default retry config
+        return IExecutionApi::Ptr{new BazelApi{"remote-execution",
+                                               address_.host,
+                                               address_.port,
+                                               &auth_,
+                                               &retry_config,
+                                               {},
+                                               hash_function_}};
+    }
+
+  private:
+    ServerAddress const& address_;
+    Auth const& auth_;
+    HashFunction const hash_function_;
 };
 
 }  // namespace
@@ -45,53 +59,133 @@ auto const kApiFactory = []() {
 TEST_CASE("BazelAPI: No input, no output", "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
-    TestNoInputNoOutput(kApiFactory, remote_config->platform_properties);
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
+    TestNoInputNoOutput(api_factory, remote_config->platform_properties);
 }
 
 TEST_CASE("BazelAPI: No input, create output", "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
-    TestNoInputCreateOutput(kApiFactory, remote_config->platform_properties);
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
+    TestNoInputCreateOutput(api_factory, remote_config->platform_properties);
 }
 
 TEST_CASE("BazelAPI: One input copied to output", "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
-    TestOneInputCopiedToOutput(kApiFactory, remote_config->platform_properties);
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
+    TestOneInputCopiedToOutput(api_factory, remote_config->platform_properties);
 }
 
 TEST_CASE("BazelAPI: Non-zero exit code, create output", "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
-    TestNonZeroExitCodeCreateOutput(kApiFactory,
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
+    TestNonZeroExitCodeCreateOutput(api_factory,
                                     remote_config->platform_properties);
 }
 
 TEST_CASE("BazelAPI: Retrieve two identical trees to path", "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
     TestRetrieveTwoIdenticalTreesToPath(
-        kApiFactory, remote_config->platform_properties, "two_trees");
+        api_factory, remote_config->platform_properties, "two_trees");
 }
 
 TEST_CASE("BazelAPI: Retrieve file and symlink with same content to path",
           "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
     TestRetrieveFileAndSymlinkWithSameContentToPath(
-        kApiFactory, remote_config->platform_properties, "file_and_symlink");
+        api_factory, remote_config->platform_properties, "file_and_symlink");
 }
 
 TEST_CASE("BazelAPI: Retrieve mixed blobs and trees", "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
     TestRetrieveMixedBlobsAndTrees(
-        kApiFactory, remote_config->platform_properties, "blobs_and_trees");
+        api_factory, remote_config->platform_properties, "blobs_and_trees");
 }
 
 TEST_CASE("BazelAPI: Create directory prior to execution", "[execution_api]") {
     auto remote_config = TestRemoteConfig::ReadFromEnvironment();
     REQUIRE(remote_config);
-    TestCreateDirPriorToExecution(kApiFactory,
+    REQUIRE(remote_config->remote_address);
+    auto auth = TestAuthConfig::ReadFromEnvironment();
+    REQUIRE(auth);
+
+    HashFunction const hash_function{Compatibility::IsCompatible()
+                                         ? HashFunction::JustHash::Compatible
+                                         : HashFunction::JustHash::Native};
+
+    FactoryApi api_factory{
+        &*remote_config->remote_address, &*auth, hash_function};
+    TestCreateDirPriorToExecution(api_factory,
                                   remote_config->platform_properties);
 }