diff --git a/contrib/sip_proxy/filters/network/source/tra/tra.h b/contrib/sip_proxy/filters/network/source/tra/tra.h
index e3d5e3f98c748..46761e65570f5 100644
--- a/contrib/sip_proxy/filters/network/source/tra/tra.h
+++ b/contrib/sip_proxy/filters/network/source/tra/tra.h
@@ -53,8 +53,6 @@ class Client {
 
   virtual void closeStream() PURE;
 
-  virtual void resetStream() PURE;
-
   virtual void createTrafficRoutingAssistant(
       const std::string& type, const absl::flat_hash_map<std::string, std::string>& data,
       Tracing::Span& parent_span, const StreamInfo::StreamInfo& stream_info) PURE;
diff --git a/contrib/sip_proxy/filters/network/source/tra/tra_impl.cc b/contrib/sip_proxy/filters/network/source/tra/tra_impl.cc
index e956b5f1fdba4..a897807b58ad6 100644
--- a/contrib/sip_proxy/filters/network/source/tra/tra_impl.cc
+++ b/contrib/sip_proxy/filters/network/source/tra/tra_impl.cc
@@ -33,7 +33,7 @@ GrpcClientImpl::~GrpcClientImpl() {
   }
 
   if (stream_ != nullptr) {
-    stream_.closeStream();
+    stream_.resetStream();
   }
 }
 
@@ -58,14 +58,6 @@ void GrpcClientImpl::closeStream() {
   }
 }
 
-void GrpcClientImpl::resetStream() {
-  ASSERT(callbacks_ != nullptr);
-  if (stream_ != nullptr) {
-    stream_.resetStream();
-    stream_ = nullptr;
-  }
-}
-
 void GrpcClientImpl::createTrafficRoutingAssistant(
     const std::string& type, const absl::flat_hash_map<std::string, std::string>& data,
     Tracing::Span& parent_span, const StreamInfo::StreamInfo& stream_info) {
diff --git a/contrib/sip_proxy/filters/network/source/tra/tra_impl.h b/contrib/sip_proxy/filters/network/source/tra/tra_impl.h
index 7b3c23c6a14f1..3ba92ad9379ae 100644
--- a/contrib/sip_proxy/filters/network/source/tra/tra_impl.h
+++ b/contrib/sip_proxy/filters/network/source/tra/tra_impl.h
@@ -50,8 +50,6 @@ class GrpcClientImpl : public Client,
 
   void closeStream() override;
 
-  void resetStream() override;
-
   void createTrafficRoutingAssistant(const std::string& type,
                                      const absl::flat_hash_map<std::string, std::string>& data,
                                      Tracing::Span& parent_span,
diff --git a/contrib/sip_proxy/filters/network/test/BUILD b/contrib/sip_proxy/filters/network/test/BUILD
index 70997bb2b1316..376b053eb4daa 100644
--- a/contrib/sip_proxy/filters/network/test/BUILD
+++ b/contrib/sip_proxy/filters/network/test/BUILD
@@ -83,25 +83,25 @@ envoy_cc_test(
     ],
 )
 
-#envoy_cc_test(
-#    name = "tra_test",
-#    srcs = ["tra_test.cc"],
-#    deps = [
-#        ":mocks",
-#        ":utility_lib",
-#        "//contrib/sip_proxy/filters/network/source:config",
-#        "//contrib/sip_proxy/filters/network/source:conn_manager_lib",
-#        "//contrib/sip_proxy/filters/network/source/filters:filter_interface",
-#        "//contrib/sip_proxy/filters/network/source/router:config",
-#        "//contrib/sip_proxy/filters/network/source/router:router_interface",
-#        "//contrib/sip_proxy/filters/network/source/tra:tra_lib",
-#        "//test/mocks/network:network_mocks",
-#        "//test/mocks/server:factory_context_mocks",
-#        "//test/test_common:printers_lib",
-#        "@envoy_api//contrib/envoy/extensions/filters/network/sip_proxy/tra/v3alpha:pkg_cc_proto",
-#        "@envoy_api//contrib/envoy/extensions/filters/network/sip_proxy/v3alpha:pkg_cc_proto",
-#    ],
-#)
+envoy_cc_test(
+    name = "tra_test",
+    srcs = ["tra_test.cc"],
+    deps = [
+        ":mocks",
+        ":utility_lib",
+        "//contrib/sip_proxy/filters/network/source:config",
+        "//contrib/sip_proxy/filters/network/source:conn_manager_lib",
+        "//contrib/sip_proxy/filters/network/source/filters:filter_interface",
+        "//contrib/sip_proxy/filters/network/source/router:config",
+        "//contrib/sip_proxy/filters/network/source/router:router_interface",
+        "//contrib/sip_proxy/filters/network/source/tra:tra_lib",
+        "//test/mocks/network:network_mocks",
+        "//test/mocks/server:factory_context_mocks",
+        "//test/test_common:printers_lib",
+        "@envoy_api//contrib/envoy/extensions/filters/network/sip_proxy/tra/v3alpha:pkg_cc_proto",
+        "@envoy_api//contrib/envoy/extensions/filters/network/sip_proxy/v3alpha:pkg_cc_proto",
+    ],
+)
 
 envoy_cc_test(
     name = "decoder_test",
diff --git a/contrib/sip_proxy/filters/network/test/app_exception_impl_test.cc b/contrib/sip_proxy/filters/network/test/app_exception_impl_test.cc
index 4104da3898965..f99ac5240e30b 100644
--- a/contrib/sip_proxy/filters/network/test/app_exception_impl_test.cc
+++ b/contrib/sip_proxy/filters/network/test/app_exception_impl_test.cc
@@ -17,6 +17,13 @@ TEST(AppExceptionImplTest, CopyConstructor) {
   EXPECT_STREQ("msg", copy.what());
 }
 
+TEST(AppExceptionImplTest, EncodeWithoutNecessaryHeaders) {
+  AppException app_ex(AppExceptionType::InternalError, "msg");
+  MessageMetadata metadata;
+  Buffer::OwnedImpl buffer;
+  app_ex.encode(metadata, buffer);
+}
+
 } // namespace SipProxy
 } // namespace NetworkFilters
 } // namespace Extensions
diff --git a/contrib/sip_proxy/filters/network/test/mocks.cc b/contrib/sip_proxy/filters/network/test/mocks.cc
index 7133a7b72c32d..d400dc741a455 100644
--- a/contrib/sip_proxy/filters/network/test/mocks.cc
+++ b/contrib/sip_proxy/filters/network/test/mocks.cc
@@ -51,7 +51,7 @@ MockDecoderFilterCallbacks::MockDecoderFilterCallbacks() {
 
   ON_CALL(*this, streamId()).WillByDefault(Return(stream_id_));
   ON_CALL(*this, transactionInfos()).WillByDefault(Return(transaction_infos_));
-  ON_CALL(*this, streamInfo()).WillByDefault(ReturnRef(stream_info_));
+  ON_CALL(*this, streamInfo()).WillByDefault(ReturnRef(connection_.stream_info_));
 }
 MockDecoderFilterCallbacks::~MockDecoderFilterCallbacks() = default;
 
diff --git a/contrib/sip_proxy/filters/network/test/mocks.h b/contrib/sip_proxy/filters/network/test/mocks.h
index b9b26a1562351..56b3301da48ed 100644
--- a/contrib/sip_proxy/filters/network/test/mocks.h
+++ b/contrib/sip_proxy/filters/network/test/mocks.h
@@ -129,7 +129,6 @@ class MockDecoderFilterCallbacks : public DecoderFilterCallbacks {
   uint64_t stream_id_{1};
   std::string transaction_id_{"test"};
   NiceMock<Network::MockConnection> connection_;
-  NiceMock<StreamInfo::MockStreamInfo> stream_info_;
   std::shared_ptr<Router::MockRoute> route_;
   std::shared_ptr<Router::TransactionInfos> transaction_infos_;
 };
@@ -167,7 +166,7 @@ class MockRouteEntry : public RouteEntry {
   MockRouteEntry();
   ~MockRouteEntry() override;
 
-  //  // SipProxy::Router::RouteEntry
+  // SipProxy::Router::RouteEntry
   MOCK_METHOD(const std::string&, clusterName, (), (const));
   MOCK_METHOD(const Envoy::Router::MetadataMatchCriteria*, metadataMatchCriteria, (), (const));
   std::string cluster_name_{"fake_cluster"};
@@ -221,25 +220,6 @@ class MockConnectionManager : public ConnectionManager {
   MOCK_METHOD(std::shared_ptr<SipSettings>, settings, (), (const));
 };
 
-namespace TrafficRoutingAssistant {
-class MockGrpcClientImpl : public GrpcClientImpl {
-public:
-  MockGrpcClientImpl(const Grpc::RawAsyncClientSharedPtr& async_client,
-                     const absl::optional<std::chrono::milliseconds>& timeout)
-      : GrpcClientImpl(async_client, timeout) {
-    async_client_ = std::make_shared<NiceMock<Grpc::MockAsyncClient>>();
-    request_ = new Grpc::MockAsyncRequest();
-  }
-  ~MockGrpcClientImpl() override { delete request_; }
-
-  std::shared_ptr<Grpc::MockAsyncClient> asyncClient() { return async_client_; }
-
-private:
-  std::shared_ptr<NiceMock<Grpc::MockAsyncClient>> async_client_;
-  Grpc::MockAsyncRequest* request_;
-};
-} // namespace TrafficRoutingAssistant
-
 class MockTrafficRoutingAssistantHandlerDeep : public TrafficRoutingAssistantHandler {
 public:
   MockTrafficRoutingAssistantHandlerDeep(
@@ -250,6 +230,13 @@ class MockTrafficRoutingAssistantHandlerDeep : public TrafficRoutingAssistantHan
   MOCK_METHOD(TrafficRoutingAssistant::ClientPtr&, traClient, (), (override));
 };
 
+class MockRequestCallbacks : public TrafficRoutingAssistant::RequestCallbacks {
+public:
+  MOCK_METHOD(void, complete,
+              (const TrafficRoutingAssistant::ResponseType&, const std::string&, const absl::any&),
+              ());
+};
+
 } // namespace SipProxy
 } // namespace NetworkFilters
 } // namespace Extensions
diff --git a/contrib/sip_proxy/filters/network/test/tra_test.cc b/contrib/sip_proxy/filters/network/test/tra_test.cc
index 5370c5d7306ce..77f361449ee10 100644
--- a/contrib/sip_proxy/filters/network/test/tra_test.cc
+++ b/contrib/sip_proxy/filters/network/test/tra_test.cc
@@ -20,7 +20,6 @@
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
-using testing::_;
 using testing::NiceMock;
 using testing::Return;
 using testing::ReturnRef;
@@ -32,34 +31,8 @@ namespace SipProxy {
 
 class SipTraTest : public testing::Test {
 public:
-  SipTraTest() : async_stream_(std::make_unique<testing::NiceMock<Grpc::MockAsyncStream>>()) {}
-  ~SipTraTest() override { delete (filter_); }
-
-  void initTraHandler() {
-    std::string sip_proxy_yaml = R"EOF(
-           stat_prefix: egress_sip
-           route_config:
-             routes:
-             - match:
-                domain: "icscf-internal.cncs.svc.cluster.local"
-                header: "Route"
-                parameter: "x-suri"
-               route:
-                cluster: fake_cluster
-             - match:
-                domain: "scscf-internal.cncs.svc.cluster.local"
-                header: "Route"
-                parameter: "x-suri"
-               route:
-                cluster: fake_cluster2
-           settings:
-             transaction_timeout: 32s
-             local_services:
-             - domain: "pcsf-cfed.cncs.svc.cluster.local"
-               parameter: "x-suri"
-)EOF";
-    TestUtility::loadFromYaml(sip_proxy_yaml, sip_proxy_config_);
-
+  SipTraTest() : stream_info_(time_source_, nullptr) {}
+  std::shared_ptr<SipProxy::MockTrafficRoutingAssistantHandlerDeep> initTraHandler() {
     std::string tra_yaml = R"EOF(
                grpc_service:
                  envoy_grpc:
@@ -67,182 +40,183 @@ class SipTraTest : public testing::Test {
                timeout: 2s
                transport_api_version: V3
 )EOF";
-    TestUtility::loadFromYaml(tra_yaml, tra_config_);
 
-    StreamInfo::StreamInfoImpl stream_info{time_source_, nullptr};
+    auto tra_config = std::make_shared<
+        envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceConfig>();
+    TestUtility::loadFromYaml(tra_yaml, *tra_config);
+
     SipFilterStats stat = SipFilterStats::generateStats("test.", store_);
-    EXPECT_CALL(config_, stats()).WillRepeatedly(ReturnRef(stat));
-    filter_ =
-        new NiceMock<MockConnectionManager>(config_, random_, time_source_, context_, nullptr);
+    auto config = std::make_shared<NiceMock<MockConfig>>();
+    EXPECT_CALL(*config, stats()).WillRepeatedly(ReturnRef(stat));
+    auto context = std::make_shared<NiceMock<Server::Configuration::MockFactoryContext>>();
+    auto filter = std::make_unique<NiceMock<MockConnectionManager>>(*config, random_, time_source_,
+                                                                    *context, nullptr);
 
-    tra_handler_ = std::make_shared<NiceMock<SipProxy::MockTrafficRoutingAssistantHandlerDeep>>(
-        *filter_, sip_proxy_config_.settings().tra_service_config(), context_, stream_info);
-  }
+    auto tra_handler = std::make_shared<NiceMock<SipProxy::MockTrafficRoutingAssistantHandlerDeep>>(
+        *filter, *tra_config, *context, stream_info_);
+
+    auto async_client = std::make_shared<testing::NiceMock<Grpc::MockAsyncClient>>();
+    EXPECT_CALL(*async_client, sendRaw(_, _, _, _, _, _))
+        .WillRepeatedly(testing::Return(async_client->async_request_.get()));
 
-  void initGrpcClient() {
-    initTraHandler();
-    async_request_ = std::make_unique<testing::NiceMock<Grpc::MockAsyncRequest>>();
     async_stream_ = std::make_unique<testing::NiceMock<Grpc::MockAsyncStream>>();
-    async_client_ = std::make_shared<testing::NiceMock<Grpc::MockAsyncClient>>();
-    EXPECT_CALL(*async_client_, sendRaw(_, _, _, _, _, _))
-        .WillRepeatedly(testing::Return(async_request_.get()));
-    EXPECT_CALL(*async_client_, startRaw(_, _, _, _))
+    EXPECT_CALL(*async_client, startRaw(_, _, _, _))
         .WillRepeatedly(testing::Return(async_stream_.get()));
 
-    grpc_client_ = std::make_unique<TrafficRoutingAssistant::MockGrpcClientImpl>(
-        async_client_, std::chrono::milliseconds(2000));
-    grpc_client_->setRequestCallbacks(*tra_handler_);
+    auto grpc_client = std::make_unique<TrafficRoutingAssistant::GrpcClientImpl>(
+        async_client, std::chrono::milliseconds(2000));
+    tra_client_ = std::move(grpc_client);
+    EXPECT_CALL(*tra_handler, traClient()).WillRepeatedly(ReturnRef(tra_client_));
+    return tra_handler;
   }
 
-  void initTraClient() {
-    initGrpcClient();
-    tra_client_ = std::move(grpc_client_);
-    EXPECT_CALL(*tra_handler_, traClient()).WillRepeatedly(ReturnRef(tra_client_));
-  }
-
-  NiceMock<MockConnectionManager>* filter_{};
   NiceMock<MockTimeSystem> time_source_;
-  envoy::extensions::filters::network::sip_proxy::v3alpha::SipProxy sip_proxy_config_;
-  NiceMock<Server::Configuration::MockFactoryContext> context_;
-  NiceMock<MockConfig> config_;
-  NiceMock<Random::MockRandomGenerator> random_;
-  Stats::TestUtil::TestStore store_;
-  envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceConfig tra_config_;
-  NiceMock<SipFilters::MockDecoderFilterCallbacks> callbacks_;
   Tracing::MockSpan span_;
-
-  std::unique_ptr<testing::NiceMock<Grpc::MockAsyncRequest>> async_request_;
+  Stats::TestUtil::TestStore store_;
+  NiceMock<Random::MockRandomGenerator> random_;
+  StreamInfo::StreamInfoImpl stream_info_;
   std::unique_ptr<testing::NiceMock<Grpc::MockAsyncStream>> async_stream_;
-  std::unique_ptr<TrafficRoutingAssistant::MockGrpcClientImpl> grpc_client_;
-  std::shared_ptr<SipProxy::MockTrafficRoutingAssistantHandlerDeep> tra_handler_;
-  std::shared_ptr<Grpc::MockAsyncClient> async_client_;
   TrafficRoutingAssistant::ClientPtr tra_client_;
 };
 
 TEST_F(SipTraTest, TraUpdate) {
-  initTraClient();
-  tra_handler_->updateTrafficRoutingAssistant("lskpmc", "S1F1", "10.0.0.1");
+  auto tra_handler = initTraHandler();
+  tra_handler->updateTrafficRoutingAssistant("lskpmc", "S1F1", "10.0.0.1");
 }
 
 TEST_F(SipTraTest, TraRetrieveContinue) {
-  initTraClient();
-  tra_handler_->updateTrafficRoutingAssistant("lskpmc", "S1F1", "10.0.0.1");
+  auto tra_handler = initTraHandler();
+  tra_handler->updateTrafficRoutingAssistant("lskpmc", "S1F1", "10.0.0.1");
 
+  NiceMock<SipFilters::MockDecoderFilterCallbacks> callbacks;
   std::string host = "10.0.0.1";
   EXPECT_EQ(QueryStatus::Continue,
-            tra_handler_->retrieveTrafficRoutingAssistant("lskpmc", "S1F1", callbacks_, host));
+            tra_handler->retrieveTrafficRoutingAssistant("lskpmc", "S1F1", callbacks, host));
 }
 
 TEST_F(SipTraTest, TraRetrievePending) {
-  initTraClient();
-  StreamInfo::StreamInfoImpl stream_info{time_source_, nullptr};
+  auto tra_handler = initTraHandler();
+  NiceMock<SipFilters::MockDecoderFilterCallbacks> callbacks;
+
   MessageMetadataSharedPtr metadata = std::make_shared<MessageMetadata>("");
   metadata->addQuery("lskpmc", true);
-  EXPECT_CALL(callbacks_, metadata()).WillRepeatedly(Return(metadata));
+  EXPECT_CALL(callbacks, metadata()).WillRepeatedly(Return(metadata));
   std::string host = "10.0.0.1";
   EXPECT_EQ(QueryStatus::Pending,
-            tra_handler_->retrieveTrafficRoutingAssistant("lskpmc", "S1F1", callbacks_, host));
+            tra_handler->retrieveTrafficRoutingAssistant("lskpmc", "S1F1", callbacks, host));
 }
 
 TEST_F(SipTraTest, TraRetrieveStop) {
-  initTraClient();
-  StreamInfo::StreamInfoImpl stream_info{time_source_, nullptr};
+  auto tra_handler = initTraHandler();
+  NiceMock<SipFilters::MockDecoderFilterCallbacks> callbacks;
+
   MessageMetadataSharedPtr metadata = std::make_shared<MessageMetadata>("");
   metadata->addQuery("lskpmc", false);
-  EXPECT_CALL(callbacks_, metadata()).WillRepeatedly(Return(metadata));
+  EXPECT_CALL(callbacks, metadata()).WillRepeatedly(Return(metadata));
   std::string host = "10.0.0.1";
   EXPECT_EQ(QueryStatus::Stop,
-            tra_handler_->retrieveTrafficRoutingAssistant("lskpmc", "S1F1", callbacks_, host));
+            tra_handler->retrieveTrafficRoutingAssistant("lskpmc", "S1F1", callbacks, host));
 }
 
 TEST_F(SipTraTest, TraCompleteUpdateRsp) {
-  initTraClient();
-  tra_handler_->complete(TrafficRoutingAssistant::ResponseType::UpdateResp, "", "");
+  auto tra_handler = initTraHandler();
+  tra_handler->complete(TrafficRoutingAssistant::ResponseType::UpdateResp, "", "");
 }
 
 TEST_F(SipTraTest, TraCompleteCreateRsp) {
-  initTraClient();
-  tra_handler_->complete(TrafficRoutingAssistant::ResponseType::CreateResp, "", "");
+  auto tra_handler = initTraHandler();
+  tra_handler->complete(TrafficRoutingAssistant::ResponseType::CreateResp, "", "");
 }
 
 TEST_F(SipTraTest, TraCompleteDeleteRsp) {
-  initTraClient();
-  tra_handler_->complete(TrafficRoutingAssistant::ResponseType::DeleteResp, "", "");
+  auto tra_handler = initTraHandler();
+  tra_handler->complete(TrafficRoutingAssistant::ResponseType::DeleteResp, "", "");
 }
 
 TEST_F(SipTraTest, TraCompleteRetrieveRsp) {
-  initTraClient();
+  auto tra_handler = initTraHandler();
   envoy::extensions::filters::network::sip_proxy::tra::v3alpha::RetrieveResponse
       retrive_response_config;
   std::string retrieveRsp_yaml = R"EOF(
-            data: {"S1F1":"10.0.0.1"}
+             data: {"S1F1":"10.0.0.1"}
 )EOF";
   TestUtility::loadFromYaml(retrieveRsp_yaml, retrive_response_config);
 
-  tra_handler_->complete(TrafficRoutingAssistant::ResponseType::RetrieveResp, "lskpmc",
-                         retrive_response_config);
+  tra_handler->complete(TrafficRoutingAssistant::ResponseType::RetrieveResp, "lskpmc",
+                        retrive_response_config);
 }
 
 TEST_F(SipTraTest, TraCompleteSubscribeRsp) {
-  initTraClient();
+  auto tra_handler = initTraHandler();
   envoy::extensions::filters::network::sip_proxy::tra::v3alpha::SubscribeResponse
       subscribe_response_config;
   std::string subscribeRsp_yaml = R"EOF(
-            data: {"S1F1":"10.0.0.1"}
+             data: {"S2F1":"10.0.0.1"}
 )EOF";
   TestUtility::loadFromYaml(subscribeRsp_yaml, subscribe_response_config);
 
-  tra_handler_->complete(TrafficRoutingAssistant::ResponseType::SubscribeResp, "lskpmc",
-                         subscribe_response_config);
+  tra_handler->complete(TrafficRoutingAssistant::ResponseType::SubscribeResp, "lskpmc",
+                        subscribe_response_config);
 }
 
 TEST_F(SipTraTest, TraDoSubscribe) {
-  initTraClient();
+  auto tra_handler = initTraHandler();
   envoy::extensions::filters::network::sip_proxy::v3alpha::CustomizedAffinity affinity_config;
   std::string affinity_yaml = R"EOF(
-           entries:
-           - key_name: lskpmc
-             query: true
-             subscribe: true
-           - key_name: ep
-             query: false
-             subscribe: false
+            entries:
+            - key_name: lskpmc
+              query: true
+              subscribe: true
+            - key_name: ep
+              query: false
+              subscribe: false
 )EOF";
   TestUtility::loadFromYaml(affinity_yaml, affinity_config);
-
-  tra_handler_->doSubscribe(affinity_config);
+  tra_handler->doSubscribe(affinity_config);
 }
 
 TEST_F(SipTraTest, TraDelete) {
-  initTraClient();
-  tra_handler_->deleteTrafficRoutingAssistant("lskpmc", "S1F1");
+  auto tra_handler = initTraHandler();
+  tra_handler->deleteTrafficRoutingAssistant("lskpmc", "S1F1");
 }
 
 TEST_F(SipTraTest, TraSubscribe) {
-  initTraClient();
-  tra_handler_->subscribeTrafficRoutingAssistant("lskpmc");
+  auto tra_handler = initTraHandler();
+  tra_handler->subscribeTrafficRoutingAssistant("lskpmc");
 }
 
 TEST_F(SipTraTest, GrpcClientCancel) {
-  initGrpcClient();
-  StreamInfo::StreamInfoImpl stream_info{time_source_, nullptr};
+  auto async_client = std::make_shared<testing::NiceMock<Grpc::MockAsyncClient>>();
+  testing::NiceMock<Grpc::MockAsyncStream> async_stream;
+  EXPECT_CALL(*async_client, sendRaw(_, _, _, _, _, _))
+      .WillRepeatedly(testing::Return(async_client->async_request_.get()));
+
+  auto grpc_client =
+      TrafficRoutingAssistant::GrpcClientImpl(async_client, std::chrono::milliseconds(2000));
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
+
   absl::flat_hash_map<std::string, std::string> data;
   data.emplace(std::make_pair("S1F1", "10.0.0.1"));
-  grpc_client_->createTrafficRoutingAssistant("lskpmc", data, span_, stream_info);
-  grpc_client_->cancel();
+  grpc_client.createTrafficRoutingAssistant("lskpmc", data, span_, stream_info_);
+  grpc_client.cancel();
 }
 
 TEST_F(SipTraTest, GrpcClientCloseStream) {
-  initGrpcClient();
-  StreamInfo::StreamInfoImpl stream_info{time_source_, nullptr};
-  grpc_client_->subscribeTrafficRoutingAssistant("lskpmc", span_, stream_info);
+  auto async_client = std::make_shared<testing::NiceMock<Grpc::MockAsyncClient>>();
+  testing::NiceMock<Grpc::MockAsyncStream> async_stream;
+  EXPECT_CALL(*async_client, startRaw(_, _, _, _)).WillRepeatedly(testing::Return(&async_stream));
+
+  auto grpc_client =
+      TrafficRoutingAssistant::GrpcClientImpl(async_client, std::chrono::milliseconds(2000));
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
 
-  grpc_client_->closeStream();
+  grpc_client.subscribeTrafficRoutingAssistant("lskpmc", span_, stream_info_);
+  grpc_client.closeStream();
 }
 
 TEST_F(SipTraTest, GrpcClientOnSuccessRetrieveRsp) {
-  initGrpcClient();
-
   envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse
       service_response_config;
   std::string serviceRsp_yaml = R"EOF(
@@ -250,7 +224,7 @@ TEST_F(SipTraTest, GrpcClientOnSuccessRetrieveRsp) {
             ret: 0
             reason: success
             retrieve_response:
-              data: {"S1F1", "10.0.0.1"}
+              data: {"S1F1": "10.0.0.1"}
 )EOF";
   TestUtility::loadFromYaml(serviceRsp_yaml, service_response_config);
 
@@ -258,12 +232,14 @@ TEST_F(SipTraTest, GrpcClientOnSuccessRetrieveRsp) {
       response = std::make_unique<
           envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>(
           service_response_config);
-  grpc_client_->onSuccess(std::move(response), span_);
+
+  auto grpc_client = TrafficRoutingAssistant::GrpcClientImpl(nullptr, absl::nullopt);
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
+  grpc_client.onSuccess(std::move(response), span_);
 }
 
 TEST_F(SipTraTest, GrpcClientOnSuccessCreateRsp) {
-  initGrpcClient();
-
   envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse
       service_response_config;
   std::string serviceRsp_yaml = R"EOF(
@@ -273,20 +249,21 @@ TEST_F(SipTraTest, GrpcClientOnSuccessCreateRsp) {
 )EOF";
   TestUtility::loadFromYaml(serviceRsp_yaml, service_response_config);
 
-  envoy::extensions::filters::network::sip_proxy::tra::v3alpha::CreateResponse* create_response =
+  auto create_response =
       new envoy::extensions::filters::network::sip_proxy::tra::v3alpha::CreateResponse();
   service_response_config.set_allocated_create_response(create_response);
   std::unique_ptr<envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>
       response = std::make_unique<
           envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>(
           service_response_config);
-  grpc_client_->onSuccess(std::move(response), span_);
-  delete (create_response);
+
+  auto grpc_client = TrafficRoutingAssistant::GrpcClientImpl(nullptr, absl::nullopt);
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
+  grpc_client.onSuccess(std::move(response), span_);
 }
 
 TEST_F(SipTraTest, GrpcClientOnSuccessUpdateRsp) {
-  initGrpcClient();
-
   envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse
       service_response_config;
   std::string serviceRsp_yaml = R"EOF(
@@ -296,20 +273,20 @@ TEST_F(SipTraTest, GrpcClientOnSuccessUpdateRsp) {
 )EOF";
   TestUtility::loadFromYaml(serviceRsp_yaml, service_response_config);
 
-  envoy::extensions::filters::network::sip_proxy::tra::v3alpha::UpdateResponse* update_response =
+  auto update_response =
       new envoy::extensions::filters::network::sip_proxy::tra::v3alpha::UpdateResponse();
   service_response_config.set_allocated_update_response(update_response);
-  std::unique_ptr<envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>
-      response = std::make_unique<
-          envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>(
-          service_response_config);
-  grpc_client_->onSuccess(std::move(response), span_);
-  delete (update_response);
+  auto response = std::make_unique<
+      envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>(
+      service_response_config);
+
+  auto grpc_client = TrafficRoutingAssistant::GrpcClientImpl(nullptr, absl::nullopt);
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
+  grpc_client.onSuccess(std::move(response), span_);
 }
 
 TEST_F(SipTraTest, GrpcClientOnSuccessDeleteRsp) {
-  initGrpcClient();
-
   envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse
       service_response_config;
   std::string serviceRsp_yaml = R"EOF(
@@ -319,30 +296,54 @@ TEST_F(SipTraTest, GrpcClientOnSuccessDeleteRsp) {
 )EOF";
   TestUtility::loadFromYaml(serviceRsp_yaml, service_response_config);
 
-  envoy::extensions::filters::network::sip_proxy::tra::v3alpha::DeleteResponse* delete_response =
+  auto delete_response =
       new envoy::extensions::filters::network::sip_proxy::tra::v3alpha::DeleteResponse();
   service_response_config.set_allocated_delete_response(delete_response);
-  std::unique_ptr<envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>
-      response = std::make_unique<
-          envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>(
-          service_response_config);
-  grpc_client_->onSuccess(std::move(response), span_);
-  delete (delete_response);
+  auto response = std::make_unique<
+      envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>(
+      service_response_config);
+
+  auto grpc_client = TrafficRoutingAssistant::GrpcClientImpl(nullptr, absl::nullopt);
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
+  grpc_client.onSuccess(std::move(response), span_);
 }
 
 TEST_F(SipTraTest, GrpcClientOnReceiveMessage) {
-  initGrpcClient();
-
   std::unique_ptr<envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>
       response = std::make_unique<
           envoy::extensions::filters::network::sip_proxy::tra::v3alpha::TraServiceResponse>();
-  grpc_client_->onReceiveMessage(std::move(response));
+
+  auto grpc_client = TrafficRoutingAssistant::GrpcClientImpl(nullptr, absl::nullopt);
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
+  grpc_client.onReceiveMessage(std::move(response));
 }
 
 TEST_F(SipTraTest, GrpcClientOnFailure) {
-  initGrpcClient();
-  Grpc::Status::GrpcStatus status = Grpc::Status::WellKnownGrpcStatus::Ok;
-  grpc_client_->onFailure(status, "", span_);
+  Grpc::Status::GrpcStatus status = Grpc::Status::WellKnownGrpcStatus::Unknown;
+
+  auto grpc_client = TrafficRoutingAssistant::GrpcClientImpl(nullptr, absl::nullopt);
+  NiceMock<SipProxy::MockRequestCallbacks> request_callbacks;
+  grpc_client.setRequestCallbacks(request_callbacks);
+  grpc_client.onFailure(status, "", span_);
+}
+
+TEST_F(SipTraTest, Misc) {
+  auto grpc_client = TrafficRoutingAssistant::GrpcClientImpl(nullptr, absl::nullopt);
+
+  Http::TestRequestHeaderMapImpl request_headers;
+  grpc_client.onCreateInitialMetadata(request_headers);
+
+  Http::ResponseHeaderMapPtr response_headers = std::make_unique<Http::TestResponseHeaderMapImpl>();
+  grpc_client.onReceiveInitialMetadata(std::move(response_headers));
+
+  Http::ResponseTrailerMapPtr response_trailers =
+      std::make_unique<Http::TestResponseTrailerMapImpl>();
+  grpc_client.onReceiveTrailingMetadata(std::move(response_trailers));
+
+  Grpc::Status::GrpcStatus status = Grpc::Status::WellKnownGrpcStatus::Unknown;
+  grpc_client.onRemoteClose(status, "");
 }
 
 } // namespace SipProxy