diff --git a/tests/unit/net/http_loader.rs b/tests/unit/net/http_loader.rs
index e7b2055fa3c..b7a679b46eb 100644
--- a/tests/unit/net/http_loader.rs
+++ b/tests/unit/net/http_loader.rs
@@ -132,18 +132,6 @@ impl HttpResponse for MockResponse {
     fn status_raw(&self) -> &RawStatus { &self.sr }
 }
 
-fn redirect_to(host: String) -> MockResponse {
-    let mut headers = Headers::new();
-    headers.set(Location(host.to_owned()));
-
-    MockResponse::new(
-        headers,
-        StatusCode::MovedPermanently,
-        RawStatus(301, Cow::Borrowed("Moved Permanently")),
-        b"".to_vec()
-    )
-}
-
 struct TestProvider {
     username: String,
     password: String,
@@ -191,7 +179,6 @@ fn respond_404() -> MockResponse {
 }
 
 enum ResponseType {
-    Redirect(String),
     RedirectWithHeaders(String, Headers),
     Text(Vec<u8>),
     WithHeaders(Vec<u8>, Headers),
@@ -211,9 +198,6 @@ impl MockRequest {
 
 fn response_for_request_type(t: ResponseType) -> Result<MockResponse, LoadError> {
     match t {
-        ResponseType::Redirect(location) => {
-            Ok(redirect_to(location))
-        },
         ResponseType::RedirectWithHeaders(location, headers) => {
             Ok(redirect_with_headers(location, headers))
         },
@@ -1260,41 +1244,38 @@ fn test_load_succeeds_with_a_redirect_loop() {
 
 #[test]
 fn test_load_follows_a_redirect() {
-    struct Factory;
+    let post_handler = move |request: HyperRequest, response: HyperResponse| {
+        assert_eq!(request.method, Method::Get);
+        response.send(b"Yay!").unwrap();
+    };
+    let (mut post_server, post_url) = make_server(post_handler);
 
-    impl HttpRequestFactory for Factory {
-        type R = MockRequest;
+    let post_redirect_url = post_url.clone();
+    let pre_handler = move |request: HyperRequest, mut response: HyperResponse| {
+        assert_eq!(request.method, Method::Get);
+        response.headers_mut().set(Location(post_redirect_url.to_string()));
+        *response.status_mut() = StatusCode::MovedPermanently;
+        response.send(b"").unwrap();
+    };
+    let (mut pre_server, pre_url) = make_server(pre_handler);
 
-        fn create(&self, url: ServoUrl, _: Method, _: Headers) -> Result<MockRequest, LoadError> {
-            if url.domain().unwrap() == "mozilla.com" {
-                Ok(MockRequest::new(ResponseType::Redirect("http://mozilla.org".to_owned())))
-            } else if url.domain().unwrap() == "mozilla.org" {
-                Ok(
-                    MockRequest::new(
-                        ResponseType::Text(
-                            <[_]>::to_vec("Yay!".as_bytes())
-                        )
-                    )
-                )
-            } else {
-                panic!("unexpected host {:?}", url)
-            }
-        }
-    }
+    let request = Request::from_init(RequestInit {
+        url: pre_url.clone(),
+        method: Method::Get,
+        destination: Destination::Document,
+        origin: pre_url.clone(),
+        pipeline_id: Some(TEST_PIPELINE_ID),
+        .. RequestInit::default()
+    });
+    let response = fetch_sync(request, None);
 
-    let url = ServoUrl::parse("http://mozilla.com").unwrap();
-    let load_data = LoadData::new(LoadContext::Browsing, url.clone(), &HttpTest);
-    let http_state = HttpState::new();
-    let ui_provider = TestProvider::new();
+    let _ = pre_server.close();
+    let _ = post_server.close();
 
-    match load(&load_data, &ui_provider, &http_state, None, &Factory,
-               DEFAULT_USER_AGENT.into(), &CancellationListener::new(None), None) {
-        Err(e) => panic!("expected to follow a redirect {:?}", e),
-        Ok(mut lr) => {
-            let response = read_response(&mut lr);
-            assert_eq!(response, "Yay!".to_owned());
-        }
-    }
+    let response = response.to_actual();
+    assert!(response.status.unwrap().is_success());
+    assert_eq!(*response.body.lock().unwrap(),
+               ResponseBody::Done(b"Yay!".to_vec()));
 }
 
 struct DontConnectFactory;