Fix Flight tests on Windows

cpp/src/arrow/flight/client.cc

@@ -95,7 +95,7 @@ class GrpcAddCallHeaders : public AddCallHeaders {
  public:
   explicit GrpcAddCallHeaders(std::multimap<grpc::string, grpc::string>* metadata)
       : metadata_(metadata) {}
-  ~GrpcAddCallHeaders() = default;
+  ~GrpcAddCallHeaders() override = default;
 
   void AddHeader(const std::string& key, const std::string& value) override {
     metadata_->insert(std::make_pair(key, value));

cpp/src/arrow/flight/flight_test.cc

@@ -813,6 +813,15 @@ class TestPropagatingMiddleware : public ::testing::Test {
     ASSERT_OK(second_server_->Shutdown());
   }
 
+  void CheckHeader(const std::string& header, const std::string& value,
+                   const CallHeaders::const_iterator& it) {
+    // Construct a string_view before comparison to satisfy MSVC
+    util::string_view header_view(header.data(), header.length());
+    util::string_view value_view(value.data(), value.length());
+    ASSERT_EQ(header_view, (*it).first);
+    ASSERT_EQ(value_view, (*it).second);
+  }
+
  protected:
   std::unique_ptr<FlightClient> client_;
   std::unique_ptr<FlightServerBase> first_server_;
@@ -1456,12 +1465,10 @@ TEST_F(TestPropagatingMiddleware, CallHeaders) {
         incoming_headers.GetHeaders(header1);
     auto& current = header_pair.first;
     ASSERT_NE(current, header_pair.second);
-    ASSERT_EQ(header1, (*current).first);
-    ASSERT_EQ(header1_value1, (*current).second);
+    CheckHeader(header1, header1_value1, current);
     ++current;
     ASSERT_NE(current, header_pair.second);
-    ASSERT_EQ(header1, (*current).first);
-    ASSERT_EQ(header1_value2, (*current).second);
+    CheckHeader(header1, header1_value2, current);
     ++current;
     ASSERT_EQ(current, header_pair.second);
   }
@@ -1470,8 +1477,7 @@ TEST_F(TestPropagatingMiddleware, CallHeaders) {
         incoming_headers.GetHeaders(header2);
     auto& current = header_pair.first;
     ASSERT_NE(current, header_pair.second);
-    ASSERT_EQ(header2, (*current).first);
-    ASSERT_EQ(header2_value1, (*current).second);
+    CheckHeader(header2, header2_value1, current);
     ++current;
     ASSERT_EQ(current, header_pair.second);
   }

cpp/src/arrow/flight/middleware_internal.cc

@@ -35,21 +35,24 @@ namespace internal {
 class MultimapIterator : public HeaderIterator::Impl {
  public:
   explicit MultimapIterator(GrpcMetadataMap::const_iterator it) : it_(it) {}
+  ~MultimapIterator() override = default;
 
   void Next() override { it_++; }
+
   const HeaderIterator::value_type& Dereference() const override {
     current_header_ = util::string_view(it_->first.data(), it_->first.length());
     current_value_ = util::string_view(it_->second.data(), it_->second.length());
     current_ = std::make_pair(current_header_, current_value_);
     return current_;
   }
+
   bool Equals(const void* other) const override {
     return it_ == static_cast<const MultimapIterator*>(other)->it_;
   }
+
   std::unique_ptr<HeaderIterator::Impl> Clone() const override {
     return arrow::internal::make_unique<MultimapIterator>(it_);
   }
-  ~MultimapIterator() = default;
 
  private:
   GrpcMetadataMap::const_iterator it_;

cpp/src/arrow/flight/middleware_internal.h

@@ -21,6 +21,7 @@
 #pragma once
 
 #include "arrow/flight/platform.h"
+#include "arrow/flight/visibility.h"  // IWYU pragma: keep
 
 #include <map>
 #include <string>
@@ -42,10 +43,10 @@ namespace internal {
 
 typedef std::multimap<grpc::string_ref, grpc::string_ref> GrpcMetadataMap;
 
-class GrpcCallHeaders : public CallHeaders {
+class ARROW_FLIGHT_EXPORT GrpcCallHeaders : public CallHeaders {
  public:
   explicit GrpcCallHeaders(const GrpcMetadataMap* metadata) : metadata_(metadata) {}
-  ~GrpcCallHeaders() = default;
+  ~GrpcCallHeaders() override = default;
 
   std::pair<const_iterator, const_iterator> GetHeaders(
       const std::string& key) const override;

cpp/src/arrow/flight/server.cc

@@ -262,7 +262,7 @@ class GrpcServerCallContext : public ServerCallContext {
 class GrpcAddCallHeaders : public AddCallHeaders {
  public:
   explicit GrpcAddCallHeaders(grpc::ServerContext* context) : context_(context) {}
-  ~GrpcAddCallHeaders() = default;
+  ~GrpcAddCallHeaders() override = default;
 
   void AddHeader(const std::string& key, const std::string& value) override {
     context_->AddInitialMetadata(key, value);

python/pyarrow/tests/test_flight.py

@@ -33,12 +33,17 @@ from pyarrow.util import pathlib, find_free_port
 try:
     from pyarrow import flight
     from pyarrow.flight import (
-        FlightClient, FlightServerBase, ServerAuthHandler, ClientAuthHandler
+        FlightClient, FlightServerBase,
+        ServerAuthHandler, ClientAuthHandler,
+        ServerMiddleware, ServerMiddlewareFactory,
+        ClientMiddleware, ClientMiddlewareFactory,
     )
 except ImportError:
     flight = None
     FlightClient, FlightServerBase = object, object
     ServerAuthHandler, ClientAuthHandler = object, object
+    ServerMiddleware, ServerMiddlewareFactory = object, object
+    ClientMiddleware, ClientMiddlewareFactory = object, object
 
 
 # Marks all of the tests in this module
@@ -415,7 +420,7 @@ _thread_locals = threading.local()
 _thread_locals.sentinel = "wrong value"
 
 
-class ThreadLocalServerMiddleware(flight.ServerMiddleware):
+class ThreadLocalServerMiddleware(ServerMiddleware):
     def sending_headers(self):
         assert _thread_locals.sentinel == "right value"
 
@@ -424,7 +429,7 @@ class ThreadLocalServerMiddleware(flight.ServerMiddleware):
             _thread_locals.sentinel
 
 
-class ThreadLocalServerMiddlewareFactory(flight.ServerMiddlewareFactory):
+class ThreadLocalServerMiddlewareFactory(ServerMiddlewareFactory):
     last_sentinel = None
 
     def start_call(self, info, headers):
@@ -438,7 +443,7 @@ class ThreadLocalFlightServer(FlightServerBase):
         return iter([flight.Result(sentinel.encode())])
 
 
-class SelectiveAuthServerMiddlewareFactory(flight.ServerMiddlewareFactory):
+class SelectiveAuthServerMiddlewareFactory(ServerMiddlewareFactory):
     def start_call(self, info, headers):
         if info.method == flight.FlightMethod.LIST_ACTIONS:
             # No auth needed
@@ -455,12 +460,12 @@ class SelectiveAuthServerMiddlewareFactory(flight.ServerMiddlewareFactory):
         _thread_locals.sentinel = "password"
 
 
-class SelectiveAuthClientMiddlewareFactory(flight.ClientMiddlewareFactory):
+class SelectiveAuthClientMiddlewareFactory(ClientMiddlewareFactory):
     def start_call(self, info):
         return SelectiveAuthClientMiddleware()
 
 
-class SelectiveAuthClientMiddleware(flight.ClientMiddleware):
+class SelectiveAuthClientMiddleware(ClientMiddleware):
     def sending_headers(self):
         return {
             "x-auth-token": "password",