added more tests

Author: zookzook

coveralls.json

@@ -0,0 +1,6 @@
+{
+  "skip_files": [
+    "lib/bson/utils.ex",
+    "lib/mongo/binary_utils.ex"
+  ]
+}

lib/bson.ex

@@ -14,7 +14,10 @@ defmodule BSON do
   """
   @spec encode(document) :: iodata
   def encode(map) when is_map(map) do
-    BSON.Encoder.encode(map)
+    case Map.has_key?(map, :__struct__) do
+       true  -> BSON.Encoder.encode(Map.to_list(map))
+       false -> BSON.Encoder.encode(map)
+    end
   end
 
   def encode([{_, _}|_] = keyword) do

lib/bson/encoder.ex

@@ -98,18 +98,10 @@ defmodule BSON.Encoder do
   def document(doc) do
     {_, iodata} =
       Enum.reduce(doc, {:unknown, ""}, fn
-        {:__struct__, _value}, {:binary, _acc} ->
-          invalid_doc(doc)
-
-        {:__struct__, _value}, {_, acc} ->
-          {:atom, acc}
-
-        {key, _value}, {:binary, _acc} when is_atom(key) ->
-          invalid_doc(doc)
-
-        {key, _value}, {:atom, _acc} when is_binary(key) ->
-          invalid_doc(doc)
-
+        {:__struct__, _value}, {:binary, _acc} -> invalid_doc(doc)
+        {:__struct__, _value}, {_, acc}        -> {:atom, acc}
+        {key, _value}, {:binary, _acc} when is_atom(key) -> invalid_doc(doc)
+        {key, _value}, {:atom, _acc} when is_binary(key) -> invalid_doc(doc)
         {key, value}, {_, acc} ->
           {key_type, key} = key(key)
           type = type(value)
@@ -122,10 +114,8 @@ defmodule BSON.Encoder do
 
   defp cstring(string), do: [string, 0x00]
 
-  defp key(value) when is_atom(value),
-    do: {:atom, cstring(Atom.to_string(value))}
-  defp key(value) when is_binary(value),
-    do: {:binary, cstring(value)}
+  defp key(value) when is_atom(value), do: {:atom, cstring(Atom.to_string(value))}
+  defp key(value) when is_binary(value), do: {:binary, cstring(value)}
 
   defp array([], _ix),
     do: []

lib/mongo/query.ex

@@ -2,21 +2,17 @@ defmodule Mongo.Query do
   @moduledoc """
     This is the query implementation for the Query Protocoll
 
-    The action attribute describes as atom the desired action. There are currently two
-    * :command
-    * :wire_version
-      
     Encoding and decoding does not take place at this point, but is directly performed
     into the functions of Mongo.MongoDBConnection.Utils.
   """
   defstruct action: nil
 end
 
 defimpl DBConnection.Query, for: Mongo.Query do
-  def parse(query, _opts), do: query
-  def describe(query, _opts), do: query
+  # coveralls-ignore-start
+  def parse(query, _opts), do: query      # gets never called
+  def describe(query, _opts), do: query   # gets never called
+  # coveralls-ignore-stop
   def encode(_query, params, _opts), do: params
-  def decode(_query, :ok, _opts), do: :ok
-  def decode(_query, wire_version, _opts) when is_integer(wire_version), do: wire_version
   def decode(_query, reply, _opts), do: reply
 end

test/bson_test.exs

@@ -1,3 +1,7 @@
+defmodule TestUser do
+  defstruct name: "John", age: 27
+end
+
 defmodule BSONTest do
   use ExUnit.Case, async: true
 
@@ -75,6 +79,19 @@ defmodule BSONTest do
   @map21 %{"q" => %BSON.Binary{binary: <<1,2,3>>, subtype: :binary_old}}
   @bin21 <<20, 0, 0, 0, 5, 113, 0, 7, 0, 0, 0, 2, 3, 0, 0, 0, 1, 2, 3, 0>>
 
+  @map22 %{"regex" => %BSON.Regex{pattern: "acme.*corp", options: "i"}}
+  @bin22 <<25, 0, 0, 0, 11, 114, 101, 103, 101, 120, 0, 97, 99, 109, 101, 46, 42, 99, 111, 114, 112, 0, 105, 0, 0>>
+
+  @map23 %{"number" => %BSON.LongNumber{value: 123}}
+  @bin23 <<21, 0, 0, 0, 18, 110, 117, 109, 98, 101, 114, 0, 123, 0, 0, 0, 0, 0, 0, 0, 0>>
+
+  @map24 %{"number" => Decimal.new("0.33")}
+  @bin24 <<29, 0, 0, 0, 19, 110, 117, 109, 98, 101, 114, 0, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 60, 48, 0>>
+
+  @map25 %TestUser{}
+  @bin25 <<29, 0, 0, 0, 16, 97, 103, 101, 0, 27, 0, 0, 0, 2, 110, 97, 109, 101, 0, 5, 0, 0, 0, 74, 111, 104, 110, 0, 0>>
+
+
   test "encode" do
     assert encode(@map1)  == @bin1
     assert encode(@map2)  == @bin2
@@ -97,6 +114,10 @@ defmodule BSONTest do
     assert encode(@map19) == @bin19
     assert encode(@map20) == @bin20
     assert encode(@map21) == @bin21
+    assert encode(@map22) == @bin22
+    assert encode(@map23) == @bin23
+    assert encode(@map24) == @bin24
+    assert encode(@map25) == @bin25
   end
 
   test "decode" do
@@ -121,6 +142,9 @@ defmodule BSONTest do
     assert decode(@bin19) == @map19
     assert decode(@bin20) == @map20
     assert decode(@bin21) == @map21
+    assert decode(@bin22) == @map22
+    assert decode(@bin23) == %{"number" => 123}
+    assert decode(@bin24) == @map24
   end
 
   test "keywords" do
@@ -181,6 +205,16 @@ defmodule BSONTest do
     assert encode(@mapNegInf) == @binNegInf
   end
 
+  test "mixing atoms with binaries" do
+    document =  1..33 |> Enum.reduce(%{}, fn(x, acc) -> Map.put(acc,to_string(x),x) end ) |> Map.put(:a, 10)
+    assert_raise ArgumentError, fn -> encode(document) end
+    document = %{:key => "value", "id" => 10}
+    assert_raise ArgumentError, fn -> encode(document) end
+    document =  1..33 |> Enum.reduce(%{}, fn(x, acc) -> Map.put(acc,to_string(x),x) end ) |> Map.put(:__struct__, TestUser)
+    assert_raise ArgumentError, fn -> encode(document) end
+
+  end
+
   defp encode(value) do
     value |> BSON.encode |> IO.iodata_to_binary
   end

test/mongo/cursor_test.exs

@@ -18,7 +18,7 @@ defmodule Mongo.CursorTest do
     docs = Stream.cycle([%{foo: 42}]) |> Enum.take(100)
 
     assert {:ok, _} = Mongo.insert_many(c.pid, coll, docs)
-    assert [%{"foo" => 42}, %{"foo" => 42}] = Mongo.find(c.pid, coll, %{}, limit: 2) |> Enum.to_list |> Enum.map(fn m ->  Map.pop(m, "_id") |> elem(1) end)
+    assert [%{"foo" => 42}, %{"foo" => 42}] = Mongo.find(c.pid, coll, %{}, limit: 2)|> Enum.to_list |> Enum.map(fn m ->  Map.pop(m, "_id") |> elem(1) end)
   end
 
   # issue #35: Crash executing find function without enough permission