ruby-trello 1.2.1 → 1.3.0

data/spec/member_spec.rb

@@ -9,105 +9,127 @@ module Trello
     let(:member) { client.find(:member, 'abcdef123456789012345678') }
     let(:client) { Client.new }
 
-    before(:each) do
-      client.stub(:get).with('/members/abcdef123456789012345678', {}).and_return user_payload
+    before do
+      allow(client)
+        .to receive(:get)
+        .with('/members/abcdef123456789012345678', {})
+        .and_return user_payload
     end
 
     context 'finding' do
       let(:client) { Trello.client }
 
       it 'delegates to Trello.client#find' do
-        client.should_receive(:find).with(:member, 'abcdef123456789012345678', {})
+        expect(client)
+          .to receive(:find)
+          .with(:member, 'abcdef123456789012345678', {})
+
         Member.find('abcdef123456789012345678')
       end
 
       it 'is equivalent to client#find' do
-        Member.find('abcdef123456789012345678').should eq(member)
+        expect(Member.find('abcdef123456789012345678')).to eq(member)
       end
     end
 
-    context 'actions' do
-      it 'retrieves a list of actions', refactor: true do
-        client.stub(:get).with('/members/abcdef123456789012345678/actions', { filter: :all }).and_return actions_payload
-        member.actions.count.should be > 0
+    describe 'attributes' do
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/members/abcdef123456789012345678/#{resource}", { filter: filter })
+          .and_return payload
       end
-    end
 
-    context 'boards' do
-      it 'has a list of boards' do
-        client.stub(:get).with('/members/abcdef123456789012345678/boards', { filter: :all }).and_return boards_payload
-        boards = member.boards
-        boards.count.should be > 0
+      describe 'actions' do
+        let(:resource) { 'actions' }
+        let(:filter)   { :all }
+        let(:payload)  { actions_payload }
+
+        it 'retrieves a list of actions' do
+          expect(member.actions.count).to be > 0
+        end
       end
-    end
 
-    context 'cards' do
-      it 'has a list of cards' do
-        client.stub(:get).with('/members/abcdef123456789012345678/cards', { filter: :open }).and_return cards_payload
-        cards = member.cards
-        cards.count.should be > 0
+      describe 'boards' do
+        let(:resource) { 'boards' }
+        let(:filter)   { :all }
+        let(:payload)  { boards_payload }
+
+        it { expect(member.boards.count).to be > 0 }
       end
-    end
 
-    context 'organizations' do
-      it 'has a list of organizations' do
-        client.stub(:get).with('/members/abcdef123456789012345678/organizations', { filter: :all }).and_return orgs_payload
-        orgs = member.organizations
-        orgs.count.should be > 0
+      describe 'cards' do
+        let(:resource) { 'cards' }
+        let(:filter)   { :open }
+        let(:payload)  { cards_payload }
+
+        it { expect(member.cards.count).to be > 0 }
+      end
+
+      describe 'organizations' do
+        let(:resource) { 'organizations' }
+        let(:filter)   { :all }
+        let(:payload)  { orgs_payload }
+
+        it { expect(member.organizations.count).to be > 0 }
       end
     end
 
     context 'notifications' do
       it 'has a list of notifications' do
-        client.stub(:get).with('/members/abcdef123456789012345678/notifications', {}).and_return '[' << notification_payload << ']'
-        member.notifications.count.should be 1
+        allow(client)
+          .to receive(:get)
+          .with('/members/abcdef123456789012345678/notifications', {})
+          .and_return '[' << notification_payload << ']'
+
+        expect(member.notifications.count).to eq 1
       end
     end
 
     context 'personal' do
       it 'gets the members bio' do
-        member.bio.should == user_details['bio']
+        expect(member.bio).to eq user_details['bio']
       end
 
       it 'gets the full name' do
-        member.full_name.should == user_details['fullName']
+        expect(member.full_name).to eq user_details['fullName']
       end
 
       it 'gets the avatar id' do
-        member.avatar_id.should == user_details['avatarHash']
+        expect(member.avatar_id).to eq user_details['avatarHash']
       end
 
       it 'returns a valid url for the avatar' do
-        member.avatar_url(size: :large).should == 'https://trello-avatars.s3.amazonaws.com/abcdef1234567890abcdef1234567890/170.png'
-        member.avatar_url(size: :small).should == 'https://trello-avatars.s3.amazonaws.com/abcdef1234567890abcdef1234567890/30.png'
+        expect(member.avatar_url(size: :large)).to eq 'https://trello-avatars.s3.amazonaws.com/abcdef1234567890abcdef1234567890/170.png'
+        expect(member.avatar_url(size: :small)).to eq 'https://trello-avatars.s3.amazonaws.com/abcdef1234567890abcdef1234567890/30.png'
       end
 
       it 'gets the url' do
-        member.url.should == user_details['url']
+        expect(member.url).to eq user_details['url']
       end
 
       it 'gets the username' do
-        member.username.should == user_details['username']
+        expect(member.username).to eq user_details['username']
       end
 
       it 'gets the email' do
-        member.email.should == user_details['email']
+        expect(member.email).to eq user_details['email']
       end
 
       it 'gets the initials' do
-        member.initials.should == user_details['initials']
+        expect(member.initials).to eq user_details['initials']
       end
     end
 
     context 'modification' do
       it 'lets us know a field has changed without committing it' do
-        expect(member.changed?).to be(false)
+        expect(member).to_not be_changed
         member.bio = 'New and amazing'
-        expect(member.changed?).to be(true)
+        expect(member).to be_changed
       end
 
       it 'does not understand the #id= method' do
-        -> { member.id = '42' }.should raise_error NoMethodError
+        expect { member.id = '42' }.to raise_error NoMethodError
       end
     end
   end

data/spec/notification_spec.rb

@@ -8,79 +8,114 @@ module Trello
     let(:member) { client.find(:member, "abcdef123456789012345678") }
     let(:client) { Client.new }
 
-    before(:each) do
-      client.stub(:get).with("/members/abcdef123456789012345678", {}).and_return user_payload
-      client.stub(:get).with("/members/abcdef123456789012345678/notifications", {}).and_return "[" << notification_payload << "]"
+    before do
+      allow(client)
+        .to receive(:get)
+        .with("/members/abcdef123456789012345678", {})
+        .and_return user_payload
+
+      allow(client)
+        .to receive(:get)
+        .with("/members/abcdef123456789012345678/notifications", {})
+        .and_return("[" << notification_payload << "]")
     end
 
     context "finding" do
       let(:client) { Trello.client }
 
       it "can find a specific notification" do
-        client.stub(:get).with("/notifications/#{notification_details['id']}", {}).and_return notification_payload
-        Notification.find(notification_details['id']).should == notification
+        allow(client)
+          .to receive(:get)
+          .with("/notifications/#{notification_details['id']}", {})
+          .and_return notification_payload
+
+        expect(Notification.find(notification_details['id'])).to eq notification
       end
     end
 
     context "boards" do
       it "can retrieve the board" do
-        client.stub(:get).with("/notifications/#{notification_details['id']}/board").and_return JSON.generate(boards_details.first)
-        notification.board.id.should == boards_details.first['id']
+        allow(client)
+          .to receive(:get)
+          .with("/notifications/#{notification_details['id']}/board")
+          .and_return JSON.generate(boards_details.first)
+
+        expect(notification.board.id).to eq boards_details.first['id']
       end
     end
 
     context "lists" do
       it "can retrieve the list" do
-        client.stub(:get).with("/notifications/#{notification_details['id']}/list").and_return JSON.generate(lists_details.first)
-        notification.list.id.should == lists_details.first['id']
+        allow(client)
+          .to receive(:get)
+          .with("/notifications/#{notification_details['id']}/list")
+          .and_return JSON.generate(lists_details.first)
+
+        expect(notification.list.id).to eq lists_details.first['id']
       end
     end
 
     context "cards" do
       it "can retrieve the card" do
-        client.stub(:get).with("/notifications/#{notification_details['id']}/card").and_return JSON.generate(cards_details.first)
-        notification.card.id.should == cards_details.first['id']
+        allow(client)
+          .to receive(:get)
+          .with("/notifications/#{notification_details['id']}/card")
+          .and_return JSON.generate(cards_details.first)
+
+        expect(notification.card.id).to eq cards_details.first['id']
       end
     end
 
     context "members" do
       it "can retrieve the member" do
-        client.stub(:get).with("/notifications/#{notification_details['id']}/member").and_return user_payload
-        notification.member.id.should == user_details['id']
+        allow(client)
+          .to receive(:get)
+          .with("/notifications/#{notification_details['id']}/member")
+          .and_return user_payload
+
+        expect(notification.member.id).to eq user_details['id']
       end
 
       it "can retrieve the member creator" do
-        client.stub(:get).with("/members/#{user_details['id']}", {}).and_return user_payload
-        notification.member_creator.id.should == user_details['id']
+        allow(client)
+          .to receive(:get)
+          .with("/members/#{user_details['id']}", {})
+          .and_return user_payload
+
+        expect(notification.member_creator.id).to eq user_details['id']
       end
     end
 
     context "organization" do
       it "can retrieve the organization" do
-        client.stub(:get).with("/notifications/#{notification_details['id']}/organization").and_return JSON.generate(orgs_details.first)
-        notification.organization.id.should == orgs_details.first['id']
+        allow(client)
+          .to receive(:get)
+          .with("/notifications/#{notification_details['id']}/organization")
+          .and_return JSON.generate(orgs_details.first)
+
+        expect(notification.organization.id).to eq orgs_details.first['id']
       end
     end
 
     context "local" do
       it "gets the read status" do
-        notification.unread?.should == notification_details['unread']
+        expect(notification.unread?).to eq notification_details['unread']
       end
 
       it "gets the type" do
-        notification.type.should == notification_details['type']
+        expect(notification.type).to eq notification_details['type']
       end
 
       it "gets the date" do
-        notification.date.should == notification_details['date']
+        expect(notification.date).to eq notification_details['date']
       end
 
       it "gets the data" do
-        notification.data.should == notification_details['data']
+        expect(notification.data).to eq notification_details['data']
       end
 
       it "gets the member creator id" do
-        notification.member_creator_id.should == notification_details['idMemberCreator']
+        expect(notification.member_creator_id).to eq notification_details['idMemberCreator']
       end
     end
   end

data/spec/oauth_policy_spec.rb

@@ -12,8 +12,8 @@ describe OAuthPolicy do
   describe '#consumer_credential' do
     it 'uses class setting if available' do
       policy = OAuthPolicy.new
-      policy.consumer_credential.key.should eq('xxx')
-      policy.consumer_credential.secret.should eq('xxx')
+      expect(policy.consumer_credential.key).to eq('xxx')
+      expect(policy.consumer_credential.secret).to eq('xxx')
     end
 
     it 'is built from given consumer_key and consumer_secret' do
@@ -21,14 +21,14 @@ describe OAuthPolicy do
         consumer_key: 'consumer_key',
         consumer_secret: 'consumer_secret'
       )
-      policy.consumer_credential.key.should eq('consumer_key')
-      policy.consumer_credential.secret.should eq('consumer_secret')
+      expect(policy.consumer_credential.key).to eq('consumer_key')
+      expect(policy.consumer_credential.secret).to eq('consumer_secret')
     end
 
     it 'is nil if none supplied to class' do
       OAuthPolicy.consumer_credential = nil
       policy = OAuthPolicy.new
-      policy.consumer_credential.should be_nil
+      expect(policy.consumer_credential).to be_nil
     end
   end
 
@@ -36,8 +36,8 @@ describe OAuthPolicy do
     it 'uses class setting if available' do
       OAuthPolicy.token = OAuthCredential.new 'xxx', 'xxx'
       policy = OAuthPolicy.new
-      policy.token.key.should eq('xxx')
-      policy.token.secret.should eq('xxx')
+      expect(policy.token.key).to eq('xxx')
+      expect(policy.token.secret).to eq('xxx')
     end
 
     it 'is built from given oauth_token and oauth_token_secret' do
@@ -45,13 +45,13 @@ describe OAuthPolicy do
         oauth_token: 'oauth_token',
         oauth_token_secret: 'oauth_token_secret'
       )
-      policy.token.key.should eq('oauth_token')
-      policy.token.secret.should eq('oauth_token_secret')
+      expect(policy.token.key).to eq('oauth_token')
+      expect(policy.token.secret).to eq('oauth_token_secret')
     end
 
     it 'is an empty token if no oauth credentials supplied' do
       policy = OAuthPolicy.new
-      policy.token.should be_nil
+      expect(policy.token).to be_nil
     end
   end
 
@@ -65,27 +65,38 @@ describe OAuthPolicy do
 
       authorized_request = OAuthPolicy.authorize request
 
-      authorized_request.headers.keys.should include 'Authorization'
+      expect(authorized_request.headers.keys).to include 'Authorization'
     end
 
     it 'preserves query parameters' do
       uri = Addressable::URI.parse('https://xxx/?name=Riccardo')
       request = Request.new :get, uri
 
-      Clock.stub(:timestamp).and_return '1327048592'
-      Nonce.stub(:next).and_return 'b94ff2bf7f0a5e87a326064ae1dbb18f'
+      allow(Clock)
+        .to receive(:timestamp)
+        .and_return '1327048592'
+
+      allow(Nonce)
+        .to receive(:next)
+        .and_return 'b94ff2bf7f0a5e87a326064ae1dbb18f'
+
       OAuthPolicy.consumer_credential = OAuthCredential.new 'consumer_key', 'consumer_secret'
       OAuthPolicy.token               = OAuthCredential.new 'token', nil
 
       authorized_request = OAuthPolicy.authorize request
 
       the_query_parameters = Addressable::URI.parse(authorized_request.uri).query_values
-      the_query_parameters.should == {'name' => 'Riccardo'}
+      expect(the_query_parameters).to eq({'name' => 'Riccardo'})
     end
 
     it 'adds the correct signature as part of authorization header' do
-      Clock.stub(:timestamp).and_return '1327048592'
-      Nonce.stub(:next).and_return 'b94ff2bf7f0a5e87a326064ae1dbb18f'
+      allow(Clock)
+        .to receive(:timestamp)
+        .and_return '1327048592'
+
+      allow(Nonce)
+        .to receive(:next)
+        .and_return 'b94ff2bf7f0a5e87a326064ae1dbb18f'
 
       OAuthPolicy.consumer_credential = OAuthCredential.new 'consumer_key', 'consumer_secret'
       OAuthPolicy.token               = OAuthCredential.new 'token', nil
@@ -94,12 +105,17 @@ describe OAuthPolicy do
 
       authorized_request = OAuthPolicy.authorize request
 
-      authorized_request.headers['Authorization'].should =~ /oauth_signature="TVNk%2FCs03FHqutDUqn05%2FDkvVek%3D"/
+      expect(authorized_request.headers['Authorization']).to match(/oauth_signature="TVNk%2FCs03FHqutDUqn05%2FDkvVek%3D"/)
     end
 
     it 'adds correct signature for uri with parameters' do
-      Clock.stub(:timestamp).and_return '1327351010'
-      Nonce.stub(:next).and_return 'f5474aaf44ca84df0b09870044f91c69'
+      allow(Clock)
+        .to receive(:timestamp)
+        .and_return '1327351010'
+
+      allow(Nonce)
+        .to receive(:next)
+        .and_return 'f5474aaf44ca84df0b09870044f91c69'
 
       OAuthPolicy.consumer_credential = OAuthCredential.new 'consumer_key', 'consumer_secret'
       OAuthPolicy.token               = OAuthCredential.new 'token', nil
@@ -108,7 +124,7 @@ describe OAuthPolicy do
 
       authorized_request = OAuthPolicy.authorize request
 
-      authorized_request.headers['Authorization'].should =~ /oauth_signature="DprU1bdbNdJQ40UhD4n7wRR9jts%3D"/
+      expect(authorized_request.headers['Authorization']).to match(/oauth_signature="DprU1bdbNdJQ40UhD4n7wRR9jts%3D"/)
     end
 
     it 'fails if consumer_credential is unset' do
@@ -116,12 +132,17 @@ describe OAuthPolicy do
 
       request = Request.new :get, Addressable::URI.parse('http://xxx/')
 
-      -> { OAuthPolicy.authorize request }.should raise_error 'The consumer_credential has not been supplied.'
+      expect { OAuthPolicy.authorize request }.to raise_error 'The consumer_credential has not been supplied.'
     end
 
     it 'can sign with token' do
-      Clock.stub(:timestamp).and_return '1327360530'
-      Nonce.stub(:next).and_return '4f610cb28e7aa8711558de5234af1f0e'
+      allow(Clock)
+        .to receive(:timestamp)
+        .and_return '1327360530'
+
+      allow(Nonce)
+        .to receive(:next)
+        .and_return '4f610cb28e7aa8711558de5234af1f0e'
 
       OAuthPolicy.consumer_credential = OAuthCredential.new 'consumer_key', 'consumer_secret'
       OAuthPolicy.token  = OAuthCredential.new 'token_key', 'token_secret'
@@ -130,7 +151,7 @@ describe OAuthPolicy do
 
       authorized_request = OAuthPolicy.authorize request
 
-      authorized_request.headers['Authorization'].should =~ /oauth_signature="1Boj4fo6KiXA4xGD%2BKF5QOD36PI%3D"/
+      expect(authorized_request.headers['Authorization']).to match(/oauth_signature="1Boj4fo6KiXA4xGD%2BKF5QOD36PI%3D"/)
     end
 
     it 'adds correct signature for https uri'