iso-deserializer 0.8.0

data/test/unit/deserializer_test.rb

@@ -0,0 +1,200 @@
+require 'minitest_helper'
+
+class DeserializerTest < Minitest::Test
+
+  def setup
+    @params = { user: 6,
+                user_id: 6,
+                text: "text",
+                i_sholdnt_be_here: :should_i_now}
+
+  end
+
+  def test_no_nil_params
+    assert_raises Deserializer::DeserializerError do
+      BasicDeserializer.from_params nil
+    end
+  end
+
+  def test_from_params
+    assert_equal ({user_id: 6, text: "text"}) , BasicDeserializer.from_params( @params )
+  end
+
+  def test_does_not_eat_false_or_nil_values
+    params = {  user_id: nil,
+                text: false,
+                i_sholdnt_be_here: :should_i_now }
+                
+    assert_equal ({user_id: nil, text: false}) , BasicDeserializer.from_params( params )
+  end
+
+  def test_permitted_params
+    assert_equal [:user_id, :text] , BasicDeserializer.permitted_params
+  end
+
+  def test_permitted_params_with_attr_key
+    assert_equal [:user, :text] , AttributeDeserializer.permitted_params
+  end
+
+  def test_attribute
+    assert_equal "text", AttributeDeserializer.from_params( @params )[:text]
+  end
+
+  def test_attribute_with_key
+    assert_equal 6, AttributeDeserializer.from_params( @params )[:user_id]
+  end
+
+  def test_ignore_empty_option
+    d = EmptiableAttributeDeserializer
+    
+    assert_equal ({ emptiable: true }), d.from_params( emptiable: true )
+    assert_equal ({ nonemptiable: true }), d.from_params( nonemptiable: true )
+
+    [false, nil, "", [], {}].each do |empty_value|
+      assert_equal ({}), d.from_params( emptiable: empty_value )
+      assert_equal ({ nonemptiable: empty_value }), d.from_params( nonemptiable: empty_value )
+    end
+  end
+
+  def test_ignore_empty_with_key
+    d = EmptiableAttributeDeserializer
+    
+    assert_equal ({ emptiable_with_key: true }), d.from_params( empty: true )
+    assert_equal ({ nonemptiable_with_key: true }), d.from_params( non_empty: true )
+
+    [false, nil, "", [], {}].each do |value|
+      assert_equal ({}), d.from_params( key: value )
+      assert_equal ({ nonemptiable_with_key: value }), d.from_params( non_empty: value )
+    end
+  end
+
+  def test_undefined_params_dont_come_through
+    assert_equal nil, AttributeDeserializer.from_params( @params )[:i_shouldnt_be_here]
+  end
+
+  def test_supports_conversions
+    expected = { real_range: (1..4), bad_range: (1..1)}
+    params   = { real_range: [1, 12, 4], bad_range: 1}
+
+    assert_equal expected, ConversionDeserializer.from_params( params )
+  end
+
+  def test_supports_conversions_with_key
+    expected = { real_range: (1..4), bad_range: (1..1)}
+    params   = { real: [1, 4], bad: 1}
+
+    assert_equal expected, KeyedConversionDeserializer.from_params( params )
+  end
+
+  def test_supports_conversions_with_ignore_empty
+    expected = { real_range: (1..4)}
+    params   = { real: [1, 4], bad: nil}
+
+    assert_equal expected, NillableConversionDeserializer.from_params( params )
+  end
+
+  def test_has_one
+    expected = { internal: :thing, params: { user_id: 6, text: "text" }}
+    params   = { external: :thing, params: @params }
+    assert_equal expected, VanillaHasOneDeserializer.from_params( params )
+  end
+
+  def test_has_one_supports_key
+    expected = { internal: :thing, user_info: { user_id: 6, text: "text" }}
+    params   = { external: :thing, thing: @params }
+    assert_equal expected, KeyedHasOneDeserializer.from_params( params )
+  end
+
+  def test_has_one_requires_deserializer
+    assert_raises Deserializer::DeserializerError do
+      BasicDeserializer.has_one :splosion
+    end
+  end
+
+  def test_has_one_with_key_target
+    expected = { internal: :thing, user_info: { user_id: 6, text: "text" }}
+    params   = { external: :thing, thing: @params }
+    assert_equal expected, HasOneWithTargetDeserializer.from_params( params )
+  end
+
+  def test_can_combine_two_has_ones_into_a_third_key
+    expected = { internal: :thing, user_info: { user_id: 6, text: "text", attr1: :blah, attr2: :blech }}
+    params   = { external: :thing, thing: @params, other_thing: {attr1: :blah, attr2: :blech} }
+    assert_equal expected, TricksyDeserializer.from_params( params )
+  end
+
+
+  def test_can_merge_a_has_one_into_another
+    expected = { internal: :thing, thing: { user_id: 6, text: "text", attr1: :blah, attr2: :blech }}
+    params   = { external: :thing, thing: @params, other_thing: {attr1: :blah, attr2: :blech} }
+    assert_equal expected, ExtraTricksyDeserializer.from_params( params )
+  end
+
+
+  def test_merge_has_one_into_object
+    expected = { internal: :thing, user_id: 6, text: "text", attr1: :blah, attr2: :blech }
+    params   = { external: :thing, thing: @params, other_thing: {attr1: :blah, attr2: :blech} }
+    assert_equal expected, HasOneWithObjectTargetDeserializer.from_params( params )
+  end
+
+  def test_belongs_to_unpermitted
+    assert_raises Deserializer::DeserializerError do
+      BasicDeserializer.belongs_to :explody
+    end
+  end
+
+  def test_tests_requires_deserializer
+    assert_raises Deserializer::DeserializerError do
+      BasicDeserializer.nests :splosion
+    end
+  end
+
+  def test_supports_nested
+    params   = { id: 1, attr_1: "blah", attr_2: "something" }
+    expected = { id: 1, attr_1: "blah", nested_object: { name: "blah", attr_2: "something" } }
+
+    assert_equal expected, NestableDeserializer.from_params( params )
+  end
+
+  def test_has_many_requires_deserializer
+    assert_raises Deserializer::DeserializerError do
+      BasicDeserializer.has_many :splosions
+    end
+  end
+
+  def test_supports_has_many
+    params   = { id: 1, attributes: [{user: 6, text: "lol"}, {user: 6, text: "something"}] }
+    expected = { id: 1, attributes: [{user_id: 6, text: "lol"}, {user_id: 6, text: "something"}] }
+
+    assert_equal expected, HasManyDeserializer.from_params( params )
+  end
+
+  def test_has_many_handles_no_input
+    assert_equal ({}), HasManyDeserializer.from_params( {} )
+  end
+
+  def test_has_many_supports_key
+    params   = { id: 1, attributes: [{user: 6, text: "lol"}, {user: 6, text: "something"}] }
+    expected = { id: 1, special_attributes: [{user_id: 6, text: "lol"}, {user_id: 6, text: "something"}] }
+
+    assert_equal expected, KeyedHasManyDeserializer.from_params( params )
+  end
+
+  def test_has_one_handles_no_input
+    assert_equal ({}), VanillaHasOneDeserializer.from_params( {} )
+  end
+
+  def test_nested_handles_no_input
+    assert_equal ({nested_object: {}}), NestableDeserializer.from_params( {} )
+  end
+
+  def test_can_inherit_from_other_deserializer
+    base_permitted_params = HasOneWithTargetDeserializer.permitted_params
+
+    assert_equal [:external, :thing], base_permitted_params, "inheritance broke the base class"
+    
+    inherited_permitted_params = base_permitted_params + [:this, :that, :created_by]
+    
+    assert_equal inherited_permitted_params, InheritedDeserializer.permitted_params
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: iso-deserializer
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Isometric
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description: conversion from complexy write params to a json blob that an AR model
+  can consume
+email:
+- andy@iso.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- MIT-LICENSE
+- README.md
+- Rakefile
+- deserializer.gemspec
+- gemfiles/4.0.gemfile
+- gemfiles/5.0.gemfile
+- gemfiles/6.0.gemfile
+- lib/deserializer.rb
+- lib/deserializer/attributable.rb
+- lib/deserializer/attribute.rb
+- lib/deserializer/attribute/association.rb
+- lib/deserializer/attribute/attribute.rb
+- lib/deserializer/attribute/base.rb
+- lib/deserializer/attribute/has_many_association.rb
+- lib/deserializer/attribute/has_one_association.rb
+- lib/deserializer/attribute/nested_association.rb
+- lib/deserializer/attribute/value_attribute.rb
+- lib/deserializer/base.rb
+- lib/deserializer/deserializer_error.rb
+- lib/deserializer/version.rb
+- test/lib/deserializers.rb
+- test/minitest_helper.rb
+- test/unit/deserializer_error_test.rb
+- test/unit/deserializer_test.rb
+homepage: https://github.com/gaorlov/deserializer
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: deserialization
+test_files:
+- test/lib/deserializers.rb
+- test/minitest_helper.rb
+- test/unit/deserializer_error_test.rb
+- test/unit/deserializer_test.rb