Add more tests for derived types.

lib/wafer/spi.ex

@@ -59,7 +59,7 @@ defimpl Wafer.SPI, for: Any do
         import Wafer.Guards
         alias Wafer.SPI
 
-        def transfer(%{unquote(key) => inner_conn}, data)
+        def transfer(%{unquote(key) => inner_conn} = conn, data)
             when is_binary(data) do
           with {:ok, data, inner_conn} <- SPI.transfer(inner_conn, data),
                do: {:ok, data, Map.put(conn, unquote(key), inner_conn)}

test/chip_test.exs

@@ -1,6 +1,16 @@
 defmodule WaferChipTest do
   use ExUnit.Case, async: true
   alias Wafer.Chip
+  alias Wafer.Driver.CircuitsI2C, as: Driver
+  alias Wafer.Chip.Wafer.Driver.CircuitsI2C, as: Impl
+  import Mimic
+  Code.require_file("test/support/test_utils.exs")
+  @moduledoc false
+
+  setup do
+    Mimic.copy(Impl)
+    {:ok, []}
+  end
 
   describe "__deriving__/3" do
     test "deriving with default key name" do
@@ -12,10 +22,55 @@ defmodule WaferChipTest do
       mod = test_mod(:marty)
       assert Chip.impl_for!(struct(mod, fruit: :noop))
     end
+
+    test "reading a derived register" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:read_register, 1, fn conn, reg_addr, bytes ->
+        assert conn == %Driver{}
+        assert reg_addr == 2
+        assert bytes == 1
+        {:ok, <<0>>}
+      end)
+
+      Chip.read_register(outer_struct, 2, 1)
+    end
+
+    test "writing a derived register" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:write_register, 1, fn conn, reg_addr, data ->
+        assert conn == %Driver{}
+        assert reg_addr == 2
+        assert data == <<0>>
+        {:ok, conn}
+      end)
+
+      assert {:ok, ^outer_struct} = Chip.write_register(outer_struct, 2, <<0>>)
+    end
+
+    test "swapping a derived register" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:swap_register, 1, fn conn, reg_addr, data ->
+        assert conn == %Driver{}
+        assert reg_addr == 2
+        assert data == <<0>>
+        {:ok, <<1>>, conn}
+      end)
+
+      assert {:ok, <<1>>, ^outer_struct} = Chip.swap_register(outer_struct, 2, <<0>>)
+    end
   end
 
   defp test_mod(key \\ :conn) do
-    mod = random_module_name()
+    mod = TestUtils.random_module_name()
 
     if key == :conn do
       defmodule mod do
@@ -31,13 +86,4 @@ defmodule WaferChipTest do
 
     mod
   end
-
-  defp random_module_name do
-    name =
-      16
-      |> :crypto.strong_rand_bytes()
-      |> Base.encode64(padding: false)
-
-    Module.concat(__MODULE__, name)
-  end
 end

test/gpio_test.exs

@@ -0,0 +1,127 @@
+defmodule WaferGPIOTest do
+  use ExUnit.Case, async: true
+  alias Wafer.GPIO
+  alias Wafer.Driver.CircuitsGPIO, as: Driver
+  alias Wafer.GPIO.Wafer.Driver.CircuitsGPIO, as: Impl
+  import Mimic
+  Code.require_file("test/support/test_utils.exs")
+  @moduledoc false
+
+  setup do
+    Mimic.copy(Impl)
+    {:ok, []}
+  end
+
+  describe "__deriving___/3" do
+    test "deriving with default key name" do
+      mod = test_mod()
+      assert GPIO.impl_for!(struct(mod, conn: :noop))
+    end
+
+    test "deriving with a specified key name" do
+      mod = test_mod(:marty)
+      assert GPIO.impl_for!(struct(mod, fruit: :noop))
+    end
+
+    test "read a derived pin" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:read, 1, fn conn ->
+        assert conn == %Driver{}
+        {:ok, 0, conn}
+      end)
+
+      assert {:ok, 0, ^outer_struct} = GPIO.read(outer_struct)
+    end
+
+    test "write a derived pin" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:write, 1, fn conn, value ->
+        assert conn == %Driver{}
+        assert value == 1
+        {:ok, conn}
+      end)
+
+      assert {:ok, ^outer_struct} = GPIO.write(outer_struct, 1)
+    end
+
+    test "direction on a derived pin" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:direction, 1, fn conn, direction ->
+        assert conn == %Driver{}
+        assert direction == :out
+        {:ok, conn}
+      end)
+
+      assert {:ok, ^outer_struct} = GPIO.direction(outer_struct, :out)
+    end
+
+    test "enabling interrupt on a derived pin" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:enable_interrupt, 1, fn conn, condition ->
+        assert conn == %Driver{}
+        assert condition == :rising
+        {:ok, conn}
+      end)
+
+      assert {:ok, ^outer_struct} = GPIO.enable_interrupt(outer_struct, :rising)
+    end
+
+    test "disabling interrupt on a derived pin" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:disable_interrupt, 1, fn conn, condition ->
+        assert conn == %Driver{}
+        assert condition == :rising
+        {:ok, conn}
+      end)
+
+      assert {:ok, ^outer_struct} = GPIO.disable_interrupt(outer_struct, :rising)
+    end
+
+    test "setting pull mode on a derived pin" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:pull_mode, 1, fn conn, condition ->
+        assert conn == %Driver{}
+        assert condition == :pull_up
+        {:ok, conn}
+      end)
+
+      assert {:ok, ^outer_struct} = GPIO.pull_mode(outer_struct, :pull_up)
+    end
+  end
+
+  defp test_mod(key \\ :conn) do
+    mod = TestUtils.random_module_name()
+
+    if key == :conn do
+      defmodule mod do
+        @derive GPIO
+        defstruct [:conn]
+      end
+    else
+      defmodule mod do
+        @derive {GPIO, key: key}
+        defstruct [key]
+      end
+    end
+
+    mod
+  end
+end

test/i2c_test.exs

@@ -0,0 +1,103 @@
+defmodule WaferI2CTest do
+  use ExUnit.Case, async: true
+  alias Wafer.I2C
+  alias Wafer.Driver.CircuitsI2C, as: Driver
+  alias Wafer.I2C.Wafer.Driver.CircuitsI2C, as: Impl
+  import Mimic
+  Code.require_file("test/support/test_utils.exs")
+  @moduledoc false
+
+  setup do
+    Mimic.copy(Impl)
+    {:ok, []}
+  end
+
+  describe "__deriving__/3" do
+    test "deriving with default key name" do
+      mod = test_mod()
+      assert I2C.impl_for!(struct(mod, conn: :noop))
+    end
+
+    test "deriving with a specified key name" do
+      mod = test_mod(:marty)
+      assert I2C.impl_for!(struct(mod, fruit: :noop))
+    end
+
+    test "reading a derived I2C device" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:read, 1, fn conn, bytes, opts ->
+        assert conn == %Driver{}
+        assert bytes == 2
+        assert opts == []
+        {:ok, <<0>>}
+      end)
+
+      assert {:ok, <<0>>} = I2C.read(outer_struct, 2, [])
+    end
+
+    test "writing a derived I2C device" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:write, 1, fn conn, data, opts ->
+        assert conn == %Driver{}
+        assert data == <<0>>
+        assert opts == []
+        {:ok, conn}
+      end)
+
+      assert {:ok, ^outer_struct} = I2C.write(outer_struct, <<0>>, [])
+    end
+
+    test "write_read on a derived I2C device" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:write_read, 1, fn conn, data, bytes, opts ->
+        assert conn == %Driver{}
+        assert data == <<0>>
+        assert bytes == 1
+        assert opts == []
+        {:ok, <<1>>, conn}
+      end)
+
+      assert {:ok, <<1>>, ^outer_struct} = I2C.write_read(outer_struct, <<0>>, 1, [])
+    end
+
+    test "detect_devices on a derived I2C device" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:detect_devices, 1, fn conn ->
+        assert conn == %Driver{}
+        {:ok, []}
+      end)
+
+      assert {:ok, []} = I2C.detect_devices(outer_struct)
+    end
+  end
+
+  defp test_mod(key \\ :conn) do
+    mod = TestUtils.random_module_name()
+
+    if key == :conn do
+      defmodule mod do
+        @derive I2C
+        defstruct [:conn]
+      end
+    else
+      defmodule mod do
+        @derive {I2C, key: key}
+        defstruct [key]
+      end
+    end
+
+    mod
+  end
+end

test/registers_test.exs

@@ -2,6 +2,7 @@ defmodule WaferRegistersTest do
   use ExUnit.Case, async: true
   use Mimic
   alias Wafer.Chip
+  Code.require_file("test/support/test_utils.exs")
 
   describe "read-only register" do
     test "the register read function is defined" do
@@ -138,7 +139,7 @@ defmodule WaferRegistersTest do
   end
 
   defp test_mod do
-    mod = random_module_name()
+    mod = TestUtils.random_module_name()
 
     defmodule mod do
       use Wafer.Registers
@@ -150,13 +151,4 @@ defmodule WaferRegistersTest do
 
     mod
   end
-
-  defp random_module_name do
-    name =
-      16
-      |> :crypto.strong_rand_bytes()
-      |> Base.encode64(padding: false)
-
-    Module.concat(__MODULE__, name)
-  end
 end

test/spi_test.exs

@@ -0,0 +1,58 @@
+defmodule WaferSPITest do
+  use ExUnit.Case, async: true
+  alias Wafer.SPI
+  alias Wafer.Driver.CircuitsSPI, as: Driver
+  alias Wafer.SPI.Wafer.Driver.CircuitsSPI, as: Impl
+  import Mimic
+  Code.require_file("test/support/test_utils.exs")
+  @moduledoc false
+
+  setup do
+    Mimic.copy(Impl)
+    {:ok, []}
+  end
+
+  describe "__deriving__/3" do
+    test "deriving with default key name" do
+      mod = test_mod()
+      assert SPI.impl_for!(struct(mod, conn: :noop))
+    end
+
+    test "deriving with a specified key name" do
+      mod = test_mod(:marty)
+      assert SPI.impl_for!(struct(mod, fruit: :noop))
+    end
+
+    test "transfer on a derived SPI device" do
+      outer_mod = test_mod()
+      outer_struct = struct(outer_mod, conn: %Driver{})
+
+      Impl
+      |> expect(:transfer, 1, fn conn, data ->
+        assert conn == %Driver{}
+        assert data == <<0>>
+        {:ok, <<1>>, conn}
+      end)
+
+      assert {:ok, <<1>>, ^outer_struct} = SPI.transfer(outer_struct, <<0>>)
+    end
+  end
+
+  defp test_mod(key \\ :conn) do
+    mod = TestUtils.random_module_name()
+
+    if key == :conn do
+      defmodule mod do
+        @derive SPI
+        defstruct [:conn]
+      end
+    else
+      defmodule mod do
+        @derive {SPI, key: key}
+        defstruct [key]
+      end
+    end
+
+    mod
+  end
+end

test/support/test_utils.exs

@@ -0,0 +1,12 @@
+defmodule TestUtils do
+  @moduledoc false
+
+  def random_module_name do
+    name =
+      16
+      |> :crypto.strong_rand_bytes()
+      |> Base.encode64(padding: false)
+
+    Module.concat(__MODULE__, name)
+  end
+end