ruby-trello 2.2.0 → 3.1.0

data/spec/unit/trello/schema/attribute/default_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Schema::Attribute::Default' do
+
+  let(:attribute) { Trello::Schema::Attribute::Default.new(name: name, options: options, serializer: serializer) }
+
+  describe '#build_attributes' do
+    let(:name) { :date_create_utc }
+    let(:options) { { remote_key: 'dateCreateUTC' } }
+    let(:serializer) { double('serializer') }
+    let(:default) { nil }
+
+    before do
+      allow(serializer)
+        .to receive(:deserialize)
+        .with(raw_value, default)
+        .and_return(deserialize_result)
+    end
+
+    let(:build_attributes) { attribute.build_attributes(params, attributes) }
+    let(:attributes) { { name: 'John' } }
+
+    context 'when target key in params is string' do
+      let(:raw_value) { '2020-02-20 00:00:00' }
+      let(:deserialize_result) { Time.new(2020, 2, 20) }
+      let(:params) { { 'date_create_utc' => raw_value } }
+
+      it 'get and deserialize that value and set to attributes' do
+        expect(build_attributes).to match_hash_with_indifferent_access(
+          { name: 'John', date_create_utc: Time.new(2020, 2, 20) }
+        )
+      end
+    end
+
+    context 'when target key in params is symbol' do
+      let(:raw_value) { '2020-02-20 00:00:00' }
+      let(:deserialize_result) { Time.new(2020, 2, 20) }
+      let(:params) { { date_create_utc: raw_value } }
+
+      it 'get and deserialize that value and set to attributes' do
+        expect(build_attributes).to match_hash_with_indifferent_access(
+          { name: 'John', date_create_utc: Time.new(2020, 2, 20) }
+        )
+      end
+    end
+
+    context 'when value under remote_key is nil' do
+      let(:raw_value) { nil }
+      let(:deserialize_result) { nil }
+      let(:params) { { 'dateCreateUTC': raw_value } }
+
+      it 'get and deserialize that value and set to attributes' do
+        expect(build_attributes).to match_hash_with_indifferent_access(
+          { name: 'John', date_create_utc: nil }
+        )
+      end
+    end
+
+    context 'when value under name key is nil' do
+      let(:raw_value) { nil }
+      let(:deserialize_result) { nil }
+      let(:params) { { date_create_utc: raw_value } }
+
+      it 'get and deserialize that value and set to attributes' do
+        expect(build_attributes).to match_hash_with_indifferent_access(
+          { name: 'John', date_create_utc: nil }
+        )
+      end
+    end
+
+    context 'when value under remote_key is false' do
+      let(:raw_value) { false }
+      let(:deserialize_result) { false }
+      let(:params) { { 'dateCreateUTC': raw_value } }
+
+      it 'get and deserialize that value and set to attributes' do
+        expect(build_attributes).to match_hash_with_indifferent_access(
+          { name: 'John', date_create_utc: false }
+        )
+      end
+    end
+  end
+
+
+  describe '#build_pending_update_attributes' do
+    let(:name) { :date_create_utc }
+    let(:options) { { remote_key: 'dateCreateUTC' } }
+    let(:serializer) { double('serializer') }
+    let(:default) { nil }
+
+    before do
+      allow(serializer)
+        .to receive(:deserialize)
+        .with(raw_value, default)
+        .and_return(deserialize_result)
+    end
+
+    let(:build_pending_update_attributes) { attribute.build_pending_update_attributes(params, attributes) }
+    let(:attributes) { { name: 'John' } }
+
+    context 'when remote_key and target key is missing' do
+      let(:raw_value) { false }
+      let(:deserialize_result) { false }
+      let(:params) { {} }
+
+      it "won't set any value to pending update attributes" do
+        expect(build_pending_update_attributes).to match_hash_with_indifferent_access({ name: 'John' })
+      end
+    end
+
+    context 'when remote_key exists' do
+      let(:raw_value) { false }
+      let(:deserialize_result) { false }
+      let(:params) { { 'dateCreateUTC': raw_value } }
+
+      it 'will set the value to pending update attributes' do
+        expect(build_pending_update_attributes).to match_hash_with_indifferent_access(
+          { name: 'John', date_create_utc: raw_value }
+        )
+      end
+    end
+
+    context 'when target key exists' do
+      let(:raw_value) { false }
+      let(:deserialize_result) { false }
+      let(:params) { { date_create_utc: raw_value } }
+
+      it 'will set the value to pending update attributes' do
+        expect(build_pending_update_attributes).to match_hash_with_indifferent_access(
+          { name: 'John', date_create_utc: raw_value }
+        )
+      end
+    end
+  end
+
+
+  describe '#build_payload_for_create' do
+    let(:name) { :date_create_utc }
+    let(:serializer) { double('serializer') }
+    let(:default) { nil }
+
+    before do
+      allow(serializer)
+        .to receive(:serialize)
+        .with(Time.new(2020, 2, 20))
+        .and_return('2020-02-20 00:00:00')
+    end
+
+    let(:build_attributes) { attribute.build_payload_for_create(attributes, payload) }
+    let(:payload) { { 'name' => 'John' } }
+
+
+    context 'when attribute is for action create' do
+      let(:options) { {} }
+
+      context 'when attribute value is nil' do
+        let(:attributes) { { date_create_utc: nil } }
+
+        it "won't put it in payload" do
+          expect(build_attributes).to eq({ 'name' => 'John' })
+        end
+      end
+
+      context 'when attributes does not contain the attribute key' do
+        let(:attributes) { {} }
+
+        it "won't put it in payload" do
+          expect(build_attributes).to eq({ 'name' => 'John' })
+        end
+      end
+
+      context 'when attribute value is normal' do
+        let(:attributes) { { date_create_utc: Time.new(2020, 2, 20) } }
+
+        it 'get and serialize that value and set to payload with stringify name' do
+          expect(build_attributes).to eq({ 'name' => 'John', 'date_create_utc' => '2020-02-20 00:00:00' })
+        end
+      end
+    end
+
+    context 'when attribute is not for action create' do
+      let(:options) { { update_only: true } }
+      let(:attributes) { { date_create_utc: Time.new(2020, 2, 20) } }
+
+      it "won't put it in payload" do
+        expect(build_attributes).to eq({ 'name' => 'John' })
+      end
+    end
+  end
+
+  describe '#build_payload_for_update' do
+    let(:name) { :date_create_utc }
+    let(:serializer) { double('serializer') }
+    let(:default) { nil }
+
+    before do
+      allow(serializer)
+        .to receive(:serialize)
+        .with(Time.new(2020, 2, 20))
+        .and_return('2020-02-20 00:00:00')
+    end
+
+    let(:build_attributes) { attribute.build_payload_for_update(attributes, payload) }
+    let(:payload) { { 'name' => 'John' } }
+
+    context 'when attribute is for action create' do
+      let(:options) { {} }
+
+      context 'when attributes does not contain the attribute key' do
+        let(:attributes) { {} }
+
+        it "won't put it in payload" do
+          expect(build_attributes).to eq({ 'name' => 'John' })
+        end
+      end
+
+      context 'when attribute value is normal' do
+        let(:attributes) { { date_create_utc: Time.new(2020, 2, 20) } }
+
+        it 'get and serialize that value and set to payload with stringify name' do
+          expect(build_attributes).to eq({ 'name' => 'John', 'date_create_utc' => '2020-02-20 00:00:00' })
+        end
+      end
+    end
+
+    context 'when attribute is not for action create' do
+      let(:options) { { create_only: true } }
+      let(:attributes) { { date_create_utc: Time.new(2020, 2, 20) } }
+
+      it "won't put it in payload" do
+        expect(build_attributes).to eq({ 'name' => 'John' })
+      end
+    end
+  end
+
+end

data/spec/unit/trello/schema/attribute_builder_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe Trello::Schema::AttributeBuilder do
+
+  describe '.build' do
+    context 'when does not pass class_name and serializer' do
+      let(:build_attribute) { Trello::Schema::AttributeBuilder.build(:name, { readonly: true }) }
+      let(:attribute) { double('attribute') }
+
+      it 'use Schema::Attribute::Default to initialize with Schema::Serializer::Default' do
+        expect(Schema::Attribute::Default)
+          .to receive(:new)
+          .with(name: :name, options: { readonly: true }, serializer: Schema::Serializer::Default)
+          .and_return(attribute)
+
+        expect(build_attribute).to eq(attribute)
+      end
+    end
+
+    context 'when does pass class_name and serializer' do
+      let(:build_attribute) { Trello::Schema::AttributeBuilder.build(:name, { readonly: true, class_name: 'CustomAttribute', serializer: 'CustomSerializer' }) }
+      let(:attribute) { double('attribute') }
+
+      around do |example|
+        module Trello
+          class Schema
+            module Attribute
+              class CustomAttribute
+              end
+            end
+            module Serializer
+              class CustomSerializer
+              end
+            end
+          end
+        end
+
+        example.run
+
+        Trello::Schema::Attribute.send(:remove_const, 'CustomAttribute')
+        Trello::Schema::Serializer.send(:remove_const, 'CustomSerializer')
+      end
+
+      it 'use passin class to initializer with passin serializer' do
+        expect(Schema::Attribute::CustomAttribute)
+          .to receive(:new)
+          .with(name: :name, options: { readonly: true }, serializer: Schema::Serializer::CustomSerializer)
+          .and_return(attribute)
+
+        expect(build_attribute).to eq(attribute)
+      end
+    end
+  end
+
+end

data/spec/unit/trello/schema/attribute_registration_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe Trello::Schema::AttributeRegistration do
+
+  around do |example|
+    module Trello
+      class FakeBoard < BasicData
+        def initialize; end
+      end
+    end
+
+    example.run
+
+    Trello.send(:remove_const, 'FakeBoard')
+  end
+
+  let(:attribute) { Trello::Schema::Attribute::Base.new(
+    name: name,
+    options: options,
+    serializer: serializer
+  ) }
+
+  context 'when it is a writable attribute' do
+    let(:name) { :name }
+    let(:serializer) { double('serializer') }
+    let(:options) { nil }
+
+    it 'create getter method for the attribute' do
+      Trello::Schema::AttributeRegistration.register(Trello::FakeBoard, attribute)
+
+      expect(Trello::FakeBoard.new).to respond_to(:name)
+    end
+
+    it 'create setter method for the attribute' do
+      Trello::Schema::AttributeRegistration.register(Trello::FakeBoard, attribute)
+
+      expect(Trello::FakeBoard.new).to respond_to(:name=)
+    end
+  end
+
+  context 'when it is a readonly attribute' do
+    let(:name) { :name }
+    let(:serializer) { double('serializer') }
+    let(:options) { { readonly: true } }
+
+    it 'create getter method for the attribute' do
+      Trello::Schema::AttributeRegistration.register(Trello::FakeBoard, attribute)
+
+      expect(Trello::FakeBoard.new).to respond_to(:name)
+    end
+
+    it "won't create setter method for the attribute" do
+      Trello::Schema::AttributeRegistration.register(Trello::FakeBoard, attribute)
+
+      expect(Trello::FakeBoard.new).not_to respond_to(:name=)
+    end
+  end
+
+end

data/spec/unit/trello/schema/serializer/default_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Schema::Serializer::Default' do
+
+  describe '.serialize' do
+    it 'directly return the value' do
+      expect(Trello::Schema::Serializer::Default.serialize('John')).to eq('John')
+    end
+  end
+
+  describe '.deserialize' do
+    it 'directly return the value' do
+      expect(Trello::Schema::Serializer::Default.deserialize('John', nil)).to eq('John')
+      expect(Trello::Schema::Serializer::Default.deserialize(nil, 'John')).to eq('John')
+      expect(Trello::Schema::Serializer::Default.deserialize(false, 'John')).to eq(false)
+    end
+  end
+
+end

data/spec/unit/trello/schema/serializer/time_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe 'Trello::Schema::Serializer::Time' do
+
+  describe '.serialize' do
+    it 'parse the time to string with format like: 2020-01-01T00:00:00.000Z' do
+      expect(Trello::Schema::Serializer::Time.serialize(Time.new(2020, 4, 13, 23, 12, 59))).to eq('2020-04-13T23:12:59.000Z')
+    end
+  end
+
+  describe '.deserialize' do
+    context 'when pass in time string' do
+      it 'parset it to a time' do
+        expect(Trello::Schema::Serializer::Time.deserialize('2020-04-13T23:12:59.000Z', nil)).to eq(Time.new(2020, 4, 13, 23, 12, 59))
+      end
+    end
+
+    context 'when pass in a time' do
+      it 'return the time' do
+        expect(Trello::Schema::Serializer::Time.deserialize(Time.new(2020, 4, 13, 23, 12, 59), nil)).to eq(Time.new(2020, 4, 13, 23, 12, 59))
+      end
+    end
+
+    context 'when pass in a object respond to :to_time. i.e. Date, DateTime ...' do
+      it 'convert it to time' do
+        expect(Trello::Schema::Serializer::Time.deserialize(Date.new(2020, 4, 13), nil)).to eq(Time.new(2020, 4, 13))
+      end
+    end
+
+    context 'when pass in a invalid value' do
+      it 'return the default value' do
+        expect(Trello::Schema::Serializer::Time.deserialize('abc', nil)).to eq(nil)
+        expect(Trello::Schema::Serializer::Time.deserialize('abc', Time.new(2020, 1, 1))).to eq(Time.new(2020, 1, 1))
+        expect(Trello::Schema::Serializer::Time.deserialize(nil, Time.new(2020, 1, 1))).to eq(Time.new(2020, 1, 1))
+      end
+    end
+  end
+
+end

data/spec/unit/trello/schema_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe Trello::Schema do
+
+  describe '#attribute' do
+    let(:schema) { Trello::Schema.new }
+
+    it 'record attribute to attrs' do
+      attribute_1 = double('Trello::Schema::Attribute::Default')
+      attribute_2 = double('Trello::Schema::Attribute::Default')
+
+      expect(Trello::Schema::AttributeBuilder).to receive(:build).with(:id, readonly: true).and_return(attribute_1)
+      expect(Trello::Schema::AttributeBuilder).to receive(:build).with(:name, {}).and_return(attribute_2)
+
+      schema.attribute(:id, readonly: true)
+      schema.attribute(:name)
+
+      expect(schema.attrs).to be_a(Hash)
+      expect(schema.attrs.count).to eq(2)
+      expect(schema.attrs[:id]).to eq(attribute_1)
+      expect(schema.attrs[:name]).to eq(attribute_2)
+    end
+  end
+
+end

data/spec/webhook_spec.rb

@@ -20,7 +20,7 @@ module Trello
       it "delegates to Trello.client#find" do
         expect(client)
           .to receive(:find)
-          .with(:webhook, '1234', {})
+          .with('webhook', '1234', {})
 
         Webhook.find('1234')
       end
@@ -43,7 +43,7 @@ module Trello
         webhook = Webhook.new(webhook_details)
         expect(webhook.id).to           eq webhook_details['id']
         expect(webhook.description).to  eq webhook_details['description']
-        expect(webhook.id_model).to     eq webhook_details['idModel']
+        expect(webhook.model_id).to     eq webhook_details['idModel']
         expect(webhook.callback_url).to eq webhook_details['callbackURL']
         expect(webhook.active).to       eq webhook_details['active']
       end
@@ -52,7 +52,7 @@ module Trello
         webhook_details = webhooks_details[1]
         webhook = Webhook.new(webhook_details)
         expect(webhook.description).to  eq webhook_details[:description]
-        expect(webhook.id_model).to     eq webhook_details[:id_model]
+        expect(webhook.model_id).to     eq webhook_details[:model_id]
         expect(webhook.callback_url).to eq webhook_details[:callback_url]
       end
 
@@ -62,14 +62,21 @@ module Trello
         webhook = webhooks_details.first
         result = JSON.generate(webhook)
 
-        expected_payload = {description: webhook[:description], idModel: webhook[:idModel], callbackURL: webhook[:callbackURL]}
+        expected_payload = {
+          'description' => webhook['description'],
+          'idModel' => webhook['idModel'],
+          'callbackURL' => webhook['callbackURL'],
+          'active' => webhook['active']
+        }
 
         expect(client)
           .to receive(:post)
           .with("/webhooks", expected_payload)
           .and_return result
 
-        webhook = Webhook.create(webhooks_details.first)
+        params = webhooks_details.first
+        params.delete('id')
+        webhook = Webhook.create(params)
 
         expect(webhook.class).to be Webhook
       end
@@ -79,12 +86,21 @@ module Trello
       it "updating description does a put on the correct resource with the correct value" do
         expected_new_description = "xxx"
 
-        expected_payload = {description: expected_new_description, idModel: webhook.id_model, callbackURL: webhook.callback_url, active: webhook.active}
+        expected_payload = { 'description' => expected_new_description}
 
         expect(client)
           .to receive(:put)
           .once
           .with("/webhooks/#{webhook.id}", expected_payload)
+          .and_return({
+            'id' => webhook.id,
+            'idModel' => webhook.model_id,
+            'description' => 'xxx',
+            'callbackURL' => webhook.callback_url,
+            'active' => webhook.active,
+            'consecutiveFailures' => webhook.consecutive_failures,
+            'firstConsecutiveFailDate' => webhook.first_consecutive_fail_date
+          }.to_json)
 
         webhook.description = expected_new_description
         webhook.save
@@ -112,7 +128,7 @@ module Trello
         expected = {
           'id' => 'id',
           'description' => 'description',
-          'idModel' => 'id_model',
+          'idModel' => 'model_id',
           'callbackURL' => 'callback_url',
           'active' => 'active'
         }