init the project

Author: tyrchen

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.gitignore

@@ -0,0 +1,24 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+json_data_faker-*.tar
+

README.md

@@ -0,0 +1,74 @@
+# JsonDataFaker
+
+Generate JSON data from JSON schema by using faking data.
+
+```elixir
+iex> object_schema = %{
+    "properties" => %{
+      "body" => %{
+        "maxLength" => 140,
+        "minLength" => 3,
+        "type" => "string"
+      },
+      "created" => %{
+        "format" => "date-time",
+        "type" => "string"
+      },
+      "id" => %{
+        "format" => "uuid",
+        "type" => "string"
+      },
+      "status" => %{
+        "enum" => [
+          "active",
+          "completed"
+        ],
+        "type" => "string"
+      },
+      "updated" => %{
+        "format" => "date-time",
+        "type" => "string"
+      }
+    },
+    "required" => [
+      "body"
+    ],
+    "type" => "object"
+  }
+
+iex> schema = %{
+  "items" => object_schema,
+  "type" => "array"
+}
+
+iex> JsonDataFaker.generate(schema)
+[
+  %{
+    "body" => "Do you think I am easier to be played on than a pipe?",
+    "created" => "2020-11-28T01:15:35.268463Z",
+    "id" => "13543d9c-0f37-482d-84d6-52b2cb8c1b3f",
+    "status" => "active",
+    "updated" => "2020-11-28T01:15:35.268478Z"
+  },
+  %{
+    "body" => "When sorrows come, they come not single spies, but in battalions.",
+    "created" => "2020-11-28T01:15:35.268502Z",
+    "id" => "c95ef972-05c9-4132-9525-09c99a15bf01",
+    "status" => "completed",
+    "updated" => "2020-11-28T01:15:35.268517Z"
+  }
+  ...
+]
+```
+
+## Installation
+
+```elixir
+def deps do
+  [
+    {:json_data_faker, "~> 0.1.0"}
+  ]
+end
+```
+
+Documentation: [https://hexdocs.pm/json_data_faker](https://hexdocs.pm/json_data_faker).

lib/json_data_faker.ex

@@ -0,0 +1,87 @@
+defmodule JsonDataFaker do
+  @moduledoc """
+  Generate fake data based on json schema.
+  """
+
+  alias ExJsonSchema.Schema
+
+  @doc """
+  generate fake data with given schema. It could be a raw json schema or ExJsonSchema.Schema.Root type.
+
+  ## Examples
+
+      iex> schema = %{
+      ...>  "properties" => %{
+      ...>    "body" => %{"maxLength" => 140, "minLength" => 3, "type" => "string"},
+      ...>    "title" => %{"maxLength" => 64, "minLength" => 3, "type" => "string"}
+      ...>  },
+      ...>  "required" => ["title"],
+      ...>  "type" => "object"
+      ...>}
+      iex> %{"title" => title, "body" => body} = JsonDataFaker.generate(schema)
+  """
+  def generate(%Schema.Root{} = schema) do
+    generate_by_type(schema.schema)
+  end
+
+  def generate(schema) when is_map(schema) do
+    generate(Schema.resolve(schema))
+  end
+
+  # private functions
+  defp generate_by_type(%{"type" => "boolean"}) do
+    Enum.random([true, false])
+  end
+
+  defp generate_by_type(%{"type" => "string"} = schema) do
+    generate_string(schema)
+  end
+
+  defp generate_by_type(%{"type" => "integer"} = schema) do
+    min = schema["minimum"] || 10
+    max = schema["maximum"] || 1000
+    Enum.random(min..max)
+  end
+
+  defp generate_by_type(%{"type" => "array"} = schema) do
+    inner_schema = schema["items"]
+    count = Enum.random(5..20)
+
+    Enum.map(1..count, fn _ ->
+      generate_by_type(inner_schema)
+    end)
+  end
+
+  defp generate_by_type(%{"type" => "object"} = schema) do
+    Enum.reduce(schema["properties"], %{}, fn {k, inner_schema}, acc ->
+      Map.put(acc, k, generate_by_type(inner_schema))
+    end)
+  end
+
+  defp generate_string(%{"format" => "date-time"}),
+    do: DateTime.utc_now() |> DateTime.to_iso8601()
+
+  defp generate_string(%{"format" => "uuid"}), do: Faker.UUID.v4()
+  defp generate_string(%{"format" => "email"}), do: Faker.Internet.email()
+  defp generate_string(%{"format" => "hostname"}), do: Faker.Internet.domain_name()
+  defp generate_string(%{"format" => "ipv4"}), do: Faker.Internet.ip_v4_address()
+  defp generate_string(%{"format" => "ipv6"}), do: Faker.Internet.ip_v6_address()
+  defp generate_string(%{"format" => "uri"}), do: Faker.Internet.url()
+
+  defp generate_string(%{"enum" => choices}), do: Enum.random(choices)
+
+  defp generate_string(%{"pattern" => regex}),
+    do: Randex.stream(Regex.compile!(regex)) |> Enum.take(1) |> List.first()
+
+  defp generate_string(schema) do
+    min = schema["minLength"] || 0
+    max = schema["maxLength"] || 1024
+    s = Faker.Lorem.Shakespeare.hamlet()
+
+    case String.length(s) do
+      v when v > max -> String.slice(s, 0, max - 1)
+      v when v < min -> s <> " " <> List.to_string(Faker.Lorem.characters(min - v))
+      _ -> s
+    end
+  end
+end

mix.exs

@@ -0,0 +1,30 @@
+defmodule JsonDataFaker.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      app: :json_data_faker,
+      version: "0.1.0",
+      elixir: "~> 1.10",
+      start_permanent: Mix.env() == :prod,
+      deps: deps()
+    ]
+  end
+
+  # Run "mix help compile.app" to learn about applications.
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  # Run "mix help deps" to learn about dependencies.
+  defp deps do
+    [
+      {:ex_json_schema, "~> 0.7"},
+      {:randex, "~> 0.4.0"},
+      {:faker, "~> 0.16"},
+      {:uuid, "~> 1.1"}
+    ]
+  end
+end

mix.lock

@@ -0,0 +1,6 @@
+%{
+  "ex_json_schema": {:hex, :ex_json_schema, "0.7.4", "09eb5b0c8184e5702bc89625a9d0c05c7a0a845d382e9f6f406a0fc1c9a8cc3f", [:mix], [], "hexpm", "45c67fa840f0d719a2b5578126dc29bcdc1f92499c0f61bcb8a3bcb5935f9684"},
+  "faker": {:hex, :faker, "0.16.0", "1e2cf3e8d60d44a30741fb98118fcac18b2020379c7e00d18f1a005841b2f647", [:mix], [], "hexpm", "fbcb9bf1299dff3c9dd7e50f41802bbc472ffbb84e7656394c8aa913ec315141"},
+  "randex": {:hex, :randex, "0.4.0", "f76712da3663dd7d4166e017829ec428dc67df9e11b82d923dfd6f9b4854b373", [:mix], [{:stream_data, "~> 0.4", [hex: :stream_data, repo: "hexpm", optional: true]}], "hexpm", "f803f256542bd264acea832a69f6e5fea3df4cd3f8a9f03588e5593f04c61095"},
+  "uuid": {:hex, :uuid, "1.1.8", "e22fc04499de0de3ed1116b770c7737779f226ceefa0badb3592e64d5cfb4eb9", [:mix], [], "hexpm", "c790593b4c3b601f5dc2378baae7efaf5b3d73c4c6456ba85759905be792f2ac"},
+}

test/json_data_faker_test.exs

@@ -0,0 +1,90 @@
+defmodule JsonDataFakerTest do
+  use ExUnit.Case
+  alias ExJsonSchema.{Validator, Schema}
+  doctest JsonDataFaker
+
+  @complex_object %{
+    "properties" => %{
+      "body" => %{
+        "maxLength" => 140,
+        "minLength" => 3,
+        "type" => "string"
+      },
+      "created" => %{
+        "format" => "date-time",
+        "type" => "string"
+      },
+      "id" => %{
+        "format" => "uuid",
+        "type" => "string"
+      },
+      "status" => %{
+        "enum" => [
+          "active",
+          "completed"
+        ],
+        "type" => "string"
+      },
+      "updated" => %{
+        "format" => "date-time",
+        "type" => "string"
+      }
+    },
+    "required" => [
+      "body"
+    ],
+    "type" => "object"
+  }
+
+  test "string uuid generation should work" do
+    schema = %{"type" => "string", "format" => "uuid"}
+    assert {:ok, _} = UUID.info(JsonDataFaker.generate(schema))
+  end
+
+  Enum.each(["date-time", "email", "hostname", "ipv4", "ipv6", "uri"], fn format ->
+    test "string #{format} generation should work" do
+      schema = %{"type" => "string", "format" => unquote(format)}
+      s = JsonDataFaker.generate(schema)
+      assert Validator.valid?(Schema.resolve(schema), s)
+    end
+  end)
+
+  test "string regex generation should work" do
+    schema = %{"type" => "string", "pattern" => "^(\\([0-9]{3}\\))?[0-9]{3}-[0-9]{4}$"}
+    s = JsonDataFaker.generate(schema)
+    assert Validator.valid?(Schema.resolve(schema), s)
+  end
+
+  test "string enum generation should work" do
+    schema = %{"type" => "string", "enum" => ["active", "completed"]}
+    s = JsonDataFaker.generate(schema)
+    assert Validator.valid?(Schema.resolve(schema), s)
+  end
+
+  test "string with max / min length should work" do
+    schema = %{"type" => "string", "minLength" => 200, "maxLength" => 201}
+    s = JsonDataFaker.generate(schema)
+    assert Validator.valid?(Schema.resolve(schema), s)
+  end
+
+  test "integer generation should work" do
+    schema = %{"type" => "integer", "minimum" => 5, "maximum" => 20}
+    s = JsonDataFaker.generate(schema)
+    assert Validator.valid?(Schema.resolve(schema), s)
+  end
+
+  test "complex object generation should work" do
+    s = JsonDataFaker.generate(@complex_object)
+    assert Validator.valid?(Schema.resolve(@complex_object), s)
+  end
+
+  test "array of object generation should work" do
+    schema = %{
+      "items" => @complex_object,
+      "type" => "array"
+    }
+
+    s = JsonDataFaker.generate(schema)
+    assert Validator.valid?(Schema.resolve(schema), s)
+  end
+end

test/test_helper.exs

@@ -0,0 +1 @@
+ExUnit.start()