ruby-trello 2.0.1 → 3.0.0

data/spec/checklist_spec.rb

@@ -20,7 +20,7 @@ module Trello
       it "delegates to Trello.client#find" do
         expect(client)
           .to receive(:find)
-          .with(:checklist, 'abcdef123456789123456789', {})
+          .with('checklist', 'abcdef123456789123456789', {})
 
         Checklist.find('abcdef123456789123456789')
       end
@@ -35,41 +35,43 @@ module Trello
 
       it 'creates a new record and saves it on Trello', refactor: true do
         payload = {
-            name: 'Test Checklist',
-            desc: '',
-            card_id: cards_details.first['id']
+          name: 'Test Checklist',
+          card_id: '5e94fd9443f25a7263b165d0'
         }
 
-        attributes = checklists_details.first.merge(payload).except("idBoard")
-        result = JSON.generate(attributes)
+        result = JSON.generate(payload)
 
-
-        expected_payload = {name: "Test Checklist", idCard: cards_details.first['id']}
+        expected_payload = {
+          'name' => 'Test Checklist',
+          'idCard' => '5e94fd9443f25a7263b165d0'
+        }
 
         expect(client)
           .to receive(:post)
           .with("/checklists", expected_payload)
           .and_return result
 
-        checklist = Checklist.create(attributes)
+        checklist = Checklist.create(payload)
 
         expect(checklist).to be_a Checklist
       end
 
       it 'initializes all fields from response-like hash' do
-        checklist_details = checklists_details.first
-        checklist = Checklist.new(checklist_details)
-        expect(checklist.id).to          eq checklist_details['id']
-        expect(checklist.name).to        eq checklist_details['name']
-        expect(checklist.description).to eq checklist_details['desc']
-        expect(checklist.closed).to      eq checklist_details['closed']
-        expect(checklist.position).to    eq checklist_details['pos']
-        expect(checklist.url).to         eq checklist_details['url']
-        expect(checklist.board_id).to    eq checklist_details['idBoard']
-        expect(checklist.card_id).to     eq checklist_details['idCard']
-        expect(checklist.list_id).to     eq checklist_details['idList']
-        expect(checklist.member_ids).to  eq checklist_details['idMembers']
-        expect(checklist.check_items).to eq checklist_details['checkItems']
+        checklist = Checklist.new(
+          'id'         => 'abcdef123456789123456789',
+          'name'       => 'Test Checklist',
+          'pos'        => 16384,
+          'idBoard'    => 'abcdef123456789123456789',
+          'idCard'     => 'abccardid',
+          'checkItems' => { 'id' => 'ghijk987654321' }
+        )
+
+        expect(checklist.id).to          eq 'abcdef123456789123456789'
+        expect(checklist.name).to        eq 'Test Checklist'
+        expect(checklist.position).to    eq 16384
+        expect(checklist.board_id).to    eq 'abcdef123456789123456789'
+        expect(checklist.card_id).to     eq 'abccardid'
+        expect(checklist.check_items).to eq({ 'id' => 'ghijk987654321' })
       end
 
       it 'initializes required fields from options-like hash' do
@@ -113,7 +115,7 @@ module Trello
         result = JSON.generate(checklists_details.first)
         expect(client)
           .to receive(:put)
-          .once.with(expected_resource, payload)
+          .once.with(expected_resource, {'name' => expected_new_name})
           .and_return result
 
         checklist.name = expected_new_name
@@ -132,7 +134,7 @@ module Trello
         expect(client)
           .to receive(:put)
           .once
-          .with(expected_resource, payload)
+          .with(expected_resource, {'pos' => expected_new_position})
           .and_return result
 
         checklist.position = expected_new_position
@@ -197,19 +199,6 @@ module Trello
       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
-        expect(checklist.list).to_not be_nil
-      end
-    end
-
     context "making a copy" do
       let(:client) { Trello.client }
       let(:copy_options) { { :name => checklist.name, :idCard => checklist.card_id } }
@@ -218,7 +207,7 @@ module Trello
       before(:each) do
         allow(client)
           .to receive(:post)
-          .with("/checklists", copy_options)
+          .with("/checklists", copy_options.stringify_keys)
           .and_return JSON.generate(copied_checklists_details.first)
 
         allow(checklist)
@@ -271,15 +260,10 @@ module Trello
         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)

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" 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 position' do
+        expect(option.position).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,273 @@
+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.position).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.position).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(:position)
+        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',
+          type: 'checkbox',
+          model_id: 'abc123',
+          model_type: 'board',
+          position: 123,
+          filed_group: nil
+        }
+
+        result = JSON.generate(test_payload)
+
+        expected_payload = {
+          'name' => 'Test Custom Field',
+          'pos' => 123,
+          'idModel' => 'abc123',
+          'modelType' => 'board',
+          'type' => 'checkbox'
+        }
+
+        expect(client)
+          .to receive(:post)
+          .with('/customFields', expected_payload)
+          .and_return result
+
+        custom_field = CustomField.create(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)
+          .and_return(JSON.generate(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.position).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.position).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" 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.position).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