diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 1b41e8e..0921d95 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -358,11 +358,26 @@
     writer()->SetSupportedVersions(versions);
   }
 
+  // This should be called before setting customized encrypters/decrypters for
+  // connection and peer creator.
   void set_perspective(Perspective perspective) {
     writer()->set_perspective(perspective);
     QuicConnectionPeer::SetPerspective(this, perspective);
     QuicSentPacketManagerPeer::SetPerspective(
         QuicConnectionPeer::GetSentPacketManager(this), perspective);
+    QuicConnectionPeer::GetFramer(this)->SetInitialObfuscators(
+        TestConnectionId());
+    for (EncryptionLevel level : {ENCRYPTION_ZERO_RTT, ENCRYPTION_HANDSHAKE,
+                                  ENCRYPTION_FORWARD_SECURE}) {
+      if (QuicConnectionPeer::GetFramer(this)->HasEncrypterOfEncryptionLevel(
+              level)) {
+        SetEncrypter(level, std::make_unique<NullEncrypter>(perspective));
+      }
+      if (QuicConnectionPeer::GetFramer(this)->HasDecrypterOfEncryptionLevel(
+              level)) {
+        InstallDecrypter(level, std::make_unique<NullDecrypter>(perspective));
+      }
+    }
   }
 
   // Enable path MTU discovery.  Assumes that the test is performed from the
@@ -575,7 +590,8 @@
         peer_creator_(connection_id_,
                       &peer_framer_,
                       /*delegate=*/nullptr),
-        writer_(new TestPacketWriter(version(), &clock_)),
+        writer_(
+            new TestPacketWriter(version(), &clock_, Perspective::IS_CLIENT)),
         connection_(connection_id_,
                     kPeerAddress,
                     helper_.get(),
@@ -1251,6 +1267,14 @@
     }
     QuicFramerPeer::SetPerspective(&peer_framer_,
                                    QuicUtils::InvertPerspective(perspective));
+    peer_framer_.SetInitialObfuscators(TestConnectionId());
+    for (EncryptionLevel level : {ENCRYPTION_ZERO_RTT, ENCRYPTION_HANDSHAKE,
+                                  ENCRYPTION_FORWARD_SECURE}) {
+      if (peer_framer_.HasEncrypterOfEncryptionLevel(level)) {
+        peer_creator_.SetEncrypter(
+            level, std::make_unique<NullEncrypter>(peer_framer_.perspective()));
+      }
+    }
   }
 
   void set_packets_between_probes_base(
@@ -6392,7 +6416,7 @@
 
 TEST_P(QuicConnectionTest, WriteBlockedAfterClientSendsConnectivityProbe) {
   PathProbeTestInit(Perspective::IS_CLIENT);
-  TestPacketWriter probing_writer(version(), &clock_);
+  TestPacketWriter probing_writer(version(), &clock_, Perspective::IS_CLIENT);
   // Block next write so that sending connectivity probe will encounter a
   // blocked write when send a connectivity probe to the peer.
   probing_writer.BlockOnNextWrite();
@@ -6424,7 +6448,7 @@
 
 TEST_P(QuicConnectionTest, WriterErrorWhenClientSendsConnectivityProbe) {
   PathProbeTestInit(Perspective::IS_CLIENT);
-  TestPacketWriter probing_writer(version(), &clock_);
+  TestPacketWriter probing_writer(version(), &clock_, Perspective::IS_CLIENT);
   probing_writer.SetShouldWriteFail();
 
   // Connection should not be closed if a connectivity probe is failed to be
@@ -8447,7 +8471,7 @@
 
   // Simulate path degrading handling by sending a probe on an alternet path.
   clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
-  TestPacketWriter probing_writer(version(), &clock_);
+  TestPacketWriter probing_writer(version(), &clock_, Perspective::IS_CLIENT);
   connection_.SendConnectivityProbingPacket(&probing_writer,
                                             connection_.peer_address());
   // Verify that path degrading detection is not reset.
diff --git a/quic/test_tools/quic_test_utils.cc b/quic/test_tools/quic_test_utils.cc
index 5aa2a7a..ed7dc75 100644
--- a/quic/test_tools/quic_test_utils.cc
+++ b/quic/test_tools/quic_test_utils.cc
@@ -1363,9 +1363,12 @@
   return true;
 }
 
-TestPacketWriter::TestPacketWriter(ParsedQuicVersion version, MockClock* clock)
+TestPacketWriter::TestPacketWriter(ParsedQuicVersion version,
+                                   MockClock* clock,
+                                   Perspective perspective)
     : version_(version),
-      framer_(SupportedVersions(version_), Perspective::IS_SERVER),
+      framer_(SupportedVersions(version_),
+              QuicUtils::InvertPerspective(perspective)),
       clock_(clock) {
   QuicFramerPeer::SetLastSerializedServerConnectionId(framer_.framer(),
                                                       TestConnectionId());
@@ -1427,11 +1430,18 @@
     }
   } else if (framer_.framer()->version().KnowsWhichDecrypterToUse()) {
     framer_.framer()->InstallDecrypter(
+        ENCRYPTION_HANDSHAKE,
+        std::make_unique<NullDecrypter>(framer_.framer()->perspective()));
+    framer_.framer()->InstallDecrypter(
+        ENCRYPTION_ZERO_RTT,
+        std::make_unique<NullDecrypter>(framer_.framer()->perspective()));
+    framer_.framer()->InstallDecrypter(
         ENCRYPTION_FORWARD_SECURE,
-        std::make_unique<NullDecrypter>(Perspective::IS_SERVER));
+        std::make_unique<NullDecrypter>(framer_.framer()->perspective()));
   }
   EXPECT_TRUE(framer_.ProcessPacket(packet))
-      << framer_.framer()->detailed_error();
+      << framer_.framer()->detailed_error() << " perspective "
+      << framer_.framer()->perspective();
   if (block_on_next_write_) {
     write_blocked_ = true;
     block_on_next_write_ = false;
diff --git a/quic/test_tools/quic_test_utils.h b/quic/test_tools/quic_test_utils.h
index e207a56..457663e 100644
--- a/quic/test_tools/quic_test_utils.h
+++ b/quic/test_tools/quic_test_utils.h
@@ -1878,7 +1878,10 @@
   };
 
  public:
-  TestPacketWriter(ParsedQuicVersion version, MockClock* clock);
+  TestPacketWriter(ParsedQuicVersion version,
+                   MockClock* clock,
+                   Perspective perspective);
+
   TestPacketWriter(const TestPacketWriter&) = delete;
   TestPacketWriter& operator=(const TestPacketWriter&) = delete;
 
@@ -2006,6 +2009,7 @@
     // we send.
     QuicFramerPeer::SetPerspective(framer_.framer(),
                                    QuicUtils::InvertPerspective(perspective));
+    framer_.framer()->SetInitialObfuscators(TestConnectionId());
   }
 
   // final_bytes_of_last_packet_ returns the last four bytes of the previous