ruby-trello 2.2.0 → 2.3.0

data/spec/spec_helper.rb

@@ -1,36 +1,46 @@
-require 'rubygems'
+require 'bundler/setup'
+require 'dotenv/load'
+require 'trello'
+require 'webmock/rspec'
+require 'stringio'
+require 'vcr'
 
-unless defined? Rubinius
-  require 'simplecov'
-  SimpleCov.start
-end
+require 'pry-byebug' if RUBY_ENGINE != 'jruby'
 
-begin
-  require 'pry-byebug'
-rescue LoadError
-end
+VCR.configure do |config|
+  config.cassette_library_dir = 'spec/cassettes'
+  config.hook_into :webmock
 
-# Set up gems listed in the Gemfile.
-begin
-  ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', File.dirname(__FILE__))
-  require 'bundler'
-  Bundler.setup
-rescue Bundler::GemNotFound => e
-  STDERR.puts e.message
-  STDERR.puts 'Try running `bundle install`.'
-  exit!
-end
+  config.filter_sensitive_data('DEVELOPER_PUBLIC_KEY') do |interaction|
+    CGI.parse(URI.parse(interaction.request.uri).query)['key'].first
+  end
+  config.filter_sensitive_data('MEMBER_TOKEN') do |interaction|
+    CGI.parse(URI.parse(interaction.request.uri).query)['token'].first
+  end
+  config.filter_sensitive_data('set_cookie_dsc') do |interaction|
+    set_cookie_headers = interaction.response.headers['Set-Cookie']
 
-Bundler.require(:spec)
+    if set_cookie_headers
+      set_cookie_headers.first.scan(/dsc=(\w+)/).flatten.first
+    end
+  end
 
-require 'trello'
-require 'webmock/rspec'
-require 'stringio'
+  uri_without_credentials_matcher = lambda do |match_request, coming_request|
+    without_public_key = -> (uri) { uri.sub(/key=\w+/, 'key=DEVELOPER_PUBLIC_KEY') }
+    without_member_token = -> (uri) { uri.sub(/token=\w+/, 'token=MEMBER_TOKEN') }
+    without_credentials = -> (request) { without_public_key.call(without_member_token.call(request.uri)) }
+
+    without_credentials.call(match_request) == without_credentials.call(coming_request)
+  end
+
+  config.default_cassette_options[:match_requests_on] = [:method, uri_without_credentials_matcher]
+end
 
 Trello.logger = Logger.new(StringIO.new)
 
 RSpec.configure do |rspec|
   rspec.filter_run_excluding broken: true
+  rspec.filter_run_when_matching focus: true
 
   rspec.before :each do
     Trello.reset!
@@ -42,6 +52,21 @@ RSpec.configure do |rspec|
     example.run
     $VERBOSE = verbose
   end
+
+  rspec.failure_color = :magenta
+  rspec.tty = true
+  rspec.color = true
+end
+
+RSpec::Expectations.configuration.on_potential_false_positives = :nothing
+
+module IntegrationHelpers
+  def setup_trello
+    Trello.configure do |config|
+      config.developer_public_key = ENV['TRELLO_DEVELOPER_PUBLIC_KEY'] || 'developerpublickey'
+      config.member_token = ENV['TRELLO_MEMBER_TOKEN'] || 'membertoken'
+    end
+  end
 end
 
 module Helpers

data/spec/unit/trello/association_builder/has_many_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe Trello::AssociationBuilder::HasMany do
+
+  describe '.build' do
+    around do |example|
+      class FakeBoard; end
+
+      example.run
+
+      Object.send(:remove_const, 'FakeBoard')
+    end
+
+    it 'build has many finder method' do
+      Trello::AssociationBuilder::HasMany.build(FakeBoard, 'boards', {})
+
+      expect(FakeBoard.new.respond_to?(:boards)).to eq(true)
+    end
+
+    it 'the finder method return result from Trello::AssociationFetcher' do
+      fake_board = FakeBoard.new
+      has_many_fetcher = instance_double(Trello::AssociationFetcher::HasMany)
+      allow(Trello::AssociationFetcher::HasMany)
+        .to receive(:new)
+        .with(fake_board, 'boards', {})
+        .and_return(has_many_fetcher)
+
+      result = double('result')
+      allow(has_many_fetcher).to receive(:fetch).with(a: 1, b: 2).and_return(result)
+
+      Trello::AssociationBuilder::HasMany.build(FakeBoard, 'boards', {})
+      expect(fake_board.boards(a: 1, b: 2)).to eq(result)
+    end
+  end
+
+end

data/spec/unit/trello/association_builder/has_one_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe Trello::AssociationBuilder::HasOne do
+
+  describe '.build' do
+    around do |example|
+      class FakeBoard; end
+
+      example.run
+
+      Object.send(:remove_const, 'FakeBoard')
+    end
+
+    it 'build has one finder method' do
+      Trello::AssociationBuilder::HasOne.build(FakeBoard, 'organization', {})
+
+      expect(FakeBoard.new.respond_to?(:organization)).to eq(true)
+    end
+
+    it 'the finder method return result from Trello::AssociationFetcher' do
+      fake_board = FakeBoard.new
+      has_one_fetcher = instance_double(Trello::AssociationFetcher::HasOne)
+      allow(Trello::AssociationFetcher::HasOne)
+        .to receive(:new)
+        .with(fake_board, 'organization', {})
+        .and_return(has_one_fetcher)
+
+      result = double('result')
+      allow(has_one_fetcher).to receive(:fetch).and_return(result)
+
+      Trello::AssociationBuilder::HasOne.build(FakeBoard, 'organization', {})
+      expect(fake_board.organization).to eq(result)
+    end
+  end
+
+end

data/spec/unit/trello/association_fetcher/has_many/fetch_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+RSpec.describe Trello::AssociationFetcher::HasMany::Fetch do
+
+  describe '.execute' do
+    let(:client) { instance_double(Trello::Client) }
+    let(:association_class) { double('Association Class') }
+    let(:association_owner) { double('association_owner', client: client) }
+    let(:fetch_path) { '/test' }
+    let(:filter_params) { { a: 1 } }
+    let(:resources) { double('resources') }
+    let(:result) { double('result') }
+
+    let(:params) { instance_double('params',
+      association_class: association_class,
+      association_owner: association_owner,
+      fetch_path: fetch_path,
+      filter_params: filter_params
+    ) }
+
+    before do
+      allow(Trello).to receive(:client).and_return(client)
+      allow(client)
+        .to receive(:find_many)
+        .with(association_class, fetch_path, filter_params)
+        .and_return(resources)
+      allow(Trello::MultiAssociation)
+        .to receive(:new)
+        .with(association_owner, resources)
+        .and_return(double('multi-association', proxy: result))
+    end
+
+    it 'return the result from Trello.client and MultiAssociation' do
+      expect(Trello::AssociationFetcher::HasMany::Fetch.execute(params)).to eq(result)
+    end
+  end
+
+end

data/spec/unit/trello/association_fetcher/has_many/params_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+RSpec.describe Trello::AssociationFetcher::HasMany::Params do
+
+  let(:params) { Trello::AssociationFetcher::HasMany::Params.new(
+    association_owner: association_owner,
+    association_name: association_name,
+    association_options: association_options,
+    filter: filter
+  ) }
+
+  let(:association_owner) { double('owner', id: 1) }
+  let(:association_name) { 'cards' }
+  let(:association_options) { { filter: :all } }
+  let(:filter) { { a: 1 } }
+
+  describe '.association_class' do
+    context 'when explicit set :via in association_options' do
+      let(:association_options) { { via: Trello::Board } }
+
+      it 'return the value under the :via key' do
+        expect(params.association_class).to eq(Trello::Board)
+      end
+    end
+
+    context 'when does not set :via in association_options' do
+      before do
+        allow(Trello::AssociationInferTool)
+          .to receive(:infer_class_on_name)
+          .with(association_name)
+          .and_return(Trello::Card)
+      end
+
+      it 'return association_class use AssociationInferTool' do
+        expect(params.association_class).to eq(Trello::Card)
+      end
+    end
+  end
+
+  describe '.association_owner' do
+    it 'return association_owner directly' do
+      expect(params.association_owner).to eq(association_owner)
+    end
+  end
+
+  describe '.fetch_path' do
+    context 'when explicit set :in, :path in association_options' do
+      let(:association_options) { { in: 'boards', path: 'cards' } }
+
+      it 'use them to generate fetch_path - formula: ":in/owner_id/:path"' do
+        expect(params.fetch_path).to eq('/boards/1/cards')
+      end
+    end
+
+    context 'when does not set :in, :path in association_options' do
+      let(:association_owner) { double('owner', id: 1, class: Trello::Member) }
+      before do
+        allow(Trello::AssociationInferTool)
+          .to receive(:infer_restful_resource_on_class)
+          .with(Trello::Member)
+          .and_return('members')
+      end
+
+      it 'will generate fetch_path use AssociationInferTool' do
+        expect(params.fetch_path).to eq('/members/1/cards')
+      end
+    end
+  end
+
+  describe '.filter_params' do
+    context 'when filter and default_filer are both nil' do
+      let(:association_options) { nil }
+      let(:filter) { nil }
+
+      it 'return a empty hash' do
+        expect(params.filter_params).to eq({})
+      end
+    end
+
+    context 'when filter is nil' do
+      let(:association_options) { { filter: :all } }
+      let(:filter) { nil }
+
+      it 'return default filter' do
+        expect(params.filter_params).to eq({ filter: :all })
+      end
+    end
+
+    context 'when default filter is nil' do
+      let(:association_options) { nil }
+      let(:filter) { { a: 1 } }
+
+      it 'return filter' do
+        expect(params.filter_params).to eq({ a: 1 })
+      end
+    end
+
+    context 'when both filter and default_filter exists' do
+      let(:association_options) { { filter: :all } }
+      let(:filter) { { a: 1, filter: :open } }
+
+      it 'return the result from merge filter on default_filter' do
+        expect(params.filter_params).to eq({a: 1, filter: :open})
+      end
+    end
+  end
+end

data/spec/unit/trello/association_fetcher/has_many_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe Trello::AssociationFetcher::HasMany do
+
+  describe '#new' do
+    let(:board) { instance_double(Trello::Board) }
+    let(:has_many) {
+      Trello::AssociationFetcher::HasMany.new(board, 'cards', {filter: :all})
+    }
+
+    it 'has model_class attribute' do
+      expect(has_many.model).to eq(board)
+    end
+
+    it 'has name attribute' do
+      expect(has_many.name).to eq('cards')
+    end
+
+    it 'has options attribute' do
+      expect(has_many.options).to eq({filter: :all})
+    end
+  end
+
+  describe '.fetch' do
+    let(:board) { instance_double(Trello::Board) }
+    let(:params) { instance_double(Trello::AssociationFetcher::HasMany::Params) }
+    let(:fetch_result) { double('fetch result') }
+    let(:has_many_fetcher) {
+      Trello::AssociationFetcher::HasMany.new(board, 'cards', {filter: :all})
+    }
+
+    it 'return the result from HasMany::Fetch and HasMany::Params' do
+      expect(Trello::AssociationFetcher::HasMany::Params)
+        .to receive(:new)
+        .with(
+          association_owner: board,
+          association_name: 'cards',
+          association_options: { filter: :all },
+          filter: { a: 1 }
+        ).and_return(params)
+      expect(Trello::AssociationFetcher::HasMany::Fetch)
+        .to receive(:execute)
+        .with(params)
+        .and_return(fetch_result)
+
+      expect(has_many_fetcher.fetch(a: 1)).to eq(fetch_result)
+    end
+  end
+
+end

data/spec/unit/trello/association_fetcher/has_one/fetch_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+RSpec.describe Trello::AssociationFetcher::HasOne::Fetch do
+
+  describe '.execute' do
+    let(:client) { instance_double(Trello::Client) }
+    let(:association_owner) { double('association_owner', client: client) }
+    let(:association_restful_id) { 1 }
+    let(:association_class) { double('association_class') }
+    let(:result) { double('result') }
+
+    let(:params) { instance_double('params',
+      association_owner: association_owner,
+      association_restful_name: association_restful_name,
+      association_restful_id: association_restful_id,
+      association_class: association_class
+    )}
+
+    context 'when association_restful_name exists' do
+      let(:association_restful_name) { 'organizations' }
+
+      before do
+        allow(Trello).to receive(:client).and_return(client)
+        allow(client)
+          .to receive(:find)
+          .with(association_restful_name, association_restful_id)
+          .and_return(result)
+      end
+
+      it 'return the result from Trello.client' do
+        expect(Trello::AssociationFetcher::HasOne::Fetch.execute(params)).to eq(result)
+      end
+    end
+
+    context 'when association_restful_name does not exist' do
+      let(:association_restful_name) { nil }
+
+      before do
+        allow(association_class)
+          .to receive(:find)
+          .with(association_restful_id)
+          .and_return(result)
+      end
+
+      it 'return the result from association_class' do
+        expect(Trello::AssociationFetcher::HasOne::Fetch.execute(params)).to eq(result)
+      end
+    end
+  end
+
+end

data/spec/unit/trello/association_fetcher/has_one/params_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+RSpec.describe Trello::AssociationFetcher::HasOne::Params do
+
+  let(:params) { Trello::AssociationFetcher::HasOne::Params.new(
+    association_owner: association_owner,
+    association_name: association_name,
+    association_options: association_options,
+  )}
+
+  let(:association_owner) { double('owner', id: 1, organization_id: 9) }
+  let(:association_name) { 'organization' }
+  let(:association_options) { { using: :organization_id } }
+
+  describe 'association_class' do
+    context 'when explicit set :via in association_options' do
+      let(:association_options) { { via: Trello::Organization } }
+
+      it 'return the value under the :via key' do
+        expect(params.association_class).to eq(Trello::Organization)
+      end
+    end
+
+    context 'when does not set :via in association_options' do
+      before do
+        allow(Trello::AssociationInferTool)
+          .to receive(:infer_class_on_name)
+          .with(association_name)
+          .and_return(Trello::Organization)
+      end
+
+      it 'return association_class use AssociationInferTool' do
+        expect(params.association_class).to eq(Trello::Organization)
+      end
+    end
+  end
+
+  describe 'association_owner' do
+    it 'return association_owner directly' do
+      expect(params.association_owner).to eq(association_owner)
+    end
+  end
+
+  describe 'association_restful_name' do
+    context 'when explicit set :path in association_options' do
+      let(:association_options) { { path: :organizations } }
+
+      it 'return :path directly' do
+        expect(params.association_restful_name).to eq(:organizations)
+      end
+    end
+
+    context 'when does not set :path in association_options' do
+      let(:association_options) { {} }
+
+      it 'return nil' do
+        expect(params.association_restful_name).to eq(nil)
+      end
+    end
+  end
+
+  describe 'association_restful_id' do
+    context 'when explicit set :using in association_options' do
+      let(:association_options) { { using: :organization_id } }
+
+      it 'return the result from association_owner.<using> directly' do
+        expect(params.association_restful_id).to eq(9)
+      end
+    end
+
+    context 'when does not set :using in association_options' do
+      let(:association_options) { {} }
+
+      it 'return the result from association_owner.id directly' do
+        expect(params.association_restful_id).to eq(1)
+      end
+    end
+  end
+
+
+end