versioncake 2.5.0 → 3.0.0

data/lib/versioncake/versioned_resource.rb

@@ -0,0 +1,14 @@
+module VersionCake
+  class VersionedResource
+    attr_reader :uri, :supported_versions, :deprecated_versions, :obsolete_versions
+
+    def initialize(uri, obsolete_versions, deprecated_versions, supported_versions)
+      @uri, @supported_versions, @deprecated_versions, @obsolete_versions =
+        uri, supported_versions, deprecated_versions, obsolete_versions
+    end
+
+    def latest_version
+      @supported_versions.last
+    end
+  end
+end

data/lib/versioncake/view_additions.rb

@@ -3,17 +3,17 @@ require 'action_view'
 # register an addition detail for the lookup context to understand,
 # this will allow us to have the versions available upon lookup in
 # the resolver.
-ActionView::LookupContext.register_detail(:versions){ VersionCake::Railtie.config.versioncake.supported_versions }
+ActionView::LookupContext.register_detail(:versions){ [] }
 
 ActionView::PathResolver.class_eval do
   # not sure why we are doing this yet, but looks like a good idea
-  if ActionPack::VERSION::MAJOR >= 4 && ActionPack::VERSION::MINOR >= 1
+  if ActionPack::VERSION::MAJOR >= 4 && ActionPack::VERSION::MINOR >= 1 || ActionPack::VERSION::MAJOR >= 5
     ActionView::PathResolver::EXTENSIONS.replace({
-                                                     :locale => ".",
-                                                     :formats => ".",
-                                                     :versions => ".",
-                                                     :variants => "+",
-                                                     :handlers => "."
+                                                     locale: ".",
+                                                     formats: ".",
+                                                     versions: ".",
+                                                     variants: "+",
+                                                     handlers: "."
                                                  })
 
     ActionView::PathResolver::DEFAULT_PATTERN.replace ":prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:versions,}{.:handlers,}"

data/spec/fixtures/test_cases.yml

@@ -0,0 +1,45 @@
+# http_header_strategy
+- request:
+    headers:
+      HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=1"
+  response: "1"
+
+- request:
+    headers:
+      HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=2"
+  response: "2"
+
+# request_parameter_strategy
+- request:
+    method: post
+    params:
+      api_version: "1"
+  response: "1"
+
+- request:
+    method: post
+    params:
+      api_version: "2"
+  response: "2"
+
+# query_parameter_strategy
+- request:
+    params:
+      api_version: "1"
+  response: "1"
+
+- request:
+    params:
+      api_version: "2"
+  response: "2"
+
+# http_header_strategy
+- request:
+    headers:
+      HTTP_API_VERSION: "1"
+  response: "1"
+
+- request:
+    headers:
+      HTTP_API_VERSION: "2"
+  response: "2"

data/spec/integration/controller/renders_controller_spec.rb

@@ -0,0 +1,73 @@
+require './spec/rails_helper'
+
+describe RendersController, type: :controller do
+  let(:request_options) { {} }
+  subject(:response_body) { get :index, request_options; response.body }
+
+  context '#index' do
+    render_views
+    before { set_request_version 'renders', request_version }
+    before { response_body }
+
+    context 'when requesting the non latest version' do
+      let(:request_version) { 1 }
+
+      it { expect(controller.request_version).to eq 1 }
+      it { expect(controller.is_latest_version?).to be_falsey }
+      it { expect(controller.is_deprecated_version?).to be_falsey }
+      it { expect(response_body).to eq 'template v1' }
+    end
+
+    context 'with explicity requesting the latest version' do
+      let(:request_version) { 5 }
+
+      it { expect(controller.request_version).to eq 5 }
+      it { expect(controller.is_latest_version?).to be_truthy }
+      it { expect(controller.is_deprecated_version?).to be_falsey }
+      it { expect(response_body).to eq 'template v2' }
+    end
+
+    context 'when requesting a deprecated version' do
+      let(:request_version) { 4 }
+
+      it { expect(controller.request_version).to eq 4 }
+      it { expect(controller.is_latest_version?).to be_falsey }
+      it { expect(controller.is_deprecated_version?).to be_truthy }
+      it { expect(response_body).to eq 'template v2' }
+    end
+
+    context '#set_version' do
+      let(:request_options) { { 'override_version' => 2 } }
+      let(:request_version) { 3 }
+
+      it { expect(controller.request_version).to eq 2 }
+      it { expect(response_body).to eq 'template v2' }
+    end
+  end
+
+  context 'errors' do
+    context 'with a version larger than the supported versions' do
+      before { set_version_context :version_too_high }
+
+      it { expect { response_body }.to raise_error VersionCake::UnsupportedVersionError }
+    end
+
+    context 'with a version lower than the supported versions' do
+      before { set_version_context :version_too_low }
+
+      it { expect { response_body }.to raise_error VersionCake::UnsupportedVersionError }
+    end
+
+    context 'with an invalid version' do
+      before { set_version_context :version_invalid }
+
+      it { expect { response_body }.to raise_error VersionCake::UnsupportedVersionError }
+    end
+
+    context 'with an obsolete version' do
+      before { set_version_context :obsolete }
+
+      it { expect { response_body }.to raise_error VersionCake::ObsoleteVersionError }
+    end
+  end
+end

data/spec/integration/controller/unversioned_controller_spec.rb

@@ -0,0 +1,12 @@
+require './spec/rails_helper'
+
+describe UnversionedController, type: :controller do
+  subject(:response) { get :index }
+
+  context '#index' do
+    render_views
+
+    it { expect(response).to be_success }
+    it { expect(response.body).to eq 'unversioned index' }
+  end
+end

data/spec/integration/rack/middleware_regression_spec.rb

@@ -0,0 +1,41 @@
+require './spec/rails_helper'
+require 'yaml'
+
+describe VersionCake::Rack::Middleware do
+  let(:app) do
+    rack = Rack::Builder.new do
+      use VersionCake::Rack::Middleware
+      run lambda { |env| [ 200, {}, [ env['versioncake.context'].version ] ] }
+    end
+    Rack::MockRequest.new(rack)
+  end
+
+  test_cases = YAML.load(File.open('./spec/fixtures/test_cases.yml'))
+  test_cases.each do |test_case|
+    context 'for a test case' do
+
+
+      let(:data) { test_case['request'] || {} }
+      let(:method) { (data['method'] || 'get').to_sym }
+      let(:headers) { data['headers'] || {} }
+      let(:params) { data['params'] || {} }
+      let(:test_response) { test_case['response'] }
+
+      it "test yml test cases" do
+        begin
+          response = app.request(method, '/renders', headers.merge(params: params))
+          expect(response.body).to(eq(test_response), custom_message(headers, params, method, response.body, test_response))
+        rescue => e
+          raise custom_message(headers, params, method, response.body, test_response) + ", but it failed with an exception '#{e.message}'"
+        end
+      end
+    end
+  end
+
+  def custom_message(headers, params, method, actual_response, expected_response)
+    data = []
+    data << "headers:#{headers}" if headers
+    data << "params:#{params}" if params
+    "Expected #{data.join(',')} with method #{method} to yield '#{expected_response}', but got '#{actual_response}'"
+  end
+end

data/spec/integration/view/render_spec.rb

@@ -0,0 +1,33 @@
+require './spec/rails_helper'
+
+describe ActionView::Base do
+  let(:path) { ActionView::FileSystemResolver.new('./spec/fixtures') }
+  let(:view_paths) { ActionView::PathSet.new([path]) }
+  let(:view) { ActionView::Base.new(view_paths) }
+  let(:version_override) { nil }
+  subject { view.render(template: 'templates/versioned', versions: version_override) }
+
+  context 'with a 0 version' do
+    before { view.lookup_context.versions = [:v0] }
+
+    it { is_expected.to eq 'template' }
+  end
+
+  context 'with the version override set' do
+    let(:version_override) { :v1 }
+
+    it { is_expected.to eq 'template v1' }
+  end
+
+  context 'with an older version in the lookup context' do
+    before { view.lookup_context.versions = [:v2] }
+
+    it { is_expected.to eq 'template v2' }
+  end
+
+  context 'with a v4 requested, but only highest templates is v3' do
+    before { view.lookup_context.versions = [:v4,:v3,:v2,:v1] }
+
+    it { is_expected.to eq 'template v3' }
+  end
+end

data/spec/integration/view/view_additions_spec.rb

@@ -0,0 +1,51 @@
+require './spec/rails_helper'
+
+describe ActionView::PathResolver do
+  let(:resolver) { ActionView::PathResolver.new }
+
+  context '#extract_handler_and_format' do
+    subject(:template_format) do
+      _, format = resolver.extract_handler_and_format("application.#{template_extension}", nil)
+      format.to_s
+    end
+
+    context 'when only handler and format are present' do
+      let(:template_extension) { 'html.erb' }
+
+      it { expect(template_format).to eq 'text/html' }
+    end
+
+    context 'when handler, format and version are present' do
+      let(:template_extension) { 'json.v1.jbuilder' }
+
+      it { expect(template_format).to eq 'application/json' }
+    end
+
+    context 'when handler, format and locale are present' do
+      let(:template_extension) { 'en.json.jbuilder' }
+
+      it { expect(template_format).to eq 'application/json' }
+    end
+
+    context 'when handler, format, locale and version are present' do
+      let(:template_extension) { 'en.json.v1.jbuilder' }
+
+      it { expect(template_format).to eq 'application/json' }
+    end
+
+    context 'when in Rails >=4.1' do
+      before do
+        unless (ActionPack::VERSION::MAJOR == 4 && ActionPack::VERSION::MINOR >= 1) ||
+            ActionPack::VERSION::MAJOR > 5
+          skip('Template variants are only available in Rails >=4.1')
+        end
+      end
+
+      context 'when handler, format, variant and version are present' do
+        let(:template_extension) { 'application.json+tablet.v1.jbuilder' }
+
+        it { expect(template_format).to eq 'application/json' }
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,41 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV['RAILS_ENV'] ||= 'test'
+require File.expand_path('../test_app/config/environment.rb', __FILE__)
+require 'rails/all'
+
+require 'rspec/rails'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+# Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  # ## Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  # config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = false # false - no active record
+
+  # If true, the base class of anonymous controllers will be inferred
+  # automatically. This will be the default behavior in future versions of
+  # rspec-rails.
+  config.infer_base_class_for_anonymous_controllers = false
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+  config.include VersionCake::TestHelpers, type: :controller
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'coveralls'
+Coveralls.wear!
+require 'versioncake'
+
+# We have to occasionally require test-unit because it was removed as a core
+# dependency, so have to explicitly disable it from running automatically
+Test::Unit::AutoRunner.need_auto_run = false if defined?(Test::Unit::AutoRunner)
+
+def capture_stdout(flag=true)
+  if flag
+    out     = StringIO.new
+    $stdout = out
+  else
+    $stdout = STDOUT
+  end
+end
+
+# Turn off stdout for all specs
+def quiet_stdout
+  around(:example) do |example|
+    capture_stdout true
+    example.run
+    capture_stdout false
+  end
+end

data/spec/test_app/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+RendersTest::Application.load_tasks

data/spec/test_app/app/controllers/unversioned_controller.rb

@@ -0,0 +1,6 @@
+require "action_controller"
+require "action_controller/base"
+
+class UnversionedController < ActionController::Base
+  def index;end
+end

data/spec/test_app/app/views/renders/index.html.erb

@@ -0,0 +1 @@
+base template

data/spec/test_app/app/views/unversioned/index.html.erb

@@ -0,0 +1 @@
+unversioned index

data/spec/test_app/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run RendersTest::Application

data/{test → spec/test_app}/config/application.rb

@@ -1,6 +1,4 @@
-require "action_controller/railtie"
-require "active_support/railtie"
-
+require 'rails/all'
 # Auto-require default libraries and those for the current Rails environment.
 Bundler.require :default, Rails.env
 
@@ -11,8 +9,8 @@ module RendersTest
     config.eager_load = false
 
     config.active_support.deprecation = :stderr
-
-    config.versioncake.supported_version_numbers = (1..3)
-    config.versioncake.extraction_strategy = [:http_header, :http_accept_parameter, :query_parameter, :request_parameter]
+    config.generators do |g|
+      g.test_framework :rspec
+    end
   end
 end