ruby-trello 2.0.0 → 2.3.1

data/spec/checklist_spec.rb

@@ -167,12 +167,21 @@ module Trello
         expected_item_id = "1234"
         expected_state = "incomplete"
         expected_resource =
-          "/cards/abccardid/checklist/abcdef123456789123456789" \
-          "/checkItem/#{expected_item_id}/state"
-        payload = { value: expected_state }
+          "/cards/abccardid/checkItem/#{expected_item_id}"
+        payload = { state: expected_state }
         expect(client).to receive(:put).once.with(expected_resource, payload)
         checklist.update_item_state(expected_item_id, expected_state)
       end
+
+      it "updates an item's with boolean input" do
+        expected_item_id = "1234"
+        expected_state = "complete"
+        expected_resource =
+            "/cards/abccardid/checkItem/#{expected_item_id}"
+        payload = { state: expected_state }
+        expect(client).to receive(:put).once.with(expected_resource, payload)
+        checklist.update_item_state(expected_item_id, true)
+      end
     end
 
     context "board" do
@@ -256,5 +265,32 @@ module Trello
         checklist.copy
       end
     end
+
+    describe "#update_fields" do
+      it "does not set any fields when the fields argument is empty" do
+        expected = {
+          'id' => 'id',
+          'name' => 'name',
+          'desc' => 'description',
+          'closed' => 'closed',
+          'url' => 'url',
+          'checkItems' => 'check_items',
+          'pos' => 'position',
+          'idBoard' => 'board_id',
+          'idCard' => 'card_id',
+          'idList' => 'list_id',
+          'idMembers' => 'member_ids'
+        }
+
+        checklist = Checklist.new(expected)
+        checklist.client = client
+
+        checklist.update_fields({})
+
+        expected.each do |key, value|
+          expect(checklist.send(value)).to eq expected[key]
+        end
+      end
+    end
   end
 end

data/spec/client_spec.rb

@@ -50,7 +50,11 @@ describe Client do
           .to receive(:try_execute)
           .and_return(response_with_non_200_status)
 
-        expect { client.get "/xxx" }.to raise_error(Error, "404 error response")
+        expect { client.get "/xxx" }.to raise_error do |error|
+          expect(error).to be_a(Error)
+          expect(error.message).to eq("404 error response")
+          expect(error.status_code).to eq(404)
+        end
       end
     end
   end

data/spec/custom_field_item_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+module Trello
+  describe CustomFieldItem do
+    include Helpers
+
+    let(:text_field_details) {
+      {
+        'id'   => 'abcdefgh12345678',
+        'value' => {"text" => "Low Priority"},
+        'idValue' => nil,
+        'idModel' => 'abc123',
+        'idCustomField' => 'abcd1234',
+        'modelType' => 'card'
+      }
+    }
+
+    let(:list_item_details) {
+      {
+        'id'   => 'abcdefgh12345678',
+        'value' => nil,
+        'idValue' => 'abcde12345',
+        'idModel' => 'abc123',
+        'idCustomField' => 'abcd1234',
+        'modelType' => 'card'
+      }
+    }
+
+    let(:client) { Client.new }
+    let(:text_item) { CustomFieldItem.new(text_field_details) }
+    let(:list_item) { CustomFieldItem.new(list_item_details) }
+
+    it 'validates presence of id, model ID and custom field ID' do
+      invalid_item = CustomFieldItem.new
+
+      expect(invalid_item).to be_invalid
+      expect(invalid_item.errors).to include(:id)
+      expect(invalid_item.errors).to include(:model_id)
+      expect(invalid_item.errors).to include(:custom_field_id)
+    end
+
+    describe 'retrieve item fields' do
+      it 'gets its id' do
+        expect(text_item.id).to eq text_field_details['id']
+      end
+
+      it 'gets its value' do
+        expect(text_item.value).to eq text_field_details['value']
+      end
+
+      it 'gets its model type' do
+        expect(text_item.model_type).to eq text_field_details['modelType']
+      end
+
+      it 'gets its model ID' do
+        expect(text_item.model_id).to eq text_field_details['idModel']
+      end
+
+      it 'gets its custom field ID' do
+        expect(text_item.custom_field_id).to eq text_field_details['idCustomField']
+      end
+
+      it 'has a value ID for list option' do
+        expect(list_item.option_id).to eq list_item_details['idValue']
+      end
+    end
+
+    describe 'list option' do
+      let(:client) { Trello.client }
+
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/customFields/#{list_item.custom_field_id}/options/#{list_item.option_id}")
+          .and_return JSON.generate(custom_field_option_details)
+      end
+
+      it 'gets the value' do
+        expect(list_item.option_value).to_not be_nil
+      end
+    end
+
+    describe 'custom field' do
+      let(:client) { Trello.client }
+
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/customFields/abcd1234", {})
+          .and_return JSON.generate(custom_fields_details.first)
+      end
+
+      it 'has a custom field' do
+        expect(text_item.custom_field).to be_a CustomField
+        expect(text_item.custom_field.name).to eq('Priority')
+      end
+
+      it 'returns the custom field type' do
+        expect(text_item.type).to eq 'checkbox'
+      end
+    end
+
+    describe 'card' do
+      let(:client) { Trello.client }
+
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/cards/abc123", {})
+          .and_return JSON.generate(cards_details.first)
+      end
+
+      it 'has a card' do
+        expect(text_item.card).to be_a Card
+      end
+    end
+
+    describe '#update_fields' do
+
+      context 'when the fields argument is empty' do
+        let(:fields) { {} }
+
+        it 'custom field item does not set any fields' do
+          text_item.update_fields(fields)
+
+          expect(text_item.id).to eq text_field_details['id']
+          expect(text_item.option_id).to eq text_field_details['idValue']
+          expect(text_item.model_id).to eq text_field_details['idModel']
+          expect(text_item.custom_field_id).to eq text_field_details['idCustomField']
+          expect(text_item.model_type).to eq text_field_details['modelType']
+          expect(text_item.value).to eq text_field_details['value']
+        end
+      end
+
+      context 'when the fields argument has at least one field' do
+
+        context 'and the field does changed' do
+          let(:fields) { { value: { number: '42' } } }
+
+          it 'custom field item does set the changed fields' do
+            text_item.update_fields(fields)
+
+            expect(text_item.value).to eq( { number: '42' } )
+          end
+
+          it 'card has been mark as changed' do
+            text_item.update_fields(fields)
+
+            expect(text_item.changed?).to be_truthy
+          end
+        end
+
+        context "and the field doesn't changed" do
+          let(:fields) { { value: text_field_details['value'] } }
+
+          it "custom field item attributes doesn't changed" do
+            text_item.update_fields(fields)
+
+            expect(text_item.value).to eq(text_field_details['value'])
+          end
+
+          it "custom field item hasn't been mark as changed", pending: true do
+            text_item.update_fields(fields)
+
+            expect(text_item.changed?).to be_falsy
+          end
+        end
+
+        context "and the field isn't a correct attributes of the card" do
+          let(:fields) { { abc: 'abc' } }
+
+          it "custom field item attributes doesn't changed" do
+            text_item.update_fields(fields)
+
+            expect(text_item.id).to eq text_field_details['id']
+            expect(text_item.option_id).to eq text_field_details['idValue']
+            expect(text_item.model_id).to eq text_field_details['idModel']
+            expect(text_item.custom_field_id).to eq text_field_details['idCustomField']
+            expect(text_item.model_type).to eq text_field_details['modelType']
+            expect(text_item.value).to eq text_field_details['value']
+          end
+
+          it "custom field item hasn't been mark as changed" do
+            text_item.update_fields(fields)
+
+            expect(text_item.changed?).to be_falsy
+          end
+        end
+      end
+    end
+  end
+end

data/spec/custom_field_option_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module Trello
+  describe CustomFieldOption do
+    include Helpers
+
+    let(:option) { CustomFieldOption.new(custom_field_option_details) }
+
+    it 'validates presence of value and id' do
+      invalid_option = CustomFieldOption.new
+
+      expect(invalid_option).to be_invalid
+      expect(invalid_option.errors).to include(:value)
+      expect(invalid_option.errors).to include(:id)
+    end
+
+    describe 'retrieve option fields' do
+      it 'gets its id' do
+        expect(option.id).to eq custom_field_option_details['_id']
+      end
+
+      it 'gets its color' do
+        expect(option.color).to eq custom_field_option_details['color']
+      end
+
+      it 'knows its value' do
+        expect(option.value).to eq custom_field_option_details['value']
+      end
+
+      it 'gets its pos' do
+        expect(option.pos).to eq custom_field_option_details['pos']
+      end
+    end
+
+    describe 'update fields' do
+      it 'allows fields to be updated' do
+        updated = {
+          color: "purple",
+          value: { "text" => "Medium Priority" }
+        }
+
+        option.update_fields(updated)
+
+        expect(option.color).to eq "purple"
+        expect(option.value).to eq({"text" => "Medium Priority"})
+      end
+    end
+  end
+end

data/spec/custom_field_spec.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+
+module Trello
+  describe CustomField do
+    include Helpers
+
+    let(:custom_field) { client.find('customFields', 'abcdef123456789123456789') }
+    let(:client) { Client.new }
+
+    before do
+      allow(client)
+        .to receive(:get)
+        .with('/customFields/abcdef123456789123456789', {})
+        .and_return custom_fields_payload
+    end
+
+    context 'creating' do
+      let(:client) { Trello.client }
+
+      it 'creates a new CustomField record' do
+        custom_fields_details.each do |details|
+          custom_field = CustomField.new(details)
+          expect(custom_field).to be_valid
+        end
+      end
+
+      it 'properly initializes all fields from response-like formatted hash' do
+        custom_field_details = custom_fields_details.first
+        custom_field = CustomField.new(custom_field_details)
+        expect(custom_field.id).to          eq(custom_field_details['id'])
+        expect(custom_field.name).to        eq(custom_field_details['name'])
+        expect(custom_field.type).to        eq(custom_field_details['type'])
+        expect(custom_field.pos).to         eq(custom_field_details['pos'])
+        expect(custom_field.model_id).to    eq(custom_field_details['idModel'])
+        expect(custom_field.model_type).to  eq(custom_field_details['modelType'])
+      end
+
+      it 'properly initializes all fields from options-like formatted hash' do
+        custom_field_details = custom_fields_details[1]
+        custom_field = CustomField.new(custom_field_details)
+        expect(custom_field.id).to          eq(custom_field_details[:id])
+        expect(custom_field.name).to        eq(custom_field_details[:name])
+        expect(custom_field.type).to        eq(custom_field_details[:type])
+        expect(custom_field.pos).to         eq(custom_field_details[:pos])
+        expect(custom_field.model_id).to    eq(custom_field_details[:model_id])
+        expect(custom_field.model_type).to  eq(custom_field_details[:model_type])
+      end
+
+      it 'validates presence of id, name, model id, model type, type, and position' do
+        custom_field = CustomField.new
+        expect(custom_field).to_not be_valid
+        expect(custom_field.errors.count).to eq(6)
+        expect(custom_field.errors).to include(:name)
+        expect(custom_field.errors).to include(:id)
+        expect(custom_field.errors).to include(:model_id)
+        expect(custom_field.errors).to include(:model_type)
+        expect(custom_field.errors).to include(:pos)
+        expect(custom_field.errors).to include(:type)
+      end
+
+      it 'creates a new record and saves it on Trello', refactor: true do
+        test_payload = {
+          name: 'Test Custom Field'
+        }
+
+        result = JSON.generate(custom_fields_details.first.merge(test_payload))
+        expected_payload = {name: 'Test Custom Field', type: 'checkbox', idModel: 'abc123',
+                            modelType: 'board', pos: 123, fieldGroup: nil}
+
+        expect(client)
+          .to receive(:post)
+          .with('/customFields', expected_payload)
+          .and_return result
+
+        custom_field = CustomField.create(custom_fields_details[1].merge(test_payload))
+        expect(custom_field).to be_a CustomField
+      end
+    end
+
+    context 'finding' do
+      let(:client) { Trello.client }
+
+      before do
+        allow(client)
+          .to receive(:find)
+      end
+
+      it 'delegates to Trello.client#find' do
+        expect(client)
+          .to receive(:find)
+          .with('customFields', 'abcdef123456789123456789', {})
+
+        CustomField.find('abcdef123456789123456789')
+      end
+
+      it 'is equivalent to client#find' do
+        expect(CustomField.find('abcdef123456789123456789')).to eq(custom_field)
+      end
+    end
+
+    context 'updating' do
+      it 'correctly updates custom field name' do
+        expected_new_name = 'Test Name'
+
+        payload = { name: expected_new_name }
+
+        expect(client)
+          .to receive(:put).once
+          .with('/customFields/abcdef123456789123456789', payload)
+
+        custom_field.name = expected_new_name
+        custom_field.save
+      end
+    end
+
+    context 'fields' do
+      it 'gets its id' do
+        expect(custom_field.id).to_not be_nil
+      end
+
+      it 'gets its name' do
+        expect(custom_field.name).to_not be_nil
+      end
+
+      it 'gets the model id' do
+        expect(custom_field.model_id).to_not be_nil
+      end
+
+      it 'gets the model type' do
+        expect(custom_field.model_type).to_not be_nil
+      end
+
+      it 'gets its type' do
+        expect(custom_field.type).to_not be_nil
+      end
+
+      it 'gets its position' do
+        expect(custom_field.pos).to_not be_nil
+      end
+    end
+
+    context 'boards' do
+      before do
+        allow(client)
+          .to receive(:get)
+          .with('/boards/abc123', {})
+          .and_return JSON.generate(boards_details.first)
+      end
+
+      it 'has a board' do
+        expect(custom_field.board).to_not be_nil
+      end
+    end
+
+    context 'options' do
+      it 'creates a new option' do
+        payload = { :value => { "text" => "High Priority" } }
+
+        expect(client)
+          .to receive(:post)
+          .with('/customFields/abcdef123456789123456789/options', payload)
+
+        custom_field.create_new_option({"text" => "High Priority"})
+      end
+
+      it 'deletes option' do
+        expect(client)
+          .to receive(:delete)
+          .with('/customFields/abcdef123456789123456789/options/abc123')
+
+        custom_field.delete_option('abc123')
+      end
+    end
+
+    context 'deleting' do
+      it 'deletes the custom field' do
+        expect(client)
+          .to receive(:delete)
+          .with("/customFields/#{custom_field.id}")
+
+        custom_field.delete
+      end
+    end
+
+    describe '#update_fields' do
+      let(:custom_field_detail) { custom_fields_details.first }
+      let(:custom_field) { CustomField.new(custom_field_detail) }
+
+      context 'when the fields argument is empty' do
+        let(:fields) { {} }
+
+        it 'custom field does not set any fields' do
+          custom_field.update_fields(fields)
+
+          expect(custom_field.id).to eq custom_field_detail['id']
+          expect(custom_field.model_id).to eq custom_field_detail['idModel']
+          expect(custom_field.model_type).to eq custom_field_detail['modelType']
+          expect(custom_field.name).to eq custom_field_detail['name']
+          expect(custom_field.pos).to eq custom_field_detail['pos']
+          expect(custom_field.type).to eq custom_field_detail['type']
+        end
+      end
+
+      context 'when the fields argument has at least one field' do
+        context 'and the field does changed' do
+          let(:fields) { { name: 'Awesome Name' } }
+
+          it 'custom field does set the changed fields' do
+            custom_field.update_fields(fields)
+
+            expect(custom_field.name).to eq('Awesome Name')
+          end
+
+          it 'custom field has been mark as changed' do
+            custom_field.update_fields(fields)
+
+            expect(custom_field.changed?).to be_truthy
+          end
+        end
+
+        context "and the field doesn't changed" do
+          let(:fields) { { name: custom_field_detail['name'] } }
+
+          it "custom field attributes doesn't changed" do
+            custom_field.update_fields(fields)
+
+            expect(custom_field.name).to eq(custom_field_detail['name'])
+          end
+
+          it "custom field hasn't been mark as changed", pending: true do
+            custom_field.update_fields(fields)
+
+            expect(custom_field.changed?).to be_falsy
+          end
+        end
+
+        context "and the field isn't a correct attributes of the card" do
+          let(:fields) { { abc: 'abc' } }
+
+          it "custom field attributes doesn't changed" do
+            custom_field.update_fields(fields)
+
+            expect(custom_field.id).to eq custom_field_detail['id']
+            expect(custom_field.model_id).to eq custom_field_detail['idModel']
+            expect(custom_field.model_type).to eq custom_field_detail['modelType']
+            expect(custom_field.name).to eq custom_field_detail['name']
+            expect(custom_field.pos).to eq custom_field_detail['pos']
+            expect(custom_field.type).to eq custom_field_detail['type']
+          end
+
+          it "custom field hasn't been mark as changed" do
+            custom_field.update_fields(fields)
+
+            expect(custom_field.changed?).to be_falsy
+          end
+        end
+      end
+    end
+
+  end
+end