ruby-trello 1.2.1 → 1.3.0

data/spec/checklist_spec.rb

@@ -7,21 +7,26 @@ module Trello
     let(:checklist) { client.find(:checklist, 'abcdef123456789123456789') }
     let(:client) { Client.new }
 
-    before(:each) do
-      client.stub(:get).with("/checklists/abcdef123456789123456789", {}).
-          and_return JSON.generate(checklists_details.first)
+    before do
+      allow(client)
+        .to receive(:get)
+        .with("/checklists/abcdef123456789123456789", {})
+        .and_return JSON.generate(checklists_details.first)
     end
 
     context "finding" do
       let(:client) { Trello.client }
 
       it "delegates to Trello.client#find" do
-        client.should_receive(:find).with(:checklist, 'abcdef123456789123456789', {})
+        expect(client)
+          .to receive(:find)
+          .with(:checklist, 'abcdef123456789123456789', {})
+
         Checklist.find('abcdef123456789123456789')
       end
 
       it "is equivalent to client#find" do
-        Checklist.find('abcdef123456789123456789').should eq(checklist)
+        expect(Checklist.find('abcdef123456789123456789')).to eq(checklist)
       end
     end
 
@@ -38,11 +43,14 @@ module Trello
 
         expected_payload = {name: "Test Checklist", idBoard: "abcdef123456789123456789"}
 
-        client.should_receive(:post).with("/checklists", expected_payload).and_return result
+        expect(client)
+          .to receive(:post)
+          .with("/checklists", expected_payload)
+          .and_return result
 
         checklist = Checklist.create(checklists_details.first.merge(payload.merge(board_id: boards_details.first['id'])))
 
-        checklist.class.should be Checklist
+        expect(checklist).to be_a Checklist
       end
     end
 
@@ -50,13 +58,19 @@ module Trello
       let(:client) { Trello.client }
 
       it "deletes a checklist" do
-        client.should_receive(:delete).with("/checklists/#{checklist.id}")
+        expect(client)
+          .to receive(:delete)
+          .with("/checklists/#{checklist.id}")
+
         checklist.delete
       end
 
       it "deletes a checklist item" do
         item_id = checklist.check_items.first.last
-        client.should_receive(:delete).with("/checklists/#{checklist.id}/checkItems/#{item_id}")
+        expect(client)
+          .to receive(:delete)
+          .with("/checklists/#{checklist.id}/checkItems/#{item_id}")
+
         checklist.delete_checklist_item(item_id)
       end
     end
@@ -71,7 +85,10 @@ module Trello
         }
 
         result = JSON.generate(checklists_details.first)
-        client.should_receive(:put).once.with(expected_resource, payload).and_return result
+        expect(client)
+          .to receive(:put)
+          .once.with(expected_resource, payload)
+          .and_return result
 
         checklist.name = expected_new_name
         checklist.save
@@ -86,7 +103,11 @@ module Trello
         }
 
         result = JSON.generate(checklists_details.first)
-        client.should_receive(:put).once.with(expected_resource, payload).and_return result
+        expect(client)
+          .to receive(:put)
+          .once
+          .with(expected_resource, payload)
+          .and_return result
 
         checklist.position = expected_new_position
         checklist.save
@@ -107,23 +128,95 @@ module Trello
             pos: expected_pos
         }
         result = JSON.generate(result_hash)
-        client.should_receive(:post).once.with("/checklists/abcdef123456789123456789/checkItems", payload).and_return result
+        expect(client)
+          .to receive(:post)
+          .once
+          .with("/checklists/abcdef123456789123456789/checkItems", payload)
+          .and_return result
 
         checklist.add_item(expected_item_name, expected_checked, expected_pos)
       end
     end
 
     context "board" do
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/boards/abcdef123456789123456789")
+          .and_return JSON.generate(boards_details.first)
+      end
+
       it "has a board" do
-        client.stub(:get).with("/boards/abcdef123456789123456789").and_return JSON.generate(boards_details.first)
-        checklist.board.should_not be_nil
+        expect(checklist.board).to_not be_nil
       end
     end
 
     context "list" do
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/lists/abcdef123456789123456789", {})
+          .and_return JSON.generate(lists_details.first)
+      end
+
       it 'has a list' do
-        client.stub(:get).with("/lists/abcdef123456789123456789", {}).and_return JSON.generate(lists_details.first)
-        checklist.list.should_not be_nil
+        expect(checklist.list).to_not be_nil
+      end
+    end
+
+    context "making a copy" do
+      let(:client) { Trello.client }
+      let(:copy_options) { { :name => checklist.name, :idBoard => checklist.board_id } }
+      let(:copied_checklist) { checklist.copy }
+
+      before(:each) do
+        allow(client)
+          .to receive(:post)
+          .with("/checklists", copy_options)
+          .and_return JSON.generate(copied_checklists_details.first)
+
+        allow(checklist)
+          .to receive(:items)
+          .and_return []
+      end
+
+      it "creates a new checklist" do
+        expect(copied_checklist).to be_an_instance_of Checklist
+      end
+
+      it "is not the same Ruby object as the original checklist" do
+        expect(copied_checklist).to_not be checklist
+      end
+
+      it "has the same name as the original checklist" do
+        expect(copied_checklist.name).to eq checklist.name
+      end
+
+      it "has the same board as the original checklist" do
+        expect(copied_checklist.board_id).to eq checklist.board_id
+      end
+
+      it "creates items for the copy based on the original checklist's items" do
+        checklist_copy  = Trello::Checklist.new
+        allow(checklist_copy)
+          .to receive(:add_item)
+
+        allow(Trello::Checklist)
+          .to receive(:create)
+          .and_return(checklist_copy)
+
+        incomplete_item = double("incomplete", name: "1", complete?: false)
+        complete_item   = double("complete", name: "2", complete?: true)
+        checklist_items = [incomplete_item, complete_item]
+        allow(checklist).to receive(:items).and_return checklist_items
+
+        checklist_items.each do |item|
+          expect(checklist_copy)
+            .to receive(:add_item)
+            .with(item.name, item.complete?)
+        end
+
+        checklist.copy
       end
     end
   end

data/spec/client_spec.rb

@@ -13,16 +13,28 @@ describe Client, "and how it handles authorization" do
   let(:auth_policy) { double }
 
   before do
-    TInternet.stub(:execute).and_return fake_ok_response
-    Authorization::AuthPolicy.stub(:new).and_return(auth_policy)
-    auth_policy.stub(:authorize) do |request|
-      request
-    end
+    allow(TInternet)
+      .to receive(:execute)
+      .and_return fake_ok_response
+
+    allow(Authorization::AuthPolicy)
+      .to receive(:new)
+      .and_return(auth_policy)
+
+    allow(auth_policy)
+      .to receive(:authorize) { |request| request }
   end
 
   it "authorizes before it queries the internet" do
-    auth_policy.should_receive(:authorize).once.ordered
-    TInternet.should_receive(:execute).once.ordered
+    expect(auth_policy)
+      .to receive(:authorize)
+      .once
+      .ordered
+
+    expect(TInternet)
+      .to receive(:execute)
+      .once
+      .ordered
 
     client.get "/xxx"
   end
@@ -31,7 +43,10 @@ describe Client, "and how it handles authorization" do
     expected_uri = Addressable::URI.parse("https://api.trello.com/1/xxx?a=1&b=2")
     expected_request = Request.new :get, expected_uri, {}
 
-    TInternet.should_receive(:execute).once.with expected_request
+    expect(TInternet)
+      .to receive(:execute)
+      .once
+      .with expected_request
 
     client.get "/xxx", a: "1", b: "2"
   end
@@ -40,7 +55,10 @@ describe Client, "and how it handles authorization" do
     expected_uri = Addressable::URI.parse("https://api.trello.com/1/xxx?name=Jazz%20Kang")
     expected_request = Request.new :get, expected_uri, {}
 
-    TInternet.should_receive(:execute).once.with expected_request
+    expect(TInternet)
+      .to receive(:execute)
+      .once
+      .with expected_request
 
     client.get "/xxx", name: "Jazz Kang"
   end
@@ -51,31 +69,40 @@ describe Client, "and how it handles authorization" do
       code: 404,
       body: expected_error_message
 
-    TInternet.stub(:execute).and_return response_with_non_200_status
+    expect(TInternet)
+      .to receive(:execute)
+      .and_return response_with_non_200_status
 
-    -> { client.get "/xxx" }.should raise_error expected_error_message
+    expect { client.get "/xxx" }.to raise_error expected_error_message
   end
 
   it "uses version 1 of the API" do
-    TInternet.should_receive(:execute).once do |request|
-      request.uri.to_s.should =~ /1\//
-      fake_ok_response
-    end
+    expect(TInternet)
+      .to receive(:execute)
+      .once do |request|
+        expect(request.uri.to_s).to match(/1\//)
+        fake_ok_response
+      end
 
     client.get "/"
   end
 
   it "omits the \"?\" when no parameters" do
-    TInternet.should_receive(:execute).once do |request|
-      request.uri.to_s.should_not =~ /\?$/
-      fake_ok_response
-    end
+    expect(TInternet)
+      .to receive(:execute)
+      .once do |request|
+        expect(request.uri.to_s).not_to match(/\?$/)
+        fake_ok_response
+      end
 
     client.get "/xxx"
   end
 
   it "supports post" do
-    TInternet.should_receive(:execute).once.and_return fake_ok_response
+    expect(TInternet)
+      .to receive(:execute)
+      .once
+      .and_return fake_ok_response
 
     client.post "/xxx", { phil: "T' north" }
   end
@@ -83,10 +110,12 @@ describe Client, "and how it handles authorization" do
   it "supplies the body for a post" do
     expected_body = { name: "Phil", nickname: "The Crack Fox" }
 
-    TInternet.should_receive(:execute).once do |request|
-      request.body.should == expected_body
-      fake_ok_response
-    end
+    expect(TInternet)
+      .to receive(:execute)
+      .once do |request|
+        expect(request.body).to eq expected_body
+        fake_ok_response
+      end
 
     client.post "/xxx", expected_body
   end
@@ -94,16 +123,21 @@ describe Client, "and how it handles authorization" do
   it "supplies the path for a post" do
     expected_path = "/xxx"
 
-    TInternet.should_receive(:execute).once do |request|
-      request.uri.path.should =~ /#{expected_path}$/
-      fake_ok_response
-    end
+    expect(TInternet)
+      .to receive(:execute)
+      .once do |request|
+        expect(request.uri.path).to match(/#{expected_path}$/)
+        fake_ok_response
+      end
 
     client.post "/xxx", {}
   end
 
   it "supports put" do
-    TInternet.should_receive(:execute).once.and_return fake_ok_response
+    expect(TInternet)
+      .to receive(:execute)
+      .once
+      .and_return fake_ok_response
 
     client.put "/xxx", { phil: "T' north" }
   end
@@ -111,10 +145,12 @@ describe Client, "and how it handles authorization" do
   it "supplies the body for a put" do
     expected_body = { name: "Phil", nickname: "The Crack Fox" }
 
-    TInternet.should_receive(:execute).once do |request|
-      request.body.should == expected_body
-      fake_ok_response
-    end
+    expect(TInternet)
+      .to receive(:execute)
+      .once do |request|
+        expect(request.body).to eq expected_body
+        fake_ok_response
+      end
 
     client.put "/xxx", expected_body
   end
@@ -122,10 +158,12 @@ describe Client, "and how it handles authorization" do
   it "supplies the path for a put" do
     expected_path = "/xxx"
 
-    TInternet.should_receive(:execute).once do |request|
-      request.uri.path.should =~ /#{expected_path}$/
-      fake_ok_response
-    end
+    expect(TInternet)
+      .to receive(:execute)
+      .once do |request|
+        expect(request.uri.path).to match(/#{expected_path}$/)
+        fake_ok_response
+      end
 
     client.put "/xxx", {}
   end
@@ -141,10 +179,10 @@ describe Client, "and how it handles authorization" do
     end
 
     it "is configurable" do
-      client.consumer_key.should eq('consumer_key')
-      client.consumer_secret.should eq('consumer_secret')
-      client.oauth_token.should eq('oauth_token')
-      client.oauth_token_secret.should eq('oauth_token_secret')
+      expect(client.consumer_key).to eq('consumer_key')
+      expect(client.consumer_secret).to eq('consumer_secret')
+      expect(client.oauth_token).to eq('oauth_token')
+      expect(client.oauth_token_secret).to eq('oauth_token_secret')
     end
   end
 
@@ -157,10 +195,10 @@ describe Client, "and how it handles authorization" do
         config.oauth_token_secret = 'oauth_token_secret'
       end
 
-      client.consumer_key.should eq('consumer_key')
-      client.consumer_secret.should eq('consumer_secret')
-      client.oauth_token.should eq('oauth_token')
-      client.oauth_token_secret.should eq('oauth_token_secret')
+      expect(client.consumer_key).to eq('consumer_key')
+      expect(client.consumer_secret).to eq('consumer_secret')
+      expect(client.oauth_token).to eq('oauth_token')
+      expect(client.oauth_token_secret).to eq('oauth_token_secret')
     end
   end
 end

data/spec/configuration_spec.rb

@@ -3,45 +3,26 @@ require 'spec_helper'
 describe Trello::Configuration do
   let(:configuration) { Trello::Configuration.new }
 
-  it 'has a consumer_key attribute' do
-    configuration.consumer_key = 'consumer_key'
-    configuration.consumer_key.should eq('consumer_key')
-  end
-
-  it 'has a consumer_secret attribute' do
-    configuration.consumer_secret = 'consumer_secret'
-    configuration.consumer_secret.should eq('consumer_secret')
-  end
-
-  it 'has a oauth_token attribute' do
-    configuration.oauth_token = 'oauth_token'
-    configuration.oauth_token.should eq('oauth_token')
-  end
-
-  it 'has a oauth_token_secret attribute' do
-    configuration.oauth_token_secret = 'oauth_token_secret'
-    configuration.oauth_token_secret.should eq('oauth_token_secret')
-  end
-
-  it 'has a developer public key attribute' do
-    configuration.developer_public_key = 'developer_public_key'
-    configuration.developer_public_key.should eq('developer_public_key')
-  end
-
-  it 'has a member token attribute' do
-    configuration.member_token = 'member_token'
-    configuration.member_token.should eq('member_token')
+  [
+    :consumer_key,
+    :consumer_secret,
+    :oauth_token,
+    :oauth_token_secret,
+    :developer_public_key,
+    :member_token,
+    :return_url
+
+  ].each do |attribute|
+    it "has a #{attribute} attribute" do
+      configuration.public_send(:"#{attribute}=", attribute)
+      expect(configuration.public_send(attribute)).to eq attribute
+    end
   end
 
   it 'has a callback (for oauth)' do
     callback = -> { 'foobar' }
     configuration.callback = callback
-    configuration.callback.call.should eq('foobar')
-  end
-
-  it 'has a return_url' do
-    configuration.return_url = 'http://www.example.com/callback'
-    configuration.return_url.should eq('http://www.example.com/callback')
+    expect(configuration.callback.call).to eq('foobar')
   end
 
   describe 'initialize' do
@@ -52,10 +33,10 @@ describe Trello::Configuration do
         oauth_token: 'oauth_token',
         oauth_token_secret: 'oauth_token_secret'
       )
-      configuration.consumer_key.should eq('consumer_key')
-      configuration.consumer_secret.should eq('consumer_secret')
-      configuration.oauth_token.should eq('oauth_token')
-      configuration.oauth_token_secret.should eq('oauth_token_secret')
+      expect(configuration.consumer_key).to eq('consumer_key')
+      expect(configuration.consumer_secret).to eq('consumer_secret')
+      expect(configuration.oauth_token).to eq('oauth_token')
+      expect(configuration.oauth_token_secret).to eq('oauth_token_secret')
     end
   end
 
@@ -63,11 +44,11 @@ describe Trello::Configuration do
     let(:configuration) { Trello::Configuration.new(attributes) }
 
     it 'returns an empty if no attributes specified' do
-      Trello::Configuration.new({}).credentials.should eq({})
+      expect(Trello::Configuration.new({}).credentials).to eq({})
     end
 
     it 'returns an empty if attributes incomplete' do
-      Trello::Configuration.new(consumer_key: 'consumer_key').credentials.should eq({})
+      expect(Trello::Configuration.new(consumer_key: 'consumer_key').credentials).to eq({})
     end
 
     it 'returns a hash of oauth attributes' do
@@ -77,7 +58,7 @@ describe Trello::Configuration do
         oauth_token: 'oauth_token',
         oauth_token_secret: 'oauth_token_secret'
       )
-      configuration.credentials.should eq(
+      expect(configuration.credentials).to eq(
         consumer_key: 'consumer_key',
         consumer_secret: 'consumer_secret',
         oauth_token: 'oauth_token',
@@ -92,7 +73,7 @@ describe Trello::Configuration do
         return_url: 'http://example.com',
         callback: 'callback'
       )
-      configuration.credentials.should eq(
+      expect(configuration.credentials).to eq(
         consumer_key: 'consumer_key',
         consumer_secret: 'consumer_secret',
         return_url: 'http://example.com',
@@ -105,7 +86,7 @@ describe Trello::Configuration do
         developer_public_key: 'developer_public_key',
         member_token: 'member_token'
       )
-      configuration.credentials.should eq(
+      expect(configuration.credentials).to eq(
         developer_public_key: 'developer_public_key',
         member_token: 'member_token'
       )