passaporteweb-client 0.2.0 → 0.3.0

data/spec/passaporte_web/identity_service_spec.rb

@@ -10,14 +10,14 @@ describe PassaporteWeb::IdentityService do
   describe ".new" do
     it "should instanciate an (almost) empty object" do
       identity_service = described_class.new(mock_identity)
-      identity_service.attributes.should == {identity: mock_identity, slug: nil, is_active: nil, service_data: nil}
-      identity_service.identity.should == mock_identity
-      identity_service.slug.should be_nil
-      identity_service.is_active.should be_nil
+      expect(identity_service.attributes).to eq({identity: mock_identity, slug: nil, is_active: nil, service_data: nil})
+      expect(identity_service.identity).to eq(mock_identity)
+      expect(identity_service.slug).to be_nil
+      expect(identity_service.is_active).to be_nil
       expect(identity_service.is_active?).to be_falsy
-      identity_service.service_data.should be_nil
-      identity_service.errors.should be_empty
-      identity_service.should_not be_persisted
+      expect(identity_service.service_data).to be_nil
+      expect(identity_service.errors).to be_empty
+      expect(identity_service).not_to be_persisted
     end
     it "should instanciate an object with attributes set" do
       identity_service = described_class.new(mock_identity)
@@ -27,32 +27,32 @@ describe PassaporteWeb::IdentityService do
         'service_data' => identity_service_data_hash
       }
       identity_service = described_class.new(mock_identity, attributes)
-      identity_service.attributes.should == {identity: mock_identity, slug: 'identity_client', is_active: true, service_data: identity_service_data_hash}
-      identity_service.identity.should == mock_identity
-      identity_service.slug.should == 'identity_client'
-      identity_service.is_active.should == true
+      expect(identity_service.attributes).to eq({identity: mock_identity, slug: 'identity_client', is_active: true, service_data: identity_service_data_hash})
+      expect(identity_service.identity).to eq(mock_identity)
+      expect(identity_service.slug).to eq('identity_client')
+      expect(identity_service.is_active).to eq(true)
       expect(identity_service.is_active?).to be_truthy
-      identity_service.service_data.should == identity_service_data_hash
-      identity_service.errors.should be_empty
-      identity_service.should_not be_persisted
+      expect(identity_service.service_data).to eq(identity_service_data_hash)
+      expect(identity_service.errors).to be_empty
+      expect(identity_service).not_to be_persisted
     end
   end
 
   describe ".find", vcr: true do
     it "should find the IdentityService representing the existing relationship between the Identity and the Service" do
       identity_service = described_class.find(identity, 'identity_client')
-      identity_service.should be_instance_of(described_class)
-      identity_service.identity.should == identity
-      identity_service.slug.should == 'identity_client'
+      expect(identity_service).to be_instance_of(described_class)
+      expect(identity_service.identity).to eq(identity)
+      expect(identity_service.slug).to eq('identity_client')
       expect(identity_service.is_active).to be_truthy
       expect(identity_service.is_active?).to be_truthy
-      identity_service.service_data.should be_nil
-      identity_service.errors.should be_empty
-      identity_service.should be_persisted
+      expect(identity_service.service_data).to be_nil
+      expect(identity_service.errors).to be_empty
+      expect(identity_service).to be_persisted
     end
     it "should return nil it the Identity does not have a relationship with the Service" do
       other_identity = PassaporteWeb::Identity.find('840df3bd-8414-4085-9920-1937f4b37dd3')
-      described_class.find(other_identity, 'identity_client').should be_nil
+      expect(described_class.find(other_identity, 'identity_client')).to be_nil
     end
   end
 
@@ -66,20 +66,20 @@ describe PassaporteWeb::IdentityService do
       }
       identity_service = described_class.new(other_identity, attributes)
       expect(identity_service.save).to be_truthy
-      identity_service.service_data.should == identity_service_data_hash_as_strings
+      expect(identity_service.service_data).to eq(identity_service_data_hash_as_strings)
 
       identity_service = described_class.find(other_identity, 'identity_client')
-      identity_service.service_data.should == identity_service_data_hash_as_strings
+      expect(identity_service.service_data).to eq(identity_service_data_hash_as_strings)
     end
     it "should update the relationship between Identity and Service with extra data" do
       identity_service = described_class.find(identity, 'identity_client')
-      identity_service.service_data.should be_empty
+      expect(identity_service.service_data).to be_empty
       identity_service.service_data = identity_service_data_hash
       expect(identity_service.save).to be_truthy
-      identity_service.service_data.should == identity_service_data_hash_as_strings
+      expect(identity_service.service_data).to eq(identity_service_data_hash_as_strings)
 
       identity_service = described_class.find(identity, 'identity_client')
-      identity_service.service_data.should == identity_service_data_hash_as_strings
+      expect(identity_service.service_data).to eq(identity_service_data_hash_as_strings)
     end
   end
 

data/spec/passaporte_web/identity_spec.rb

@@ -4,15 +4,15 @@ require 'spec_helper'
 describe PassaporteWeb::Identity do
 
   describe "constants" do
-    it { described_class::ATTRIBUTES.should == [:accounts, :birth_date, :country, :cpf, :email, :first_name, :gender, :id_token, :is_active, :language, :last_name, :nickname, :notifications, :send_myfreecomm_news, :send_partner_news, :services, :timezone, :update_info_url, :uuid, :password, :password2, :must_change_password, :inhibit_activation_message, :tos, :bio, :position, :city, :company, :profession, :identity_info_url, :state, :email_list] }
-    it { described_class::UPDATABLE_ATTRIBUTES.should == [:first_name, :last_name, :nickname, :cpf, :birth_date, :gender, :send_myfreecomm_news, :send_partner_news, :country, :language, :timezone, :bio, :position, :city, :company, :profession, :state] }
-    it { described_class::CREATABLE_ATTRIBUTES.should == [:first_name, :last_name, :nickname, :cpf, :birth_date, :gender, :send_myfreecomm_news, :send_partner_news, :country, :language, :timezone, :bio, :position, :city, :company, :profession, :state, :email, :password, :password2, :must_change_password, :tos, :inhibit_activation_message] }
+    it { expect(described_class::ATTRIBUTES).to eq([:accounts, :birth_date, :country, :cpf, :email, :first_name, :gender, :id_token, :is_active, :language, :last_name, :nickname, :notifications, :send_myfreecomm_news, :send_partner_news, :services, :timezone, :update_info_url, :uuid, :password, :password2, :must_change_password, :inhibit_activation_message, :tos, :bio, :position, :city, :company, :profession, :identity_info_url, :state, :email_list]) }
+    it { expect(described_class::UPDATABLE_ATTRIBUTES).to eq([:first_name, :last_name, :nickname, :cpf, :birth_date, :gender, :send_myfreecomm_news, :send_partner_news, :country, :language, :timezone, :bio, :position, :city, :company, :profession, :state]) }
+    it { expect(described_class::CREATABLE_ATTRIBUTES).to eq([:first_name, :last_name, :nickname, :cpf, :birth_date, :gender, :send_myfreecomm_news, :send_partner_news, :country, :language, :timezone, :bio, :position, :city, :company, :profession, :state, :email, :password, :password2, :must_change_password, :tos, :inhibit_activation_message]) }
   end
 
   describe ".new" do
     it "should instanciate an empty object" do
       identity = described_class.new
-      identity.attributes.should == {:accounts=>nil, :birth_date=>nil, :country=>nil, :cpf=>nil, :email=>nil, :first_name=>nil, :gender=>nil, :id_token=>nil, :is_active=>nil, :language=>nil, :last_name=>nil, :nickname=>nil, :notifications=>nil, :send_myfreecomm_news=>nil, :send_partner_news=>nil, :services=>nil, :timezone=>nil, :update_info_url=>nil, :uuid=>nil, :password=>nil, :password2=>nil, :must_change_password=>nil, :inhibit_activation_message=>nil, :tos=>nil, :bio=>nil, :position=>nil, :city=>nil, :company=>nil, :profession=>nil, :identity_info_url=>nil, :state=>nil, :email_list=>nil}
+      expect(identity.attributes).to eq({:accounts=>nil, :birth_date=>nil, :country=>nil, :cpf=>nil, :email=>nil, :first_name=>nil, :gender=>nil, :id_token=>nil, :is_active=>nil, :language=>nil, :last_name=>nil, :nickname=>nil, :notifications=>nil, :send_myfreecomm_news=>nil, :send_partner_news=>nil, :services=>nil, :timezone=>nil, :update_info_url=>nil, :uuid=>nil, :password=>nil, :password2=>nil, :must_change_password=>nil, :inhibit_activation_message=>nil, :tos=>nil, :bio=>nil, :position=>nil, :city=>nil, :company=>nil, :profession=>nil, :identity_info_url=>nil, :state=>nil, :email_list=>nil})
     end
     it "should instanciate an object with attributes set" do
       attributes = {
@@ -46,29 +46,29 @@ describe PassaporteWeb::Identity do
         "tos"=>nil
       }
       identity = described_class.new(attributes)
-      identity.attributes.should == {:accounts=>[], :birth_date=>"1945-10-27", :country=>"Brasil", :cpf=>nil, :email=>"lula@example.com", :first_name=>"Luis Inácio", :gender=>"M", :id_token=>nil, :is_active=>true, :language=>"pt_BR", :last_name=>"da Silva", :nickname=>"Lula", :notifications=>{"count"=>0, "list"=>"/notifications/api/"}, :send_myfreecomm_news=>false, :send_partner_news=>false, :services=>{"myfinance"=>"/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/myfinance/", "account_manager"=>"/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/account_manager/"}, :timezone=>"GMT-3", :update_info_url=>"/profile/api/info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/", :uuid=>"a5868d14-6529-477a-9c6b-a09dd42a7cd2", :password=>nil, :password2=>nil, :must_change_password=>nil, :inhibit_activation_message=>nil, :tos=>nil, :bio=>nil, :position=>nil, :city=>nil, :company=>nil, :profession=>nil, :identity_info_url=>nil, :state=>nil, :email_list=>nil}
-      identity.last_name.should == "da Silva"
-      identity.is_active.should == true
-      identity.timezone.should == "GMT-3"
-      identity.nickname.should == "Lula"
-      identity.first_name.should == "Luis Inácio"
-      identity.send_partner_news.should == false
-      identity.uuid.should == "a5868d14-6529-477a-9c6b-a09dd42a7cd2"
-      identity.language.should == "pt_BR"
-      identity.country.should == "Brasil"
-      identity.update_info_url.should == "/profile/api/info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/"
-      identity.send_myfreecomm_news.should == false
-      identity.gender.should == "M"
-      identity.birth_date.should == "1945-10-27"
-      identity.email.should == "lula@example.com"
-      identity.notifications.should == {"count" => 0, "list" => "/notifications/api/"}
-      identity.accounts.should == []
-      identity.services.should == {"myfinance" => "/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/myfinance/", "account_manager" => "/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/account_manager/"}
-      identity.password.should be_nil
-      identity.password2.should be_nil
-      identity.must_change_password.should be_nil
-      identity.inhibit_activation_message.should be_nil
-      identity.tos.should be_nil
+      expect(identity.attributes).to eq({:accounts=>[], :birth_date=>"1945-10-27", :country=>"Brasil", :cpf=>nil, :email=>"lula@example.com", :first_name=>"Luis Inácio", :gender=>"M", :id_token=>nil, :is_active=>true, :language=>"pt_BR", :last_name=>"da Silva", :nickname=>"Lula", :notifications=>{"count"=>0, "list"=>"/notifications/api/"}, :send_myfreecomm_news=>false, :send_partner_news=>false, :services=>{"myfinance"=>"/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/myfinance/", "account_manager"=>"/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/account_manager/"}, :timezone=>"GMT-3", :update_info_url=>"/profile/api/info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/", :uuid=>"a5868d14-6529-477a-9c6b-a09dd42a7cd2", :password=>nil, :password2=>nil, :must_change_password=>nil, :inhibit_activation_message=>nil, :tos=>nil, :bio=>nil, :position=>nil, :city=>nil, :company=>nil, :profession=>nil, :identity_info_url=>nil, :state=>nil, :email_list=>nil})
+      expect(identity.last_name).to eq("da Silva")
+      expect(identity.is_active).to eq(true)
+      expect(identity.timezone).to eq("GMT-3")
+      expect(identity.nickname).to eq("Lula")
+      expect(identity.first_name).to eq("Luis Inácio")
+      expect(identity.send_partner_news).to eq(false)
+      expect(identity.uuid).to eq("a5868d14-6529-477a-9c6b-a09dd42a7cd2")
+      expect(identity.language).to eq("pt_BR")
+      expect(identity.country).to eq("Brasil")
+      expect(identity.update_info_url).to eq("/profile/api/info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/")
+      expect(identity.send_myfreecomm_news).to eq(false)
+      expect(identity.gender).to eq("M")
+      expect(identity.birth_date).to eq("1945-10-27")
+      expect(identity.email).to eq("lula@example.com")
+      expect(identity.notifications).to eq({"count" => 0, "list" => "/notifications/api/"})
+      expect(identity.accounts).to eq([])
+      expect(identity.services).to eq({"myfinance" => "/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/myfinance/", "account_manager" => "/accounts/api/service-info/a5868d14-6529-477a-9c6b-a09dd42a7cd2/account_manager/"})
+      expect(identity.password).to be_nil
+      expect(identity.password2).to be_nil
+      expect(identity.must_change_password).to be_nil
+      expect(identity.inhibit_activation_message).to be_nil
+      expect(identity.tos).to be_nil
     end
   end
 
@@ -76,60 +76,60 @@ describe PassaporteWeb::Identity do
     it "should identify two profiles with the same uuid as equal" do
       p1 = described_class.new('uuid' => 'some-uuid')
       p2 = described_class.new('uuid' => 'some-uuid')
-      p1.should == p2
-      p1.should_not === p2
-      p2.should == p1
-      p2.should_not === p1
+      expect(p1).to eq(p2)
+      expect(p1).not_to be === p2
+      expect(p2).to eq(p1)
+      expect(p2).not_to be === p1
     end
     it "should identify two profiles with different uuids as different" do
       p1 = described_class.new('uuid' => 'some-uuid-1')
       p2 = described_class.new('uuid' => 'some-uuid-2')
-      p1.should_not == p2
-      p1.should_not === p2
-      p2.should_not == p1
-      p2.should_not === p1
+      expect(p1).not_to eq(p2)
+      expect(p1).not_to be === p2
+      expect(p2).not_to eq(p1)
+      expect(p2).not_to be === p1
       p3 = described_class.new
-      p1.should_not == p3
-      p3.should_not == p1
-      p3.should_not === p1
+      expect(p1).not_to eq(p3)
+      expect(p3).not_to eq(p1)
+      expect(p3).not_to be === p1
     end
   end
 
   describe ".find", :vcr => true do
     it "should find the requested profile by uuid" do
       identity = described_class.find("5e32f927-c4ab-404e-a91c-b2abc05afb56")
-      identity.should be_instance_of(described_class)
-      identity.uuid.should == '5e32f927-c4ab-404e-a91c-b2abc05afb56'
-      identity.should be_persisted
-      identity.email.should == 'teste@teste.com'
-      identity.update_info_url.should == '/accounts/api/identities/5e32f927-c4ab-404e-a91c-b2abc05afb56/'
-      identity.accounts.size.should == 9
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort.should == [nil]
+      expect(identity).to be_instance_of(described_class)
+      expect(identity.uuid).to eq('5e32f927-c4ab-404e-a91c-b2abc05afb56')
+      expect(identity).to be_persisted
+      expect(identity.email).to eq('teste@teste.com')
+      expect(identity.update_info_url).to eq('/accounts/api/identities/5e32f927-c4ab-404e-a91c-b2abc05afb56/')
+      expect(identity.accounts.size).to eq(9)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort).to eq([nil])
     end
     it "should find the requested profile by uuid, including expired accounts" do
       identity = described_class.find("5e32f927-c4ab-404e-a91c-b2abc05afb56", true)
-      identity.accounts.size.should == 10
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort.should == [nil]
+      expect(identity.accounts.size).to eq(10)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort).to eq([nil])
     end
     it "should find the requested profile by uuid, including other services" do
       identity = described_class.find("5e32f927-c4ab-404e-a91c-b2abc05afb56", false, true)
-      identity.accounts.size.should == 10
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort.should == ["identity_client", "vc-promove"]
+      expect(identity.accounts.size).to eq(10)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort).to eq(["identity_client", "vc-promove"])
     end
     it "should find the requested profile by uuid, including other services and expired accounts" do
       identity = described_class.find("5e32f927-c4ab-404e-a91c-b2abc05afb56", true, true)
-      identity.accounts.size.should == 11
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort.should == ["identity_client", "vc-promove"]
+      expect(identity.accounts.size).to eq(11)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort).to eq(["identity_client", "vc-promove"])
     end
     # REGRSSION
     it "should return the is_active and id_token fields" do
       identity = described_class.find('13b972ab-0946-4a5b-8217-60255a9cbee7', true, true)
       expect(identity.is_active).to be_truthy
-      identity.id_token.should be_nil # não mostra token pois não foi autenticado com a senha do usuário
+      expect(identity.id_token).to be_nil # não mostra token pois não foi autenticado com a senha do usuário
     end
     it "should raise an error if no profiles exist with that uuid" do
       expect {
@@ -141,42 +141,42 @@ describe PassaporteWeb::Identity do
   describe ".find_by_email", :vcr => true do
     it "should find the requested profile by email" do
       identity = described_class.find_by_email("teste@teste.com")
-      identity.should be_instance_of(described_class)
-      identity.uuid.should == '5e32f927-c4ab-404e-a91c-b2abc05afb56'
-      identity.should be_persisted
-      identity.email.should == 'teste@teste.com'
-      identity.update_info_url.should == '/accounts/api/identities/5e32f927-c4ab-404e-a91c-b2abc05afb56/'
-      identity.accounts.size.should == 9
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort.should == [nil]
-      identity.services.size.should == 1
-      identity.services.keys.should == ['identity_client']
+      expect(identity).to be_instance_of(described_class)
+      expect(identity.uuid).to eq('5e32f927-c4ab-404e-a91c-b2abc05afb56')
+      expect(identity).to be_persisted
+      expect(identity.email).to eq('teste@teste.com')
+      expect(identity.update_info_url).to eq('/accounts/api/identities/5e32f927-c4ab-404e-a91c-b2abc05afb56/')
+      expect(identity.accounts.size).to eq(9)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort).to eq([nil])
+      expect(identity.services.size).to eq(1)
+      expect(identity.services.keys).to eq(['identity_client'])
     end
     it "should find the requested profile by email, including expired accounts" do
       identity = described_class.find_by_email("teste@teste.com", true)
-      identity.accounts.size.should == 10
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort.should == [nil]
-      identity.services.size.should == 1
-      identity.services.keys.should == ['identity_client']
+      expect(identity.accounts.size).to eq(10)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] rescue nil }.sort).to eq([nil])
+      expect(identity.services.size).to eq(1)
+      expect(identity.services.keys).to eq(['identity_client'])
     end
     it "should find the requested profile by email, including other services" do
       identity = described_class.find_by_email("teste@teste.com", false, true)
-      identity.accounts.size.should == 10
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort.should == ["identity_client", "vc-promove"]
+      expect(identity.accounts.size).to eq(10)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort).to eq(["identity_client", "vc-promove"])
     end
     it "should find the requested profile by email, including other services and expired accounts" do
       identity = described_class.find_by_email("teste@teste.com", true, true)
-      identity.accounts.size.should == 11
-      identity.accounts.map { |a| a['expiration'] }.uniq.should == [nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"]
-      identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort.should == ["identity_client", "vc-promove"]
+      expect(identity.accounts.size).to eq(11)
+      expect(identity.accounts.map { |a| a['expiration'] }.uniq).to eq([nil, "2013-04-02 00:00:00", "2014-05-01 00:00:00"])
+      expect(identity.accounts.map { |a| a['services'] }.flatten.uniq.map { |s| s['slug'] }.sort).to eq(["identity_client", "vc-promove"])
     end
     # REGRSSION
     it "should return the is_active and id_token fields" do
       identity = described_class.find_by_email('mobileteste269@mailinator.com', true, true)
       expect(identity.is_active).to be_truthy
-      identity.id_token.should be_nil # não mostra token pois não foi autenticado com a senha do usuário
+      expect(identity.id_token).to be_nil # não mostra token pois não foi autenticado com a senha do usuário
     end
     it "should raise an error if no profiles exist with that email" do
       expect {
@@ -188,27 +188,27 @@ describe PassaporteWeb::Identity do
   describe ".profile", :vcr => true do
     it "should find the requested profile by email" do
       identity = described_class.profile('8923199e-6c43-415a-bbd1-2e302fdf8d96')
-      identity.should be_instance_of(described_class)
-      identity.bio.should == 'I\'m the Kingslayer!'
-      identity.position.should == 'Knight'
-      identity.language.should == 'ur'
-      identity.city.should == 'Casterly Rock'
-      identity.gender.should == 'M'
-      identity.company.should == 'Lannister House'
-      identity.profession.should == 'Kingslayer'
-      identity.identity_info_url.should == 'http://sandbox.app.passaporteweb.com.br/accounts/api/identities/8923199e-6c43-415a-bbd1-2e302fdf8d96/'
-      identity.state.should == 'AC'
-      identity.country.should == 'Westeros'
-      identity.birth_date.should == '1950-01-01'
-      identity.timezone.should == 'Pacific/Midway'
-      identity.nickname.should == 'Jaime'
-      identity.email_list.count.should == 2
+      expect(identity).to be_instance_of(described_class)
+      expect(identity.bio).to eq('I\'m the Kingslayer!')
+      expect(identity.position).to eq('Knight')
+      expect(identity.language).to eq('ur')
+      expect(identity.city).to eq('Casterly Rock')
+      expect(identity.gender).to eq('M')
+      expect(identity.company).to eq('Lannister House')
+      expect(identity.profession).to eq('Kingslayer')
+      expect(identity.identity_info_url).to eq('http://sandbox.app.passaporteweb.com.br/accounts/api/identities/8923199e-6c43-415a-bbd1-2e302fdf8d96/')
+      expect(identity.state).to eq('AC')
+      expect(identity.country).to eq('Westeros')
+      expect(identity.birth_date).to eq('1950-01-01')
+      expect(identity.timezone).to eq('Pacific/Midway')
+      expect(identity.nickname).to eq('Jaime')
+      expect(identity.email_list.count).to eq(2)
       # Primary e-mail
-      identity.email_list[0]['address'].should == 'jaime.lannister@mailinator.com'
+      expect(identity.email_list[0]['address']).to eq('jaime.lannister@mailinator.com')
       expect(identity.email_list[0]['is_primary']).to be_truthy
       expect(identity.email_list[0]['is_active']).to be_truthy
       # Secondary email
-      identity.email_list[1]['address'].should == 'kingslayer@mailinator.com'
+      expect(identity.email_list[1]['address']).to eq('kingslayer@mailinator.com')
       expect(identity.email_list[1]['is_primary']).to be_falsy
       expect(identity.email_list[1]['is_active']).to be_truthy
     end
@@ -222,17 +222,17 @@ describe PassaporteWeb::Identity do
   describe ".authenticate", vcr: true do
     it "should return an instance of Identity if the password is correct for the given email" do
       identity = described_class.authenticate('teste@teste.com', '123456')
-      identity.should be_instance_of(described_class)
-      identity.should be_persisted
-      identity.uuid.should == '5e32f927-c4ab-404e-a91c-b2abc05afb56'
-      identity.email.should == 'teste@teste.com'
-      identity.update_info_url.should == '/accounts/api/identities/5e32f927-c4ab-404e-a91c-b2abc05afb56/'
+      expect(identity).to be_instance_of(described_class)
+      expect(identity).to be_persisted
+      expect(identity.uuid).to eq('5e32f927-c4ab-404e-a91c-b2abc05afb56')
+      expect(identity.email).to eq('teste@teste.com')
+      expect(identity.update_info_url).to eq('/accounts/api/identities/5e32f927-c4ab-404e-a91c-b2abc05afb56/')
     end
     # REGRSSION
     it "should return the is_active and id_token fields" do
       identity = described_class.authenticate('mobileteste269@mailinator.com', 'vivalasvegas')
       expect(identity.is_active).to be_truthy
-      identity.id_token.should == '9864ec27fb4fd866f6fad5bc041d0363d0bc0fd2945858a1'
+      expect(identity.id_token).to eq('9864ec27fb4fd866f6fad5bc041d0363d0bc0fd2945858a1')
     end
     it "should return false if the password is wrong for the given email" do
       expect(described_class.authenticate('teste@teste.com', 'wrong password')).to be_falsy
@@ -263,24 +263,24 @@ describe PassaporteWeb::Identity do
       let(:identity) { described_class.find("5e32f927-c4ab-404e-a91c-b2abc05afb56") }
       context "on success" do
         it "should update the profile attributes on the server" do
-          identity.first_name.should == 'Testador'
-          identity.should be_persisted
+          expect(identity.first_name).to eq('Testador')
+          expect(identity).to be_persisted
           identity.first_name = 'Testador 2'
           expect(identity.save).to be_truthy
-          identity.should be_persisted
-          identity.first_name.should == 'Testador 2'
+          expect(identity).to be_persisted
+          expect(identity.first_name).to eq('Testador 2')
 
           identity = described_class.find("5e32f927-c4ab-404e-a91c-b2abc05afb56")
-          identity.first_name.should == 'Testador 2'
+          expect(identity.first_name).to eq('Testador 2')
         end
       end
       context "on failure" do
         it "should return false and set the errors hash" do
           identity.cpf = 42
-          identity.should be_persisted
+          expect(identity).to be_persisted
           expect(identity.save).to be_falsy
-          identity.should be_persisted
-          identity.errors.should == {"cpf" => ["Certifique-se de que o valor tenha no mínimo 11 caracteres (ele possui 2)."]}
+          expect(identity).to be_persisted
+          expect(identity.errors).to eq({"cpf" => ["Certifique-se de que o valor tenha no mínimo 11 caracteres (ele possui 2)."]})
         end
       end
     end
@@ -297,9 +297,9 @@ describe PassaporteWeb::Identity do
             "tos" => true
           }
           identity = described_class.new(attributes)
-          identity.should_not be_persisted
+          expect(identity).not_to be_persisted
           expect(identity.save).to be_truthy
-          identity.should be_persisted
+          expect(identity).to be_persisted
         end
         it "should save with all params" do
           attributes = {
@@ -316,9 +316,9 @@ describe PassaporteWeb::Identity do
             "send_myfreecomm_news" => false
           }
           identity = described_class.new(attributes)
-          identity.should_not be_persisted
+          expect(identity).not_to be_persisted
           expect(identity.save).to be_truthy
-          identity.should be_persisted
+          expect(identity).to be_persisted
         end
         # REGRESSION
         it "should send the inhibit_activation_message information" do
@@ -333,7 +333,7 @@ describe PassaporteWeb::Identity do
           }
           identity = described_class.new(attributes)
           mock_response = double('response', code: 201, body: MultiJson.encode(attributes))
-          PassaporteWeb::Http.should_receive(:post).with("/accounts/api/create/", attributes).and_return(mock_response)
+          expect(PassaporteWeb::Http).to receive(:post).with("/accounts/api/create/", attributes).and_return(mock_response)
           expect(identity.save).to be_truthy
         end
       end
@@ -346,10 +346,10 @@ describe PassaporteWeb::Identity do
             "tos" => true
           }
           identity = described_class.new(attributes)
-          identity.should_not be_persisted
+          expect(identity).to_not be_persisted
           expect(identity.save).to_not be_truthy
-          identity.should_not be_persisted
-          identity.errors.should == {"password2"=>["Este campo é obrigatório."], "password"=>["Este campo é obrigatório."]}
+          expect(identity).to_not be_persisted
+          expect(identity.errors).to eq({"password2"=>["Este campo é obrigatório."], "password"=>["Este campo é obrigatório."]})
         end
       end
     end