ruby-trello 2.2.0 → 3.1.0

data/spec/custom_field_spec.rb

@@ -30,7 +30,7 @@ module Trello
         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.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
@@ -41,7 +41,7 @@ module Trello
         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.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
@@ -54,25 +54,36 @@ module Trello
         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(: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'
+          name: 'Test Custom Field',
+          type: 'checkbox',
+          model_id: 'abc123',
+          model_type: 'board',
+          position: 123,
+          filed_group: nil
         }
 
-        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}
+        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(custom_fields_details[1].merge(test_payload))
+        custom_field = CustomField.create(test_payload)
         expect(custom_field).to be_a CustomField
       end
     end
@@ -102,11 +113,12 @@ module Trello
       it 'correctly updates custom field name' do
         expected_new_name = 'Test Name'
 
-        payload = { name: expected_new_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
@@ -135,7 +147,7 @@ module Trello
       end
 
       it 'gets its position' do
-        expect(custom_field.pos).to_not be_nil
+        expect(custom_field.position).to_not be_nil
       end
     end
 
@@ -181,5 +193,81 @@ module Trello
         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

data/spec/integration/action/find_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Action#find' do
+  include IntegrationHelpers
+
+  before { setup_trello }
+
+  it 'find with id and get all fields' do
+    VCR.use_cassette('action_find_with_id_and_get_all_fields') do
+      action = Trello::Action.find('5f60f07958388d26dc063c30')
+      expect(action).to be_a(Trello::Action)
+
+      expect(action.id).to eq('5f60f07958388d26dc063c30')
+      expect(action.creator_id).not_to be_nil
+      expect(action.data).not_to be_nil
+      expect(action.type).not_to be_nil
+      expect(action.date).not_to be_nil
+      expect(action.limits).not_to be_nil
+      expect(action.display).not_to be_nil
+    end
+  end
+
+end

data/spec/integration/basic_data/many_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+module Trello
+  describe BasicData do
+    describe '.many' do
+      let(:client_double) { double('client') }
+      let(:cards) { double('cards') }
+
+      around do |example|
+        class FakeCard < BasicData
+        end
+        class FakeBoard < BasicData
+          schema do
+            attribute :id
+          end
+
+          def update_fields(fields)
+            attributes[:id] = fields[:id]
+          end
+        end
+
+        example.run
+
+        Trello.send(:remove_const, 'FakeBoard')
+        Trello.send(:remove_const, 'FakeCard')
+      end
+
+      def mock_client_and_association(klass:, resource:, id:, path:, params:)
+        resources = double('resources')
+        allow(FakeBoard).to receive(:client).and_return(client_double)
+        allow_any_instance_of(FakeBoard).to receive(:client).and_return(client_double)
+        allow(client_double).to receive(:find_many).with(klass, "/#{resource}/#{id}/#{path}", params).and_return(resources)
+        allow(MultiAssociation).to receive(:new).with(FakeBoard, resources).and_return(double('association', proxy: cards))
+      end
+
+      context 'when only pass in the name' do
+        before do
+          FakeBoard.class_eval { many :fake_cards }
+
+          mock_client_and_association(
+            klass: Trello::FakeCard,
+            resource: 'fakeboards',
+            id: 1,
+            path: 'fake_cards',
+            params: {}
+          )
+        end
+
+        it 'can get cards from client' do
+          expect(FakeBoard.new(id: 1).fake_cards).to eq(cards)
+        end
+      end
+
+      context 'when pass in name with in:' do
+        before do
+          FakeBoard.class_eval { many :fake_cards, in: 'boards' }
+
+          mock_client_and_association(
+            klass: Trello::FakeCard,
+            resource: 'boards',
+            id: 1,
+            path: 'fake_cards',
+            params: {}
+          )
+        end
+
+        it 'can get cards from client' do
+          expect(FakeBoard.new(id: 1).fake_cards).to eq(cards)
+        end
+      end
+
+      context 'when pass in name with via:' do
+        before do
+          FakeBoard.class_eval { many :fake_cards, via: Card }
+
+          mock_client_and_association(
+            klass: Trello::Card,
+            resource: 'fakeboards',
+            id: 1,
+            path: 'fake_cards',
+            params: {}
+          )
+        end
+
+        it 'can get cards from client' do
+          expect(FakeBoard.new(id: 1).fake_cards).to eq(cards)
+        end
+      end
+
+      context 'when pass in name with path:' do
+        before do
+          FakeBoard.class_eval { many :fake_cards, path: 'test' }
+
+          mock_client_and_association(
+            klass: Trello::FakeCard,
+            resource: 'fakeboards',
+            id: 1,
+            path: 'test',
+            params: {}
+          )
+        end
+
+        it 'can get cards from client' do
+          expect(FakeBoard.new(id: 1).fake_cards).to eq(cards)
+        end
+      end
+
+      context 'when pass in name with other params' do
+        before do
+          FakeBoard.class_eval { many :fake_cards, test: 'test' }
+
+          mock_client_and_association(
+            klass: Trello::FakeCard,
+            resource: 'fakeboards',
+            id: 1,
+            path: 'fake_cards',
+            params: {test: 'test'}
+          )
+        end
+
+        it 'can get cards from client' do
+          expect(FakeBoard.new(id: 1).fake_cards).to eq(cards)
+        end
+      end
+    end
+  end
+end

data/spec/integration/basic_data/one_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::BasicData.one' do
+
+  let(:client_double) { double('client') }
+  let(:organization) { double('organization') }
+
+  around do |example|
+    module Trello
+      class FakeOrganization < BasicData
+      end
+      class FakeBoard < BasicData
+        def update_fields(fields)
+          attributes[:id] = fields[:id]
+        end
+      end
+    end
+
+    example.run
+
+    Trello.send(:remove_const, 'FakeBoard')
+    Trello.send(:remove_const, 'FakeOrganization')
+  end
+
+  def mock_client_and_association(klass: Trello::FakeOrganization, id: 1, path: nil, id_field: :id)
+    association_restful_name = path
+    allow(Trello::FakeBoard).to receive(:client).and_return(client_double)
+    allow_any_instance_of(Trello::FakeBoard).to receive(:client).and_return(client_double)
+    allow_any_instance_of(Trello::FakeBoard).to receive(id_field).and_return(id)
+    if association_restful_name
+      allow(client_double).to receive(:find).with(association_restful_name, id).and_return(organization)
+    else
+      allow(klass).to receive(:find).with(id).and_return(organization)
+    end
+  end
+
+  context 'when only pass in the name' do
+    before do
+      Trello::FakeBoard.class_eval { one :fake_organization }
+
+      mock_client_and_association
+    end
+
+    it 'can get the association from client' do
+      expect(Trello::FakeBoard.new(id: 1).fake_organization).to eq(organization)
+    end
+  end
+
+  context 'when pass in name with path' do
+    before do
+      Trello::FakeBoard.class_eval { one :fake_organization, path: 'organizations' }
+
+      mock_client_and_association(path: 'organizations')
+    end
+
+    it 'can get the association from client' do
+      expect(Trello::FakeBoard.new(id: 1).fake_organization).to eq(organization)
+    end
+  end
+
+  context 'when pass in name with via' do
+    before do
+      Trello::FakeBoard.class_eval { one :fake_organization, via: Trello::FakeOrganization }
+
+      mock_client_and_association
+    end
+
+    it 'can get the association from client' do
+      expect(Trello::FakeBoard.new(id: 1).fake_organization).to eq(organization)
+    end
+  end
+
+  context 'when pass in name with using' do
+    before do
+      Trello::FakeBoard.class_eval { one :fake_organization, using: :test_id }
+
+      mock_client_and_association(id_field: :test_id)
+    end
+
+    it 'can get the association from client' do
+      expect(Trello::FakeBoard.new(id: 1).fake_organization).to eq(organization)
+    end
+  end
+end

data/spec/integration/basic_data/schema_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+RSpec.describe 'BasicData#schema' do
+
+  around do |example|
+    module Trello
+      class FakeBoard < BasicData
+        schema do
+          attribute :id, readonly: true, primary_key: true
+          attribute :name
+          attribute :description, remote_key: :desc
+          attribute :last_activity_date, readonly: true, remote_key: :dateLastActivity, serializer: 'Time'
+          attribute :keep_cards_from_source, create_only: true, remote_key: :keepFromSource
+          attribute :subscribed, update_only: true, default: true
+          attribute :visibility_level, remote_key: 'permissionLevel', class_name: 'BoardPref'
+        end
+      end
+    end
+
+    example.run
+
+    Trello.send(:remove_const, 'FakeBoard')
+  end
+
+  let(:attributes) { FakeBoard.schema.attrs }
+  let(:stringify_init_params) {{
+    'id' => 99,
+    'name' => 'Test Board',
+    'desc' => 'board desc ...',
+    'dateLastActivity' => '2020-02-20 00:00:00',
+    'keepFromSource' => true,
+    'subscribed' => true
+  }}
+
+  let(:symbolize_init_params) {{
+    id: 99,
+    name: 'Test Board',
+    description: 'board desc ...',
+    last_activity_date: Time.new(2020, 2, 20),
+    keep_cards_from_source: true,
+    subscribed: true
+  }}
+
+  it 'will create 6 attributes' do
+    expect(attributes.count).to eq(7)
+  end
+
+  it 'can success parse readonly primary key :id' do
+    attribute = attributes[:id]
+    expect(attribute.name).to eq(:id)
+    expect(attribute.primary_key?).to eq(true)
+    expect(attribute.readonly?).to eq(true)
+    expect(attribute.remote_key).to eq('id')
+    expect(attribute.for_action?(:create)).to eq(false)
+    expect(attribute.for_action?(:update)).to eq(true)
+    expect(attribute.default).to eq(nil)
+    expect(attribute.build_attributes({id: 1, name: 'Test'}, {})).to match_hash_with_indifferent_access({id: 1})
+    expect(attribute.build_attributes({'id' => 1, 'name' => 'Text'}, {})).to match_hash_with_indifferent_access({id: 1})
+    expect(attribute.build_payload_for_create({ id: 1, name: 'Text' }, {})).to eq({})
+    expect(attribute.build_payload_for_update({ id: 1, name: 'Text' }, {})).to eq({ 'id' => 1 })
+  end
+
+  it 'can succes parse attribute :name with default setting' do
+    attribute = attributes[:name]
+    expect(attribute.name).to eq(:name)
+    expect(attribute.primary_key?).to eq(false)
+    expect(attribute.readonly?).to eq(false)
+    expect(attribute.remote_key).to eq('name')
+    expect(attribute.for_action?(:create)).to eq(true)
+    expect(attribute.for_action?(:update)).to eq(true)
+    expect(attribute.default).to eq(nil)
+    expect(attribute.build_attributes({id: 1, name: 'Test'}, {})).to match_hash_with_indifferent_access({name: 'Test'})
+    expect(attribute.build_attributes({'id' => 1, 'name' => 'Text'}, {})).to match_hash_with_indifferent_access({name: 'Text'})
+    expect(attribute.build_payload_for_create({ id: 1, name: 'Text' }, {})).to eq({ 'name' => 'Text' })
+    expect(attribute.build_payload_for_update({ id: 1, name: 'Text' }, {})).to eq({ 'name' => 'Text' })
+  end
+
+  it 'can succes parse attribute :description with diferent remote_key' do
+    attribute = attributes[:description]
+    expect(attribute.name).to eq(:description)
+    expect(attribute.primary_key?).to eq(false)
+    expect(attribute.readonly?).to eq(false)
+    expect(attribute.remote_key).to eq('desc')
+    expect(attribute.for_action?(:create)).to eq(true)
+    expect(attribute.for_action?(:update)).to eq(true)
+    expect(attribute.default).to eq(nil)
+    expect(attribute.build_attributes({id: 1, description: '...'}, {})).to match_hash_with_indifferent_access({description: '...'})
+    expect(attribute.build_attributes({'id' => 1, 'desc' => '...'}, {})).to match_hash_with_indifferent_access({description: '...'})
+    expect(attribute.build_payload_for_create({ id: 1, description: '...' }, {})).to eq({ 'desc' => '...' })
+    expect(attribute.build_payload_for_update({ id: 1, description: '...' }, {})).to eq({ 'desc' => '...' })
+  end
+
+  it 'can success parse attribute :keep_cards_from_source with create_only and remote_key' do
+    attribute = attributes[:keep_cards_from_source]
+    expect(attribute.name).to eq(:keep_cards_from_source)
+    expect(attribute.primary_key?).to eq(false)
+    expect(attribute.readonly?).to eq(false)
+    expect(attribute.remote_key).to eq('keepFromSource')
+    expect(attribute.for_action?(:create)).to eq(true)
+    expect(attribute.for_action?(:update)).to eq(false)
+    expect(attribute.default).to eq(nil)
+    expect(attribute.build_attributes({id: 1, keep_cards_from_source: true}, {})).to match_hash_with_indifferent_access({keep_cards_from_source: true})
+    expect(attribute.build_attributes({'id' => 1, 'keepFromSource' => true}, {})).to match_hash_with_indifferent_access({keep_cards_from_source: true})
+    expect(attribute.build_payload_for_create({ id: 1, keep_cards_from_source: true }, {})).to eq({ 'keepFromSource' => true })
+    expect(attribute.build_payload_for_update({ id: 1, keep_cards_from_source: true }, {})).to eq({})
+  end
+
+  it 'can succes parse attribute :subscribed with update only' do
+    attribute = attributes[:subscribed]
+    expect(attribute.name).to eq(:subscribed)
+    expect(attribute.primary_key?).to eq(false)
+    expect(attribute.readonly?).to eq(false)
+    expect(attribute.remote_key).to eq('subscribed')
+    expect(attribute.for_action?(:create)).to eq(false)
+    expect(attribute.for_action?(:update)).to eq(true)
+    expect(attribute.default).to eq(true)
+    expect(attribute.build_attributes({id: 1, subscribed: true}, {})).to match_hash_with_indifferent_access({subscribed: true})
+    expect(attribute.build_attributes({id: 1}, {})).to match_hash_with_indifferent_access({subscribed: true})
+    expect(attribute.build_attributes({'id' => 1, 'subscribed' => true}, {})).to match_hash_with_indifferent_access({subscribed: true})
+    expect(attribute.build_payload_for_create({ id: 1, subscribed: true }, {})).to eq({})
+    expect(attribute.build_payload_for_update({ id: 1, subscribed: true }, {})).to eq({ 'subscribed' => true })
+  end
+
+  it 'can success parse attribute :last_activity_date with specific serializer' do
+    attribute = attributes[:last_activity_date]
+    expect(attribute.name).to eq(:last_activity_date)
+    expect(attribute.primary_key?).to eq(false)
+    expect(attribute.readonly?).to eq(true)
+    expect(attribute.remote_key).to eq('dateLastActivity')
+    expect(attribute.for_action?(:create)).to eq(false)
+    expect(attribute.for_action?(:update)).to eq(false)
+    expect(attribute.default).to eq(nil)
+    expect(attribute.build_attributes({id: 1, last_activity_date: Time.new(2020, 1, 1)}, {})).to match_hash_with_indifferent_access({last_activity_date: Time.new(2020, 1, 1)})
+    expect(attribute.build_attributes({id: 1}, {})).to match_hash_with_indifferent_access({last_activity_date: nil})
+    expect(attribute.build_attributes({'id' => 1, 'dateLastActivity' => Time.new(2020, 1, 1)}, {})).to match_hash_with_indifferent_access({last_activity_date: Time.new(2020, 1, 1)})
+    expect(attribute.build_payload_for_create({ id: 1, last_activity_date: Time.new(2020, 1, 1) }, {})).to eq({})
+    expect(attribute.build_payload_for_update({ id: 1, last_activity_date: Time.new(2020, 1, 1) }, {})).to eq({})
+  end
+
+  it 'can success parse attribute :visibility_level with specific class_name' do
+    attribute = attributes[:visibility_level]
+    expect(attribute.name).to eq(:visibility_level)
+    expect(attribute.primary_key?).to eq(false)
+    expect(attribute.readonly?).to eq(false)
+    expect(attribute.remote_key).to eq('permissionLevel')
+    expect(attribute.for_action?(:create)).to eq(true)
+    expect(attribute.for_action?(:update)).to eq(true)
+    expect(attribute.default).to eq(nil)
+    expect(attribute.build_attributes({id: 1, visibility_level: 'org'}, {})).to match_hash_with_indifferent_access({visibility_level: 'org'})
+    expect(attribute.build_attributes({id: 1}, {})).to match_hash_with_indifferent_access({visibility_level: nil})
+    expect(attribute.build_attributes({'id' => 1, 'prefs' => { 'permissionLevel' => 'org' }}, {})).to match_hash_with_indifferent_access({visibility_level: 'org'})
+    expect(attribute.build_payload_for_create({ id: 1, visibility_level: 'org' }, {})).to eq({ 'prefs_permissionLevel' => 'org' })
+    expect(attribute.build_payload_for_update({ id: 1, visibility_level: 'org' }, {})).to eq({ 'prefs/permissionLevel' => 'org' })
+  end
+
+end

data/spec/integration/board/add_member_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Board#add_member' do
+  include IntegrationHelpers
+
+  before { setup_trello }
+
+  it 'can add a member to a board' do
+    VCR.use_cassette('can_add_a_member_to_a_board') do
+      member = Trello::Member.new('id' => 'wokenqingtian')
+      card = Trello::Board.find('5e93ba98614ac22d22f085c4')
+      response = card.add_member(member)
+
+      expect(response.code).to eq(200)
+      body = JSON.parse(response.body)
+      expect(body['id']).to eq('5e93ba98614ac22d22f085c4')
+      expect(body['members'][0]['username']).to eq('wokenqingtian') 
+    end
+  end
+
+end

data/spec/integration/board/all_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Board.all' do
+  include IntegrationHelpers
+
+  before { setup_trello }
+
+  it 'can success return all boards for the current user' do
+    VCR.use_cassette('can_success_return_all_boards_of_current_user') do
+      boards = Trello::Board.all
+      expect(boards.count).to be > 1
+      expect(boards[0].name).to eq('IT 1')
+      expect(boards[1].name).to eq('IT 2')
+      expect(boards[2].name).to eq('IT 3')
+      expect(boards[3].name).to eq('IT 4')
+      expect(boards[4].name).to eq('IT 5')
+    end
+  end
+
+end

data/spec/integration/board/associations/actions_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Board#actions' do
+  include IntegrationHelpers
+
+  before { setup_trello }
+
+  it 'can get actions' do
+    VCR.use_cassette('can_get_actions_of_board') do
+      board = Trello::Board.find('5e93ba98614ac22d22f085c4')
+      actions = board.actions
+
+      expect(actions).to be_a(Array)
+      expect(actions[0]).to be_a(Trello::Action)
+    end
+  end
+
+end

data/spec/integration/board/associations/cards_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Board#cards' do
+  include IntegrationHelpers
+
+  before { setup_trello }
+
+  it 'can get cards' do
+    VCR.use_cassette('can_get_cards_of_board') do
+      board = Trello::Board.find('5e93ba98614ac22d22f085c4')
+      cards = board.cards
+
+      expect(cards).to be_a(Array)
+      expect(cards[0]).to be_a(Trello::Card)
+    end
+  end
+
+end

data/spec/integration/board/associations/checklists_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Board#checklists' do
+  include IntegrationHelpers
+
+  before { setup_trello }
+
+  it 'can get checklists' do
+    VCR.use_cassette('can_get_checklists_of_board') do
+      board = Trello::Board.find('5e93ba98614ac22d22f085c4')
+      checklists = board.checklists
+
+      expect(checklists).to be_a(Array)
+      expect(checklists[0]).to be_a(Trello::Checklist)
+    end
+  end
+
+end

data/spec/integration/board/associations/custom_fields_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Board#custom_fields' do
+  include IntegrationHelpers
+
+  before { setup_trello }
+
+  it 'can get custom fields' do
+    VCR.use_cassette('can_get_custom_fields_of_board') do
+      board = Trello::Board.find('5e93ba98614ac22d22f085c4')
+      custom_fields = board.custom_fields
+
+      expect(custom_fields).to be_a(Array)
+      expect(custom_fields[0]).to be_a(Trello::CustomField)
+    end
+  end
+
+end