paradocs 1.0.22

data/spec/field_spec.rb

@@ -0,0 +1,416 @@
+require "spec_helper"
+
+describe Paradocs::Field do
+  let(:context)  { Paradocs::Context.new }
+
+  subject { described_class.new(:a_key) }
+
+  def register_coercion(name, block)
+    Paradocs.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
+        has_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
+  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
+
+        def policy_name
+          :custom_policy
+        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 Paradocs::ConfigurationError
+    end
+
+    it 'chains policies' do
+      Paradocs.registry.policy :general, custom_klass.new("General")
+      Paradocs.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
+      Paradocs.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 message to #errors if validation fails' 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("$", "is invalid")
+        expect(r.value).to eq "b"
+      end
+    end
+  end
+end

data/spec/helpers.rb

@@ -0,0 +1,18 @@
+def expected_policy_behavior(policy:, policy_args: [], input:, output: nil, errors: {}, environment: {}, ignore_for: [])
+  output ||= input
+  schema = Paradocs::Schema.new do
+    input.map do |key, value|
+      instruction = ignore_for.include?(key) ? -> { field(key) } : -> { field(key).policy(*([policy] + policy_args)) }
+
+      instance_exec &instruction
+    end
+  end
+
+  if block_given? || output.nil?
+    expect { schema.resolve(input, environment) }.to yield
+  else
+    result = schema.resolve(input, environment)
+    expect(result.output).to eq(output)
+    expect(result.errors).to eq(errors)
+  end
+end

data/spec/policies_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+
+describe 'default coercions' do
+  def test_coercion(key, value, expected)
+    coercion = Paradocs.registry.coercions[key]
+    expect(coercion.new.coerce(value, nil, nil)).to eq expected
+  end
+
+  describe ':datetime' do
+    it {
+      coercion = Paradocs.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
+
+  describe ':gt' do
+    it "passes the value if it's greater than policy param" do
+      expected_policy_behavior(policy: :gt, policy_args: [3], input: {a: 4}, output: {a: 4})
+    end
+
+    it "raises error if value is greater to policy param" do
+      errors  = {"$.a"=>["value must be strictly greater than 10"]}
+      errors2 = {"$.a"=>["value must be strictly greater than 10"]}
+      expected_policy_behavior(policy: :gt, policy_args: [10], input: {a: 4}, errors: errors)
+      expected_policy_behavior(policy: :gt, policy_args: [10], input: {a: 10}, errors: errors2)
+    end
+  end
+
+  describe ':gte' do
+    it "passes the value if it's greater or equal to policy param" do
+      expected_policy_behavior(policy: :gte, policy_args: [3], input: {a: 4}, output: {a: 4})
+      expected_policy_behavior(policy: :gte, policy_args: [3], input: {a: 3}, output: {a: 3})
+    end
+
+    it "raises error if value is greater than policy param" do
+      errors = {"$.a"=>["value must be greater than or equal to 10"]}
+      expected_policy_behavior(policy: :gte, policy_args: [10], input: {a: 4}, errors: errors)
+    end
+  end
+
+  describe ':lt' do
+    it "passes the value if it's less to policy param" do
+      expected_policy_behavior(policy: :lt, policy_args: [100], input: {a: 4}, output: {a: 4})
+    end
+
+    it "raises error if value is strictly less to policy param" do
+      errors  = {"$.a"=>["value must be strictly less than 10"]}
+      errors2 = {"$.a"=>["value must be strictly less than 10"]}
+      expected_policy_behavior(policy: :lt, policy_args: [10], input: {a: 40}, errors: errors)
+      expected_policy_behavior(policy: :lt, policy_args: [10], input: {a: 10}, errors: errors2)
+    end
+  end
+
+  describe ':lte' do
+    it "passes the value if it's less or equal to policy param" do
+      expected_policy_behavior(policy: :lte, policy_args: [100], input: {a: 4}, output: {a: 4})
+      expected_policy_behavior(policy: :lte, policy_args: [100], input: {a: 100}, output: {a: 100})
+    end
+
+    it "raises error if value is less or equal than policy param" do
+      errors = {"$.a"=>["value must be less than or equal to 1"]}
+      expected_policy_behavior(policy: :lte, policy_args: [1], input: {a: 40}, output: {a: 40}, errors: errors)
+    end
+  end
+
+  describe ':length' do
+    it "passes the value if it's between min and max limits" do
+      expected_policy_behavior(policy: :length, policy_args: [{min: 5, max: 20}], input: {a: "string"}, output: {a: "string"})
+      expected_policy_behavior(policy: :length, policy_args: [{min: 5}], input: {a: "string"}, output: {a: "string"})
+      expected_policy_behavior(policy: :length, policy_args: [{max: 20}], input: {a: "string"}, output: {a: "string"})
+    end
+
+    it "passes the value if it's exactly :eq limit" do
+      expected_policy_behavior(policy: :length, policy_args: [{eq: 5}], input: {a: "12345"}, output: {a: "12345"})
+    end
+
+    it "raises error if value is not exactly than defined :eq limit" do
+      errors = {"$.a"=>["value must be exactly 10 characters"]}
+      expected_policy_behavior(policy: :length, policy_args: [{eq: 10}], input: {a: "test"}, output: {a: "test"}, errors: errors)
+    end
+
+    it "raises error if value is less than min limit" do
+      errors = {"$.a"=>["value must be minimum 10 characters"]}
+      expected_policy_behavior(policy: :length, policy_args: [{min: 10}], input: {a: "test"}, output: {a: "test"}, errors: errors)
+    end
+
+    it "raises error if value is greater than max limit" do
+      errors = {"$.a"=>["value must be maximum 3 characters"]}
+      expected_policy_behavior(policy: :length, policy_args: [{max: 3}], input: {a: "test"}, output: {a: "test"}, errors: errors)
+    end
+
+    it "raises error with full description if value is less than min limit" do
+      errors = {"$.a"=>["value must be minimum 10 characters, maximum 20 characters"]}
+      expected_policy_behavior(policy: :length, policy_args: [{min: 10, max: 20}], input: {a: "test"}, output: {a: "test"}, errors: errors)
+    end
+
+    it "raises error with full description if value is greater than max limit" do
+      errors = {"$.a"=>["value must be minimum 3 characters, maximum 5 characters"]}
+      expected_policy_behavior(policy: :length, policy_args: [{min: 3, max: 5}], input: {a: "test_test"}, output: {a: "test_test"}, errors: errors)
+    end
+  end
+end