9708111060

Committed 24 Jun 2024 04:43AM UTC coverage: 98.097% (+0.7%) from 97.348%

Build # 9708111060

Build Type

push

github

Committed by

notEthan

Commit Message

v0.8.0

Run Details

5877 of 5991 relevant lines covered (98.1%)

148855.95 hits per line

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

98.57

/test/jsi_coder_test.rb

require_relative 'test_helper'

describe JSI::JSICoder do
  let(:schema_content) do
    {properties: {foo: {}, bar: {}}}
  end
  let(:schema_block) { nil }
  let(:schema) { JSI.new_schema(schema_content, default_metaschema: JSI::JSONSchemaDraft07, &schema_block) }
  let(:options) { {} }
  let(:jsi_opt) { {} }
  let(:coder) { JSI::JSICoder.new(schema, jsi_opt: jsi_opt, **options) }

  describe 'json' do
    describe 'load' do
      it 'loads nil' do
        assert_nil(coder.load(nil))
      end
      it 'loads a hash' do
        assert_equal(schema.new_jsi({'foo' => 'bar'}), coder.load({"foo" => "bar"}))
      end
      it 'loads something else' do
        assert_equal(schema.new_jsi([[]]), coder.load([[]]))
      end

      describe 'jsi_opt' do
        let(:jsi_opt) { {stringify_symbol_keys: true} }
        it('loads') { assert_equal(schema.new_jsi({'foo' => 'bar'}), coder.load({:foo => "bar"})) }
      end

      describe 'array' do
        let(:options) { {array: true} }
        it 'loads an array of hashes' do
          data = [{"foo" => "bar"}, {"foo" => "baz"}]
          assert_equal([schema.new_jsi({'foo' => 'bar'}), schema.new_jsi({'foo' => 'baz'})], coder.load(data))
        end
        it 'loads an empty array' do
          assert_equal([], coder.load([]))
        end
        it 'loads a not an array' do
          assert_raises(TypeError) { coder.load({"foo" => "bar"}) }
        end
      end
      describe 'array schema' do
        let(:schema_content) { {items: {properties: {foo: {}, bar: {}}}} }
        it 'loads an array of hashes' do
          data = [{"foo" => "bar"}, {"foo" => "baz"}]
          assert_equal(schema.new_jsi([{'foo' => 'bar'}, {'foo' => 'baz'}]), coder.load(data))
        end
        it 'loads an empty array' do
          assert_equal(schema.new_jsi([]), coder.load([]))
        end
        it 'loads a not an array' do
          assert_equal(schema.new_jsi({"foo" => "bar"}), coder.load({"foo" => "bar"}))
        end
      end
    end
    describe 'dump' do
      it 'dumps nil' do
        assert_nil(coder.dump(nil))
      end
      it 'dumps a JSI' do
        assert_equal({"foo" => "x", "bar" => "y"}, coder.dump(schema.new_jsi({'foo' => 'x', 'bar' => 'y'})))
      end
      it 'dumps something else' do
        if Object.method_defined?(:as_json) && ENV['JSI_TEST_EXTDEP']
          skip("external dependency defines Object#as_json")
        end
        assert_raises(TypeError) do
          coder.dump(Object.new)
        end
      end
      it 'dumps some of the keys of a JSI after loading in a partial one' do
        jsi = coder.load({'foo' => 'who'})
        assert_equal({'foo' => 'who'}, coder.dump(jsi))
        jsi = jsi.merge('bar' => 'whar')
        assert_equal({'foo' => 'who', 'bar' => 'whar'}, coder.dump(jsi))
      end
      describe 'array' do
        let(:options) { {array: true} }
        it 'dumps an array of JSIs' do
          jsis = [schema.new_jsi({'foo' => 'x', 'bar' => 'y'}), schema.new_jsi({'foo' => 'z', 'bar' => 'q'})]
          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], coder.dump(jsis))
        end
      end
      describe 'array schema' do
        let(:schema_content) { {items: {properties: {foo: {}, bar: {}}}} }
        it 'dumps a JSI array' do
          jsis = schema.new_jsi([{'foo' => 'x', 'bar' => 'y'}, {'foo' => 'z', 'bar' => 'q'}])
          assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], coder.dump(jsis))
        end
      end

      describe 'as_json options' do
        let(:options) { {as_json_opt: {from: 'as_json'}} }
        let(:schema_content) { {'$id': 'tag:uthb'} }
        let(:schema_block) { proc { redef_method(:as_json) { |**kw| kw } } }

        it 'passes options' do
          assert_equal({from: 'as_json'}, coder.dump(schema.new_jsi({'foo' => 'x'})))
        end
      end
    end
  end
end

$test_report_file_loaded[__FILE__]

1	require_relative 'test_helper'	14✔
2
3	describe JSI::JSICoder do	14✔
4	let(:schema_content) do	14✔
5	{properties: {foo: {}, bar: {}}}	168✔
6	end
7	let(:schema_block) { nil }	238✔
8	let(:schema) { JSI.new_schema(schema_content, default_metaschema: JSI::JSONSchemaDraft07, &schema_block) }	252✔
9	let(:options) { {} }	182✔
10	let(:jsi_opt) { {} }	238✔
11	let(:coder) { JSI::JSICoder.new(schema, jsi_opt: jsi_opt, **options) }	252✔
12
13	describe 'json' do	14✔
14	describe 'load' do	14✔
15	it 'loads nil' do	14✔
16	assert_nil(coder.load(nil))	14✔
17	end
18	it 'loads a hash' do	14✔
19	assert_equal(schema.new_jsi({'foo' => 'bar'}), coder.load({"foo" => "bar"}))	14✔
20	end
21	it 'loads something else' do	14✔
22	assert_equal(schema.new_jsi([[]]), coder.load([[]]))	14✔
23	end
24
25	describe 'jsi_opt' do	14✔
26	let(:jsi_opt) { {stringify_symbol_keys: true} }	28✔
27	it('loads') { assert_equal(schema.new_jsi({'foo' => 'bar'}), coder.load({:foo => "bar"})) }	28✔
28	end
29
30	describe 'array' do	14✔
31	let(:options) { {array: true} }	56✔
32	it 'loads an array of hashes' do	14✔
33	data = [{"foo" => "bar"}, {"foo" => "baz"}]	14✔
34	assert_equal([schema.new_jsi({'foo' => 'bar'}), schema.new_jsi({'foo' => 'baz'})], coder.load(data))	14✔
35	end
36	it 'loads an empty array' do	14✔
37	assert_equal([], coder.load([]))	14✔
38	end
39	it 'loads a not an array' do	14✔
40	assert_raises(TypeError) { coder.load({"foo" => "bar"}) }	28✔
41	end
42	end
43	describe 'array schema' do	14✔
44	let(:schema_content) { {items: {properties: {foo: {}, bar: {}}}} }	56✔
45	it 'loads an array of hashes' do	14✔
46	data = [{"foo" => "bar"}, {"foo" => "baz"}]	14✔
47	assert_equal(schema.new_jsi([{'foo' => 'bar'}, {'foo' => 'baz'}]), coder.load(data))	14✔
48	end
49	it 'loads an empty array' do	14✔
50	assert_equal(schema.new_jsi([]), coder.load([]))	14✔
51	end
52	it 'loads a not an array' do	14✔
53	assert_equal(schema.new_jsi({"foo" => "bar"}), coder.load({"foo" => "bar"}))	14✔
54	end
55	end
56	end
57	describe 'dump' do	14✔
58	it 'dumps nil' do	14✔
59	assert_nil(coder.dump(nil))	14✔
60	end
61	it 'dumps a JSI' do	14✔
62	assert_equal({"foo" => "x", "bar" => "y"}, coder.dump(schema.new_jsi({'foo' => 'x', 'bar' => 'y'})))	14✔
63	end
64	it 'dumps something else' do	14✔
65	if Object.method_defined?(:as_json) && ENV['JSI_TEST_EXTDEP']	14✔
66	skip("external dependency defines Object#as_json")	×
67	end
68	assert_raises(TypeError) do	14✔
69	coder.dump(Object.new)	14✔
70	end
71	end
72	it 'dumps some of the keys of a JSI after loading in a partial one' do	14✔
73	jsi = coder.load({'foo' => 'who'})	14✔
74	assert_equal({'foo' => 'who'}, coder.dump(jsi))	14✔
75	jsi = jsi.merge('bar' => 'whar')	14✔
76	assert_equal({'foo' => 'who', 'bar' => 'whar'}, coder.dump(jsi))	14✔
77	end
78	describe 'array' do	14✔
79	let(:options) { {array: true} }	28✔
80	it 'dumps an array of JSIs' do	14✔
81	jsis = [schema.new_jsi({'foo' => 'x', 'bar' => 'y'}), schema.new_jsi({'foo' => 'z', 'bar' => 'q'})]	14✔
82	assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], coder.dump(jsis))	14✔
83	end
84	end
85	describe 'array schema' do	14✔
86	let(:schema_content) { {items: {properties: {foo: {}, bar: {}}}} }	28✔
87	it 'dumps a JSI array' do	14✔
88	jsis = schema.new_jsi([{'foo' => 'x', 'bar' => 'y'}, {'foo' => 'z', 'bar' => 'q'}])	14✔
89	assert_equal([{"foo" => "x", "bar" => "y"}, {"foo" => "z", "bar" => "q"}], coder.dump(jsis))	14✔
90	end
91	end
92
93	describe 'as_json options' do	14✔
94	let(:options) { {as_json_opt: {from: 'as_json'}} }	28✔
95	let(:schema_content) { {'$id': 'tag:uthb'} }	28✔
96	let(:schema_block) { proc { redef_method(:as_json) { \|**kw\| kw } } }	56✔
97
98	it 'passes options' do	14✔
99	assert_equal({from: 'as_json'}, coder.dump(schema.new_jsi({'foo' => 'x'})))	14✔
100	end
101	end
102	end
103	end
104	end
105
106	$test_report_file_loaded[__FILE__]	14✔

notEthan / jsi / 9708111060

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