added new test functions, added some convenience function for dropping and creating indexes

Author: zookzook

lib/mongo.ex

@@ -1041,6 +1041,27 @@ defmodule Mongo do
     end
   end
 
+  @doc """
+  Convenient function to creates new indexes in the collection `coll`.
+  """
+  @spec create_indexes(GenServer.server, String.t, Keyword.t, Keyword.t) :: :ok | {:error, Mongo.Error.t}
+  def create_indexes(topology_pid, coll, indexes, opts \\ []) do
+    cmd = [createIndexes: coll, indexes: indexes]
+    with {:ok, _} <- Mongo.issue_command(topology_pid, cmd, :write, opts) do
+      :ok
+    end
+  end
+
+  @doc """
+  Convenient function that drops the collection `coll`.
+  """
+  @spec drop_collection(GenServer.server, String.t, Keyword.t) :: :ok | {:error, Mongo.Error.t}
+  def drop_collection(topology_pid, coll, opts \\ []) do
+    with {:ok, _} <- Mongo.issue_command(topology_pid, [drop: coll], :write, opts) do
+      :ok
+    end
+  end
+
   @doc """
   Getting Collection Names
   """

lib/mongo/grid_fs/bucket.ex

@@ -96,10 +96,12 @@ defmodule Mongo.GridFs.Bucket do
   Drops the files and chunks collections associated with
   this bucket.
   """
-  @spec drop(Bucket.t) :: Mongo.result(BSON.document)
+  @spec drop(Bucket.t) :: :ok | {:error, Mongo.Error.t}
   def drop(%Bucket{topology_pid: topology_pid, opts: opts} = bucket) do
-    {:ok, _} = Mongo.issue_command(topology_pid, [drop: files_collection_name(bucket)], :write, opts)
-    {:ok, _} = Mongo.issue_command(topology_pid, [drop: chunks_collection_name(bucket)], :write, opts)
+    with :ok <- Mongo.drop_collection(topology_pid, files_collection_name(bucket), opts),
+         :ok <- Mongo.drop_collection(topology_pid, chunks_collection_name(bucket), opts) do
+      :ok
+    end
   end
 
   @doc """
@@ -212,20 +214,14 @@ defmodule Mongo.GridFs.Bucket do
   # Creates the indexes for the fs.chunks collection
   #
   defp create_chunks_index(%Bucket{topology_pid: topology_pid, opts: opts} = bucket) do
-    cmd = [createIndexes: chunks_collection_name(bucket), indexes: [[key: [files_id: 1, n: 1], name: @chunks_index_name, unique: true]]]
-    with {:ok, _} <- Mongo.issue_command(topology_pid, cmd, :write, opts) do
-      :ok
-    end
+    Mongo.create_indexes(topology_pid, chunks_collection_name(bucket), [[key: [files_id: 1, n: 1], name: @chunks_index_name, unique: true]], opts)
   end
 
   ##
   # Creates the indexes for the fs.files collection
   #
   defp create_files_index(%Bucket{topology_pid: topology_pid, opts: opts} = bucket) do
-    cmd = [createIndexes: files_collection_name(bucket), indexes: [[key: [filename: 1, uploadDate: 1], name: @files_index_name]]]
-    with {:ok, _} <- Mongo.issue_command(topology_pid, cmd, :write, opts) do
-      :ok
-    end
+    Mongo.create_indexes(topology_pid, files_collection_name(bucket), [[key: [filename: 1, uploadDate: 1], name: @files_index_name]], opts)
   end
 
 end

lib/session/session_pool.ex

@@ -38,22 +38,19 @@ defmodule Mongo.Session.SessionPool do
   @spec checkin(GenServer.server, ServerSession.t) :: none()
   @compile {:inline, checkin: 2}
   def checkin(%{queue: queue, timeout: timeout} = pool, session) do
-
-    # queue = prune(queue, timeout)
-
     case ServerSession.about_to_expire?(session, timeout) do
       true  -> %{pool | queue: queue}
       false -> %{pool | queue: [session | queue]}
     end
   end
 
   ##
-  # remove all old sessions
+  # remove all old sessions, dead code
   #
-  def prune(%{queue: queue, timeout: timeout} = pool) do
-    queue = Enum.reject(queue, fn session -> ServerSession.about_to_expire?(session, timeout) end)
-    %{pool | queue: queue}
-  end
+  #def prune(%{queue: queue, timeout: timeout} = pool) do
+  #  queue = Enum.reject(queue, fn session -> ServerSession.about_to_expire?(session, timeout) end)
+  #  %{pool | queue: queue}
+  #end
 
   ##
   # find the next valid sessions and removes all sessions that timed out

test/mongo/grid_fs/download_test.exs

@@ -0,0 +1,115 @@
+defmodule Mongo.GridFs.DownloadTest do
+  use ExUnit.Case
+
+  alias Mongo.GridFs.Bucket
+  alias Mongo.GridFs.Upload
+  alias Mongo.GridFs.Download
+  alias BSON.ObjectId
+
+  setup_all do
+    assert {:ok, pid} = Mongo.TestConnection.connect
+    bucket = Bucket.new(pid)
+
+    upload_stream = Upload.open_upload_stream(bucket, "test.jpg", nil)
+    src_filename = "./test/data/test.jpg"
+    File.stream!(src_filename, [], 512) |> Stream.into(upload_stream) |> Stream.run()
+    file_id = upload_stream.id
+    assert file_id != nil
+
+    {:ok, [pid: pid, bucket: bucket, id: file_id]}
+  end
+
+  test "open_download_stream - binary", c do
+
+    dest_filename = "/tmp/my-test-file.jps"
+    File.rm(dest_filename)
+
+    with {:ok, stream} <- Download.open_download_stream(c.bucket, ObjectId.encode!(c.id)) do
+      stream
+      |> Stream.into(File.stream!(dest_filename))
+      |> Stream.run
+    end
+
+    assert true == File.exists?(dest_filename)
+
+  end
+
+  test "open_download_stream - object id", c do
+
+    dest_filename = "/tmp/my-test-file.jps"
+    File.rm(dest_filename)
+
+    with {:ok, stream} <- Download.open_download_stream(c.bucket, c.id) do
+      stream
+      |> Stream.into(File.stream!(dest_filename))
+      |> Stream.run
+    end
+
+    assert true == File.exists?(dest_filename)
+
+  end
+
+  test "open_download_stream - map ", c do
+
+    assert c.id != nil
+    file = Download.find_one_file(c.bucket, c.id)
+
+    dest_filename = "/tmp/my-test-file.jps"
+    File.rm(dest_filename)
+
+    with {:ok, stream} <- Download.open_download_stream(c.bucket, file) do
+      stream
+      |> Stream.into(File.stream!(dest_filename))
+      |> Stream.run
+    end
+
+    assert true == File.exists?(dest_filename)
+
+  end
+
+  test "find_and_stream", c do
+
+    dest_filename = "/tmp/my-test-file.jps"
+    File.rm(dest_filename)
+
+    with {{:ok, stream}, file_info} <- Download.find_and_stream(c.bucket, c.id) do
+      stream
+      |> Stream.into(File.stream!(dest_filename))
+      |> Stream.run
+      assert file_info["filename"] == "test.jpg"
+    end
+
+    assert true == File.exists?(dest_filename)
+
+    File.rm(dest_filename)
+
+    with {{:ok, stream}, file_info} <- Download.find_and_stream(c.bucket, ObjectId.encode!(c.id)) do
+      stream
+      |> Stream.into(File.stream!(dest_filename))
+      |> Stream.run
+      assert file_info["filename"] == "test.jpg"
+    end
+
+    assert true == File.exists?(dest_filename)
+
+  end
+
+  test "find_one_file - filename ", c do
+
+    assert c.id != nil
+    file = Download.find_one_file(c.bucket, "test.jpg")
+
+    dest_filename = "/tmp/my-test-file.jps"
+    File.rm(dest_filename)
+
+    with {:ok, stream} <- Download.open_download_stream(c.bucket, file) do
+      stream
+      |> Stream.into(File.stream!(dest_filename))
+      |> Stream.run
+    end
+
+    assert true == File.exists?(dest_filename)
+
+  end
+
+end

test/mongo/session_test.exs

@@ -74,7 +74,7 @@ defmodule Mongo.SessionTest do
     {session_a, session_pool} = SessionPool.checkout(session_pool)
     {session_b, session_pool} = SessionPool.checkout(session_pool)
 
-    session_a = session_a|> make_old(-59)
+    session_a = session_a |> make_old(-59)
     session_b = session_b |> make_old(-59)
 
     session_pool = SessionPool.checkin(session_pool, session_a)