diff --git a/lib/facebook.ex b/lib/facebook.ex
index bb28a6d..1559de9 100644
--- a/lib/facebook.ex
+++ b/lib/facebook.ex
@@ -30,7 +30,7 @@ defmodule Facebook do
 
   @type fields :: list
   @type access_token :: String.t
-  @type response :: {:json, HashDict.t} | {:body, String.t}
+  @type response :: {:ok, Map.t} | {:error, Map.t}
   @type using_appsecret :: boolean
   @type reaction :: :reaction
 
@@ -38,11 +38,11 @@ defmodule Facebook do
   If you want to use an appsecret proof, pass it into set_appsecret:
 
   ## Example
-      iex> Facebook.setAppsecret("appsecret")
+      iex> Facebook.set_appsecret("appsecret")
 
   See: https://developers.facebook.com/docs/graph-api/securing-requests
   """
-  def setAppsecret(appsecret) do
+  def set_appsecret(appsecret) do
     Config.appsecret(appsecret)
   end
 
@@ -50,7 +50,8 @@ defmodule Facebook do
   Basic user infos of the logged in user (specified by the access_token).
 
   ## Example
-      iex> Facebook.me("id,first_name", "<Your Token>")
+      iex> Facebook.me("id,first_name", "<Access Token>")
+      {:ok, %{"first_name" => "...", "id" => "..."}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/user/
   """
@@ -63,7 +64,8 @@ defmodule Facebook do
   Basic user infos of the logged in user (specified by the access_token).
 
   ## Example
-      iex> Facebook.me([fields: "id,first_name"], "<Your Token>")
+      iex> Facebook.me([fields: "id,first_name"], "<Access Token>")
+      {:ok, %{"first_name" => "...", "id" => "..."}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/user/
   """
@@ -91,9 +93,11 @@ defmodule Facebook do
   ## Examples
       iex> # publish a message
       iex> Facebook.publish(:feed, "<Feed Id>", [message: "<Message Body"], "<Access Token>")
+      {:ok, %{"id" => "{page_id}_{post_id}"}}
 
       iex> # publish a link and message
       iex> Facebook.publish(:feed, "<Feed Id>", [message: "<Message Body", link: "www.example.com"], "<Access Token>")
+      {:ok, %{"id" => "{page_id}_{post_id}"}}
 
   """
   @spec publish(:feed, feed_id :: String.t, fields, access_token) :: response
@@ -111,11 +115,12 @@ defmodule Facebook do
 
   ## Example
       iex> Facebook.publish(:photo, "<Feed Id>", "<Image Path>", [], "<Access Token>")
-      {:json, %{"id" => "..."}}
+      {:ok, %{"id" => photo_id, "post_id" => "{page_id}_{post_id}"}
 
       iex> Facebook.publish(:video, "<Feed Id>", "<Video Path>", [], "<Access Token>")
-      {:json, %{"id" => "..."}}
+      {:ok, %{"id" => video_id}
 
+  See: https://developers.facebook.com/docs/pages/publishing#fotos_videos
   """
   @spec publish(:photo, page_id :: String.t, file_path :: String.t, fields, access_token) :: response
   def publish(:photo, page_id, file_path, fields, access_token) do
@@ -139,7 +144,8 @@ defmodule Facebook do
   A Picture for a Facebook User
 
   ## Example
-      iex> Facebook.picture("<Some Id>", "small", "<Your Token>")
+      iex> Facebook.picture("<Some Id>", "small", "<Access Token>")
+      {:ok, %{"data": "..."}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/user/picture/
   """
@@ -155,12 +161,13 @@ defmodule Facebook do
   Likes of the currently logged in user (specified by the access_token)
 
   ## Example
-      iex> Facebook.myLikes("<Your Token>")
+      iex> Facebook.my_likes("<Access Token>")
+      {:ok, %{"data" => [...]}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/user/likes
   """
-  @spec myLikes(access_token) :: response
-  def myLikes(access_token) do
+  @spec my_likes(access_token) :: response
+  def my_likes(access_token) do
     fields = [access_token: access_token]
       |> add_app_secret(access_token)
 
@@ -171,7 +178,8 @@ defmodule Facebook do
   Retrieves a list of granted permissions
 
   ## Example
-      iex> Facebook.permissions("<Some Id>", "<Your Token>")
+      iex> Facebook.permissions("<Some Id>", "<Access Token>")
+      {:ok, %{"data" => [%{"permission" => "...", "status" => "..."}]}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/user/permissions
   """
@@ -186,36 +194,22 @@ defmodule Facebook do
   Get the count of fans for the provided page_id
 
   ## Example
-      iex> Facebook.fanCount("CocaColaMx", "<Your Token>")
+      iex> Facebook.fan_count("CocaColaMx", "<Access Token>")
+      {:ok, %{"fan_count" => fan_count, "id" => id}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/page/
   """
-  @spec fanCount(page_id :: integer | String.t, access_token) :: integer
-  def fanCount(page_id, access_token) do
-    {:json, %{"fan_count" => fanCount}} = page(page_id, access_token, ["fan_count"])
-    fanCount
-  end
-
-  @doc """
-  *Deprecated:* Please use fanCount instead.
-
-  Get the count of fans for the provided page_id
-
-  ## Example
-      iex> Facebook.pageLikes("CocaColaMx", "<Your Token>")
-
-  See: https://developers.facebook.com/docs/graph-api/reference/page/
-  """
-  @spec pageLikes(page_id :: integer | String.t, access_token) :: integer
-  def pageLikes(page_id, access_token) do
-    fanCount(page_id, access_token)
+  @spec fan_count(page_id :: integer | String.t, access_token) :: integer
+  def fan_count(page_id, access_token) do
+    page(page_id, access_token, ["fan_count"])
   end
 
   @doc """
   Basic page information for the provided page_id
 
   ## Example
-      iex> Facebook.page("CocaColaMx", "<Your Token>")
+      iex> Facebook.page("CocaColaMx", "<Access Token>")
+      {:ok, %{"id" => id, "name" => name}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/page
   """
@@ -228,7 +222,8 @@ defmodule Facebook do
   Get page information for the specified fields for the provided page_id
 
   ## Example
-      iex> Facebook.page("CocaColaMx", "<Your Token>", "id")
+      iex> Facebook.page("CocaColaMx", "<Access Token>", "id")
+      {:ok, %{"id" => id}
 
   See: https://developers.facebook.com/docs/graph-api/reference/page
   """
@@ -255,21 +250,20 @@ defmodule Facebook do
   100.*
 
   ## Examples
-      iex> Facebook.pageFeed(:posts, "CocaColaMx", "<Your Token>")
-      iex> Facebook.pageFeed(:tagged, "CocaColaMx", "<Your Token>", 55)
-      iex> Facebook.pageFeed(:promotable_posts, "CocaColaMx", "<Your Token>")
-      iex> Facebook.pageFeed(:feed, "CocaColaMx", "<Your Token>", 55, "id,name")
+      iex> Facebook.page_feed(:posts, "CocaColaMx", "<Access Token>")
+      iex> Facebook.page_feed(:tagged, "CocaColaMx", "<Access Token>", 55)
+      iex> Facebook.page_feed(:promotable_posts, "CocaColaMx", "<Access Token>")
+      iex> Facebook.page_feed(:feed, "CocaColaMx", "<Access Token>", 55, "id,name")
+      {:ok, %{"data" => [...]}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/page/feed
   """
-  @spec pageFeed(scope :: atom | String.t, page_id :: String.t, access_token, limit :: number, fields :: String.t) :: Map.t
-  def pageFeed(scope, page_id, access_token, limit \\ 25, fields \\ "") when limit <= 100 do
+  @spec page_feed(scope :: atom | String.t, page_id :: String.t, access_token, limit :: number, fields :: String.t) :: response
+  def page_feed(scope, page_id, access_token, limit \\ 25, fields \\ "") when limit <= 100 do
     params = [access_token: access_token, limit: limit, fields: fields]
       |> add_app_secret(access_token)
 
-    {_, content} = Facebook.Graph.get(~s(/#{page_id}/#{scope}), params)
-
-    content
+    Facebook.Graph.get(~s(/#{page_id}/#{scope}), params)
   end
 
   @doc """
@@ -277,23 +271,23 @@ defmodule Facebook do
 
   An *object* stands for: post, comment, link, status update, photo.
 
-  If you want to get the likes of a page, please see *fanCount*.
+  If you want to get the likes of a page, please see *fan_count*.
 
   Expected scopes:
     * :likes
     * :comments
 
   ## Example
-      iex> Facebook.objectCount(:likes, "1326382730725053_1326476257382367", "<Token>")
-      2
-      iex> Facebook.objectCount(:comments, "1326382730725053_1326476257382367", "<Token>")
-      2
+      iex> Facebook.object_count(:likes, "1326382730725053_1326476257382367", "<Access Token>")
+      {:ok, 10}
+      iex> Facebook.object_count(:comments, "1326382730725053_1326476257382367", "<Access Token>")
+      {:ok, 5}
 
   See: https://developers.facebook.com/docs/graph-api/reference/object/likes
   See: https://developers.facebook.com/docs/graph-api/reference/object/comments
   """
-  @spec objectCount(scope :: atom, object_id :: String.t, access_token) :: number
-  def objectCount(scope, object_id, access_token) when is_atom(scope) do
+  @spec object_count(scope :: atom, object_id :: String.t, access_token) :: {:ok, number} | {:error, Map.t}
+  def object_count(scope, object_id, access_token) when is_atom(scope) do
     params = [access_token: access_token, summary: true]
       |> add_app_secret(access_token)
 
@@ -302,8 +296,8 @@ defmodule Facebook do
       |> String.downcase
 
     Facebook.Graph.get(~s(/#{object_id}/#{scp}), params)
-      |> getSummary
-      |> summaryCount
+      |> get_summary
+      |> summary_count
   end
 
   @doc """
@@ -319,15 +313,15 @@ defmodule Facebook do
     * :none
 
   ## Examples
-      iex> Facebook.objectCount(:reaction, :wow, "769860109692136_1173416799336463", "<Token>")
-      2
-      iex> Facebook.objectCount(:reaction, :haha, "769860109692136_1173416799336463", "<Token>")
-      12
-      iex> Facebook.objectCount(:reaction, :thankful, "769860109692136_1173416799336463", "<Token>")
-      33
+      iex> Facebook.object_count(:reaction, :wow, "769860109692136_1173416799336463", "<Access Token>")
+      {:ok, 100}
+      iex> Facebook.object_count(:reaction, :haha, "769860109692136_1173416799336463", "<Access Token>")
+      {:ok, 100}
+      iex> Facebook.object_count(:reaction, :thankful, "769860109692136_1173416799336463", "<Access Token>")
+      {:ok, 100}
   """
-  @spec objectCount(reaction, react_type :: atom, object_id :: String.t, access_token) :: number
-  def objectCount(:reaction, react_type, object_id, access_token) when is_atom(react_type) do
+  @spec object_count(reaction, react_type :: atom, object_id :: String.t, access_token) :: {:ok, number} | {:error, Map.t}
+  def object_count(:reaction, react_type, object_id, access_token) when is_atom(react_type) do
     type = react_type
       |> Atom.to_string
       |> String.upcase
@@ -336,19 +330,19 @@ defmodule Facebook do
       |> add_app_secret(access_token)
 
     Facebook.Graph.get(~s(/#{object_id}/reactions), params)
-      |> getSummary
-      |> summaryCount
+      |> get_summary
+      |> summary_count
   end
 
   @doc """
   Get all the object reactions with single request.
 
   ## Examples
-      iex> Facebook.objectCountAll("769860109692136_1173416799336463", "<Token>")
-      %{"angry" => 0, "haha" => 1, "like" => 0, "love" => 0, "sad" => 0, "wow" => 0}
+      iex> Facebook.object_count_all("769860109692136_1173416799336463", "<Access Token>")
+      {:ok, %{"angry" => 0, "haha" => 1, "like" => 0, "love" => 0, "sad" => 0, "wow" => 0}}
   """
-  @spec objectCountAll(object_id :: String.t, access_token) :: map
-  def objectCountAll(object_id, access_token) do
+  @spec object_count_all(object_id :: String.t, access_token) :: response
+  def object_count_all(object_id, access_token) do
     graph_query = """
     reactions.type(LIKE).summary(total_count).limit(0).as(like),
     reactions.type(LOVE).summary(total_count).limit(0).as(love),
@@ -362,51 +356,51 @@ defmodule Facebook do
       |> add_app_secret(access_token)
 
     Facebook.Graph.get(~s(/#{object_id}), params)
-      |> summaryCountAll
+      |> summary_count_all
   end
 
   @doc """
   Exchange an authorization code for an access token
 
   ## Examples
-      iex> Facebook.accessToken("client_id", "client_secret", "redirect_uri", "code")
-      %{
-        "access_token" => "ACCESS_TOKEN",
+      iex> Facebook.access_token("client_id", "client_secret", "redirect_uri", "code")
+      {:ok, %{
+        "access_token" => access_token,
         "expires_in" => 5183976,
         "token_type" => "bearer"
-      }
+      }}
 
   See: https://developers.facebook.com/docs/facebook-login/manually-build-a-login-flow#confirm
   """
-  @spec accessToken(String.t, String.t, String.t, String.t) :: String.t
-  def accessToken(client_id, client_secret, redirect_uri, code) do
+  @spec access_token(String.t, String.t, String.t, String.t) :: response
+  def access_token(client_id, client_secret, redirect_uri, code) do
     [ client_id: client_id,
       client_secret: client_secret,
       redirect_uri: redirect_uri,
       code: code ]
-      |> getAccessToken
+      |> get_access_token
   end
 
   @doc """
   Exchange a short lived access token for a long lived one
 
   ## Examples
-      iex> Facebook.longLivedAccessToken("client_id", "client_secret", "access_token")
-      %{
-        "access_token" => "ACCESS_TOKEN",
+      iex> Facebook.long_lived_access_token("client_id", "client_secret", "access_token")
+      {:ok, %{
+        "access_token" => access_token,
         "expires_in" => 5183976,
         "token_type" => "bearer"
-      }
+      }}
 
   See: https://developers.facebook.com/docs/facebook-login/access-tokens/expiration-and-extension
   """
-  @spec longLivedAccessToken(String.t, String.t, String.t) :: String.t
-  def longLivedAccessToken(client_id, client_secret, access_token) do
+  @spec long_lived_access_token(String.t, String.t, String.t) :: response
+  def long_lived_access_token(client_id, client_secret, access_token) do
     [ grant_type: "fb_exchange_token",
       client_id: client_id,
       client_secret: client_secret,
       fb_exchange_token: access_token ]
-      |> getAccessToken
+      |> get_access_token
   end
 
   @doc """
@@ -418,62 +412,59 @@ defmodule Facebook do
     - https://developers.facebook.com/docs/graph-api/reference/v2.8/app/accounts/test-users
 
   ## Examples
-    iex> Facebook.testUsers("appId", "appId|appSecret")
-    [
+    iex> Facebook.test_users("appId", "appId|appSecret")
+    {:ok, %{"data" => [
       %{
         "access_token" => "ACCESS_TOKEN",
         "id" => "USER_ID",
         "login_url" => "https://developers.facebook.com/checkpoint/test-user-login/USER_ID/"
       }
-    ]
+    ]}
   """
-  @spec testUsers(String.t, String.t) :: Map.t
-  def testUsers(app_id, access_token) do
-    case Facebook.Graph.get(~s(/#{app_id}/accounts/test-users), [access_token: access_token]) do
-      {:json, %{"error" => _} = error} -> error
-      {:json, %{"data" => data}} -> data
-    end
+  @spec test_users(String.t, String.t) :: response
+  def test_users(app_id, access_token) do
+    Facebook.Graph.get(
+      ~s(/#{app_id}/accounts/test-users),
+      [access_token: access_token]
+    )
   end
 
-  
+
   # Request access token and extract the access token from the access token
   # response
-  defp getAccessToken(params) do
-    case Facebook.Graph.get(~s(/oauth/access_token), params) do
-      {:json, %{"error" => error}} -> %{"error" => error}
-      {:json, %{"summary" => summary}} -> summary
-      {:json, info_map} -> info_map
-    end
+  defp get_access_token(params) do
+    Facebook.Graph.get(~s(/oauth/access_token), params)
   end
 
   # Provides the summary of a GET request when the 'summary' query parameter is
   # set to true.
-  defp getSummary(summary_response) do
+  defp get_summary(summary_response) do
     case summary_response do
-      {:json, %{"error" => error}} -> %{"error" => error}
-      {:json, %{"summary" => summary}} -> summary
+      {:error, error} -> {:error, error}
+      {:ok, %{"summary" => summary}} -> summary
     end
   end
 
   # Gets the 'total_count' attribute from a summary request.
-  defp summaryCount(%{"total_count" => count}), do: count
+  defp summary_count(%{"total_count" => count}), do: {:ok, count}
 
   # Returns an error if the summary request fails.
-  defp summaryCount(%{"error" => error}), do: %{"error" => error}
+  defp summary_count({:error, error}), do: {:error, error}
 
-  defp summaryCountAll({:json, data}), do: summaryCountAll(data)
+  defp summary_count_all({:ok, data}), do: summary_count_all(data)
 
   # Returns an error if the summary request fails.
-  defp summaryCountAll(%{"error" => error}), do: %{"error" => error}
+  defp summary_count_all({:error, error}), do: {:error, error}
 
   # Calculate the reactions summary
-  defp summaryCountAll(summary) do
+  defp summary_count_all(summary) do
     Map.keys(summary)
       |> Enum.reject(fn(x) -> x === "id" end)
       |> Enum.map(fn(x) ->
         [x, get_in(summary[x], ["summary", "total_count"])] end)
       |> Enum.reduce(%{}, fn([name, count], acc) ->
         Map.put(acc, name, count) end)
+      |> (& {:ok, &1}).()
   end
 
   # 'Encrypts' the token together with the app secret according to the guidelines of facebook.
diff --git a/lib/facebook/graph.ex b/lib/facebook/graph.ex
index 331e17a..97c7ce9 100644
--- a/lib/facebook/graph.ex
+++ b/lib/facebook/graph.ex
@@ -88,25 +88,26 @@ defmodule Facebook.Graph do
   """
   @spec request(method, url, payload, options) :: response
   def request(method, url, payload, options) do
-    headers = []
-    Logger.debug fn ->
-      "[#{method}] #{url} #{inspect headers} #{inspect payload}"
-    end
+    send_request(method, url, [], payload, options)
+      |> parse_response_body()
+      |> format_response_body()
+  end
+
+  def send_request(method, url, headers, payload, options) do
+    {:ok, _, _, client_ref} = :hackney.request(method, url, headers, payload, options)
+    :hackney.body(client_ref)
+  end
 
-    with {:ok, _status_code, _headers, client_ref} <- :hackney.request(method, url, headers, payload, options),
-	       {:ok, body} <- :hackney.body(client_ref) do
-      Logger.debug fn -> "body: #{inspect body}" end
-      case JSON.decode(body) do
-        {:ok, data} -> {:json, data}
-        _           -> {:body, body}
-      end
-    else
-      {:error, reason} ->
-        Logger.error fn -> "error: #{inspect reason}" end
-        reason
-      error ->
-        Logger.error fn -> "error: #{inspect error}"  end
-        error
-    end
+  defp parse_response_body({:ok, body}) do
+    JSON.decode(body)
+  end
+  defp parse_response_body({:error, error}), do: {:error, error}
+
+  defp format_response_body({:ok, %{"error" => error}}) do
+    {:error, error}
+  end
+  defp format_response_body({:ok, resp}) do
+    {:ok, resp}
   end
+  defp format_response_body({:error, error}), do: {:error, error}
 end
diff --git a/lib/facebook/stream.ex b/lib/facebook/stream.ex
index 8856338..da7657c 100644
--- a/lib/facebook/stream.ex
+++ b/lib/facebook/stream.ex
@@ -21,23 +21,23 @@ defmodule Facebook.Stream do
   The default error handler sleeps 1 second between retries.
 
   ## Examples
-  iex> stream = Facebook.pageFeed(:feed, "CocaColaMx", "<Your Token>", "id,name") |> Facebook.Stream.new
+  iex> stream = Facebook.page_feed(:feed, "CocaColaMx", "<Your Token>", "id,name") |> Facebook.Stream.new
   iex> stream |> Stream.filter(fn(name) -> name == "Coca Cola" end) |> Stream.take(100) |> Enum.to_list
 
   # Custom error handler with linear backoff
-  iex> feed = Facebook.pageFeed(:feed, "CocaColaMx", "<Your Token>", 25, "id,name")
+  iex> feed = Facebook.page_feed(:feed, "CocaColaMx", "<Your Token>", 25, "id,name")
   iex> stream = Facebook.Stream.new(feed, fn(error, retry) -> Process.sleep(retry*500) end)
   iex> stream |> Stream.filter(fn(name) -> name == "Coca Cola" end) |> Stream.take(100) |> Enum.to_list
   """
   @spec new(Map.t, ((error, retry) -> any), pos_integer) :: Enumerable.t
-  def new(paged_response,
+  def new({:ok, paged_response},
     error_handler \\ fn(_error, _retry) -> Process.sleep(1_000) end,
     max_retries \\ 3) do
     Stream.resource(
       fn -> %__MODULE__{next: paged_response, current: :empty, max_retries: max_retries} end,
-      fn(feed) -> case nextPage(feed, error_handler) do
+      fn(feed) -> case next_page(feed, error_handler) do
 		    %__MODULE__{current: nil   }   -> {:halt, nil} # no more data
-		    %__MODULE__{current: response} -> {getData(response), %{feed | current: response}} # normal pagination
+		    %__MODULE__{current: response} -> {get_data(response), %{feed | current: response}} # normal pagination
 		    {error, retries} -> # max retries reached
 		      error_handler.(error, retries)
 		      {:halt, error}
@@ -49,21 +49,21 @@ defmodule Facebook.Stream do
   end
 
   # Get next object using FB Graph API pagination
-  defp nextPage(%__MODULE__{current: :empty, next: next} = feed,
+  defp next_page(%__MODULE__{current: :empty, next: next} = feed,
     _error_handler) do
     %{feed | current: next, next: :empty}
   end
 
-  defp nextPage(%__MODULE__{current: current, max_retries: max_retries} = feed,
+  defp next_page(%__MODULE__{current: current, max_retries: max_retries} = feed,
     error_handler) do
     Stream.cycle([1])
     |> Stream.scan(0, &(&1+&2))
     |> Enum.reduce_while(feed, fn i, acc ->
       if i < max_retries do
-	case getNextPagedData(current) do
+	case get_next_paged_data(current) do
 	  {:error, reason}  -> error_handler.(reason, i); {:cont, reason}
-	  {:json, %{"error" => reason}} -> error_handler.(reason, i); {:cont, reason}
-	  {:json, next_obj} -> {:halt, %{feed | current: next_obj}}
+	  {:ok, %{"error" => reason}} -> error_handler.(reason, i); {:cont, reason}
+	  {:ok, next_obj} -> {:halt, %{feed | current: next_obj}}
 	  nil               -> {:halt, %{feed | current: nil}}
 	end
       else
@@ -73,18 +73,18 @@ defmodule Facebook.Stream do
   end
 
   # Gets next data page
-  defp getNextPagedData(%{"paging" => %{"next" => next_url}}) do
+  defp get_next_paged_data(%{"paging" => %{"next" => next_url}}) do
     Graph.request(:get, next_url, [])
   end
 
-  defp getNextPagedData(%{"paging" => %{"cursors" => %{"next" => next_url}}}) do
+  defp get_next_paged_data(%{"paging" => %{"cursors" => %{"next" => next_url}}}) do
     Graph.request(:get, next_url, [])
   end
 
-  defp getNextPagedData(_), do: nil
+  defp get_next_paged_data(_), do: nil
 
   # Get data from FB Graph Object
-  defp getData(%{"data" => data}), do: data
-  defp getData(_), do: nil
+  defp get_data(%{"data" => data}), do: data
+  defp get_data(_), do: nil
 
 end
diff --git a/mix.exs b/mix.exs
index 79a351c..2020153 100644
--- a/mix.exs
+++ b/mix.exs
@@ -53,7 +53,10 @@ defmodule Facebook.Mixfile do
     [
       {:json, ">= 0.3.3"},
       {:hackney, "~> 1.6"},
-      {:ex_doc, ">= 0.13.0", only: :dev}
+      {:ex_doc, ">= 0.13.0", only: :dev},
+
+      {:mock, "~> 0.2.0", only: :test},
+      {:mix_test_watch, "~> 0.3", only: :dev, runtime: false}
     ]
   end
 end
diff --git a/test/facebook_test.exs b/test/facebook_test.exs
index baad8e6..a9a34c0 100644
--- a/test/facebook_test.exs
+++ b/test/facebook_test.exs
@@ -1,182 +1,494 @@
-defmodule FacebookTest do
-  use ExUnit.Case
+defmodule Facebook.FacebookTest do
+  use ExUnit.Case, async: false
 
-  @appId System.get_env("FBEX_APP_ID")
-  @appSecret System.get_env("FBEX_APP_SECRET")
+  import Facebook.GraphMock
+  import Mock
+
+  @app_id "123"
+  @app_secret "456"
   # 19292868552 = facebook for developers page
-  @pageId 19292868552
+  @page_id 19292868552
   # 629965917187496 = page id the test user created
-  @testPageId 629965917187496
-
-  setup_all do
-    assert(@appId != nil)
-    assert(@appSecret != nil)
-
-    Facebook.setAppsecret(@appSecret)
-
-    appAccessToken = "#{@appId}|#{@appSecret}"
-
-    [user | _] = Facebook.testUsers(@appId, appAccessToken)
-
-    assert(String.length(user["access_token"]) > 0)
-    assert(String.length(user["id"]) > 0)
-    assert(String.length(user["login_url"]) > 0)
+  @test_page_id 629965917187496
 
+  setup do
     [
-      app_access_token: appAccessToken,
-      id: user["id"],
-      access_token: user["access_token"]
+      app_access_token: "#{@app_id}|#{@app_secret}",
+      id: "116331862460015",
+      access_token: "123",
+      invalid_access_token: "123"
     ]
   end
 
-  test "me", context do
-    %{id: id, access_token: access_token} = context
-
-    {:json, userData} = Facebook.me("id,first_name", access_token)
-
-    assert(userData["id"] == id)
-    assert(String.length(userData["first_name"]) > 0)
+  describe "me" do
+    test "success", %{id: id, access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.me(:success) end
+      ] do
+        assert {:ok, user} = Facebook.me("id,first_name", access_token)
+        assert(user["id"] == id)
+        assert(String.length(user["first_name"]) > 0)
+      end
+    end
+
+    test "error", %{invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, %{"code" => _,"message" => _,}} = Facebook.me(
+          "id,first_name",
+          invalid_access_token
+        )
+      end
+    end
   end
 
-  test "picture", context do
-    %{id: id, access_token: access_token} = context
-
-    {:json, pictureData} = Facebook.picture(id, "small", access_token)
-
-    assert(String.length(pictureData["data"]["url"]) > 0)
-  end
-
-  test "publish", context do
-    %{id: id, access_token: access_token} = context
-
-    {:json, response} = Facebook.publish(:feed, id, [message: "test message", link: "www.example.org"], access_token)
-    assert(String.length(response["id"]) > 0)
-  end
-
-  test "publish photo", context do
-    %{id: id, access_token: access_token} = context
-    file_path = "test/assets/sample_image.png"
-
-    {:json, response} = Facebook.publish(:photo, id, file_path, [], access_token)
-    assert(String.length(response["id"]) > 0)
-  end
-
-  test "publish video", context do
-    %{id: id, access_token: access_token} = context
-    file_path = "test/assets/sample_video.mpg"
-
-    {:json, response} = Facebook.publish(:video, id, file_path, [], access_token)
-    assert(String.length(response["id"]) > 0)
+  describe "picture" do
+    test "success", %{id: id, access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.picture(:success) end
+      ] do
+        {:ok, %{"data" => picture_data}} = Facebook.picture(
+          id,
+          "small",
+          access_token
+        )
+
+        assert(String.length(picture_data["url"]) > 0)
+      end
+    end
+
+    test "error", %{id: id, invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.picture(id, "small", invalid_access_token)
+      end
+    end
   end
 
-  test "myLikes", context do
-    %{access_token: access_token} = context
-
-    {:json, likesData} = Facebook.myLikes(access_token)
-
-    assert(likesData["data"] != nil)
+  describe "publish" do
+    test "feed - success", %{id: id, access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.publish(:success, :feed) end
+      ] do
+        {:ok, response} = Facebook.publish(
+          :feed,
+          id,
+          [message: "test message",
+          link: "www.example.org"],
+          access_token
+        )
+        assert(String.length(response["id"]) > 0)
+      end
+    end
+
+    test "feed - error", %{id: id, invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.publish(
+          :feed,
+          id,
+          [message: "test message",
+          link: "www.example.org"],
+          invalid_access_token
+        )
+      end
+    end
+
+    test "photo - success", %{id: id, access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.publish(:success, :image) end
+      ] do
+        file_path = "test/assets/sample_image.png"
+        assert {:ok, %{"id" => _, "post_id" => _}} = Facebook.publish(
+          :photo,
+          id,
+          file_path,
+          [],
+          access_token
+        )
+      end
+    end
+
+    test "photo - error", %{id: id, invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        file_path = "test/assets/sample_image.png"
+        assert {:error, _} = Facebook.publish(
+          :photo,
+          id,
+          file_path,
+          [],
+          invalid_access_token
+        )
+      end
+    end
+
+    test "video - success", %{id: id, access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.publish(:success, :image) end
+      ] do
+        file_path = "test/assets/sample_video.mpg"
+        assert {:ok, response} = Facebook.publish(
+          :video,
+          id,
+          file_path,
+          [],
+          access_token
+        )
+        assert(String.length(response["id"]) > 0)
+      end
+    end
+
+    test "video - error", %{id: id, invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        file_path = "test/assets/sample_image.png"
+        assert {:error, _} = Facebook.publish(
+          :photo,
+          id,
+          file_path,
+          [],
+          invalid_access_token
+        )
+      end
+    end
   end
 
-  test "permissions", context do
-    %{id: id, access_token: access_token} = context
-
-    {:json, perms} = Facebook.permissions(id, access_token)
-
-    assert(perms["data"] != nil)
-
-    [ permission | _ ] = perms["data"]
-    assert(permission["permission"] != nil)
-    assert(permission["status"] != nil)
+  describe "my_likes" do
+    test "success", %{access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.my_likes(:success) end
+      ] do
+        {:ok, likes_data} = Facebook.my_likes(access_token)
+
+        assert(likes_data != nil)
+      end
+    end
+
+    test "error", %{invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.my_likes(invalid_access_token)
+      end
+    end
   end
 
-  test "fanCount", context do
-    %{app_access_token: app_access_token} = context
-
-    count = Facebook.fanCount(@pageId, app_access_token)
-    assert(count > 0)
+  describe "permissions" do
+    test "success", %{id: id, access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.permissions(:success) end
+      ] do
+        assert {:ok, %{"data" => data}} = Facebook.permissions(id, access_token)
+
+        [permission | _] = data
+        assert(permission["permission"] != nil)
+        assert(permission["status"] != nil)
+      end
+    end
+
+    test "error", %{id: id, invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.permissions(id, invalid_access_token)
+      end
+    end
   end
 
-  test "pageLikes", context do
-    %{app_access_token: app_access_token} = context
-
-    count = Facebook.pageLikes(@pageId, app_access_token)
-    assert(count > 0)
+  describe "fan_count" do
+    test "success", %{app_access_token: app_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.page(:success, :fan_count) end
+      ] do
+        assert {:ok, %{"fan_count" => _}} = Facebook.fan_count(
+          @page_id,
+          app_access_token
+        )
+      end
+    end
+
+    test "error", %{invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.fan_count(@page_id, invalid_access_token)
+      end
+    end
   end
 
-  test "page", context do
-    %{app_access_token: app_access_token} = context
-
-    {:json, data} = Facebook.page(@pageId, app_access_token)
-    assert(data != nil)
-
-    %{"name" => name, "id" => id} = data
-    assert(String.length(name) > 0)
-    assert(id == Integer.to_string(@pageId, 10))
+  describe "page" do
+    test "success", %{app_access_token: app_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.page(:success) end
+      ] do
+        assert {:ok, %{
+          "name" => name,
+          "id" => id
+        }} = Facebook.page(@page_id, app_access_token)
+
+        assert(String.length(name) > 0)
+        assert(id == Integer.to_string(@page_id, 10))
+      end
+    end
+
+    test "error", %{invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.page(@page_id, invalid_access_token)
+      end
+    end
   end
 
-  test "page with fields", context do
-    %{app_access_token: app_access_token} = context
-
-    {:json, data} = Facebook.page(@pageId, app_access_token, ["about"])
-    assert(data != nil)
-
-    %{"id" => id, "about" => about} = data
-    assert(String.length(about) > 0)
-    assert(id == Integer.to_string(@pageId, 10))
+  describe "page with fields" do
+    test "success", %{app_access_token: app_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.page(:success, :with_fields) end
+      ] do
+        assert {:ok, %{
+          "id" => id,
+          "about" => about
+        }} = Facebook.page(@page_id, app_access_token, ["about"])
+
+        assert(String.length(about) > 0)
+        assert(id == Integer.to_string(@page_id, 10))
+      end
+    end
+
+    test "error", %{invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.page(
+          @page_id,
+          invalid_access_token,
+          ["about"]
+        )
+      end
+    end
   end
 
-  test "page feed", context do
-    %{access_token: access_token} = context
-
-    data = Facebook.pageFeed(:feed, @testPageId, access_token)
-    assert(data != nil)
+  describe "page feed" do
+    test "success", %{app_access_token: app_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.page(:success, :feed) end
+      ] do
+        assert {:ok, %{"data" => [data | _]}} = Facebook.page_feed(
+          :feed,
+          @page_id,
+          app_access_token,
+          1
+        )
+
+        assert %{
+          "id" => _,
+          "created_time" => _,
+          "message" => _,
+          "story" => _
+        } = data
+      end
+    end
+
+    test "error", %{invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.page_feed(
+          :feed,
+          @page_id,
+          invalid_access_token,
+          1
+        )
+      end
+    end
   end
 
-  test "object count", context do
-    %{access_token: access_token} = context
-
-    count = Facebook.objectCount(:likes, "#{@testPageId}_629967087187379", access_token)
-    assert(count >= 0)
+  describe "object count" do
+    test "success", %{access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.object_count(:success, :likes) end
+      ] do
+        assert {:ok, 10} = Facebook.object_count(
+          :likes,
+          "1326382730725053_1326476257382367",
+          access_token
+        )
+      end
+    end
   end
 
-  test "object reaction count", context do
-    %{access_token: access_token} = context
-
-    count = Facebook.objectCount(:reaction, :wow, "#{@testPageId}_629967087187379", access_token)
-    assert(count >= 0)
+  describe "object reaction count" do
+    test "success", %{access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.object_count(:success, :likes) end
+      ] do
+        assert {:ok, 10} = Facebook.object_count(
+          :reaction,
+          :wow,
+          "#{@test_page_id}_629967087187379",
+          access_token
+        )
+      end
+    end
   end
 
-  test "object count all", context do
-    %{access_token: access_token} = context
-
-    counts = Facebook.objectCountAll("#{@testPageId}_629967087187379", access_token)
-    assert(counts["angry"] >= 0)
-    assert(counts["haha"] >= 0)
-    assert(counts["like"] >= 0)
-    assert(counts["love"] >= 0)
-    assert(counts["sad"] >= 0)
-    assert(counts["wow"] >= 0)
+  describe "object count all" do
+    test "success", %{access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.object_count_all(:success) end
+      ] do
+        assert {:ok, %{"haha" => haha, "love" => love}} = Facebook.object_count_all(
+          "#{@test_page_id}_629967087187379",
+          access_token
+        )
+
+        assert haha == 135
+        assert love == 10
+      end
+    end
   end
 
-  test "long lived access token", context do
-    %{access_token: access_token} = context
-    data = Facebook.longLivedAccessToken(@appId, @appSecret, access_token)
-
-    assert(String.length(data["access_token"]) > 0)
-    assert(data["token_type"] == "bearer")
-    assert(data["expires"] > 0)
+  describe "long lived access token" do
+    test "success", %{access_token: access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.long_lived_access_token(:success) end
+      ] do
+        assert {:ok, %{
+          "access_token" => access_token,
+          "expires_in" => expires_in,
+          "token_type" => token_type
+        }} = Facebook.long_lived_access_token(
+          @app_id,
+          @app_secret,
+          access_token
+        )
+
+        assert(String.length(access_token) > 0)
+        assert(token_type == "bearer")
+        assert(expires_in > 0)
+      end
+    end
+
+    test "error", %{invalid_access_token: invalid_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.error() end
+      ] do
+        assert {:error, _} = Facebook.long_lived_access_token(
+          @app_id,
+          @app_secret,
+          invalid_access_token
+        )
+      end
+    end
   end
 
-  test "new stream", context do
-    %{access_token: access_token} = context
-
-    stream =
-      Facebook.pageFeed(:feed, @testPageId, access_token, 25)
-      |> Facebook.Stream.new
-
-    # get 150 posts
-    posts = stream |> Stream.take(150) |> Enum.to_list
-
-    assert(length(posts) == 150)
+  describe "new stream" do
+    test "success", %{app_access_token: app_access_token} do
+      with_mock :hackney, [
+        request: fn(_method, _url, _headers, _payload, _options) ->
+          {:ok, nil, nil, nil}
+        end,
+        body: fn(_) -> Facebook.GraphMock.page(:success, :feed) end
+      ] do
+        posts = Facebook.page_feed(
+          :feed,
+          @page_id,
+          app_access_token,
+          1
+        )
+          |> Facebook.Stream.new
+          |> Stream.take(1)
+          |> Enum.to_list
+
+        assert(length(posts) == 1)
+      end
+    end
   end
 end
diff --git a/test/graph_mock.ex b/test/graph_mock.ex
new file mode 100644
index 0000000..02f5a22
--- /dev/null
+++ b/test/graph_mock.ex
@@ -0,0 +1,104 @@
+defmodule Facebook.GraphMock do
+  def error() do
+    JSON.encode(%{"error": %{
+      "message": "Invalid OAuth access token.",
+      "type": "OAuthException",
+      "code": 190,
+      "fbtrace_id": "GB4fbEEGxkW"
+    }})
+  end
+
+  def long_lived_access_token(:success) do
+    JSON.encode(%{
+      "access_token" => "access_token",
+      "expires_in" => 5184000,
+      "token_type" => "bearer"
+    })
+  end
+
+  def my_likes(:success) do
+    JSON.encode(%{
+      "data": []
+    })
+  end
+
+  def me(:success) do
+    JSON.encode(%{
+      "id": "116331862460015", "first_name": "Open"
+    })
+  end
+
+  def object_count(:success, :likes) do
+    JSON.encode(%{"summary" => %{
+      "total_count" => 10
+    }})
+  end
+
+  def object_count_all(:success) do
+    JSON.encode(%{
+      "haha" => %{"summary" => %{"total_count" => 135}},
+      "love" => %{"summary" => %{"total_count" => 10}}
+    })
+  end
+
+  def page(:success) do
+    JSON.encode(%{
+      "id": "19292868552", "name": "Facebook for Developers"
+    })
+  end
+
+  def page(:success, :feed) do
+    JSON.encode(%{"data": [%{
+      "created_time" => "2017-01-01T01:05:49+0000",
+      "id" => "915520981811232_1894726877223966",
+      "message" => "https://www.facebook.com/notes/...",
+      "story" => ""
+    }]})
+  end
+
+  def page(:success, :with_fields) do
+    JSON.encode(%{
+      "id": "19292868552",
+      "about": "Build, grow, and monetize your app with Facebook."
+    })
+  end
+
+  def page(:success, :fan_count) do
+    JSON.encode(%{
+      "id": "19292868552", "fan_count": 5469088
+    })
+  end
+
+  def permissions(:success) do
+    JSON.encode(%{"data": [%{
+      "permission": "user_friends",
+      "status": "granted"
+    }]})
+  end
+
+  def picture(:success) do
+    JSON.encode(%{"data": %{
+      "is_silhouette": true,
+      "url": "https://scontent.xx.fbcdn.net/..."
+    }})
+  end
+
+  def publish(:success, :feed) do
+    JSON.encode(%{
+      "id": "116331862460015_120732275353308",
+    })
+  end
+
+  def publish(:success, :image) do
+    JSON.encode(%{
+      "id": "120752462017955",
+      "post_id": "116331862460015_120752105351324"
+    })
+  end
+
+  def publish(:success, :video) do
+    JSON.encode(%{
+      "id": "120762398683628",
+    })
+  end
+end
diff --git a/test/test_helper.exs b/test/test_helper.exs
index 869559e..5662f9a 100644
--- a/test/test_helper.exs
+++ b/test/test_helper.exs
@@ -1 +1,3 @@
+Code.load_file("test/graph_mock.ex")
+
 ExUnit.start()