parametric 0.0.1 → 0.2.10

data/spec/schema_spec.rb

@@ -0,0 +1,289 @@
+require 'spec_helper'
+
+describe Parametric::Schema do
+  before do
+    Parametric.policy :flexible_bool do
+      coerce do |v, k, c|
+        case v
+        when '1', 'true', 'TRUE', true
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+
+  subject do
+    described_class.new do
+      field(:title).policy(:string).present
+      field(:price).policy(:integer).meta(label: "A price")
+      field(:status).policy(:string).options(['visible', 'hidden'])
+      field(:tags).policy(:split).policy(:array)
+      field(:description).policy(:string)
+      field(:variants).policy(:array).schema do
+        field(:name).policy(:string).present
+        field(:sku)
+        field(:stock).policy(:integer).default(1)
+        field(:available_if_no_stock).policy(:boolean).policy(:flexible_bool).default(false)
+      end
+    end
+  end
+
+  describe "#structure" do
+    it "represents data structure and meta data" do
+      sc = subject.structure
+      expect(sc[:title][:present]).to be true
+      expect(sc[:title][:type]).to eq :string
+      expect(sc[:price][:type]).to eq :integer
+      expect(sc[:price][:label]).to eq "A price"
+      expect(sc[:variants][:type]).to eq :array
+      sc[:variants][:structure].tap do |sc|
+        expect(sc[:name][:type]).to eq :string
+        expect(sc[:name][:present]).to be true
+        expect(sc[:stock][:default]).to eq 1
+      end
+    end
+  end
+
+  def resolve(schema, payload, &block)
+    yield schema.resolve(payload)
+  end
+
+  def test_schema(schema, payload, result)
+    resolve(schema, payload) do |results|
+      expect(results.output).to eq result
+    end
+  end
+
+  it 'works' do
+    test_schema(subject, {
+      title: 'iPhone 6 Plus',
+      price: '100.0',
+      status: 'visible',
+      tags: 'tag1, tag2',
+      description: 'A description',
+      variants: [{name: 'v1', sku: 'ABC', stock: '10', available_if_no_stock: true}]
+    },
+    {
+      title: 'iPhone 6 Plus',
+      price: 100,
+      status: 'visible',
+      tags: ['tag1', 'tag2'],
+      description: 'A description',
+      variants: [{name: 'v1', sku: 'ABC', stock: 10, available_if_no_stock: true}]
+    })
+
+    test_schema(subject, {
+      title: 'iPhone 6 Plus',
+      variants: [{name: 'v1', available_if_no_stock: '1'}]
+    },
+    {
+      title: 'iPhone 6 Plus',
+      variants: [{name: 'v1', stock: 1, available_if_no_stock: true}]
+    })
+
+    resolve(subject, {}) do |results|
+      expect(results.valid?).to be false
+      expect(results.errors['$.title']).not_to be_nil
+      expect(results.errors['$.variants']).to be_nil
+      expect(results.errors['$.status']).to be_nil
+    end
+
+    resolve(subject, {title: 'Foobar', variants: [{name: 'v1'}, {sku: '345'}]}) do |results|
+      expect(results.valid?).to be false
+      expect(results.errors['$.variants[1].name']).not_to be_nil
+    end
+  end
+
+  it "ignores nil fields if using :declared policy" do
+    schema = described_class.new do
+      field(:id).type(:integer)
+      field(:title).declared.type(:string)
+    end
+
+    resolve(schema, {id: 123}) do |results|
+      expect(results.output.keys).to eq [:id]
+    end
+  end
+
+  describe "#policy" do
+    it "applies policy to all fields" do
+      subject.policy(:declared)
+
+      resolve(subject, {}) do |results|
+        expect(results.valid?).to be true
+        expect(results.errors.keys).to be_empty
+      end
+    end
+
+    it "replaces previous policies" do
+      subject.policy(:declared)
+      subject.policy(:present)
+
+      resolve(subject, {title: "hello"}) do |results|
+        expect(results.valid?).to be false
+        expect(results.errors.keys).to match_array(%w(
+          $.price
+          $.status
+          $.tags
+          $.description
+          $.variants
+        ))
+      end
+    end
+
+    it "applies :noop policy to all fields" do
+      subject.policy(:noop)
+
+      resolve(subject, {}) do |results|
+        expect(results.valid?).to be false
+        expect(results.errors['$.title']).not_to be_nil
+      end
+    end
+  end
+
+  describe "#merge" do
+    context "no options" do
+      let!(:schema1) {
+        described_class.new do
+          field(:title).policy(:string).present
+          field(:price).policy(:integer)
+        end
+      }
+
+      let!(:schema2) {
+        described_class.new do
+          field(:price).policy(:string)
+          field(:description).policy(:string)
+        end
+      }
+
+      it "returns a new schema adding new fields and updating existing ones" do
+        new_schema = schema1.merge(schema2)
+        expect(new_schema.fields.keys).to match_array([:title, :price, :description])
+
+        # did not mutate original
+        expect(schema1.fields[:price].meta_data[:type]).to eq :integer
+
+        expect(new_schema.fields[:title].meta_data[:type]).to eq :string
+        expect(new_schema.fields[:price].meta_data[:type]).to eq :string
+      end
+
+      it 'can merge from a block' do
+        new_schema = schema1.merge do
+          field(:price).policy(:string)
+          field(:description).policy(:string)
+        end
+
+        expect(schema1.fields[:price].meta_data[:type]).to eq :integer
+        expect(new_schema.fields[:title].meta_data[:type]).to eq :string
+        expect(new_schema.fields[:price].meta_data[:type]).to eq :string
+      end
+    end
+
+    context "with options" do
+      let!(:schema1) {
+        described_class.new(price_type: :integer, label: "Foo") do |opts|
+          field(:title).policy(:string).present
+          field(:price).policy(opts[:price_type]).meta(label: opts[:label])
+        end
+      }
+
+      let!(:schema2) {
+        described_class.new(price_type: :string) do
+          field(:description).policy(:string)
+        end
+      }
+
+      it "inherits options" do
+        new_schema = schema1.merge(schema2)
+        expect(new_schema.fields[:price].meta_data[:type]).to eq :string
+        expect(new_schema.fields[:price].meta_data[:label]).to eq "Foo"
+      end
+
+      it "re-applies blocks with new options" do
+        new_schema = schema1.merge(schema2)
+        expect(new_schema.fields.keys).to match_array([:title, :price, :description])
+
+        # did not mutate original
+        expect(schema1.fields[:price].meta_data[:type]).to eq :integer
+
+        expect(new_schema.fields[:title].meta_data[:type]).to eq :string
+        expect(new_schema.fields[:price].meta_data[:type]).to eq :string
+      end
+    end
+  end
+
+  describe "#clone" do
+    let!(:schema1) {
+      described_class.new do |opts|
+        field(:id).present
+        field(:title).policy(:string).present
+        field(:price)
+      end
+    }
+
+    it "returns a copy that can be further manipulated" do
+      schema2 = schema1.clone.policy(:declared).ignore(:id)
+      expect(schema1.fields.keys).to match_array([:id, :title, :price])
+      expect(schema2.fields.keys).to match_array([:title, :price])
+
+      results1 = schema1.resolve(id: "abc", price: 100)
+      expect(results1.errors.keys).to eq ["$.title"]
+
+      results2 = schema2.resolve(id: "abc", price: 100)
+      expect(results2.errors.keys).to eq []
+    end
+  end
+
+  context 'yielding schema to definition, to preserve outer context' do
+    it 'yields schema instance and options to definition block, can access outer context' do
+      schema1 = described_class.new do
+        field(:name).type(:string)
+      end
+      schema2 = described_class.new do |sc, _opts|
+        sc.field(:user).schema schema1
+      end
+
+      out = schema2.resolve(user: { name: 'Joe' }).output
+      expect(out[:user][:name]).to eq 'Joe'
+    end
+  end
+
+  describe "#ignore" do
+    it "ignores fields" do
+      s1 = described_class.new.ignore(:title, :status) do
+        field(:status)
+        field(:title).policy(:string).present
+        field(:price).policy(:integer)
+      end
+
+      output = s1.resolve(status: "draft", title: "foo", price: "100").output
+      expect(output).to eq({price: 100})
+    end
+
+    it "ignores when merging" do
+      s1 = described_class.new do
+        field(:status)
+        field(:title).policy(:string).present
+      end
+
+      s1 = described_class.new.ignore(:title, :status) do
+        field(:price).policy(:integer)
+      end
+
+      output = s1.resolve(title: "foo", status: "draft", price: "100").output
+      expect(output).to eq({price: 100})
+    end
+
+    it "returns self so it can be chained" do
+      s1 = described_class.new do
+        field(:status)
+        field(:title).policy(:string).present
+      end
+
+      expect(s1.ignore(:status)).to eq s1
+    end
+  end
+end

data/spec/schema_walk_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Schema#walk' do
+  let(:schema) do
+    Parametric::Schema.new do
+      field(:title).meta(example: 'a title', label: 'custom title')
+      field(:tags).policy(:array).meta(example: ['tag1', 'tag2'], label: 'comma-separated tags')
+      field(:friends).policy(:array).schema do
+        field(:name).meta(example: 'a friend', label: 'friend full name')
+        field(:age).meta(example: 34, label: 'age')
+      end
+    end
+  end
+
+  it "recursively walks the schema and collects meta data" do
+    results = schema.walk(:label)
+    expect(results.output).to eq({
+      title: 'custom title',
+      tags: 'comma-separated tags',
+      friends: [
+        {
+          name: 'friend full name',
+          age: 'age'
+        }
+      ]
+    })
+  end
+
+  it "works with blocks" do
+    results = schema.walk{|field| field.meta_data[:example]}
+    expect(results.output).to eq({
+      title: 'a title',
+      tags: ['tag1', 'tag2'],
+      friends: [
+        {
+          name: 'a friend',
+          age: 34
+        }
+      ]
+    })
+  end
+end

data/spec/spec_helper.rb

@@ -1,2 +1,3 @@
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'byebug'
 require 'parametric'

data/spec/struct_spec.rb

@@ -0,0 +1,324 @@
+require 'spec_helper'
+require 'parametric/struct'
+
+describe Parametric::Struct do
+  it "works" do
+    friend_class = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:name).type(:string).present
+        field(:age).type(:integer)
+      end
+    end
+
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:friends).type(:array).default([]).schema friend_class
+      end
+    end
+
+    new_instance = klass.new
+    expect(new_instance.title).to eq ''
+    expect(new_instance.friends).to eq []
+    expect(new_instance.valid?).to be false
+    expect(new_instance.errors['$.title']).not_to be_nil
+
+    instance = klass.new({
+      title: 'foo',
+      friends: [
+        {name: 'Ismael', age: 40},
+        {name: 'Joe', age: 39},
+      ]
+    })
+
+    expect(instance.title).to eq 'foo'
+    expect(instance.friends.size).to eq 2
+    expect(instance.friends.first.name).to eq 'Ismael'
+    expect(instance.friends.first).to be_a friend_class
+
+    invalid_instance = klass.new({
+      friends: [
+        {name: 'Ismael', age: 40},
+        {age: 39},
+      ]
+    })
+
+    expect(invalid_instance.valid?).to be false
+    expect(invalid_instance.errors['$.title']).not_to be_nil
+    expect(invalid_instance.errors['$.friends[1].name']).not_to be_nil
+    expect(invalid_instance.friends[1].errors['$.name']).not_to be_nil
+  end
+
+  it "is inmutable by default" do
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:friends).type(:array).default([])
+        field(:friend).type(:object)
+      end
+    end
+
+    instance = klass.new
+    expect {
+      instance.title = "foo"
+    }.to raise_error NoMethodError
+
+    expect {
+      instance.friends << 1
+    }.to raise_error RuntimeError
+  end
+
+  it "works with anonymous nested schemas" do
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:friends).type(:array).schema do
+          field(:age).type(:integer)
+        end
+      end
+    end
+
+    instance = klass.new({
+      title: 'foo',
+      friends: [
+        {age: 10},
+        {age: 39},
+      ]
+    })
+
+    expect(instance.title).to eq 'foo'
+    expect(instance.friends.size).to eq 2
+    expect(instance.friends.first.age).to eq 10
+  end
+
+  it 'wraps nested schemas in custom class' do
+    klass = Class.new do
+      include Parametric::Struct
+
+      def self.parametric_build_class_for_child(key, child_schema)
+        Class.new do
+          include Parametric::Struct
+          schema child_schema
+          def salutation
+            "my age is #{age}"
+          end
+        end
+      end
+
+      schema do
+        field(:name).type(:string).present
+        field(:friends).type(:array).schema do
+          field(:age).type(:integer)
+        end
+      end
+    end
+
+    user = klass.new(name: 'Ismael', friends: [{age: 43}])
+    expect(user.friends.first.salutation).to eq 'my age is 43'
+  end
+
+  it "wraps regular schemas in structs" do
+    friend_schema = Parametric::Schema.new do
+      field(:name)
+    end
+
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:friends).type(:array).schema friend_schema
+      end
+    end
+
+    instance = klass.new({
+      title: 'foo',
+      friends: [{name: 'Ismael'}]
+    })
+
+    expect(instance.friends.first.name).to eq 'Ismael'
+  end
+
+  it "#to_h" do
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:friends).type(:array).schema do
+          field(:name).type(:string)
+          field(:age).type(:integer).default(20)
+        end
+      end
+    end
+
+    instance = klass.new({
+      title: 'foo',
+      friends: [
+        {name: 'Jane'},
+        {name: 'Joe', age: '39'},
+      ]
+    })
+
+    expect(instance.to_h).to eq({
+      title: 'foo',
+      friends: [
+        {name: 'Jane', age: 20},
+        {name: 'Joe', age: 39},
+      ]
+    })
+
+    new_instance = klass.new(instance.to_h)
+    expect(new_instance.title).to eq 'foo'
+
+    # it returns a copy so we can't break things!
+    data = new_instance.to_h
+    data[:title] = 'nope'
+    expect(new_instance.to_h[:title]).to eq 'foo'
+  end
+
+  it "works with inheritance" do
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:friends).type(:array).schema do
+          field(:name).type(:string)
+          field(:age).type(:integer).default(20)
+        end
+      end
+    end
+
+    subclass = Class.new(klass) do
+      schema do
+        field(:email)
+      end
+    end
+
+    instance = subclass.new(
+      title: 'foo',
+      email: 'email@me.com',
+      friends: [
+        {name: 'Jane', age: 20},
+        {name: 'Joe', age: 39},
+      ]
+    )
+
+    expect(instance.title).to eq 'foo'
+    expect(instance.email).to eq 'email@me.com'
+    expect(instance.friends.size).to eq 2
+  end
+
+  it "implements deep struct equality" do
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:friends).type(:array).schema do
+          field(:age).type(:integer)
+        end
+      end
+    end
+
+    s1 = klass.new({
+      title: 'foo',
+      friends: [
+        {age: 10},
+        {age: 39},
+      ]
+    })
+
+
+    s2 = klass.new({
+      title: 'foo',
+      friends: [
+        {age: 10},
+        {age: 39},
+      ]
+    })
+
+    s3 = klass.new({
+      title: 'foo',
+      friends: [
+        {age: 11},
+        {age: 39},
+      ]
+    })
+
+    s4 = klass.new({
+      title: 'bar',
+      friends: [
+        {age: 10},
+        {age: 39},
+      ]
+    })
+
+    expect(s1 == s2).to be true
+    expect(s1 == s3).to be false
+    expect(s1 == s4).to be false
+  end
+
+  it "#merge returns a new instance" do
+    klass = Class.new do
+      include Parametric::Struct
+
+      schema do
+        field(:title).type(:string).present
+        field(:desc)
+        field(:friends).type(:array).schema do
+          field(:name).type(:string)
+        end
+      end
+    end
+
+    original = klass.new(
+      title: 'foo',
+      desc: 'no change',
+      friends: [{name: 'joe'}]
+    )
+
+    copy = original.merge(
+      title: 'bar',
+      friends: [{name: 'jane'}]
+    )
+
+    expect(original.title).to eq 'foo'
+    expect(original.desc).to eq 'no change'
+    expect(original.friends.first.name).to eq 'joe'
+
+    expect(copy.title).to eq 'bar'
+    expect(copy.desc).to eq 'no change'
+    expect(copy.friends.first.name).to eq 'jane'
+  end
+
+  describe '.new!' do
+    it 'raises a useful exception if invalid data' do
+      klass = Class.new do
+        include Parametric::Struct
+
+        schema do
+          field(:title).type(:string).present
+        end
+      end
+
+      begin
+        klass.new!(title: '')
+      rescue Parametric::InvalidStructError => e
+        expect(e.errors['$.title']).not_to be nil
+      end
+
+      valid = klass.new!(title: 'foo')
+      expect(valid.title).to eq 'foo'
+    end
+  end
+end