grape-security 0.8.0

data/spec/grape/middleware/versioner/param_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Versioner::Param do
+
+  let(:app) { lambda { |env| [200, env, env['api.version']] } }
+  subject { Grape::Middleware::Versioner::Param.new(app, @options || {}) }
+
+  it 'sets the API version based on the default param (apiver)' do
+    env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
+    expect(subject.call(env)[1]["api.version"]).to eq('v1')
+  end
+
+  it 'cuts (only) the version out of the params' do
+    env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1", "other_param" => "5" })
+    env['rack.request.query_hash'] = Rack::Utils.parse_nested_query(env['QUERY_STRING'])
+    expect(subject.call(env)[1]['rack.request.query_hash']["apiver"]).to be_nil
+    expect(subject.call(env)[1]['rack.request.query_hash']["other_param"]).to eq("5")
+  end
+
+  it 'provides a nil version if no version is given' do
+    env = Rack::MockRequest.env_for("/")
+    expect(subject.call(env).last).to be_nil
+  end
+
+  context 'with specified parameter name' do
+    before { @options = { parameter: 'v' } }
+    it 'sets the API version based on the custom parameter name' do
+      env = Rack::MockRequest.env_for("/awesome", params: { "v" => "v1" })
+      expect(subject.call(env)[1]["api.version"]).to eq("v1")
+    end
+    it 'does not set the API version based on the default param' do
+      env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
+      expect(subject.call(env)[1]["api.version"]).to be_nil
+    end
+  end
+
+  context 'with specified versions' do
+    before { @options = { versions: ['v1', 'v2'] } }
+    it 'throws an error if a non-allowed version is specified' do
+      env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v3" })
+      expect(catch(:error) { subject.call(env) }[:status]).to eq(404)
+    end
+    it 'allows versions that have been specified' do
+      env = Rack::MockRequest.env_for("/awesome", params: { "apiver" => "v1" })
+      expect(subject.call(env)[1]["api.version"]).to eq('v1')
+    end
+  end
+
+  it 'returns a 200 when no version is set (matches the first version found)' do
+    @options = {
+      versions: ['v1'],
+      version_options: { using: :header }
+    }
+    env = Rack::MockRequest.env_for("/awesome", params: {})
+    expect(subject.call(env).first).to eq(200)
+  end
+
+end

data/spec/grape/middleware/versioner/path_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Versioner::Path do
+  let(:app) { lambda { |env| [200, env, env['api.version']] } }
+  subject { Grape::Middleware::Versioner::Path.new(app, @options || {}) }
+
+  it 'sets the API version based on the first path' do
+    expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
+  end
+
+  it 'does not cut the version out of the path' do
+    expect(subject.call('PATH_INFO' => '/v1/awesome')[1]['PATH_INFO']).to eq('/v1/awesome')
+  end
+
+  it 'provides a nil version if no path is given' do
+    expect(subject.call('PATH_INFO' => '/').last).to be_nil
+  end
+
+  context 'with a pattern' do
+    before { @options = { pattern: /v./i } }
+    it 'sets the version if it matches' do
+      expect(subject.call('PATH_INFO' => '/v1/awesome').last).to eq('v1')
+    end
+
+    it 'ignores the version if it fails to match' do
+      expect(subject.call('PATH_INFO' => '/awesome/radical').last).to be_nil
+    end
+  end
+
+  [['v1', 'v2'], [:v1, :v2], [:v1, 'v2'], ['v1', :v2]].each do |versions|
+    context 'with specified versions as #{versions}' do
+      before { @options = { versions: versions } }
+
+      it 'throws an error if a non-allowed version is specified' do
+        expect(catch(:error) { subject.call('PATH_INFO' => '/v3/awesome') }[:status]).to eq(404)
+      end
+
+      it 'allows versions that have been specified' do
+        expect(subject.call('PATH_INFO' => '/v1/asoasd').last).to eq('v1')
+      end
+    end
+  end
+
+end

data/spec/grape/middleware/versioner_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Grape::Middleware::Versioner do
+
+  let(:klass) { Grape::Middleware::Versioner }
+
+  it 'recognizes :path' do
+    expect(klass.using(:path)).to eq(Grape::Middleware::Versioner::Path)
+  end
+
+  it 'recognizes :header' do
+    expect(klass.using(:header)).to eq(Grape::Middleware::Versioner::Header)
+  end
+
+  it 'recognizes :param' do
+    expect(klass.using(:param)).to eq(Grape::Middleware::Versioner::Param)
+  end
+
+  it 'recognizes :accept_version_header' do
+    expect(klass.using(:accept_version_header)).to eq(Grape::Middleware::Versioner::AcceptVersionHeader)
+  end
+end

data/spec/grape/path_spec.rb

@@ -0,0 +1,229 @@
+require 'spec_helper'
+
+module Grape
+  describe Path do
+
+    describe "#initialize" do
+      it "remembers the path" do
+        path = Path.new('/:id', anything, anything)
+        expect(path.raw_path).to eql('/:id')
+      end
+
+      it "remembers the namespace" do
+        path = Path.new(anything, '/users', anything)
+        expect(path.namespace).to eql('/users')
+      end
+
+      it "remebers the settings" do
+        path = Path.new(anything, anything, foo: 'bar')
+        expect(path.settings).to eql(foo: 'bar')
+      end
+    end
+
+    describe "#mount_path" do
+      it "is nil when no mount path setting exists" do
+        path = Path.new(anything, anything, {})
+        expect(path.mount_path).to be_nil
+      end
+
+      it "is nil when the mount path is nil" do
+        path = Path.new(anything, anything, mount_path: nil)
+        expect(path.mount_path).to be_nil
+      end
+
+      it "splits the mount path" do
+        path = Path.new(anything, anything, mount_path: 'foo/bar')
+        expect(path.mount_path).to eql(['foo', 'bar'])
+      end
+    end
+
+    describe "#root_prefix" do
+      it "is nil when no root prefix setting exists" do
+        path = Path.new(anything, anything, {})
+        expect(path.root_prefix).to be_nil
+      end
+
+      it "is nil when the mount path is nil" do
+        path = Path.new(anything, anything, root_prefix: nil)
+        expect(path.root_prefix).to be_nil
+      end
+
+      it "splits the mount path" do
+        path = Path.new(anything, anything, root_prefix: 'hello/world')
+        expect(path.root_prefix).to eql(['hello', 'world'])
+      end
+    end
+
+    describe "#uses_path_versioning?" do
+      it "is false when the version setting is nil" do
+        path = Path.new(anything, anything, version: nil)
+        expect(path.uses_path_versioning?).to be false
+      end
+
+      it "is false when the version option is header" do
+        path = Path.new(
+          anything,
+          anything,
+          version: 'v1',
+          version_options: { using: :header }
+        )
+
+        expect(path.uses_path_versioning?).to be false
+      end
+
+      it "is true when the version option is path" do
+        path = Path.new(
+          anything,
+          anything,
+          version: 'v1',
+          version_options: { using: :path }
+        )
+
+        expect(path.uses_path_versioning?).to be true
+      end
+    end
+
+    describe "#has_namespace?" do
+      it "is false when the namespace is nil" do
+        path = Path.new(anything, nil, anything)
+        expect(path).not_to have_namespace
+      end
+
+      it "is false when the namespace starts with whitespace" do
+        path = Path.new(anything, ' /foo', anything)
+        expect(path).not_to have_namespace
+      end
+
+      it "is false when the namespace is the root path" do
+        path = Path.new(anything, '/', anything)
+        expect(path).not_to have_namespace
+      end
+
+      it "is true otherwise" do
+        path = Path.new(anything, '/world', anything)
+        expect(path).to have_namespace
+      end
+    end
+
+    describe "#has_path?" do
+      it "is false when the path is nil" do
+        path = Path.new(nil, anything, anything)
+        expect(path).not_to have_path
+      end
+
+      it "is false when the path starts with whitespace" do
+        path = Path.new(' /foo', anything, anything)
+        expect(path).not_to have_path
+      end
+
+      it "is false when the path is the root path" do
+        path = Path.new('/', anything, anything)
+        expect(path).not_to have_path
+      end
+
+      it "is true otherwise" do
+        path = Path.new('/hello', anything, anything)
+        expect(path).to have_path
+      end
+    end
+
+    describe "#path" do
+      context "mount_path" do
+        it "is not included when it is nil" do
+          path = Path.new(nil, nil, mount_path: '/foo/bar')
+          expect(path.path).to eql '/foo/bar'
+        end
+
+        it "is included when it is not nil" do
+          path = Path.new(nil, nil, {})
+          expect(path.path).to eql('/')
+        end
+      end
+
+      context "root_prefix" do
+        it "is not included when it is nil" do
+          path = Path.new(nil, nil, {})
+          expect(path.path).to eql('/')
+        end
+
+        it "is included after the mount path" do
+          path = Path.new(
+            nil,
+            nil,
+            mount_path: '/foo',
+            root_prefix: '/hello'
+          )
+
+          expect(path.path).to eql('/foo/hello')
+        end
+      end
+
+      it "uses the namespace after the mount path and root prefix" do
+        path = Path.new(
+          nil,
+          'namespace',
+          mount_path: '/foo',
+          root_prefix: '/hello'
+        )
+
+        expect(path.path).to eql('/foo/hello/namespace')
+      end
+
+      it "uses the raw path after the namespace" do
+        path = Path.new(
+          'raw_path',
+          'namespace',
+          mount_path: '/foo',
+          root_prefix: '/hello'
+        )
+
+        expect(path.path).to eql('/foo/hello/namespace/raw_path')
+      end
+    end
+
+    describe "#suffix" do
+      context "when path versioning is used" do
+        it "includes a '/'" do
+          path = Path.new(nil, nil, {})
+          allow(path).to receive(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(/.:format)')
+        end
+      end
+
+      context "when path versioning is not used" do
+        it "does not include a '/' when the path has a namespace" do
+          path = Path.new(nil, 'namespace', {})
+          allow(path).to receive(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(.:format)')
+        end
+
+        it "does not include a '/' when the path has a path" do
+          path = Path.new('/path', nil, {})
+          allow(path).to receive(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(.:format)')
+        end
+
+        it "includes a '/' otherwise" do
+          path = Path.new(nil, nil, {})
+          allow(path).to receive(:uses_path_versioning?) { true }
+
+          expect(path.suffix).to eql('(/.:format)')
+        end
+      end
+    end
+
+    describe "#path_with_suffix" do
+      it "combines the path and suffix" do
+        path = Path.new(nil, nil, {})
+        allow(path).to receive(:path) { '/the/path' }
+        allow(path).to receive(:suffix) { 'suffix' }
+
+        expect(path.path_with_suffix).to eql('/the/pathsuffix')
+      end
+    end
+
+  end
+end

data/spec/grape/util/hash_stack_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Grape::Util::HashStack do
+
+  describe '#get' do
+    it 'finds the first available key' do
+      subject[:abc] = 123
+      subject.push(abc: 345)
+      expect(subject.get(:abc)).to eq(345)
+    end
+
+    it 'is nil if the key has not been set' do
+      expect(subject[:abc]).to be_nil
+    end
+  end
+
+  describe '#set' do
+    it 'sets a value on the highest frame' do
+      subject.push
+      subject.set(:abc, 123)
+      expect(subject.stack.last[:abc]).to eq(123)
+    end
+  end
+
+  describe '#imbue' do
+    it 'pushes a new value onto the end of an array' do
+      subject[:abc] = []
+      subject.imbue :abc, [123]
+      subject.imbue :abc, [456]
+      expect(subject[:abc]).to eq([123, 456])
+    end
+
+    it 'merges a hash that is passed' do
+      subject[:abc] = { foo: 'bar' }
+      subject.imbue :abc, baz: 'wich'
+      expect(subject[:abc]).to eq(foo: 'bar', baz: 'wich')
+    end
+
+    it 'sets the value if not a hash or array' do
+      subject.imbue :abc, 123
+      expect(subject[:abc]).to eq(123)
+    end
+
+    it 'is able to imbue an array without explicit setting' do
+      subject.imbue :arr, [1]
+      subject.imbue :arr, [2]
+      expect(subject[:arr]).to eq([1, 2])
+    end
+
+    it 'is able to imbue a hash without explicit setting' do
+      subject.imbue :hash, foo: 'bar'
+      subject.imbue :hash, baz: 'wich'
+      expect(subject[:hash]).to eq(foo: 'bar', baz: 'wich')
+    end
+  end
+
+  describe '#push' do
+    it 'returns a HashStack' do
+      expect(subject.push(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
+    end
+
+    it 'places the passed value on the top of the stack' do
+      subject.push(abc: 123)
+      expect(subject.stack).to eq([{}, { abc: 123 }])
+    end
+
+    it 'pushes an empty hash by default' do
+      subject[:abc] = 123
+      subject.push
+      expect(subject.stack).to eq([{ abc: 123 }, {}])
+    end
+  end
+
+  describe '#pop' do
+    it 'removes and return the top frame' do
+      subject.push(abc: 123)
+      expect(subject.pop).to eq(abc: 123)
+      expect(subject.stack.size).to eq(1)
+    end
+  end
+
+  describe '#peek' do
+    it 'returns the top frame without removing it' do
+      subject.push(abc: 123)
+      expect(subject.peek).to eq(abc: 123)
+      expect(subject.stack.size).to eq(2)
+    end
+  end
+
+  describe '#prepend' do
+    it 'returns a HashStack' do
+      expect(subject.prepend(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
+    end
+
+    it "prepends a HashStack's stack onto its own stack" do
+      other = Grape::Util::HashStack.new.push(abc: 123)
+      expect(subject.prepend(other).stack).to eq([{}, { abc: 123 }, {}])
+    end
+  end
+
+  describe '#concat' do
+    it 'returns a HashStack' do
+      expect(subject.concat(Grape::Util::HashStack.new)).to be_kind_of(Grape::Util::HashStack)
+    end
+
+    it "appends a HashStack's stack onto its own stack" do
+      other = Grape::Util::HashStack.new.push(abc: 123)
+      expect(subject.concat(other).stack).to eq([{}, {}, { abc: 123 }])
+    end
+  end
+
+  describe '#update' do
+    it 'merges! into the top frame' do
+      subject.update(abc: 123)
+      expect(subject.stack).to eq([{ abc: 123 }])
+    end
+
+    it 'returns a HashStack' do
+      expect(subject.update(abc: 123)).to be_kind_of(Grape::Util::HashStack)
+    end
+  end
+
+  describe '#clone' do
+    it 'performs a deep copy' do
+      subject[:abc] = 123
+      subject.push def: 234
+      clone = subject.clone
+      clone[:def] = 345
+      expect(subject[:def]).to eq(234)
+    end
+  end
+end