haveapi 0.4.2 → 0.5.0

data/spec/params_spec.rb

@@ -0,0 +1,190 @@
+describe HaveAPI::Params do
+  class MyResource < HaveAPI::Resource
+    params(:all) do
+      string :res_param1
+      string :res_param2
+    end
+
+    class Index < HaveAPI::Actions::Default::Index
+
+    end
+    
+    class Show < HaveAPI::Actions::Default::Show
+      output do
+        string :not_label
+      end
+    end
+
+    class Create < HaveAPI::Actions::Default::Create
+
+    end
+  end
+  
+  it 'executes all blocks' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { string :param1 }
+    p.add_block Proc.new { string :param2 }
+    p.add_block Proc.new { string :param3 }
+    p.exec
+    expect(p.params.map { |p| p.name }).to contain_exactly(*%i(param1 param2 param3))
+  end
+
+  it 'returns deduced singular namespace' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    expect(p.namespace).to eq(:my_resource)
+  end
+
+  it 'returns deduced plural namespace' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.layout = :object_list
+    expect(p.namespace).to eq(:my_resources)
+  end
+
+  it 'returns set namespace' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.namespace = :custom_ns
+    expect(p.namespace).to eq(:custom_ns)
+  end
+
+  it 'uses params from parent resource' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { use :all }
+    p.exec
+    expect(p.params.map { |p| p.name }).to contain_exactly(*%i(res_param1 res_param2))
+  end
+
+  it 'has param requires' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { requires :p_required }
+    p.exec
+    expect(p.params.first.required?).to be true
+  end
+
+  it 'has param optional' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { optional :p_optional }
+    p.exec
+    expect(p.params.first.required?).to be false
+  end
+
+  it 'has param string' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { string :p_string }
+    p.exec
+    expect(p.params.first.type).to eq(String)
+  end
+
+  it 'has param text' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { text :p_text }
+    p.exec
+    expect(p.params.first.type).to eq(Text)
+  end
+
+  %i(id integer foreign_key).each do |type|
+    it "has param #{type}" do
+      p = HaveAPI::Params.new(:input, MyResource::Index)
+      p.add_block Proc.new { send(type, :"p_#{type}") }
+      p.exec
+      expect(p.params.first.type).to eq(Integer)
+    end
+  end
+
+  it 'has param float' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { float :p_float }
+    p.exec
+    expect(p.params.first.type).to eq(Float)
+  end
+
+  it 'has param bool' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { bool :p_bool }
+    p.exec
+    expect(p.params.first.type).to eq(Boolean)
+  end
+
+  it 'has param datetime' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { datetime :p_datetime }
+    p.exec
+    expect(p.params.first.type).to eq(Datetime)
+  end
+
+  it 'has param param' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { param :p_param, type: Integer }
+    p.exec
+    expect(p.params.first.type).to eq(Integer)
+  end
+
+  it 'has param resource' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block Proc.new { resource MyResource }
+    p.exec
+    expect(p.params.first).to be_an_instance_of(HaveAPI::Parameters::Resource)
+  end
+
+  it 'patches params' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block(Proc.new do
+      string :param1, label: 'Param 1'
+      string :param2, label: 'Param 2', desc: 'Implicit description'
+    end)
+    p.exec
+    p.patch(:param1, label: 'Better param 1')
+    p.patch(:param2, desc: 'Better description')
+    expect(p.params.first.label).to eq('Better param 1')
+    expect(p.params.second.desc).to eq('Better description')
+  end
+
+  it 'validates upon build' do
+    p = HaveAPI::Params.new(:output, MyResource::Index)
+    p.add_block Proc.new { resource MyResource }
+    p.exec
+    expect(p.params.first).to be_an_instance_of(HaveAPI::Parameters::Resource)
+    expect { p.validate_build }.to raise_error(RuntimeError)
+  end
+
+  it 'accepts valid input layout' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block(Proc.new do
+      string :param1, required: true
+      string :param2
+    end)
+    p.exec
+
+    expect do
+      p.check_layout({
+          my_resource: {}
+      })
+    end.not_to raise_error
+  end
+
+  it 'rejects invalid input layout' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block(Proc.new do
+      string :param1, required: true
+      string :param2
+    end)
+    p.exec
+
+    expect do
+      p.check_layout({
+          something_bad: {}
+      })
+    end.to raise_error(HaveAPI::ValidationError)
+  end
+
+  it 'indexes parameters by name' do
+    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p.add_block(Proc.new do
+      string :param1
+      string :param2
+    end)
+    p.exec
+
+    expect(p[:param1]).to eq(p.params.first)
+    expect(p[:param2]).to eq(p.params.second)
+  end
+end

data/spec/resource_spec.rb

@@ -0,0 +1,63 @@
+describe HaveAPI::Resource do
+  class PluralTest < HaveAPI::Resource
+    
+  end
+
+  class SingularTest < HaveAPI::Resource
+    singular true
+  end
+
+  it 'has correct obj_type' do
+    expect(PluralTest.obj_type).to eq(:resource)
+    expect(SingularTest.obj_type).to eq(:resource)
+  end
+
+  it 'has plural name' do
+    expect(PluralTest.resource_name).to eq('plural_tests')
+  end
+
+  it 'has singular name' do
+    expect(SingularTest.resource_name).to eq('singular_test')
+  end
+
+  class ComplexTest < HaveAPI::Resource
+    class Index < HaveAPI::Actions::Default::Index ; end
+    class Show < HaveAPI::Actions::Default::Show ; end
+    class Create < HaveAPI::Actions::Default::Create ; end
+    class Dummy ; end
+
+    class SubResource < HaveAPI::Resource
+      class Index < HaveAPI::Actions::Default::Index ; end
+      class Show < HaveAPI::Actions::Default::Show ; end
+    end
+  end
+
+  it 'iterates over actions' do
+    actions = []
+
+    ComplexTest.actions do |a|
+      actions << a
+    end
+
+    expect(actions).to contain_exactly(
+      ComplexTest::Index,
+      ComplexTest::Show,
+      ComplexTest::Create
+    )
+  end
+
+  it 'iterates over resources' do
+    resources = []
+
+    ComplexTest.resources do |r|
+      resources << r
+    end
+
+    expect(resources).to contain_exactly(ComplexTest::SubResource)
+  end
+
+  it 'defines and returns resource-wide params' do
+    ComplexTest.params(:name) { 'executed' }
+    expect(ComplexTest.params(:name).call).to eq('executed')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'require_all'
+require_relative '../lib/haveapi'
+require_rel '../lib/haveapi/spec/*.rb'
+
+module HaveAPI
+  module Spec
+    module API
+
+    end
+  end
+end
+
+require_rel 'api'
+
+# Configure specs
+RSpec.configure do |config|
+  config.order = 'random'
+
+  config.extend HaveAPI::Spec::ApiBuilder
+  config.include HaveAPI::Spec::SpecMethods
+end

data/spec/validators/acceptance_spec.rb

@@ -0,0 +1,29 @@
+describe HaveAPI::Validators::Acceptance do
+  shared_examples(:all) do
+    it 'accepts correct value' do
+      expect(@v.valid?('foo')).to be true
+    end
+
+    it "rejects incorrect value" do
+      expect(@v.valid?('bar')).to be false
+    end
+  end 
+
+  context 'short form' do
+    before(:each) do
+      @v = HaveAPI::Validators::Acceptance.new(:accept, 'foo')
+    end
+
+    include_examples :all
+  end
+
+  context 'full form' do
+    before(:each) do
+      @v = HaveAPI::Validators::Acceptance.new(:accept, {
+          value: 'foo'
+      })
+    end
+
+    include_examples :all
+  end
+end

data/spec/validators/confirmation_spec.rb

@@ -0,0 +1,46 @@
+describe HaveAPI::Validators::Confirmation do
+  shared_examples(:all) do
+    it 'accepts the same value' do
+      expect(@v.validate('foo', {other_param: 'foo'})).to be true
+    end
+
+    it "rejects a different value" do
+      expect(@v.validate('bar', {other_param: 'foo'})).to be false
+    end
+  end 
+
+  context 'short form' do
+    before(:each) do
+      @v = HaveAPI::Validators::Confirmation.new(:confirm, :other_param)
+    end
+
+    include_examples :all
+  end
+
+  context 'full form' do
+    before(:each) do
+      @v = HaveAPI::Validators::Confirmation.new(:confirm, {
+          param: :other_param
+      })
+    end
+
+    include_examples :all
+  end
+
+  context 'with equal = false' do
+    before(:each) do
+      @v = HaveAPI::Validators::Confirmation.new(:confirm, {
+          param: :other_param,
+          equal: false
+      })
+    end
+
+    it 'rejects the same value' do
+      expect(@v.validate('foo', {other_param: 'foo'})).to be false
+    end
+
+    it 'accepts a different value' do
+      expect(@v.validate('bar', {other_param: 'foo'})).to be true
+    end
+  end
+end

data/spec/validators/custom_spec.rb

@@ -0,0 +1,6 @@
+describe HaveAPI::Validators::Custom do
+  it 'always passes' do
+    v = HaveAPI::Validators::Custom.new(:validate, 'some custom validation')
+    expect(v.valid?('WHATEVER')).to be true
+  end
+end

data/spec/validators/exclusion_spec.rb

@@ -0,0 +1,32 @@
+describe HaveAPI::Validators::Exclusion do
+  shared_examples(:all) do
+    it 'rejects a listed value' do
+      expect(@v.valid?('one')).to be false
+      expect(@v.valid?('two')).to be false
+      expect(@v.valid?('three')).to be false
+    end
+
+    it "accepts an unlisted value" do
+      expect(@v.valid?('zero')).to be true
+      expect(@v.valid?('four')).to be true
+    end
+  end 
+
+  context 'short form' do
+    before(:each) do
+      @v = HaveAPI::Validators::Exclusion.new(:exclude, %w(one two three))
+    end
+
+    include_examples :all
+  end
+
+  context 'full form' do
+    before(:each) do
+      @v = HaveAPI::Validators::Exclusion.new(:exclude, {
+          values: %w(one two three)
+      })
+    end
+
+    include_examples :all
+  end
+end

data/spec/validators/format_spec.rb

@@ -0,0 +1,54 @@
+describe HaveAPI::Validators::Format do
+  shared_examples(:all) do
+    it 'accepts a value that matches the regexp' do
+      expect(@v.valid?('aab')).to be true
+      expect(@v.valid?('aacacb')).to be true
+    end
+
+    it "rejects a value that does not match the regexp" do
+      expect(@v.valid?('aacac')).to be false
+      expect(@v.valid?('bacacb')).to be false
+      expect(@v.valid?('b')).to be false
+    end
+  end 
+
+  context 'with match = true' do
+    context 'short form' do
+      before(:each) do
+        @v = HaveAPI::Validators::Format.new(:format, /^a[^b]+b$/)
+      end
+
+      include_examples :all
+    end
+
+    context 'full form' do
+      before(:each) do
+        @v = HaveAPI::Validators::Format.new(:format, {
+            rx: /^a[^b]+b$/
+        })
+      end
+
+      include_examples :all
+    end
+  end
+
+  context 'with match = false' do
+    before(:each) do
+      @v = HaveAPI::Validators::Format.new(:format, {
+            rx: /^a[^b]+b$/,
+            match: false
+      })
+    end
+    
+    it 'rejects a value that matches the regexp' do
+      expect(@v.valid?('aab')).to be false
+      expect(@v.valid?('aacacb')).to be false
+    end
+
+    it "accepts a value if it does not match the regexp" do
+      expect(@v.valid?('aacac')).to be true
+      expect(@v.valid?('bacacb')).to be true
+      expect(@v.valid?('b')).to be true
+    end
+  end
+end

data/spec/validators/inclusion_spec.rb

@@ -0,0 +1,43 @@
+describe HaveAPI::Validators::Inclusion do
+  shared_examples(:all) do
+    it 'accepts a listed value' do
+      expect(@v.valid?('one')).to be true
+      expect(@v.valid?('two')).to be true
+      expect(@v.valid?('three')).to be true
+    end
+
+    it "rejects an unlisted value" do
+      expect(@v.valid?('zero')).to be false
+      expect(@v.valid?('four')).to be false
+    end
+  end 
+
+  [
+      %w(one two three),
+      {
+          one: 'Fancy one',
+          two: 'Fancy two',
+          three: 'Fancy three'
+      }
+  ].each do |include|
+    context "with include as a '#{include.class}'" do
+      context 'short form' do
+        before(:each) do
+          @v = HaveAPI::Validators::Inclusion.new(:include, %w(one two three))
+        end
+
+        include_examples :all
+      end
+
+      context 'full form' do
+        before(:each) do
+          @v = HaveAPI::Validators::Inclusion.new(:include, {
+              values: %w(one two three)
+          })
+        end
+
+        include_examples :all
+      end
+    end
+  end
+end

data/spec/validators/length_spec.rb

@@ -0,0 +1,45 @@
+describe HaveAPI::Validators::Length do
+  it 'does not allow to mix min/max with equals' do
+    expect do
+      HaveAPI::Validators::Length.new(:length, {min: 33, equals: 42})
+    end.to raise_error(RuntimeError)
+  end
+  
+  it 'requires one of min, max or equals' do
+    expect do
+      HaveAPI::Validators::Length.new(:length, {})
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'checks minimum' do
+    v = HaveAPI::Validators::Length.new(:length, {min: 2})
+    expect(v.valid?('a'*1)).to be false
+    expect(v.valid?('a'*2)).to be true
+    expect(v.valid?('a'*33)).to be true
+  end
+  
+  it 'checks maximum' do
+    v = HaveAPI::Validators::Length.new(:length, {max: 5})
+    expect(v.valid?('a'*4)).to be true
+    expect(v.valid?('a'*5)).to be true
+    expect(v.valid?('a'*6)).to be false
+    expect(v.valid?('a'*11)).to be false
+  end
+
+  it 'checks range' do
+    v = HaveAPI::Validators::Length.new(:length, {min: 3, max: 6})
+    expect(v.valid?('a'*2)).to be false
+    expect(v.valid?('a'*3)).to be true
+    expect(v.valid?('a'*4)).to be true
+    expect(v.valid?('a'*5)).to be true
+    expect(v.valid?('a'*6)).to be true
+    expect(v.valid?('a'*7)).to be false
+  end
+
+  it 'check a specific length' do
+    v = HaveAPI::Validators::Length.new(:length, {equals: 4})
+    expect(v.valid?('a'*2)).to be false
+    expect(v.valid?('a'*4)).to be true
+    expect(v.valid?('a'*5)).to be false
+  end
+end

data/spec/validators/numericality_spec.rb

@@ -0,0 +1,70 @@
+describe HaveAPI::Validators::Numericality do
+  it 'cannot be both even and odd at the same time' do
+    expect do
+      HaveAPI::Validators::Numericality.new(:number, {odd: true, even: true})
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'checks minimum' do
+    v = HaveAPI::Validators::Numericality.new(:number, {min: 5})
+    expect(v.valid?(4)).to be false
+    expect(v.valid?(5)).to be true
+    expect(v.valid?(6)).to be true
+  end
+  
+  it 'checks maximum' do
+    v = HaveAPI::Validators::Numericality.new(:number, {max: 50})
+    expect(v.valid?(100)).to be false
+    expect(v.valid?(51)).to be false
+    expect(v.valid?(50)).to be true
+    expect(v.valid?(40)).to be true
+  end
+
+  it 'checks that x % y = 0' do
+    v = HaveAPI::Validators::Numericality.new(:number, {mod: 2})
+    expect(v.valid?(3)).to be false
+    expect(v.valid?(15)).to be false
+    expect(v.valid?(0)).to be true
+    expect(v.valid?(2)).to be true
+    expect(v.valid?(48)).to be true
+  end
+  
+  it 'checks that the number is in a step' do
+    v = HaveAPI::Validators::Numericality.new(:number, {step: 3})
+    expect(v.valid?(4)).to be false
+    expect(v.valid?(14)).to be false
+    expect(v.valid?(0)).to be true
+    expect(v.valid?(3)).to be true
+    expect(v.valid?(6)).to be true
+    expect(v.valid?(9)).to be true
+  end
+
+  it 'checks that the number is in a step with a minimum' do
+    v = HaveAPI::Validators::Numericality.new(:number, {min: 5, step: 3})
+    expect(v.valid?(0)).to be false
+    expect(v.valid?(3)).to be false
+    expect(v.valid?(4)).to be false
+    expect(v.valid?(12)).to be false
+    expect(v.valid?(15)).to be false
+    expect(v.valid?(5)).to be true
+    expect(v.valid?(8)).to be true
+    expect(v.valid?(11)).to be true
+    expect(v.valid?(14)).to be true
+  end
+
+  it 'checks that the number is even' do
+    v = HaveAPI::Validators::Numericality.new(:number, {even: true})
+    expect(v.valid?(1)).to be false
+    expect(v.valid?(3)).to be false
+    expect(v.valid?(0)).to be true
+    expect(v.valid?(2)).to be true
+  end
+  
+  it 'checks that the number is odd' do
+    v = HaveAPI::Validators::Numericality.new(:number, {odd: true})
+    expect(v.valid?(1)).to be true
+    expect(v.valid?(3)).to be true
+    expect(v.valid?(0)).to be false
+    expect(v.valid?(2)).to be false
+  end
+end

data/spec/validators/presence_spec.rb

@@ -0,0 +1,47 @@
+describe HaveAPI::Validators::Presence do
+  shared_examples(:all) do
+    it 'accepts a present value' do
+      expect(@v.valid?('foo')).to be true
+    end
+
+    it 'rejects a missing or empty value' do
+      expect(@v.valid?(nil)).to be false
+      expect(@v.valid?('')).to be false
+      expect(@v.valid?(" \t"*4)).to be false
+    end
+  end
+
+  context 'with empty = true' do
+    context 'in short form' do
+      before(:each) do
+        @v = HaveAPI::Validators::Presence.new(:required, true)
+      end
+
+      include_examples :all
+    end
+
+    context 'in full form' do
+      before(:each) do
+        @v = HaveAPI::Validators::Presence.new(:required, {})
+      end
+      
+      include_examples :all
+    end
+  end
+
+  context 'with empty = false' do
+    before(:each) do
+      @v = HaveAPI::Validators::Presence.new(:required, {empty: true})
+    end
+
+    it 'accepts a present value' do
+      expect(@v.valid?('foo')).to be true
+    end
+
+    it 'rejects a missing or an empty value' do
+      expect(@v.valid?(nil)).to be false
+      expect(@v.valid?('')).to be true
+      expect(@v.valid?(" \t"*4)).to be true
+    end
+  end
+end