him 0.1.0

data/spec/model/parse_spec.rb

@@ -0,0 +1,619 @@
+# encoding: utf-8
+
+require File.join(File.dirname(__FILE__), "../spec_helper.rb")
+
+describe Him::Model::Parse do
+  context "when include_root_in_json is set" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+      end
+
+      Him::API.default_api.connection.adapter :test do |stub|
+        stub.post("/users") { |env| [200, {}, { user: { id: 1, fullname: params(env)[:user][:fullname] } }.to_json] }
+        stub.post("/users/admins") { |env| [200, {}, { user: { id: 1, fullname: params(env)[:user][:fullname] } }.to_json] }
+      end
+    end
+
+    context "to true" do
+      before do
+        spawn_model "Foo::User" do
+          include_root_in_json true
+          parse_root_in_json true
+          custom_post :admins
+        end
+      end
+
+      it "inherits attributes from parent class" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+        end
+
+        expect(Foo::ChildUser).to be_include_root_in_json
+      end
+
+      it "allows `include_root_in_json` to be set to `false` on a child model" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+          include_root_in_json false
+        end
+
+        expect(Foo::ChildUser).to_not be_include_root_in_json
+      end
+
+      it "wraps params in the element name in `to_params`" do
+        @new_user = Foo::User.new(fullname: "Tobias Fünke")
+        expect(@new_user.to_params).to eq(user: { fullname: "Tobias Fünke" })
+      end
+
+      it "wraps params in the element name in `.create`" do
+        @new_user = Foo::User.admins(fullname: "Tobias Fünke")
+        expect(@new_user.fullname).to eq("Tobias Fünke")
+      end
+    end
+
+    context "to false" do
+      before do
+        spawn_model "Foo::User" do
+          include_root_in_json false
+        end
+      end
+
+      it "inherits attributes from parent class" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+        end
+
+        expect(Foo::ChildUser).to_not be_include_root_in_json
+      end
+
+      it "allows `include_root_in_json` to be set to `true` on a child model" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+          include_root_in_json true
+        end
+
+        expect(Foo::ChildUser).to be_include_root_in_json
+      end
+    end
+
+    context "to a symbol" do
+      before do
+        spawn_model "Foo::User" do
+          include_root_in_json :person
+          parse_root_in_json :person
+        end
+      end
+
+      it "wraps params in the specified value" do
+        @new_user = Foo::User.new(fullname: "Tobias Fünke")
+        expect(@new_user.to_params).to eq(person: { fullname: "Tobias Fünke" })
+      end
+    end
+
+    context "in the parent class" do
+      before do
+        spawn_model("Foo::Model") { include_root_in_json true }
+
+        class User < Foo::Model; end
+        @spawned_models << :User
+      end
+
+      it "wraps params with the class name" do
+        @new_user = User.new(fullname: "Tobias Fünke")
+        expect(@new_user.to_params).to eq(user: { fullname: "Tobias Fünke" })
+      end
+    end
+  end
+
+  context "when `request_new_object_on_build` is set" do
+    context "to true" do
+      before do
+        spawn_model "Foo::User" do
+          request_new_object_on_build true
+        end
+      end
+
+      it "inherits attributes from parent class" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+        end
+
+        expect(Foo::ChildUser).to be_request_new_object_on_build
+      end
+
+      it "allows `request_new_object_on_build` to be set to `false` on a child model" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+          request_new_object_on_build false
+        end
+
+        expect(Foo::ChildUser).to_not be_request_new_object_on_build
+      end
+    end
+
+    context "to false" do
+      before do
+        spawn_model "Foo::User" do
+          request_new_object_on_build false
+        end
+      end
+
+      it "inherits attributes from parent class" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+        end
+
+        expect(Foo::ChildUser).to_not be_request_new_object_on_build
+      end
+
+      it "allows `request_new_object_on_build` to be set to `true` on a child model" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+          request_new_object_on_build true
+        end
+
+        expect(Foo::ChildUser).to be_request_new_object_on_build
+      end
+    end
+  end
+
+  context "when parse_root_in_json is set" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+      end
+    end
+
+    context "to true" do
+      before do
+        Him::API.default_api.connection.adapter :test do |stub|
+          stub.post("/users") { [200, {}, { user: { id: 1, fullname: "Lindsay Fünke" } }.to_json] }
+          stub.get("/users") { [200, {}, [{ user: { id: 1, fullname: "Lindsay Fünke" } }].to_json] }
+          stub.get("/users/admins") { [200, {}, [{ user: { id: 1, fullname: "Lindsay Fünke" } }].to_json] }
+          stub.get("/users/1") { [200, {}, { user: { id: 1, fullname: "Lindsay Fünke" } }.to_json] }
+          stub.put("/users/1") { [200, {}, { user: { id: 1, fullname: "Tobias Fünke Jr." } }.to_json] }
+        end
+
+        spawn_model("Foo::User") do
+          parse_root_in_json true
+          custom_get :admins
+        end
+      end
+
+      it "inherits attributes from parent class" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+        end
+
+        expect(Foo::ChildUser).to be_parse_root_in_json
+      end
+
+      it "allows `parse_root_in_json` to be set to `false` on a child model" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+          parse_root_in_json false
+        end
+
+        expect(Foo::ChildUser).to_not be_parse_root_in_json
+      end
+
+      it "parse the data from the JSON root element after .create" do
+        @new_user = Foo::User.create(fullname: "Lindsay Fünke")
+        expect(@new_user.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after an arbitrary HTTP request" do
+        @new_user = Foo::User.admins
+        expect(@new_user.first.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after .all" do
+        @users = Foo::User.all
+        expect(@users.first.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after .find" do
+        @user = Foo::User.find(1)
+        expect(@user.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after .save" do
+        @user = Foo::User.find(1)
+        @user.fullname = "Tobias Fünke"
+        @user.save
+        expect(@user.fullname).to eq("Tobias Fünke Jr.")
+      end
+    end
+
+    context "to false" do
+      before do
+        spawn_model "Foo::User" do
+          parse_root_in_json false
+        end
+      end
+
+      it "inherits attributes from parent class" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+        end
+
+        expect(Foo::ChildUser).to_not be_parse_root_in_json
+      end
+
+      it "allows `parse_root_in_json` to be set to `true` on a child model" do
+        spawn_model "Foo::ChildUser", super_class: Foo::User do
+          parse_root_in_json true
+        end
+
+        expect(Foo::ChildUser).to be_parse_root_in_json
+      end
+    end
+
+    context "to a symbol" do
+      before do
+        Him::API.default_api.connection.adapter :test do |stub|
+          stub.post("/users") { [200, {}, { person: { id: 1, fullname: "Lindsay Fünke" } }.to_json] }
+        end
+
+        spawn_model("Foo::User") { parse_root_in_json :person }
+      end
+
+      it "parse the data with the symbol" do
+        @new_user = Foo::User.create(fullname: "Lindsay Fünke")
+        expect(@new_user.id).to eq(1)
+        expect(@new_user.fullname).to eq("Lindsay Fünke")
+      end
+    end
+
+    context "in the parent class" do
+      before do
+        Him::API.default_api.connection.adapter :test do |stub|
+          stub.post("/users") { [200, {}, { user: { id: 1, fullname: "Lindsay Fünke" } }.to_json] }
+          stub.get("/users") { [200, {}, { users: [{ id: 1, fullname: "Lindsay Fünke" }] }.to_json] }
+        end
+
+        spawn_model("Foo::Model") { parse_root_in_json true, format: :active_model_serializers }
+        class User < Foo::Model
+
+          collection_path "/users"
+        end
+
+        @spawned_models << :User
+      end
+
+      it "parse the data with the symbol" do
+        @new_user = User.create(fullname: "Lindsay Fünke")
+        expect(@new_user.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parses the collection of data" do
+        @users = User.all
+        expect(@users.first.fullname).to eq("Lindsay Fünke")
+      end
+    end
+
+    context "to true with format: :active_model_serializers" do
+      before do
+        Him::API.default_api.connection.adapter :test do |stub|
+          stub.post("/users") { [200, {}, { user: { id: 1, fullname: "Lindsay Fünke" } }.to_json] }
+          stub.get("/users") { [200, {}, { users: [{ id: 1, fullname: "Lindsay Fünke" }] }.to_json] }
+          stub.get("/users/admins") { [200, {}, { users: [{ id: 1, fullname: "Lindsay Fünke" }] }.to_json] }
+          stub.get("/users/1") { [200, {}, { user: { id: 1, fullname: "Lindsay Fünke" } }.to_json] }
+          stub.put("/users/1") { [200, {}, { user: { id: 1, fullname: "Tobias Fünke Jr." } }.to_json] }
+        end
+
+        spawn_model("Foo::User") do
+          parse_root_in_json true, format: :active_model_serializers
+          custom_get :admins
+        end
+      end
+
+      it "parse the data from the JSON root element after .create" do
+        @new_user = Foo::User.create(fullname: "Lindsay Fünke")
+        expect(@new_user.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after an arbitrary HTTP request" do
+        @users = Foo::User.admins
+        expect(@users.first.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after .all" do
+        @users = Foo::User.all
+        expect(@users.first.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after .find" do
+        @user = Foo::User.find(1)
+        expect(@user.fullname).to eq("Lindsay Fünke")
+      end
+
+      it "parse the data from the JSON root element after .save" do
+        @user = Foo::User.find(1)
+        @user.fullname = "Tobias Fünke"
+        @user.save
+        expect(@user.fullname).to eq("Tobias Fünke Jr.")
+      end
+    end
+  end
+
+  context "when to_params is set" 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"] }
+        end
+      end
+
+      spawn_model "Foo::User" do
+        def to_params
+          { fullname: "Lindsay Fünke" }
+        end
+      end
+    end
+
+    it "changes the request parameters for one-line resource creation" do
+      @user = Foo::User.create(fullname: "Tobias Fünke")
+      expect(@user.fullname).to eq("Lindsay Fünke")
+    end
+
+    it "changes the request parameters for Model.new + #save" do
+      @user = Foo::User.new(fullname: "Tobias Fünke")
+      @user.save
+      expect(@user.fullname).to eq("Lindsay Fünke")
+    end
+  end
+
+  context "when parse_root_in_json is true without AMS format" 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") { [200, {}, { users: [{ id: 1, name: "Tobias" }] }.to_json] }
+          stub.get("/users/1") { [200, {}, { user: { id: 1, name: "Tobias" } }.to_json] }
+        end
+      end
+
+      spawn_model "Foo::User" do
+        parse_root_in_json true
+      end
+    end
+
+    it "unwraps collection root key" do
+      users = Foo::User.all
+      expect(users.length).to eq(1)
+      expect(users.first.name).to eq("Tobias")
+    end
+
+    it "unwraps single resource root key" do
+      user = Foo::User.find(1)
+      expect(user.name).to eq("Tobias")
+    end
+  end
+
+  context "when associations reference each other" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+      end
+
+      Him::API.default_api.connection.adapter :test do |stub|
+        stub.get("/users/1") { |env| [200, {}, { id: 1, name: "Tobias", comments: [{ id: 2, body: "Hey!", user_id: 1 }] }.to_json] }
+      end
+
+      spawn_model "Foo::User" do
+        has_many :comments, class_name: "Foo::Comment"
+      end
+
+      spawn_model "Foo::Comment" do
+        belongs_to :user, class_name: "Foo::User"
+      end
+    end
+
+    it "does not infinitely loop when calling to_params with cyclic associations" do
+      user = Foo::User.find(1)
+      expect { Timeout.timeout(5) { user.to_params } }.not_to raise_error
+    end
+
+    it "does not include belongs_to parent data in nested to_params" do
+      user = Foo::User.find(1)
+      params = user.to_params
+      comment_params = params[:comments].first
+      expect(comment_params).not_to have_key(:user)
+    end
+  end
+
+  context "when parsed_data has string keys" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Class.new(Faraday::Middleware) {
+          def on_complete(env)
+            env[:body] = {
+              "data" => JSON.parse(env[:body]),
+              "metadata" => {},
+              "errors" => {}
+            }
+          end
+        }
+        builder.adapter :test do |stub|
+          stub.get("/users") { [200, {}, [{ "id" => 1, "name" => "Tobias" }].to_json] }
+          stub.get("/users/1") { [200, {}, { "id" => 1, "name" => "Tobias" }.to_json] }
+        end
+      end
+
+      spawn_model "Foo::User"
+    end
+
+    it "handles collections with string-keyed parsed data" do
+      users = Foo::User.all
+      expect(users.length).to eq(1)
+      expect(users.first.name).to eq("Tobias")
+    end
+
+    it "handles single resources with string-keyed parsed data" do
+      user = Foo::User.find(1)
+      expect(user.name).to eq("Tobias")
+    end
+  end
+
+  context "when parse_root_in_json set json_api to true" 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, {}, { users: [{ id: 1, fullname: "Lindsay Fünke" }] }.to_json] }
+          stub.get("/users/admins") { [200, {}, { users: [{ id: 1, fullname: "Lindsay Fünke" }] }.to_json] }
+          stub.get("/users/1") { [200, {}, { users: [{ id: 1, fullname: "Lindsay Fünke" }] }.to_json] }
+          stub.post("/users") { [200, {}, { users: [{ fullname: "Lindsay Fünke" }] }.to_json] }
+          stub.put("/users/1") { [200, {}, { users: [{ id: 1, fullname: "Tobias Fünke Jr." }] }.to_json] }
+        end
+      end
+
+      spawn_model("Foo::User") do
+        parse_root_in_json true, format: :json_api
+        include_root_in_json true
+        custom_get :admins
+      end
+    end
+
+    it "parse the data from the JSON root element after .create" do
+      @new_user = Foo::User.create(fullname: "Lindsay Fünke")
+      expect(@new_user.fullname).to eq("Lindsay Fünke")
+    end
+
+    it "parse the data from the JSON root element after an arbitrary HTTP request" do
+      @new_user = Foo::User.admins
+      expect(@new_user.first.fullname).to eq("Lindsay Fünke")
+    end
+
+    it "parse the data from the JSON root element after .all" do
+      @users = Foo::User.all
+      expect(@users.first.fullname).to eq("Lindsay Fünke")
+    end
+
+    it "parse the data from the JSON root element after .find" do
+      @user = Foo::User.find(1)
+      expect(@user.fullname).to eq("Lindsay Fünke")
+    end
+
+    it "parse the data from the JSON root element after .save" do
+      @user = Foo::User.find(1)
+      @user.fullname = "Tobias Fünke"
+      @user.save
+      expect(@user.fullname).to eq("Tobias Fünke Jr.")
+    end
+
+    it "parse the data from the JSON root element after new/save" do
+      @user = Foo::User.new
+      @user.fullname = "Lindsay Fünke (before save)"
+      @user.save
+      expect(@user.fullname).to eq("Lindsay Fünke")
+    end
+  end
+
+  context "when include_root_in_json set json_api" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+      end
+
+      Him::API.default_api.connection.adapter :test do |stub|
+        stub.post("/users") { |env| [200, {}, { users: [{ id: 1, fullname: params(env)[:users][:fullname] }] }.to_json] }
+      end
+    end
+
+    context "to true" do
+      before do
+        spawn_model "Foo::User" do
+          include_root_in_json true
+          parse_root_in_json true, format: :json_api
+          custom_post :admins
+        end
+      end
+
+      it "wraps params in the element name in `to_params`" do
+        @new_user = Foo::User.new(fullname: "Tobias Fünke")
+        expect(@new_user.to_params).to eq(users: [{ fullname: "Tobias Fünke" }])
+      end
+
+      it "wraps params in the element name in `.where`" do
+        @new_user = Foo::User.where(fullname: "Tobias Fünke").build
+        expect(@new_user.fullname).to eq("Tobias Fünke")
+      end
+    end
+  end
+
+  context "when send_only_modified_attributes is set" do
+    before do
+      Him::API.setup url: "https://api.example.com", send_only_modified_attributes: true do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+      end
+
+      Him::API.default_api.connection.adapter :test do |stub|
+        stub.get("/users/1") { [200, {}, { id: 1, first_name: "Gooby", last_name: "Pls" }.to_json] }
+      end
+
+      spawn_model "Foo::User" do
+        include_root_in_json true
+      end
+    end
+
+    it "only sends the attributes that were modified" do
+      user = Foo::User.find 1
+      user.first_name = "Someone"
+      expect(user.to_params).to eql(user: { first_name: "Someone" })
+    end
+
+    it "sends all attributes when changes is empty (custom actions)" do
+      user = Foo::User.find 1
+      params = Foo::User.to_params(user.attributes)
+      expect(params).to eql(user: { id: 1, first_name: "Gooby", last_name: "Pls" })
+    end
+  end
+
+  context 'when passed a non-Her ActiveModel instance' do
+    before do
+      klass = Class.new do
+        include ActiveModel::Serialization
+
+        def attributes
+          { 'name' => nil }
+        end
+
+        def name
+          'foo'
+        end
+      end
+
+      @model = klass.new
+
+      Him::API.setup
+      spawn_model 'Foo::User'
+    end
+
+    it 'serializes the instance in `to_params`' do
+      attributes = { model: @model }
+      user = Foo::User.new(attributes)
+      expect(user.to_params).to eq(model: { name: 'foo' })
+    end
+  end
+
+  context "when attribute uses the same name as root element" do
+    before do
+      Him::API.setup url: "https://api.example.com" do |builder|
+        builder.use Him::Middleware::FirstLevelParseJSON
+        builder.use Faraday::Request::UrlEncoded
+      end
+
+      Him::API.default_api.connection.adapter :test do |stub|
+        stub.post("/users") { |env| [200, {}, { user: "foobar", id: 1, fullname: params(env)[:fullname] }.to_json] }
+      end
+
+      spawn_model "Foo::User"
+    end
+
+    it "parses as attribute instead of root element" do
+      user = Foo::User.create(fullname: "barfoo")
+      expect(user.fullname).to eq "barfoo"
+      expect(user.user).to eq "foobar"
+    end
+  end
+end