[Unit Test] Complete WinFSP unit tests #21

initial support for winfsp to linux remote testing
initial support for linx to winfsp remote testing

CHANGELOG.md

@@ -1,7 +1,22 @@
 # Changelog
 
+## v2.0.6-release
+
+### Issues
+
+* ~~\#12 [Unit Test] Complete all providers unit tests~~
+* ~~\#21 [Unit Test] Complete WinFSP unit tests~~
+* ~~\#22 [Unit Test] Complete FUSE unit tests~~
+* ~~\#33 Complete initial v2.0 documentation~~
+* \#42 [bug] Remote mount directory listing on Windows connected to Linux is failing
+
+### Changes from v2.0.5-rc
+
+* Drive letters in UI should always be lowercase
+
 ## v2.0.5-rc
 
+<!-- markdownlint-disable-next-line -->
 ### Issues
 
 * \#39 Create management portal in Flutter

config.sh

@@ -10,7 +10,7 @@ PROJECT_DESC="Mount utility for Sia and S3"
 
 PROJECT_MAJOR_VERSION=2
 PROJECT_MINOR_VERSION=0
-PROJECT_REVISION_VERSION=5
+PROJECT_REVISION_VERSION=6
 PROJECT_RELEASE_NUM=0
 PROJECT_RELEASE_ITER=rc
 

repertory/librepertory/include/drives/fuse/remotefuse/remote_server.hpp

@@ -59,7 +59,8 @@ private:
 
   static void populate_stat(const struct stat64 &unix_st, remote::stat &r_stat);
 
-  [[nodiscard]] auto update_to_windows_format(json &item) -> json &;
+  [[nodiscard]] auto update_to_windows_format(const std::string &root_api_path,
+                                              json &item) -> json &;
 
 public:
   // FUSE Layer

repertory/librepertory/src/drives/fuse/fuse_base.cpp

@@ -374,13 +374,13 @@ auto fuse_base::init_impl(struct fuse_conn_info *conn) -> void * {
   if (not utils::file::change_to_process_directory()) {
     utils::error::raise_error(function_name,
                               "failed to change to process directory");
-    event_system::instance().raise<unmount_requested>();
+    event_system::instance().raise<unmount_requested>(function_name);
     return this;
   }
 
   if (not console_enabled_ && not repertory::project_initialize()) {
     utils::error::raise_error(function_name, "failed to initialize repertory");
-    event_system::instance().raise<unmount_requested>();
+    event_system::instance().raise<unmount_requested>(function_name);
   }
 
   return this;

repertory/librepertory/src/drives/fuse/remotefuse/remote_fuse_drive.cpp

@@ -259,7 +259,7 @@ auto remote_fuse_drive::init_impl(struct fuse_conn_info *conn) -> void * {
   if (remote_instance_->fuse_init() != 0) {
     utils::error::raise_error(function_name,
                               "failed to connect to remote server");
-    event_system::instance().raise<unmount_requested>();
+    event_system::instance().raise<unmount_requested>(function_name);
   } else {
     server_ = std::make_shared<server>(config_);
     server_->start();

repertory/librepertory/src/drives/fuse/remotefuse/remote_server.cpp

@@ -1390,11 +1390,11 @@ auto remote_server::winfsp_read_directory(PVOID file_desc, PWSTR /*pattern*/,
 
   item_list.clear();
 
-  const auto handle = reinterpret_cast<remote::file_handle>(file_desc);
+  auto handle = reinterpret_cast<remote::file_handle>(file_desc);
   auto ret = static_cast<packet::error_type>(
       has_open_info(static_cast<native_handle>(handle), STATUS_INVALID_HANDLE));
   if (ret == STATUS_SUCCESS) {
-    const auto api_path = construct_api_path(
+    auto api_path = construct_api_path(
         get_open_file_path(static_cast<native_handle>(handle)));
     directory_iterator iterator(drive_.get_directory_items(api_path));
     auto offset = marker == nullptr
@@ -1405,7 +1405,7 @@ auto remote_server::winfsp_read_directory(PVOID file_desc, PWSTR /*pattern*/,
     json item;
     while (iterator.get_json(offset++, item) == 0) {
       try {
-        item_list.emplace_back(update_to_windows_format(item));
+        item_list.emplace_back(update_to_windows_format(api_path, item));
       } catch (const std::exception &e) {
         utils::error::raise_error(function_name, e, "exception occurred");
       }
@@ -1679,30 +1679,53 @@ auto remote_server::json_release_directory_snapshot(
   return 0;
 }
 
-auto remote_server::update_to_windows_format(json &item) -> json & {
+auto remote_server::update_to_windows_format(const std::string &root_api_path,
-  const auto api_path = item["path"].get<std::string>();
+                                             json &item) -> json & {
-  item["meta"][META_ACCESSED] = std::to_string(
+  REPERTORY_USES_FUNCTION_NAME();
-      utils::string::to_uint64(empty_as_zero(item["meta"][META_ACCESSED])));
-  item["meta"][META_CREATION] = std::to_string(
-      utils::string::to_uint64(empty_as_zero(item["meta"][META_CREATION])));
-  item["meta"][META_MODIFIED] = std::to_string(
-      utils::string::to_uint64(empty_as_zero(item["meta"][META_MODIFIED])));
 
-  if (item["meta"][META_WRITTEN].empty() ||
+  auto api_path = item[JSON_API_PATH].get<std::string>();
-      (item["meta"][META_WRITTEN].get<std::string>() == "0") ||
+  if (api_path == "." || api_path == "..") {
-      (item["meta"][META_WRITTEN].get<std::string>() ==
+    auto orig_api_path{api_path};
-       std::to_string(utils::time::WIN32_TIME_CONVERSION))) {
+
-    drive_.set_item_meta(api_path, META_WRITTEN,
+    api_path = api_path == "."
-                         item["meta"][META_MODIFIED].get<std::string>());
+                   ? root_api_path
-    item["meta"][META_WRITTEN] = item["meta"][META_MODIFIED];
+                   : utils::path::get_parent_api_path(root_api_path);
+
+    api_meta_map meta;
+    auto res = drive_.get_item_meta(api_path, meta);
+    if (res != api_error::success) {
+      utils::error::raise_api_path_error(
+          function_name, api_path, res,
+          fmt::format("failed to get '{}' meta", orig_api_path));
+      return item;
+    }
+
+    item[JSON_META] = meta;
   }
 
-  if (item["meta"][META_ATTRIBUTES].empty()) {
+  item[JSON_META][META_ACCESSED] = std::to_string(
-    item["meta"][META_ATTRIBUTES] =
+      utils::string::to_uint64(empty_as_zero(item[JSON_META][META_ACCESSED])));
-        item["directory"].get<bool>() ? std::to_string(FILE_ATTRIBUTE_DIRECTORY)
+  item[JSON_META][META_CREATION] = std::to_string(
-                                      : std::to_string(FILE_ATTRIBUTE_ARCHIVE);
+      utils::string::to_uint64(empty_as_zero(item[JSON_META][META_CREATION])));
+  item[JSON_META][META_MODIFIED] = std::to_string(
+      utils::string::to_uint64(empty_as_zero(item[JSON_META][META_MODIFIED])));
+
+  if (item[JSON_META][META_WRITTEN].empty() ||
+      (item[JSON_META][META_WRITTEN].get<std::string>() == "0") ||
+      (item[JSON_META][META_WRITTEN].get<std::string>() ==
+       std::to_string(utils::time::WIN32_TIME_CONVERSION))) {
+    drive_.set_item_meta(api_path, META_WRITTEN,
+                         item[JSON_META][META_MODIFIED].get<std::string>());
+    item[JSON_META][META_WRITTEN] = item[JSON_META][META_MODIFIED];
+  }
+
+  if (item[JSON_META][META_ATTRIBUTES].empty()) {
+    item[JSON_META][META_ATTRIBUTES] =
+        item[JSON_DIRECTORY].get<bool>()
+            ? std::to_string(FILE_ATTRIBUTE_DIRECTORY)
+            : std::to_string(FILE_ATTRIBUTE_ARCHIVE);
     drive_.set_item_meta(api_path, META_ATTRIBUTES,
-                         item["meta"][META_ATTRIBUTES].get<std::string>());
+                         item[JSON_META][META_ATTRIBUTES].get<std::string>());
   }
 
   return item;

repertory/librepertory/src/drives/winfsp/remotewinfsp/remote_winfsp_drive.cpp

@@ -361,11 +361,10 @@ auto remote_winfsp_drive::ReadDirectory(PVOID /*file_node*/, PVOID file_desc,
               &ret)) {
         auto item_found = false;
         for (const auto &item : item_list) {
-          auto item_path = item["path"].get<std::string>();
+          auto item_path = item[JSON_API_PATH].get<std::string>();
           auto display_name = utils::string::from_utf8(
               utils::path::strip_to_file_name(item_path));
           if (not marker || (marker && item_found)) {
-            // if (not utils::path::is_ads_file_path(item_path)) {
             union {
               UINT8 B[FIELD_OFFSET(FSP_FSCTL_DIR_INFO, FileNameBuf) +
                       ((repertory::max_path_length + 1U) * sizeof(WCHAR))];
@@ -380,10 +379,8 @@ auto remote_winfsp_drive::ReadDirectory(PVOID /*file_node*/, PVOID file_desc,
                           display_name.size()) *
                  sizeof(WCHAR)));
 
-            if (not item["meta"].empty() ||
+            populate_file_info(item, directory_info->FileInfo);
-                ((item_path != ".") && (item_path != ".."))) {
+
-              populate_file_info(item, directory_info->FileInfo);
-            }
             if (ret == STATUS_SUCCESS) {
               ::wcscpy_s(&directory_info->FileNameBuf[0],
                          repertory::max_path_length, &display_name[0]);
@@ -394,7 +391,6 @@ auto remote_winfsp_drive::ReadDirectory(PVOID /*file_node*/, PVOID file_desc,
                 break;
               }
             }
-            // }
           } else {
             item_found = display_name == std::wstring(marker);
           }

repertory/librepertory/src/rpc/server/server.cpp

@@ -1,187 +1,189 @@
-/*
+/*
-  Copyright <2018-2025> <scott.e.graves@protonmail.com>
+  Copyright <2018-2025> <scott.e.graves@protonmail.com>
-
+
-  Permission is hereby granted, free of charge, to any person obtaining a copy
+  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
+  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
+  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
+  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
+  furnished to do so, subject to the following conditions:
-
+
-  The above copyright notice and this permission notice shall be included in all
+  The above copyright notice and this permission notice shall be included in all
-  copies or substantial portions of the Software.
+  copies or substantial portions of the Software.
-
+
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-  SOFTWARE.
+  SOFTWARE.
-*/
+*/
-#include "rpc/server/server.hpp"
+#include "rpc/server/server.hpp"
-
+
-#include "app_config.hpp"
+#include "app_config.hpp"
-#include "events/event_system.hpp"
+#include "events/event_system.hpp"
-#include "events/types/service_start_begin.hpp"
+#include "events/types/service_start_begin.hpp"
-#include "events/types/service_start_end.hpp"
+#include "events/types/service_start_end.hpp"
-#include "events/types/service_stop_begin.hpp"
+#include "events/types/service_stop_begin.hpp"
-#include "events/types/service_stop_end.hpp"
+#include "events/types/service_stop_end.hpp"
-#include "events/types/unmount_requested.hpp"
+#include "events/types/unmount_requested.hpp"
-#include "rpc/common.hpp"
+#include "rpc/common.hpp"
-#include "utils/error_utils.hpp"
+#include "utils/error_utils.hpp"
-
+
-namespace repertory {
+namespace repertory {
-server::server(app_config &config) : config_(config) {}
+server::server(app_config &config) : config_(config) {}
-
+
-void server::handle_get_config(const httplib::Request & /*req*/,
+void server::handle_get_config(const httplib::Request & /*req*/,
-                               httplib::Response &res) {
+                               httplib::Response &res) {
-  auto data = config_.get_json();
+  auto data = config_.get_json();
-  clean_json_config(config_.get_provider_type(), data);
+  clean_json_config(config_.get_provider_type(), data);
-  res.set_content(data.dump(), "application/json");
+  res.set_content(data.dump(), "application/json");
-  res.status = http_error_codes::ok;
+  res.status = http_error_codes::ok;
-}
+}
-
+
-void server::handle_get_config_value_by_name(const httplib::Request &req,
+void server::handle_get_config_value_by_name(const httplib::Request &req,
-                                             httplib::Response &res) {
+                                             httplib::Response &res) {
-  auto name = req.get_param_value("name");
+  auto name = req.get_param_value("name");
-  auto data = json({{
+  auto data = json({{
-      "value",
+      "value",
-      clean_json_value(name, config_.get_value_by_name(name)),
+      clean_json_value(name, config_.get_value_by_name(name)),
-  }});
+  }});
-  res.set_content(data.dump(), "application/json");
+  res.set_content(data.dump(), "application/json");
-  res.status = http_error_codes::ok;
+  res.status = http_error_codes::ok;
-}
+}
-
+
-void server::handle_set_config_value_by_name(const httplib::Request &req,
+void server::handle_set_config_value_by_name(const httplib::Request &req,
-                                             httplib::Response &res) {
+                                             httplib::Response &res) {
-  auto name = req.get_param_value("name");
+  auto name = req.get_param_value("name");
-  auto value = req.get_param_value("value");
+  auto value = req.get_param_value("value");
-
+
-  json data = {{
+  json data = {{
-      "value",
+      "value",
-      clean_json_value(name, config_.set_value_by_name(name, value)),
+      clean_json_value(name, config_.set_value_by_name(name, value)),
-  }};
+  }};
-  res.set_content(data.dump(), "application/json");
+  res.set_content(data.dump(), "application/json");
-  res.status = http_error_codes::ok;
+  res.status = http_error_codes::ok;
-}
+}
-
+
-void server::handle_unmount(const httplib::Request & /*req*/,
+void server::handle_unmount(const httplib::Request & /*req*/,
-                            httplib::Response &res) {
+                            httplib::Response &res) {
-  event_system::instance().raise<unmount_requested>();
+  REPERTORY_USES_FUNCTION_NAME();
-  res.status = http_error_codes::ok;
+
-}
+  event_system::instance().raise<unmount_requested>(function_name);
-
+  res.status = http_error_codes::ok;
-void server::initialize(httplib::Server &inst) {
+}
-  inst.Get("/api/v1/" + rpc_method::get_config, [this](auto &&req, auto &&res) {
+
-    handle_get_config(std::forward<decltype(req)>(req),
+void server::initialize(httplib::Server &inst) {
-                      std::forward<decltype(res)>(res));
+  inst.Get("/api/v1/" + rpc_method::get_config, [this](auto &&req, auto &&res) {
-  });
+    handle_get_config(std::forward<decltype(req)>(req),
-
+                      std::forward<decltype(res)>(res));
-  inst.Get("/api/v1/" + rpc_method::get_config_value_by_name,
+  });
-           [this](auto &&req, auto &&res) {
+
-             handle_get_config_value_by_name(std::forward<decltype(req)>(req),
+  inst.Get("/api/v1/" + rpc_method::get_config_value_by_name,
-                                             std::forward<decltype(res)>(res));
+           [this](auto &&req, auto &&res) {
-           });
+             handle_get_config_value_by_name(std::forward<decltype(req)>(req),
-
+                                             std::forward<decltype(res)>(res));
-  inst.Post("/api/v1/" + rpc_method::set_config_value_by_name,
+           });
-            [this](auto &&req, auto &&res) {
+
-              handle_set_config_value_by_name(std::forward<decltype(req)>(req),
+  inst.Post("/api/v1/" + rpc_method::set_config_value_by_name,
-                                              std::forward<decltype(res)>(res));
+            [this](auto &&req, auto &&res) {
-            });
+              handle_set_config_value_by_name(std::forward<decltype(req)>(req),
-
+                                              std::forward<decltype(res)>(res));
-  inst.Post("/api/v1/" + rpc_method::unmount, [this](auto &&req, auto &&res) {
+            });
-    handle_unmount(std::forward<decltype(req)>(req),
+
-                   std::forward<decltype(res)>(res));
+  inst.Post("/api/v1/" + rpc_method::unmount, [this](auto &&req, auto &&res) {
-  });
+    handle_unmount(std::forward<decltype(req)>(req),
-}
+                   std::forward<decltype(res)>(res));
-
+  });
-void server::start() {
+}
-  REPERTORY_USES_FUNCTION_NAME();
+
-
+void server::start() {
-  mutex_lock lock(start_stop_mutex_);
+  REPERTORY_USES_FUNCTION_NAME();
-  if (server_thread_) {
+
-    return;
+  mutex_lock lock(start_stop_mutex_);
-  }
+  if (server_thread_) {
-
+    return;
-  event_system::instance().raise<service_start_begin>(function_name, "server");
+  }
-
+
-  server_ = std::make_unique<httplib::Server>();
+  event_system::instance().raise<service_start_begin>(function_name, "server");
-
+
-  server_->set_exception_handler([](const httplib::Request &req,
+  server_ = std::make_unique<httplib::Server>();
-                                    httplib::Response &res,
+
-                                    std::exception_ptr ptr) {
+  server_->set_exception_handler([](const httplib::Request &req,
-    json data = {{"path", req.path}};
+                                    httplib::Response &res,
-
+                                    std::exception_ptr ptr) {
-    try {
+    json data = {{"path", req.path}};
-      std::rethrow_exception(ptr);
+
-    } catch (std::exception &e) {
+    try {
-      data["error"] = (e.what() == nullptr) ? "unknown error" : e.what();
+      std::rethrow_exception(ptr);
-      utils::error::raise_error(function_name, e,
+    } catch (std::exception &e) {
-                                "failed request: " + req.path);
+      data["error"] = (e.what() == nullptr) ? "unknown error" : e.what();
-    } catch (...) {
+      utils::error::raise_error(function_name, e,
-      data["error"] = "unknown error";
+                                "failed request: " + req.path);
-      utils::error::raise_error(function_name, "unknown error",
+    } catch (...) {
-                                "failed request: " + req.path);
+      data["error"] = "unknown error";
-    }
+      utils::error::raise_error(function_name, "unknown error",
-
+                                "failed request: " + req.path);
-    res.set_content(data.dump(), "application/json");
+    }
-    res.status = http_error_codes::internal_error;
+
-  });
+    res.set_content(data.dump(), "application/json");
-
+    res.status = http_error_codes::internal_error;
-  server_->set_pre_routing_handler(
+  });
-      [this](auto &&req, auto &&res) -> httplib::Server::HandlerResponse {
+
-        if (rpc::check_authorization(config_, req)) {
+  server_->set_pre_routing_handler(
-          return httplib::Server::HandlerResponse::Unhandled;
+      [this](auto &&req, auto &&res) -> httplib::Server::HandlerResponse {
-        }
+        if (rpc::check_authorization(config_, req)) {
-
+          return httplib::Server::HandlerResponse::Unhandled;
-        res.status = http_error_codes::unauthorized;
+        }
-        return httplib::Server::HandlerResponse::Handled;
+
-      });
+        res.status = http_error_codes::unauthorized;
-
+        return httplib::Server::HandlerResponse::Handled;
-  initialize(*server_);
+      });
-
+
-  server_thread_ = std::make_unique<std::thread>([this]() {
+  initialize(*server_);
-    server_->set_socket_options([](auto &&sock) {
+
-#if defined(_WIN32)
+  server_thread_ = std::make_unique<std::thread>([this]() {
-      int enable{1};
+    server_->set_socket_options([](auto &&sock) {
-      setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
+#if defined(_WIN32)
-                 reinterpret_cast<const char *>(&enable), sizeof(enable));
+      int enable{1};
-#else  //  !defined(_WIN32)
+      setsockopt(sock, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
-      linger opt{1, 0};
+                 reinterpret_cast<const char *>(&enable), sizeof(enable));
-      setsockopt(sock, SOL_SOCKET, SO_LINGER,
+#else  //  !defined(_WIN32)
-                 reinterpret_cast<const char *>(&opt), sizeof(opt));
+      linger opt{1, 0};
-#endif // defined(_WIN32)
+      setsockopt(sock, SOL_SOCKET, SO_LINGER,
-    });
+                 reinterpret_cast<const char *>(&opt), sizeof(opt));
-
+#endif // defined(_WIN32)
-    server_->listen("127.0.0.1", config_.get_api_port());
+    });
-  });
+
-  event_system::instance().raise<service_start_end>(function_name, "server");
+    server_->listen("127.0.0.1", config_.get_api_port());
-}
+  });
-
+  event_system::instance().raise<service_start_end>(function_name, "server");
-void server::stop() {
+}
-  REPERTORY_USES_FUNCTION_NAME();
+
-
+void server::stop() {
-  unique_mutex_lock lock(start_stop_mutex_);
+  REPERTORY_USES_FUNCTION_NAME();
-  if (not server_thread_) {
+
-    return;
+  unique_mutex_lock lock(start_stop_mutex_);
-  }
+  if (not server_thread_) {
-
+    return;
-  event_system::instance().raise<service_stop_begin>(function_name, "server");
+  }
-
+
-  server_->stop();
+  event_system::instance().raise<service_stop_begin>(function_name, "server");
-
+
-  std::unique_ptr<std::thread> thread{nullptr};
+  server_->stop();
-  std::swap(thread, server_thread_);
+
-  lock.unlock();
+  std::unique_ptr<std::thread> thread{nullptr};
-
+  std::swap(thread, server_thread_);
-  thread->join();
+  lock.unlock();
-  thread.reset();
+
-
+  thread->join();
-  lock.lock();
+  thread.reset();
-  server_.reset();
+
-  lock.unlock();
+  lock.lock();
-
+  server_.reset();
-  event_system::instance().raise<service_stop_end>(function_name, "server");
+  lock.unlock();
-}
+
-} // namespace repertory
+  event_system::instance().raise<service_stop_end>(function_name, "server");
+}
+} // namespace repertory

repertory/repertory/main.cpp

@@ -23,6 +23,8 @@
 #include "backward.hpp"
 #endif // defined(PROJECT_ENABLE_BACKWARD_CPP)
 
+#include <algorithm>
+
 #include "cli/actions.hpp"
 #include "initialize.hpp"
 #include "types/repertory.hpp"
@@ -44,7 +46,7 @@ auto main(int argc, char **argv) -> int {
   std::vector<const char *> args;
   {
     auto args_span = std::span(argv, static_cast<std::size_t>(argc));
-    std::copy(args_span.begin(), args_span.end(), std::back_inserter(args));
+    std::ranges::copy(args_span, std::back_inserter(args));
   }
 
   if (argc == 1) {

repertory/repertory/src/ui/handlers.cpp

@@ -326,9 +326,9 @@ void handlers::handle_put_mount_location(const httplib::Request &req,
 void handlers::handle_get_available_locations(httplib::Response &res) {
 #if defined(_WIN32)
   constexpr const std::array<std::string_view, 26U> letters{
-      "A:", "B:", "C:", "D:", "E:", "F:", "G:", "H:", "I:",
+      "a:", "b:", "c:", "d:", "e:", "f:", "g:", "h:", "i:",
-      "J:", "K:", "L:", "M:", "N:", "O:", "P:", "Q:", "R:",
+      "j:", "k:", "l:", "m:", "n:", "o:", "p:", "q:", "r:",
-      "S:", "T:", "U:", "V:", "W:", "X:", "Y:", "Z:",
+      "s:", "t:", "u:", "v:", "w:", "x:", "y:", "z:",
   };
 
   auto available = std::accumulate(

repertory/repertory_test/include/fixtures/fuse_fixture.hpp

@@ -54,21 +54,31 @@ namespace repertory {
 struct local_s3 final {
   static constexpr const provider_type type{provider_type::s3};
   static constexpr const provider_type type2{provider_type::s3};
+  static constexpr const std::uint16_t port{0U};
 };
 
 struct local_sia final {
   static constexpr const provider_type type{provider_type::sia};
   static constexpr const provider_type type2{provider_type::sia};
+  static constexpr const std::uint16_t port{0U};
 };
 
 struct remote_s3 final {
   static constexpr const provider_type type{provider_type::remote};
   static constexpr const provider_type type2{provider_type::s3};
+  static constexpr const std::uint16_t port{0U};
 };
 
 struct remote_sia final {
   static constexpr const provider_type type{provider_type::remote};
   static constexpr const provider_type type2{provider_type::sia};
+  static constexpr const std::uint16_t port{0U};
+};
+
+struct remote_linux_to_winfsp final {
+  static constexpr const provider_type type{provider_type::remote};
+  static constexpr const provider_type type2{provider_type::unknown};
+  static constexpr const std::uint16_t port{30001U};
 };
 
 template <typename provider_t> class fuse_test : public ::testing::Test {
@@ -178,7 +188,7 @@ protected:
       execute_mount(drive_args, mount_location);
     };
 
-    const auto mount_remote = [&]() {
+    const auto mount_remote = [&](std::uint16_t port = 30000U) {
       {
         mount_location2 = mount_location;
 
@@ -187,7 +197,8 @@ protected:
             {
                 "fuse_test",
                 app_config::get_provider_name(provider_t::type) + '_' +
-                    app_config::get_provider_name(provider_t::type2),
+                    app_config::get_provider_name(provider_t::type2) + '_' +
+                    std::to_string(port),
             });
 
         mount_location = utils::path::combine(test_directory, {"mount"});
@@ -206,7 +217,7 @@ protected:
             "-dd",
             config2->get_data_directory(),
             "-rm",
-            "localhost:30000",
+            fmt::format("localhost:{}", port),
             mount_location,
         });
       }
@@ -233,6 +244,10 @@ protected:
         mount_sia();
       } break;
 
+      case provider_type::unknown:
+        mount_remote(provider_t::port);
+        return;
+
       default:
         throw std::runtime_error("remote provider type is not implemented");
         return;
@@ -410,9 +425,15 @@ std::string fuse_test<provider_t>::mount_location;
 template <typename provider_t>
 std::string fuse_test<provider_t>::mount_location2;
 
-// using fuse_provider_types = ::testing::Types<local_s3, remote_s3>;
+#if defined(__linux__)
 using fuse_provider_types =
     ::testing::Types<local_s3, remote_s3, local_sia, remote_sia>;
+// using fuse_provider_types =
+//     ::testing::Types<local_s3, remote_s3, local_sia, remote_sia,
+//     remote_linux_to_winfsp>;
+#else  // !defined(__linux__)
+build fails here
+#endif // defined(_WIN32)
 } // namespace repertory
 
 #endif // !defined(_WIN32)

repertory/repertory_test/include/fixtures/winfsp_fixture.hpp

@@ -45,21 +45,31 @@ namespace repertory {
 struct local_s3 final {
   static constexpr const provider_type type{provider_type::s3};
   static constexpr const provider_type type2{provider_type::s3};
+  static constexpr const std::uint16_t port{0U};
 };
 
 struct local_sia final {
   static constexpr const provider_type type{provider_type::sia};
   static constexpr const provider_type type2{provider_type::sia};
+  static constexpr const std::uint16_t port{0U};
 };
 
 struct remote_s3 final {
   static constexpr const provider_type type{provider_type::remote};
   static constexpr const provider_type type2{provider_type::s3};
+  static constexpr const std::uint16_t port{0U};
 };
 
 struct remote_sia final {
   static constexpr const provider_type type{provider_type::remote};
   static constexpr const provider_type type2{provider_type::sia};
+  static constexpr const std::uint16_t port{0U};
+};
+
+struct remote_winfsp_to_linux final {
+  static constexpr const provider_type type{provider_type::remote};
+  static constexpr const provider_type type2{provider_type::unknown};
+  static constexpr const std::uint16_t port{30001U};
 };
 
 template <typename provider_t> class winfsp_test : public ::testing::Test {
@@ -160,13 +170,15 @@ protected:
       execute_mount(drive_args, mount_location);
     };
 
-    const auto mount_remote = [&]() {
+    const auto mount_remote = [&](std::uint16_t port = 30000U) {
       {
         auto test_directory = utils::path::combine(
             test::get_test_output_dir(),
             {
                 "winfsp_test",
-                app_config::get_provider_name(provider_type::remote),
+                app_config::get_provider_name(provider_t::type) + '_' +
+                    app_config::get_provider_name(provider_t::type2) + '_' +
+                    std::to_string(port),
             });
 
         mount_location2 = mount_location;
@@ -184,7 +196,7 @@ protected:
             "-dd",
             config->get_data_directory(),
             "-rm",
-            "localhost:30000",
+            fmt::format("localhost:{}", port),
             mount_location,
         });
       }
@@ -211,6 +223,10 @@ protected:
         mount_sia();
       } break;
 
+      case provider_type::unknown:
+        mount_remote(provider_t::port);
+        return;
+
       default:
         throw std::runtime_error("remote provider type is not implemented");
         return;