Create GitHub Actions workflow

.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  - push
+  - pull_request
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: OTP ${{ matrix.otp }} / Elixir ${{ matrix.elixir }}
+    runs-on: ubuntu-20.04
+    strategy:
+      matrix:
+        include:
+          - elixir: 1.12.0
+            otp: 22.3
+          - elixir: 1.15.2
+            otp: 25.3
+    env:
+      MIX_ENV: test
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: recursive
+      - name: Set up Elixir
+        uses: erlef/setup-beam@v1
+        with:
+          otp-version: ${{ matrix.otp }}
+          elixir-version: ${{ matrix.elixir }}
+      - name: Restore dependencies cache
+        uses: actions/cache@v3
+        with:
+          path: deps
+          key: deps-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-${{ hashFiles('**/mix.lock') }}
+          restore-keys: deps-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-
+      - name: Restore build cache
+        uses: actions/cache@v3
+        with:
+          path: _build/test
+          key: build-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-${{ hashFiles('**/mix.lock') }}
+          restore-keys: build-${{ runner.os }}-${{ matrix.otp }}-${{ matrix.elixir }}-
+      - name: Install dependencies
+        run: mix deps.get
+      - name: Compile dependencies
+        run: mix deps.compile
+      - name: Compile
+        run: mix compile --warnings-as-errors
+      - name: Dialyzer
+        run: mix dialyzer --halt-exit-status
+      - name: Run tests
+        run: mix coveralls.github
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -1,6 +1,6 @@
 # Elixir JSON Schema Validator
 
-[![Build Status](https://app.travis-ci.com/jonasschmidt/ex_json_schema.svg?branch=master)](https://app.travis-ci.com/github/jonasschmidt/ex_json_schema)
+[![Build Status](https://github.com/jonasschmidt/ex_json_schema/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/jonasschmidt/ex_json_schema/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/jonasschmidt/ex_json_schema/badge.svg?branch=master)](https://coveralls.io/github/jonasschmidt/ex_json_schema?branch=master)
 [![Module Version](https://img.shields.io/hexpm/v/ex_json_schema.svg)](https://hex.pm/packages/ex_json_schema)
 [![Hex Docs](https://img.shields.io/badge/hex-docs-lightgreen.svg)](https://hexdocs.pm/ex_json_schema/)
@@ -35,7 +35,7 @@ If you have remote schemata that need to be fetched at runtime, you have to regi
 ```elixir
 config :ex_json_schema,
   :remote_schema_resolver,
-  fn url -> HTTPoison.get!(url).body |> Poison.decode! end
+  fn url -> HTTPoison.get!(url).body |> Jason.decode! end
 ```
 
 Alternatively, you can specify a module and function name for situations where using anonymous functions is not possible (i.e. working with Erlang releases):

config/test.exs

@@ -1,10 +1,15 @@
 use Mix.Config
 
 defmodule CustomFormatValidator do
   def validate(_format, _data), do: true
 end
 
 config :ex_json_schema,
-  decode_json: fn json -> Poison.decode(json) end,
-  remote_schema_resolver: fn url -> HTTPoison.get!(url).body |> Poison.decode!() end,
+  decode_json: fn json -> Jason.decode(json) end,
+  remote_schema_resolver: fn url -> HTTPoison.get!(url).body |> Jason.decode!() end,
   custom_format_validator: {CustomFormatValidator, :validate}
+
+config :ex_json_schema, SamplePhoenix.Endpoint,
+  http: [ip: {127, 0, 0, 1}, port: 1234],
+  server: true,
+  secret_key_base: String.duplicate("a", 64)

mix.exs

@@ -21,7 +21,7 @@ defmodule ExJsonSchema.Mixfile do
       preferred_cli_env: [coveralls: :test, dialyzer: :test],
       dialyzer: [
         plt_add_apps: [:ex_unit],
-        plt_core_path: ".",
+        plt_core_path: "_build/#{Mix.env()}",
         plt_add_deps: :transitive
       ]
     ]
@@ -39,7 +39,9 @@ defmodule ExJsonSchema.Mixfile do
       {:excoveralls, "~> 0.14", only: :test},
       {:httpoison, "~> 1.8", only: :test},
       {:mix_test_watch, "~> 0.7", only: [:dev, :test]},
-      {:poison, "~> 5.0", only: :test}
+      {:jason, "~> 1.4", only: :test},
+      {:plug_cowboy, "~> 2.5", only: :test},
+      {:phoenix, "~> 1.6", only: :test}
     ]
   end
 

test/ex_json_schema/schema_test.exs

@@ -35,7 +35,7 @@ defmodule ExJsonSchema.SchemaTest do
     schema = %{"properties" => "foo"}
 
     assert_raise ExJsonSchema.Schema.InvalidSchemaError,
-                 ~s(schema did not pass validation against its meta-schema: [%ExJsonSchema.Validator.Error{error: %ExJsonSchema.Validator.Error.Type{expected: ["object"], actual: "string"}, path: "#/properties"}]),
+                 ~r/schema did not pass validation against its meta-schema: \[%ExJsonSchema.Validator.Error{error: %ExJsonSchema.Validator.Error.Type{/,
                  fn -> resolve(schema) end
 
     assert_raise ExJsonSchema.Schema.InvalidSchemaError,
@@ -132,19 +132,19 @@ defmodule ExJsonSchema.SchemaTest do
   test "fetching a ref schema with a path" do
     schema =
       resolve(%{
-        "properties" => %{"foo" => %{"$ref" => "http://localhost:8000/subschema.json#/foo"}}
+        "properties" => %{"foo" => %{"$ref" => "http://localhost:1234/subschema.json#/foo"}}
       })
 
     assert get_fragment!(schema, "#/properties/foo") == %{
-             "$ref" => ["http://localhost:8000/subschema.json", "foo"]
+             "$ref" => ["http://localhost:1234/subschema.json", "foo"]
            }
   end
 
   test "fetching a ref schema with a URL" do
-    schema = resolve(%{"$ref" => "http://localhost:8000/subschema.json#/foo"})
+    schema = resolve(%{"$ref" => "http://localhost:1234/subschema.json#/foo"})
 
-    assert get_fragment!(schema, "http://localhost:8000/subschema.json#/foo") == %{
-             "$ref" => ["http://localhost:8000/subsubschema.json", "foo"]
+    assert get_fragment!(schema, "http://localhost:1234/subschema.json#/foo") == %{
+             "$ref" => ["http://localhost:1234/subsubschema.json", "foo"]
            }
   end
 end

test/ex_json_schema/validator_test.exs

@@ -8,7 +8,7 @@ defmodule ExJsonSchema.ValidatorTest do
 
   @schema_with_ref Schema.resolve(%{
                      "properties" => %{
-                       "foo" => %{"$ref" => "http://localhost:8000/subschema.json#/foo"}
+                       "foo" => %{"$ref" => "http://localhost:1234/subschema.json#/foo"}
                      }
                    })
 
@@ -66,7 +66,7 @@ defmodule ExJsonSchema.ValidatorTest do
 
   test "validation errors with a remote reference within a remote reference" do
     assert_validation_errors(
-      %{"$ref" => "http://localhost:8000/subschema.json#/foo"},
+      %{"$ref" => "http://localhost:1234/subschema.json#/foo"},
       "foo",
       [{"Type mismatch. Expected Integer but got String.", "#"}],
       [%Error{error: %Error.Type{expected: ["integer"], actual: "string"}, path: "#"}]

test/support/remote_schema_server.ex

@@ -0,0 +1,34 @@
+defmodule SamplePhoenix.SampleController do
+  use Phoenix.Controller
+
+  def show(conn, %{"path" => path}) do
+    test_path = Path.join(__DIR__, "..") |> Path.expand()
+
+    json =
+      case File.read(Path.join([test_path, "support/schemata"] ++ path)) do
+        {:ok, json} -> json
+        _ -> File.read!(Path.join([test_path, "JSON-Schema-Test-Suite/remotes"] ++ path))
+      end
+
+    conn |> put_resp_content_type("application/json") |> send_resp(200, json)
+  end
+end
+
+defmodule Router do
+  use Phoenix.Router
+
+  pipeline :api do
+    plug(:accepts, ["json"])
+  end
+
+  scope "/", SamplePhoenix, log: false do
+    pipe_through(:api)
+
+    get("/*path", SampleController, :show)
+  end
+end
+
+defmodule SamplePhoenix.Endpoint do
+  use Phoenix.Endpoint, otp_app: :ex_json_schema
+  plug(Router)
+end

test/support/schemata/subschema.json

@@ -1,5 +1,5 @@
 {
   "foo": {
-    "$ref": "http://localhost:8000/subsubschema.json#/foo"
+    "$ref": "http://localhost:1234/subsubschema.json#/foo"
   }
 }

test/support/test_helpers.ex

@@ -4,6 +4,6 @@ defmodule ExJsonSchema.Test.Support.TestHelpers do
     schema_tests_path
     |> Path.join(name <> ".json")
     |> File.read!()
-    |> Poison.decode!()
+    |> Jason.decode!()
   end
 end

test/test_helper.exs

@@ -1,18 +1,4 @@
 ExUnit.start()
 HTTPoison.start()
 
-{:ok, _} =
-  :inets.start(:httpd,
-    server_name: 'test 1',
-    document_root: './test/JSON-Schema-Test-Suite/remotes',
-    server_root: '.',
-    port: 1234
-  )
-
-{:ok, _} =
-  :inets.start(:httpd,
-    server_name: 'test 2',
-    document_root: './test/support/schemata',
-    server_root: '.',
-    port: 8000
-  )
+{:ok, _} = Supervisor.start_link([SamplePhoenix.Endpoint], strategy: :one_for_one)