sproutapp / pavlov Goto Github PK

defmodule Something.SomethingElse do
  def do_it do
    IO.puts "Doing it!"
    42
  end
end

defmodule MyTest do
  use Pavlov.Case, async: true
  alias Something.SomethingElse, as: Potato

  describe "something" do
    let :result, do: Potato.do_it

    it "can't find Potato" do
      assert result == 42
    end
  end
end

defmodule MyApp.ConnCase do
  @moduledoc """
  This module defines the test case to be used by
  tests that require setting up a connection.

  Such tests rely on `Phoenix.ConnTest` and also
  imports other functionality to make it easier
  to build and query models.

  Finally, if the test case interacts with the database,
  it cannot be async. For this reason, every test runs
  inside a transaction which is reset at the beginning
  of the test unless the test case is marked as async.
  """

  use ExUnit.CaseTemplate

  using do
    quote do
      # Import conveniences for testing with connections
      use Phoenix.ConnTest

      alias MyApp.Repo
      import Ecto.Model
      import Ecto.Query, only: [from: 2]

      import MyApp.Router.Helpers

      # The default endpoint for testing
      @endpoint MyApp.Endpoint
    end
  end

  setup tags do
    unless tags[:async] do
      Ecto.Adapters.SQL.restart_test_transaction(MyApp.Repo, [])
    end

    :ok
  end
end

defmodule MyApp.UserControllerTest do
  use MyApp.ConnCase, async: true
  use Pavlov.Case, async: true
  import Pavlov.Syntax.Expect

  let(:base_url) do
    "/api/user" 
  end


  describe "POST (base_url)" do
    context "if no Authorization header was passed" do
      @endpoint MyApp.Endpoint

      it "returns status code of 401 Unauthorized" do 
        response = post conn(), base_url
        expect response.status |> to_eq 401
      end
    end
  end
end

defmodule MyApp.UserControllerTest do
  use MyApp.ConnCase, async: true
  use Pavlov.Case, async: true
  import Pavlov.Syntax.Expect

  let(:base_url) do
    "/api/user" 
  end


  describe "POST (base_url)" do
    @endpoint MyApp.Endpoint

    context "if no Authorization header was passed" do
      it "returns status code of 401 Unauthorized" do 
        response = post conn(), base_url
        expect response.status |> to_eq 401
      end
    end
  end
end

defmodule MyApp.UserControllerTest do
  use MyApp.ConnCase, async: true
  use Pavlov.Case, async: true
  import Pavlov.Syntax.Expect

  let(:base_url) do
    "/api/user" 
  end

  @endpoint MyApp.Endpoint

  describe "POST (base_url)" do
    context "if no Authorization header was passed" do
      it "returns status code of 401 Unauthorized" do 
        response = post conn(), base_url
        expect response.status |> to_eq 401
      end
    end
  end
end

allow(Mockable) |> to_receive(do_something: fn -> :error end)
Mockable |> to_receive(do_something_else: fn -> :success end)

allow(Mockable) |> to_receive(do_something: fn -> :error end)
allow(Mockable) |> to_receive(do_something_else: fn -> :success end)

    def allow(module, opts \\ [:no_link]) do
      case Process.whereis(String.to_atom("#{to_string(module)}_meck")) do
        nil -> setup_meck(module, opts)
        _   -> module
       end
    end

    defp setup_meck(module, opts) do
      :meck.new(module, opts)
      # Unload the module once the test exits
      on_exit fn ->
        :meck.unload(module)
      end
      module
    end

    allow(Mockable)
      |> to_receive(do_something: fn -> :error end)
      |> to_receive(do_something_else: fn -> :success end)

expect(%{abc: 123, def: 234}) |> to_match(%{abc: 123})

expect(%{abc: 345, def: 234}) |> to_match(%{abc: 123})

defmodule MyApp.UserTest do
  use MyApp.ConnCase, async: true # default ConnCase generated by Phoenix 
  use Pavlov.Case, async: true
  import Pavlov.Syntax.Expect

  let(:base_url) do
    "/api/user" 
  end

  describe "POST (base_url)" do
    context "if no Authorization header was passed" do
      @endpoint MyApp.Endpoint

      subject do
        conn() |> post base_url
      end      

      it "returns status code of 401 Unauthorized" do 
        expect subject.status |> to_eq 401
      end
    end
  end
end

defmodule MyApp.UserTest do
  use MyApp.ConnCase, async: true # default ConnCase generated by Phoenix 
  use Pavlov.Case, async: true
  import Pavlov.Syntax.Expect

  let(:base_url) do
    "/api/user" 
  end

  describe "POST (base_url)" do
    context "if no Authorization header was passed" do
      @endpoint MyApp.Endpoint

      subject do
        Phoenix.ConnTest.conn() |> Phoenix.ConnTest.post base_url # Here we add module names
      end      

      it "returns status code of 401 Unauthorized" do 
        expect subject.status |> to_eq 401
      end
    end
  end
end