paradocs 1.0.22

data/spec/schema_spec.rb

@@ -0,0 +1,299 @@
+require 'spec_helper'
+
+describe Paradocs::Schema do
+  before do
+    Paradocs.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 "order input by schema fields' keys order" do
+    payload = {
+      tags: 'tag',
+      status: 'visible',
+      extra_field: "extra",
+      price: "100",
+      title: "title",
+      variants: [
+        {
+          stock: '10',
+          available_if_no_stock: true,
+          extra_field: "extra",
+          name: 'v1',
+          sku: 'ABC'
+        }
+      ]
+    }
+
+    output = subject.resolve(payload).output
+    expect(output).to eq({
+      title: "title",
+      price: 100,
+      status: "visible",
+      tags: ["tag"],
+      variants: [
+        {
+          name: "v1",
+          sku: "ABC",
+          stock: 10,
+          available_if_no_stock: true
+        }
+      ]
+    })
+  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
+    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
+
+  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_structures_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe "Schema structures generation" do
+  Paradocs.policy :policy_with_error do
+    register_error ArgumentError
+
+    validate do |*|
+      raise ArgumentError
+    end
+  end
+
+  Paradocs.policy :policy_with_silent_error do
+    register_silent_error RuntimeError
+  end
+
+  let(:schema) do
+    Paradocs::Schema.new do
+      subschema(:highest_level) { field(:test).present } # no mutations on this level -> subschema ignored
+
+      field(:data).type(:object).present.schema do
+        field(:id).type(:integer).present.policy(:policy_with_error)
+        field(:name).type(:string).meta(label: "very important staff")
+        field(:role).type(:string).declared.options(["admin", "user"]).default("user").mutates_schema! do |*|
+          :test_subschema
+        end
+        field(:extra).type(:array).required.schema do
+          field(:extra).declared.default(false).policy(:policy_with_silent_error)
+        end
+
+        mutation_by!(:name) { :subschema }
+
+        subschema(:subschema) do
+          field(:test_field).present
+        end
+        subschema(:test_subschema) do
+          field(:test1).present
+        end
+      end
+    end
+  end
+
+
+  it "generates nested data for documentation generation" do
+    result = schema.structure { |k, meta| meta[:block_works] = true unless meta[:present] }
+    expect(result[:_subschemes]).to eq({})
+    expect(result[:_errors]).to eq([ArgumentError])
+    data_structure = result[:data].delete(:structure)
+    expect(result[:data]).to eq({
+      type: :object,
+      required: true,
+      present: true,
+      json_path: "$.data",
+      nested_name: "data",
+    })
+    expect(data_structure[:_subschemes]).to eq({
+      test_subschema: {
+        _errors: [],
+        _subschemes: {},
+        test1: {required: true, present: true, json_path: "$.data.test1", nested_name: "data.test1"}
+      },
+      subschema: {
+        _errors: [],
+        _subschemes: {},
+        test_field: {required: true, present: true, json_path: "$.data.test_field", nested_name: "data.test_field"}
+      }
+    })
+    expect(data_structure[:id]).to eq({
+      type: :integer,
+      required: true,
+      present: true,
+      policy_with_error: {errors: [ArgumentError]},
+      json_path: "$.data.id",
+      nested_name: "data.id"
+    })
+    expect(data_structure[:name]).to eq({
+      type: :string,
+      label: "very important staff",
+      mutates_schema: true,
+      block_works: true,
+      json_path: "$.data.name",
+      nested_name: "data.name"
+    })
+    expect(data_structure[:role]).to eq({
+      type: :string,
+      options: ["admin", "user"],
+      default: "user",
+      mutates_schema: true,
+      block_works: true,
+      json_path: "$.data.role",
+      nested_name: "data.role"
+    })
+    expect(data_structure[:extra]).to eq({
+      type: :array,
+      required: true,
+      block_works: true,
+      json_path: "$.data.extra[]",
+      nested_name: "data.extra",
+      structure: {
+        extra: {
+          default: false,
+          block_works: true,
+          json_path: "$.data.extra[].extra",
+          nested_name: "data.extra.extra",
+          policy_with_silent_error: {errors: []}
+        },
+        _subschemes: {}
+      }
+    })
+  end
+
+  it "generates flatten data for documentation generation" do
+    expect(schema.flatten_structure { |key, meta| meta[:block_works] = true if key.split(".").size == 1 }).to eq({
+      "data" => {
+        type: :object,
+        required: true,
+        present: true,
+        block_works: true,
+        json_path: "$.data"
+      },
+      "data.extra" => {
+        type: :array,
+        required: true,
+        json_path: "$.data.extra[]"
+      },
+      "data.extra.extra" => {
+        default: false,
+        json_path: "$.data.extra[].extra",
+        policy_with_silent_error: {errors: []}
+      },
+      "data.id" => {
+        type: :integer,
+        required: true,
+        present: true,
+        json_path: "$.data.id",
+        policy_with_error: {errors: [ArgumentError]}
+      },
+      "data.name" => {
+        type: :string,
+        json_path: "$.data.name",
+        label: "very important staff",
+        mutates_schema: true
+      },
+      "data.role" => {
+        type: :string,
+        options: ["admin", "user"],
+        default: "user",
+        json_path: "$.data.role",
+        mutates_schema: true
+      },
+      _errors: [ArgumentError],
+      _subschemes: {
+        test_subschema: {
+          _errors: [],
+          _subschemes: {},
+          "data.test1"=>{
+            required: true,
+            present: true,
+            json_path: "$.data.test1"
+          }
+        },
+        subschema: {
+          _errors: [],
+          _subschemes: {},
+          "data.test_field" => {required: true, present: true, json_path: "$.data.test_field"}
+        }
+      }
+    })
+  end
+end

data/spec/schema_walk_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Schema#walk' do
+  let(:schema) do
+    Paradocs::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

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'pry'
+require 'paradocs'
+require_relative 'helpers'