generate edge cases more frequently

Author: IgnacioGoldchluk

CHANGELOG.md

@@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
 
 ## Unreleased
 
+## 0.0.12 [2026-06-28]
+- Generate better extreme cases for "number", "integer" and "string" types
+
 ## 0.0.11 [2026-06-26]
 - Add `:string_kind` option to `RockSolid.from_schema/2`
 

README.md

@@ -10,7 +10,7 @@ Add to your list of dependencies
 ```elixir
 def deps do
   [
-    {:rock_solid, "~> 0.0.11", only: :test}
+    {:rock_solid, "~> 0.0.12", only: :test}
   ]
 end
 ```

lib/rock_solid.ex

@@ -66,7 +66,7 @@ defmodule RockSolid do
 
   @opts_schema [
     resolver: [type: :mod_arg, required: true],
-    string_kind: [type: :atom, default: :printable]
+    string_kind: [type: :atom, default: nil]
   ]
 
   @doc """
@@ -76,7 +76,8 @@ defmodule RockSolid do
 
   - `:resolver` - Either a module or a tuple {module, args} that implements the
   `RockSolid.Resolution.Resolver` behaviour. Defaults to [`DummyResolver`](`RockSolid.Resolution.Resolvers.DummyResolver`).
-  - `:string_kind` - The kind of strings to generate. See `StreamData.string/2`. Defaults to `:printable`
+  - `:string_kind` - The kind of strings to generate. See `StreamData.string/2`. Defaults to
+  generating `:utf8` strings
   """
   def from_schema(json_schema, opts \\ []) do
     opts = opts |> parse_resolver() |> NimbleOptions.validate!(@opts_schema)

lib/rock_solid/strategy.ex

@@ -54,21 +54,20 @@ defmodule RockSolid.Strategy do
   end
 
   defp gen(%{"type" => "integer"} = schema, _) do
-    [min: Schemas.Number.min_value(schema), max: Schemas.Number.max_value(schema)]
-    |> Keyword.filter(fn {_, v} -> not is_nil(v) end)
-    |> MoreStreamData.more_integer()
+    StreamData.frequency([
+      {90, regular_integer(schema)},
+      {5, close_to_max(schema)},
+      {5, close_to_min(schema)}
+    ])
     |> filter_value(schema["exclusiveMinimum"])
     |> filter_value(schema["exclusiveMaximum"])
   end
 
-  defp gen(%{"type" => "number"} = schema, _) do
-    [
-      min: Schemas.Number.min_value(schema),
-      max: Schemas.Number.max_value(schema),
-      exclude_min?: Map.has_key?(schema, "exclusiveMinimum"),
-      exclude_max?: Map.has_key?(schema, "exclusiveMaximum")
-    ]
-    |> MoreStreamData.more_float()
+  defp gen(%{"type" => "number"} = schema, opts) do
+    StreamData.frequency([
+      {50, gen(float_to_int(schema), opts)},
+      {50, gen_float(schema)}
+    ])
   end
 
   # pattern always takes priority above format, because format is not stanarized
@@ -91,10 +90,17 @@ defmodule RockSolid.Strategy do
   end
 
   defp gen(%{"type" => "string"} = schema, opts) do
-    StreamData.string(
-      Keyword.fetch!(opts, :string_kind),
-      to_keyword(schema, min_length: "minLength", max_length: "maxLength")
-    )
+    string_opts = to_keyword(schema, min_length: "minLength", max_length: "maxLength")
+
+    case Keyword.fetch!(opts, :string_kind) do
+      nil ->
+        [:utf8, :printable, :ascii]
+        |> Enum.map(fn codepoints -> {1, StreamData.string(codepoints, string_opts)} end)
+        |> StreamData.frequency()
+
+      kind ->
+        StreamData.string(kind, string_opts)
+    end
     |> filter_min_length(schema["minLength"])
   end
 
@@ -503,4 +509,71 @@ defmodule RockSolid.Strategy do
       end
     end)
   end
+
+  defp regular_integer(schema) do
+    [min: Schemas.Number.min_value(schema), max: Schemas.Number.max_value(schema)]
+    |> Keyword.filter(fn {_, v} -> not is_nil(v) end)
+    |> MoreStreamData.more_integer()
+  end
+
+  defp close_to_max(schema) do
+    max = Schemas.Number.max_value(schema) || 2_147_483_647
+    min = Schemas.Number.min_value(schema) || -2_147_483_648
+
+    StreamData.integer(0..(max - min))
+    |> StreamData.map(fn val -> max - val end)
+  end
+
+  defp close_to_min(schema) do
+    max = Schemas.Number.max_value(schema) || 2_147_483_647
+    min = Schemas.Number.min_value(schema) || -2_147_483_648
+
+    StreamData.integer(0..(max - min))
+    |> StreamData.map(fn val -> val + min end)
+  end
+
+  defp gen_float(schema) do
+    StreamData.frequency([
+      {90, regular_float(schema)},
+      {5, close_to_max_float(schema)},
+      {5, close_to_min_float(schema)}
+    ])
+  end
+
+  defp regular_float(schema) do
+    [
+      min: Schemas.Number.min_value(schema),
+      max: Schemas.Number.max_value(schema),
+      exclude_min?: Map.has_key?(schema, "exclusiveMinimum"),
+      exclude_max?: Map.has_key?(schema, "exclusiveMaximum")
+    ]
+    |> MoreStreamData.more_float()
+  end
+
+  defp close_to_max_float(schema) do
+    max = Schemas.Number.max_value(schema) || 8.94e307
+    min = Schemas.Number.min_value(schema) || -8.94e307
+
+    StreamData.float(min: 0, max: max - min)
+    |> StreamData.map(fn val -> max - val end)
+  end
+
+  defp close_to_min_float(schema) do
+    max = Schemas.Number.max_value(schema) || 8.94e307
+    min = Schemas.Number.min_value(schema) || -8.94e307
+
+    StreamData.float(min: 0, max: max - min)
+    |> StreamData.map(fn val -> val + min end)
+  end
+
+  defp float_to_int(%{"type" => "number"} = schema) do
+    ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum"]
+    |> Enum.reduce(Map.put(schema, "type", "integer"), fn key, acc_schema ->
+      if Map.has_key?(acc_schema, key) do
+        Map.update!(acc_schema, key, &trunc/1)
+      else
+        acc_schema
+      end
+    end)
+  end
 end

mix.exs

@@ -2,7 +2,7 @@ defmodule RockSolid.MixProject do
   use Mix.Project
 
   @source_url "https://github.com/IgnacioGoldchluk/rock_solid"
-  @version "0.0.11"
+  @version "0.0.12"
 
   def project do
     [

test/rock_solid/strategy_test.exs

@@ -5,6 +5,14 @@ defmodule RockSolid.StrategyTest do
   alias RockSolid.Schemas.Vocabulary
 
   describe "from_json_schema/1" do
+    property "number generates both integers and floats" do
+      schema = %{"type" => "number", "minimum" => -1.0, "maximum" => 250.5}
+
+      check all num <- RockSolid.from_schema(schema) do
+        assert num >= -1.0 and num <= 250.5
+      end
+    end
+
     property "generates strings of the specified codepoints" do
       schema = %{
         "type" => "object",