Instruct jiffy to use nil as the Elixir equivalent of the JSON null value

jcoglan · hulkoba · commit fedd48b82ebd · 2025-11-19T15:21:17.000+01:00
diff --git a/test/elixir/lib/couch.ex b/test/elixir/lib/couch.ex
@@ -117,7 +117,7 @@ defmodule Couch do
 
   def process_request_body(body) do
     if is_map(body) do
-      :jiffy.encode(body)
+      :jiffy.encode(body, [:use_nil])
     else
       body
     end
@@ -131,7 +131,7 @@ defmodule Couch do
     content_type = headers[:"Content-Type"]
 
     if !!content_type and String.match?(content_type, ~r/application\/json/) do
-      body |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps])
+      body |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps, :use_nil])
     else
       process_response_body(body)
     end
diff --git a/test/elixir/lib/couch/dbtest.ex b/test/elixir/lib/couch/dbtest.ex
@@ -90,7 +90,7 @@ defmodule Couch.DBTest do
         if prev_value != "" do
           url = "/_node/#{node}/_config/#{section}/#{key}"
           headers = ["X-Couch-Persist": "false"]
-          body = :jiffy.encode(prev_value)
+          body = :jiffy.encode(prev_value, [:use_nil])
           resp = Couch.put(url, headers: headers, body: body)
           assert resp.status_code == 200
         else
@@ -109,7 +109,7 @@ defmodule Couch.DBTest do
     Enum.map(resp.body["all_nodes"], fn node ->
       url = "/_node/#{node}/_config/#{section}/#{key}"
       headers = ["X-Couch-Persist": "false"]
-      body = :jiffy.encode(value)
+      body = :jiffy.encode(value, [:use_nil])
       resp = Couch.put(url, headers: headers, body: body)
       assert resp.status_code == 200
       {node, resp.body}
@@ -494,7 +494,7 @@ defmodule Couch.DBTest do
               Couch.put(
                 "/_node/#{node}/_config/#{setting.section}/#{setting.key}",
                 headers: ["X-Couch-Persist": false],
-                body: :jiffy.encode(setting.value)
+                body: :jiffy.encode(setting.value, [:use_nil])
               )
 
             assert resp.status_code == 200
@@ -525,7 +525,7 @@ defmodule Couch.DBTest do
               Couch.put(
                 "/_node/#{node}/_config/#{setting.section}/#{setting.key}",
                 headers: ["X-Couch-Persist": false],
-                body: :jiffy.encode(value)
+                body: :jiffy.encode(value, [:use_nil])
               )
 
             assert resp.status_code == 200
diff --git a/test/elixir/lib/couch_raw.ex b/test/elixir/lib/couch_raw.ex
@@ -46,7 +46,7 @@ defmodule Rawresp do
 
   def process_request_body(body) do
     if is_map(body) do
-      :jiffy.encode(body)
+      :jiffy.encode(body, [:use_nil])
     else
       body
     end
diff --git a/test/elixir/test/all_docs_test.exs b/test/elixir/test/all_docs_test.exs
@@ -116,7 +116,7 @@ defmodule AllDocsTest do
     assert row["key"] == "1"
     assert row["id"] == "1"
     assert row["value"]["deleted"]
-    assert row["doc"] == :null
+    assert row["doc"] == nil
 
     # Add conflicts
     conflicted_doc1 = %{
diff --git a/test/elixir/test/attachments_multipart_test.exs b/test/elixir/test/attachments_multipart_test.exs
@@ -152,7 +152,7 @@ defmodule AttachmentMultipartTest do
     assert Enum.at(sections, 2).headers["Content-Disposition"] ==
              ~s(attachment; filename="bar.txt")
 
-    doc = :jiffy.decode(Enum.at(sections, 0).body, [:return_maps])
+    doc = :jiffy.decode(Enum.at(sections, 0).body, [:return_maps, :use_nil])
 
     assert doc["_attachments"]["foo.txt"]["follows"] == true
     assert doc["_attachments"]["bar.txt"]["follows"] == true
@@ -175,7 +175,7 @@ defmodule AttachmentMultipartTest do
     sections = parse_multipart(resp)
     assert length(sections) == 2
 
-    doc = :jiffy.decode(Enum.at(sections, 0).body, [:return_maps])
+    doc = :jiffy.decode(Enum.at(sections, 0).body, [:return_maps, :use_nil])
 
     assert doc["_attachments"]["foo.txt"]["stub"] == true
     assert doc["_attachments"]["bar.txt"]["follows"] == true
@@ -206,7 +206,7 @@ defmodule AttachmentMultipartTest do
     assert length(inner_sections) == 2
     assert Enum.at(inner_sections, 0).headers["Content-Type"] == "application/json"
 
-    doc = :jiffy.decode(Enum.at(inner_sections, 0).body, [:return_maps])
+    doc = :jiffy.decode(Enum.at(inner_sections, 0).body, [:return_maps, :use_nil])
     assert doc["_attachments"]["foo.txt"]["stub"] == true
     assert doc["_attachments"]["bar.txt"]["follows"] == true
 
@@ -228,7 +228,7 @@ defmodule AttachmentMultipartTest do
 
     assert length(sections) == 2
 
-    doc = :jiffy.decode(Enum.at(sections, 0).body, [:return_maps])
+    doc = :jiffy.decode(Enum.at(sections, 0).body, [:return_maps, :use_nil])
     assert doc["_attachments"]["foo.txt"]["stub"] == true
     assert doc["_attachments"]["bar.txt"]["follows"] == true
     assert Enum.at(sections, 1).body == "this is 18 chars l"
@@ -377,7 +377,7 @@ defmodule AttachmentMultipartTest do
     assert length(inner_sections) == 3
     assert Enum.at(inner_sections, 0).headers["Content-Type"] == "application/json"
 
-    doc = :jiffy.decode(Enum.at(inner_sections, 0).body, [:return_maps])
+    doc = :jiffy.decode(Enum.at(inner_sections, 0).body, [:return_maps, :use_nil])
     assert doc["_attachments"]["lorem.txt"]["follows"] == true
     assert doc["_attachments"]["lorem.txt"]["encoding"] == "gzip"
     assert doc["_attachments"]["data.bin"]["follows"] == true
@@ -414,7 +414,7 @@ defmodule AttachmentMultipartTest do
     # 2 inner sections: a document body section plus 1 attachment data section
     assert length(inner_sections) == 2
     assert Enum.at(inner_sections, 0).headers["Content-Type"] == "application/json"
-    doc = :jiffy.decode(Enum.at(inner_sections, 0).body, [:return_maps])
+    doc = :jiffy.decode(Enum.at(inner_sections, 0).body, [:return_maps, :use_nil])
     assert doc["_attachments"]["lorem.txt"]["follows"] == true
     assert doc["_attachments"]["lorem.txt"]["encoding"] == "gzip"
     assert Enum.at(inner_sections, 1).body != lorem
@@ -434,7 +434,7 @@ defmodule AttachmentMultipartTest do
     boundary = Enum.at(String.split(boundary_arg, "="), 1)
 
     if String.starts_with?(boundary, ~s(")) do
-      :jiffy.decode(boundary)
+      :jiffy.decode(boundary, [:use_nil])
     else
       boundary
     end
diff --git a/test/elixir/test/changes_async_test.exs b/test/elixir/test/changes_async_test.exs
@@ -407,7 +407,7 @@ defmodule ChangesAsyncTest do
   end
 
   defp parse_chunk(msg) do
-    msg.chunk |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps])
+    msg.chunk |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps, :use_nil])
   end
 
   defp parse_event(msg) do
@@ -419,7 +419,7 @@ defmodule ChangesAsyncTest do
     |> Enum.map(fn p ->
       p
       |> IO.iodata_to_binary()
-      |> :jiffy.decode([:return_maps])
+      |> :jiffy.decode([:return_maps, :use_nil])
     end)
   end
 
@@ -497,7 +497,7 @@ defmodule ChangesAsyncTest do
     body_lines
     |> Enum.filter(fn line -> line != "" end)
     |> Enum.map(fn line ->
-      line |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps])
+      line |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps, :use_nil])
     end)
   end
 
diff --git a/test/elixir/test/changes_test.exs b/test/elixir/test/changes_test.exs
@@ -198,7 +198,7 @@ defmodule ChangesTest do
     assert Enum.member?(changes_ids, "doc1")
     assert Enum.member?(changes_ids, "doc3")
 
-    encoded_doc_ids = doc_ids.doc_ids |> :jiffy.encode()
+    encoded_doc_ids = doc_ids.doc_ids |> :jiffy.encode([:use_nil])
 
     resp =
       Couch.get("/#{db_name}/_changes",
diff --git a/test/elixir/test/config_test.exs b/test/elixir/test/config_test.exs
@@ -23,7 +23,7 @@ defmodule ConfigTest do
   def set_config(context, section, key, val, status_assert) do
     url = "#{context[:config_url]}/#{section}/#{key}"
     headers = ["X-Couch-Persist": "false"]
-    resp = Couch.put(url, headers: headers, body: :jiffy.encode(val))
+    resp = Couch.put(url, headers: headers, body: :jiffy.encode(val, [:use_nil]))
 
     if status_assert do
       assert resp.status_code == status_assert
diff --git a/test/elixir/test/design_docs_test.exs b/test/elixir/test/design_docs_test.exs
@@ -222,7 +222,7 @@ defmodule DesignDocsTest do
     result =
       resp.body
       |> IO.iodata_to_binary()
-      |> :jiffy.decode([:return_maps])
+      |> :jiffy.decode([:return_maps, :use_nil])
 
     assert result["language"] == "javascript"
   end
diff --git a/test/elixir/test/design_options_test.exs b/test/elixir/test/design_options_test.exs
@@ -50,7 +50,7 @@ defmodule DesignOptionsTest do
 
     row_with_key =
       resp.body["rows"]
-      |> Enum.filter(fn p -> p["key"] != :null end)
+      |> Enum.filter(fn p -> p["key"] != nil end)
 
     assert length(row_with_key) == 2
   end
diff --git a/test/elixir/test/erlang_views_test.exs b/test/elixir/test/erlang_views_test.exs
@@ -96,7 +96,7 @@ defmodule ErlangViewsTest do
         "erlang"
       )
 
-    assert Map.get(List.first(results["rows"]), "key", :null) == :null
+    assert Map.get(List.first(results["rows"]), "key", nil) == nil
     assert List.first(results["rows"])["value"] > 0
   end
 
diff --git a/test/elixir/test/jsonp_test.exs b/test/elixir/test/jsonp_test.exs
@@ -107,7 +107,7 @@ defmodule JsonpTest do
       |> Enum.map(fn p ->
         p
         |> IO.iodata_to_binary()
-        |> :jiffy.decode([:return_maps])
+        |> :jiffy.decode([:return_maps, :use_nil])
       end)
       |> Enum.at(0)
 
diff --git a/test/elixir/test/nouveau_test.exs b/test/elixir/test/nouveau_test.exs
@@ -140,7 +140,7 @@ defmodule NouveauTest do
 
   def assert_status_code(resp, code) do
     assert resp.status_code == code,
-      "status code: #{resp.status_code}, resp body: #{:jiffy.encode(resp.body)}"
+      "status code: #{resp.status_code}, resp body: #{:jiffy.encode(resp.body, [:use_nil])}"
   end
 
   test "user-agent header is forbidden", _context do
diff --git a/test/elixir/test/partition_crud_test.exs b/test/elixir/test/partition_crud_test.exs
@@ -154,7 +154,7 @@ defmodule PartitionCrudTest do
                        "error" => "illegal_docid",
                        "id" => "my-partition-post",
                        "reason" => "Doc id must be of form partition:id",
-                       "rev" => :null
+                       "rev" => nil
                      }
                    }
                  ],
diff --git a/test/elixir/test/partition_mango_test.exs b/test/elixir/test/partition_mango_test.exs
@@ -478,7 +478,7 @@ defmodule PartitionMangoTest do
     %{:body => body} = resp
 
     assert body["index"]["name"] == "_all_docs"
-    assert body["mrargs"]["partition"] == :null
+    assert body["mrargs"]["partition"] == nil
 
     resp =
       Couch.post(
@@ -493,7 +493,7 @@ defmodule PartitionMangoTest do
     %{:body => body} = resp
 
     assert body["index"]["def"] == %{"fields" => [%{"some" => "asc"}]}
-    assert body["mrargs"]["partition"] == :null
+    assert body["mrargs"]["partition"] == nil
   end
 
   @tag :with_partitioned_db
diff --git a/test/elixir/test/replication_test.exs b/test/elixir/test/replication_test.exs
@@ -1627,7 +1627,7 @@ defmodule ReplicationTest do
   end
 
   def set_security(db_name, sec_props) do
-    resp = Couch.put("/#{db_name}/_security", body: :jiffy.encode(sec_props))
+    resp = Couch.put("/#{db_name}/_security", body: :jiffy.encode(sec_props, [:use_nil]))
     assert HTTPotion.Response.success?(resp)
     assert resp.body["ok"]
   end
diff --git a/test/elixir/test/reshard_basic_test.exs b/test/elixir/test/reshard_basic_test.exs
@@ -24,12 +24,12 @@ defmodule ReshardBasicTest do
   test "basic api querying, no jobs present" do
     summary = get_summary()
     assert summary["state"] == "running"
-    assert summary["state_reason"] == :null
+    assert summary["state_reason"] == nil
     assert summary["total"] == 0
     assert summary["completed"] == 0
     assert summary["failed"] == 0
     assert summary["stopped"] == 0
-    assert get_state() == %{"state" => "running", "reason" => :null}
+    assert get_state() == %{"state" => "running", "reason" => nil}
     assert get_jobs() == []
   end
 
@@ -57,11 +57,11 @@ defmodule ReshardBasicTest do
   end
 
   test "toggle global state" do
-    assert get_state() == %{"state" => "running", "reason" => :null}
+    assert get_state() == %{"state" => "running", "reason" => nil}
     put_state_stopped("xyz")
     assert get_state() == %{"state" => "stopped", "reason" => "xyz"}
     put_state_running()
-    assert get_state() == %{"state" => "running", "reason" => :null}
+    assert get_state() == %{"state" => "running", "reason" => nil}
   end
 
   test "split q=1 db shards on node1 (1 job)", context do
diff --git a/test/elixir/test/rewrite_test.exs b/test/elixir/test/rewrite_test.exs
@@ -420,14 +420,14 @@ defmodule RewriteTest do
           )
 
         assert resp.status_code == 200
-        result = resp.body |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps])
+        result = resp.body |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps, :use_nil])
         first_row = Enum.at(result["rows"], 0)
         assert Map.has_key?(first_row, "doc")
 
         # COUCHDB-2031 - path normalization versus qs params
         resp = Rawresp.get("/#{db_name}/_design/test/_rewrite/db/_design/test?meta=true")
         assert resp.status_code == 200
-        result = resp.body |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps])
+        result = resp.body |> IO.iodata_to_binary() |> :jiffy.decode([:return_maps, :use_nil])
         assert result["_id"] == "_design/test"
         assert Map.has_key?(result, "_revs_info")
 
diff --git a/test/elixir/test/users_db_test.exs b/test/elixir/test/users_db_test.exs
@@ -126,7 +126,7 @@ defmodule UsersDbTest do
         headers: [authorization: "Basic Xzpf"]
       )
 
-    assert resp.body["userCtx"]["name"] == :null
+    assert resp.body["userCtx"]["name"] == nil
     assert not Enum.member?(resp.body["info"], "authenticated")
 
     # ok, now create a conflicting edit on the jchris doc, and make sure there's no login.
diff --git a/test/elixir/test/view_collation_raw_test.exs b/test/elixir/test/view_collation_raw_test.exs
@@ -13,7 +13,7 @@ defmodule ViewCollationRawTest do
     3,
     4,
     false,
-    :null,
+    nil,
     true,
 
     # Then objects, compared each key value in the list until different.
@@ -109,7 +109,7 @@ defmodule ViewCollationRawTest do
   test "key query option", context do
     Enum.each(@values, fn value ->
       retry_until(fn ->
-        resp = Couch.get(url(context), query: %{:key => :jiffy.encode(value)})
+        resp = Couch.get(url(context), query: %{:key => :jiffy.encode(value, [:use_nil])})
         assert length(resp.body["rows"]) == 1
         assert Enum.at(resp.body["rows"], 0)["key"] == convert(value)
       end)
@@ -154,6 +154,6 @@ defmodule ViewCollationRawTest do
   end
 
   def convert(value) do
-    :jiffy.decode(:jiffy.encode(value), [:return_maps])
+    :jiffy.decode(:jiffy.encode(value, [:use_nil]), [:return_maps, :use_nil])
   end
 end
diff --git a/test/elixir/test/view_collation_test.exs b/test/elixir/test/view_collation_test.exs
@@ -8,7 +8,7 @@ defmodule ViewCollationTest do
 
   @values [
     # Special values sort before all other types
-    :null,
+    nil,
     false,
     true,
 
@@ -94,7 +94,7 @@ defmodule ViewCollationTest do
   test "key query option", context do
     Enum.each(@values, fn value ->
       retry_until(fn ->
-        resp = Couch.get(url(context), query: %{:key => :jiffy.encode(value)})
+        resp = Couch.get(url(context), query: %{:key => :jiffy.encode(value, [:use_nil])})
         assert length(resp.body["rows"]) == 1
         assert Enum.at(resp.body["rows"], 0)["key"] == convert(value)
       end)
@@ -139,6 +139,6 @@ defmodule ViewCollationTest do
   end
 
   def convert(value) do
-    :jiffy.decode(:jiffy.encode(value), [:return_maps])
+    :jiffy.decode(:jiffy.encode(value, [:use_nil]), [:return_maps, :use_nil])
   end
 end
diff --git a/test/elixir/test/view_errors_test.exs b/test/elixir/test/view_errors_test.exs
@@ -20,7 +20,7 @@ defmodule ViewErrorsTest do
     # being included in the view results as null
     results = query(db_name, map_fun)
     assert results["total_rows"] == 1
-    assert Enum.at(results["rows"], 0)["key"] == :null
+    assert Enum.at(results["rows"], 0)["key"] == nil
   end
 
   @tag :with_db
@@ -62,7 +62,7 @@ defmodule ViewErrorsTest do
       |> Map.get("key")
       |> Enum.at(1)
 
-    assert key == :null
+    assert key == nil
   end
 
   @tag :with_db
diff --git a/test/elixir/test/view_multi_key_all_docs_test.exs b/test/elixir/test/view_multi_key_all_docs_test.exs
diff --git a/test/elixir/test/view_multi_key_design_test.exs b/test/elixir/test/view_multi_key_design_test.exs
diff --git a/test/elixir/test/view_offsets_test.exs b/test/elixir/test/view_offsets_test.exs
