him 0.1.0

data/spec/model/attributes_spec.rb

@@ -0,0 +1,384 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe Him::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")
+      expect(@new_user.new?).to be_truthy
+      expect(@new_user.fullname).to eq("Tobias Fünke")
+    end
+
+    it "handles new resource with block" do
+      @new_user = Foo::User.new do |user|
+        user.fullname = "Tobias Fünke"
+      end
+      expect(@new_user.new?).to be_truthy
+      expect(@new_user.fullname).to eq("Tobias Fünke")
+    end
+
+    it "accepts new resource with strings as hash keys" do
+      @new_user = Foo::User.new("fullname" => "Tobias Fünke")
+      expect(@new_user.fullname).to eq("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")
+      expect(@new_user).not_to respond_to(:unknown_method_for_a_user)
+      expect(@new_user).to respond_to(:fullname)
+    end
+
+    it "handles respond_to for setter" do
+      @new_user = Foo::User.new
+      expect(@new_user).to respond_to(:fullname=)
+    end
+
+    it "handles respond_to for query" do
+      @new_user = Foo::User.new
+      expect(@new_user).to respond_to(:fullname?)
+    end
+
+    it "handles has_attribute? for getter" do
+      @new_user = Foo::User.new(fullname: "Mayonegg")
+      expect(@new_user).not_to have_attribute(:unknown_method_for_a_user)
+      expect(@new_user).to have_attribute(:fullname)
+    end
+
+    it "handles get_attribute for getter" do
+      @new_user = Foo::User.new(fullname: "Mayonegg")
+      expect(@new_user.get_attribute(:unknown_method_for_a_user)).to be_nil
+      expect(@new_user.get_attribute(:fullname)).to eq("Mayonegg")
+    end
+
+    it "handles get_attribute for getter with dash" do
+      @new_user = Foo::User.new(:'life-span' => "3 years")
+      expect(@new_user.get_attribute(:unknown_method_for_a_user)).to be_nil
+      expect(@new_user.get_attribute(:'life-span')).to eq("3 years")
+    end
+
+    it "handles attribute_changed_in_place?" do
+      @new_user = Foo::User.new
+      @new_user.fullname = "Schmoo"
+      expect(@new_user.attribute_changed_in_place?(:fullname)).to be_truthy
+    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
+      expect(@user).to be_active
+    end
+
+    it "expects to receive hash" do
+      expect { @user.assign_attributes(1) }.to raise_error(ArgumentError, 'When assigning attributes, you must pass a hash as an argument.')
+    end
+  end
+
+  context "checking resource equality" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+        builder.adapter :test do |stub|
+          stub.get("/users/1") { [200, {}, { id: 1, fullname: "Lindsay Fünke" }.to_json] }
+          stub.get("/users/2") { [200, {}, { id: 1, fullname: "Tobias Fünke" }.to_json] }
+          stub.get("/admins/1") { [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
+      expect(user).to eq(user)
+    end
+
+    it "returns true for the same resource via find" do
+      expect(user).to eq(Foo::User.find(1))
+    end
+
+    it "returns true for the same class with identical data" do
+      expect(user).to eq(Foo::User.new(id: 1, fullname: "Lindsay Fünke"))
+    end
+
+    it "returns true for a different resource with the same data" do
+      expect(user).to eq(Foo::Admin.find(1))
+    end
+
+    it "returns false for the same class with different data" do
+      expect(user).not_to eq(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" })
+      expect(user).not_to eq(fake_user)
+    end
+
+    it "delegates eql? to ==" do
+      other = Object.new
+      expect(user).to receive(:==).with(other).and_return(true)
+      expect(user.eql?(other)).to be_truthy
+    end
+
+    it "treats equal resources as equal for Array#uniq" do
+      user2 = Foo::User.find(1)
+      expect([user, user2].uniq).to eq([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
+      expect(hash.size).to eq(1)
+      expect(hash).to eq(user => false)
+    end
+  end
+
+  context "handling metadata and errors" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.adapter :test do |stub|
+          stub.post("/users") { [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: %w[Foo Bar], _metadata: { secret: true })
+    end
+
+    it "should return response_errors stored in the method provided by `store_response_errors`" do
+      expect(@user.errors).to eq(%w[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
+      expect(@user.my_data).to eq(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)
+      expect(@user.my_data).to be_empty
+      expect(@user.errors).to be_empty
+    end
+  end
+
+  context "overwriting default attribute methods" do
+    context "for getter method" do
+      before do
+        Him::API.setup url: "https://api.example.com" do |builder|
+          builder.use Him::Middleware::FirstLevelParseJSON
+          builder.adapter :test do |stub|
+            stub.get("/users/1") { [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)
+        expect(@user.document).to eq("http://example.com")
+
+        @user = Foo::User.find(1)
+        expect(@user.document).to eq("http://example.com")
+      end
+    end
+
+    context "for setter method" do
+      before do
+        Him::API.setup url: "https://api.example.com" do |builder|
+          builder.use Him::Middleware::FirstLevelParseJSON
+          builder.adapter :test do |stub|
+            stub.get("/users/1") { [200, {}, { id: 1, fullname: "Tobias Fünke", document: { url: "http://example.com" } }.to_json] }
+          end
+        end
+
+        spawn_model "Foo::User" do
+          def document=(document)
+            @_her_attributes[:document] = document[:url]
+          end
+        end
+      end
+
+      it "bypasses Her's method" do
+        @user = Foo::User.find(1)
+        expect(@user.document).to eq("http://example.com")
+
+        @user = Foo::User.find(1)
+        expect(@user.document).to eq("http://example.com")
+      end
+
+      it "exposes the method to respond_to? and respond_to_without_missing?" do
+        @user = Foo::User.find(1)
+        expect(@user.respond_to?(:document=)).to be_truthy
+        expect(@user.respond_to_without_missing?(:document=)).to be_truthy
+      end
+
+      it "exposes a non-existent method to respond_to? but not respond_to_without_missing?" do
+        @user = Foo::User.find(1)
+        expect(@user.respond_to?(:nonexistent=)).to be_truthy
+        expect(@user.respond_to_without_missing?(:nonexistent=)).to be_falsey
+      end
+    end
+
+    context "for predicate method" do
+      before do
+        Him::API.setup url: "https://api.example.com" do |builder|
+          builder.use Him::Middleware::FirstLevelParseJSON
+          builder.adapter :test do |stub|
+            stub.get("/users/1") { [200, {}, { id: 1, fullname: "Lindsay Fünke", document: { url: nil } }.to_json] }
+            stub.get("/users/2") { [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)
+        expect(@user.document?).to be_falsey
+
+        @user = Foo::User.find(1)
+        expect(@user.document?).to be_falsey
+
+        @user = Foo::User.find(2)
+        expect(@user.document?).to 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 { is_expected.to respond_to(:fullname) }
+      it { is_expected.to respond_to(:fullname=) }
+      it { is_expected.to respond_to(:fullname?) }
+    end
+
+    it "defines setter that affects attributes" do
+      user = Foo::User.new
+      user.fullname = "Tobias Fünke"
+      expect(user.attributes[:fullname]).to eq("Tobias Fünke")
+    end
+
+    it "defines getter that reads attributes" do
+      user = Foo::User.new
+      user.assign_attributes(fullname: "Tobias Fünke")
+      expect(user.fullname).to eq("Tobias Fünke")
+    end
+
+    it "defines predicate that reads attributes" do
+      user = Foo::User.new
+      expect(user.fullname?).to be_falsey
+      user.assign_attributes(fullname: "Tobias Fünke")
+      expect(user.fullname?).to be_truthy
+    end
+
+    it "does not define a getter for attributes matching reserved words" do
+      user = Foo::User.new
+      user.assign_attributes(class: "klass")
+      expect(user.class.name).to eq("Foo::User")
+    end
+
+    it "does not crash when data includes an 'attributes' key" do
+      user = Foo::User.new(attributes: { foo: "bar" })
+      expect(user.attributes).to be_a(Hash)
+      expect(user.attributes[:attributes]).to eq("foo" => "bar")
+    end
+
+    context "when attribute methods are already defined" do
+      before do
+        class AbstractUser
+
+          def fullname
+            raise NotImplementedError
+          end
+
+          def fullname=(value)
+            raise NotImplementedError
+          end
+
+          def fullname?
+            raise NotImplementedError
+          end
+        end
+        @spawned_models << :AbstractUser
+
+        spawn_model "Foo::User", super_class: AbstractUser do
+          attributes :fullname
+        end
+      end
+
+      it "overrides getter method" do
+        user = Foo::User.new
+        expect { user.fullname }.to_not raise_error(NotImplementedError)
+      end
+
+      it "overrides setter method" do
+        user = Foo::User.new
+        expect { user.fullname = "foo" }.to_not raise_error(NotImplementedError)
+      end
+
+      it "overrides predicate method" do
+        user = Foo::User.new
+        expect { user.fullname? }.to_not raise_error(NotImplementedError)
+      end
+    end
+  end
+end

data/spec/model/callbacks_spec.rb

@@ -0,0 +1,194 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe "Him::Model and ActiveModel::Callbacks" do
+  before do
+    Him::API.setup url: "https://api.example.com" do |builder|
+      builder.use Him::Middleware::FirstLevelParseJSON
+    end
+  end
+
+  context :before_save do
+    subject { User.create(name: "Tobias Funke") }
+    before do
+      Him::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
+        spawn_model "User" do
+          before_save :alter_name
+          def alter_name
+            name.upcase!
+          end
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+
+    context "when using a block callback" do
+      before do
+        spawn_model "User" do
+          before_save -> { name.upcase! }
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+
+    context "when changing a value of an existing resource in a callback" do
+      before do
+        spawn_model "User" do
+          before_save :alter_name
+          def alter_name
+            self.name = "Lumberjack" if persisted?
+          end
+        end
+      end
+
+      it "should call the server with the changed value" do
+        expect(subject.name).to eq("Tobias Funke")
+        subject.save
+        expect(subject.name).to eq("Lumberjack")
+      end
+    end
+  end
+
+  context :before_create do
+    subject { User.create(name: "Tobias Funke") }
+    before do
+      Him::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
+        spawn_model "User" do
+          before_create :alter_name
+          def alter_name
+            name.upcase!
+          end
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+
+    context "when using a block callback" do
+      before do
+        spawn_model "User" do
+          before_create -> { name.upcase! }
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+  end
+
+  context :after_find do
+    subject { User.find(1) }
+    before do
+      Him::API.default_api.connection.adapter :test do |stub|
+        stub.get("/users/1") { [200, {}, { id: 1, name: "Tobias Funke" }.to_json] }
+      end
+    end
+
+    context "when using a symbol callback" do
+      before do
+        spawn_model "User" do
+          after_find :alter_name
+          def alter_name
+            name.upcase!
+          end
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+
+    context "callback invocation count" do
+      before do
+        spawn_model "User" do
+          attr_accessor :find_count
+          after_find :track_find
+          def track_find
+            self.find_count ||= 0
+            self.find_count += 1
+          end
+        end
+      end
+
+      it "calls after_find exactly once" do
+        user = User.find(1)
+        expect(user.find_count).to eq(1)
+      end
+    end
+
+    context "when using a block callback" do
+      before do
+        spawn_model "User" do
+          after_find -> { name.upcase! }
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+  end
+
+  context :after_initialize do
+    subject { User.new(name: "Tobias Funke") }
+
+    context "when using a symbol callback" do
+      before do
+        spawn_model "User" do
+          after_initialize :alter_name
+          def alter_name
+            name.upcase!
+          end
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+
+    context "when using a block callback" do
+      before do
+        spawn_model "User" do
+          after_initialize -> { name.upcase! }
+        end
+      end
+
+      describe "#name" do
+        subject { super().name }
+        it { is_expected.to eq("TOBIAS FUNKE") }
+      end
+    end
+  end
+end

data/spec/model/dirty_spec.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe "Him::Model and ActiveModel::Dirty" do
+  context "checking dirty attributes" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+        builder.adapter :test do |stub|
+          stub.get("/users")   { [200, {}, [{ id: 1, fullname: "Lindsay Fünke" }, { id: 2, fullname: "Maeby Fünke" }].to_json] }
+          stub.get("/users/1") { [200, {}, { id: 1, fullname: "Lindsay Fünke" }.to_json] }
+          stub.get("/users/2") { [200, {}, { id: 2, fullname: "Maeby Fünke" }.to_json] }
+          stub.get("/users/3") { [200, {}, { user_id: 3, fullname: "Maeby Fünke" }.to_json] }
+          stub.put("/users/1") { [200, {}, { id: 1, fullname: "Tobias Fünke" }.to_json] }
+          stub.put("/users/2") { [400, {}, { errors: ["Email cannot be blank"] }.to_json] }
+          stub.post("/users")  { [200, {}, { id: 1, fullname: "Tobias Fünke" }.to_json] }
+          stub.get("/users/1/posts") { [200, {}, [{ id: 1, user_id: 1, body: "Hello" }].to_json] }
+          stub.get("/users/1/posts/1") { [200, {}, { id: 1, user_id: 1, body: "Hello" }.to_json] }
+        end
+      end
+
+      spawn_model "Foo::Post" do
+        belongs_to :user
+        attributes :body
+      end
+      spawn_model "Foo::User" do
+        has_many :posts
+        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
+        expect(user.changes).to be_empty
+        expect(user).not_to be_changed
+      end
+      context "with successful save" do
+        it "tracks dirty attributes" do
+          user.fullname = "Tobias Fünke"
+          expect(user.fullname_changed?).to be_truthy
+          expect(user.email_changed?).to be_falsey
+          expect(user).to be_changed
+          user.save
+          expect(user).not_to be_changed
+        end
+
+        it "tracks only changed dirty attributes" do
+          user.fullname = user.fullname
+          expect(user.fullname_changed?).to be_falsey
+        end
+
+        it "tracks previous changes" do
+          user.fullname = "Tobias Fünke"
+          user.save
+          expect(user.previous_changes).to eq("fullname" => ["Lindsay Fünke", "Tobias 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")
+          expect(user.fullname_changed?).to be_truthy
+          expect(user).to be_changed
+          expect(user.changes.length).to eq(1)
+        end
+      end
+
+      context "with erroneous save" do
+        it "tracks dirty attributes" do
+          user = Foo::User.find(2)
+          user.fullname = "Tobias Fünke"
+          expect(user.fullname_changed?).to be_truthy
+          expect(user.email_changed?).to be_falsey
+          expect(user).to be_changed
+          user.save
+          expect(user).to be_changed
+        end
+      end
+    end
+
+    context "for an existing resource from an association" do
+      let(:post) { Foo::User.find(1).posts.find(1) }
+      it "has no changes" do
+        expect(post.changes).to be_empty
+        expect(post).to_not be_changed
+      end
+    end
+
+    context "for an existing resource from an association collection" do
+      let(:post) { Foo::User.find(1).posts.first }
+      it "has no changes" do
+        expect(post.changes).to be_empty
+        expect(post).to_not be_changed
+      end
+    end
+
+    context "for resources from a collection" do
+      let(:users) { Foo::User.all.fetch }
+      it "has no changes" do
+        users.each do |user|
+          expect(user.changes).to be_empty
+          expect(user).to_not be_changed
+        end
+      end
+    end
+
+    context "for new resource" do
+      let(:user) { Foo::User.new(fullname: "Lindsay Fünke") }
+      it "has changes" do
+        expect(user).to be_changed
+      end
+      it "tracks dirty attributes" do
+        user.fullname = "Tobias Fünke"
+        expect(user.fullname_changed?).to be_truthy
+        expect(user).to be_changed
+        user.save
+        expect(user).not_to be_changed
+      end
+    end
+
+    context "for a new resource from an association" do
+      let(:post) { Foo::User.find(1).posts.build }
+      it "has changes" do
+        expect(post).to be_changed
+      end
+    end
+  end
+end