diff --git a/libweave/Android.mk b/libweave/Android.mk
index 215e13f..ac1185d 100644
--- a/libweave/Android.mk
+++ b/libweave/Android.mk
@@ -147,6 +147,7 @@
 LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
 
 LOCAL_SRC_FILES := \
+	src/test/fake_stream.cc \
 	src/test/mock_command.cc \
 	src/test/mock_http_client.cc \
 	src/test/mock_task_runner.cc \
diff --git a/libweave/include/weave/test/fake_stream.h b/libweave/include/weave/test/fake_stream.h
new file mode 100644
index 0000000..3c21571
--- /dev/null
+++ b/libweave/include/weave/test/fake_stream.h
@@ -0,0 +1,48 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIBWEAVE_INCLUDE_WEAVE_TEST_FAKE_STREAM_H_
+#define LIBWEAVE_INCLUDE_WEAVE_TEST_FAKE_STREAM_H_
+
+#include <weave/stream.h>
+
+#include <string>
+
+#include <base/time/time.h>
+#include <gmock/gmock.h>
+
+namespace weave {
+
+class TaskRunner;
+
+namespace test {
+
+class FakeStream : public Stream {
+ public:
+  explicit FakeStream(TaskRunner* task_runner);
+  FakeStream(TaskRunner* task_runner, const std::string& read_data);
+
+  void ExpectWritePacketString(base::TimeDelta, const std::string& data);
+  void AddReadPacketString(base::TimeDelta, const std::string& data);
+
+  void CancelPendingOperations() override;
+  void Read(void* buffer,
+            size_t size_to_read,
+            const ReadSuccessCallback& success_callback,
+            const ErrorCallback& error_callback) override;
+  void Write(const void* buffer,
+             size_t size_to_write,
+             const SuccessCallback& success_callback,
+             const ErrorCallback& error_callback) override;
+
+ private:
+  TaskRunner* task_runner_{nullptr};
+  std::string write_data_;
+  std::string read_data_;
+};
+
+}  // namespace test
+}  // namespace weave
+
+#endif  // LIBWEAVE_INCLUDE_WEAVE_TEST_FAKE_STREAM_H_
diff --git a/libweave/libweave.gypi b/libweave/libweave.gypi
index 3eb64f3..544e127 100644
--- a/libweave/libweave.gypi
+++ b/libweave/libweave.gypi
@@ -53,6 +53,7 @@
       'third_party/modp_b64/modp_b64.cc',
     ],
     'weave_test_sources': [
+      'src/test/fake_stream.cc',
       'src/test/mock_command.cc',
       'src/test/mock_http_client.cc',
       'src/test/mock_task_runner.cc',
diff --git a/libweave/src/notification/xmpp_channel_unittest.cc b/libweave/src/notification/xmpp_channel_unittest.cc
index da555e0..a6992e9 100644
--- a/libweave/src/notification/xmpp_channel_unittest.cc
+++ b/libweave/src/notification/xmpp_channel_unittest.cc
@@ -8,6 +8,7 @@
 #include <queue>
 
 #include <gtest/gtest.h>
+#include <weave/test/fake_stream.h>
 #include <weave/test/mock_network_provider.h>
 #include <weave/test/mock_task_runner.h>
 
@@ -79,64 +80,12 @@
 
 }  // namespace
 
-class FakeStream : public Stream {
- public:
-  explicit FakeStream(TaskRunner* task_runner) : task_runner_{task_runner} {}
-
-  void CancelPendingOperations() override {}
-
-  void ExpectWritePacketString(base::TimeDelta, const std::string& data) {
-    write_data_ += data;
-  }
-
-  void AddReadPacketString(base::TimeDelta, const std::string& data) {
-    read_data_ += data;
-  }
-
-  void Read(void* buffer,
-            size_t size_to_read,
-            const ReadSuccessCallback& success_callback,
-            const ErrorCallback& error_callback) override {
-    if (read_data_.empty()) {
-      task_runner_->PostDelayedTask(
-          FROM_HERE,
-          base::Bind(&FakeStream::Read, base::Unretained(this), buffer,
-                     size_to_read, success_callback, error_callback),
-          base::TimeDelta::FromSeconds(0));
-      return;
-    }
-    size_t size = std::min(size_to_read, read_data_.size());
-    memcpy(buffer, read_data_.data(), size);
-    read_data_ = read_data_.substr(size);
-    task_runner_->PostDelayedTask(FROM_HERE, base::Bind(success_callback, size),
-                                  base::TimeDelta::FromSeconds(0));
-  }
-
-  void Write(const void* buffer,
-             size_t size_to_write,
-             const SuccessCallback& success_callback,
-             const ErrorCallback& error_callback) override {
-    size_t size = std::min(size_to_write, write_data_.size());
-    EXPECT_EQ(
-        write_data_.substr(0, size),
-        std::string(reinterpret_cast<const char*>(buffer), size_to_write));
-    write_data_ = write_data_.substr(size);
-    task_runner_->PostDelayedTask(FROM_HERE, success_callback,
-                                  base::TimeDelta::FromSeconds(0));
-  }
-
- private:
-  TaskRunner* task_runner_{nullptr};
-  std::string write_data_;
-  std::string read_data_;
-};
-
 class FakeXmppChannel : public XmppChannel {
  public:
   explicit FakeXmppChannel(TaskRunner* task_runner,
                            weave::NetworkProvider* network)
       : XmppChannel{kAccountName, kAccessToken, task_runner, network},
-        stream_{new FakeStream{task_runner_}},
+        stream_{new test::FakeStream{task_runner_}},
         fake_stream_{stream_.get()} {}
 
   void Connect(
@@ -158,8 +107,8 @@
     fake_stream_->AddReadPacketString(delta, data);
   }
 
-  std::unique_ptr<FakeStream> stream_;
-  FakeStream* fake_stream_{nullptr};
+  std::unique_ptr<test::FakeStream> stream_;
+  test::FakeStream* fake_stream_{nullptr};
 };
 
 class MockNetworkProvider : public weave::test::MockNetworkProvider {
diff --git a/libweave/src/test/fake_stream.cc b/libweave/src/test/fake_stream.cc
new file mode 100644
index 0000000..5adf462
--- /dev/null
+++ b/libweave/src/test/fake_stream.cc
@@ -0,0 +1,62 @@
+// Copyright 2015 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <weave/test/fake_stream.h>
+
+#include <base/bind.h>
+#include <gtest/gtest.h>
+#include <weave/task_runner.h>
+
+namespace weave {
+namespace test {
+
+FakeStream::FakeStream(TaskRunner* task_runner) : task_runner_{task_runner} {}
+FakeStream::FakeStream(TaskRunner* task_runner, const std::string& read_data)
+    : task_runner_{task_runner}, read_data_{read_data} {}
+
+void FakeStream::CancelPendingOperations() {}
+
+void FakeStream::ExpectWritePacketString(base::TimeDelta,
+                                         const std::string& data) {
+  write_data_ += data;
+}
+
+void FakeStream::AddReadPacketString(base::TimeDelta, const std::string& data) {
+  read_data_ += data;
+}
+
+void FakeStream::Read(void* buffer,
+                      size_t size_to_read,
+                      const ReadSuccessCallback& success_callback,
+                      const ErrorCallback& error_callback) {
+  if (read_data_.empty()) {
+    task_runner_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&FakeStream::Read, base::Unretained(this), buffer,
+                    size_to_read, success_callback, error_callback),
+        base::TimeDelta::FromSeconds(0));
+    return;
+  }
+  size_t size = std::min(size_to_read, read_data_.size());
+  memcpy(buffer, read_data_.data(), size);
+  read_data_ = read_data_.substr(size);
+  task_runner_->PostDelayedTask(FROM_HERE, base::Bind(success_callback, size),
+                                base::TimeDelta::FromSeconds(0));
+}
+
+void FakeStream::Write(const void* buffer,
+                       size_t size_to_write,
+                       const SuccessCallback& success_callback,
+                       const ErrorCallback& error_callback) {
+  size_t size = std::min(size_to_write, write_data_.size());
+  EXPECT_EQ(
+      write_data_.substr(0, size),
+      std::string(reinterpret_cast<const char*>(buffer), size_to_write));
+  write_data_ = write_data_.substr(size);
+  task_runner_->PostDelayedTask(FROM_HERE, success_callback,
+                                base::TimeDelta::FromSeconds(0));
+}
+
+}  // namespace test
+}  // namespace weave