parametric 0.0.1 → 0.2.12

data/spec/field_spec.rb

@@ -0,0 +1,430 @@
+require "spec_helper"
+
+describe Parametric::Field do
+  let(:registry) { Parametric.registry }
+  let(:context) { Parametric::Context.new}
+  subject { described_class.new(:a_key, registry) }
+
+  def register_coercion(name, block)
+    registry.policy name do
+      coerce &block
+    end
+  end
+
+  def resolve(subject, payload)
+    subject.resolve(payload, context)
+  end
+
+  def has_errors
+    expect(context.errors.keys).not_to be_empty
+  end
+
+  def no_errors
+    expect(context.errors.keys).to be_empty
+  end
+
+  def has_error(key, message)
+    expect(context.errors[key]).to include(message)
+  end
+
+  let(:payload) { {a_key: "Joe"} }
+
+  describe "#resolve" do
+    it "returns value" do
+      resolve(subject, payload).tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "Joe"
+      end
+    end
+  end
+
+  BUILT_IN_COERCIONS = [:string, :integer, :number, :array, :object, :boolean]
+
+  describe "#meta_data" do
+    BUILT_IN_COERCIONS.each do |t|
+      it "policy #{t} adds #{t} to meta data" do
+        subject.policy(t)
+        expect(subject.meta_data[:type]).to eq t
+      end
+    end
+  end
+
+  describe "#type" do
+    it "is an alias for #policy" do
+      subject.type(:integer)
+      resolve(subject, a_key: "10.0").tap do |r|
+        expect(r.value).to eq 10
+      end
+    end
+  end
+
+  describe "#policy" do
+    it "coerces integer" do
+      subject.policy(:integer)
+      resolve(subject, a_key: "10.0").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq 10
+      end
+    end
+
+    it "coerces number" do
+      subject.policy(:number)
+      resolve(subject, a_key: "10.0").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq 10.0
+      end
+    end
+
+    it "coerces string" do
+      subject.policy(:string)
+      resolve(subject, a_key: 10.0).tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "10.0"
+      end
+    end
+  end
+
+  describe "#default" do
+    it "is default if missing key" do
+      resolve(subject.default("AA"), foobar: 1).tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "AA"
+      end
+    end
+
+    it "returns value if key is present" do
+      resolve(subject.default("AA"), a_key: nil).tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq nil
+      end
+
+      resolve(subject.default("AA"), a_key: "abc").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "abc"
+      end
+    end
+  end
+
+  describe "#present" do
+    it "is valid if value is present" do
+      resolve(subject.present, a_key: "abc").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "abc"
+      end
+    end
+
+    it "is invalid if value is empty" do
+      resolve(subject.present, a_key: "").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq ""
+      end
+
+      resolve(subject.present, a_key: nil).tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq nil
+      end
+    end
+
+    it "is invalid if key is missing" do
+      resolve(subject.present, foo: "abc").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq nil
+      end
+    end
+  end
+
+  describe "#required" do
+    it "is valid if key is present" do
+      resolve(subject.required, a_key: "abc").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "abc"
+      end
+    end
+
+    it "is valid if key is present and value empty" do
+      resolve(subject.required, a_key: "").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq ""
+      end
+    end
+
+    it "is invalid if key is missing" do
+      resolve(subject.required, foobar: "lala").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq nil
+      end
+    end
+  end
+
+  describe "#options" do
+    before do
+      subject.options(['a', 'b', 'c'])
+    end
+
+    it "resolves if value within options" do
+      resolve(subject, a_key: "b").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "b"
+      end
+    end
+
+    it "resolves if value is array within options" do
+      resolve(subject, a_key: ["b", "c"]).tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq ["b", "c"]
+      end
+    end
+
+    it "does not resolve if missing key" do
+      resolve(subject, foobar: ["b", "c"]).tap do |r|
+        expect(r.eligible?).to be false
+        no_errors
+        expect(r.value).to be_nil
+      end
+    end
+
+    it "does resolve if missing key and default set" do
+      subject.default("Foobar")
+      resolve(subject, foobar: ["b", "c"]).tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "Foobar"
+      end
+    end
+
+    it "is invalid if missing key and required" do
+      subject = described_class.new(:a_key).required.options(%w(a b c))
+      resolve(subject, foobar: ["b", "c"]).tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to be_nil
+      end
+    end
+
+    it "is invalid if value outside options" do
+      resolve(subject, a_key: "x").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq "x"
+      end
+
+      resolve(subject, a_key: ["x", "b"]).tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq ["x", "b"]
+      end
+    end
+  end
+
+  describe ":split policy" do
+    it "splits by comma" do
+      resolve(subject.policy(:split), a_key: "tag1,tag2").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq ["tag1", "tag2"]
+      end
+    end
+  end
+
+  describe ":declared policy" do
+    it "is eligible if key exists" do
+      resolve(subject.policy(:declared).present, a_key: "").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq ""
+      end
+    end
+
+    it "is available as method" do
+      resolve(subject.declared.present, a_key: "").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq ""
+      end
+    end
+
+    it "is not eligible if key does not exist" do
+      resolve(subject.policy(:declared).present, foo: "").tap do |r|
+        expect(r.eligible?).to be false
+        no_errors
+        expect(r.value).to eq nil
+      end
+    end
+
+    it "returns default" do
+      resolve(subject.policy(:declared).default('aa'), foo: "").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq 'aa'
+      end
+    end
+  end
+
+  describe ':declared_no_default' do
+    it "does not return default" do
+      resolve(subject.policy(:declared_no_default).default('aa'), lala: "").tap do |r|
+        expect(r.eligible?).to be false
+        no_errors
+        expect(r.value).to eq nil
+      end
+    end
+  end
+
+  describe ":noop policy" do
+    it "does not do anything" do
+      resolve(subject.policy(:noop).present, a_key: "").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq ""
+      end
+
+      resolve(subject.policy(:noop).present, foo: "").tap do |r|
+        expect(r.eligible?).to be true
+        has_errors
+        expect(r.value).to eq nil
+      end
+    end
+  end
+
+  describe "#schema" do
+    it "runs sub-schema" do
+      subject.schema do
+        field(:name).policy(:string)
+        field(:tags).policy(:split).policy(:array)
+      end
+
+      payload = {a_key: [{name: "n1", tags: "t1,t2"}, {name: "n2", tags: ["t3"]}]}
+
+      resolve(subject, payload).tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq([
+          {name: "n1", tags: ["t1", "t2"]},
+          {name: "n2", tags: ["t3"]},
+        ])
+      end
+    end
+  end
+
+  describe '#policy' do
+    let(:custom_klass) do
+      Class.new do
+        def initialize(title = 'Sr.')
+          @title = title
+        end
+
+        def eligible?(*_)
+          true
+        end
+
+        def valid?(*_)
+          true
+        end
+
+        def coerce(value, key, context)
+          "#{@title} #{value}"
+        end
+
+        def meta_data
+          {foo: "bar"}
+        end
+      end
+    end
+
+    it 'works with policy in registry' do
+      register_coercion :foo, ->(v, k, c){ "Hello #{v}" }
+      subject.policy(:foo)
+      resolve(subject, a_key: "Ismael").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "Hello Ismael"
+      end
+    end
+
+    it 'raises if policy not found' do
+      expect{
+        subject.policy(:foobar)
+      }.to raise_exception Parametric::ConfigurationError
+    end
+
+    it 'chains policies' do
+      registry.policy :general, custom_klass.new("General")
+      registry.policy :commander, custom_klass.new("Commander")
+
+      subject
+        .policy(:general)
+        .policy(:commander)
+
+      resolve(subject, a_key: "Ismael").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "Commander General Ismael"
+      end
+    end
+
+    it "can instantiate policy class and pass arguments" do
+      registry.policy :job_title, custom_klass
+
+      subject.policy(:job_title, "Developer")
+
+      resolve(subject, a_key: "Ismael").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "Developer Ismael"
+      end
+    end
+
+    it "can take a class not in the registry" do
+      subject.policy(custom_klass, "Developer")
+
+      resolve(subject, a_key: "Ismael").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "Developer Ismael"
+      end
+    end
+
+    it "adds policy meta data" do
+      subject.policy(custom_klass, "Developer")
+      expect(subject.meta_data[:foo]).to eq "bar"
+    end
+
+    it "can take an instance not in the registry" do
+      subject.policy(custom_klass.new("Developer"), "ignore this")
+
+      resolve(subject, a_key: "Ismael").tap do |r|
+        expect(r.eligible?).to be true
+        no_errors
+        expect(r.value).to eq "Developer Ismael"
+      end
+    end
+
+    it 'add policy exceptions to #errors' do
+      register_coercion :error, ->(v, k, c){ raise "This is an error" }
+
+      subject.policy(:error)
+
+      resolve(subject, a_key: "b").tap do |r|
+        expect(r.eligible?).to be true
+        has_error("$", "This is an error")
+        expect(r.value).to eq "b"
+      end
+    end
+  end
+end

data/spec/policies_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe 'default coercions' do
+  def test_coercion(key, value, expected)
+    coercion = Parametric.registry.policies[key]
+    expect(coercion.new.coerce(value, nil, nil)).to eq expected
+  end
+
+  describe ':datetime' do
+    it {
+      coercion = Parametric.registry.coercions[:datetime]
+      coercion.new.coerce("2016-11-05T14:23:34Z", nil, nil).tap do |d|
+        expect(d).to be_a Date
+        expect(d.year).to eq 2016
+        expect(d.month).to eq 11
+        expect(d.day).to eq 5
+        expect(d.hour).to eq 14
+        expect(d.minute).to eq 23
+        expect(d.second).to eq 34
+        expect(d.zone).to eq "+00:00"
+      end
+    }
+  end
+
+  describe ':integer' do
+    it {
+      test_coercion(:integer, '10', 10)
+      test_coercion(:integer, '10.20', 10)
+      test_coercion(:integer, 10.20, 10)
+      test_coercion(:integer, 10, 10)
+    }
+  end
+
+  describe ':number' do
+    it {
+      test_coercion(:number, '10', 10.0)
+      test_coercion(:number, '10.20', 10.20)
+      test_coercion(:number, 10.20, 10.20)
+      test_coercion(:number, 10, 10.0)
+    }
+  end
+
+  describe ':string' do
+    it {
+      test_coercion(:string, '10', '10')
+      test_coercion(:string, '10.20', '10.20')
+      test_coercion(:string, 10.20, '10.2')
+      test_coercion(:string, 10, '10')
+      test_coercion(:string, true, 'true')
+      test_coercion(:string, 'hello', 'hello')
+    }
+  end
+
+  describe ':boolean' do
+    it {
+      test_coercion(:boolean, true, true)
+      test_coercion(:boolean, '10', true)
+      test_coercion(:boolean, '', true)
+      test_coercion(:boolean, nil, false)
+      test_coercion(:boolean, false, false)
+    }
+  end
+
+  describe ':split' do
+    it {
+      test_coercion(:split, 'aaa,bb,cc', ['aaa', 'bb', 'cc'])
+      test_coercion(:split, 'aaa ,bb,  cc', ['aaa', 'bb', 'cc'])
+      test_coercion(:split, 'aaa', ['aaa'])
+      test_coercion(:split, ['aaa', 'bb', 'cc'], ['aaa', 'bb', 'cc'])
+    }
+  end
+end

data/spec/schema_lifecycle_hooks_spec.rb

@@ -0,0 +1,133 @@
+require 'spec_helper'
+
+describe Parametric::Schema do
+  describe '#before_resolve' do
+    it 'passes payload through before_resolve block, if defined' do
+      schema = described_class.new do
+        before_resolve do |payload, _context|
+          payload[:slug] = payload[:name].to_s.downcase.gsub(/\s+/, '-') unless payload[:slug]
+          payload
+        end
+
+        field(:name).policy(:string).present
+        field(:slug).policy(:string).present
+        field(:variants).policy(:array).schema do
+          before_resolve do |payload, _context|
+            payload[:slug] = "v: #{payload[:name].to_s.downcase}"
+            payload
+          end
+          field(:name).policy(:string).present
+          field(:slug).type(:string).present
+        end
+      end
+
+      result = schema.resolve({ name: 'A name', variants: [{ name: 'A variant' }] })
+      expect(result.valid?).to be true
+      expect(result.output[:slug]).to eq 'a-name'
+      expect(result.output[:variants].first[:slug]).to eq 'v: a variant'
+    end
+
+    it 'collects errors added in before_resolve blocks' do
+      schema = described_class.new do
+        field(:variants).type(:array).schema do
+          before_resolve do |payload, context|
+            context.add_error 'nope!' if payload[:name] == 'with errors'
+            payload
+          end
+          field(:name).type(:string)
+        end
+      end
+
+      results = schema.resolve({ variants: [ {name: 'no errors'}, {name: 'with errors'}]})
+      expect(results.valid?).to be false
+      expect(results.errors['$.variants[1]']).to eq ['nope!']
+    end
+
+    it 'copies before_resolve hooks to merged schemas' do
+      schema1 = described_class.new do
+        before_resolve do |payload, _context|
+          payload[:slug] = payload[:name].to_s.downcase.gsub(/\s+/, '-') unless payload[:slug]
+          payload
+        end
+        field(:name).present.type(:string)
+        field(:slug).present.type(:string)
+      end
+
+      schema2 = described_class.new do
+        before_resolve do |payload, _context|
+          payload[:slug] = "slug-#{payload[:slug]}" if payload[:slug]
+          payload
+        end
+
+        field(:age).type(:integer)
+      end
+
+      schema3 = schema1.merge(schema2)
+
+      results = schema3.resolve({ name: 'Ismael Celis', age: 41 })
+      expect(results.output[:slug]).to eq 'slug-ismael-celis'
+    end
+
+    it 'works with any callable' do
+      slug_maker = Class.new do
+        def initialize(slug_field, from:)
+          @slug_field, @from = slug_field, from
+        end
+
+        def call(payload, _context)
+          payload.merge(
+            @slug_field => payload[@from].to_s.downcase.gsub(/\s+/, '-')
+          )
+        end
+      end
+
+      schema = described_class.new do |sc, _opts|
+        sc.before_resolve slug_maker.new(:slug, from: :name)
+
+        sc.field(:name).type(:string)
+        sc.field(:slug).type(:string)
+      end
+
+      results = schema.resolve(name: 'Ismael Celis')
+      expect(results.output[:slug]).to eq 'ismael-celis'
+    end
+  end
+
+  describe '#after_resolve' do
+    let!(:schema) do
+      described_class.new do
+        after_resolve do |payload, ctx|
+          ctx.add_base_error('deposit', 'cannot be greater than house price') if payload[:deposit] > payload[:house_price]
+          payload.merge(desc: 'hello')
+        end
+
+        field(:deposit).policy(:integer).present
+        field(:house_price).policy(:integer).present
+        field(:desc).policy(:string)
+      end
+    end
+
+    it 'passes payload through after_resolve block, if defined' do
+      result = schema.resolve({ deposit: 1100, house_price: 1000 })
+      expect(result.valid?).to be false
+      expect(result.output[:deposit]).to eq 1100
+      expect(result.output[:house_price]).to eq 1000
+      expect(result.output[:desc]).to eq 'hello'
+    end
+
+    it 'copies after hooks when merging schemas' do
+      child_schema = described_class.new do
+        field(:name).type(:string)
+      end
+
+      union = schema.merge(child_schema)
+
+      result = union.resolve({ name: 'Joe', deposit: 1100, house_price: 1000 })
+      expect(result.valid?).to be false
+      expect(result.output[:deposit]).to eq 1100
+      expect(result.output[:house_price]).to eq 1000
+      expect(result.output[:desc]).to eq 'hello'
+      expect(result.output[:name]).to eq 'Joe'
+    end
+  end
+end