him 0.1.0

data/spec/model/paths_spec.rb

@@ -0,0 +1,348 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe Him::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
+          expect(Foo::User.new(id: "foo").request_path).to eq("users/foo")
+          expect(Foo::User.new(id: nil).request_path).to eq("users")
+          expect(Foo::User.new.request_path).to eq("users")
+        end
+
+        it "builds paths with custom collection path" do
+          Foo::User.collection_path "/utilisateurs"
+          expect(Foo::User.new(id: "foo").request_path).to eq("/utilisateurs/foo")
+          expect(Foo::User.new.request_path).to eq("/utilisateurs")
+        end
+
+        it "builds paths with custom relative collection path" do
+          Foo::User.collection_path "utilisateurs"
+          expect(Foo::User.new(id: "foo").request_path).to eq("utilisateurs/foo")
+          expect(Foo::User.new.request_path).to eq("utilisateurs")
+        end
+
+        it "builds paths with custom collection path with multiple variables" do
+          Foo::User.collection_path "/organizations/:organization_id/utilisateurs"
+
+          expect(Foo::User.new(id: "foo").request_path(_organization_id: "acme")).to eq("/organizations/acme/utilisateurs/foo")
+          expect(Foo::User.new.request_path(_organization_id: "acme")).to eq("/organizations/acme/utilisateurs")
+
+          expect(Foo::User.new(id: "foo", organization_id: "acme").request_path).to eq("/organizations/acme/utilisateurs/foo")
+          expect(Foo::User.new(organization_id: "acme").request_path).to eq("/organizations/acme/utilisateurs")
+        end
+
+        it "builds paths with custom relative collection path with multiple variables" do
+          Foo::User.collection_path "organizations/:organization_id/utilisateurs"
+
+          expect(Foo::User.new(id: "foo").request_path(_organization_id: "acme")).to eq("organizations/acme/utilisateurs/foo")
+          expect(Foo::User.new.request_path(_organization_id: "acme")).to eq("organizations/acme/utilisateurs")
+
+          expect(Foo::User.new(id: "foo", organization_id: "acme").request_path).to eq("organizations/acme/utilisateurs/foo")
+          expect(Foo::User.new(organization_id: "acme").request_path).to eq("organizations/acme/utilisateurs")
+        end
+
+        it "builds paths with custom item path" do
+          Foo::User.resource_path "/utilisateurs/:id"
+          expect(Foo::User.new(id: "foo").request_path).to eq("/utilisateurs/foo")
+          expect(Foo::User.new.request_path).to eq("users")
+        end
+
+        it "builds paths with custom relative item path" do
+          Foo::User.resource_path "utilisateurs/:id"
+          expect(Foo::User.new(id: "foo").request_path).to eq("utilisateurs/foo")
+          expect(Foo::User.new.request_path).to eq("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(Him::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"
+          expect(Foo::User.new(id: "Привет").request_path(_organization_id: "лол")).to eq("organizations/%D0%BB%D0%BE%D0%BB/utilisateurs/%D0%9F%D1%80%D0%B8%D0%B2%D0%B5%D1%82")
+          expect(Foo::User.new(organization_id: "лол", id: "Привет").request_path).to eq("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
+          expect(Foo::AdminUser.new(id: "foo").request_path).to eq("admin_users/foo")
+          expect(Foo::AdminUser.new.request_path).to eq("admin_users")
+        end
+
+        it "builds paths with custom collection path" do
+          Foo::AdminUser.collection_path "/users"
+          expect(Foo::AdminUser.new(id: "foo").request_path).to eq("/users/foo")
+          expect(Foo::AdminUser.new.request_path).to eq("/users")
+        end
+
+        it "builds paths with custom relative collection path" do
+          Foo::AdminUser.collection_path "users"
+          expect(Foo::AdminUser.new(id: "foo").request_path).to eq("users/foo")
+          expect(Foo::AdminUser.new.request_path).to eq("users")
+        end
+
+        it "builds paths with custom collection path with multiple variables" do
+          Foo::AdminUser.collection_path "/organizations/:organization_id/users"
+          expect(Foo::AdminUser.new(id: "foo").request_path(_organization_id: "acme")).to eq("/organizations/acme/users/foo")
+          expect(Foo::AdminUser.new.request_path(_organization_id: "acme")).to eq("/organizations/acme/users")
+        end
+
+        it "builds paths with custom relative collection path with multiple variables" do
+          Foo::AdminUser.collection_path "organizations/:organization_id/users"
+          expect(Foo::AdminUser.new(id: "foo").request_path(_organization_id: "acme")).to eq("organizations/acme/users/foo")
+          expect(Foo::AdminUser.new.request_path(_organization_id: "acme")).to eq("organizations/acme/users")
+        end
+
+        it "builds paths with custom item path" do
+          Foo::AdminUser.resource_path "/users/:id"
+          expect(Foo::AdminUser.new(id: "foo").request_path).to eq("/users/foo")
+          expect(Foo::AdminUser.new.request_path).to eq("admin_users")
+        end
+
+        it "builds paths with custom relative item path" do
+          Foo::AdminUser.resource_path "users/:id"
+          expect(Foo::AdminUser.new(id: "foo").request_path).to eq("users/foo")
+          expect(Foo::AdminUser.new.request_path).to eq("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(Him::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(Him::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
+        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/foo") { [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
+        expect(User.find("foo").id).to eq("foo")
+        expect(User.find("foo").id).to eq("foo")
+      end
+    end
+
+    context "nested model" do
+      before do
+        spawn_model "Foo::User"
+      end
+
+      describe "#request_path" do
+        it "builds paths with defaults" do
+          expect(Foo::User.new(id: "foo").request_path).to eq("users/foo")
+          expect(Foo::User.new.request_path).to eq("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
+          expect(User.new(UserId: "foo").request_path).to eq("users/foo")
+          expect(User.new(id: "foo").request_path).to eq("users")
+        end
+
+        it "replaces :id with the appropriate primary key" do
+          expect(Customer.new(customer_id: "joe").request_path).to eq("customers/joe")
+          expect(Customer.new(id: "joe").request_path).to eq("customers")
+        end
+      end
+    end
+  end
+
+  context "making subdomain HTTP requests" 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("organizations/2/users") { [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") { [200, {}, { id: 1, fullname: "Tobias Fünke", organization_id: 2 }.to_json] }
+          stub.put("organizations/2/users/1") { [200, {}, { id: 1, fullname: "Lindsay Fünke", organization_id: 2 }.to_json] }
+          stub.get("organizations/2/users/1") { [200, {}, { id: 1, fullname: "Tobias Fünke", organization_id: 2, active: true }.to_json] }
+          stub.delete("organizations/2/users/1") { [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)
+        expect(@user.id).to eq(1)
+        expect(@user.fullname).to eq("Tobias Fünke")
+      end
+
+      it "maps a single resource using a scope to a Ruby object" do
+        Foo::User.scope :for_organization, ->(o) { where(organization_id: o) }
+        @user = Foo::User.for_organization(2).find(1)
+        expect(@user.id).to eq(1)
+        expect(@user.fullname).to eq("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
+        expect(@users.length).to eq(2)
+        expect(@users.first.fullname).to eq("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)
+        expect(@new_user.new?).to be_truthy
+
+        @existing_user = Foo::User.find(1, _organization_id: 2)
+        expect(@existing_user.new?).to 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)
+        expect(@user.id).to eq(1)
+        expect(@user.fullname).to eq("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
+        expect(@user.fullname).to eq("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)
+        expect(@user.fullname).to eq("Tobias Fünke")
+        @user.fullname = "Kittie Sanchez"
+        expect(@user.fullname).to eq("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)
+        expect(@user.fullname).to eq("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
+        expect(@user.fullname).to eq("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)
+        expect(@user.active).to be_falsey
+      end
+
+      it "handle resource deletion through #destroy on an existing resource" do
+        @user = Foo::User.find(1, _organization_id: 2)
+        @user.destroy
+        expect(@user.active).to be_falsey
+      end
+    end
+  end
+
+  context "making path HTTP requests" do
+    before do
+      Him::API.setup url: "https://example.com/api/" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+        builder.adapter :test do |stub|
+          stub.get("/api/organizations/2/users") { [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") { [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)
+        expect(@user.id).to eq(1)
+        expect(@user.fullname).to eq("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
+        expect(@users.length).to eq(2)
+        expect(@users.first.fullname).to eq("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)
+        expect(@user.id).to eq(1)
+        expect(@user.fullname).to eq("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
+        expect(@users.length).to eq(2)
+        expect(@users.first.fullname).to eq("Tobias Fünke")
+      end
+    end
+  end
+end

data/spec/model/relation_spec.rb

@@ -0,0 +1,255 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe Him::Model::Relation do
+  describe :where do
+    context "for base classes" 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?foo=1&bar=2") { ok! [{ id: 2, fullname: "Tobias Fünke" }] }
+            stub.get("/users?admin=1") { ok! [{ id: 1, fullname: "Tobias Fünke" }] }
+            stub.get("/users?id=3&foo=2") { ok! [{ id: 3, fullname: "Tobias Fünke" }] }
+
+            stub.get("/users") do
+              ok! [
+                { id: 1, fullname: "Tobias Fünke" },
+                { id: 2, fullname: "Lindsay Fünke" },
+                @created_user
+              ].compact
+            end
+
+            stub.post("/users") do
+              @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 immediately" do
+        expect(Foo::User).to receive(:request).never
+        @users = Foo::User.where(admin: 1)
+      end
+
+      it "fetches the data and passes query parameters" do
+        expect(Foo::User).to receive(:request).once.and_call_original
+        @users = Foo::User.where(admin: 1)
+        expect(@users).to respond_to(:length)
+        expect(@users.size).to eql 1
+      end
+
+      it "fetches the data by parameters including primary_key" do
+        expect(Foo::User).to receive(:request).once.and_call_original
+        @users = Foo::User.where(id: 3, foo: 2)
+        expect(@users).to respond_to(:length)
+        expect(@users.size).to eql 1
+      end
+
+      it "chains multiple where statements" do
+        @user = Foo::User.where(foo: 1).where(bar: 2).first
+        expect(@user.id).to eq(2)
+      end
+
+      it "does not reuse relations" do
+        expect(Foo::User.all.size).to eql 2
+        expect(Foo::User.create(fullname: "George Michael Bluth").id).to eq(3)
+        expect(Foo::User.all.size).to eql 3
+      end
+
+      it "returns an empty collection without fetching when [] is given" do
+        expect(Foo::User).not_to receive(:request)
+        users = Foo::User.where(fullname: [])
+        expect(users).to respond_to(:length)
+        expect(users.size).to eql 0
+      end
+    end
+
+    context "for parent class" 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?page=2") { ok! [{ id: 1, fullname: "Tobias Fünke" }, { id: 2, fullname: "Lindsay Fünke" }] }
+          end
+        end
+
+        spawn_model("Foo::Model") do
+          scope :page, ->(page) { where(page: page) }
+        end
+
+        class User < Foo::Model; end
+        @spawned_models << :User
+      end
+
+      it "propagates the scopes through its children" do
+        expect(User.page(2).length).to eq(2)
+        expect(User.scoped.page(2).length).to eq(2)
+      end
+    end
+  end
+
+  describe :create 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.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
+        expect(@user.id).to eq(1)
+        expect(@user.fullname).to eq("Tobias Fünke")
+        expect(@user.email).to eq("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")
+        expect(@user.id).to eq(1)
+        expect(@user.fullname).to eq("Tobias Fünke")
+        expect(@user.email).to eq("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
+      expect(@new_user.new?).to be_truthy
+      expect(@new_user.fullname).to eq("Tobias Fünke")
+    end
+  end
+
+  describe :scope 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?what=4&where=3") { ok! [{ id: 3, fullname: "Maeby Fünke" }] }
+          stub.get("/users?what=2") { ok! [{ id: 2, fullname: "Lindsay Fünke" }] }
+          stub.get("/users?where=6") { ok! [{ id: 4, fullname: "Tobias Fünke" }] }
+          stub.get('/bar/users') { ok! [] }
+        end
+      end
+
+      spawn_model "Foo::User" do
+        scope :foo, ->(v) { where(what: v) }
+        scope :bar, ->(v) { where(where: v) }
+        scope :baz, -> { bar(6) }
+      end
+
+      spawn_model "Bar::User" do
+        collection_path '/bar/users'
+        scope :baz, -> { where(where: 7) }
+      end
+    end
+
+    it "passes query parameters" do
+      @user = Foo::User.foo(2).first
+      expect(@user.id).to eq(2)
+    end
+
+    it "passes multiple query parameters" do
+      @user = Foo::User.foo(4).bar(3).first
+      expect(@user.id).to eq(3)
+    end
+
+    it "handles embedded scopes" do
+      @user = Foo::User.baz.first
+      expect(@user.id).to eq(4)
+    end
+
+    it "does not share scope with other models" do
+      expect(Bar::User.scoped).not_to respond_to(:foo, :bar)
+      expect(Foo::User.scoped.baz.params[:where]).to eq(6)
+      expect(Bar::User.scoped.baz.params[:where]).to eq(7)
+    end
+
+  end
+
+  describe :default_scope do
+    context "for new objects" do
+      before do
+        spawn_model "Foo::User" do
+          default_scope -> { where(active: true) }
+          default_scope -> { where(admin: true) }
+        end
+      end
+
+      it "should apply the scope to the attributes" do
+        expect(Foo::User.new).to be_active
+        expect(Foo::User.new).to be_admin
+      end
+    end
+
+    context "for fetched resources" 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.post("/users") { |env| ok! id: 3, active: (params(env)[:active] == "true") }
+          end
+        end
+
+        spawn_model "Foo::User" do
+          default_scope -> { where(active: true) }
+        end
+      end
+
+      it("should apply the scope to the request") { expect(Foo::User.create).to be_active }
+    end
+
+    context "for fetched collections" 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?active=true") { |env| ok! [{ id: 3, active: (params(env)[:active] == "true") }] }
+          end
+        end
+
+        spawn_model "Foo::User" do
+          default_scope -> { where(active: true) }
+        end
+      end
+
+      it("should apply the scope to the request") { expect(Foo::User.all.first).to be_active }
+    end
+  end
+
+  describe :map 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") do
+            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
+      expect(Foo::User.all.map(&:fullname)).to eq(["Tobias Fünke", "Lindsay Fünke"])
+    end
+  end
+end

data/spec/model/validations_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe "Him::Model and ActiveModel::Validations" do
+  context "validating attributes" do
+    before do
+      spawn_model "Foo::User" do
+        attributes :fullname, :email, :age
+        validates_presence_of :fullname
+        validates_presence_of :email
+        validates_numericality_of :age
+      end
+    end
+
+    it "validates attributes when calling #valid?" do
+      user = Foo::User.new
+      expect(user).not_to be_valid
+      expect(user.errors.full_messages).to include("Fullname can't be blank")
+      expect(user.errors.full_messages).to include("Email can't be blank")
+      user.fullname = "Tobias Fünke"
+      user.email = "tobias@bluthcompany.com"
+      user.age = 35
+      expect(user).to 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"])
+      expect(user.errors).to include("Email cannot be blank")
+    end
+  end
+end