haveapi 0.26.4 → 0.27.0

data/spec/resource_spec.rb

@@ -1,4 +1,4 @@
-describe HaveAPI::Resource do
+module ResourceSpec
   class PluralTest < HaveAPI::Resource
   end
 
@@ -6,19 +6,6 @@ describe HaveAPI::Resource do
     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
@@ -29,33 +16,60 @@ describe HaveAPI::Resource do
       class Show < HaveAPI::Actions::Default::Show; end
     end
   end
+end
+
+describe HaveAPI::Resource do
+  it 'has correct obj_type' do
+    expect(ResourceSpec::PluralTest.obj_type).to eq(:resource)
+    expect(ResourceSpec::SingularTest.obj_type).to eq(:resource)
+  end
+
+  context 'when resource is plural' do
+    it 'has singular resource name' do
+      expect(ResourceSpec::PluralTest.resource_name).to eq('PluralTest')
+    end
+
+    it 'has plural rest name' do
+      expect(ResourceSpec::PluralTest.rest_name).to eq('plural_tests')
+    end
+  end
+
+  context 'when resource is singular' do
+    it 'has singular resource name' do
+      expect(ResourceSpec::SingularTest.resource_name).to eq('SingularTest')
+    end
+
+    it 'has singular rest name' do
+      expect(ResourceSpec::SingularTest.rest_name).to eq('singular_test')
+    end
+  end
 
   it 'iterates over actions' do
     actions = []
 
-    ComplexTest.actions do |a|
+    ResourceSpec::ComplexTest.actions do |a|
       actions << a
     end
 
     expect(actions).to contain_exactly(
-      ComplexTest::Index,
-      ComplexTest::Show,
-      ComplexTest::Create
+      ResourceSpec::ComplexTest::Index,
+      ResourceSpec::ComplexTest::Show,
+      ResourceSpec::ComplexTest::Create
     )
   end
 
   it 'iterates over resources' do
     resources = []
 
-    ComplexTest.resources do |r|
+    ResourceSpec::ComplexTest.resources do |r|
       resources << r
     end
 
-    expect(resources).to contain_exactly(ComplexTest::SubResource)
+    expect(resources).to contain_exactly(ResourceSpec::ComplexTest::SubResource)
   end
 
   it 'defines and returns resource-wide params' do
-    ComplexTest.params(:name) { 'executed' }
-    expect(ComplexTest.params(:name).call).to eq('executed')
+    ResourceSpec::ComplexTest.params(:name) { 'executed' }
+    expect(ResourceSpec::ComplexTest.params(:name).call).to eq('executed')
   end
 end

data/spec/server/integration_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+describe HaveAPI::Server do
+  describe 'integration' do
+    api do
+      define_resource(:Test) do
+        version 1
+        auth false
+
+        define_action(:Echo) do
+          http_method :post
+          authorize { allow }
+
+          input do
+            string :msg
+          end
+
+          output do
+            string :msg
+          end
+
+          def exec
+            { msg: params.dig(:test, :msg) }
+          end
+        end
+      end
+    end
+
+    default_version 1
+
+    it 'returns 406 for unsupported Accept' do
+      header 'Accept', 'text/plain'
+      options '/v1/'
+
+      expect(last_response.status).to eq(406)
+    end
+
+    it 'returns 400 for invalid JSON' do
+      header 'Content-Type', 'application/json'
+      header 'Accept', 'application/json'
+      post '/v1/tests/echo', '{'
+
+      expect(last_response.status).to eq(400)
+      expect(api_response).not_to be_ok
+      expect(api_response.message).to match(/Bad JSON syntax/)
+    end
+
+    it 'returns JSON envelope for unknown route' do
+      header 'Accept', 'application/json'
+      get '/does-not-exist'
+
+      expect(last_response.status).to eq(404)
+      expect(api_response).not_to be_ok
+    end
+
+    it 'handles CORS preflight OPTIONS' do
+      header 'Accept', 'application/json'
+      header 'Origin', 'https://example.com'
+      header 'Access-Control-Request-Method', 'POST'
+      header 'Access-Control-Request-Headers', 'X-Foo, Authorization'
+      options '/v1/'
+
+      expect(last_response.status).to eq(200)
+
+      headers = last_response.headers.transform_keys(&:downcase)
+      expect(headers['access-control-allow-origin']).to eq('*')
+      expect(headers['access-control-allow-methods']).to include('POST')
+      expect(headers['access-control-allow-headers']).to be_a(String)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+ENV['RACK_ENV'] ||= 'test'
+
 require 'require_all'
 require_relative '../lib/haveapi'
 require_rel '../lib/haveapi/spec/*.rb'
@@ -9,8 +11,6 @@ module HaveAPI
   end
 end
 
-require_rel 'api'
-
 # Configure specs
 RSpec.configure do |config|
   config.order = 'random'

data/spec/validators/acceptance_spec.rb

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

data/spec/validators/confirmation_spec.rb

@@ -1,46 +1,44 @@
 describe HaveAPI::Validators::Confirmation do
-  shared_examples(:all) do
+  shared_examples('all') do
     it 'accepts the same value' do
-      expect(@v.validate('foo', { other_param: 'foo' })).to be true
+      expect(validator.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
+      expect(validator.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
+  context 'with short form' do
+    let(:validator) { described_class.new(:confirm, :other_param) }
 
-    include_examples :all
+    it_behaves_like 'all'
   end
 
-  context 'full form' do
-    before(:each) do
-      @v = HaveAPI::Validators::Confirmation.new(:confirm, {
+  context 'with full form' do
+    let(:validator) do
+      described_class.new(:confirm, {
         param: :other_param
       })
     end
 
-    include_examples :all
+    it_behaves_like 'all'
   end
 
   context 'with equal = false' do
-    before(:each) do
-      @v = HaveAPI::Validators::Confirmation.new(:confirm, {
+    let(:validator) do
+      described_class.new(:confirm, {
         param: :other_param,
         equal: false
       })
     end
 
     it 'rejects the same value' do
-      expect(@v.validate('foo', { other_param: 'foo' })).to be false
+      expect(validator.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
+      expect(validator.validate('bar', { other_param: 'foo' })).to be true
     end
   end
 end

data/spec/validators/custom_spec.rb

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

data/spec/validators/exclusion_spec.rb

@@ -1,32 +1,30 @@
 describe HaveAPI::Validators::Exclusion do
-  shared_examples(:all) 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
+      expect(validator.valid?('one')).to be false
+      expect(validator.valid?('two')).to be false
+      expect(validator.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
+      expect(validator.valid?('zero')).to be true
+      expect(validator.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
+  context 'with short form' do
+    let(:validator) { described_class.new(:exclude, %w[one two three]) }
 
-    include_examples :all
+    it_behaves_like 'all'
   end
 
-  context 'full form' do
-    before(:each) do
-      @v = HaveAPI::Validators::Exclusion.new(:exclude, {
+  context 'with full form' do
+    let(:validator) do
+      described_class.new(:exclude, {
         values: %w[one two three]
       })
     end
 
-    include_examples :all
+    it_behaves_like 'all'
   end
 end

data/spec/validators/format_spec.rb

@@ -1,54 +1,52 @@
 describe HaveAPI::Validators::Format do
-  shared_examples(:all) 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
+      expect(validator.valid?('aab')).to be true
+      expect(validator.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
+      expect(validator.valid?('aacac')).to be false
+      expect(validator.valid?('bacacb')).to be false
+      expect(validator.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
+    context 'with short form' do
+      let(:validator) { described_class.new(:format, /^a[^b]+b$/) }
 
-      include_examples :all
+      it_behaves_like 'all'
     end
 
-    context 'full form' do
-      before(:each) do
-        @v = HaveAPI::Validators::Format.new(:format, {
+    context 'with full form' do
+      let(:validator) do
+        described_class.new(:format, {
           rx: /^a[^b]+b$/
         })
       end
 
-      include_examples :all
+      it_behaves_like 'all'
     end
   end
 
   context 'with match = false' do
-    before(:each) do
-      @v = HaveAPI::Validators::Format.new(:format, {
+    let(:validator) do
+      described_class.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
+      expect(validator.valid?('aab')).to be false
+      expect(validator.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
+      expect(validator.valid?('aacac')).to be true
+      expect(validator.valid?('bacacb')).to be true
+      expect(validator.valid?('b')).to be true
     end
   end
 end

data/spec/validators/inclusion_spec.rb

@@ -1,14 +1,14 @@
 describe HaveAPI::Validators::Inclusion do
-  shared_examples(:all) 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
+      expect(validator.valid?('one')).to be true
+      expect(validator.valid?('two')).to be true
+      expect(validator.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
+      expect(validator.valid?('zero')).to be false
+      expect(validator.valid?('four')).to be false
     end
   end
 
@@ -21,22 +21,20 @@ describe HaveAPI::Validators::Inclusion do
     }
   ].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
+      context 'with short form' do
+        let(:validator) { described_class.new(:include, %w[one two three]) }
 
-        include_examples :all
+        it_behaves_like 'all'
       end
 
-      context 'full form' do
-        before(:each) do
-          @v = HaveAPI::Validators::Inclusion.new(:include, {
+      context 'with full form' do
+        let(:validator) do
+          described_class.new(:include, {
             values: %w[one two three]
           })
         end
 
-        include_examples :all
+        it_behaves_like 'all'
       end
     end
   end

data/spec/validators/length_spec.rb

@@ -1,25 +1,25 @@
 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 })
+      described_class.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, {})
+      described_class.new(:length, {})
     end.to raise_error(RuntimeError)
   end
 
   it 'checks minimum' do
-    v = HaveAPI::Validators::Length.new(:length, { min: 2 })
+    v = described_class.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 })
+    v = described_class.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
@@ -27,7 +27,7 @@ describe HaveAPI::Validators::Length do
   end
 
   it 'checks range' do
-    v = HaveAPI::Validators::Length.new(:length, { min: 3, max: 6 })
+    v = described_class.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
@@ -37,7 +37,7 @@ describe HaveAPI::Validators::Length do
   end
 
   it 'check a specific length' do
-    v = HaveAPI::Validators::Length.new(:length, { equals: 4 })
+    v = described_class.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

data/spec/validators/numericality_spec.rb

@@ -1,19 +1,19 @@
 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 })
+      described_class.new(:number, { odd: true, even: true })
     end.to raise_error(RuntimeError)
   end
 
   it 'checks minimum' do
-    v = HaveAPI::Validators::Numericality.new(:number, { min: 5 })
+    v = described_class.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 })
+    v = described_class.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
@@ -21,7 +21,7 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that x % y = 0' do
-    v = HaveAPI::Validators::Numericality.new(:number, { mod: 2 })
+    v = described_class.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
@@ -30,7 +30,7 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that the number is in a step' do
-    v = HaveAPI::Validators::Numericality.new(:number, { step: 3 })
+    v = described_class.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
@@ -40,7 +40,7 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that the number is in a step with a minimum' do
-    v = HaveAPI::Validators::Numericality.new(:number, { min: 5, step: 3 })
+    v = described_class.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
@@ -53,7 +53,7 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that the number is even' do
-    v = HaveAPI::Validators::Numericality.new(:number, { even: true })
+    v = described_class.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
@@ -61,7 +61,7 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks that the number is odd' do
-    v = HaveAPI::Validators::Numericality.new(:number, { odd: true })
+    v = described_class.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
@@ -69,12 +69,12 @@ describe HaveAPI::Validators::Numericality do
   end
 
   it 'checks number as string' do
-    v = HaveAPI::Validators::Numericality.new(:number, { min: 5 })
+    v = described_class.new(:number, { min: 5 })
     expect(v.valid?('5')).to be true
   end
 
   it 'rejects a string that is not a number' do
-    v = HaveAPI::Validators::Numericality.new(:number, { min: 5 })
+    v = described_class.new(:number, { min: 5 })
     expect(v.valid?('abc')).to be false
   end
 end

data/spec/validators/presence_spec.rb

@@ -1,47 +1,41 @@
 describe HaveAPI::Validators::Presence do
-  shared_examples(:all) do
+  shared_examples('all') do
     it 'accepts a present value' do
-      expect(@v.valid?('foo')).to be true
+      expect(validator.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
+      expect(validator.valid?(nil)).to be false
+      expect(validator.valid?('')).to be false
+      expect(validator.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
+    context 'with short form' do
+      let(:validator) { described_class.new(:required, true) }
 
-      include_examples :all
+      it_behaves_like 'all'
     end
 
-    context 'in full form' do
-      before(:each) do
-        @v = HaveAPI::Validators::Presence.new(:required, {})
-      end
+    context 'with full form' do
+      let(:validator) { described_class.new(:required, {}) }
 
-      include_examples :all
+      it_behaves_like 'all'
     end
   end
 
   context 'with empty = false' do
-    before(:each) do
-      @v = HaveAPI::Validators::Presence.new(:required, { empty: true })
-    end
+    let(:validator) { described_class.new(:required, { empty: true }) }
 
     it 'accepts a present value' do
-      expect(@v.valid?('foo')).to be true
+      expect(validator.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
+      expect(validator.valid?(nil)).to be false
+      expect(validator.valid?('')).to be true
+      expect(validator.valid?(" \t" * 4)).to be true
     end
   end
 end