Switch to :ok/:error tuple response

Author: hamiltop

lib/rethinkdb/response.ex

@@ -25,7 +25,7 @@ defmodule RethinkDB.Feed do
     def reduce(changes, acc, fun) do
       stream = Stream.unfold(changes, fn
         x = %RethinkDB.Feed{data: []} ->
-          r = RethinkDB.next(x)
+          {:ok, r} = RethinkDB.next(x)
           {r, struct(r, data: [])}
         x = %RethinkDB.Feed{} ->
           {x, struct(x, data: [])}
@@ -48,19 +48,19 @@ defmodule RethinkDB.Response do
   def parse(raw_data, token, pid) do
     d = Poison.decode!(raw_data)
     data = RethinkDB.Pseudotypes.convert_reql_pseudotypes(d["r"])
-    resp = case d["t"] do
-      1  -> %RethinkDB.Record{data: hd(data)}
-      2  -> %RethinkDB.Collection{data: data}
+    {code, resp} = case d["t"] do
+      1  -> {:ok, %RethinkDB.Record{data: hd(data)}}
+      2  -> {:ok, %RethinkDB.Collection{data: data}}
       3  -> case d["n"] do
-          [2] -> %RethinkDB.Feed{token: token, data: hd(data), pid: pid, note: d["n"]}
-           _  -> %RethinkDB.Feed{token: token, data: data, pid: pid, note: d["n"]}
+          [2] -> {:ok, %RethinkDB.Feed{token: token, data: hd(data), pid: pid, note: d["n"]}}
+           _  -> {:ok, %RethinkDB.Feed{token: token, data: data, pid: pid, note: d["n"]}}
         end
-      4  -> %RethinkDB.Response{token: token, data: d}
-      16  -> %RethinkDB.Response{token: token, data: d}
-      17  -> %RethinkDB.Response{token: token, data: d}
-      18  -> %RethinkDB.Response{token: token, data: d}
+      4  ->  {:ok, %RethinkDB.Response{token: token, data: d}}
+      16  -> {:error, %RethinkDB.Response{token: token, data: d}}
+      17  -> {:error, %RethinkDB.Response{token: token, data: d}}
+      18  -> {:error, %RethinkDB.Response{token: token, data: d}}
     end
-    %{resp | :profile => d["p"]}
+    {code, %{resp | :profile => d["p"]}}
   end
 end
 

test/changes_test.exs

@@ -22,7 +22,7 @@ defmodule ChangesTest do
 
   test "first change" do
     q = table(@table_name) |> changes
-    changes = %Feed{} = run(q)
+    {:ok, changes = %Feed{}} = run(q)
 
     t = Task.async fn ->
       changes |> Enum.take(1)
@@ -35,15 +35,15 @@ defmodule ChangesTest do
 
   test "changes" do
     q = table(@table_name) |> changes
-    changes = %Feed{} = run(q)
+    {:ok, changes} = {:ok, %Feed{}} = run(q)
     t = Task.async fn ->
       RethinkDB.Connection.next(changes)
     end
     data = %{"test" => "data"}
     q = table(@table_name) |> insert(data)
-    res = run(q)
+    {:ok, res} = run(q)
     expected = res.data["id"]
-    changes = Task.await(t) 
+    {:ok, changes} = Task.await(t) 
     ^expected = changes.data |> hd |> Map.get("id")
 
     # test Enumerable

test/connection_test.exs

@@ -32,7 +32,7 @@ defmodule ConnectionTest do
     %RethinkDB.Exception.ConnectionClosed{} = table_list |> run
     conn = FlakyConnection.start('localhost', 28015, [local_port: 28014])
     :timer.sleep(1000)
-    %RethinkDB.Record{} = RethinkDB.Query.table_list |> run
+    {:ok, %RethinkDB.Record{}} = RethinkDB.Query.table_list |> run
     ref = Process.monitor(c)
     FlakyConnection.stop(conn)
     receive do
@@ -53,7 +53,7 @@ defmodule ConnectionTest do
       GenServer.cast(__MODULE__, :stop)
     end
     table(table) |> index_wait |> run
-    change_feed = table(table) |> changes |> run
+    {:ok, change_feed} = table(table) |> changes |> run
     task = Task.async fn ->
       RethinkDB.Connection.next change_feed
     end
@@ -84,7 +84,7 @@ defmodule ConnectionTest do
     {:ok, c} = RethinkDB.Connection.start_link(db: "new_test")
     db_create("new_test") |> RethinkDB.run(c)
     db("new_test") |> table_create("new_test_table") |> RethinkDB.run(c)
-    %{data: data} = table_list |> RethinkDB.run(c)
+    {:ok, %{data: data}} = table_list |> RethinkDB.run(c)
     assert data == ["new_test_table"]
   end
 
@@ -109,7 +109,7 @@ defmodule ConnectionTest do
   test "ssl connection" do
     conn = FlakyConnection.start('localhost', 28015, [ssl: [keyfile: "./test/cert/host.key", certfile: "./test/cert/host.crt"]])
     {:ok, c} = RethinkDB.Connection.start_link(port: conn.port, ssl: [ca_certs: ["./test/cert/rootCA.crt"]], sync_connect: true)
-    %{data: _} = table_list |> RethinkDB.run(c)
+    {:ok, %{data: _}} = table_list |> RethinkDB.run(c)
   end
 end
 
@@ -127,7 +127,7 @@ defmodule ConnectionRunTest do
     db_create("db_option_test") |> run
     table_create("db_option_test_table") |> run(db: "db_option_test")
 
-    %{data: data} = db("db_option_test") |> table_list |> run
+    {:ok, %{data: data}} = db("db_option_test") |> table_list |> run
 
     db_drop("db_option_test") |> run
 
@@ -136,7 +136,7 @@ defmodule ConnectionRunTest do
 
   test "run(conn, opts) with :durability option" do
     table_drop("durability_test_table") |> run
-    response = table_create("durability_test_table") |> run(durability: "soft")
+    {:ok, response} = table_create("durability_test_table") |> run(durability: "soft")
     durability = response.data["config_changes"]
                  |> List.first
                  |> Map.fetch!("new_val")
@@ -153,7 +153,7 @@ defmodule ConnectionRunTest do
   end
 
   test "run with :profile options" do
-    resp = make_array([1,2,3]) |> run(profile: true)
+    {:ok, resp} = make_array([1,2,3]) |> run(profile: true)
     assert [%{"description" => _, "duration(ms)" => _,
              "sub_tasks" => _}] = resp.profile
   end

test/query/administration_query_test.exs

@@ -18,27 +18,27 @@ defmodule AdministrationQueryTest do
   end
 
   test "config" do
-    r = table(@table_name) |> config |> run
+    {:ok, r} = table(@table_name) |> config |> run
     assert %RethinkDB.Record{data: %{"db" => "test"}} = r
   end
 
   test "rebalance" do
-    r = table(@table_name) |> rebalance |> run
+    {:ok, r} = table(@table_name) |> rebalance |> run
     assert %RethinkDB.Record{data: %{"rebalanced" => _}} = r
   end
 
   test "reconfigure" do
-    r = table(@table_name) |> reconfigure(shards: 1, dry_run: true, replicas: 1) |> run
+    {:ok, r} = table(@table_name) |> reconfigure(shards: 1, dry_run: true, replicas: 1) |> run
     assert %RethinkDB.Record{data: %{"reconfigured" => _}} = r
   end
 
   test "status" do
-    r = table(@table_name) |> status |> run
+    {:ok, r} = table(@table_name) |> status |> run
     assert %RethinkDB.Record{data: %{"name" => @table_name}} = r
   end
 
   test "wait" do
-    r = table(@table_name) |> wait(wait_for: :ready_for_writes) |> run
+    {:ok, r} = table(@table_name) |> wait(wait_for: :ready_for_writes) |> run
     assert %RethinkDB.Record{data: %{"ready" => 1}} = r
   end
 end

test/query/aggregation_test.exs

@@ -21,7 +21,7 @@ defmodule AggregationTest do
         %{a: "bye"}
       ]
       |> group("a")
-    %Record{data: data} = query |> run
+    {:ok, %Record{data: data}} = query |> run
     assert data == %{
       "bye" => [
         %{"a" => "bye"}
@@ -43,7 +43,7 @@ defmodule AggregationTest do
       |> group(lambda fn (x) ->
         (x["a"] == "hi") || (x["a"] == "hello")
       end)
-    %Record{data: data} = query |> run
+    {:ok, %Record{data: data}} = query |> run
     assert data == %{
       false: [
         %{"a" => "bye"},
@@ -67,7 +67,7 @@ defmodule AggregationTest do
       |> group([lambda(fn (x) ->
         (x["a"] == "hi") || (x["a"] == "hello")
       end), "b"])
-    %Record{data: data} = query |> run
+    {:ok, %Record{data: data}} = query |> run
     assert data == %{
       [false, nil] => [
         %{"a" => "bye"},
@@ -95,7 +95,7 @@ defmodule AggregationTest do
         (x["a"] == "hi") || (x["a"] == "hello")
       end), "b"])
       |> ungroup
-    %Record{data: data} = query |> run
+    {:ok, %Record{data: data}} = query |> run
     assert data == [
       %{
         "group" => [false, nil],
@@ -124,39 +124,39 @@ defmodule AggregationTest do
     query = [1,2,3,4] |> reduce(lambda fn(el, acc) ->
       el + acc
     end)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 10
   end
 
   test "count" do
     query = [1,2,3,4] |> count
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 4
   end
 
   test "count with value" do
     query = [1,2,2,3,4] |> count(2)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 2
   end
 
   test "count with predicate" do
     query = [1,2,2,3,4] |> count(lambda fn(x) ->
       rem(x, 2) == 0
     end)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 3
   end
 
   test "sum" do
     query = [1,2,3,4] |> sum
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 10
   end
 
   test "sum with field" do
     query = [%{a: 1},%{a: 2},%{b: 3},%{b: 4}] |> sum("a")
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 3
   end
 
@@ -168,19 +168,19 @@ defmodule AggregationTest do
         x * 2
       end
     end)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 18
   end
 
   test "avg" do
     query = [1,2,3,4] |> avg
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 2.5
   end
 
   test "avg with field" do
     query = [%{a: 1},%{a: 2},%{b: 3},%{b: 4}] |> avg("a")
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 1.5
   end
 
@@ -192,25 +192,25 @@ defmodule AggregationTest do
         x * 2
       end
     end)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 6
   end
 
   test "min" do
     query = [1,2,3,4] |> Query.min
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 1
   end
 
   test "min with field" do
     query = [%{a: 1},%{a: 2},%{b: 3},%{b: 4}] |> Query.min("b")
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == %{"b" => 3}
   end
 
   test "min with subquery field" do
     query = [%{a: 1},%{a: 2},%{b: 3},%{b: 4}] |> Query.min(Query.downcase("B"))
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == %{"b" => 3}
   end
 
@@ -223,25 +223,25 @@ defmodule AggregationTest do
         x * 2
       end
     end)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 2  
   end
 
   test "max" do
     query = [1,2,3,4] |> Query.max
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 4
   end
 
   test "max with field" do
     query = [%{a: 1},%{a: 2},%{b: 3},%{b: 4}] |> Query.max("b")
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == %{"b" => 4}
   end
 
   test "max with subquery field" do
     query = [%{a: 1},%{a: 2},%{b: 3},%{b: 4}] |> Query.max(Query.downcase("B"))
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == %{"b" => 4}
   end
 
@@ -253,13 +253,13 @@ defmodule AggregationTest do
         x * 2
       end
     end)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == 3
   end
 
   test "distinct" do
     query = [1,2,3,3,4,4,5] |> distinct
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == [1,2,3,4,5]
   end
 
@@ -270,31 +270,31 @@ defmodule AggregationTest do
 
   test "contains" do
     query = [1,2,3,4] |> contains(4)
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == true
   end
 
   test "contains multiple values" do
     query = [1,2,3,4] |> contains([4, 3])
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == true
   end
 
   test "contains with function" do
     query = [1,2,3,4] |> contains(lambda &(&1 == 3))
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == true
   end
 
   test "contains with multiple function" do
     query = [1,2,3,4] |> contains([lambda(&(&1 == 3)), lambda(&(&1 == 5))])
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == false
   end
 
   test "contains with multiple (mixed)" do
     query = [1,2,3,4] |> contains([lambda(&(&1 == 3)), 2])
-    %Record{data: data} = run query
+    {:ok, %Record{data: data}} = run query
     assert data == true
   end
 end

test/query/control_structures_adv_test.exs

@@ -28,7 +28,7 @@ defmodule ControlStructuresAdvTest do
       table_query |> insert(%{a: x})
     end)
     run q
-    %Collection{data: data} = run table_query
+    {:ok, %Collection{data: data}} = run table_query
     assert Enum.count(data) == 3
   end
 end