haveapi 0.4.2 → 0.5.0

data/spec/action/dsl_spec.rb

@@ -0,0 +1,199 @@
+describe HaveAPI::Action do
+  context 'DSL' do
+    it 'inherits input' do
+      class Resource < HaveAPI::Resource
+        class InputAction < HaveAPI::Action
+          input do
+            string :param
+          end
+        end
+
+        class SubInputAction < InputAction ; end
+      end
+
+      # Invokes execution of input/output blocks
+      Resource.routes
+      expect(Resource::SubInputAction.input.params.first.name).to eq(:param)
+    end
+
+    it 'inherits output' do
+      class Resource < HaveAPI::Resource
+        class OutputAction < HaveAPI::Action
+          output do
+            string :param
+          end
+        end
+
+        class SubOutputAction < OutputAction ; end
+      end
+    
+      # Invokes execution of input/output blocks
+      Resource.routes
+      expect(Resource::SubOutputAction.output.params.first.name).to eq(:param)
+    end
+
+    it 'chains input' do
+      class Resource < HaveAPI::Resource
+        class InputChainAction < HaveAPI::Action
+          input do
+            string :param1
+          end
+
+          input do
+            string :param2
+          end
+        end
+      end
+   
+      # Invokes execution of input/output blocks
+      Resource.routes
+
+      params = Resource::InputChainAction.input.params.map { |p| p.name }
+      expect(params).to contain_exactly(:param1, :param2)
+    end
+
+    it 'chains output' do
+      class Resource < HaveAPI::Resource
+        class OutputChainAction < HaveAPI::Action
+          output do
+            string :param1
+          end
+
+          output do
+            string :param2
+          end
+        end
+      end
+   
+      # Invokes execution of input/output blocks
+      Resource.routes
+
+      params = Resource::OutputChainAction.output.params.map { |p| p.name }
+      expect(params).to contain_exactly(:param1, :param2)
+    end
+
+    it 'can combine chaining and inheritance' do
+      class Resource < HaveAPI::Resource
+        class BaseAction < HaveAPI::Action
+          input do
+            string :inbase1
+          end
+
+          input do
+            string :inbase2
+          end
+
+          output do
+            string :outbase1
+          end
+
+          output do
+            string :outbase2
+          end
+        end
+
+        class SubAction < BaseAction
+          input do
+            string :insub1
+            string :insub2
+          end
+
+          input do
+            string :insub3
+          end
+
+          output do
+            string :outsub1
+            string :outsub2
+          end
+
+          output do
+            string :outsub3
+          end
+        end
+      end
+
+      # Invokes execution of input/output blocks
+      Resource.routes
+
+      input = Resource::SubAction.input.params.map { |p| p.name }
+      output = Resource::SubAction.output.params.map { |p| p.name }
+
+      expect(input).to contain_exactly(*%i(inbase1 inbase2 insub1 insub2 insub3))
+      expect(output).to contain_exactly(*%i(outbase1 outbase2 outsub1 outsub2 outsub3))
+    end
+
+    it 'sets layout' do
+      class Resource < HaveAPI::Resource
+        class DefaultLayoutAction < HaveAPI::Action ; end
+
+        class ObjectLayoutAction < HaveAPI::Action
+          input(:object) {}
+          output(:object) {}
+        end
+
+        class ObjectListLayoutAction < HaveAPI::Action
+          input(:object_list) {}
+          output(:object_list) {}
+        end
+        
+        class HashLayoutAction < HaveAPI::Action
+          input(:hash) {}
+          output(:hash) {}
+        end
+        
+        class HashListLayoutAction < HaveAPI::Action
+          input(:hash_list) {}
+          output(:hash_list) {}
+        end
+        
+        class CombinedLayoutAction < HaveAPI::Action
+          input(:hash) {}
+          output(:object_list) {}
+        end
+      end
+
+      expect(Resource::DefaultLayoutAction.input.layout).to eq(:object)
+      expect(Resource::DefaultLayoutAction.output.layout).to eq(:object)
+
+      expect(Resource::ObjectLayoutAction.input.layout).to eq(:object)
+      expect(Resource::ObjectLayoutAction.output.layout).to eq(:object)
+
+      expect(Resource::ObjectListLayoutAction.input.layout).to eq(:object_list)
+      expect(Resource::ObjectListLayoutAction.output.layout).to eq(:object_list)
+
+      expect(Resource::HashLayoutAction.input.layout).to eq(:hash)
+      expect(Resource::HashLayoutAction.output.layout).to eq(:hash)
+
+      expect(Resource::HashListLayoutAction.input.layout).to eq(:hash_list)
+      expect(Resource::HashListLayoutAction.output.layout).to eq(:hash_list)
+
+      expect(Resource::CombinedLayoutAction.input.layout).to eq(:hash)
+      expect(Resource::CombinedLayoutAction.output.layout).to eq(:object_list)
+    end
+
+    it 'catches exceptions in input' do
+      class ExResourceIn < HaveAPI::Resource
+        class ExInputAction < HaveAPI::Action
+          input do
+            fail 'this is terrible!'
+          end
+        end
+      end
+
+      expect { ExResourceIn.routes }.to raise_error(HaveAPI::BuildError)
+    end
+    
+    it 'catches exceptions in output' do
+      class ExResourceOut < HaveAPI::Resource
+        class ExOutputAction < HaveAPI::Action
+          output do
+            fail 'this is terrible!'
+          end
+        end
+      end
+
+      expect { ExResourceOut.routes }.to raise_error(HaveAPI::BuildError)
+    end
+  end
+end

data/spec/authorization_spec.rb

@@ -0,0 +1,113 @@
+describe HaveAPI::Authorization do
+  class Resource < HaveAPI::Resource
+    class Index < HaveAPI::Actions::Default::Index
+      input do
+        string :param1
+        string :param2
+      end
+
+      output do
+        string :param1
+        string :param2
+      end
+    end
+
+    routes
+  end
+
+  it 'defaults to deny' do
+    auth = HaveAPI::Authorization.new {}
+    expect(auth.authorized?(nil)).to be false
+  end
+
+  it 'can authorize' do
+    auth = HaveAPI::Authorization.new { allow }
+    expect(auth.authorized?(nil)).to be true
+  end
+
+  it 'applies restrictions' do
+    auth = HaveAPI::Authorization.new do
+      restrict filter: true
+      allow
+    end
+
+    expect(auth.authorized?(nil)).to be true
+    expect(auth.restrictions[:filter]).to be true
+  end
+
+  it 'whitelists input' do
+    auth = HaveAPI::Authorization.new do
+      input whitelist: %i(param1)
+      allow
+    end
+    
+    expect(auth.authorized?(nil)).to be true
+  
+    action = Resource::Index
+
+    expect(auth.filter_input(
+        action.input.params,
+        action.model_adapter(action.input.layout).input({
+            param1: '123',
+            param2: '456',
+        })
+    ).keys).to contain_exactly(:param1)
+  end
+
+  it 'blacklists input' do
+    auth = HaveAPI::Authorization.new do
+      input blacklist: %i(param1)
+      allow
+    end
+    
+    expect(auth.authorized?(nil)).to be true
+  
+    action = Resource::Index
+
+    expect(auth.filter_input(
+        action.input.params,
+        action.model_adapter(action.input.layout).input({
+            param1: '123',
+            param2: '456',
+        })
+    ).keys).to contain_exactly(:param2)
+  end
+
+  it 'whitelists output' do
+    auth = HaveAPI::Authorization.new do
+      output whitelist: %i(param1)
+      allow
+    end
+    
+    expect(auth.authorized?(nil)).to be true
+  
+    action = Resource::Index
+
+    expect(auth.filter_output(
+        action.output.params,
+        action.model_adapter(action.output.layout).output(nil, {
+            param1: '123',
+            param2: '456',
+        })
+    ).keys).to contain_exactly(:param1)
+  end
+
+  it 'blacklists output' do
+    auth = HaveAPI::Authorization.new do
+      output blacklist: %i(param1)
+      allow
+    end
+    
+    expect(auth.authorized?(nil)).to be true
+  
+    action = Resource::Index
+
+    expect(auth.filter_output(
+        action.output.params,
+        action.model_adapter(action.output.layout).output(nil, {
+            param1: '123',
+            param2: '456',
+        })
+    ).keys).to contain_exactly(:param2)
+  end
+end

data/spec/common_spec.rb

@@ -0,0 +1,47 @@
+describe HaveAPI::Common do
+  class Test1 < HaveAPI::Common
+    has_attr :attr1
+    has_attr :attr2, 42
+  end
+
+  it 'defines attributes' do
+    expect(Test1.attr1).to be_nil
+    expect(Test1.attr2).to eq(42)
+  end
+  
+  class Test2 < HaveAPI::Common
+    has_attr :attr1
+    has_attr :attr2, 42
+  end
+
+  it 'sets attributes' do
+    Test2.attr1 'val1'
+    Test2.attr2 663
+
+    expect(Test2.attr1).to eq('val1')
+    expect(Test2.attr2).to eq(663)
+  end
+
+  class Test3 < HaveAPI::Common
+    has_attr :attr1
+    has_attr :attr2, 42
+    has_attr :attr3
+
+    attr1 'foo'
+    attr2 :bar
+
+    def self.inherited(subclass)
+      inherit_attrs(subclass)
+    end
+  end
+
+  class SubTest3 < Test3
+    attr3 'bar'
+  end
+
+  it 'inherites attributes' do
+    expect(SubTest3.attr1).to eq('foo')
+    expect(SubTest3.attr2).to eq(:bar)
+    expect(SubTest3.attr3).to eq('bar')
+  end
+end

data/spec/documentation_spec.rb

@@ -0,0 +1,29 @@
+describe 'Documentation' do
+  it 'responds to OPTIONS /' do
+
+  end
+  
+  it 'responds to OPTIONS /?describe=versions' do
+
+  end
+  
+  it 'responds to OPTIONS /?describe=default' do
+
+  end
+
+  it 'responds to OPTIONS /<version>' do
+
+  end
+
+  it 'responds to OPTIONS /<every action>?method=<method>' do
+
+  end
+
+  it 'has online doc' do
+  
+  end
+
+  it 'has online doc for every version' do
+
+  end
+end

data/spec/envelope_spec.rb

@@ -0,0 +1,33 @@
+describe 'Envelope' do
+  context 'documentation' do
+    empty_api
+
+    it 'returns correct envelope' do
+      call_api(:options, '/')
+      expect(api_response.envelope.keys).to contain_exactly(
+          *%i(version status response message errors)
+      )
+    end
+    
+    it 'succeeds' do
+      call_api(:options, '/')
+      expect(api_response).to be_ok
+    end
+  end
+
+  context 'data' do
+    empty_api
+    
+    it 'returns correct envelope' do
+      call_api(:get, '/unknown_resource')
+      expect(api_response.envelope.keys).to contain_exactly(
+          *%i(status response message errors)
+      )
+    end
+
+    it 'fails' do
+      call_api(:get, '/unknown_resource')
+      expect(api_response).to_not be_ok
+    end
+  end
+end

data/spec/hooks_spec.rb

@@ -0,0 +1,146 @@
+describe HaveAPI::Hooks do
+  class ClassLevel
+    include HaveAPI::Hookable
+
+    has_hook :simple_hook
+    has_hook :arg_hook
+    has_hook :ret_hook
+    has_hook :context_hook
+  end
+  
+  class InstanceLevel
+    include HaveAPI::Hookable
+
+    has_hook :simple_hook
+    has_hook :arg_hook
+    has_hook :ret_hook
+    has_hook :context_hook
+  end
+
+  def connect_hook(name, &block)
+    @obj.connect_hook(name, &block)
+  end
+
+  def call_hooks(*args)
+    case @level
+    when :class
+      @obj.call_hooks(*args)
+
+    when :instance
+      if @method
+        @obj.method(@method).call(*args)
+
+      else
+        @obj.call_hooks_for(*args)
+      end
+
+    else
+      fail "unknown level '#{@level}'"
+    end
+  end
+  
+  shared_examples(:common) do
+    it 'calls hooks' do
+      called = false
+
+      connect_hook(:simple_hook) do |ret|
+        called = true
+        ret
+      end
+
+      call_hooks(:simple_hook)
+      expect(called).to be true
+    end
+    
+    it 'passes arguments' do
+      called = false
+      
+      connect_hook(:arg_hook) do |ret, a, b, c|
+        called = true
+        expect([a, b, c]).to eq([1, 2, 3])
+        ret
+      end
+
+      call_hooks(:arg_hook, args: [1, 2, 3])
+      expect(called).to be true
+    end
+
+    it 'chains hooks' do
+      arr = []
+
+      5.times do |i|
+        connect_hook(:simple_hook) do |ret|
+          arr << i
+          ret
+        end
+      end
+
+      call_hooks(:simple_hook)
+      expect(arr).to eq([0, 1, 2, 3, 4])
+    end
+
+    it 'chains return value' do
+      5.times do
+        connect_hook(:ret_hook) do |ret|
+          ret[:counter] += 1
+          ret
+        end
+      end
+
+      sum = call_hooks(:ret_hook, initial: {counter: 0})
+      expect(sum[:counter]).to eq(5)
+    end
+
+    it 'executes block in given context' do
+      class CustomEnv
+        def foo
+          'bar'
+        end
+      end
+
+      connect_hook(:context_hook) do |ret|
+        ret[:val] = foo
+        ret
+      end
+
+      res = call_hooks(:context_hook, CustomEnv.new)
+      expect(res[:val]).to eq('bar')
+    end
+  end
+
+  context 'on class level' do
+    before(:each) do
+      @obj = ClassLevel
+      @level = :class
+    end
+    
+    include_examples :common
+  end
+
+  context 'on instance level' do
+    context 'all hooks' do
+      before(:each) do
+        @obj = InstanceLevel.new
+        @level = :instance
+      end
+      
+      include_examples :common
+    end
+    
+    context 'only class hooks' do
+      # FIXME: class hooks fail (that is correct, no class hooks are defined)
+      #        must find a way to test failure
+      #include_examples :common
+    end
+    
+    context 'only instance hooks' do
+      before(:each) do
+        @obj = InstanceLevel.new
+        @level = :instance
+        @method = :call_instance_hooks_for
+      end
+      
+      include_examples :common
+    end
+  end
+end

data/spec/parameters/typed_spec.rb

@@ -0,0 +1,93 @@
+require 'time'
+
+describe 'Parameters::Typed' do
+  def p_type(type)
+    HaveAPI::Parameters::Typed.new(:param1, type: type)
+  end
+
+  def p_arg(arg = {})
+    HaveAPI::Parameters::Typed.new(*[:param1, arg])
+  end
+
+  it 'does not change provided arguments' do
+    kwargs = {
+        label: 'Param 1',
+        desc: 'Desc',
+        required: true,
+    }
+    p_arg(kwargs)
+    expect(kwargs.keys).to contain_exactly(*%i(label desc required))
+  end
+
+  it 'automatically sets label' do
+    p = p_arg
+    expect(p.label).to eq('Param1')
+  end
+
+  it 'accepts custom label' do
+    p = p_arg(label: 'Custom')
+    expect(p.label).to eq('Custom')
+  end
+
+  it 'rejects unknown parameters' do
+    expect do
+      p_arg(shiny: true)
+    end.to raise_error(RuntimeError)
+  end
+
+  it 'can be required' do
+    p = p_arg(required: true)
+    expect(p.required?).to be true
+  end
+
+  it 'can be optional' do
+    p = p_arg
+    expect(p.optional?).to be true
+    
+    p = p_arg(required: false)
+    expect(p.optional?).to be true
+    
+    p = p_arg(required: nil)
+    expect(p.optional?).to be true
+  end
+
+  it 'cleans input value' do
+    # Integer
+    p = p_type(Integer)
+    expect(p.clean('42')).to eq(42)
+    
+    # Float
+    p = p_type(Float)
+    expect(p.clean('3.1456')).to eq(3.1456)
+
+    # Boolean
+    p = p_type(Boolean)
+
+    %w(true t yes y 1).each do |v|
+      expect(p.clean(v)).to be true
+    end
+    
+    %w(false f no n 0).each do |v|
+      expect(p.clean(v)).to be false
+    end
+
+    # Datetime
+    p = p_type(Datetime)
+    t = Time.now
+    t2 = Time.iso8601(t.iso8601)
+
+    expect(p.clean(t.iso8601)).to eq(t2)
+    expect { p.clean('bzz') }.to raise_error(HaveAPI::ValidationError)
+
+    # String, Text
+    p = p_type(String)
+    expect(p.clean('bzz')).to eq('bzz')
+
+    # Defaults
+    p = p_type(String)
+    expect(p.clean(nil)).to be_nil
+
+    p.patch(default: 'bazinga')
+    expect(p.clean(nil)).to eq('bazinga')
+  end
+end