test_track_rails_client 2.0.0 → 3.0.0

data/vendor/gems/her/spec/model/paths_spec.rb

@@ -1,347 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
-
-describe Her::Model::Paths do
-  context "building request paths" do
-    context "simple model" do
-      before do
-        spawn_model "Foo::User"
-      end
-
-      describe "#request_path" do
-        it "builds paths with defaults" do
-          Foo::User.new(:id => "foo").request_path.should == "users/foo"
-          Foo::User.new(:id => nil).request_path.should == "users"
-          Foo::User.new().request_path.should == "users"
-        end
-
-        it "builds paths with custom collection path" do
-          Foo::User.collection_path "/utilisateurs"
-          Foo::User.new(:id => "foo").request_path.should == "/utilisateurs/foo"
-          Foo::User.new().request_path.should == "/utilisateurs"
-        end
-
-        it "builds paths with custom relative collection path" do
-          Foo::User.collection_path "utilisateurs"
-          Foo::User.new(:id => "foo").request_path.should == "utilisateurs/foo"
-          Foo::User.new().request_path.should == "utilisateurs"
-        end
-
-        it "builds paths with custom collection path with multiple variables" do
-          Foo::User.collection_path "/organizations/:organization_id/utilisateurs"
-
-          Foo::User.new(:id => "foo").request_path(:_organization_id => "acme").should == "/organizations/acme/utilisateurs/foo"
-          Foo::User.new().request_path(:_organization_id => "acme").should == "/organizations/acme/utilisateurs"
-
-          Foo::User.new(:id => "foo", :organization_id => "acme").request_path.should == "/organizations/acme/utilisateurs/foo"
-          Foo::User.new(:organization_id => "acme").request_path.should == "/organizations/acme/utilisateurs"
-        end
-
-        it "builds paths with custom relative collection path with multiple variables" do
-          Foo::User.collection_path "organizations/:organization_id/utilisateurs"
-
-          Foo::User.new(:id => "foo").request_path(:_organization_id => "acme").should == "organizations/acme/utilisateurs/foo"
-          Foo::User.new().request_path(:_organization_id => "acme").should == "organizations/acme/utilisateurs"
-
-          Foo::User.new(:id => "foo", :organization_id => "acme").request_path.should == "organizations/acme/utilisateurs/foo"
-          Foo::User.new(:organization_id => "acme").request_path.should == "organizations/acme/utilisateurs"
-        end
-
-        it "builds paths with custom item path" do
-          Foo::User.resource_path "/utilisateurs/:id"
-          Foo::User.new(:id => "foo").request_path.should == "/utilisateurs/foo"
-          Foo::User.new().request_path.should == "users"
-        end
-
-        it "builds paths with custom relative item path" do
-          Foo::User.resource_path "utilisateurs/:id"
-          Foo::User.new(:id => "foo").request_path.should == "utilisateurs/foo"
-          Foo::User.new().request_path.should == "users"
-        end
-
-        it "raises exceptions when building a path without required custom variables" do
-          Foo::User.collection_path "/organizations/:organization_id/utilisateurs"
-          expect { Foo::User.new(:id => "foo").request_path }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/utilisateurs/:id`. Parameters are `{:id=>\"foo\"}`.")
-        end
-
-        it "escapes the variable values" do
-          Foo::User.collection_path "organizations/:organization_id/utilisateurs"
-          Foo::User.new(:id => "Привет").request_path(:_organization_id => 'лол').should == "organizations/%D0%BB%D0%BE%D0%BB/utilisateurs/%D0%9F%D1%80%D0%B8%D0%B2%D0%B5%D1%82"
-          Foo::User.new(:organization_id => 'лол', :id => "Привет").request_path.should == "organizations/%D0%BB%D0%BE%D0%BB/utilisateurs/%D0%9F%D1%80%D0%B8%D0%B2%D0%B5%D1%82"
-        end
-      end
-    end
-
-    context "simple model with multiple words" do
-      before do
-        spawn_model "Foo::AdminUser"
-      end
-
-      describe "#request_path" do
-        it "builds paths with defaults" do
-          Foo::AdminUser.new(:id => "foo").request_path.should == "admin_users/foo"
-          Foo::AdminUser.new().request_path.should == "admin_users"
-        end
-
-        it "builds paths with custom collection path" do
-          Foo::AdminUser.collection_path "/users"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "/users/foo"
-          Foo::AdminUser.new().request_path.should == "/users"
-        end
-
-        it "builds paths with custom relative collection path" do
-          Foo::AdminUser.collection_path "users"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "users/foo"
-          Foo::AdminUser.new().request_path.should == "users"
-        end
-
-        it "builds paths with custom collection path with multiple variables" do
-          Foo::AdminUser.collection_path "/organizations/:organization_id/users"
-          Foo::AdminUser.new(:id => "foo").request_path(:_organization_id => "acme").should == "/organizations/acme/users/foo"
-          Foo::AdminUser.new().request_path(:_organization_id => "acme").should == "/organizations/acme/users"
-        end
-
-        it "builds paths with custom relative collection path with multiple variables" do
-          Foo::AdminUser.collection_path "organizations/:organization_id/users"
-          Foo::AdminUser.new(:id => "foo").request_path(:_organization_id => "acme").should == "organizations/acme/users/foo"
-          Foo::AdminUser.new().request_path(:_organization_id => "acme").should == "organizations/acme/users"
-        end
-
-        it "builds paths with custom item path" do
-          Foo::AdminUser.resource_path "/users/:id"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "/users/foo"
-          Foo::AdminUser.new().request_path.should == "admin_users"
-        end
-
-        it "builds paths with custom relative item path" do
-          Foo::AdminUser.resource_path "users/:id"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "users/foo"
-          Foo::AdminUser.new().request_path.should == "admin_users"
-        end
-
-        it "raises exceptions when building a path without required custom variables" do
-          Foo::AdminUser.collection_path "/organizations/:organization_id/users"
-          expect { Foo::AdminUser.new(:id => "foo").request_path }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/users/:id`. Parameters are `{:id=>\"foo\"}`.")
-        end
-
-        it "raises exceptions when building a relative path without required custom variables" do
-          Foo::AdminUser.collection_path "organizations/:organization_id/users"
-          expect { Foo::AdminUser.new(:id => "foo").request_path }.to raise_error(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `organizations/:organization_id/users/:id`. Parameters are `{:id=>\"foo\"}`.")
-        end
-      end
-    end
-
-    context "children model" do
-      before do
-        Her::API.setup :url => "https://api.example.com" do |builder|
-          builder.use Her::Middleware::FirstLevelParseJSON
-          builder.use Faraday::Request::UrlEncoded
-          builder.adapter :test do |stub|
-            stub.get("/users/foo") { |env| [200, {}, { :id => 'foo' }.to_json] }
-          end
-        end
-
-        spawn_model("Foo::Model") { include_root_in_json true }
-
-        class User < Foo::Model; end
-        @spawned_models << :User
-      end
-
-      it "builds path using the children model name" do
-        User.find('foo').id.should == 'foo'
-        User.find('foo').id.should == 'foo'
-      end
-    end
-
-    context "nested model" do
-      before do
-        spawn_model "Foo::User"
-      end
-
-      describe "#request_path" do
-        it "builds paths with defaults" do
-          Foo::User.new(:id => "foo").request_path.should == "users/foo"
-          Foo::User.new.request_path.should == "users"
-        end
-      end
-    end
-
-    context 'custom primary key' do
-      before do
-        spawn_model 'User' do
-          primary_key 'UserId'
-          resource_path 'users/:UserId'
-        end
-
-        spawn_model 'Customer' do
-          primary_key :customer_id
-          resource_path 'customers/:id'
-        end
-      end
-
-      describe '#request_path' do
-        it 'uses the correct primary key attribute' do
-          User.new(:UserId => 'foo').request_path.should == 'users/foo'
-          User.new(:id => 'foo').request_path.should == 'users'
-        end
-
-        it 'replaces :id with the appropriate primary key' do
-          Customer.new(:customer_id => 'joe').request_path.should == 'customers/joe'
-          Customer.new(:id => 'joe').request_path.should == 'customers'
-        end
-      end
-    end
-  end
-
-  context "making subdomain HTTP requests" do
-    before do
-      Her::API.setup :url => "https://api.example.com/" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-        builder.adapter :test do |stub|
-          stub.get("organizations/2/users") { |env| [200, {}, [{ :id => 1, :fullname => "Tobias Fünke", :organization_id => 2 }, { :id => 2, :fullname => "Lindsay Fünke", :organization_id => 2 }].to_json] }
-          stub.post("organizations/2/users") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke", :organization_id => 2 }.to_json] }
-          stub.put("organizations/2/users/1") { |env| [200, {}, { :id => 1, :fullname => "Lindsay Fünke", :organization_id => 2 }.to_json] }
-          stub.get("organizations/2/users/1") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke", :organization_id => 2, :active => true }.to_json] }
-          stub.delete("organizations/2/users/1") { |env| [200, {}, { :id => 1, :fullname => "Lindsay Fünke", :organization_id => 2, :active => false }.to_json] }
-        end
-      end
-
-      spawn_model "Foo::User" do
-        collection_path "organizations/:organization_id/users"
-      end
-    end
-
-    describe "fetching a resource" do
-      it "maps a single resource to a Ruby object" do
-        @user = Foo::User.find(1, :_organization_id => 2)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
-      end
-
-      it "maps a single resource using a scope to a Ruby object" do
-        Foo::User.scope :for_organization, lambda { |o| where(:organization_id => o) }
-        @user = Foo::User.for_organization(2).find(1)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
-      end
-    end
-
-    describe "fetching a collection" do
-      it "maps a collection of resources to an array of Ruby objects" do
-        @users = Foo::User.where(:_organization_id => 2).all
-        @users.length.should == 2
-        @users.first.fullname.should == "Tobias Fünke"
-      end
-    end
-
-    describe "handling new resource" do
-      it "handles new resource" do
-        @new_user = Foo::User.new(:fullname => "Tobias Fünke", :organization_id => 2)
-        @new_user.new?.should be_truthy
-
-        @existing_user = Foo::User.find(1, :_organization_id => 2)
-        @existing_user.new?.should be_falsey
-      end
-    end
-
-    describe "creating resources" do
-      it "handle one-line resource creation" do
-        @user = Foo::User.create(:fullname => "Tobias Fünke", :organization_id => 2)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
-      end
-
-      it "handle resource creation through Model.new + #save" do
-        @user = Foo::User.new(:fullname => "Tobias Fünke", :organization_id => 2)
-        @user.save
-        @user.fullname.should == "Tobias Fünke"
-      end
-    end
-
-    context "updating resources" do
-      it "handle resource data update without saving it" do
-        @user = Foo::User.find(1, :_organization_id => 2)
-        @user.fullname.should == "Tobias Fünke"
-        @user.fullname = "Kittie Sanchez"
-        @user.fullname.should == "Kittie Sanchez"
-      end
-
-      it "handle resource update through the .update class method" do
-        @user = Foo::User.save_existing(1, { :fullname => "Lindsay Fünke", :organization_id => 2 })
-        @user.fullname.should == "Lindsay Fünke"
-      end
-
-      it "handle resource update through #save on an existing resource" do
-        @user = Foo::User.find(1, :_organization_id => 2)
-        @user.fullname = "Lindsay Fünke"
-        @user.save
-        @user.fullname.should == "Lindsay Fünke"
-      end
-    end
-
-    context "deleting resources" do
-      it "handle resource deletion through the .destroy class method" do
-        @user = Foo::User.destroy_existing(1, :_organization_id => 2)
-        @user.active.should be_falsey
-      end
-
-      it "handle resource deletion through #destroy on an existing resource" do
-        @user = Foo::User.find(1, :_organization_id => 2)
-        @user.destroy
-        @user.active.should be_falsey
-      end
-    end
-  end
-
-  context "making path HTTP requests" do
-    before do
-      Her::API.setup :url => "https://example.com/api/" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-        builder.adapter :test do |stub|
-          stub.get("/api/organizations/2/users") { |env| [200, {}, [{ :id => 1, :fullname => "Tobias Fünke", :organization_id => 2 }, { :id => 2, :fullname => "Lindsay Fünke", :organization_id => 2 }].to_json] }
-          stub.get("/api/organizations/2/users/1") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke", :organization_id => 2, :active => true }.to_json] }
-        end
-      end
-
-      spawn_model "Foo::User" do
-        collection_path "organizations/:organization_id/users"
-      end
-    end
-
-    describe "fetching a resource" do
-      it "maps a single resource to a Ruby object" do
-        @user = Foo::User.find(1, :_organization_id => 2)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
-      end
-    end
-
-    describe "fetching a collection" do
-      it "maps a collection of resources to an array of Ruby objects" do
-        @users = Foo::User.where(:_organization_id => 2).all
-        @users.length.should == 2
-        @users.first.fullname.should == "Tobias Fünke"
-      end
-    end
-
-    describe "fetching a resource with absolute path" do
-      it "maps a single resource to a Ruby object" do
-        Foo::User.resource_path '/api/' + Foo::User.resource_path
-        @user = Foo::User.find(1, :_organization_id => 2)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
-      end
-    end
-
-    describe "fetching a collection with absolute path" do
-      it "maps a collection of resources to an array of Ruby objects" do
-        Foo::User.collection_path '/api/' + Foo::User.collection_path
-        @users = Foo::User.where(:_organization_id => 2).all
-        @users.length.should == 2
-        @users.first.fullname.should == "Tobias Fünke"
-      end
-    end
-  end
-end

data/vendor/gems/her/spec/model/relation_spec.rb

@@ -1,226 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
-
-describe Her::Model::Relation do
-  describe :where do
-    context "for base classes" do
-      before do
-        Her::API.setup :url => "https://api.example.com" do |builder|
-          builder.use Her::Middleware::FirstLevelParseJSON
-          builder.adapter :test do |stub|
-            stub.get("/users?foo=1&bar=2") { |env| ok! [{ :id => 2, :fullname => "Tobias Fünke" }] }
-            stub.get("/users?admin=1") { |env| ok! [{ :id => 1, :fullname => "Tobias Fünke" }] }
-
-            stub.get("/users") do |env|
-              ok! [
-                { :id => 1, :fullname => "Tobias Fünke" },
-                { :id => 2, :fullname => "Lindsay Fünke" },
-                @created_user,
-              ].compact
-            end
-
-            stub.post('/users') do |env|
-              @created_user = { :id => 3, :fullname => 'George Michael Bluth' }
-              ok! @created_user
-            end
-          end
-        end
-
-        spawn_model "Foo::User"
-      end
-
-      it "doesn't fetch the data immediatly" do
-        Foo::User.should_receive(:request).never
-        @users = Foo::User.where(:admin => 1)
-      end
-
-      it "fetches the data and passes query parameters" do
-        Foo::User.should_receive(:request).once.and_call_original
-        @users = Foo::User.where(:admin => 1)
-        @users.should respond_to(:length)
-        @users.size.should eql 1
-      end
-
-      it "chains multiple where statements" do
-        @user = Foo::User.where(:foo => 1).where(:bar => 2).first
-        @user.id.should == 2
-      end
-
-      it "does not reuse relations" do
-        Foo::User.all.size.should eql 2
-        Foo::User.create(:fullname => 'George Michael Bluth').id.should == 3
-        Foo::User.all.size.should eql 3
-      end
-    end
-
-    context "for parent class" do
-      before do
-        Her::API.setup :url => "https://api.example.com" do |builder|
-          builder.use Her::Middleware::FirstLevelParseJSON
-          builder.adapter :test do |stub|
-            stub.get("/users?page=2") { |env| ok! [{ :id => 1, :fullname => "Tobias Fünke" }, { :id => 2, :fullname => "Lindsay Fünke" }] }
-          end
-        end
-
-        spawn_model("Foo::Model") do
-          scope :page, lambda { |page| where(:page => page) }
-        end
-
-        class User < Foo::Model; end
-        @spawned_models << :User
-      end
-
-      it "propagates the scopes through its children" do
-        @users = User.page(2)
-        @users.length.should == 2
-      end
-    end
-  end
-
-  describe :create do
-    before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.use Faraday::Request::UrlEncoded
-        builder.adapter :test do |stub|
-          stub.post("/users") { |env| ok! :id => 1, :fullname => params(env)[:fullname], :email => params(env)[:email] }
-        end
-      end
-
-      spawn_model "Foo::User"
-    end
-
-    context "with a single where call" do
-      it "creates a resource and passes the query parameters" do
-        @user = Foo::User.where(:fullname => "Tobias Fünke", :email => "tobias@bluth.com").create
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
-        @user.email.should == "tobias@bluth.com"
-      end
-    end
-
-    context "with multiple where calls" do
-      it "creates a resource and passes the query parameters" do
-        @user = Foo::User.where(:fullname => "Tobias Fünke").create(:email => "tobias@bluth.com")
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
-        @user.email.should == "tobias@bluth.com"
-      end
-    end
-  end
-
-  describe :build do
-    before { spawn_model "Foo::User" }
-
-    it "handles new resource with build" do
-      @new_user = Foo::User.where(:fullname => "Tobias Fünke").build
-      @new_user.new?.should be_truthy
-      @new_user.fullname.should == "Tobias Fünke"
-    end
-  end
-
-  describe :scope do
-    before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.adapter :test do |stub|
-          stub.get("/users?what=4&where=3") { |env| ok! [{ :id => 3, :fullname => "Maeby Fünke" }] }
-          stub.get("/users?what=2") { |env| ok! [{ :id => 2, :fullname => "Lindsay Fünke" }] }
-          stub.get("/users?where=6") { |env| ok! [{ :id => 4, :fullname => "Tobias Fünke" }] }
-        end
-      end
-
-      spawn_model 'Foo::User' do
-        scope :foo, lambda { |v| where(:what => v) }
-        scope :bar, lambda { |v| where(:where => v) }
-        scope :baz, lambda { bar(6) }
-      end
-    end
-
-    it "passes query parameters" do
-      @user = Foo::User.foo(2).first
-      @user.id.should == 2
-    end
-
-    it "passes multiple query parameters" do
-      @user = Foo::User.foo(4).bar(3).first
-      @user.id.should == 3
-    end
-
-    it "handles embedded scopes" do
-      @user = Foo::User.baz.first
-      @user.id.should == 4
-    end
-  end
-
-  describe :default_scope do
-    context "for new objects" do
-      before do
-        spawn_model 'Foo::User' do
-          default_scope lambda { where(:active => true) }
-          default_scope lambda { where(:admin => true) }
-        end
-      end
-
-      it "should apply the scope to the attributes" do
-        Foo::User.new.should be_active
-        Foo::User.new.should be_admin
-      end
-    end
-
-    context "for fetched resources" do
-      before do
-        Her::API.setup :url => "https://api.example.com" do |builder|
-          builder.use Her::Middleware::FirstLevelParseJSON
-          builder.use Faraday::Request::UrlEncoded
-          builder.adapter :test do |stub|
-            stub.post("/users") { |env| ok! :id => 3, :active => (params(env)[:active] == "true" ? true : false) }
-          end
-        end
-
-        spawn_model 'Foo::User' do
-          default_scope lambda { where(:active => true) }
-        end
-      end
-
-      it("should apply the scope to the request") { Foo::User.create.should be_active }
-    end
-
-    context "for fetched collections" do
-      before do
-        Her::API.setup :url => "https://api.example.com" do |builder|
-          builder.use Her::Middleware::FirstLevelParseJSON
-          builder.use Faraday::Request::UrlEncoded
-          builder.adapter :test do |stub|
-            stub.get("/users?active=true") { |env| ok! [{ :id => 3, :active => (params(env)[:active] == "true" ? true : false) }] }
-          end
-        end
-
-        spawn_model 'Foo::User' do
-          default_scope lambda { where(:active => true) }
-        end
-      end
-
-      it("should apply the scope to the request") { Foo::User.all.first.should be_active }
-    end
-  end
-
-  describe :map do
-    before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.adapter :test do |stub|
-          stub.get("/users") do |env|
-            ok! [{ :id => 1, :fullname => "Tobias Fünke" }, { :id => 2, :fullname => "Lindsay Fünke" }]
-          end
-        end
-      end
-
-      spawn_model 'Foo::User'
-    end
-
-    it "delegates the method to the fetched collection" do
-      Foo::User.all.map(&:fullname).should == ["Tobias Fünke", "Lindsay Fünke"]
-    end
-  end
-end

data/vendor/gems/her/spec/model/validations_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
-
-describe "Her::Model and ActiveModel::Validations" do
-  context "validating attributes" do
-    before do
-      spawn_model "Foo::User" do
-        attributes :fullname, :email
-        validates_presence_of :fullname
-        validates_presence_of :email
-      end
-    end
-
-    it "validates attributes when calling #valid?" do
-      user = Foo::User.new
-      user.should_not be_valid
-      user.errors.full_messages.should include("Fullname can't be blank")
-      user.errors.full_messages.should include("Email can't be blank")
-      user.fullname = "Tobias Fünke"
-      user.email = "tobias@bluthcompany.com"
-      user.should be_valid
-    end
-  end
-
-  context "handling server errors" do
-    before do
-      spawn_model("Foo::Model") do
-        def errors
-          @response_errors
-        end
-      end
-
-      class User < Foo::Model; end
-      @spawned_models << :User
-    end
-
-    it "validates attributes when calling #valid?" do
-      user = User.new(:_errors => ["Email cannot be blank"])
-      user.errors.should include("Email cannot be blank")
-    end
-  end
-end

data/vendor/gems/her/spec/model_spec.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Her::Model do
-  before do
-    Her::API.setup :url => "https://api.example.com" do |connection|
-      connection.use Her::Middleware::FirstLevelParseJSON
-      connection.adapter :test do |stub|
-        stub.get("/users/1") { |env| [200, {}, { :id => 1, :name => "Tobias Fünke" }.to_json] }
-        stub.get("/users/1/comments") { |env| [200, {}, [{ :id => 4, :body => "They're having a FIRESALE?" }].to_json] }
-      end
-    end
-
-    spawn_model("Foo::User") { has_many :comments }
-    spawn_model("Foo::Comment")
-  end
-  subject { Foo::User.find(1) }
-
-  describe :has_key? do
-    it { should_not have_key(:unknown_method_for_a_user) }
-    it { should_not have_key(:unknown_method_for_a_user) }
-    it { should have_key(:name) }
-    it { should have_key(:comments) }
-  end
-
-  describe :[] do
-    it { should_not have_key(:unknown_method_for_a_user) }
-    specify { subject[:name].should == "Tobias Fünke" }
-    specify { subject[:comments].first.body.should == "They're having a FIRESALE?" }
-  end
-end

data/vendor/gems/her/spec/spec_helper.rb

@@ -1,27 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
-
-require "rspec"
-require "rspec/its"
-require "her"
-require "pry"
-
-# Require everything in `spec/support`
-Dir[File.expand_path('../../spec/support/**/*.rb', __FILE__)].map(&method(:require))
-
-# Remove ActiveModel deprecation message
-I18n.enforce_available_locales = false
-
-RSpec.configure do |config|
-  config.include Her::Testing::Macros::ModelMacros
-  config.include Her::Testing::Macros::RequestMacros
-
-  config.before :each do
-    @spawned_models = []
-  end
-
-  config.after :each do
-    @spawned_models.each do |model|
-      Object.instance_eval { remove_const model } if Object.const_defined?(model)
-    end
-  end
-end

data/vendor/gems/her/spec/support/extensions/array.rb

@@ -1,5 +0,0 @@
-class Array
-  def to_json
-    MultiJson.dump(self)
-  end
-end

data/vendor/gems/her/spec/support/extensions/hash.rb

@@ -1,5 +0,0 @@
-class Hash
-  def to_json
-    MultiJson.dump(self)
-  end
-end