test: add guides tests

Author: fahchen

guides/plugins/derive_enumerable.md

@@ -8,7 +8,7 @@ Let's start!
 
 ## Implementation
 ```elixir
-defmodule MyPlugin do
+defmodule Guides.Plugins.Enumerable do
   use TypedStructor.Plugin
 
   @impl TypedStructor.Plugin
@@ -40,11 +40,11 @@ end
 defmodule User do
   use TypedStructor
 
-  typed_structor do
-    plugin MyPlugin
+  typed_structor enforce: true do
+    plugin Guides.Plugins.Enumerable
 
-    field :name, String.t(), enforce: true
-    field :age, integer(), enforce: true
+    field :name, String.t()
+    field :age, Integer.t()
   end
 end
 ```

guides/plugins/derive_jason.md

@@ -5,7 +5,7 @@ generate the `Jason.Encoder` implementation for the struct.
 
 ## Implementation
 ```elixir
-defmodule MyPlugin do
+defmodule Guides.Plugins.Jason do
   use TypedStructor.Plugin
 
   @impl TypedStructor.Plugin
@@ -29,10 +29,10 @@ end
 defmodule User do
   use TypedStructor
 
-  typed_structor do
-    plugin MyPlugin
+  typed_structor enforce: true do
+    plugin Guides.Plugins.Jason
 
-    field :name, String.t(), enforce: true
+    field :name, String.t()
   end
 end
 ```

guides/plugins/primary_key_and_timestamps.md

@@ -7,7 +7,7 @@ This plugin use `c:TypedStructor.Plugin.before_definition/2` callback to
 inject the primary key and timestamps fields to the type definition.
 
 ```elixir
-defmodule MyApp.TypedStructor.Plugins.PrimaryKeyAndTimestamps do
+defmodule Guides.Plugins.PrimaryKeyAndTimestamps do
   use TypedStructor.Plugin
 
   @impl TypedStructor.Plugin
@@ -33,14 +33,14 @@ end
 ## Usage
 
 ```elixir
-defmodule MyApp.User do
+defmodule User do
   use TypedStructor
   use Ecto.Schema
 
   # disable struct creation or it will conflict with the Ecto schema
   typed_structor define_struct: false do
     # register the plugin
-    plugin MyApp.TypedStructor.Plugins.PrimaryKeyAndTimestamps
+    plugin Guides.Plugins.PrimaryKeyAndTimestamps
 
     field :name, String.t()
     field :age, integer(), enforce: true # There is always a non-nil value

guides/plugins/type_only_on_ecto_schema.md

@@ -13,7 +13,7 @@ set to `false` to prevent struct creation.
 
 Here is the plugin(*feel free to copy and paste*):
 ```elixir
-defmodule MyApp.TypedStructor.Plugins.TypeOnlyOnEctoSchema do
+defmodule Guides.Plugins.TypeOnlyOnEctoSchema do
   use TypedStructor.Plugin
 
   @impl TypedStructor.Plugin
@@ -40,7 +40,7 @@ defmodule MyApp.User do
   use Ecto.Schema
 
   typed_structor do
-    plugin MyApp.TypedStructor.Plugins.TypeOnlyOnEctoSchema
+    plugin Guides.Plugins.TypeOnlyOnEctoSchema
 
     field :id, integer(), enforce: true
     field :name, String.t()
@@ -56,7 +56,7 @@ end
 
 ## Registering the plugin globally
 ```elixir
-config :typed_structor, plugins: [MyApp.TypedStructor.Plugins.TypeOnlyOnEctoSchema]
+config :typed_structor, plugins: [Guides.Plugins.TypeOnlyOnEctoSchema]
 ```
 
 Note that the plugin is applied to **all modules** that use `TypedStructor`,
@@ -65,7 +65,7 @@ you can opt-out by determining the module name or other conditions.
 Let's change the plugin to only apply to modules from the `MyApp` namespace(*feel free to copy and paste*):
 
 ```elixir
-defmodule MyApp.TypedStructor.Plugins.TypeOnlyOnEctoSchema do
+defmodule Guides.Plugins.TypeOnlyOnEctoSchema do
   use TypedStructor.Plugin
 
   @impl TypedStructor.Plugin
@@ -93,7 +93,7 @@ Now you can use `typed_structor` without registering the plugin explicitly:
    use Ecto.Schema
 
    typed_structor do
--    plugin MyApp.TypedStructor.Plugins.TypeOnlyOnEctoSchema
+-    plugin Guides.Plugins.TypeOnlyOnEctoSchema
 
      field :id, integer(), enforce: true
      field :name, String.t()

mix.exs

@@ -11,6 +11,7 @@ defmodule TypedStructor.MixProject do
       elixir: "~> 1.14",
       elixirc_paths: elixirc_paths(Mix.env()),
       start_permanent: Mix.env() == :prod,
+      consolidate_protocols: Mix.env() != :test,
       deps: deps(),
       name: "TypedStructor",
       source: @source_url,
@@ -61,6 +62,7 @@ defmodule TypedStructor.MixProject do
       {:credo, "~> 1.7", only: [:dev, :test], runtime: false},
       {:dialyxir, "~> 1.4", only: [:dev, :test], runtime: false},
       {:ecto, "~> 3.0", only: [:dev, :test], optional: true},
+      {:jason, "~> 1.4", only: [:dev, :test], optional: true},
       {:makeup_diff, "~> 0.1", only: [:test, :dev], runtime: false}
     ]
   end

test/guides/plugins/enumerable_test.exs

@@ -0,0 +1,11 @@
+defmodule Guides.Plugins.EnumerableTest do
+  use TypedStructor.GuideCase,
+    async: true,
+    guide: "derive_enumerable.md"
+
+  test "works" do
+    user = %User{name: "Phil", age: 20}
+    assert [:name, :age] === Enum.map(user, fn {key, _value} -> key end)
+    assert [name: "Phil", age: 20] === Enum.to_list(user)
+  end
+end

test/guides/plugins/jason_test.exs

@@ -0,0 +1,9 @@
+defmodule Guides.Plugins.JasonTest do
+  use TypedStructor.GuideCase,
+    async: true,
+    guide: "derive_jason.md"
+
+  test "works" do
+    assert {:ok, "{\"name\":\"Phil\"}"} === Jason.encode(%User{name: "Phil"})
+  end
+end

test/guides/plugins/primary_key_and_timestamps_test.exs

@@ -0,0 +1,21 @@
+defmodule Guides.Plugins.PrimaryKeyAndTimestampsTest do
+  use TypedStructor.GuideCase,
+    async: true,
+    guide: "primary_key_and_timestamps.md"
+
+  test "works", ctx do
+    assert """
+           @type t() :: %Guides.Plugins.PrimaryKeyAndTimestampsTest.User{
+             __meta__: term(),
+             age: integer(),
+             id: integer(),
+             inserted_at: NaiveDateTime.t(),
+             name: String.t() | nil,
+             updated_at: NaiveDateTime.t()
+           }
+           """ === types(ctx.registered.bytecode)
+
+    user = %User{name: "Phil"}
+    assert 20 === user.age
+  end
+end

test/guides/plugins/type_only_on_ecto_schema_test.exs

@@ -0,0 +1,19 @@
+defmodule Guides.Plugins.TypeOnlyOnEctoSchema do
+  use TypedStructor.GuideCase,
+    async: true,
+    guide: "type_only_on_ecto_schema.md"
+
+  test "works", ctx do
+    assert """
+           @type t() :: %Guides.Plugins.TypeOnlyOnEctoSchema.MyApp.User{
+             __meta__: term(),
+             age: integer(),
+             id: integer(),
+             name: String.t() | nil
+           }
+           """ === types(ctx.registered.bytecode)
+
+    user = %MyApp.User{name: "Phil"}
+    assert 20 === user.age
+  end
+end

test/support/guide_case.ex

@@ -0,0 +1,93 @@
+defmodule TypedStructor.GuideCase do
+  @moduledoc false
+
+  use ExUnit.CaseTemplate
+
+  using opts do
+    guide = Keyword.fetch!(opts, :guide)
+
+    file = Path.expand([__DIR__, "../../../", "guides/plugins/", guide])
+
+    ast = Code.string_to_quoted!(extract_code(file))
+
+    quote do
+      Code.compiler_options(debug_info: true)
+
+      {:module, _module_name, bytecode, _submodule} = unquote(ast)
+
+      ExUnit.Case.register_module_attribute(__MODULE__, :bytecode)
+      @bytecode bytecode
+
+      import unquote(__MODULE__), only: [types: 1]
+    end
+  end
+
+  def types(bytecode) when is_binary(bytecode) do
+    TypedStructor.TypeCase.types(bytecode) <> "\n"
+  end
+
+  defp extract_code(file) do
+    content =
+      File.read!(file)
+
+    content
+    |> String.split("\n")
+    |> Enum.with_index(1)
+    |> extract_code(%{in_code_block?: false, codes: []})
+    |> case do
+      %{codes: [implementation, usage | _resut]} ->
+        """
+        #{implementation |> Enum.reverse() |> Enum.join("\n")}
+        #{usage |> Enum.reverse() |> Enum.join("\n")}
+        """
+
+      ctx ->
+        raise ArgumentError,
+              """
+              Cannot find implementation and usage in file #{inspect(file)}
+              context: #{inspect(ctx)}
+              #{content}
+              """
+    end
+  end
+
+  @start "```elixir"
+  @stop "```"
+
+  defp extract_code([], %{in_code_block?: false} = ctx) do
+    %{ctx | codes: Enum.reverse(ctx.codes)}
+  end
+
+  defp extract_code([{@start, _index} | rest], %{in_code_block?: false} = ctx) do
+    extract_code(rest, %{ctx | in_code_block?: true, codes: [[] | ctx.codes]})
+  end
+
+  defp extract_code([{@stop, _index} | rest], %{in_code_block?: true} = ctx) do
+    extract_code(rest, %{ctx | in_code_block?: false})
+  end
+
+  defp extract_code([{text, _index} | rest], %{in_code_block?: true} = ctx) do
+    [current | codes] = ctx.codes
+    extract_code(rest, %{ctx | codes: [[text | current] | codes]})
+  end
+
+  defp extract_code([_text | rest], %{in_code_block?: false} = ctx) do
+    extract_code(rest, ctx)
+  end
+
+  defp extract_code([{text, index} | _rest], ctx) do
+    raise ArgumentError,
+          """
+          Unexpected text at line #{index}: #{inspect(text)}
+          context: #{inspect(ctx)}
+          """
+  end
+
+  defp extract_code([], ctx) do
+    raise ArgumentError,
+          """
+          Code block not closed
+          context: #{inspect(ctx)}
+          """
+  end
+end