Add tests for :timezone option in mix ecto.create

Author: josevalim

lib/mix/tasks/ecto.create.ex

@@ -60,7 +60,9 @@ defmodule Mix.Tasks.Ecto.Create do
         "create storage for #{inspect(repo)}"
       )
 
-      case repo.__adapter__().storage_up(repo.config()) do
+      config_opts = Keyword.take(opts, [:timezone]) ++ repo.config()
+
+      case repo.__adapter__().storage_up(config_opts) do
         :ok ->
           unless opts[:quiet] do
             Mix.shell().info("The database for #{inspect(repo)} has been created")

test/mix/tasks/ecto.create_drop_test.exs

@@ -10,27 +10,32 @@ defmodule Mix.Tasks.Ecto.CreateDropTest do
     @behaviour Ecto.Adapter.Storage
 
     defmacro __before_compile__(_), do: :ok
-    def dumpers(_, _), do: raise "not implemented"
-    def loaders(_, _), do: raise "not implemented"
-    def init(_), do: raise "not implemented"
-    def checkout(_, _, _), do: raise "not implemented"
-    def checked_out?(_), do: raise "not implemented"
-    def ensure_all_started(_, _), do: raise "not implemented"
+    def dumpers(_, _), do: raise("not implemented")
+    def loaders(_, _), do: raise("not implemented")
+    def init(_), do: raise("not implemented")
+    def checkout(_, _, _), do: raise("not implemented")
+    def checked_out?(_), do: raise("not implemented")
+    def ensure_all_started(_, _), do: raise("not implemented")
+
+    def storage_up(opts) do
+      return = Process.get(:storage_up)
+      Process.put(:storage_up, opts)
+      return || raise "no storage_up"
+    end
 
-    def storage_up(_), do: Process.get(:storage_up) || raise "no storage_up"
-    def storage_down(_), do: Process.get(:storage_down) || raise "no storage_down"
-    def storage_status(_), do: raise "no storage_status"
+    def storage_down(_), do: Process.get(:storage_down) || raise("no storage_down")
+    def storage_status(_), do: raise("no storage_status")
   end
 
   defmodule NoStorageAdapter do
     @behaviour Ecto.Adapter
     defmacro __before_compile__(_), do: :ok
-    def dumpers(_, _), do: raise "not implemented"
-    def loaders(_, _), do: raise "not implemented"
-    def init(_), do: raise "not implemented"
-    def checkout(_, _, _), do: raise "not implemented"
-    def checked_out?(_), do: raise "not implemented"
-    def ensure_all_started(_, _), do: raise "not implemented"
+    def dumpers(_, _), do: raise("not implemented")
+    def loaders(_, _), do: raise("not implemented")
+    def init(_), do: raise("not implemented")
+    def checkout(_, _, _), do: raise("not implemented")
+    def checked_out?(_), do: raise("not implemented")
+    def ensure_all_started(_, _), do: raise("not implemented")
   end
 
   # Mocked repos
@@ -52,70 +57,95 @@ defmodule Mix.Tasks.Ecto.CreateDropTest do
 
   test "runs the adapter storage_up" do
     Process.put(:storage_up, :ok)
-    Create.run ["-r", to_string(Repo)]
-    assert_received {:mix_shell, :info, ["The database for Mix.Tasks.Ecto.CreateDropTest.Repo has been created"]}
+    Create.run(["-r", to_string(Repo)])
+
+    assert_received {:mix_shell, :info,
+                     ["The database for Mix.Tasks.Ecto.CreateDropTest.Repo has been created"]}
+  end
+
+  test "parses options" do
+    Process.put(:storage_up, :ok)
+    Create.run(["-r", to_string(Repo)])
+    refute Keyword.has_key?(Process.get(:storage_up), :timezone)
+
+    Process.put(:storage_up, :ok)
+    Create.run(["-r", to_string(Repo), "--timezone", "Europe/Warsaw"])
+    assert Keyword.take(Process.get(:storage_up), [:timezone]) == [timezone: "Europe/Warsaw"]
   end
 
   test "runs the adapter storage_up with --quiet" do
     Process.put(:storage_up, :ok)
-    Create.run ["-r", to_string(Repo), "--quiet"]
+    Create.run(["-r", to_string(Repo), "--quiet"])
     refute_received {:mix_shell, :info, [_]}
   end
 
   test "informs the user when the repo is already up" do
     Process.put(:storage_up, {:error, :already_up})
-    Create.run ["-r", to_string(Repo)]
-    assert_received {:mix_shell, :info, ["The database for Mix.Tasks.Ecto.CreateDropTest.Repo has already been created"]}
+    Create.run(["-r", to_string(Repo)])
+
+    assert_received {:mix_shell, :info,
+                     [
+                       "The database for Mix.Tasks.Ecto.CreateDropTest.Repo has already been created"
+                     ]}
   end
 
   test "raises an error when storage_up gives an unknown feedback" do
     Process.put(:storage_up, {:error, :confused})
+
     assert_raise Mix.Error, fn ->
-      Create.run ["-r", to_string(Repo)]
+      Create.run(["-r", to_string(Repo)])
     end
   end
 
   test "raises an error on storage_up when the adapter doesn't define a storage" do
     assert_raise Mix.Error, ~r/to implement Ecto.Adapter.Storage/, fn ->
-      Create.run ["-r", to_string(NoStorageRepo)]
+      Create.run(["-r", to_string(NoStorageRepo)])
     end
   end
 
   ## Down
 
   test "runs the adapter storage_down" do
     Process.put(:storage_down, :ok)
-    Drop.run ["-r", to_string(Repo)]
-    assert_received {:mix_shell, :info, ["The database for Mix.Tasks.Ecto.CreateDropTest.Repo has been dropped"]}
+    Drop.run(["-r", to_string(Repo)])
+
+    assert_received {:mix_shell, :info,
+                     ["The database for Mix.Tasks.Ecto.CreateDropTest.Repo has been dropped"]}
   end
 
   test "runs the adapter storage_down with --quiet" do
     Process.put(:storage_down, :ok)
-    Drop.run ["-r", to_string(Repo), "--quiet"]
+    Drop.run(["-r", to_string(Repo), "--quiet"])
     refute_received {:mix_shell, :info, [_]}
   end
 
   test "informs the user when the repo is already down" do
     Process.put(:storage_down, {:error, :already_down})
-    Drop.run ["-r", to_string(Repo)]
-    assert_received {:mix_shell, :info, ["The database for Mix.Tasks.Ecto.CreateDropTest.Repo has already been dropped"]}
+    Drop.run(["-r", to_string(Repo)])
+
+    assert_received {:mix_shell, :info,
+                     [
+                       "The database for Mix.Tasks.Ecto.CreateDropTest.Repo has already been dropped"
+                     ]}
   end
 
   test "raises an error when storage_down gives an unknown feedback" do
     Process.put(:storage_down, {:error, {:error, :confused}})
+
     assert_raise Mix.Error, ~r/couldn't be dropped: {:error, :confused}/, fn ->
-      Drop.run ["-r", to_string(Repo)]
+      Drop.run(["-r", to_string(Repo)])
     end
 
     Process.put(:storage_down, {:error, "unknown"})
+
     assert_raise Mix.Error, ~r/couldn't be dropped: unknown/, fn ->
-      Drop.run ["-r", to_string(Repo)]
+      Drop.run(["-r", to_string(Repo)])
     end
   end
 
   test "raises an error on storage_down when the adapter doesn't define a storage" do
     assert_raise Mix.Error, ~r/to implement Ecto.Adapter.Storage/, fn ->
-      Drop.run ["-r", to_string(NoStorageRepo)]
+      Drop.run(["-r", to_string(NoStorageRepo)])
     end
   end
 end