ruby-trello 1.2.1 → 1.3.0

data/spec/hash_spec.rb

@@ -5,7 +5,11 @@ describe Hash, '#jsoned_into' do
   include Helpers
 
   it "should convert a single parsed json into card" do
-    Trello::Card.should_receive(:new).once.with(cards_details.first)
+    expect(Trello::Card)
+      .to receive(:new)
+      .once
+      .with(cards_details.first)
+
     cards_details.first.jsoned_into(Trello::Card)
   end
 end

data/spec/item_spec.rb

@@ -2,36 +2,54 @@ require 'spec_helper'
 
 module Trello
   describe Item do
-    before(:all) do
-      @detail = {
+    let(:details) {
+      {
         'id'   => 'abcdef123456789123456789',
         'name' => 'test item',
         'type' => 'check',
         'state' => 'complete',
         'pos' => 0
       }
+    }
 
-      @item = Item.new(@detail)
-    end
+    let(:item) { Item.new(details) }
 
     it 'gets its id' do
-      @item.id.should == @detail['id']
+      expect(item.id).to eq details['id']
     end
 
     it 'gets its name' do
-      @item.name.should == @detail['name']
+      expect(item.name).to eq details['name']
     end
 
     it 'knows its type' do
-      @item.type.should == @detail['type']
+      expect(item.type).to eq details['type']
     end
 
     it 'knows its state' do
-      @item.state.should == @detail['state']
+      expect(item.state).to eq details['state']
     end
 
     it 'knows its pos' do
-      @item.pos.should == @detail['pos']
+      expect(item.pos).to eq details['pos']
+    end
+
+    describe '#complete?' do
+      before do
+        allow(item)
+          .to receive(:state)
+          .and_return state
+      end
+
+      context 'when complete' do
+        let(:state) { 'complete' }
+        it { expect(item).to be_complete }
+      end
+
+      context 'when complete' do
+        let(:state) { 'incomplete' }
+        it { expect(item).not_to be_complete }
+      end
     end
   end
 end

data/spec/label_spec.rb

@@ -7,21 +7,26 @@ module Trello
     let(:label) { client.find(:label, 'abcdef123456789123456789') }
     let(:client) { Client.new }
 
-    before(:each) do
-      client.stub(:get).with("/labels/abcdef123456789123456789", {}).
-      and_return JSON.generate(label_details.first)
+    before do
+      allow(client)
+        .to receive(:get)
+        .with("/labels/abcdef123456789123456789", {})
+        .and_return JSON.generate(label_details.first)
     end
 
     context "finding" do
       let(:client) { Trello.client }
 
       it "delegates to Trello.client#find" do
-        client.should_receive(:find).with(:label, 'abcdef123456789123456789', {})
+        expect(client)
+          .to receive(:find)
+          .with(:label, 'abcdef123456789123456789', {})
+
         Label.find('abcdef123456789123456789')
       end
 
       it "is equivalent to client#find" do
-        Label.find('abcdef123456789123456789').should eq(label)
+        expect(Label.find('abcdef123456789123456789')).to eq(label)
       end
     end
 
@@ -29,18 +34,15 @@ module Trello
       let(:client) { Trello.client }
 
       it "creates a new record" do
-        label = Label.new(label_details.first)
-        label.should be_valid
+        expect(Label.new(label_details.first)).to be_valid
       end
 
       it 'must not be valid if not given a name' do
-        label = Label.new('idBoard' => lists_details.first['board_id'])
-        label.should_not be_valid
+        expect(Label.new('idBoard' => lists_details.first['board_id'])).to_not be_valid
       end
 
       it 'must not be valid if not given a board id' do
-        label = Label.new('name' => lists_details.first['name'])
-        label.should_not be_valid
+        expect(Label.new('name' => lists_details.first['name'])).to_not be_valid
       end
 
       it 'creates a new record and saves it on Trello', refactor: true do
@@ -53,11 +55,14 @@ module Trello
 
         expected_payload = {name: "Test Label", color: nil, idBoard: "abcdef123456789123456789" }
 
-        client.should_receive(:post).with("/labels", expected_payload).and_return result
+        expect(client)
+          .to receive(:post)
+          .with("/labels", expected_payload)
+          .and_return result
 
         label = Label.create(label_details.first.merge(payload.merge(board_id: boards_details.first['id'])))
 
-        label.class.should be Label
+        expect(label).to be_a Label
       end
     end
 
@@ -69,7 +74,10 @@ module Trello
           name: expected_new_name,
         }
 
-        client.should_receive(:put).once.with("/labels/abcdef123456789123456789", payload)
+        expect(client)
+          .to receive(:put)
+          .once
+          .with("/labels/abcdef123456789123456789", payload)
 
         label.name = expected_new_name
         label.save
@@ -82,7 +90,10 @@ module Trello
           color: expected_new_color,
         }
 
-        client.should_receive(:put).once.with("/labels/abcdef123456789123456789", payload)
+        expect(client)
+          .to receive(:put)
+          .once
+          .with("/labels/abcdef123456789123456789", payload)
 
         label.color = expected_new_color
         label.save
@@ -90,8 +101,11 @@ module Trello
 
       it "can update with any valid color" do
         %w(green yellow orange red purple blue sky lime pink black).each do |color|
-          client.stub(:put).with("/labels/abcdef123456789123456789", {color: color}).
-            and_return "not important"
+          allow(client)
+            .to receive(:put)
+            .with("/labels/abcdef123456789123456789", {color: color})
+            .and_return "not important"
+
           label.color = color
           label.save
           expect(label.errors).to be_empty
@@ -99,44 +113,55 @@ module Trello
       end
 
       it "throws an error when trying to update a label with an unknown colour" do
-        client.stub(:put).with("/labels/abcdef123456789123456789", {}).
-          and_return "not important"
+        allow(client)
+          .to receive(:put)
+          .with("/labels/abcdef123456789123456789", {})
+          .and_return "not important"
+
         label.color = 'mauve'
         label.save
+
         expect(label.errors.full_messages.to_sentence).to eq("Label color 'mauve' does not exist")
       end
     end
 
     context "deleting" do
       it "deletes the label" do
-        client.should_receive(:delete).with("/labels/#{label.id}")
+        expect(client)
+          .to receive(:delete)
+          .with("/labels/#{label.id}")
+
         label.delete
       end
     end
 
     context "fields" do
       it "gets its id" do
-        label.id.should_not be_nil
+        expect(label.id).to_not be_nil
       end
 
       it "gets its name" do
-        label.name.should_not be_nil
+        expect(label.name).to_not be_nil
       end
 
       it "gets its usage" do
-        label.uses.should_not be_nil
+        expect(label.uses).to_not be_nil
       end
 
       it "gets its color" do
-        label.color.should_not be_nil
+        expect(label.color).to_not be_nil
       end
     end
 
     context "boards" do
       it "has a board" do
-        client.stub(:get).with("/boards/abcdef123456789123456789", {}).and_return JSON.generate(boards_details.first)
-        label.board.should_not be_nil
+        expect(client)
+          .to receive(:get)
+          .with("/boards/abcdef123456789123456789", {})
+          .and_return JSON.generate(boards_details.first)
+
+        expect(label.board).to_not be_nil
       end
     end
   end
-end
+end

data/spec/list_spec.rb

@@ -8,20 +8,30 @@ module Trello
     let(:client) { Client.new }
 
     before(:each) do
-      client.stub(:get).with('/lists/abcdef123456789123456789', {}).and_return JSON.generate(lists_details.first)
-      client.stub(:get).with('/boards/abcdef123456789123456789', {}).and_return JSON.generate(boards_details.first)
+      allow(client)
+        .to receive(:get)
+        .with('/lists/abcdef123456789123456789', {})
+        .and_return JSON.generate(lists_details.first)
+
+      allow(client)
+        .to receive(:get)
+        .with('/boards/abcdef123456789123456789', {})
+        .and_return JSON.generate(boards_details.first)
     end
 
     context 'finding' do
       let(:client) { Trello.client }
 
       it 'delegates to client#find' do
-        client.should_receive(:find).with(:list, 'abcdef123456789123456789', {})
+        expect(client)
+          .to receive(:find)
+          .with(:list, 'abcdef123456789123456789', {})
+
         List.find('abcdef123456789123456789')
       end
 
       it 'is equivalent to client#find' do
-        List.find('abcdef123456789123456789').should eq(list)
+        expect(List.find('abcdef123456789123456789')).to eq(list)
       end
     end
 
@@ -30,34 +40,36 @@ module Trello
 
       it 'creates a new record' do
         list = List.new(lists_details.first)
-        list.should be_valid
+        expect(list).to be_valid
       end
 
       it 'must not be valid if not given a name' do
         list = List.new(lists_details.first.except('name'))
-        list.should_not be_valid
+        expect(list).to_not be_valid
       end
 
       it 'must not be valid if not given a list id' do
         list = List.new(lists_details.first.except('id'))
-        list.should_not be_valid
+        expect(list).to_not be_valid
       end
 
       it 'creates a new record and saves it on Trello', refactor: true do
         payload = {
           name: 'Test List',
-          board_id: 'abcdef123456789123456789'
+          board_id: 'abcdef123456789123456789',
+          pos: 42
         }
 
         result = JSON.generate(payload)
 
-        expected_payload = {name: 'Test List', closed: false, idBoard: 'abcdef123456789123456789'}
+        expected_payload = {name: 'Test List', closed: false, idBoard: 'abcdef123456789123456789', pos: 42}
 
-        client.should_receive(:post).with('/lists', expected_payload).and_return result
+        expect(client)
+          .to receive(:post)
+          .with('/lists', expected_payload).and_return result
 
         list = List.create(payload)
-
-        list.class.should be List
+        expect(list).to be_a List
       end
     end
 
@@ -67,70 +79,115 @@ module Trello
 
         payload = {
           name: expected_new_name,
-          closed: false
+          closed: false,
+          pos: list.pos
         }
 
-        client.should_receive(:put).once.with('/lists/abcdef123456789123456789', payload)
+        expect(client)
+          .to receive(:put)
+          .once
+          .with('/lists/abcdef123456789123456789', payload)
+
         list.name = expected_new_name
         list.save
       end
+
+      it 'updates position' do
+        new_position = 42
+        payload = {
+          name: list.name,
+          closed: list.closed,
+          pos: new_position
+        }
+
+        expect(client)
+          .to receive(:put)
+          .once
+          .with('/lists/abcdef123456789123456789', payload)
+
+        list.pos = new_position
+        list.save
+      end
     end
 
     context 'fields' do
       it 'gets its id' do
-        list.id.should == lists_details.first['id']
+        expect(list.id).to eq lists_details.first['id']
       end
 
       it 'gets its name' do
-        list.name.should == lists_details.first['name']
+        expect(list.name).to eq lists_details.first['name']
       end
 
       it 'knows if it is open or closed' do
-        list.closed.should == lists_details.first['closed']
+        expect(list.closed).to eq lists_details.first['closed']
       end
 
       it 'has a board' do
-        list.board.should == Board.new(boards_details.first)
+        expect(list.board).to eq Board.new(boards_details.first)
       end
 
       it 'gets its position' do
-        list.pos.should == lists_details.first['pos']
+        expect(list.pos).to eq lists_details.first['pos']
       end
     end
 
     context 'actions' do
       it 'has a list of actions' do
-        client.stub(:get).with('/lists/abcdef123456789123456789/actions', { filter: :all }).and_return actions_payload
-        list.actions.count.should be > 0
+        allow(client)
+          .to receive(:get)
+          .with('/lists/abcdef123456789123456789/actions', { filter: :all })
+          .and_return actions_payload
+
+        expect(list.actions.count).to be > 0
       end
     end
 
     context 'cards' do
       it 'has a list of cards' do
-        client.stub(:get).with('/lists/abcdef123456789123456789/cards', { filter: :open }).and_return cards_payload
-        list.cards.count.should be > 0
+        allow(client)
+          .to receive(:get)
+          .with('/lists/abcdef123456789123456789/cards', { filter: :open })
+          .and_return cards_payload
+
+        expect(list.cards.count).to be > 0
+      end
+
+      it 'moves cards to another list' do
+        other_list = List.new(lists_details.first.merge(id: 'otherListID', cards: []))
+
+        allow(client)
+          .to receive(:post)
+          .with('/lists/abcdef123456789123456789/moveAllCards', { idBoard: other_list.board_id, idList: other_list.id })
+          .and_return cards_payload
+
+        expect(list.move_all_cards(other_list)).to eq cards_payload
       end
     end
 
     describe '#closed?' do
       it 'returns the closed attribute' do
-        expect(list.closed?).not_to be(true)
+        expect(list).to_not be_closed
       end
     end
 
     describe '#close' do
       it 'updates the close attribute to true' do
         list.close
-        expect(list.closed).to be(true)
+        expect(list).to be_closed
       end
     end
 
     describe '#close!' do
       it 'updates the close attribute to true and saves the list' do
-        client.should_receive(:put).once.with('/lists/abcdef123456789123456789', {
-          name: list.name,
-          closed: true
-        })
+        expect(client)
+          .to receive(:put)
+          .once
+          .with('/lists/abcdef123456789123456789', {
+            name: list.name,
+            closed: true,
+            pos: list.pos
+          })
 
         list.close!
       end