7d7015cabf77f6a7ed47ed22029e4f76acd1760b

Committed 18 Oct 2023 10:03AM UTC coverage: 96.792% (+1.9%) from 94.925%

Build # 7d7015cabf77f6a7ed47ed22029e4f76acd1760b

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #85 from jonasschmidt/github-actions

 Create GitHub Actions workflow

Run Details

8 of 8 new or added lines in 2 files covered. (100.0%)

513 of 530 relevant lines covered (96.79%)

15522.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.5

/lib/ex_json_schema/validator/error/string_formatter.ex

defmodule ExJsonSchema.Validator.Error.StringFormatter do
  alias ExJsonSchema.Validator.Error

  @spec format(ExJsonSchema.Validator.errors()) :: [{String.t(), String.t()}]
  def format(errors) do
    Enum.map(errors, fn %Error{error: error, path: path} ->
      {to_string(error), path}
    end)
  end

  defimpl String.Chars, for: Error.AdditionalItems do
    def to_string(%Error.AdditionalItems{}) do
      "Schema does not allow additional items."
    end
  end

  defimpl String.Chars, for: Error.AdditionalProperties do
    def to_string(%Error.AdditionalProperties{}) do
      "Schema does not allow additional properties."
    end
  end

  defimpl String.Chars, for: Error.AllOf do
    def to_string(%Error.AllOf{invalid: invalid}) do
      "Expected all of the schemata to match, but the schemata at the following indexes did not: #{Enum.map_join(invalid, ", ", & &1.index)}."
    end
  end

  defimpl String.Chars, for: Error.AnyOf do
    def to_string(%Error.AnyOf{}) do
      "Expected any of the schemata to match but none did."
    end
  end

  defimpl String.Chars, for: Error.Const do
    def to_string(%Error.Const{expected: expected}) do
      "Expected data to be #{inspect(expected)}."
    end
  end

  defimpl String.Chars, for: Error.Contains do
    def to_string(%Error.Contains{}) do
      "Expected any of the items to match the schema but none did."
    end
  end

  defimpl String.Chars, for: Error.ContentEncoding do
    def to_string(%Error.ContentEncoding{expected: expected}) do
      "Expected the content to be #{expected}-encoded."
    end
  end

  defimpl String.Chars, for: Error.ContentMediaType do
    def to_string(%Error.ContentMediaType{expected: expected}) do
      "Expected the content to be of media type #{expected}."
    end
  end

  defimpl String.Chars, for: Error.Dependencies do
    def to_string(%Error.Dependencies{property: property, missing: [missing]}) do
      "Property #{property} depends on property #{missing} to be present but it was not."
    end

    def to_string(%Error.Dependencies{property: property, missing: missing}) do
      "Property #{property} depends on properties #{Enum.join(missing, ", ")} to be present but they were not."
    end
  end

  defimpl String.Chars, for: Error.Enum do
    def to_string(%Error.Enum{}) do
      "Value is not allowed in enum."
    end
  end

  defimpl String.Chars, for: Error.False do
    def to_string(%Error.False{}) do
      "False schema never matches."
    end
  end

  defimpl String.Chars, for: Error.Format do
    def to_string(%Error.Format{expected: expected}) do
      "Expected to be a valid #{format_name(expected)}."
    end

    defp format_name("date-time"), do: "ISO 8601 date-time"
    defp format_name("ipv4"), do: "IPv4 address"
    defp format_name("ipv6"), do: "IPv6 address"
    defp format_name(expected), do: expected
  end

  defimpl String.Chars, for: Error.IfThenElse do
    def to_string(%Error.IfThenElse{branch: branch}) do
      "Expected the schema in the #{branch} branch to match but it did not."
    end
  end

  defimpl String.Chars, for: Error.ItemsNotAllowed do
    def to_string(%Error.ItemsNotAllowed{}) do
      "Items are not allowed."
    end
  end

  defimpl String.Chars, for: Error.MaxItems do
    def to_string(%Error.MaxItems{expected: expected, actual: actual}) do
      "Expected a maximum of #{expected} items but got #{actual}."
    end
  end

  defimpl String.Chars, for: Error.MaxLength do
    def to_string(%Error.MaxLength{expected: expected, actual: actual}) do
      "Expected value to have a maximum length of #{expected} but was #{actual}."
    end
  end

  defimpl String.Chars, for: Error.MaxProperties do
    def to_string(%Error.MaxProperties{expected: expected, actual: actual}) do
      "Expected a maximum of #{expected} properties but got #{actual}"
    end
  end

  defimpl String.Chars, for: Error.Maximum do
    def to_string(%Error.Maximum{expected: expected, exclusive?: exclusive?}) do
      "Expected the value to be #{if exclusive?, do: "<", else: "<="} #{expected}"
    end
  end

  defimpl String.Chars, for: Error.MinItems do
    def to_string(%Error.MinItems{expected: expected, actual: actual}) do
      "Expected a minimum of #{expected} items but got #{actual}."
    end
  end

  defimpl String.Chars, for: Error.MinLength do
    def to_string(%Error.MinLength{expected: expected, actual: actual}) do
      "Expected value to have a minimum length of #{expected} but was #{actual}."
    end
  end

  defimpl String.Chars, for: Error.MinProperties do
    def to_string(%Error.MinProperties{expected: expected, actual: actual}) do
      "Expected a minimum of #{expected} properties but got #{actual}"
    end
  end

  defimpl String.Chars, for: Error.Minimum do
    def to_string(%Error.Minimum{expected: expected, exclusive?: exclusive?}) do
      "Expected the value to be #{if exclusive?, do: ">", else: ">="} #{expected}"
    end
  end

  defimpl String.Chars, for: Error.MultipleOf do
    def to_string(%Error.MultipleOf{expected: expected}) do
      "Expected value to be a multiple of #{expected}."
    end
  end

  defimpl String.Chars, for: Error.Not do
    def to_string(%Error.Not{}) do
      "Expected schema not to match but it did."
    end
  end

  defimpl String.Chars, for: Error.OneOf do
    def to_string(%Error.OneOf{valid_indices: valid_indices}) do
      if length(valid_indices) > 1 do
        "Expected exactly one of the schemata to match, but the schemata at the following indexes did: " <>
          Enum.join(valid_indices, ", ") <> "."
      else
        "Expected exactly one of the schemata to match, but none of them did."
      end
    end
  end

  defimpl String.Chars, for: Error.Pattern do
    def to_string(%Error.Pattern{expected: expected}) do
      "Does not match pattern #{inspect(expected)}."
    end
  end

  defimpl String.Chars, for: Error.PropertyNames do
    def to_string(%Error.PropertyNames{invalid: invalid}) do
      "Expected the property names to be valid but the following were not: #{invalid |> Map.keys() |> Enum.sort() |> Enum.join(", ")}."
    end
  end

  defimpl String.Chars, for: Error.Required do
    def to_string(%Error.Required{missing: [missing]}) do
      "Required property #{missing} was not present."
    end

    def to_string(%Error.Required{missing: missing}) do
      "Required properties #{Enum.join(missing, ", ")} were not present."
    end
  end

  defimpl String.Chars, for: Error.Type do
    def to_string(%Error.Type{expected: expected, actual: actual}) do
      "Type mismatch. Expected #{type_names(expected)} but got #{type_names(actual)}."
    end

    defp type_names(types) do
      types
      |> List.wrap()
      |> Enum.map(&String.capitalize/1)
      |> Enum.join(", ")
    end
  end

  defimpl String.Chars, for: Error.UniqueItems do
    def to_string(%Error.UniqueItems{}) do
      "Expected items to be unique but they were not."
    end
  end
end

1	defmodule ExJsonSchema.Validator.Error.StringFormatter do
2	alias ExJsonSchema.Validator.Error
3
4	@spec format(ExJsonSchema.Validator.errors()) :: [{String.t(), String.t()}]
5	def format(errors) do
6	Enum.map(errors, fn %Error{error: error, path: path} ->	106✔
7	{to_string(error), path}	122✔
8	end)
9	end
10
11	defimpl String.Chars, for: Error.AdditionalItems do
12	def to_string(%Error.AdditionalItems{}) do	1✔
13	"Schema does not allow additional items."
14	end
15	end
16
17	defimpl String.Chars, for: Error.AdditionalProperties do
18	def to_string(%Error.AdditionalProperties{}) do	1✔
19	"Schema does not allow additional properties."
20	end
21	end
22
23	defimpl String.Chars, for: Error.AllOf do
24	def to_string(%Error.AllOf{invalid: invalid}) do
25	"Expected all of the schemata to match, but the schemata at the following indexes did not: #{Enum.map_join(invalid, ", ", & &1.index)}."	2✔
26	end
27	end
28
29	defimpl String.Chars, for: Error.AnyOf do
30	def to_string(%Error.AnyOf{}) do	1✔
31	"Expected any of the schemata to match but none did."
32	end
33	end
34
35	defimpl String.Chars, for: Error.Const do
36	def to_string(%Error.Const{expected: expected}) do
37	"Expected data to be #{inspect(expected)}."	2✔
38	end
39	end
40
41	defimpl String.Chars, for: Error.Contains do
42	def to_string(%Error.Contains{}) do	2✔
43	"Expected any of the items to match the schema but none did."
44	end
45	end
46
47	defimpl String.Chars, for: Error.ContentEncoding do
48	def to_string(%Error.ContentEncoding{expected: expected}) do
49	"Expected the content to be #{expected}-encoded."	2✔
50	end
51	end
52
53	defimpl String.Chars, for: Error.ContentMediaType do
54	def to_string(%Error.ContentMediaType{expected: expected}) do
55	"Expected the content to be of media type #{expected}."	4✔
56	end
57	end
58
59	defimpl String.Chars, for: Error.Dependencies do
60	def to_string(%Error.Dependencies{property: property, missing: [missing]}) do
61	"Property #{property} depends on property #{missing} to be present but it was not."	2✔
62	end
63
64	def to_string(%Error.Dependencies{property: property, missing: missing}) do
65	"Property #{property} depends on properties #{Enum.join(missing, ", ")} to be present but they were not."	2✔
66	end
67	end
68
69	defimpl String.Chars, for: Error.Enum do
70	def to_string(%Error.Enum{}) do	1✔
71	"Value is not allowed in enum."
72	end
73	end
74
75	defimpl String.Chars, for: Error.False do
76	def to_string(%Error.False{}) do	2✔
77	"False schema never matches."
78	end
79	end
80
81	defimpl String.Chars, for: Error.Format do
82	def to_string(%Error.Format{expected: expected}) do
83	"Expected to be a valid #{format_name(expected)}."	16✔
84	end
85
86	defp format_name("date-time"), do: "ISO 8601 date-time"	1✔
87	defp format_name("ipv4"), do: "IPv4 address"	1✔
88	defp format_name("ipv6"), do: "IPv6 address"	1✔
89	defp format_name(expected), do: expected	10✔
90	end
91
92	defimpl String.Chars, for: Error.IfThenElse do
93	def to_string(%Error.IfThenElse{branch: branch}) do
94	"Expected the schema in the #{branch} branch to match but it did not."	×
95	end
96	end
97
98	defimpl String.Chars, for: Error.ItemsNotAllowed do
99	def to_string(%Error.ItemsNotAllowed{}) do	1✔
100	"Items are not allowed."
101	end
102	end
103
104	defimpl String.Chars, for: Error.MaxItems do
105	def to_string(%Error.MaxItems{expected: expected, actual: actual}) do
106	"Expected a maximum of #{expected} items but got #{actual}."	2✔
107	end
108	end
109
110	defimpl String.Chars, for: Error.MaxLength do
111	def to_string(%Error.MaxLength{expected: expected, actual: actual}) do
112	"Expected value to have a maximum length of #{expected} but was #{actual}."	2✔
113	end
114	end
115
116	defimpl String.Chars, for: Error.MaxProperties do
117	def to_string(%Error.MaxProperties{expected: expected, actual: actual}) do
118	"Expected a maximum of #{expected} properties but got #{actual}"	2✔
119	end
120	end
121
122	defimpl String.Chars, for: Error.Maximum do
123	def to_string(%Error.Maximum{expected: expected, exclusive?: exclusive?}) do
124	"Expected the value to be #{if exclusive?, do: "<", else: "<="} #{expected}"	4✔
125	end
126	end
127
128	defimpl String.Chars, for: Error.MinItems do
129	def to_string(%Error.MinItems{expected: expected, actual: actual}) do
130	"Expected a minimum of #{expected} items but got #{actual}."	2✔
131	end
132	end
133
134	defimpl String.Chars, for: Error.MinLength do
135	def to_string(%Error.MinLength{expected: expected, actual: actual}) do
136	"Expected value to have a minimum length of #{expected} but was #{actual}."	2✔
137	end
138	end
139
140	defimpl String.Chars, for: Error.MinProperties do
141	def to_string(%Error.MinProperties{expected: expected, actual: actual}) do
142	"Expected a minimum of #{expected} properties but got #{actual}"	2✔
143	end
144	end
145
146	defimpl String.Chars, for: Error.Minimum do
147	def to_string(%Error.Minimum{expected: expected, exclusive?: exclusive?}) do
148	"Expected the value to be #{if exclusive?, do: ">", else: ">="} #{expected}"	4✔
149	end
150	end
151
152	defimpl String.Chars, for: Error.MultipleOf do
153	def to_string(%Error.MultipleOf{expected: expected}) do
154	"Expected value to be a multiple of #{expected}."	4✔
155	end
156	end
157
158	defimpl String.Chars, for: Error.Not do
159	def to_string(%Error.Not{}) do	1✔
160	"Expected schema not to match but it did."
161	end
162	end
163
164	defimpl String.Chars, for: Error.OneOf do
165	def to_string(%Error.OneOf{valid_indices: valid_indices}) do
166	if length(valid_indices) > 1 do	4✔
167	"Expected exactly one of the schemata to match, but the schemata at the following indexes did: " <>	2✔
168	Enum.join(valid_indices, ", ") <> "."
169	else
170	"Expected exactly one of the schemata to match, but none of them did."
171	end
172	end
173	end
174
175	defimpl String.Chars, for: Error.Pattern do
176	def to_string(%Error.Pattern{expected: expected}) do
177	"Does not match pattern #{inspect(expected)}."	2✔
178	end
179	end
180
181	defimpl String.Chars, for: Error.PropertyNames do
182	def to_string(%Error.PropertyNames{invalid: invalid}) do
183	"Expected the property names to be valid but the following were not: #{invalid \|> Map.keys() \|> Enum.sort() \|> Enum.join(", ")}."	2✔
184	end
185	end
186
187	defimpl String.Chars, for: Error.Required do
188	def to_string(%Error.Required{missing: [missing]}) do
189	"Required property #{missing} was not present."	2✔
190	end
191
192	def to_string(%Error.Required{missing: missing}) do
193	"Required properties #{Enum.join(missing, ", ")} were not present."	2✔
194	end
195	end
196
197	defimpl String.Chars, for: Error.Type do
198	def to_string(%Error.Type{expected: expected, actual: actual}) do
199	"Type mismatch. Expected #{type_names(expected)} but got #{type_names(actual)}."	34✔
200	end
201
202	defp type_names(types) do
203	types
204	\|> List.wrap()
205	\|> Enum.map(&String.capitalize/1)
206	\|> Enum.join(", ")	68✔
207	end
208	end
209
210	defimpl String.Chars, for: Error.UniqueItems do
211	def to_string(%Error.UniqueItems{}) do	1✔
212	"Expected items to be unique but they were not."
213	end
214	end
215	end

jonasschmidt / ex_json_schema / 7d7015cabf77f6a7ed47ed22029e4f76acd1760b

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous