ruby-trello 2.3.1 → 3.2.0

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

@@ -0,0 +1,208 @@
+
+require 'spec_helper'
+
+RSpec.describe 'Trello::Schema::Attribute::BoardPref' do
+
+  let(:attribute) { Trello::Schema::Attribute::BoardPref.new(name: name, options: options, serializer: serializer) }
+
+  describe '#build_attributes' do
+    let(:name) { :visibility_level }
+    let(:options) { { remote_key: :permissionLevel } }
+    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 prefs and name key are both missing' do
+      let(:raw_value) { nil }
+      let(:deserialize_result) { nil }
+      let(:params) { {} }
+
+      it 'deserialize and set the attribute to nil' do
+        expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: nil })
+      end
+    end
+
+    context "when params's key prefs exits" do
+      context 'and target key is missing' do
+        let(:raw_value) { nil }
+        let(:deserialize_result) { nil }
+        let(:params) { { 'prefs' => {} } }
+
+        it 'deserialize and set the attribute to nil' do
+          expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: nil })
+        end
+      end
+
+      context 'and target value is nil' do
+        let(:raw_value) { nil }
+        let(:deserialize_result) { nil }
+        let(:params) { { 'prefs' => { 'permissionLevel' => nil } } }
+
+        it 'deserialize and set the attribute to nil' do
+          expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: nil })
+        end
+      end
+
+      context 'and target value is false' do
+        let(:raw_value) { false }
+        let(:deserialize_result) { false }
+        let(:params) { { 'prefs' => { 'permissionLevel' => false } } }
+
+        it 'deserialize and set the attribute to false' do
+          expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: false })
+        end
+      end
+
+      context 'and target value is not nil or false' do
+        let(:raw_value) { 'org' }
+        let(:deserialize_result) { 'org' }
+        let(:params) { { 'prefs' => { 'permissionLevel' => 'org' } } }
+
+        it 'deserialize and set the attribute' do
+          expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: 'org' })
+        end
+      end
+    end
+
+    context "when params's key prefs does not exits" do
+      context 'and target value is nil' do
+        let(:raw_value) { nil }
+        let(:deserialize_result) { nil }
+        let(:params) { { visibility_level: nil } }
+
+        it 'get and deserialize that value and set to attributes with symbolize name' do
+          expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: nil })
+        end
+      end
+
+      context 'and target value is false' do
+        let(:raw_value) { false }
+        let(:deserialize_result) { false }
+        let(:params) { { visibility_level: false } }
+
+        it 'get and deserialize that value and set to attributes with symbolize name' do
+          expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: false })
+        end
+      end
+
+      context 'and target value is not nil or false ' do
+        let(:raw_value) { 'org' }
+        let(:deserialize_result) { 'org' }
+        let(:params) { { visibility_level: 'org' } }
+
+        it 'get and deserialize that value and set to attributes with symbolize name' do
+          expect(build_attributes).to match_hash_with_indifferent_access({ name: 'John', visibility_level: 'org' })
+        end
+      end
+    end
+  end
+
+  describe '#build_payload_for_create' do
+    let(:name) { :visibility_level }
+    let(:options) { { remote_key: :permissionLevel } }
+    let(:serializer) { double('serializer') }
+    let(:default) { nil }
+
+    before do
+      allow(serializer)
+        .to receive(:serialize)
+        .with('org')
+        .and_return('org')
+    end
+
+    let(:build_attributes) { attribute.build_payload_for_create(attributes, payload) }
+    let(:payload) { { 'name' => 'John' } }
+
+
+    context 'when attribute is for action create' do
+
+      context 'when attribute value is nil' do
+        let(:attributes) { { visibility_level: 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) { { visibility_level: 'org' } }
+
+        it 'get and serialize that value and set to payload with stringify name' do
+          expect(build_attributes).to eq({ 'name' => 'John', 'prefs_permissionLevel' => 'org' })
+        end
+      end
+    end
+
+    context 'when attribute is not for action create' do
+      let(:options) { { remote_key: :permissionLevel, update_only: true } }
+      let(:attributes) { { visibility_level: 'org' } }
+
+      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) { :visibility_level }
+    let(:serializer) { double('serializer') }
+    let(:default) { nil }
+
+    before do
+      allow(serializer)
+        .to receive(:serialize)
+        .with('org')
+        .and_return('org')
+    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) { { remote_key: :permissionLevel } }
+
+      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) { { visibility_level: 'org' } }
+
+        it 'get and serialize that value and set to payload with stringify name' do
+          expect(build_attributes).to eq({ 'name' => 'John', 'prefs/permissionLevel' => 'org' })
+        end
+      end
+    end
+
+    context 'when attribute is not for action update' do
+      let(:options) { { remote_key: :permissionLevel, create_only: true } }
+      let(:attributes) { { visibility_level: 'org' } }
+
+      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/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