From 35e2a05ce0bf3f066bf0c21f1997db95b8a10800 Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Mon, 16 Oct 2017 23:23:09 -0700
Subject: [PATCH 1/8] Convert function returns to be more idiomatic elixir

---
 lib/facebook.ex        | 130 ++++++++++++++++----------------
 lib/facebook/graph.ex  |  46 +++++++-----
 mix.exs                |   4 +-
 test/facebook_test.exs | 163 ++++++++++++++++++++---------------------
 4 files changed, 177 insertions(+), 166 deletions(-)

diff --git a/lib/facebook.ex b/lib/facebook.ex
index bb28a6d..ddf46b1 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, HashDict.t} | {:body, String.t}
   @type using_appsecret :: boolean
   @type reaction :: :reaction
 
@@ -111,10 +111,10 @@ defmodule Facebook do
 
   ## Example
       iex> Facebook.publish(:photo, "<Feed Id>", "<Image Path>", [], "<Access Token>")
-      {:json, %{"id" => "..."}}
+      {:ok, %{"id" => "..."}}
 
       iex> Facebook.publish(:video, "<Feed Id>", "<Video Path>", [], "<Access Token>")
-      {:json, %{"id" => "..."}}
+      {:ok, %{"id" => "..."}}
 
   """
   @spec publish(:photo, page_id :: String.t, file_path :: String.t, fields, access_token) :: response
@@ -155,12 +155,12 @@ 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("<Your Token>")
 
   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)
 
@@ -186,29 +186,28 @@ 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", "<Your Token>")
 
   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
+  @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 """
-  *Deprecated:* Please use fanCount instead.
+  *Deprecated:* Please use fan_count instead.
 
   Get the count of fans for the provided page_id
 
   ## Example
-      iex> Facebook.pageLikes("CocaColaMx", "<Your Token>")
+      iex> Facebook.page_likes("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 page_likes(page_id :: integer | String.t, access_token) :: integer
+  def page_likes(page_id, access_token) do
+    fan_count(page_id, access_token)
   end
 
   @doc """
@@ -255,15 +254,15 @@ 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", "<Your Token>")
+      iex> Facebook.page_feed(:tagged, "CocaColaMx", "<Your Token>", 55)
+      iex> Facebook.page_feed(:promotable_posts, "CocaColaMx", "<Your Token>")
+      iex> Facebook.page_feed(:feed, "CocaColaMx", "<Your Token>", 55, "id,name")
 
   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) :: Map.t
+  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)
 
@@ -277,23 +276,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>")
+      iex> Facebook.object_count(:likes, "1326382730725053_1326476257382367", "<Token>")
       2
-      iex> Facebook.objectCount(:comments, "1326382730725053_1326476257382367", "<Token>")
+      iex> Facebook.object_count(:comments, "1326382730725053_1326476257382367", "<Token>")
       2
 
   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) :: number
+  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 +301,8 @@ defmodule Facebook do
       |> String.downcase
 
     Facebook.Graph.get(~s(/#{object_id}/#{scp}), params)
-      |> getSummary
-      |> summaryCount
+      |> get_summary
+      |> summary_count
   end
 
   @doc """
@@ -319,15 +318,15 @@ defmodule Facebook do
     * :none
 
   ## Examples
-      iex> Facebook.objectCount(:reaction, :wow, "769860109692136_1173416799336463", "<Token>")
+      iex> Facebook.object_count(:reaction, :wow, "769860109692136_1173416799336463", "<Token>")
       2
-      iex> Facebook.objectCount(:reaction, :haha, "769860109692136_1173416799336463", "<Token>")
+      iex> Facebook.object_count(:reaction, :haha, "769860109692136_1173416799336463", "<Token>")
       12
-      iex> Facebook.objectCount(:reaction, :thankful, "769860109692136_1173416799336463", "<Token>")
+      iex> Facebook.object_count(:reaction, :thankful, "769860109692136_1173416799336463", "<Token>")
       33
   """
-  @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) :: number
+  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 +335,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>")
+      iex> Facebook.object_count_all("769860109692136_1173416799336463", "<Token>")
       %{"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) :: map
+  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,7 +361,7 @@ defmodule Facebook do
       |> add_app_secret(access_token)
 
     Facebook.Graph.get(~s(/#{object_id}), params)
-      |> summaryCountAll
+      |> summary_count_all
   end
 
   @doc """
@@ -384,14 +383,14 @@ defmodule Facebook do
       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")
+      iex> Facebook.long_lived_access_token("client_id", "client_secret", "access_token")
       %{
         "access_token" => "ACCESS_TOKEN",
         "expires_in" => 5183976,
@@ -400,13 +399,13 @@ defmodule Facebook do
 
   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) :: String.t
+  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,7 +417,7 @@ 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")
     [
       %{
         "access_token" => "ACCESS_TOKEN",
@@ -427,47 +426,48 @@ defmodule Facebook do
       }
     ]
   """
-  @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) :: Map.t
+  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
+  defp get_access_token(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
+      {:ok, %{"error" => error}} -> %{"error" => error}
+      {:ok, %{"summary" => summary}} -> summary
+      {:ok, info_map} -> info_map
     end
   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: 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
+    Apex.ap summary
     Map.keys(summary)
       |> Enum.reject(fn(x) -> x === "id" end)
       |> Enum.map(fn(x) ->
diff --git a/lib/facebook/graph.ex b/lib/facebook/graph.ex
index 331e17a..8c46642 100644
--- a/lib/facebook/graph.ex
+++ b/lib/facebook/graph.ex
@@ -89,24 +89,34 @@ 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
+    :hackney.request(method, url, headers, payload, options)
+      |> get_response_body()
+      |> parse_response_body()
+      |> format_response_body()
+  end
+
+  defp get_response_body({:ok, _status_code, _headers, client_ref}) do
+    :hackney.body(client_ref)
+  end
+  defp get_response_body({:error, reason}), do: {:error, reason}
 
-    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, reason}), do: {:error, reason}
+
+  defp format_response_body({:ok, %{"error" => error}}) do
+    {:error, error}
+  end
+  # defp format_response_body({:ok, %{"data" => data} = rest}) do
+  #   Apex.ap rest
+  #   {:ok, data}
+  # end
+  # defp format_response_body({:ok, %{"summary" => summary}}) do
+  #   {:ok, summary}
+  # end
+  defp format_response_body({:ok, resp}) do
+    {:ok, resp}
   end
+  defp format_response_body({:error, reason}), do: {:error, reason}
 end
diff --git a/mix.exs b/mix.exs
index 79a351c..6e9676d 100644
--- a/mix.exs
+++ b/mix.exs
@@ -53,7 +53,9 @@ 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},
+      {:apex, "~>1.1.0"},
+      {: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..6353eb6 100644
--- a/test/facebook_test.exs
+++ b/test/facebook_test.exs
@@ -1,12 +1,12 @@
-defmodule FacebookTest do
+  defmodule FacebookTest do
   use ExUnit.Case
 
   @appId System.get_env("FBEX_APP_ID")
   @appSecret System.get_env("FBEX_APP_SECRET")
   # 19292868552 = facebook for developers page
-  @pageId 19292868552
+  @page_id 19292868552
   # 629965917187496 = page id the test user created
-  @testPageId 629965917187496
+  @test_page_id 629965917187496
 
   setup_all do
     assert(@appId != nil)
@@ -14,73 +14,70 @@ defmodule FacebookTest do
 
     Facebook.setAppsecret(@appSecret)
 
-    appAccessToken = "#{@appId}|#{@appSecret}"
+    app_access_token = "#{@appId}|#{@appSecret}"
 
-    [user | _] = Facebook.testUsers(@appId, appAccessToken)
+    {:ok, %{"data" => [user]}} = Facebook.test_users(@appId, app_access_token)
 
     assert(String.length(user["access_token"]) > 0)
     assert(String.length(user["id"]) > 0)
     assert(String.length(user["login_url"]) > 0)
 
     [
-      app_access_token: appAccessToken,
+      app_access_token: app_access_token,
       id: user["id"],
       access_token: user["access_token"]
     ]
   end
 
-  test "me", context do
-    %{id: id, access_token: access_token} = context
+  test "me", %{id: id, access_token: access_token} do
+    assert {:ok, user} = Facebook.me("id,first_name", access_token)
+    Apex.ap user
 
-    {:json, userData} = Facebook.me("id,first_name", access_token)
-
-    assert(userData["id"] == id)
-    assert(String.length(userData["first_name"]) > 0)
+    assert(user["id"] == id)
+    assert(String.length(user["first_name"]) > 0)
   end
 
-  test "picture", context do
-    %{id: id, access_token: access_token} = context
+  test "me - error" do
+    assert {:error, %{
+      "code" => _,
+      "message" => _,
+    }} = Facebook.me("id,first_name", "123")
+  end
 
-    {:json, pictureData} = Facebook.picture(id, "small", access_token)
+  test "picture", %{id: id, access_token: access_token} do
+    {:ok, %{"data" => picture_data}} = Facebook.picture(id, "small", access_token)
 
-    assert(String.length(pictureData["data"]["url"]) > 0)
+    assert(String.length(picture_data["url"]) > 0)
   end
 
-  test "publish", context do
-    %{id: id, access_token: access_token} = context
+  test "publish", %{id: id, access_token: access_token} do
 
-    {:json, response} = Facebook.publish(:feed, id, [message: "test message", link: "www.example.org"], access_token)
+    {:ok, 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
+  test "publish photo", %{id: id, access_token: access_token} do
     file_path = "test/assets/sample_image.png"
 
-    {:json, response} = Facebook.publish(:photo, id, file_path, [], access_token)
+    {:ok, 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"
+  test "publish video", %{id: id, access_token: access_token} do
+   file_path = "test/assets/sample_video.mpg"
 
     {:json, response} = Facebook.publish(:video, id, file_path, [], access_token)
     assert(String.length(response["id"]) > 0)
   end
 
-  test "myLikes", context do
-    %{access_token: access_token} = context
+  test "my_likes", %{access_token: access_token} do
+    {:ok, likes_data} = Facebook.my_likes(access_token)
 
-    {:json, likesData} = Facebook.myLikes(access_token)
-
-    assert(likesData["data"] != nil)
+    assert(likes_data != nil)
   end
 
-  test "permissions", context do
-    %{id: id, access_token: access_token} = context
-
-    {:json, perms} = Facebook.permissions(id, access_token)
+  test "permissions", %{id: id, access_token: access_token} do
+    {:ok, perms} = Facebook.permissions(id, access_token)
 
     assert(perms["data"] != nil)
 
@@ -89,67 +86,63 @@ defmodule FacebookTest do
     assert(permission["status"] != nil)
   end
 
-  test "fanCount", context do
-    %{app_access_token: app_access_token} = context
+  test "fan_count", %{app_access_token: app_access_token} do
+    {:ok, %{"fan_count" => fan_count}} = Facebook.fan_count(
+      @page_id,
+      app_access_token
+    )
 
-    count = Facebook.fanCount(@pageId, app_access_token)
-    assert(count > 0)
+    assert(fan_count > 0)
   end
 
-  test "pageLikes", context do
-    %{app_access_token: app_access_token} = context
+  test "page_likes", %{app_access_token: app_access_token} do
+    {:ok, %{"fan_count" => fan_count}} = Facebook.page_likes(
+      @page_id,
+      app_access_token
+    )
 
-    count = Facebook.pageLikes(@pageId, app_access_token)
-    assert(count > 0)
+    assert(fan_count > 0)
   end
 
-  test "page", context do
-    %{app_access_token: app_access_token} = context
+  test "page", %{app_access_token: app_access_token} do
+    {:ok, data} = Facebook.page(@page_id, app_access_token)
 
-    {:json, data} = Facebook.page(@pageId, app_access_token)
-    assert(data != nil)
-
-    %{"name" => name, "id" => id} = data
+    assert %{"name" => name, "id" => id} = data
     assert(String.length(name) > 0)
-    assert(id == Integer.to_string(@pageId, 10))
+    assert(id == Integer.to_string(@page_id, 10))
   end
 
-  test "page with fields", context do
-    %{app_access_token: app_access_token} = context
+  test "page with fields", %{app_access_token: app_access_token} do
+    {:ok, data} = Facebook.page(@page_id, app_access_token, ["about"])
 
-    {:json, data} = Facebook.page(@pageId, app_access_token, ["about"])
-    assert(data != nil)
-
-    %{"id" => id, "about" => about} = data
+    assert %{"id" => id, "about" => about} = data
     assert(String.length(about) > 0)
-    assert(id == Integer.to_string(@pageId, 10))
+    assert(id == Integer.to_string(@page_id, 10))
   end
 
-  test "page feed", context do
-    %{access_token: access_token} = context
-
-    data = Facebook.pageFeed(:feed, @testPageId, access_token)
+  # TODO: returning {:error, error} atm
+  test "page feed", %{access_token: access_token} do
+    data = Facebook.page_feed(:feed, @test_page_id, access_token)
+    Apex.ap data
     assert(data != nil)
   end
 
-  test "object count", context do
-    %{access_token: access_token} = context
-
-    count = Facebook.objectCount(:likes, "#{@testPageId}_629967087187379", access_token)
+  # TODO: returning {:error, error} atm
+  test "object count", %{access_token: access_token} do
+    count = Facebook.object_count(:likes, "#{@test_page_id}_629967087187379", access_token)
+    Apex.ap count
     assert(count >= 0)
   end
 
-  test "object reaction count", context do
-    %{access_token: access_token} = context
-
-    count = Facebook.objectCount(:reaction, :wow, "#{@testPageId}_629967087187379", access_token)
+  # TODO: returning {:error, error} atm
+  test "object reaction count", %{access_token: access_token} do
+    count = Facebook.object_count(:reaction, :wow, "#{@test_page_id}_629967087187379", access_token)
     assert(count >= 0)
   end
 
-  test "object count all", context do
-    %{access_token: access_token} = context
-
-    counts = Facebook.objectCountAll("#{@testPageId}_629967087187379", access_token)
+  # TODO: returning {:error, error} atm
+  test "object count all", %{access_token: access_token} do
+    counts = Facebook.object_count_all("#{@test_page_id}_629967087187379", access_token)
     assert(counts["angry"] >= 0)
     assert(counts["haha"] >= 0)
     assert(counts["like"] >= 0)
@@ -158,20 +151,26 @@ defmodule FacebookTest do
     assert(counts["wow"] >= 0)
   end
 
-  test "long lived access token", context do
-    %{access_token: access_token} = context
-    data = Facebook.longLivedAccessToken(@appId, @appSecret, access_token)
+  test "long lived access token", %{access_token: access_token} do
+    assert %{
+      "access_token" => access_token,
+      "expires_in" => expires_in,
+      "token_type" => token_type
+    } = Facebook.long_lived_access_token(
+      @appId,
+      @appSecret,
+      access_token
+    )
 
-    assert(String.length(data["access_token"]) > 0)
-    assert(data["token_type"] == "bearer")
-    assert(data["expires"] > 0)
+    assert(String.length(access_token) > 0)
+    assert(token_type == "bearer")
+    assert(expires_in > 0)
   end
 
-  test "new stream", context do
-    %{access_token: access_token} = context
-
+  # TODO: a nil stream
+  test "new stream", %{access_token: access_token} do
     stream =
-      Facebook.pageFeed(:feed, @testPageId, access_token, 25)
+      Facebook.page_feed(:feed, @test_page_id, access_token, 25)
       |> Facebook.Stream.new
 
     # get 150 posts

From 3af92af9511eb9cf5f45aba512d0ccc9383ae7a7 Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Mon, 23 Oct 2017 21:49:29 -0700
Subject: [PATCH 2/8] Wrap HTTP requests in mocks

---
 lib/facebook.ex        |   3 +-
 lib/facebook/graph.ex  |  19 +-
 mix.exs                |   5 +
 test/facebook_test.exs | 549 +++++++++++++++++++++++++++++++++--------
 test/graph_mock.ex     |  32 +++
 5 files changed, 495 insertions(+), 113 deletions(-)
 create mode 100644 test/graph_mock.ex

diff --git a/lib/facebook.ex b/lib/facebook.ex
index ddf46b1..f848d68 100644
--- a/lib/facebook.ex
+++ b/lib/facebook.ex
@@ -140,6 +140,7 @@ defmodule Facebook do
 
   ## Example
       iex> Facebook.picture("<Some Id>", "small", "<Your Token>")
+      {:ok, %{"data": "..."}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/user/picture/
   """
@@ -439,7 +440,7 @@ defmodule Facebook do
   # response
   defp get_access_token(params) do
     case Facebook.Graph.get(~s(/oauth/access_token), params) do
-      {:ok, %{"error" => error}} -> %{"error" => error}
+      {:error, error} -> {:error, error}
       {:ok, %{"summary" => summary}} -> summary
       {:ok, info_map} -> info_map
     end
diff --git a/lib/facebook/graph.ex b/lib/facebook/graph.ex
index 8c46642..97c7ce9 100644
--- a/lib/facebook/graph.ex
+++ b/lib/facebook/graph.ex
@@ -88,35 +88,26 @@ defmodule Facebook.Graph do
   """
   @spec request(method, url, payload, options) :: response
   def request(method, url, payload, options) do
-    headers = []
-    :hackney.request(method, url, headers, payload, options)
-      |> get_response_body()
+    send_request(method, url, [], payload, options)
       |> parse_response_body()
       |> format_response_body()
   end
 
-  defp get_response_body({:ok, _status_code, _headers, client_ref}) do
+  def send_request(method, url, headers, payload, options) do
+    {:ok, _, _, client_ref} = :hackney.request(method, url, headers, payload, options)
     :hackney.body(client_ref)
   end
-  defp get_response_body({:error, reason}), do: {:error, reason}
 
   defp parse_response_body({:ok, body}) do
     JSON.decode(body)
   end
-  defp parse_response_body({:error, reason}), do: {:error, reason}
+  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, %{"data" => data} = rest}) do
-  #   Apex.ap rest
-  #   {:ok, data}
-  # end
-  # defp format_response_body({:ok, %{"summary" => summary}}) do
-  #   {:ok, summary}
-  # end
   defp format_response_body({:ok, resp}) do
     {:ok, resp}
   end
-  defp format_response_body({:error, reason}), do: {:error, reason}
+  defp format_response_body({:error, error}), do: {:error, error}
 end
diff --git a/mix.exs b/mix.exs
index 6e9676d..eeaf35b 100644
--- a/mix.exs
+++ b/mix.exs
@@ -54,7 +54,12 @@ defmodule Facebook.Mixfile do
       {:json, ">= 0.3.3"},
       {:hackney, "~> 1.6"},
       {:ex_doc, ">= 0.13.0", only: :dev},
+
+      {:credo,      "~> 0.8", only: [:dev, :test]},
+      # TODO: take out apex
       {:apex, "~>1.1.0"},
+
+      {:mock, "~> 0.2.0", only: :test},
       {:mix_test_watch, "~> 0.3", only: :dev, runtime: false}
     ]
   end
diff --git a/test/facebook_test.exs b/test/facebook_test.exs
index 6353eb6..448a8a6 100644
--- a/test/facebook_test.exs
+++ b/test/facebook_test.exs
@@ -1,5 +1,90 @@
-  defmodule FacebookTest do
-  use ExUnit.Case
+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 page(:success) do
+    JSON.encode(%{
+      "id": "19292868552", "name": "Facebook for Developers"
+    })
+  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
+
+defmodule FacebookTest do
+  use ExUnit.Case, async: false
+
+  import Mock
 
   @appId System.get_env("FBEX_APP_ID")
   @appSecret System.get_env("FBEX_APP_SECRET")
@@ -8,7 +93,7 @@
   # 629965917187496 = page id the test user created
   @test_page_id 629965917187496
 
-  setup_all do
+  setup do
     assert(@appId != nil)
     assert(@appSecret != nil)
 
@@ -25,122 +110,367 @@
     [
       app_access_token: app_access_token,
       id: user["id"],
-      access_token: user["access_token"]
+      access_token: user["access_token"],
+      invalid_access_token: "123"
     ]
   end
 
-  test "me", %{id: id, access_token: access_token} do
-    assert {:ok, user} = Facebook.me("id,first_name", access_token)
-    Apex.ap user
-
-    assert(user["id"] == id)
-    assert(String.length(user["first_name"]) > 0)
-  end
-
-  test "me - error" do
-    assert {:error, %{
-      "code" => _,
-      "message" => _,
-    }} = Facebook.me("id,first_name", "123")
-  end
-
-  test "picture", %{id: id, access_token: access_token} do
-    {:ok, %{"data" => picture_data}} = Facebook.picture(id, "small", access_token)
-
-    assert(String.length(picture_data["url"]) > 0)
-  end
-
-  test "publish", %{id: id, access_token: access_token} do
-
-    {:ok, response} = Facebook.publish(:feed, id, [message: "test message", link: "www.example.org"], access_token)
-    assert(String.length(response["id"]) > 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 "publish photo", %{id: id, access_token: access_token} do
-    file_path = "test/assets/sample_image.png"
-
-    {:ok, response} = Facebook.publish(:photo, 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 "publish video", %{id: id, access_token: access_token} do
-   file_path = "test/assets/sample_video.mpg"
-
-    {:json, response} = Facebook.publish(:video, id, file_path, [], access_token)
-    assert(String.length(response["id"]) > 0)
+  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 "my_likes", %{access_token: access_token} do
-    {:ok, likes_data} = Facebook.my_likes(access_token)
-
-    assert(likes_data != 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 "permissions", %{id: id, access_token: access_token} do
-    {:ok, perms} = Facebook.permissions(id, access_token)
-
-    assert(perms["data"] != nil)
-
-    [ permission | _ ] = perms["data"]
-    assert(permission["permission"] != nil)
-    assert(permission["status"] != nil)
+  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 "fan_count", %{app_access_token: app_access_token} do
-    {:ok, %{"fan_count" => fan_count}} = Facebook.fan_count(
-      @page_id,
-      app_access_token
-    )
-
-    assert(fan_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_likes", %{app_access_token: app_access_token} do
-    {:ok, %{"fan_count" => fan_count}} = Facebook.page_likes(
-      @page_id,
-      app_access_token
-    )
-
-    assert(fan_count > 0)
+  describe "page_likes" 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.page_likes(
+          @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.page_likes(@page_id, invalid_access_token)
+      end
+    end
   end
 
-  test "page", %{app_access_token: app_access_token} do
-    {:ok, data} = Facebook.page(@page_id, app_access_token)
-
-    assert %{"name" => name, "id" => id} = data
-    assert(String.length(name) > 0)
-    assert(id == Integer.to_string(@page_id, 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", %{app_access_token: app_access_token} do
-    {:ok, data} = Facebook.page(@page_id, app_access_token, ["about"])
-
-    assert %{"id" => id, "about" => about} = data
-    assert(String.length(about) > 0)
-    assert(id == Integer.to_string(@page_id, 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
 
-  # TODO: returning {:error, error} atm
   test "page feed", %{access_token: access_token} do
     data = Facebook.page_feed(:feed, @test_page_id, access_token)
-    Apex.ap data
     assert(data != nil)
   end
 
-  # TODO: returning {:error, error} atm
   test "object count", %{access_token: access_token} do
     count = Facebook.object_count(:likes, "#{@test_page_id}_629967087187379", access_token)
-    Apex.ap count
     assert(count >= 0)
   end
 
-  # TODO: returning {:error, error} atm
   test "object reaction count", %{access_token: access_token} do
     count = Facebook.object_count(:reaction, :wow, "#{@test_page_id}_629967087187379", access_token)
     assert(count >= 0)
   end
 
-  # TODO: returning {:error, error} atm
   test "object count all", %{access_token: access_token} do
     counts = Facebook.object_count_all("#{@test_page_id}_629967087187379", access_token)
     assert(counts["angry"] >= 0)
@@ -151,23 +481,46 @@
     assert(counts["wow"] >= 0)
   end
 
-  test "long lived access token", %{access_token: access_token} do
-    assert %{
-      "access_token" => access_token,
-      "expires_in" => expires_in,
-      "token_type" => token_type
-    } = Facebook.long_lived_access_token(
-      @appId,
-      @appSecret,
-      access_token
-    )
-
-    assert(String.length(access_token) > 0)
-    assert(token_type == "bearer")
-    assert(expires_in > 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 %{
+          "access_token" => access_token,
+          "expires_in" => expires_in,
+          "token_type" => token_type
+        } = Facebook.long_lived_access_token(
+          @appId,
+          @appSecret,
+          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(
+          @appId,
+          @appSecret,
+          invalid_access_token
+        )
+      end
+    end
   end
 
-  # TODO: a nil stream
   test "new stream", %{access_token: access_token} do
     stream =
       Facebook.page_feed(:feed, @test_page_id, access_token, 25)
diff --git a/test/graph_mock.ex b/test/graph_mock.ex
new file mode 100644
index 0000000..a31e3eb
--- /dev/null
+++ b/test/graph_mock.ex
@@ -0,0 +1,32 @@
+defmodule Facebook.GraphMock do
+  def me(:success) do
+    JSON.encode(%{
+      "id": "116331862460015", "first_name": "Open"
+    })
+  end
+
+  def me(:error) do
+    JSON.encode(%{"error": %{
+      "message": "Invalid OAuth access token.",
+      "type": "OAuthException",
+      "code": 190,
+      "fbtrace_id": "GB4fbEEGxkW"
+    }})
+  end
+
+  def picture(:success) do
+    JSON.encode(%{"data": %{
+      "is_silhouette": true,
+      "url": "https://scontent.xx.fbcdn.net/v/t1.0-1/s50x50/10354686_10150004552801856_220367501106153455_n.jpg?oh=90b508dc37562a01ebe9c7b9292b9a2f&oe=5A800C40"
+    }})
+  end
+
+  def picture(:error) do
+    JSON.encode(%{"error": %{
+      "message": "Invalid OAuth access token.",
+      "type": "OAuthException",
+      "code": 190,
+      "fbtrace_id": "GB4fbEEGxkW"
+    }})
+  end
+end

From 2fadf749c73bd6e2319887935475025f9b95d088 Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Mon, 23 Oct 2017 22:55:16 -0700
Subject: [PATCH 3/8] Start updating documentation

---
 lib/facebook.ex        |  63 ++++++++------
 test/facebook_test.exs | 188 ++++++++++++++++++++---------------------
 2 files changed, 131 insertions(+), 120 deletions(-)

diff --git a/lib/facebook.ex b/lib/facebook.ex
index f848d68..a1fed31 100644
--- a/lib/facebook.ex
+++ b/lib/facebook.ex
@@ -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>")
-      {:ok, %{"id" => "..."}}
+      {:ok, %{"id" => photo_id, "post_id" => "{page_id}_{post_id}"}
 
       iex> Facebook.publish(:video, "<Feed Id>", "<Video Path>", [], "<Access Token>")
-      {:ok, %{"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,7 @@ 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/
@@ -156,7 +161,8 @@ defmodule Facebook do
   Likes of the currently logged in user (specified by the access_token)
 
   ## Example
-      iex> Facebook.my_likes("<Your Token>")
+      iex> Facebook.my_likes("<Access Token>")
+      {:ok, %{"data" => [...]}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/user/likes
   """
@@ -172,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
   """
@@ -187,7 +194,7 @@ defmodule Facebook do
   Get the count of fans for the provided page_id
 
   ## Example
-      iex> Facebook.fan_count("CocaColaMx", "<Your Token>")
+      iex> Facebook.fan_count("CocaColaMx", "<Access Token>")
 
   See: https://developers.facebook.com/docs/graph-api/reference/page/
   """
@@ -202,7 +209,8 @@ defmodule Facebook do
   Get the count of fans for the provided page_id
 
   ## Example
-      iex> Facebook.page_likes("CocaColaMx", "<Your Token>")
+      iex> Facebook.page_likes("CocaColaMx", "<Access Token>")
+      {:ok, %{"fan_count" => fan_count, "id" => id}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/page/
   """
@@ -215,7 +223,8 @@ defmodule Facebook do
   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 +237,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,10 +265,11 @@ defmodule Facebook do
   100.*
 
   ## Examples
-      iex> Facebook.page_feed(:posts, "CocaColaMx", "<Your Token>")
-      iex> Facebook.page_feed(:tagged, "CocaColaMx", "<Your Token>", 55)
-      iex> Facebook.page_feed(:promotable_posts, "CocaColaMx", "<Your Token>")
-      iex> Facebook.page_feed(: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
   """
@@ -285,9 +296,9 @@ defmodule Facebook do
 
   ## Example
       iex> Facebook.object_count(:likes, "1326382730725053_1326476257382367", "<Token>")
-      2
+      {:ok, 2}
       iex> Facebook.object_count(:comments, "1326382730725053_1326476257382367", "<Token>")
-      2
+      {:ok, 2}
 
   See: https://developers.facebook.com/docs/graph-api/reference/object/likes
   See: https://developers.facebook.com/docs/graph-api/reference/object/comments
@@ -320,11 +331,11 @@ defmodule Facebook do
 
   ## Examples
       iex> Facebook.object_count(:reaction, :wow, "769860109692136_1173416799336463", "<Token>")
-      2
+      {:ok, 100}
       iex> Facebook.object_count(:reaction, :haha, "769860109692136_1173416799336463", "<Token>")
-      12
+      {:ok, 100}
       iex> Facebook.object_count(:reaction, :thankful, "769860109692136_1173416799336463", "<Token>")
-      33
+      {:ok, 100}
   """
   @spec object_count(reaction, react_type :: atom, object_id :: String.t, access_token) :: number
   def object_count(:reaction, react_type, object_id, access_token) when is_atom(react_type) do
@@ -345,7 +356,7 @@ defmodule Facebook do
 
   ## Examples
       iex> Facebook.object_count_all("769860109692136_1173416799336463", "<Token>")
-      %{"angry" => 0, "haha" => 1, "like" => 0, "love" => 0, "sad" => 0, "wow" => 0}
+      {:ok, %{"angry" => 0, "haha" => 1, "like" => 0, "love" => 0, "sad" => 0, "wow" => 0}}
   """
   @spec object_count_all(object_id :: String.t, access_token) :: map
   def object_count_all(object_id, access_token) do
@@ -369,7 +380,7 @@ defmodule Facebook do
   Exchange an authorization code for an access token
 
   ## Examples
-      iex> Facebook.accessToken("client_id", "client_secret", "redirect_uri", "code")
+      iex> Facebook.access_token("client_id", "client_secret", "redirect_uri", "code")
       %{
         "access_token" => "ACCESS_TOKEN",
         "expires_in" => 5183976,
@@ -378,8 +389,8 @@ defmodule Facebook do
 
   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) :: String.t
+  def access_token(client_id, client_secret, redirect_uri, code) do
     [ client_id: client_id,
       client_secret: client_secret,
       redirect_uri: redirect_uri,
@@ -456,7 +467,7 @@ defmodule Facebook do
   end
 
   # Gets the 'total_count' attribute from a summary request.
-  defp summary_count(%{"total_count" => count}), do: count
+  defp summary_count(%{"total_count" => count}), do: {:ok, count}
 
   # Returns an error if the summary request fails.
   defp summary_count({:error, error}), do: {:error, error}
@@ -468,13 +479,13 @@ defmodule Facebook do
 
   # Calculate the reactions summary
   defp summary_count_all(summary) do
-    Apex.ap summary
     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/test/facebook_test.exs b/test/facebook_test.exs
index 448a8a6..d4a59f1 100644
--- a/test/facebook_test.exs
+++ b/test/facebook_test.exs
@@ -1,107 +1,24 @@
-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 page(:success) do
-    JSON.encode(%{
-      "id": "19292868552", "name": "Facebook for Developers"
-    })
-  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
-
 defmodule FacebookTest do
   use ExUnit.Case, async: false
 
   import Mock
 
-  @appId System.get_env("FBEX_APP_ID")
-  @appSecret System.get_env("FBEX_APP_SECRET")
+  @app_id System.get_env("FBEX_APP_ID")
+  @app_secret System.get_env("FBEX_APP_SECRET")
   # 19292868552 = facebook for developers page
   @page_id 19292868552
   # 629965917187496 = page id the test user created
   @test_page_id 629965917187496
 
   setup do
-    assert(@appId != nil)
-    assert(@appSecret != nil)
+    assert(@app_id != nil)
+    assert(@app_secret != nil)
 
-    Facebook.setAppsecret(@appSecret)
+    Facebook.setAppsecret(@app_secret)
 
-    app_access_token = "#{@appId}|#{@appSecret}"
+    app_access_token = "#{@app_id}|#{@app_secret}"
 
-    {:ok, %{"data" => [user]}} = Facebook.test_users(@appId, app_access_token)
+    {:ok, %{"data" => [user]}} = Facebook.test_users(@app_id, app_access_token)
 
     assert(String.length(user["access_token"]) > 0)
     assert(String.length(user["id"]) > 0)
@@ -494,8 +411,8 @@ defmodule FacebookTest do
           "expires_in" => expires_in,
           "token_type" => token_type
         } = Facebook.long_lived_access_token(
-          @appId,
-          @appSecret,
+          @app_id,
+          @app_secret,
           access_token
         )
 
@@ -513,8 +430,8 @@ defmodule FacebookTest do
         body: fn(_) -> Facebook.GraphMock.error() end
       ] do
         assert {:error, _} = Facebook.long_lived_access_token(
-          @appId,
-          @appSecret,
+          @app_id,
+          @app_secret,
           invalid_access_token
         )
       end
@@ -532,3 +449,86 @@ defmodule FacebookTest do
     assert(length(posts) == 150)
   end
 end
+
+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 page(:success) do
+    JSON.encode(%{
+      "id": "19292868552", "name": "Facebook for Developers"
+    })
+  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

From 9846aeae34ceacb31a3de5fad94f67752c499de0 Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Tue, 24 Oct 2017 23:53:59 -0700
Subject: [PATCH 4/8] Finish up mocking tests

---
 .gitignore             |   6 ++
 lib/facebook.ex        |  59 ++++--------
 lib/facebook/stream.ex |  30 +++---
 test/facebook_test.exs | 204 +++++++++++++++++++++++++++--------------
 4 files changed, 174 insertions(+), 125 deletions(-)

diff --git a/.gitignore b/.gitignore
index f20f9d3..e4ec589 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,9 @@ mix.lock
 .exenv-version
 doc
 .DS_Store
+
+# asdf
+.tool-versions
+
+# FB Tokens
+.env
diff --git a/lib/facebook.ex b/lib/facebook.ex
index a1fed31..4889979 100644
--- a/lib/facebook.ex
+++ b/lib/facebook.ex
@@ -195,6 +195,7 @@ defmodule Facebook do
 
   ## Example
       iex> Facebook.fan_count("CocaColaMx", "<Access Token>")
+      {:ok, %{"fan_count" => fan_count, "id" => id}}
 
   See: https://developers.facebook.com/docs/graph-api/reference/page/
   """
@@ -203,22 +204,6 @@ defmodule Facebook do
     page(page_id, access_token, ["fan_count"])
   end
 
-  @doc """
-  *Deprecated:* Please use fan_count instead.
-
-  Get the count of fans for the provided page_id
-
-  ## Example
-      iex> Facebook.page_likes("CocaColaMx", "<Access Token>")
-      {:ok, %{"fan_count" => fan_count, "id" => id}}
-
-  See: https://developers.facebook.com/docs/graph-api/reference/page/
-  """
-  @spec page_likes(page_id :: integer | String.t, access_token) :: integer
-  def page_likes(page_id, access_token) do
-    fan_count(page_id, access_token)
-  end
-
   @doc """
   Basic page information for the provided page_id
 
@@ -278,9 +263,7 @@ defmodule Facebook 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 """
@@ -295,10 +278,10 @@ defmodule Facebook do
     * :comments
 
   ## Example
-      iex> Facebook.object_count(:likes, "1326382730725053_1326476257382367", "<Token>")
-      {:ok, 2}
-      iex> Facebook.object_count(:comments, "1326382730725053_1326476257382367", "<Token>")
-      {:ok, 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
@@ -330,11 +313,11 @@ defmodule Facebook do
     * :none
 
   ## Examples
-      iex> Facebook.object_count(:reaction, :wow, "769860109692136_1173416799336463", "<Token>")
+      iex> Facebook.object_count(:reaction, :wow, "769860109692136_1173416799336463", "<Access Token>")
       {:ok, 100}
-      iex> Facebook.object_count(:reaction, :haha, "769860109692136_1173416799336463", "<Token>")
+      iex> Facebook.object_count(:reaction, :haha, "769860109692136_1173416799336463", "<Access Token>")
       {:ok, 100}
-      iex> Facebook.object_count(:reaction, :thankful, "769860109692136_1173416799336463", "<Token>")
+      iex> Facebook.object_count(:reaction, :thankful, "769860109692136_1173416799336463", "<Access Token>")
       {:ok, 100}
   """
   @spec object_count(reaction, react_type :: atom, object_id :: String.t, access_token) :: number
@@ -355,7 +338,7 @@ defmodule Facebook do
   Get all the object reactions with single request.
 
   ## Examples
-      iex> Facebook.object_count_all("769860109692136_1173416799336463", "<Token>")
+      iex> Facebook.object_count_all("769860109692136_1173416799336463", "<Access Token>")
       {:ok, %{"angry" => 0, "haha" => 1, "like" => 0, "love" => 0, "sad" => 0, "wow" => 0}}
   """
   @spec object_count_all(object_id :: String.t, access_token) :: map
@@ -381,11 +364,11 @@ defmodule Facebook do
 
   ## Examples
       iex> Facebook.access_token("client_id", "client_secret", "redirect_uri", "code")
-      %{
-        "access_token" => "ACCESS_TOKEN",
+      {: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
   """
@@ -403,11 +386,11 @@ defmodule Facebook do
 
   ## Examples
       iex> Facebook.long_lived_access_token("client_id", "client_secret", "access_token")
-      %{
-        "access_token" => "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
   """
@@ -430,13 +413,13 @@ defmodule Facebook do
 
   ## Examples
     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 test_users(String.t, String.t) :: Map.t
   def test_users(app_id, access_token) do
@@ -450,11 +433,7 @@ defmodule Facebook do
   # Request access token and extract the access token from the access token
   # response
   defp get_access_token(params) do
-    case Facebook.Graph.get(~s(/oauth/access_token), params) do
-      {:error, error} -> {:error, error}
-      {:ok, %{"summary" => summary}} -> summary
-      {:ok, info_map} -> info_map
-    end
+    Facebook.Graph.get(~s(/oauth/access_token), params)
   end
 
   # Provides the summary of a GET request when the 'summary' query parameter is
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/test/facebook_test.exs b/test/facebook_test.exs
index d4a59f1..2f6e87a 100644
--- a/test/facebook_test.exs
+++ b/test/facebook_test.exs
@@ -3,31 +3,18 @@ defmodule FacebookTest do
 
   import Mock
 
-  @app_id System.get_env("FBEX_APP_ID")
-  @app_secret System.get_env("FBEX_APP_SECRET")
+  @app_id "123"
+  @app_secret "456"
   # 19292868552 = facebook for developers page
   @page_id 19292868552
   # 629965917187496 = page id the test user created
   @test_page_id 629965917187496
 
   setup do
-    assert(@app_id != nil)
-    assert(@app_secret != nil)
-
-    Facebook.setAppsecret(@app_secret)
-
-    app_access_token = "#{@app_id}|#{@app_secret}"
-
-    {:ok, %{"data" => [user]}} = Facebook.test_users(@app_id, app_access_token)
-
-    assert(String.length(user["access_token"]) > 0)
-    assert(String.length(user["id"]) > 0)
-    assert(String.length(user["login_url"]) > 0)
-
     [
-      app_access_token: app_access_token,
-      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
@@ -282,18 +269,21 @@ defmodule FacebookTest do
     end
   end
 
-  describe "page_likes" do
+  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, :fan_count) end
+        body: fn(_) -> Facebook.GraphMock.page(:success) end
       ] do
-        assert {:ok, %{"fan_count" => _}} = Facebook.page_likes(
-          @page_id,
-          app_access_token
-        )
+        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
 
@@ -304,25 +294,25 @@ defmodule FacebookTest do
         end,
         body: fn(_) -> Facebook.GraphMock.error() end
       ] do
-        assert {:error, _} = Facebook.page_likes(@page_id, invalid_access_token)
+        assert {:error, _} = Facebook.page(@page_id, invalid_access_token)
       end
     end
   end
 
-  describe "page" do
+  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) end
+        body: fn(_) -> Facebook.GraphMock.page(:success, :with_fields) end
       ] do
         assert {:ok, %{
-          "name" => name,
-          "id" => id
-        }} = Facebook.page(@page_id, app_access_token)
+          "id" => id,
+          "about" => about
+        }} = Facebook.page(@page_id, app_access_token, ["about"])
 
-        assert(String.length(name) > 0)
+        assert(String.length(about) > 0)
         assert(id == Integer.to_string(@page_id, 10))
       end
     end
@@ -334,26 +324,36 @@ defmodule FacebookTest do
         end,
         body: fn(_) -> Facebook.GraphMock.error() end
       ] do
-        assert {:error, _} = Facebook.page(@page_id, invalid_access_token)
+        assert {:error, _} = Facebook.page(
+          @page_id,
+          invalid_access_token,
+          ["about"]
+        )
       end
     end
   end
 
-  describe "page with fields" do
+  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, :with_fields) end
+        body: fn(_) -> Facebook.GraphMock.page(:success, :feed) end
       ] do
-        assert {:ok, %{
-          "id" => id,
-          "about" => about
-        }} = Facebook.page(@page_id, app_access_token, ["about"])
+        assert {:ok, %{"data" => [data | _]}} = Facebook.page_feed(
+          :feed,
+          @page_id,
+          app_access_token,
+          1
+        )
 
-        assert(String.length(about) > 0)
-        assert(id == Integer.to_string(@page_id, 10))
+        assert %{
+          "id" => _,
+          "created_time" => _,
+          "message" => _,
+          "story" => _
+        } = data
       end
     end
 
@@ -364,38 +364,68 @@ defmodule FacebookTest do
         end,
         body: fn(_) -> Facebook.GraphMock.error() end
       ] do
-        assert {:error, _} = Facebook.page(
+        assert {:error, _} = Facebook.page_feed(
+          :feed,
           @page_id,
           invalid_access_token,
-          ["about"]
+          1
         )
       end
     end
   end
 
-  test "page feed", %{access_token: access_token} do
-    data = Facebook.page_feed(:feed, @test_page_id, access_token)
-    assert(data != nil)
+  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 count", %{access_token: access_token} do
-    count = Facebook.object_count(:likes, "#{@test_page_id}_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 reaction count", %{access_token: access_token} do
-    count = Facebook.object_count(:reaction, :wow, "#{@test_page_id}_629967087187379", access_token)
-    assert(count >= 0)
-  end
+  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
+        )
 
-  test "object count all", %{access_token: access_token} do
-    counts = Facebook.object_count_all("#{@test_page_id}_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)
+        assert haha == 135
+        assert love == 10
+      end
+    end
   end
 
   describe "long lived access token" do
@@ -406,11 +436,11 @@ defmodule FacebookTest do
         end,
         body: fn(_) -> Facebook.GraphMock.long_lived_access_token(:success) end
       ] do
-        assert %{
+        assert {:ok, %{
           "access_token" => access_token,
           "expires_in" => expires_in,
           "token_type" => token_type
-        } = Facebook.long_lived_access_token(
+        }} = Facebook.long_lived_access_token(
           @app_id,
           @app_secret,
           access_token
@@ -438,15 +468,27 @@ defmodule FacebookTest do
     end
   end
 
-  test "new stream", %{access_token: access_token} do
-    stream =
-      Facebook.page_feed(:feed, @test_page_id, access_token, 25)
-      |> Facebook.Stream.new
-
-    # get 150 posts
-    posts = stream |> Stream.take(150) |> Enum.to_list
+  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) == 150)
+        assert(length(posts) == 1)
+      end
+    end
   end
 end
 
@@ -480,12 +522,34 @@ defmodule Facebook.GraphMock do
     })
   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",

From 0eda4b4a54fade516e5f3d7b6909382ddd2b7716 Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Wed, 25 Oct 2017 00:05:19 -0700
Subject: [PATCH 5/8] Remove unnecessary deps

---
 mix.exs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/mix.exs b/mix.exs
index eeaf35b..2020153 100644
--- a/mix.exs
+++ b/mix.exs
@@ -55,10 +55,6 @@ defmodule Facebook.Mixfile do
       {:hackney, "~> 1.6"},
       {:ex_doc, ">= 0.13.0", only: :dev},
 
-      {:credo,      "~> 0.8", only: [:dev, :test]},
-      # TODO: take out apex
-      {:apex, "~>1.1.0"},
-
       {:mock, "~> 0.2.0", only: :test},
       {:mix_test_watch, "~> 0.3", only: :dev, runtime: false}
     ]

From 178ec2125ee4bdc2f5f465089170b5f0fd062607 Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Wed, 25 Oct 2017 00:13:17 -0700
Subject: [PATCH 6/8] Update @spec definitions

---
 lib/facebook.ex | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/lib/facebook.ex b/lib/facebook.ex
index 4889979..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 :: {:ok, 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
 
@@ -258,7 +258,7 @@ defmodule Facebook do
 
   See: https://developers.facebook.com/docs/graph-api/reference/page/feed
   """
-  @spec page_feed(scope :: atom | String.t, page_id :: String.t, access_token, limit :: number, fields :: String.t) :: Map.t
+  @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)
@@ -286,7 +286,7 @@ defmodule Facebook do
   See: https://developers.facebook.com/docs/graph-api/reference/object/likes
   See: https://developers.facebook.com/docs/graph-api/reference/object/comments
   """
-  @spec object_count(scope :: atom, object_id :: String.t, access_token) :: number
+  @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)
@@ -320,7 +320,7 @@ defmodule Facebook do
       iex> Facebook.object_count(:reaction, :thankful, "769860109692136_1173416799336463", "<Access Token>")
       {:ok, 100}
   """
-  @spec object_count(reaction, react_type :: atom, object_id :: String.t, access_token) :: number
+  @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
@@ -341,7 +341,7 @@ defmodule Facebook do
       iex> Facebook.object_count_all("769860109692136_1173416799336463", "<Access Token>")
       {:ok, %{"angry" => 0, "haha" => 1, "like" => 0, "love" => 0, "sad" => 0, "wow" => 0}}
   """
-  @spec object_count_all(object_id :: String.t, access_token) :: map
+  @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),
@@ -372,7 +372,7 @@ defmodule Facebook do
 
   See: https://developers.facebook.com/docs/facebook-login/manually-build-a-login-flow#confirm
   """
-  @spec access_token(String.t, String.t, String.t, String.t) :: String.t
+  @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,
@@ -394,7 +394,7 @@ defmodule Facebook do
 
   See: https://developers.facebook.com/docs/facebook-login/access-tokens/expiration-and-extension
   """
-  @spec long_lived_access_token(String.t, String.t, String.t) :: String.t
+  @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,
@@ -421,7 +421,7 @@ defmodule Facebook do
       }
     ]}
   """
-  @spec test_users(String.t, String.t) :: Map.t
+  @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),

From dec15e58b19d76091d5f143327266e122a7362dd Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Wed, 25 Oct 2017 22:08:05 -0700
Subject: [PATCH 7/8] line notes: update mock location

---
 test/facebook_test.exs | 108 +----------------------------------------
 test/graph_mock.ex     | 100 ++++++++++++++++++++++++++++++++------
 test/test_helper.exs   |   2 +
 3 files changed, 90 insertions(+), 120 deletions(-)

diff --git a/test/facebook_test.exs b/test/facebook_test.exs
index 2f6e87a..a9a34c0 100644
--- a/test/facebook_test.exs
+++ b/test/facebook_test.exs
@@ -1,6 +1,7 @@
-defmodule FacebookTest do
+defmodule Facebook.FacebookTest do
   use ExUnit.Case, async: false
 
+  import Facebook.GraphMock
   import Mock
 
   @app_id "123"
@@ -491,108 +492,3 @@ defmodule FacebookTest do
     end
   end
 end
-
-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/graph_mock.ex b/test/graph_mock.ex
index a31e3eb..02f5a22 100644
--- a/test/graph_mock.ex
+++ b/test/graph_mock.ex
@@ -1,32 +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 me(:error) do
-    JSON.encode(%{"error": %{
-      "message": "Invalid OAuth access token.",
-      "type": "OAuthException",
-      "code": 190,
-      "fbtrace_id": "GB4fbEEGxkW"
+  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/v/t1.0-1/s50x50/10354686_10150004552801856_220367501106153455_n.jpg?oh=90b508dc37562a01ebe9c7b9292b9a2f&oe=5A800C40"
+      "url": "https://scontent.xx.fbcdn.net/..."
     }})
   end
 
-  def picture(:error) do
-    JSON.encode(%{"error": %{
-      "message": "Invalid OAuth access token.",
-      "type": "OAuthException",
-      "code": 190,
-      "fbtrace_id": "GB4fbEEGxkW"
-    }})
+  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()

From 5305bfa2a46393a4f49b9c332d1c323b0760a456 Mon Sep 17 00:00:00 2001
From: Paul Ruescher <paul.ruescher@gmail.com>
Date: Wed, 25 Oct 2017 23:04:47 -0700
Subject: [PATCH 8/8] line note: remove unnecessary .gitignore rules

---
 .gitignore | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/.gitignore b/.gitignore
index e4ec589..f20f9d3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,9 +7,3 @@ mix.lock
 .exenv-version
 doc
 .DS_Store
-
-# asdf
-.tool-versions
-
-# FB Tokens
-.env