test_track_rails_client 2.0.0 → 3.0.0

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

@@ -1,404 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
-require 'yaml'
-
-describe Her::Model::Attributes do
-  context "mapping data to Ruby objects" do
-    before { spawn_model "Foo::User" }
-
-    it "handles new resource" do
-      @new_user = Foo::User.new(:fullname => "Tobias Fünke")
-      @new_user.new?.should be_truthy
-      @new_user.fullname.should == "Tobias Fünke"
-    end
-
-    it "accepts new resource with strings as hash keys" do
-      @new_user = Foo::User.new('fullname' => "Tobias Fünke")
-      @new_user.fullname.should == "Tobias Fünke"
-    end
-
-    it "handles method missing for getter" do
-      @new_user = Foo::User.new(:fullname => 'Mayonegg')
-      expect { @new_user.unknown_method_for_a_user }.to raise_error(NoMethodError)
-      expect { @new_user.fullname }.not_to raise_error()
-    end
-
-    it "handles method missing for setter" do
-      @new_user = Foo::User.new
-      expect { @new_user.fullname = "Tobias Fünke" }.not_to raise_error()
-    end
-
-    it "handles method missing for query" do
-      @new_user = Foo::User.new
-      expect { @new_user.fullname? }.not_to raise_error()
-    end
-
-    it "handles respond_to for getter" do
-      @new_user = Foo::User.new(:fullname => 'Mayonegg')
-      @new_user.should_not respond_to(:unknown_method_for_a_user)
-      @new_user.should respond_to(:fullname)
-    end
-
-    it "handles respond_to for setter" do
-      @new_user = Foo::User.new
-      @new_user.should respond_to(:fullname=)
-    end
-
-    it "handles respond_to for query" do
-      @new_user = Foo::User.new
-      @new_user.should respond_to(:fullname?)
-    end
-
-    it "handles has_attribute? for getter" do
-      @new_user = Foo::User.new(:fullname => 'Mayonegg')
-      @new_user.should_not have_attribute(:unknown_method_for_a_user)
-      @new_user.should have_attribute(:fullname)
-    end
-
-    it "handles get_attribute for getter" do
-      @new_user = Foo::User.new(:fullname => 'Mayonegg')
-      @new_user.get_attribute(:unknown_method_for_a_user).should be_nil
-      @new_user.get_attribute(:fullname).should == 'Mayonegg'
-    end
-
-    it "handles get_attribute for getter with dash" do
-      @new_user = Foo::User.new(:'life-span' => '3 years')
-      @new_user.get_attribute(:unknown_method_for_a_user).should be_nil
-      @new_user.get_attribute(:'life-span').should == '3 years'
-    end
-  end
-
-
-  context "assigning new resource data" do
-    before do
-      spawn_model "Foo::User"
-      @user = Foo::User.new(:active => false)
-    end
-
-    it "handles data update through #assign_attributes" do
-      @user.assign_attributes :active => true
-      @user.should be_active
-    end
-  end
-
-  context "checking resource equality" 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/1") { |env| [200, {}, { :id => 1, :fullname => "Lindsay Fünke" }.to_json] }
-          stub.get("/users/2") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke" }.to_json] }
-          stub.get("/admins/1") { |env| [200, {}, { :id => 1, :fullname => "Lindsay Fünke" }.to_json] }
-        end
-      end
-
-      spawn_model "Foo::User"
-      spawn_model "Foo::Admin"
-    end
-
-    let(:user) { Foo::User.find(1) }
-
-    it "returns true for the exact same object" do
-      user.should == user
-    end
-
-    it "returns true for the same resource via find" do
-      user.should == Foo::User.find(1)
-    end
-
-    it "returns true for the same class with identical data" do
-      user.should == Foo::User.new(:id => 1, :fullname => "Lindsay Fünke")
-    end
-
-    it "returns true for a different resource with the same data" do
-      user.should == Foo::Admin.find(1)
-    end
-
-    it "returns false for the same class with different data" do
-      user.should_not == Foo::User.new(:id => 2, :fullname => "Tobias Fünke")
-    end
-
-    it "returns false for a non-resource with the same data" do
-      fake_user = double(:data => { :id => 1, :fullname => "Lindsay Fünke" })
-      user.should_not == fake_user
-    end
-
-    it "delegates eql? to ==" do
-      other = Object.new
-      user.should_receive(:==).with(other).and_return(true)
-      user.eql?(other).should be_truthy
-    end
-
-    it "treats equal resources as equal for Array#uniq" do
-      user2 = Foo::User.find(1)
-      [user, user2].uniq.should == [user]
-    end
-
-    it "treats equal resources as equal for hash keys" do
-      Foo::User.find(1)
-      hash = { user => true }
-      hash[Foo::User.find(1)] = false
-      hash.size.should == 1
-      hash.should == { user => false }
-    end
-  end
-
-  context "handling metadata and errors" do
-    before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
-        builder.use Her::Middleware::FirstLevelParseJSON
-        builder.adapter :test do |stub|
-          stub.post("/users") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke" }.to_json] }
-        end
-      end
-
-      spawn_model 'Foo::User' do
-        store_response_errors :errors
-        store_metadata :my_data
-      end
-
-      @user = Foo::User.new(:_errors => ["Foo", "Bar"], :_metadata => { :secret => true })
-    end
-
-    it "should return response_errors stored in the method provided by `store_response_errors`" do
-      @user.errors.should == ["Foo", "Bar"]
-    end
-
-    it "should remove the default method for errors" do
-      expect { @user.response_errors }.to raise_error(NoMethodError)
-    end
-
-    it "should return metadata stored in the method provided by `store_metadata`" do
-      @user.my_data.should == { :secret => true }
-    end
-
-    it "should remove the default method for metadata" do
-      expect { @user.metadata }.to raise_error(NoMethodError)
-    end
-
-    it "should work with #save" do
-      @user.assign_attributes(:fullname => "Tobias Fünke")
-      @user.save
-      expect { @user.metadata }.to raise_error(NoMethodError)
-      @user.my_data.should be_empty
-      @user.errors.should be_empty
-    end
-  end
-
-  context "overwriting default attribute methods" do
-    context "for getter method" 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/1") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke", :document => { :url => "http://example.com" } }.to_json] }
-          end
-        end
-
-        spawn_model 'Foo::User' do
-          def document
-            @attributes[:document][:url]
-          end
-        end
-      end
-
-      it "bypasses Her's method" do
-        @user = Foo::User.find(1)
-        @user.document.should == "http://example.com"
-
-        @user = Foo::User.find(1)
-        @user.document.should == "http://example.com"
-      end
-    end
-
-    context "for setter method" 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/1") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke", :document => { :url => "http://example.com" } }.to_json] }
-          end
-        end
-
-        spawn_model 'Foo::User' do
-          def document=(document)
-            @attributes[:document] = document[:url]
-          end
-        end
-      end
-
-      it "bypasses Her's method" do
-        @user = Foo::User.find(1)
-        @user.document.should == "http://example.com"
-
-        @user = Foo::User.find(1)
-        @user.document.should == "http://example.com"
-      end
-    end
-
-    context "for predicate method" 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/1") { |env| [200, {}, { :id => 1, :fullname => "Lindsay Fünke", :document => { :url => nil } }.to_json] }
-            stub.get("/users/2") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke", :document => { :url => "http://example.com" } }.to_json] }
-          end
-        end
-
-        spawn_model 'Foo::User' do
-          def document?
-            document[:url].present?
-          end
-        end
-      end
-
-      it "byoasses Her's method" do
-        @user = Foo::User.find(1)
-        @user.document?.should be_falsey
-
-        @user = Foo::User.find(1)
-        @user.document?.should be_falsey
-
-        @user = Foo::User.find(2)
-        @user.document?.should be_truthy
-      end
-    end
-  end
-
-  context "attributes class method" do
-    before do
-      spawn_model 'Foo::User' do
-        attributes :fullname, :document
-      end
-    end
-
-    context "instance" do
-      subject { Foo::User.new }
-
-      it { should respond_to(:fullname) }
-      it { should respond_to(:fullname=) }
-      it { should respond_to(:fullname?) }
-    end
-
-    it "defines setter that affects @attributes" do
-      user = Foo::User.new
-      user.fullname = 'Tobias Fünke'
-      user.attributes[:fullname].should eq('Tobias Fünke')
-    end
-
-    it "defines getter that reads @attributes" do
-      user = Foo::User.new
-      user.assign_attributes(fullname: 'Tobias Fünke')
-      user.fullname.should eq('Tobias Fünke')
-    end
-
-    it "defines predicate that reads @attributes" do
-      user = Foo::User.new
-      user.fullname?.should be_falsey
-      user.assign_attributes(fullname: 'Tobias Fünke')
-      user.fullname?.should be_truthy
-    end
-
-    context "when attribute methods are already defined" do
-      before do
-        class AbstractUser
-          attr_accessor :fullname
-
-          def fullname?
-            @fullname.present?
-          end
-        end
-        @spawned_models << :AbstractUser
-
-        spawn_model 'Foo::User', super_class: AbstractUser do
-          attributes :fullname
-        end
-      end
-
-      it "overrides getter method" do
-        Foo::User.generated_attribute_methods.instance_methods.should include(:fullname)
-      end
-
-      it "overrides setter method" do
-        Foo::User.generated_attribute_methods.instance_methods.should include(:fullname=)
-      end
-
-      it "overrides predicate method" do
-        Foo::User.generated_attribute_methods.instance_methods.should include(:fullname?)
-      end
-
-      it "defines setter that affects @attributes" do
-        user = Foo::User.new
-        user.fullname = 'Tobias Fünke'
-        user.attributes[:fullname].should eq('Tobias Fünke')
-      end
-
-      it "defines getter that reads @attributes" do
-        user = Foo::User.new
-        user.attributes[:fullname] = 'Tobias Fünke'
-        user.fullname.should eq('Tobias Fünke')
-      end
-
-      it "defines predicate that reads @attributes" do
-        user = Foo::User.new
-        user.fullname?.should be_falsey
-        user.attributes[:fullname] = 'Tobias Fünke'
-        user.fullname?.should be_truthy
-      end
-    end
-
-    if ActiveModel::VERSION::MAJOR < 4
-      it "creates a new mutex" do
-        expect(Mutex).to receive(:new).once.and_call_original
-        spawn_model 'Foo::User' do
-          attributes :fullname
-        end
-        Foo::User.attribute_methods_mutex.should_not eq(Foo::User.generated_attribute_methods)
-      end
-
-      it "works well with Module#synchronize monkey patched by ActiveSupport" do
-        Module.class_eval do
-          def synchronize(*args)
-            raise 'gotcha!'
-          end
-        end
-        expect(Mutex).to receive(:new).once.and_call_original
-        spawn_model 'Foo::User' do
-          attributes :fullname
-        end
-        Foo::User.attribute_methods_mutex.should_not eq(Foo::User.generated_attribute_methods)
-        Module.class_eval do
-          undef :synchronize
-        end
-      end
-    else
-      it "uses ActiveModel's mutex" do
-        Foo::User.attribute_methods_mutex.should eq(Foo::User.generated_attribute_methods)
-      end
-    end
-
-    it "uses a mutex" do
-      spawn_model 'Foo::User'
-      expect(Foo::User.attribute_methods_mutex).to receive(:synchronize).once.and_call_original
-      Foo::User.class_eval do
-        attributes :fullname, :documents
-      end
-    end
-  end
-
-  context "YAML serialization" do
-    before do
-      spawn_model 'Foo::User' do
-        attributes :fullname
-      end
-    end
-
-    it "successfully serializes and deserializes" do
-      user = Foo::User.new(fullname: 'bar')
-      revived_user = YAML.load(YAML.dump(user))
-      revived_user.fullname.should eq('bar')
-    end
-  end
-end

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

@@ -1,145 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
-
-describe "Her::Model and ActiveModel::Callbacks" do
-  before do
-    Her::API.setup :url => "https://api.example.com" do |builder|
-      builder.use Her::Middleware::FirstLevelParseJSON
-    end
-
-    spawn_model "Foo::User"
-  end
-
-  context :before_save do
-    subject { Foo::User.create(:name => "Tobias Funke") }
-    before do
-      Her::API.default_api.connection.adapter :test do |stub|
-        stub.post("/users") { |env| [200, {}, { :id => 1, :name => env[:body][:name] }.to_json] }
-        stub.put("/users/1") { |env| [200, {}, { :id => 1, :name => env[:body][:name] }.to_json] }
-      end
-    end
-
-    context "when using a symbol callback" do
-      before do
-        class Foo::User
-          before_save :alter_name
-          def alter_name; self.name.upcase!;  end
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-
-    context "when using a block callback" do
-      before do
-        class Foo::User
-          before_save lambda { self.name.upcase! }
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-
-    context "when changing a value of an existing resource in a callback" do
-      before do
-        class Foo::User
-          before_save :alter_name
-          def alter_name
-            self.name = "Lumberjack" if persisted?
-          end
-        end
-      end
-
-      it "should call the server with the canged value" do
-        subject.name.should == "Tobias Funke"
-        subject.save
-        subject.name.should == "Lumberjack"
-      end
-    end
-  end
-
-  context :before_create do
-    subject { Foo::User.create(:name => "Tobias Funke") }
-    before do
-      Her::API.default_api.connection.adapter :test do |stub|
-        stub.post("/users") { |env| [200, {}, { :id => 1, :name => env[:body][:name] }.to_json] }
-      end
-    end
-
-    context "when using a symbol callback" do
-      before do
-        class Foo::User
-          before_create :alter_name
-          def alter_name; self.name.upcase!;  end
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-
-    context "when using a block callback" do
-      before do
-        class Foo::User
-          before_create lambda { self.name.upcase! }
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-  end
-
-  context :after_find do
-    subject { Foo::User.find(1) }
-    before do
-      Her::API.default_api.connection.adapter :test do |stub|
-        stub.get("/users/1") { |env| [200, {}, { :id => 1, :name => "Tobias Funke" }.to_json] }
-      end
-    end
-
-    context "when using a symbol callback" do
-      before do
-        class Foo::User
-          after_find :alter_name
-          def alter_name; self.name.upcase!;  end
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-
-    context "when using a block callback" do
-      before do
-        class Foo::User
-          after_find lambda { self.name.upcase! }
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-  end
-
-  context :after_initialize do
-    subject { Foo::User.new(:name => "Tobias Funke") }
-
-    context "when using a symbol callback" do
-      before do
-        class Foo::User
-          after_initialize :alter_name
-          def alter_name; self.name.upcase!;  end
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-
-    context "when using a block callback" do
-      before do
-        class Foo::User
-          after_initialize lambda { self.name.upcase! }
-        end
-      end
-
-      its(:name) { should == "TOBIAS FUNKE" }
-    end
-  end
-end

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

@@ -1,110 +0,0 @@
-# encoding: utf-8
-require File.join(File.dirname(__FILE__), "../spec_helper.rb")
-
-describe "Her::Model and ActiveModel::Dirty" do
-  context "checking dirty attributes" 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/1") { |env| [200, {}, { :id => 1, :fullname => "Lindsay Fünke", :friends => [ { :name => "Fred" } ], :best_friend => { :name => "Dave" } }.to_json] }
-          stub.get("/users/2") { |env| [200, {}, { :id => 2, :fullname => "Maeby Fünke" }.to_json] }
-          stub.get("/users/3") { |env| [200, {}, { :user_id => 3, :fullname => "Maeby Fünke" }.to_json] }
-          stub.put("/users/1") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke" }.to_json] }
-          stub.put("/users/2") { |env| [400, {}, { :errors => ["Email cannot be blank"] }.to_json] }
-          stub.post("/users") { |env| [200, {}, { :id => 1, :fullname => "Tobias Fünke" }.to_json] }
-        end
-      end
-
-      spawn_model "Foo::Friend" do
-        attributes :name
-      end
-      spawn_model "Foo::User" do
-        has_many :friends, class_name: "Foo::Friend"
-        has_one :best_friend, class_name: "Foo::Friend"
-
-        attributes :fullname, :email
-      end
-      spawn_model "Dynamic::User" do
-        primary_key :user_id
-      end
-    end
-
-    context "for existing resource" do
-      let(:user) { Foo::User.find(1) }
-      it "has no changes" do
-        user.changes.should be_empty
-        user.should_not be_changed
-      end
-
-      context "for has_many associations" do
-        it "has no changes" do
-          user.friends.first.name_changed?.should eq false
-        end
-      end
-
-      context "for has_one associations" do
-        it "has no changes" do
-          user.best_friend.name_changed?.should eq false
-        end
-      end
-
-      context "with successful save" do
-        it "tracks dirty attributes" do
-          user.fullname = "Tobias Fünke"
-          user.fullname_changed?.should be_truthy
-          user.email_changed?.should be_falsey
-          user.should be_changed
-          user.save
-          user.should_not be_changed
-        end
-
-        it "tracks only changed dirty attributes" do
-          user.fullname = user.fullname
-          user.fullname_changed?.should be_falsey
-        end
-
-        it "tracks previous changes" do
-          user.fullname = "Tobias Fünke"
-          user.save
-          user.previous_changes.should eq({"fullname"=>"Lindsay Fünke"})
-        end
-
-        it 'tracks dirty attribute for mass assign for dynamic created attributes' do
-          user = Dynamic::User.find(3)
-          user.assign_attributes(:fullname => 'New Fullname')
-          user.fullname_changed?.should be_truthy
-          user.should be_changed
-          user.changes.length.should eq(1)
-        end
-      end
-
-      context "with erroneous save" do
-        it "tracks dirty attributes" do
-          user = Foo::User.find(2)
-          user.fullname = "Tobias Fünke"
-          user.fullname_changed?.should be_truthy
-          user.email_changed?.should be_falsey
-          user.should be_changed
-          user.save
-          user.should be_changed
-        end
-      end
-    end
-
-    context "for new resource" do
-      let(:user) { Foo::User.new(:fullname => "Lindsay Fünke") }
-      it "has changes" do
-        user.should be_changed
-      end
-      it "tracks dirty attributes" do
-        user.fullname = "Tobias Fünke"
-        user.fullname_changed?.should be_truthy
-        user.should be_changed
-        user.save
-        user.should_not be_changed
-      end
-    end
-  end
-end