ruby-trello-czuger 2.0.0

data/spec/configuration_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Trello::Configuration do
+  let(:configuration) { Trello::Configuration.new }
+
+  [
+    :consumer_key,
+    :consumer_secret,
+    :oauth_token,
+    :oauth_token_secret,
+    :developer_public_key,
+    :member_token,
+    :return_url
+
+  ].each do |attribute|
+    it "has a #{attribute} attribute" do
+      configuration.public_send(:"#{attribute}=", attribute)
+      expect(configuration.public_send(attribute)).to eq attribute
+    end
+  end
+
+  it 'has a callback (for oauth)' do
+    callback = -> { 'foobar' }
+    configuration.callback = callback
+    expect(configuration.callback.call).to eq('foobar')
+  end
+
+  describe 'initialize' do
+    it 'sets key attributes provided as a hash' do
+      configuration = Trello::Configuration.new(
+        consumer_key: 'consumer_key',
+        consumer_secret: 'consumer_secret',
+        oauth_token: 'oauth_token',
+        oauth_token_secret: 'oauth_token_secret'
+      )
+      expect(configuration.consumer_key).to eq('consumer_key')
+      expect(configuration.consumer_secret).to eq('consumer_secret')
+      expect(configuration.oauth_token).to eq('oauth_token')
+      expect(configuration.oauth_token_secret).to eq('oauth_token_secret')
+    end
+  end
+
+  describe '#credentials' do
+    let(:configuration) { Trello::Configuration.new(attributes) }
+
+    it 'returns an empty if no attributes specified' do
+      expect(Trello::Configuration.new({}).credentials).to eq({})
+    end
+
+    it 'returns an empty if attributes incomplete' do
+      expect(Trello::Configuration.new(consumer_key: 'consumer_key').credentials).to eq({})
+    end
+
+    it 'returns a hash of oauth attributes' do
+      configuration = Trello::Configuration.new(
+        consumer_key: 'consumer_key',
+        consumer_secret: 'consumer_secret',
+        oauth_token: 'oauth_token',
+        oauth_token_secret: 'oauth_token_secret'
+      )
+      expect(configuration.credentials).to eq(
+        consumer_key: 'consumer_key',
+        consumer_secret: 'consumer_secret',
+        oauth_token: 'oauth_token',
+        oauth_token_secret: 'oauth_token_secret'
+      )
+    end
+
+    it 'includes callback and return url if given' do
+      configuration = Trello::Configuration.new(
+        consumer_key: 'consumer_key',
+        consumer_secret: 'consumer_secret',
+        return_url: 'http://example.com',
+        callback: 'callback'
+      )
+      expect(configuration.credentials).to eq(
+        consumer_key: 'consumer_key',
+        consumer_secret: 'consumer_secret',
+        return_url: 'http://example.com',
+        callback: 'callback'
+      )
+    end
+
+    it 'returns a hash of basic auth policy attributes' do
+      configuration = Trello::Configuration.new(
+        developer_public_key: 'developer_public_key',
+        member_token: 'member_token'
+      )
+      expect(configuration.credentials).to eq(
+        developer_public_key: 'developer_public_key',
+        member_token: 'member_token'
+      )
+    end
+  end
+end

data/spec/hash_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'trello/core_ext/hash'
+
+describe Hash, '#jsoned_into' do
+  include Helpers
+
+  it "should convert a single parsed json into card" do
+    expect(Trello::Card)
+      .to receive(:new)
+      .once
+      .with(cards_details.first)
+
+    cards_details.first.jsoned_into(Trello::Card)
+  end
+end

data/spec/integration/how_to_authorize_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'integration/integration_test'
+
+describe "Authorizing read-only requests", broken: true do
+  include IntegrationTest
+
+  it "Reading public resources requires just a developer public key" do
+    uri = Addressable::URI.parse("https://api.trello.com/1/boards/4ed7e27fe6abb2517a21383d")
+    uri.query_values = {
+      key: @developer_public_key
+    }
+
+    get(uri).code.should === 200
+  end
+
+  it "Reading private resources requires developer public key AND a member token" do
+    uri = Addressable::URI.parse("https://api.trello.com/1/boards/#{@welcome_board}")
+    uri.query_values = {
+      key: @developer_public_key,
+      token: @member_token
+    }
+
+    get(uri).code.should === 200
+  end
+
+  it "can fetch the welcome board" do
+    BasicAuthPolicy.developer_public_key = @developer_public_key
+    BasicAuthPolicy.member_token = @member_token
+
+    Container.set Trello::Authorization, "AuthPolicy", BasicAuthPolicy
+
+    welcome_board = Board.find @welcome_board
+    welcome_board.name.should === "Welcome Board"
+    welcome_board.id.should === @welcome_board
+  end
+end
+
+describe "OAuth", broken: true do
+  include IntegrationTest
+
+  before do
+    Container.set Trello::Authorization, "AuthPolicy", OAuthPolicy
+  end
+
+  it "[!] actually does not enforce signature at all, only the keys are required" do
+    OAuthPolicy.consumer_credential = OAuthCredential.new @developer_public_key, nil
+    OAuthPolicy.token = OAuthCredential.new @access_token_key, nil
+
+    pending "I would expect this to fail because I have signed with nil secrets" do
+      -> { Client.get("/boards/#{@welcome_board}/") }.should raise_error
+    end
+  end
+end

data/spec/integration/how_to_use_boards_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'integration/integration_test'
+
+describe "how to use boards", broken: true do
+  include IntegrationTest
+
+  context "given a valid access token" do
+    before :all do
+      OAuthPolicy.consumer_credential = OAuthCredential.new @developer_public_key, @developer_secret
+      OAuthPolicy.token = OAuthCredential.new @access_token_key, @access_token_secret
+      Container.set Trello::Authorization, "AuthPolicy", OAuthPolicy
+    end
+
+    after do
+      if @new_board and false == @new_board.closed?
+        @new_board.update_fields 'closed' => true
+        @new_board.save
+      end
+    end
+
+    it "can add a board" do
+      @new_board = Board.create(name: "An example")
+      @new_board.should_not be_nil
+      @new_board.id.should_not be_nil
+      @new_board.name.should == "An example"
+      @new_board.should_not be_closed
+    end
+
+    it "can read the welcome board" do
+      welcome_board = Board.find @welcome_board
+      welcome_board.name.should === "Welcome Board"
+      welcome_board.id.should === @welcome_board
+    end
+
+    it "can close a board" do
+      @new_board = Board.create(name: "[#{Time.now}, CLOSED] An example")
+
+      @new_board.update_fields 'closed' => true
+      @new_board.save
+
+      Board.find(@new_board.id).should be_closed
+    end
+
+    it "can list all boards" do
+      Board.from_response(Client.get("/members/me/boards/")).should be_an Array
+    end
+  end
+end

data/spec/integration/integration_test.rb

@@ -0,0 +1,40 @@
+module IntegrationTest
+  include Trello
+  include Trello::Authorization
+
+  class Container
+    class << self
+      def set(parent, name, value)
+        parent.send :remove_const, name
+        parent.const_set name, value
+      end
+    end
+  end
+
+  def self.included(klass)
+    klass.class_eval do
+      before :all do
+        # Getting developer/member key
+        # 1. https://trello.com/1/appKey/generate
+        # 2. https://trello.com/1/authorize?key=<public_key_here>&name=RubyTrelloIntegrationTests&response_type=token
+        # See: https://trello.com/board/trello-public-api/4ed7e27fe6abb2517a21383d
+
+        @developer_public_key = ENV["DEVELOPER_PUBLIC_KEY"]
+        @developer_secret     = ENV["DEVELOPER_SECRET"]
+        @member_token         = ENV["MEMBER_TOKEN"]
+        @welcome_board        = ENV["WELCOME_BOARD"]
+        @access_token_key     = ENV["ACCESS_TOKEN_KEY"]
+        @access_token_secret  = ENV["ACCESS_TOKEN_SECRET"]
+        
+        WebMock.disable!
+      end    
+    end
+  end
+
+  protected
+
+  def get(uri)
+    require "rest_client"
+    RestClient.get uri.to_s
+  end
+end

data/spec/item_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+module Trello
+  describe Item do
+    let(:details) {
+      {
+        'id'   => 'abcdef123456789123456789',
+        'name' => 'test item',
+        'type' => 'check',
+        'state' => 'complete',
+        'pos' => 0
+      }
+    }
+
+    let(:item) { Item.new(details) }
+
+    it 'gets its id' do
+      expect(item.id).to eq details['id']
+    end
+
+    it 'gets its name' do
+      expect(item.name).to eq details['name']
+    end
+
+    it 'knows its type' do
+      expect(item.type).to eq details['type']
+    end
+
+    it 'knows its state' do
+      expect(item.state).to eq details['state']
+    end
+
+    it 'knows its pos' do
+      expect(item.pos).to eq details['pos']
+    end
+
+    describe '#complete?' do
+      before do
+        allow(item)
+          .to receive(:state)
+          .and_return state
+      end
+
+      context 'when complete' do
+        let(:state) { 'complete' }
+        it { expect(item).to be_complete }
+      end
+
+      context 'when complete' do
+        let(:state) { 'incomplete' }
+        it { expect(item).not_to be_complete }
+      end
+    end
+
+    describe "#update_fields" do
+      it "does not set any fields when the fields argument is empty" do
+        expected = {
+          'id' => 'id',
+          'name' => 'name',
+          'type' => 'type',
+          'state' => 'state',
+          'pos' => 'pos'
+        }
+
+        item = Item.new(expected)
+
+        item.update_fields({})
+
+        expected.each do |key, value|
+          expect(item.send(value)).to eq expected[key]
+        end
+      end
+    end
+  end
+end

data/spec/json_utils_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+module Trello
+  RSpec.describe JsonUtils do
+    include Helpers
+
+    describe ".from_json" do
+      describe "Trello::Card" do
+        it "should convert an array of parsed json into cards" do
+          cards = Trello::Card.from_json(cards_details)
+
+          expect(cards.size).to eq(cards_details.size)
+
+          card = cards.first
+          expect(card).to be_a(Trello::Card)
+          expect(card.name).to eq(cards_details.first['name'])
+        end
+
+        it "should convert a single parsed json into card" do
+          card_details = cards_details.first
+          card = Trello::Card.from_json(card_details)
+
+          expect(card).to be_a(Trello::Card)
+          expect(card.name).to eq(cards_details.first['name'])
+        end
+      end
+    end
+
+    describe ".from_response" do
+      def example_class
+        @example_class ||= Class.new do
+          include Trello::JsonUtils
+
+          attr_accessor :name, :description
+
+          def initialize(options = {})
+            @name = options['name']
+            @description = options['description']
+          end
+        end
+      end
+
+      it 'converts json into an instance of a class' do
+        expect(example_class.from_response('{}')).to be_a example_class
+      end
+
+      it 'supplies the parsed json to the class ctor as a hash' do
+        json_text = '{"name" : "Jazz Kang", "description": "Plonker"}'
+
+        result = example_class.from_response json_text
+        expect(result.name).to eq("Jazz Kang")
+        expect(result.description).to eq("Plonker")
+      end
+
+      it 'can also handle arrays of instances of a class' do
+        json_text = <<-JSON
+      [
+       {"name" : "Jazz Kang", "description": "Plonker"},
+       {"name" : "Phil Murphy", "description": "Shoreditch hipster"}
+      ]
+        JSON
+
+        result = example_class.from_response json_text
+
+        expect(result).to be_an Array
+        expect(result.size).to eq 2
+        result.each do |parsed|
+          expect(parsed).to be_a example_class
+        end
+      end
+    end
+  end
+end

data/spec/label_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+module Trello
+  describe Label do
+    include Helpers
+
+    let(:label) { client.find(:label, 'abcdef123456789123456789') }
+    let(:client) { Client.new }
+
+    before do
+      allow(client)
+        .to receive(:get)
+        .with("/labels/abcdef123456789123456789", {})
+        .and_return JSON.generate(label_details.first)
+    end
+
+    context "finding" do
+      let(:client) { Trello.client }
+
+      it "delegates to Trello.client#find" do
+        expect(client)
+          .to receive(:find)
+          .with(:label, 'abcdef123456789123456789', {})
+
+        Label.find('abcdef123456789123456789')
+      end
+
+      it "is equivalent to client#find" do
+        expect(Label.find('abcdef123456789123456789')).to eq(label)
+      end
+    end
+
+    context "creating" do
+      let(:client) { Trello.client }
+
+      it "creates a new record" do
+        expect(Label.new(label_details.first)).to be_valid
+      end
+
+      it "initializes all fields from response-like formatted hash" do
+        details = label_details.first
+        label = Label.new(details)
+        expect(label.color).to    eq details['color']
+        expect(label.name).to     eq details['name']
+        expect(label.id).to       eq details['id']
+        expect(label.uses).to     eq details['uses']
+        expect(label.board_id).to eq details['idBoard']
+      end
+
+      it "initializes required fields from options-like formatted hash" do
+        details = label_options
+        label = Label.new(details)
+        expect(label.name).to     eq details[:name]
+        expect(label.board_id).to eq details[:board_id]
+        expect(label.color).to    eq details[:color]
+      end
+
+      it 'must not be valid if not given a name' do
+        expect(Label.new('idBoard' => lists_details.first['board_id'])).to_not be_valid
+      end
+
+      it 'must not be valid if not given a board id' do
+        expect(Label.new('name' => lists_details.first['name'])).to_not be_valid
+      end
+
+      it 'creates a new record and saves it on Trello', refactor: true do
+        payload = {
+          name: 'Test Label',
+          board_id: 'abcdef123456789123456789',
+        }
+
+        result = JSON.generate(cards_details.first.merge(payload.merge(idBoard: boards_details.first['id'])))
+
+        expected_payload = {name: "Test Label", color: nil, idBoard: "abcdef123456789123456789" }
+
+        expect(client)
+          .to receive(:post)
+          .with("/labels", expected_payload)
+          .and_return result
+
+        label = Label.create(label_details.first.merge(payload.merge(board_id: boards_details.first['id'])))
+
+        expect(label).to be_a Label
+      end
+    end
+
+    context "updating" do
+      it "updating name does a put on the correct resource with the correct value" do
+        expected_new_name = "xxx"
+
+        payload = {
+          name: expected_new_name,
+        }
+
+        expect(client)
+          .to receive(:put)
+          .once
+          .with("/labels/abcdef123456789123456789", payload)
+
+        label.name = expected_new_name
+        label.save
+      end
+
+      it "updating color does a put on the correct resource with the correct value" do
+        expected_new_color = "purple"
+
+        payload = {
+          color: expected_new_color,
+        }
+
+        expect(client)
+          .to receive(:put)
+          .once
+          .with("/labels/abcdef123456789123456789", payload)
+
+        label.color = expected_new_color
+        label.save
+      end
+
+      it "can update with any valid color" do
+        %w(green yellow orange red purple blue sky lime pink black).each do |color|
+          allow(client)
+            .to receive(:put)
+            .with("/labels/abcdef123456789123456789", {color: color})
+            .and_return "not important"
+
+          label.color = color
+          label.save
+          expect(label.errors).to be_empty
+        end
+      end
+
+      it "throws an error when trying to update a label with an unknown colour" do
+        allow(client)
+          .to receive(:put)
+          .with("/labels/abcdef123456789123456789", {})
+          .and_return "not important"
+
+        label.color = 'mauve'
+        label.save
+
+        expect(label.errors.full_messages.to_sentence).to eq("Label color 'mauve' does not exist")
+      end
+    end
+
+    context "deleting" do
+      it "deletes the label" do
+        expect(client)
+          .to receive(:delete)
+          .with("/labels/#{label.id}")
+
+        label.delete
+      end
+    end
+
+    context "fields" do
+      it "gets its id" do
+        expect(label.id).to_not be_nil
+      end
+
+      it "gets its name" do
+        expect(label.name).to_not be_nil
+      end
+
+      it "gets its usage" do
+        expect(label.uses).to_not be_nil
+      end
+
+      it "gets its color" do
+        expect(label.color).to_not be_nil
+      end
+    end
+
+    context "boards" do
+      it "has a board" do
+        expect(client)
+          .to receive(:get)
+          .with("/boards/abcdef123456789123456789", {})
+          .and_return JSON.generate(boards_details.first)
+
+        expect(label.board).to_not be_nil
+      end
+    end
+
+    describe "#update_fields" do
+      it "does not set any fields when the fields argument is empty" do
+        expected = {
+          'id' => 'id',
+          'name' => 'name',
+          'color' => 'color',
+          'idBoard' => 'board_id',
+          'uses' => 'uses'
+        }
+
+        label = Label.new(expected)
+
+        label.update_fields({})
+
+        expected.each do |key, value|
+          expect(label.send(value)).to eq expected[key]
+        end
+      end
+    end
+  end
+end