ruby-trello 2.0.1 → 3.0.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