diff --git a/src/commands/open.rs b/src/commands/open.rs
index 6074b837e..92e53c906 100644
--- a/src/commands/open.rs
+++ b/src/commands/open.rs
@@ -67,41 +67,53 @@ pub fn fetch(
     if location.starts_with("http:") || location.starts_with("https:") {
         let response = reqwest::get(location);
         match response {
-            Ok(mut r) => match r.text() {
-                Ok(s) => {
-                    let path_extension = r
-                        .url()
-                        .path_segments()
-                        .and_then(|segments| segments.last())
-                        .and_then(|name| if name.is_empty() { None } else { Some(name) })
-                        .and_then(|name| {
-                            PathBuf::from(name)
-                                .extension()
-                                .map(|name| name.to_string_lossy().to_string())
-                        });
-
-                    let extension = match r.headers().get("content-type") {
-                        Some(content_type) => {
-                            let content_type =
-                                Mime::from_str(content_type.to_str().unwrap()).unwrap();
-                            match (content_type.type_(), content_type.subtype()) {
-                                (mime::APPLICATION, mime::XML) => Some("xml".to_string()),
-                                (mime::APPLICATION, mime::JSON) => Some("json".to_string()),
-                                _ => path_extension,
-                            }
+            Ok(mut r) => match r.headers().get("content-type") {
+                Some(content_type) => {
+                    let content_type = Mime::from_str(content_type.to_str().unwrap()).unwrap();
+                    match (content_type.type_(), content_type.subtype()) {
+                        (mime::APPLICATION, mime::XML) => Ok((
+                            Some("xml".to_string()),
+                            Value::string(r.text().unwrap()),
+                            span,
+                        )),
+                        (mime::APPLICATION, mime::JSON) => Ok((
+                            Some("json".to_string()),
+                            Value::string(r.text().unwrap()),
+                            span,
+                        )),
+                        (mime::IMAGE, image_ty) => {
+                            let mut buf: Vec<u8> = vec![];
+                            r.copy_to(&mut buf).map_err(|_| {
+                                ShellError::labeled_error(
+                                    "Could not load image file",
+                                    "could not load",
+                                    span,
+                                )
+                            })?;
+                            Ok((Some(image_ty.to_string()), Value::Binary(buf), span))
                         }
-                        None => path_extension,
-                    };
+                        (mime::TEXT, mime::PLAIN) => {
+                            let path_extension = r
+                                .url()
+                                .path_segments()
+                                .and_then(|segments| segments.last())
+                                .and_then(|name| if name.is_empty() { None } else { Some(name) })
+                                .and_then(|name| {
+                                    PathBuf::from(name)
+                                        .extension()
+                                        .map(|name| name.to_string_lossy().to_string())
+                                });
 
-                    Ok((extension, Value::string(s), span))
-                }
-                Err(_) => {
-                    return Err(ShellError::labeled_error(
-                        "Web page contents corrupt",
-                        "received garbled data",
-                        span,
-                    ));
+                            Ok((path_extension, Value::string(r.text().unwrap()), span))
+                        }
+                        (ty, sub_ty) => Ok((
+                            None,
+                            Value::string(format!("Not yet support MIME type: {} {}", ty, sub_ty)),
+                            span,
+                        )),
+                    }
                 }
+                None => Ok((None, Value::string(format!("No content type found")), span)),
             },
             Err(_) => {
                 return Err(ShellError::labeled_error(
diff --git a/tests/helpers/mod.rs b/tests/helpers/mod.rs
index 9af9b8ac1..d0ec5839b 100644
--- a/tests/helpers/mod.rs
+++ b/tests/helpers/mod.rs
@@ -1,25 +1,27 @@
 use std::path::PathBuf;
 
-#[macro_export] 
+#[macro_export]
 macro_rules! nu {
     ($out:ident, $cwd:expr, $commands:expr) => {
         use std::error::Error;
         use std::io::prelude::*;
         use std::process::{Command, Stdio};
 
-        let commands = &*format!("
+        let commands = &*format!(
+            "
                             cd {}
                             {}
-                            exit", 
-                            $cwd, 
-                            $commands);
+                            exit",
+            $cwd, $commands
+        );
 
         let process = match Command::new(helpers::executable_path())
             .stdin(Stdio::piped())
             .stdout(Stdio::piped())
-            .spawn() {
-                Ok(child) => child,
-                Err(why) => panic!("Can't run test {}", why.description()),
+            .spawn()
+        {
+            Ok(child) => child,
+            Err(why) => panic!("Can't run test {}", why.description()),
         };
 
         match process.stdin.unwrap().write_all(commands.as_bytes()) {
@@ -31,7 +33,7 @@ macro_rules! nu {
 
         match process.stdout.unwrap().read_to_string(&mut _s) {
             Err(why) => panic!("couldn't read stdout: {}", why.description()),
-            Ok(_) => { 
+            Ok(_) => {
                 let _s = _s.replace("\r\n", "\n");
             }
         }
@@ -41,19 +43,19 @@ macro_rules! nu {
     };
 }
 
-#[macro_export] 
+#[macro_export]
 macro_rules! nu_error {
     ($out:ident, $cwd:expr, $commands:expr) => {
-        use std::error::Error;
         use std::io::prelude::*;
         use std::process::{Command, Stdio};
 
-        let commands = &*format!("
+        let commands = &*format!(
+            "
                             cd {}
                             {}
-                            exit", 
-                            $cwd, 
-                            $commands);
+                            exit",
+            $cwd, $commands
+        );
 
         let mut process = Command::new(helpers::executable_path())
             .stdin(Stdio::piped())
@@ -62,20 +64,23 @@ macro_rules! nu_error {
             .expect("couldn't run test");
 
         let stdin = process.stdin.as_mut().expect("couldn't open stdin");
-        stdin.write_all(commands.as_bytes()).expect("couldn't write to stdin");
+        stdin
+            .write_all(commands.as_bytes())
+            .expect("couldn't write to stdin");
 
-
-        let output = process.wait_with_output().expect("couldn't read from stderr");
+        let output = process
+            .wait_with_output()
+            .expect("couldn't read from stderr");
         let $out = String::from_utf8_lossy(&output.stderr);
     };
 }
 
 pub fn executable_path() -> PathBuf {
     let mut buf = PathBuf::new();
-        buf.push("target");
-        buf.push("debug");
-        buf.push("nu");
-        buf
+    buf.push("target");
+    buf.push("debug");
+    buf.push("nu");
+    buf
 }
 
 pub fn in_directory(str: &str) -> &str {