her 0.8.2 → 0.8.3

data/spec/model/parse_spec.rb

@@ -4,14 +4,14 @@ require File.join(File.dirname(__FILE__), "../spec_helper.rb")
 describe Her::Model::Parse do
   context "when include_root_in_json is set" do
     before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
+      Her::API.setup url: "https://api.example.com" do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON
         builder.use Faraday::Request::UrlEncoded
       end
 
       Her::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] }
+        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
 
@@ -25,13 +25,13 @@ describe Her::Model::Parse do
       end
 
       it "wraps params in the element name in `to_params`" do
-        @new_user = Foo::User.new(:fullname => "Tobias Fünke")
-        @new_user.to_params.should == { :user => { :fullname => "Tobias Fünke" } }
+        @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")
-        @new_user.fullname.should == "Tobias Fünke"
+        @new_user = Foo::User.admins(fullname: "Tobias Fünke")
+        expect(@new_user.fullname).to eq("Tobias Fünke")
       end
     end
 
@@ -44,8 +44,8 @@ describe Her::Model::Parse do
       end
 
       it "wraps params in the specified value" do
-        @new_user = Foo::User.new(:fullname => "Tobias Fünke")
-        @new_user.to_params.should == { :person => { :fullname => "Tobias Fünke" } }
+        @new_user = Foo::User.new(fullname: "Tobias Fünke")
+        expect(@new_user.to_params).to eq(person: { fullname: "Tobias Fünke" })
       end
     end
 
@@ -58,15 +58,15 @@ describe Her::Model::Parse do
       end
 
       it "wraps params with the class name" do
-        @new_user = User.new(:fullname => "Tobias Fünke")
-        @new_user.to_params.should == { :user => { :fullname => "Tobias Fünke" } }
+        @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 parse_root_in_json is set" do
     before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
+      Her::API.setup url: "https://api.example.com" do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON
         builder.use Faraday::Request::UrlEncoded
       end
@@ -75,11 +75,11 @@ describe Her::Model::Parse do
     context "to true" do
       before do
         Her::API.default_api.connection.adapter :test do |stub|
-          stub.post("/users") { |env| [200, {}, { :user => { :id => 1, :fullname => "Lindsay Fünke" } }.to_json] }
-          stub.get("/users") { |env| [200, {}, [{ :user => { :id => 1, :fullname => "Lindsay Fünke" } }].to_json] }
-          stub.get("/users/admins") { |env| [200, {}, [{ :user => { :id => 1, :fullname => "Lindsay Fünke" } }].to_json] }
-          stub.get("/users/1") { |env| [200, {}, { :user => { :id => 1, :fullname => "Lindsay Fünke" } }.to_json] }
-          stub.put("/users/1") { |env| [200, {}, { :user => { :id => 1, :fullname => "Tobias Fünke Jr." } }.to_json] }
+          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
@@ -89,53 +89,53 @@ describe Her::Model::Parse do
       end
 
       it "parse the data from the JSON root element after .create" do
-        @new_user = Foo::User.create(:fullname => "Lindsay Fünke")
-        @new_user.fullname.should == "Lindsay Fünke"
+        @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
-        @new_user.first.fullname.should == "Lindsay Fünke"
+        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
-        @users.first.fullname.should == "Lindsay Fünke"
+        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)
-        @user.fullname.should == "Lindsay Fünke"
+        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
-        @user.fullname.should == "Tobias Fünke Jr."
+        expect(@user.fullname).to eq("Tobias Fünke Jr.")
       end
     end
 
     context "to a symbol" do
       before do
         Her::API.default_api.connection.adapter :test do |stub|
-          stub.post("/users") { |env| [200, {}, { :person => { :id => 1, :fullname => "Lindsay Fünke" } }.to_json] }
+          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")
-        @new_user.fullname.should == "Lindsay Fünke"
+        @new_user = Foo::User.create(fullname: "Lindsay Fünke")
+        expect(@new_user.fullname).to eq("Lindsay Fünke")
       end
     end
 
     context "in the parent class" do
       before do
         Her::API.default_api.connection.adapter :test do |stub|
-          stub.post("/users") { |env| [200, {}, { :user => { :id => 1, :fullname => "Lindsay Fünke" } }.to_json] }
-          stub.get("/users") { |env| [200, {}, { :users => [ { :id => 1, :fullname => "Lindsay Fünke" } ] }.to_json] }
+          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 }
@@ -147,155 +147,155 @@ describe Her::Model::Parse do
       end
 
       it "parse the data with the symbol" do
-        @new_user = User.create(:fullname => "Lindsay Fünke")
-        @new_user.fullname.should == "Lindsay Fünke"
+        @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
-        @users.first.fullname.should == "Lindsay Fünke"
+        expect(@users.first.fullname).to eq("Lindsay Fünke")
       end
     end
 
-    context "to true with :format => :active_model_serializers" do
+    context "to true with format: :active_model_serializers" do
       before do
         Her::API.default_api.connection.adapter :test do |stub|
-          stub.post("/users") { |env| [200, {}, { :user => { :id => 1, :fullname => "Lindsay Fünke" } }.to_json] }
-          stub.get("/users") { |env| [200, {}, { :users => [ { :id => 1, :fullname => "Lindsay Fünke" } ] }.to_json] }
-          stub.get("/users/admins") { |env| [200, {}, { :users => [ { :id => 1, :fullname => "Lindsay Fünke" } ] }.to_json] }
-          stub.get("/users/1") { |env| [200, {}, { :user => { :id => 1, :fullname => "Lindsay Fünke" } }.to_json] }
-          stub.put("/users/1") { |env| [200, {}, { :user => { :id => 1, :fullname => "Tobias Fünke Jr." } }.to_json] }
+          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
+          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")
-        @new_user.fullname.should == "Lindsay Fünke"
+        @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
-        @users.first.fullname.should == "Lindsay Fünke"
+        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
-        @users.first.fullname.should == "Lindsay Fünke"
+        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)
-        @user.fullname.should == "Lindsay Fünke"
+        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
-        @user.fullname.should == "Tobias Fünke Jr."
+        expect(@user.fullname).to eq("Tobias Fünke Jr.")
       end
     end
   end
 
   context "when to_params is set" do
     before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
+      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'] }
+          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" }
+          { 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")
-      @user.fullname.should == "Lindsay Fünke"
+      @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 = Foo::User.new(fullname: "Tobias Fünke")
       @user.save
-      @user.fullname.should == "Lindsay Fünke"
+      expect(@user.fullname).to eq("Lindsay Fünke")
     end
   end
 
   context "when parse_root_in_json set json_api to true" do
     before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
+      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") { |env| [200, {},  { :users => [{ :id => 1, :fullname => "Lindsay Fünke" }] }.to_json] }
-          stub.get("/users/admins") { |env| [200, {}, { :users => [{ :id => 1, :fullname => "Lindsay Fünke" }] }.to_json] }
-          stub.get("/users/1") { |env| [200, {}, { :users => [{ :id => 1, :fullname => "Lindsay Fünke" }] }.to_json] }
-          stub.post("/users") { |env| [200, {}, { :users => [{ :fullname => "Lindsay Fünke" }] }.to_json] }
-          stub.put("/users/1") { |env| [200, {}, { :users => [{ :id => 1, :fullname => "Tobias Fünke Jr." }] }.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, {}, { 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
+        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")
-      @new_user.fullname.should == "Lindsay Fünke"
+      @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
-      @new_user.first.fullname.should == "Lindsay Fünke"
+      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
-      @users.first.fullname.should == "Lindsay Fünke"
+      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)
-      @user.fullname.should == "Lindsay Fünke"
+      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
-      @user.fullname.should == "Tobias Fünke Jr."
+      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
-      @user.fullname.should == "Lindsay Fünke"
+      expect(@user.fullname).to eq("Lindsay Fünke")
     end
   end
 
   context "when include_root_in_json set json_api" do
     before do
-      Her::API.setup :url => "https://api.example.com" do |builder|
+      Her::API.setup url: "https://api.example.com" do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON
         builder.use Faraday::Request::UrlEncoded
       end
 
       Her::API.default_api.connection.adapter :test do |stub|
-        stub.post("/users") { |env| [200, {}, { :users => [{ :id => 1, :fullname => params(env)[:users][:fullname] }] }.to_json] }
+        stub.post("/users") { |env| [200, {}, { users: [{ id: 1, fullname: params(env)[:users][:fullname] }] }.to_json] }
       end
     end
 
@@ -309,26 +309,26 @@ describe Her::Model::Parse do
       end
 
       it "wraps params in the element name in `to_params`" do
-        @new_user = Foo::User.new(:fullname => "Tobias Fünke")
-        @new_user.to_params.should == { :users => [{ :fullname => "Tobias Fünke" }] }
+        @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
-        @new_user.fullname.should == "Tobias Fünke"
+        @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
+  context "when send_only_modified_attributes is set" do
     before do
-      Her::API.setup :url => "https://api.example.com", :send_only_modified_attributes => true do |builder|
+      Her::API.setup url: "https://api.example.com", send_only_modified_attributes: true do |builder|
         builder.use Her::Middleware::FirstLevelParseJSON
         builder.use Faraday::Request::UrlEncoded
       end
 
       Her::API.default_api.connection.adapter :test do |stub|
-        stub.get("/users/1") { |env| [200, {}, { :id => 1, :first_name => "Gooby", :last_name => "Pls" }.to_json] }
+        stub.get("/users/1") { [200, {}, { id: 1, first_name: "Gooby", last_name: "Pls" }.to_json] }
       end
 
       spawn_model "Foo::User" do
@@ -336,10 +336,10 @@ describe Her::Model::Parse do
       end
     end
 
-    it 'only sends the attributes that were modified' do
+    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'})
+      user.first_name = "Someone"
+      expect(user.to_params).to eql(user: { first_name: "Someone" })
     end
   end
 end

data/spec/model/paths_spec.rb

@@ -10,64 +10,64 @@ describe Her::Model::Paths do
 
       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"
+          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"
-          Foo::User.new(:id => "foo").request_path.should == "/utilisateurs/foo"
-          Foo::User.new().request_path.should == "/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"
-          Foo::User.new(:id => "foo").request_path.should == "utilisateurs/foo"
-          Foo::User.new().request_path.should == "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"
 
-          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"
+          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")
 
-          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"
+          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"
 
-          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"
+          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")
 
-          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"
+          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"
-          Foo::User.new(:id => "foo").request_path.should == "/utilisateurs/foo"
-          Foo::User.new().request_path.should == "users"
+          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"
-          Foo::User.new(:id => "foo").request_path.should == "utilisateurs/foo"
-          Foo::User.new().request_path.should == "users"
+          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(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/utilisateurs/:id`. Parameters are `{:id=>\"foo\"}`.")
+          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"
+          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
@@ -79,65 +79,65 @@ describe Her::Model::Paths do
 
       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"
+          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"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "/users/foo"
-          Foo::AdminUser.new().request_path.should == "/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"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "users/foo"
-          Foo::AdminUser.new().request_path.should == "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"
-          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"
+          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"
-          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"
+          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"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "/users/foo"
-          Foo::AdminUser.new().request_path.should == "admin_users"
+          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"
-          Foo::AdminUser.new(:id => "foo").request_path.should == "users/foo"
-          Foo::AdminUser.new().request_path.should == "admin_users"
+          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(Her::Errors::PathError, "Missing :_organization_id parameter to build the request path. Path is `/organizations/:organization_id/users/:id`. Parameters are `{:id=>\"foo\"}`.")
+          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\"}`.")
+          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|
+        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] }
+            stub.get("/users/foo") { [200, {}, { id: "foo" }.to_json] }
           end
         end
 
@@ -148,8 +148,8 @@ describe Her::Model::Paths do
       end
 
       it "builds path using the children model name" do
-        User.find('foo').id.should == 'foo'
-        User.find('foo').id.should == 'foo'
+        expect(User.find("foo").id).to eq("foo")
+        expect(User.find("foo").id).to eq("foo")
       end
     end
 
@@ -160,34 +160,34 @@ describe Her::Model::Paths do
 
       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"
+          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
+    context "custom primary key" do
       before do
-        spawn_model 'User' do
-          primary_key 'UserId'
-          resource_path 'users/:UserId'
+        spawn_model "User" do
+          primary_key "UserId"
+          resource_path "users/:UserId"
         end
 
-        spawn_model 'Customer' do
+        spawn_model "Customer" do
           primary_key :customer_id
-          resource_path 'customers/: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'
+      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
-          Customer.new(:customer_id => 'joe').request_path.should == 'customers/joe'
-          Customer.new(:id => 'joe').request_path.should == 'customers'
+        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
@@ -195,15 +195,15 @@ describe Her::Model::Paths do
 
   context "making subdomain HTTP requests" do
     before do
-      Her::API.setup :url => "https://api.example.com/" do |builder|
+      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] }
+          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
 
@@ -214,94 +214,94 @@ describe Her::Model::Paths do
 
     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"
+        @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, lambda { |o| where(:organization_id => o) }
+        Foo::User.scope :for_organization, ->(o) { where(organization_id: o) }
         @user = Foo::User.for_organization(2).find(1)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
+        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
-        @users.length.should == 2
-        @users.first.fullname.should == "Tobias Fünke"
+        @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)
-        @new_user.new?.should be_truthy
+        @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)
-        @existing_user.new?.should be_falsey
+        @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)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
+        @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 = Foo::User.new(fullname: "Tobias Fünke", organization_id: 2)
         @user.save
-        @user.fullname.should == "Tobias Fünke"
+        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)
-        @user.fullname.should == "Tobias Fünke"
+        @user = Foo::User.find(1, _organization_id: 2)
+        expect(@user.fullname).to eq("Tobias Fünke")
         @user.fullname = "Kittie Sanchez"
-        @user.fullname.should == "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 })
-        @user.fullname.should == "Lindsay Fünke"
+        @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 = Foo::User.find(1, _organization_id: 2)
         @user.fullname = "Lindsay Fünke"
         @user.save
-        @user.fullname.should == "Lindsay Fünke"
+        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)
-        @user.active.should be_falsey
+        @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 = Foo::User.find(1, _organization_id: 2)
         @user.destroy
-        @user.active.should be_falsey
+        expect(@user.active).to be_falsey
       end
     end
   end
 
   context "making path HTTP requests" do
     before do
-      Her::API.setup :url => "https://example.com/api/" do |builder|
+      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] }
+          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
 
@@ -312,35 +312,35 @@ describe Her::Model::Paths do
 
     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"
+        @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
-        @users.length.should == 2
-        @users.first.fullname.should == "Tobias Fünke"
+        @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)
-        @user.id.should == 1
-        @user.fullname.should == "Tobias Fünke"
+        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
-        @users.length.should == 2
-        @users.first.fullname.should == "Tobias Fünke"
+        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