versioncake 2.5.0 → 3.0.0

data/spec/test_app/config/boot.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../Gemfile', __FILE__)
+
+require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])

data/spec/test_app/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+RendersTest::Application.initialize!

data/spec/test_app/config/initializers/versioncake.rb

@@ -0,0 +1,45 @@
+VersionCake.setup do |config|
+  # Set the version key that clients will send example: `X-API-VERSION: 5`
+  # config.version_key = 'version'
+
+  # Enable Rails versioned filename mapping
+  # config.rails_view_versioning = true
+
+  # Extraction Strategies
+  # Define how you will accept version from the request.
+  #
+  # Defaults to all:
+  #   [:http_accept_parameter, :http_header, :request_parameter, :path_parameter, :query_parameter]
+  #
+  # Custom strategy example:
+  #   You can create your own extraction strategy by giving a proc or class that responds to execute:
+  # ```
+  #     lambda {|request| request.headers["HTTP_X_MY_VERSION"] }
+  # ```
+  # or
+  # ```
+  # class ExtractorStrategy
+  #   def execute(request)
+  #     request.headers["HTTP_X_MY_VERSION"]
+  #   end
+  # end
+  # ```
+  config.extraction_strategy = [:http_accept_parameter,
+                                :http_header,
+                                :request_parameter,
+                                :path_parameter,
+                                :query_parameter]
+
+  # Version when no version in present in the request. If none is
+  # specified then it will error?
+  config.missing_version = 3
+
+  # Versioned Resources
+  # Define what server resources are supported, deprecated or obsolete
+  # Resources listed are priority based upon creation. To version all
+  # resources you can define a catch all at the bottom of the block.
+  config.resources do |r|
+    # r.resource uri_regex, obsolete, deprecated, supported
+    r.resource %r{renders/*}, [2], [4], (1..5)
+  end
+end

data/spec/test_app/config/routes.rb

@@ -0,0 +1,4 @@
+RendersTest::Application.routes.draw do
+  resources :renders, only: :index
+  resources :unversioned, only: :index
+end

data/spec/test_app/script/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/unit/cli_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe VersionCake::Cli do
+  quiet_stdout
+  before { allow(File).to receive :rename }
+
+  context '#migrate' do
+    subject(:migrated_files) { VersionCake::Cli.new.migrate(path) }
+
+    context 'when a path has migratable files' do
+      let(:path) { './spec/fixtures/templates' }
+
+      it {
+        renamed_files = [
+          ['./spec/fixtures/templates/v1_extension_scheme.v3.html.erb',
+            './spec/fixtures/templates/v1_extension_scheme.html.v3.erb'],
+          ['./spec/fixtures/templates/v1_extension_scheme.v6.json',
+            './spec/fixtures/templates/v1_extension_scheme.json.v6']
+        ]
+        expect(renamed_files).to match_array migrated_files
+      }
+    end
+
+    context 'when a path has no migratable files' do
+      let(:path) { './spec/test_app/app/views' }
+
+      it { expect(migrated_files).to be_empty }
+    end
+
+    context 'when the path is not found' do
+      let(:path) { './a/missing/path' }
+
+      it { expect { migrated_files }.to raise_error(ArgumentError) }
+    end
+  end
+end

data/spec/unit/configuration_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe VersionCake::Configuration do
+  subject(:config) do
+    config = described_class.new
+    if supported_versions
+      config.supported_version_numbers = supported_versions
+    end
+    config
+  end
+
+  context '#supported_version_numbers' do
+    context 'by default' do
+      let(:supported_versions) { nil }
+
+      it 'is a logical set of version numbers' do
+        expect(config.supported_version_numbers).to eq (1..10).to_a.reverse
+      end
+    end
+
+    context 'when set with a range' do
+      let(:supported_versions) { (1..7) }
+
+      it { expect(config.supported_version_numbers).to eq [7,6,5,4,3,2,1] }
+    end
+
+    context 'when set with an unordered array' do
+      let(:supported_versions) { [2,4,1,5,3,6,7] }
+
+      it { expect(config.supported_version_numbers).to eq [7,6,5,4,3,2,1] }
+    end
+
+    context 'when set with a single value' do
+      let(:supported_versions) { 19 }
+
+      it { expect(config.supported_version_numbers).to eq [19] }
+    end
+  end
+
+  context '#supports_version?' do
+    let(:supported_versions) { (1..7) }
+
+    it 'is true for all supported versions' do
+      config.supported_version_numbers.each do |supported_version|
+        expect(config.supports_version?(supported_version)).to be_truthy
+      end
+    end
+
+    it 'is false for other versions' do
+      [-2,-1,0,8,9,10].each do |unsupported_version|
+        expect(config.supports_version?(unsupported_version)).to be_falsey
+      end
+    end
+  end
+
+  context '#latest_version' do
+    let(:supported_versions) { [4,1,3,9,2,54] }
+
+    it { expect(config.latest_version).to eq 54 }
+  end
+end

data/spec/unit/strategies/extraction_strategy_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+# TODO: make better!!!
+describe VersionCake::ExtractionStrategy do
+  it "execute is required for a strategy" do
+    expect do
+      VersionCake::ExtractionStrategy.new.execute("request")
+    end.to raise_error(Exception)
+  end
+
+  it "custom strategy result will be converted to integer" do
+    class TestStrategy < VersionCake::ExtractionStrategy
+      def execute(request); "123"; end
+    end
+
+    expect(TestStrategy.new.extract("request")).to eq 123
+  end
+
+  it "custom strategy result will be returned" do
+    class TestStrategy < VersionCake::ExtractionStrategy
+      def execute(request); 123; end
+    end
+    expect(TestStrategy.new.extract("request")).to eq 123
+  end
+
+  it "custom strategy will fail if it returns unexpected result" do
+    class TestStrategy < VersionCake::ExtractionStrategy
+      def execute(request); Object.new; end
+    end
+    expect { TestStrategy.new.extract("request") }.to raise_error(Exception)
+  end
+
+  context '#query_parameter' do
+    subject(:lookedup_strategy) { VersionCake::ExtractionStrategy.lookup(:query_parameter) }
+
+    it { expect(lookedup_strategy.class).to eq VersionCake::QueryParameterStrategy }
+  end
+
+  it "it creates a custom strategy for a proc" do
+    strategy = VersionCake::ExtractionStrategy.lookup(lambda{|req|})
+    expect(strategy.class).to eq VersionCake::CustomStrategy
+  end
+
+  it "it wraps a custom object" do
+    class FakeStrategy
+      def execute(request);end
+    end
+    strategy = VersionCake::ExtractionStrategy.lookup(FakeStrategy.new)
+    expect(strategy.class).to eq VersionCake::CustomStrategy
+  end
+
+  it "it calls a custom objects execute method" do
+    class FakeStrategy
+      def execute(request); 9999; end
+    end
+    strategy = VersionCake::ExtractionStrategy.lookup(FakeStrategy.new)
+    expect(strategy.execute(nil)).to eq 9999
+  end
+
+  it "it fails to create a custom strategy for a proc with no parameters" do
+    expect do
+      VersionCake::ExtractionStrategy.lookup(lambda{})
+    end.to raise_error(Exception)
+  end
+
+  it "it raises error when no strategy is found" do
+    expect do
+      VersionCake::ExtractionStrategy.lookup(:fake_extraction)
+    end.to raise_error(Exception)
+  end
+end

data/spec/unit/strategies/http_accept_parameter_strategy_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe VersionCake::HttpAcceptParameterStrategy do
+  let(:strategy) { VersionCake::HttpAcceptParameterStrategy.new }
+  subject { strategy.extract(request) }
+
+  context "a request with an HTTP_ACCEPT version retrieves the version" do
+    let(:request) { instance_double('Request', env: \
+      {'HTTP_ACCEPT' => 'application/xml; api_version=11'}) }
+
+    it { is_expected.to eq 11 }
+  end
+
+  context "a request without an HTTP_ACCEPT version returns nil" do
+    let(:request) { instance_double('Request', env: \
+      {'HTTP_ACCEPT' => 'text/x-dvi; q=.8; mxb=100000; mxt=5.0, text/x-c'}) }
+
+    it { is_expected.to be_nil }
+  end
+end

data/spec/unit/strategies/http_header_strategy_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe VersionCake::HttpHeaderStrategy do
+  let(:strategy) { VersionCake::HttpHeaderStrategy.new }
+  subject { strategy.extract(request) }
+
+  context "a request with an HTTP_X_API_VERSION retrieves the version" do
+    let(:request) { instance_double('Request', env: {'HTTP_API_VERSION' => '11'}) }
+
+    it { is_expected.to eq 11 }
+  end
+
+  context "a request without an HTTP_X_API_VERSION returns nil" do
+    let(:request) { instance_double('Request', \
+      env: {'HTTP_ACCEPT' => 'text/x-dvi; q=.8; mxb=100000; mxt=5.0, text/x-c'}) }
+
+    it { is_expected.to be_nil }
+  end
+end

data/spec/unit/strategies/path_parameter_strategy_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe VersionCake::PathParameterStrategy do
+  let(:strategy) { VersionCake::PathParameterStrategy.new }
+  subject { strategy.extract(request) }
+
+  context "a request with an api_version path parameter retrieves the version" do
+    let(:request) { instance_double('Request', path: 'api/v11/parameter') }
+
+    it { is_expected.to eq 11 }
+  end
+
+  context "a request without an api_version path parameter returns nil" do
+    let(:request) { instance_double('Request', path: 'parameter/parameter') }
+
+    it { is_expected.to be_nil }
+  end
+end

data/spec/unit/strategies/query_parameter_strategy_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe VersionCake::QueryParameterStrategy do
+  let(:strategy) { VersionCake::QueryParameterStrategy.new }
+  subject { strategy.extract(request) }
+
+  context "a request with an api_version parameter retrieves the version" do
+    let(:request) { instance_double('Request', GET: {'api_version' => '11', 'other' => 'parameter'}) }
+
+    it { is_expected.to eq 11 }
+  end
+
+  context "a request with an Integer api_version parameter retrieves the version" do
+    let(:request) { instance_double('Request', GET: {'api_version' => 11, 'other' => 'parameter'}) }
+
+    it { is_expected.to eq 11 }
+  end
+
+  context "a request without an api_version parameter returns nil" do
+    let(:request) { instance_double('Request', GET: {'other' => 'parameter', 'another' => 'parameter'}) }
+
+    it { is_expected.to be_nil }
+  end
+end

data/spec/unit/strategies/request_parameter_strategy_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe VersionCake::RequestParameterStrategy do
+  let(:strategy) { VersionCake::RequestParameterStrategy.new }
+  subject { strategy.extract(request) }
+
+  context "a request with an api_version request parameter retrieves the version" do
+    let(:request) { instance_double('Request', POST: {'api_version' => '11', 'other' => 'parameter'}) }
+
+    it { is_expected.to eq 11 }
+  end
+
+  context "a request without an api_version request parameter returns nil" do
+    let(:request) { instance_double('Request', POST: \
+      {'other' => 'parameter', 'another' => 'parameter'}) }
+
+    it { is_expected.to be_nil }
+  end
+end

data/spec/unit/version_checker_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe VersionCake::VersionChecker do
+  let(:resource) do
+    double(
+      supported_versions: [5,6],
+      deprecated_versions: [4],
+      obsolete_versions: [2,3],
+    )
+  end
+  let(:version) { }
+  subject do
+    checker = VersionCake::VersionChecker.new(resource, version)
+    checker.execute
+  end
+
+  describe '#execute' do
+    context 'when no version is passed in' do
+      let(:version) { nil }
+
+      it { is_expected.to eq :no_version }
+    end
+
+    context 'when the version is a supported version' do
+      let(:version) { 5 }
+
+      it { is_expected.to eq :supported }
+    end
+
+    context 'when the version is an obsolete version' do
+      let(:version) { 3 }
+
+      it { is_expected.to eq :obsolete }
+    end
+
+    context 'when the version is a deprecated version' do
+      let(:version) { 4 }
+
+      it { is_expected.to eq :deprecated }
+    end
+
+    context 'when the version is greater than the supported versions' do
+      let(:version) { 7 }
+
+      it { is_expected.to eq :version_too_high }
+    end
+
+    context 'when the version is less than the supported versions' do
+      let(:version) { 1 }
+
+      it { is_expected.to eq :version_too_low }
+    end
+
+    context 'when the version is of a strange format' do
+      let(:version) { '1' }
+
+      it { is_expected.to eq :invalid_format }
+    end
+  end
+end

data/spec/unit/version_context_service_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe VersionCake::VersionContextService do
+
+  let(:resource_user) do
+    double('user_resource',
+      uri: %r{user},
+      supported_versions: [5,6,7],
+      deprecated_versions: [3,4],
+      obsolete_versions: [1,2]
+    )
+  end
+  let(:resource_all) do
+    double('default',
+         uri: %r{.*},
+         supported_versions: [6,7],
+         deprecated_versions: [3,4,5],
+         obsolete_versions: [1,2]
+     )
+  end
+  let(:config) do
+    double('config',
+      versioned_resources: [resource_user, resource_all],
+      missing_version: 9,
+      extraction_strategies: [
+        VersionCake::CustomStrategy.new(lambda{ |req| req.version })
+      ]
+    )
+  end
+  let(:service) { described_class.new(config) }
+
+  describe '#create_context_from_request' do
+    let(:request) { double(version: 5, path: 'users/123') }
+    subject(:context) { service.create_context_from_request(request) }
+
+    it { expect(context.version).to eq 5 }
+    it { expect(context.resource).to eq resource_user }
+    it { expect(context.result).to eq :supported }
+
+    context 'for a deprecated version' do
+      let(:request) { double(version: 5, path: 'posts/123') }
+
+      it { expect(context.version).to eq 5 }
+      it { expect(context.resource).to eq resource_all }
+      it { expect(context.result).to eq :deprecated }
+    end
+
+    context 'for an obsolete version' do
+      let(:request) { double(version: 2, path: 'users/123') }
+
+      it { expect(context.version).to eq 2 }
+      it { expect(context.resource).to eq resource_user }
+      it { expect(context.result).to eq :obsolete }
+    end
+  end
+
+  describe '#create_context' do
+    let(:uri) { 'users/21' }
+    let(:version) { 5 }
+    subject(:context) { service.create_context(uri, version) }
+
+    it { expect(context.version).to eq 5 }
+    it { expect(context.resource).to eq resource_user }
+    it { expect(context.result).to eq :supported }
+
+    context 'for a deprecated version' do
+      let(:uri) { 'posts/21' }
+      let(:version) { 5 }
+
+      it { expect(context.version).to eq 5 }
+      it { expect(context.resource).to eq resource_all }
+      it { expect(context.result).to eq :deprecated }
+    end
+
+    context 'for an obsolete version' do
+      let(:uri) { 'posts/21' }
+      let(:version) { 2 }
+
+      it { expect(context.version).to eq 2 }
+      it { expect(context.resource).to eq resource_all }
+      it { expect(context.result).to eq :obsolete }
+    end
+  end
+end