ruby-trello 2.3.1 → 3.0.0

data/spec/cassettes/webhook_find_with_id.yml

@@ -0,0 +1,100 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://api.trello.com/1/webhooks/5fa8a1e0009b2a6a669e6efa?key=DEVELOPER_PUBLIC_KEY&token=MEMBER_TOKEN
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      Accept:
+      - "*/*"
+      User-Agent:
+      - rest-client/2.1.0 (linux-gnu x86_64) ruby/2.6.6p146
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Host:
+      - api.trello.com
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      X-Dns-Prefetch-Control:
+      - 'off'
+      X-Frame-Options:
+      - DENY
+      X-Download-Options:
+      - noopen
+      X-Permitted-Cross-Domain-Policies:
+      - none
+      Referrer-Policy:
+      - strict-origin-when-cross-origin
+      Surrogate-Control:
+      - no-store
+      Cache-Control:
+      - max-age=0, must-revalidate, no-cache, no-store
+      Pragma:
+      - no-cache
+      Expires:
+      - Thu, 01 Jan 1970 00:00:00
+      X-Trello-Version:
+      - 1.2278.0
+      X-Trello-Environment:
+      - Production
+      Set-Cookie:
+      - dsc=set_cookie_dsc; Path=/; Expires=Thu, 12 Nov 2020 02:02:32 GMT; Secure
+      Access-Control-Allow-Origin:
+      - "*"
+      Access-Control-Allow-Methods:
+      - GET, PUT, POST, DELETE
+      Access-Control-Allow-Headers:
+      - Authorization, Accept, Content-Type
+      Access-Control-Expose-Headers:
+      - x-rate-limit-api-key-interval-ms, x-rate-limit-api-key-max, x-rate-limit-api-key-remaining,
+        x-rate-limit-api-token-interval-ms, x-rate-limit-api-token-max, x-rate-limit-api-token-remaining
+      X-Rate-Limit-Api-Key-Interval-Ms:
+      - '10000'
+      X-Rate-Limit-Api-Key-Max:
+      - '300'
+      X-Rate-Limit-Api-Key-Remaining:
+      - '299'
+      X-Rate-Limit-Api-Token-Interval-Ms:
+      - '10000'
+      X-Rate-Limit-Api-Token-Max:
+      - '100'
+      X-Rate-Limit-Api-Token-Remaining:
+      - '99'
+      X-Rate-Limit-Member-Interval-Ms:
+      - '10000'
+      X-Rate-Limit-Member-Max:
+      - '200'
+      X-Rate-Limit-Member-Remaining:
+      - '199'
+      X-Server-Time:
+      - '1604887352812'
+      Content-Type:
+      - application/json; charset=utf-8
+      Date:
+      - Mon, 09 Nov 2020 02:02:32 GMT
+      X-Envoy-Upstream-Service-Time:
+      - '80'
+      Expect-Ct:
+      - report-uri="https://web-security-reports.services.atlassian.com/expect-ct-report/trello-edge",
+        max-age=86400
+      Strict-Transport-Security:
+      - max-age=63072000; preload
+      X-Content-Type-Options:
+      - nosniff
+      X-Xss-Protection:
+      - 1; mode=block
+      Server:
+      - globaledge-envoy
+      Transfer-Encoding:
+      - chunked
+    body:
+      encoding: ASCII-8BIT
+      string: '{"id":"5fa8a1e0009b2a6a669e6efa","description":"test","idModel":"5fa759f1564c6e5bb803c61e","callbackURL":"https://example.com/webhook/trello_callbacks","active":true,"consecutiveFailures":0,"firstConsecutiveFailDate":null}'
+    http_version: null
+  recorded_at: Mon, 09 Nov 2020 02:02:33 GMT
+recorded_with: VCR 5.1.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

@@ -140,7 +140,7 @@ module Trello
           it 'custom field item does set the changed fields' do
             text_item.update_fields(fields)
 
-            expect(text_item.value).to eq( { number: '42' } )
+            expect(text_item.value).to eq( { 'number' => '42' } )
           end
 
           it 'card has been mark as changed' do
@@ -159,7 +159,7 @@ module Trello
             expect(text_item.value).to eq(text_field_details['value'])
           end
 
-          it "custom field item hasn't been mark as changed", pending: true do
+          it "custom field item hasn't been mark as changed" do
             text_item.update_fields(fields)
 
             expect(text_item.changed?).to be_falsy

data/spec/custom_field_option_spec.rb

@@ -27,8 +27,8 @@ module Trello
         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']
+      it 'gets its position' do
+        expect(option.position).to eq custom_field_option_details['pos']
       end
     end
 

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
 
@@ -196,7 +208,7 @@ module Trello
           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.position).to eq custom_field_detail['pos']
           expect(custom_field.type).to eq custom_field_detail['type']
         end
       end
@@ -227,7 +239,7 @@ module Trello
             expect(custom_field.name).to eq(custom_field_detail['name'])
           end
 
-          it "custom field hasn't been mark as changed", pending: true do
+          it "custom field hasn't been mark as changed" do
             custom_field.update_fields(fields)
 
             expect(custom_field.changed?).to be_falsy
@@ -244,7 +256,7 @@ module Trello
             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.position).to eq custom_field_detail['pos']
             expect(custom_field.type).to eq custom_field_detail['type']
           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

@@ -10,6 +10,10 @@ module Trello
         class FakeCard < BasicData
         end
         class FakeBoard < BasicData
+          schema do
+            attribute :id
+          end
+
           def update_fields(fields)
             attributes[:id] = fields[:id]
           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