acts_as_api 0.4.4 → 1.0.0

data/spec/shared_engine/app/controllers/shared_engine/users_controller.rb

@@ -1,22 +1,21 @@
 module SharedEngine
   class UsersController < SharedEngine::ApplicationController
-
     def index
       @users = User.all.sort_by(&:first_name)
 
       respond_to do |format|
-        format.xml  { render_for_api params[:api_template].to_sym, :xml => @users, :root => :users }
-        format.json { render_for_api params[:api_template].to_sym, :json => @users, :root => :users }
+        format.xml  { render_for_api params[:api_template].to_sym, xml: @users, root: :users }
+        format.json { render_for_api params[:api_template].to_sym, json: @users, root: :users }
       end
     end
 
     def index_meta
       @users = User.all.to_a
-      meta_hash = { :page => 1, :total => 999 }
+      meta_hash = { page: 1, total: 999 }
 
       respond_to do |format|
-        format.xml  { render_for_api params[:api_template].to_sym, :xml => @users, :root => :users,  :meta => meta_hash }
-        format.json { render_for_api params[:api_template].to_sym, :json => @users, :root => :users, :meta => meta_hash }
+        format.xml  { render_for_api params[:api_template].to_sym, xml: @users, root: :users,  meta: meta_hash }
+        format.json { render_for_api params[:api_template].to_sym, json: @users, root: :users, meta: meta_hash }
       end
     end
 
@@ -28,8 +27,8 @@ module SharedEngine
       end
 
       respond_to do |format|
-        format.xml  { render_for_api params[:api_template].to_sym, :xml => @users }
-        format.json { render_for_api params[:api_template].to_sym, :json => @users }
+        format.xml  { render_for_api params[:api_template].to_sym, xml: @users }
+        format.json { render_for_api params[:api_template].to_sym, json: @users }
       end
     end
 
@@ -38,38 +37,37 @@ module SharedEngine
 
       respond_to do |format|
         # :root => :user is only used here because we need it for the node name of the MongoUser model
-        format.xml  { render_for_api params[:api_template].to_sym, :xml => @user, :root => :user }
-        format.json { render_for_api params[:api_template].to_sym, :json => @user, :root => :user }
+        format.xml  { render_for_api params[:api_template].to_sym, xml: @user, root: :user }
+        format.json { render_for_api params[:api_template].to_sym, json: @user, root: :user }
       end
     end
 
     def show_meta
       @user = User.find(params[:id])
-      meta_hash = { :page => 1, :total => 999 }
+      meta_hash = { page: 1, total: 999 }
       respond_to do |format|
         # :root => :user is only used here because we need it for the node name of the MongoUser model
-        format.xml  { render_for_api params[:api_template].to_sym, :xml => @user, :root => :user }
-        format.json { render_for_api params[:api_template].to_sym, :json => @user, :root => :user, :meta => meta_hash }
+        format.xml  { render_for_api params[:api_template].to_sym, xml: @user, root: :user }
+        format.json { render_for_api params[:api_template].to_sym, json: @user, root: :user, meta: meta_hash }
       end
     end
 
     def show_default
       @user = User.find(params[:id])
       respond_to do |format|
-        format.xml { render :xml => @user }
-        format.json { render :json => @user }
+        format.xml  { render xml: @user }
+        format.json { render json: @user }
       end
     end
 
     def show_prefix_postfix
       @user = User.find(params[:id])
-      template = {:template => params[:api_template], :prefix => params[:api_prefix], :postfix => params[:api_postfix]}
+      template = { template: params[:api_template], prefix: params[:api_prefix], postfix: params[:api_postfix] }
       respond_to do |format|
         # :root => :user is only used here because we need it for the node name of the MongoUser model
-        format.xml { render_for_api template, :xml => @user, :root => :user }
-        format.json { render_for_api template, :json => @user, :root => :user }
+        format.xml  { render_for_api template, xml: @user, root: :user }
+        format.json { render_for_api template, json: @user, root: :user }
       end
     end
-
   end
 end

data/spec/shared_engine/app/models/plain_object.rb

@@ -1,6 +1,8 @@
-class PlainObject < Struct.new(:first_name, :last_name, :age, :active)
+class PlainObject
   extend ActsAsApi::Base
 
+  attr_accessor :first_name, :last_name, :age, :active
+
   def initialize(opts)
     opts.each do |k, v|
       send("#{k}=", v)

data/spec/shared_engine/app/models/user_template.rb

@@ -12,11 +12,11 @@ module UserTemplate
     end
 
     api_accessible :rename_last_name do |t|
-      t.add :last_name, :as => :family_name
+      t.add :last_name, as: :family_name
     end
 
     api_accessible :rename_full_name do |t|
-      t.add :full_name, :as => :other_full_name
+      t.add :full_name, as: :other_full_name
     end
 
     api_accessible :with_former_value do |t|
@@ -24,19 +24,19 @@ module UserTemplate
       t.add :last_name
     end
 
-    api_accessible :age_and_first_name, :extend => :with_former_value do |t|
+    api_accessible :age_and_first_name, extend: :with_former_value do |t|
       t.add :age
       t.remove :last_name
     end
 
     api_accessible :calling_a_proc do |t|
-      t.add Proc.new{|model| model.full_name.upcase  }, :as => :all_caps_name
-      t.add Proc.new{|model| Time.now.class.to_s  }, :as => :without_param
+      t.add proc { |model| model.full_name.upcase }, as: :all_caps_name
+      t.add proc { |_| Time.now.class.to_s }, as: :without_param
     end
 
     api_accessible :calling_a_lambda do |t|
-      t.add lambda{|model| model.full_name.upcase  }, :as => :all_caps_name
-      t.add lambda{|model| Time.now.class.to_s  }, :as => :without_param
+      t.add ->(model) { model.full_name.upcase }, as: :all_caps_name
+      t.add ->(_) { Time.now.class.to_s }, as: :without_param
     end
     api_accessible :include_tasks do |t|
       t.add :tasks
@@ -48,19 +48,19 @@ module UserTemplate
 
     api_accessible :other_sub_template do |t|
       t.add :first_name
-      t.add :tasks, :template => :other_template
+      t.add :tasks, template: :other_template
     end
 
     api_accessible :include_completed_tasks do |t|
-      t.add "tasks.completed.all", :as => :completed_tasks
+      t.add 'tasks.completed.all', as: :completed_tasks
     end
 
     api_accessible :sub_node do |t|
-      t.add Hash[:foo => :say_something], :as => :sub_nodes
+      t.add Hash[foo: :say_something], as: :sub_nodes
     end
 
     api_accessible :nested_sub_node do |t|
-      t.add Hash[:foo, Hash[:bar, :last_name]], :as => :sub_nodes
+      t.add Hash[:foo, Hash[:bar, :last_name]], as: :sub_nodes
     end
 
     api_accessible :nested_sub_hash do |t|
@@ -69,46 +69,46 @@ module UserTemplate
 
     api_accessible :if_over_thirty do |t|
       t.add :first_name
-      t.add :last_name, :if => :over_thirty?
+      t.add :last_name, if: :over_thirty?
     end
 
     api_accessible :if_returns_nil do |t|
       t.add :first_name
-      t.add :last_name, :if => :return_nil
+      t.add :last_name, if: :return_nil
     end
 
     api_accessible :if_over_thirty_proc do |t|
       t.add :first_name
-      t.add :last_name, :if => lambda{|u| u.over_thirty? }
+      t.add :last_name, if: ->(model) { model.over_thirty? }
     end
 
     api_accessible :if_returns_nil_proc do |t|
       t.add :first_name
-      t.add :last_name, :if => lambda{|u| nil }
+      t.add :last_name, if: ->(_) { nil }
     end
 
     api_accessible :unless_under_thirty do |t|
       t.add :first_name
-      t.add :last_name, :unless => :under_thirty?
+      t.add :last_name, unless: :under_thirty?
     end
 
     api_accessible :unless_returns_nil do |t|
       t.add :first_name
-      t.add :last_name, :unless => :return_nil
+      t.add :last_name, unless: :return_nil
     end
 
     api_accessible :unless_under_thirty_proc do |t|
       t.add :first_name
-      t.add :last_name, :unless => lambda{|u| u.under_thirty? }
+      t.add :last_name, unless: ->(model) { model.under_thirty? }
     end
 
     api_accessible :unless_returns_nil_proc do |t|
       t.add :first_name
-      t.add :last_name, :unless => lambda{|u| nil }
+      t.add :last_name, unless: ->(_) { nil }
     end
 
     api_accessible :with_prefix_name_only do |t|
-      t.add lambda{|model| 'true' }, :as => :prefix
+      t.add ->(_) { 'true' }, as: :prefix
       t.add :first_name
       t.add :last_name
     end
@@ -116,17 +116,17 @@ module UserTemplate
     api_accessible :name_only_with_postfix do |t|
       t.add :first_name
       t.add :last_name
-      t.add lambda{|model| 'true' }, :as => :postfix
+      t.add ->(_) { 'true' }, as: :postfix
     end
 
     api_accessible :with_prefix_name_only_with_postfix do |t|
-      t.add lambda{|model| 'true' }, :as => :prefix
+      t.add ->(_) { 'true' }, as: :prefix
       t.add :first_name
       t.add :last_name
-      t.add lambda{|model| 'true' }, :as => :postfix
+      t.add ->(_) { 'true' }, as: :postfix
     end
 
-    def before_api_response(api_response)
+    def before_api_response(_api_response)
       @before_api_response_called = true
     end
 
@@ -134,7 +134,7 @@ module UserTemplate
       !!@before_api_response_called
     end
 
-    def after_api_response(api_response)
+    def after_api_response(_api_response)
       @after_api_response_called = true
     end
 
@@ -146,9 +146,8 @@ module UserTemplate
       @skip_api_response = should_skip
     end
 
-    def around_api_response(api_response)
-      @skip_api_response ? { :skipped => true } : yield
+    def around_api_response(_api_response)
+      @skip_api_response ? { skipped: true } : yield
     end
-
   end
-end
+end

data/spec/shared_engine/lib/shared_engine.rb

@@ -1,4 +1,4 @@
-require "shared_engine/engine"
+require 'shared_engine/engine'
 
 module SharedEngine
 end

data/spec/shared_engine/lib/shared_engine/version.rb

@@ -1,3 +1,3 @@
 module SharedEngine
-  VERSION = "0.0.1"
+  VERSION = '0.0.1'.freeze
 end

data/spec/shared_engine/shared_engine.gemspec

@@ -1,21 +1,19 @@
-$:.push File.expand_path("../lib", __FILE__)
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
 
 # Maintain your gem's version:
-require "shared_engine/version"
+require 'shared_engine/version'
 
 # Describe your gem and declare its dependencies:
 Gem::Specification.new do |s|
-  s.name        = "shared_engine"
+  s.name        = 'shared_engine'
   s.version     = SharedEngine::VERSION
-  s.authors     = ["Your name"]
-  s.email       = ["Your email"]
-  s.summary     = "Summary of SharedEngine."
-  s.description = "Description of SharedEngine."
+  s.authors     = ['Your name']
+  s.email       = ['Your email']
+  s.summary     = 'Summary of SharedEngine.'
+  s.description = 'Description of SharedEngine.'
 
-  s.files = Dir["{app,config,db,lib}/**/*"] + ["MIT-LICENSE", "Rakefile", "README.rdoc"]
+  s.files = Dir['{app,config,db,lib}/**/*'] + ['MIT-LICENSE', 'Rakefile', 'README.rdoc']
 
-  s.add_dependency "rails", "~> 5.0.0.1"
-  # s.add_dependency "jquery-rails"
-
-  s.add_development_dependency "sqlite3"
+  s.add_dependency 'rails', '~> 5.0.0.1'
+  s.add_development_dependency 'sqlite3'
 end

data/spec/spec_helper.rb

@@ -1,24 +1,16 @@
-ENV["RAILS_ENV"] = "test"
+ENV['RAILS_ENV'] = 'test'
 
 if ENV['ACTS_AS_API_ORM'] == 'active_record'
-  require "active_record_dummy/config/environment"
+  require 'active_record_dummy/config/environment'
 
-  load "#{Rails.root.to_s}/db/schema.rb" # use db agnostic schema by default
+  load "#{Rails.root}/db/schema.rb" # use db agnostic schema by default
   # ActiveRecord::Migrator.up('db/migrate') # use migrations
-
-
 elsif ENV['ACTS_AS_API_ORM'] == 'mongoid'
-
-  require "mongoid_dummy/config/environment"
-
+  require 'mongoid_dummy/config/environment'
 end
 
 require 'rspec/rails'
 
 # Requires supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
-Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|file| require file }
-
-RSpec.configure do |config|
-  config.expect_with(:rspec) { |c| c.syntax = :should }
-end
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each { |file| require file }

data/spec/support/api_test_helpers.rb

@@ -1,5 +1,4 @@
 module ApiTestHelpers
-
   def response_body
     response.body.strip
   end
@@ -15,7 +14,6 @@ module ApiTestHelpers
   def jsonp_callback(callback)
     /\A#{callback}\((.*),\s+\d{3}\)\z/
   end
-
 end
 
 RSpec.configure do |c|

data/spec/support/controller_examples.rb

@@ -1,128 +1,115 @@
-shared_examples_for "a controller with ActsAsApi responses" do
+shared_examples_for 'a controller with ActsAsApi responses' do
   include ApiTestHelpers
   routes { SharedEngine::Engine.routes }
 
   describe 'xml responses' do
-
     describe 'get all users' do
-
       before(:each) do
         get :index, format: 'xml', params: { api_template: :name_only }
       end
 
-      it "should have a root node named users" do
-        response_body.should have_selector("users")
+      it 'should have a root node named users' do
+        expect(response_body).to have_selector('users')
       end
 
-      it "should contain all users" do
-        response_body.should have_selector("users > user") do |users|
-          users.size.should eql(3)
+      it 'should contain all users' do
+        expect(response_body).to have_selector('users > user') do |users|
+          expect(users.size).to eql(3)
         end
       end
 
-      it "should contain the specified attributes" do
-        response_body.should have_selector("users > user > first-name")
-        response_body.should have_selector("users > user > last-name")
+      it 'should contain the specified attributes' do
+        expect(response_body).to have_selector('users > user > first-name')
+        expect(response_body).to have_selector('users > user > last-name')
       end
-
     end
 
     describe 'get a single user' do
-
       before(:each) do
         get :show, format: 'xml', params: { api_template: :name_only, id: @luke.id }
       end
 
-      it "should have a root node named user" do
-        response_body.should have_selector("user")
+      it 'should have a root node named user' do
+        expect(response_body).to have_selector('user')
       end
 
-      it "should contain the specified attributes" do
-        response_body.should have_selector("user > first-name")
-        response_body.should have_selector("user > last-name")
+      it 'should contain the specified attributes' do
+        expect(response_body).to have_selector('user > first-name')
+        expect(response_body).to have_selector('user > last-name')
       end
-
     end
   end
 
   describe 'json responses' do
-
     describe 'get all users' do
-
       before(:each) do
         get :index, format: 'json', params: { api_template: :name_only }
       end
 
-      it "should have a root node named users" do
-        response_body_json.should have_key("users")
+      it 'should have a root node named users' do
+        expect(response_body_json).to have_key('users')
       end
 
-      it "should contain all users" do
-        response_body_json["users"].should be_a(Array)
+      it 'should contain all users' do
+        expect(response_body_json['users']).to be_a(Array)
       end
 
-      it "should contain the specified attributes" do
-        response_body_json["users"].first.should have_key("first_name")
-        response_body_json["users"].first.should have_key("last_name")
+      it 'should contain the specified attributes' do
+        expect(response_body_json['users'].first).to have_key('first_name')
+        expect(response_body_json['users'].first).to have_key('last_name')
       end
 
-      it "should contain the specified values" do
-        response_body_json["users"].first["first_name"].should eql("Han")
-        response_body_json["users"].first["last_name"].should eql("Solo")
+      it 'should contain the specified values' do
+        expect(response_body_json['users'].first['first_name']).to eql('Han')
+        expect(response_body_json['users'].first['last_name']).to eql('Solo')
       end
-
     end
 
     describe 'get all users as a ActiveRecord::Relation (or similar chained) object, autodetecting the root node name' do
-
       before(:each) do
         get :index_relation, format: 'json', params: { api_template: :name_only }
       end
 
-      it "should have a root node named users" do
-        response_body_json.should have_key("users")
+      it 'should have a root node named users' do
+        expect(response_body_json).to have_key('users')
       end
 
-      it "should contain all users" do
-        response_body_json["users"].should be_a(Array)
+      it 'should contain all users' do
+        expect(response_body_json['users']).to be_a(Array)
       end
 
-      it "should contain the specified attributes" do
-        response_body_json["users"].first.should have_key("first_name")
-        response_body_json["users"].first.should have_key("last_name")
+      it 'should contain the specified attributes' do
+        expect(response_body_json['users'].first).to have_key('first_name')
+        expect(response_body_json['users'].first).to have_key('last_name')
       end
 
-      it "should contain the specified values" do
-        response_body_json["users"].first["first_name"].should eql("Han")
-        response_body_json["users"].first["last_name"].should eql("Solo")
+      it 'should contain the specified values' do
+        expect(response_body_json['users'].first['first_name']).to eql('Han')
+        expect(response_body_json['users'].first['last_name']).to eql('Solo')
       end
-
     end
 
     describe 'get a single user' do
-
       before(:each) do
         get :show, format: 'json', params: { api_template: :name_only, id: @luke.id }
       end
 
-      it "should have a root node named user" do
-        response_body_json.should have_key("user")
+      it 'should have a root node named user' do
+        expect(response_body_json).to have_key('user')
       end
 
-      it "should contain the specified attributes" do
-        response_body_json["user"].should have_key("first_name")
-        response_body_json["user"].should have_key("last_name")
+      it 'should contain the specified attributes' do
+        expect(response_body_json['user']).to have_key('first_name')
+        expect(response_body_json['user']).to have_key('last_name')
       end
 
-      it "should contain the specified values" do
-        response_body_json["user"]["first_name"].should eql("Luke")
-        response_body_json["user"]["last_name"].should eql("Skywalker")
+      it 'should contain the specified values' do
+        expect(response_body_json['user']['first_name']).to eql('Luke')
+        expect(response_body_json['user']['last_name']).to eql('Skywalker')
       end
-
     end
 
     describe 'get a single user with a nil profile' do
-
       before(:each) do
         Profile.acts_as_api
         Profile.api_accessible :include_profile do |t|
@@ -133,41 +120,36 @@ shared_examples_for "a controller with ActsAsApi responses" do
         get :show, format: 'json', params: { api_template: :include_profile, id: @han.id }
       end
 
-      it "should have a root node named user" do
-        response_body_json.should have_key("user")
+      it 'should have a root node named user' do
+        expect(response_body_json).to have_key('user')
       end
 
-      it "should contain the specified attributes" do
-        response_body_json["user"].should have(1).keys
-        response_body_json["user"].should have_key("profile")
+      it 'should contain the specified attributes' do
+        expect(response_body_json['user']).to have(1).keys
+        expect(response_body_json['user']).to have_key('profile')
       end
 
-      it "should contain the specified values" do
-        response_body_json["user"]["profile"].should be_nil
+      it 'should contain the specified values' do
+        expect(response_body_json['user']['profile']).to be_nil
       end
-
     end
 
     describe 'get a user without specifying an api template' do
-
       before(:each) do
         get :show_default, format: 'json', params: { id: @luke.id }
       end
 
-      it "should respond with HTTP 200" do
-        response.code.should == "200"
+      it 'should respond with HTTP 200' do
+        expect(response.code).to eq('200')
       end
 
-      it "should render the model with to_json" do
-        response.body.should == @luke.to_json
+      it 'should render the model with to_json' do
+        expect(response.body).to eq(@luke.to_json)
       end
-
     end
-
   end
 
   describe 'Rails 3 default style json responses' do
-
     before(:each) do
       @org_include_root_in_json_collections = ActsAsApi::Config.include_root_in_json_collections
       ActsAsApi::Config.include_root_in_json_collections = true
@@ -178,70 +160,64 @@ shared_examples_for "a controller with ActsAsApi responses" do
     end
 
     describe 'get all users' do
-
       before(:each) do
         get :index, format: 'json', params: { api_template: :name_only }
       end
 
-      it "should have a root node named users" do
-        response_body_json.should have_key("users")
+      it 'should have a root node named users' do
+        expect(response_body_json).to have_key('users')
       end
 
-      it "should contain all users" do
-        response_body_json["users"].should be_a(Array)
+      it 'should contain all users' do
+        expect(response_body_json['users']).to be_a(Array)
       end
 
-      it "should contain the specified attributes" do
-        response_body_json["users"].first["user"].should have_key("first_name")
-        response_body_json["users"].first["user"].should have_key("last_name")
+      it 'should contain the specified attributes' do
+        expect(response_body_json['users'].first['user']).to have_key('first_name')
+        expect(response_body_json['users'].first['user']).to have_key('last_name')
       end
 
-      it "contains the user root nodes" do
-        response_body_json["users"].collect(&:keys).flatten.uniq.should eql(["user"])
+      it 'contains the user root nodes' do
+        expect(response_body_json['users'].collect(&:keys).flatten.uniq).to eql(['user'])
       end
 
-      it "should contain the specified values" do
-        response_body_json["users"].first["user"]["first_name"].should eql("Han")
-        response_body_json["users"].first["user"]["last_name"].should eql("Solo")
+      it 'should contain the specified values' do
+        expect(response_body_json['users'].first['user']['first_name']).to eql('Han')
+        expect(response_body_json['users'].first['user']['last_name']).to eql('Solo')
       end
-
     end
 
     describe 'get a single user' do
-
       before(:each) do
         get :show, format: 'json', params: { api_template: :name_only, id: @luke.id }
       end
 
-      it "should have a root node named user" do
-        response_body_json.should have_key("user")
+      it 'should have a root node named user' do
+        expect(response_body_json).to have_key('user')
       end
 
-      it "should contain the specified attributes" do
-        response_body_json["user"].should have_key("first_name")
-        response_body_json["user"].should have_key("last_name")
+      it 'should contain the specified attributes' do
+        expect(response_body_json['user']).to have_key('first_name')
+        expect(response_body_json['user']).to have_key('last_name')
       end
 
-      it "should contain the specified values" do
-        response_body_json["user"]["first_name"].should eql("Luke")
-        response_body_json["user"]["last_name"].should eql("Skywalker")
+      it 'should contain the specified values' do
+        expect(response_body_json['user']['first_name']).to eql('Luke')
+        expect(response_body_json['user']['last_name']).to eql('Skywalker')
       end
     end
-
   end
 
   describe 'jsonp responses with callback' do
-
-    it "should be disabled by default" do
-      @callback = "mycallback"
+    it 'should be disabled by default' do
+      @callback = 'mycallback'
       get :index, format: 'json', params: { api_template: :name_only, callback: @callback }
-      response_body_jsonp(@callback).should be_nil
+      expect(response_body_jsonp(@callback)).to be_nil
     end
 
-    describe "enabled jsonp callbacks" do
-
+    describe 'enabled jsonp callbacks' do
       before(:each) do
-        @callback = "mycallback"
+        @callback = 'mycallback'
 
         User.acts_as_api do |config|
           config.allow_jsonp_callback = true
@@ -256,27 +232,23 @@ shared_examples_for "a controller with ActsAsApi responses" do
       end
 
       describe 'get all users' do
-
         before(:each) do
           get :index, format: 'json', params: { api_template: :name_only, callback: @callback }
         end
 
-        it "should wrap the response in the callback" do
-          response_body_jsonp(@callback).should_not be_nil
+        it 'should wrap the response in the callback' do
+          expect(response_body_jsonp(@callback)).not_to be_nil
         end
-
       end
 
       describe 'get a single user' do
-
         before(:each) do
           get :show, format: 'json', params: { api_template: :name_only, id: @luke.id, callback: @callback }
         end
 
-        it "should wrap the response in the callback" do
-          response_body_jsonp(@callback).should_not be_nil
+        it 'should wrap the response in the callback' do
+          expect(response_body_jsonp(@callback)).not_to be_nil
         end
-
       end
 
       describe 'Requesting the JSONP content as JavaScript' do
@@ -284,8 +256,8 @@ shared_examples_for "a controller with ActsAsApi responses" do
           get :index, format: :json, params: { api_template: :name_only, callback: @callback }
         end
 
-        it "should set the content type to JavaScript" do
-          response.content_type.should == Mime[:js]
+        it 'should set the content type to JavaScript' do
+          expect(response.content_type).to eq(Mime[:js])
         end
       end
     end
@@ -306,8 +278,8 @@ shared_examples_for "a controller with ActsAsApi responses" do
         get :index, format: 'json', params: { api_template: :name_only, callback: @callback }
       end
 
-      its "response has no named root node" do
-        response_body_json.should be_an(Array)
+      it 'response has no named root node' do
+        expect(response_body_json).to be_an(Array)
       end
     end
 
@@ -316,32 +288,31 @@ shared_examples_for "a controller with ActsAsApi responses" do
         get :show, format: 'json', params: { api_template: :name_only, id: @luke.id }
       end
 
-      its "response has no named root node" do
-        response_body_json.should be_a(Hash)
-        response_body_json.should have_key("first_name")
+      it 'response has no named root node' do
+        expect(response_body_json).to be_a(Hash)
+        expect(response_body_json.keys).to include('first_name')
       end
     end
   end
 
   describe 'pass meta information on rendering' do
-
     describe 'get all users' do
       before(:each) do
         get :index_meta, format: 'json', params: { api_template: :name_only }
       end
 
-      it "shows model response fields" do
-        response_body_json.should be_a(Hash)
-        response_body_json.should have_key("users")
-        response_body_json["users"].should be_an(Array)
+      it 'shows model response fields' do
+        expect(response_body_json).to be_a(Hash)
+        expect(response_body_json).to have_key('users')
+        expect(response_body_json['users']).to be_an(Array)
       end
 
-      it "shows page field" do
-        response_body_json.should have_key("page")
+      it 'shows page field' do
+        expect(response_body_json).to have_key('page')
       end
 
-      it "shows total field" do
-        response_body_json.should have_key("total")
+      it 'shows total field' do
+        expect(response_body_json).to have_key('total')
       end
     end
 
@@ -350,97 +321,81 @@ shared_examples_for "a controller with ActsAsApi responses" do
         get :show_meta, format: 'json', params: { api_template: :name_only, id: @luke.id }
       end
 
-      it "shows model response fields" do
-        response_body_json.should be_a(Hash)
-        response_body_json.should have_key("user")
+      it 'shows model response fields' do
+        expect(response_body_json).to be_a(Hash)
+        expect(response_body_json).to have_key('user')
       end
 
-      it "shows page field" do
-        response_body_json.should have_key("page")
+      it 'shows page field' do
+        expect(response_body_json).to have_key('page')
       end
 
-      it "shows total field" do
-        response_body_json.should have_key("total")
+      it 'shows total field' do
+        expect(response_body_json).to have_key('total')
       end
-
     end
   end
 
-
   describe 'api prefix' do
-
     describe 'get single user' do
-
       before(:each) do
         get :show_prefix_postfix, format: 'xml', params: { api_template: :name_only, api_prefix: :with_prefix, id: @luke.id }
-
       end
 
-      it "should have a root node named user" do
-        response_body.should have_selector("user")
+      it 'should have a root node named user' do
+        expect(response_body).to have_selector('user')
       end
 
-      it "should contain the specified attributes" do
-        response_body.should have_selector("user > prefix")
-        response_body.should have_selector("user > first-name")
-        response_body.should have_selector("user > last-name")
+      it 'should contain the specified attributes' do
+        expect(response_body).to have_selector('user > prefix')
+        expect(response_body).to have_selector('user > first-name')
+        expect(response_body).to have_selector('user > last-name')
       end
 
-      it "should not contain the specified attributes" do
-        response_body.should_not have_selector("user > postfix")
+      it 'should not contain the specified attributes' do
+        expect(response_body).not_to have_selector('user > postfix')
       end
-
     end
-
   end
 
   describe 'api postfix' do
-
     describe 'get single user' do
-
       before(:each) do
         get :show_prefix_postfix, format: 'xml', params: { api_template: :name_only, api_postfix: :with_postfix, id: @luke.id }
       end
 
-      it "should have a root node named user" do
-        response_body.should have_selector("user")
+      it 'should have a root node named user' do
+        expect(response_body).to have_selector('user')
       end
 
-      it "should contain the specified attributes" do
-        response_body.should have_selector("user > first-name")
-        response_body.should have_selector("user > last-name")
-        response_body.should have_selector("user > postfix")
+      it 'should contain the specified attributes' do
+        expect(response_body).to have_selector('user > first-name')
+        expect(response_body).to have_selector('user > last-name')
+        expect(response_body).to have_selector('user > postfix')
       end
 
-      it "should not contain the specified attributes" do
-        response_body.should_not have_selector("user > prefix")
+      it 'should not contain the specified attributes' do
+        expect(response_body).not_to have_selector('user > prefix')
       end
-
     end
-
   end
 
   describe 'api prefix and api postfix' do
-
     describe 'get single user' do
-
       before(:each) do
-        get :show_prefix_postfix, format: 'xml', params: { api_template: :name_only, api_prefix: :with_prefix, api_postfix: :with_postfix, :id => @luke.id }
+        get :show_prefix_postfix, format: 'xml', params: { api_template: :name_only, api_prefix: :with_prefix, api_postfix: :with_postfix, id: @luke.id }
       end
 
-      it "should have a root node named user" do
-        response_body.should have_selector("user")
+      it 'should have a root node named user' do
+        expect(response_body).to have_selector('user')
       end
 
-      it "should contain the specified attributes" do
-        response_body.should have_selector("user > prefix")
-        response_body.should have_selector("user > first-name")
-        response_body.should have_selector("user > last-name")
-        response_body.should have_selector("user > postfix")
+      it 'should contain the specified attributes' do
+        expect(response_body).to have_selector('user > prefix')
+        expect(response_body).to have_selector('user > first-name')
+        expect(response_body).to have_selector('user > last-name')
+        expect(response_body).to have_selector('user > postfix')
       end
-
     end
-
   end
-
 end