ruby-trello-czuger 2.0.0

data/spec/checklist_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+
+module Trello
+  describe Checklist do
+    include Helpers
+
+    let(:checklist) { client.find(:checklist, 'abcdef123456789123456789') }
+    let(:client) { Client.new }
+
+    before do
+      allow(client)
+        .to receive(:get)
+        .with("/checklists/abcdef123456789123456789", {})
+        .and_return JSON.generate(checklists_details.first)
+    end
+
+    context "finding" do
+      let(:client) { Trello.client }
+
+      it "delegates to Trello.client#find" do
+        expect(client)
+          .to receive(:find)
+          .with(:checklist, 'abcdef123456789123456789', {})
+
+        Checklist.find('abcdef123456789123456789')
+      end
+
+      it "is equivalent to client#find" do
+        expect(Checklist.find('abcdef123456789123456789')).to eq(checklist)
+      end
+    end
+
+    context "creating" do
+      let(:client) { Trello.client }
+
+      it 'creates a new record and saves it on Trello', refactor: true do
+        payload = {
+            name: 'Test Checklist',
+            desc: '',
+            card_id: cards_details.first['id']
+        }
+
+        attributes = checklists_details.first.merge(payload).except("idBoard")
+        result = JSON.generate(attributes)
+
+
+        expected_payload = {name: "Test Checklist", idCard: cards_details.first['id']}
+
+        expect(client)
+          .to receive(:post)
+          .with("/checklists", expected_payload)
+          .and_return result
+
+        checklist = Checklist.create(attributes)
+
+        expect(checklist).to be_a Checklist
+      end
+
+      it 'initializes all fields from response-like hash' do
+        checklist_details = checklists_details.first
+        checklist = Checklist.new(checklist_details)
+        expect(checklist.id).to          eq checklist_details['id']
+        expect(checklist.name).to        eq checklist_details['name']
+        expect(checklist.description).to eq checklist_details['desc']
+        expect(checklist.closed).to      eq checklist_details['closed']
+        expect(checklist.position).to    eq checklist_details['pos']
+        expect(checklist.url).to         eq checklist_details['url']
+        expect(checklist.board_id).to    eq checklist_details['idBoard']
+        expect(checklist.card_id).to     eq checklist_details['idCard']
+        expect(checklist.list_id).to     eq checklist_details['idList']
+        expect(checklist.member_ids).to  eq checklist_details['idMembers']
+        expect(checklist.check_items).to eq checklist_details['checkItems']
+      end
+
+      it 'initializes required fields from options-like hash' do
+        checklist_details = checklists_details[1]
+        checklist = Checklist.new(checklist_details)
+        expect(checklist.name).to    eq checklist_details[:name]
+        expect(checklist.card_id).to eq checklist_details[:card_id]
+      end
+    end
+
+    context "deleting" do
+      let(:client) { Trello.client }
+
+      it "deletes a checklist" do
+        expect(client)
+          .to receive(:delete)
+          .with("/checklists/#{checklist.id}")
+
+        checklist.delete
+      end
+
+      it "deletes a checklist item" do
+        item_id = checklist.check_items.first.last
+        expect(client)
+          .to receive(:delete)
+          .with("/checklists/#{checklist.id}/checkItems/#{item_id}")
+
+        checklist.delete_checklist_item(item_id)
+      end
+    end
+
+    context "updating" do
+      it "updating name does a put on the correct resource with the correct value" do
+        expected_new_name = "xxx"
+        expected_resource = "/checklists/abcdef123456789123456789"
+        payload = {
+            name: expected_new_name,
+            pos: checklist.position
+        }
+
+        result = JSON.generate(checklists_details.first)
+        expect(client)
+          .to receive(:put)
+          .once.with(expected_resource, payload)
+          .and_return result
+
+        checklist.name = expected_new_name
+        checklist.save
+      end
+
+      it "updating position does a put on the correct resource with the correct value" do
+        expected_new_position = 33
+        expected_resource = "/checklists/abcdef123456789123456789"
+        payload = {
+            name: checklist.name,
+            pos: expected_new_position
+        }
+
+        result = JSON.generate(checklists_details.first)
+        expect(client)
+          .to receive(:put)
+          .once
+          .with(expected_resource, payload)
+          .and_return result
+
+        checklist.position = expected_new_position
+        checklist.save
+      end
+
+      it "adds an item" do
+        expected_item_name = "item1"
+        expected_checked = true
+        expected_pos = 9999
+        payload = {
+            name: expected_item_name,
+            checked: expected_checked,
+            pos: expected_pos
+        }
+        result_hash = {
+            name: expected_item_name,
+            state: expected_checked ? 'complete' : 'incomplete',
+            pos: expected_pos
+        }
+        result = JSON.generate(result_hash)
+        expect(client)
+          .to receive(:post)
+          .once
+          .with("/checklists/abcdef123456789123456789/checkItems", payload)
+          .and_return result
+
+        checklist.add_item(expected_item_name, expected_checked, expected_pos)
+      end
+
+      it "updates an item's state" do
+        expected_item_id = "1234"
+        expected_state = "incomplete"
+        expected_resource =
+          "/cards/abccardid/checkItem/#{expected_item_id}"
+        payload = { state: expected_state }
+        expect(client).to receive(:put).once.with(expected_resource, payload)
+        checklist.update_item_state(expected_item_id, expected_state)
+      end
+
+      it "updates an item's with boolean input" do
+        expected_item_id = "1234"
+        expected_state = "complete"
+        expected_resource =
+            "/cards/abccardid/checkItem/#{expected_item_id}"
+        payload = { state: expected_state }
+        expect(client).to receive(:put).once.with(expected_resource, payload)
+        checklist.update_item_state(expected_item_id, true)
+      end
+    end
+
+    context "board" do
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/boards/abcdef123456789123456789")
+          .and_return JSON.generate(boards_details.first)
+      end
+
+      it "has a board" do
+        expect(checklist.board).to_not be_nil
+      end
+    end
+
+    context "list" do
+      before do
+        allow(client)
+          .to receive(:get)
+          .with("/lists/abcdef123456789123456789", {})
+          .and_return JSON.generate(lists_details.first)
+      end
+
+      it 'has a list' do
+        expect(checklist.list).to_not be_nil
+      end
+    end
+
+    context "making a copy" do
+      let(:client) { Trello.client }
+      let(:copy_options) { { :name => checklist.name, :idCard => checklist.card_id } }
+      let(:copied_checklist) { checklist.copy }
+
+      before(:each) do
+        allow(client)
+          .to receive(:post)
+          .with("/checklists", copy_options)
+          .and_return JSON.generate(copied_checklists_details.first)
+
+        allow(checklist)
+          .to receive(:items)
+          .and_return []
+      end
+
+      it "creates a new checklist" do
+        expect(copied_checklist).to be_an_instance_of Checklist
+      end
+
+      it "is not the same Ruby object as the original checklist" do
+        expect(copied_checklist).to_not be checklist
+      end
+
+      it "has the same name as the original checklist" do
+        expect(copied_checklist.name).to eq checklist.name
+      end
+
+      it "has the same board as the original checklist" do
+        expect(copied_checklist.board_id).to eq checklist.board_id
+      end
+
+      it "creates items for the copy based on the original checklist's items" do
+        checklist_copy  = Trello::Checklist.new
+        allow(checklist_copy)
+          .to receive(:add_item)
+
+        allow(Trello::Checklist)
+          .to receive(:create)
+          .and_return(checklist_copy)
+
+        incomplete_item = double("incomplete", name: "1", complete?: false)
+        complete_item   = double("complete", name: "2", complete?: true)
+        checklist_items = [incomplete_item, complete_item]
+        allow(checklist).to receive(:items).and_return checklist_items
+
+        checklist_items.each do |item|
+          expect(checklist_copy)
+            .to receive(:add_item)
+            .with(item.name, item.complete?)
+        end
+
+        checklist.copy
+      end
+    end
+
+    describe "#update_fields" do
+      it "does not set any fields when the fields argument is empty" do
+        expected = {
+          'id' => 'id',
+          'name' => 'name',
+          'desc' => 'description',
+          'closed' => 'closed',
+          'url' => 'url',
+          'checkItems' => 'check_items',
+          'pos' => 'position',
+          'idBoard' => 'board_id',
+          'idCard' => 'card_id',
+          'idList' => 'list_id',
+          'idMembers' => 'member_ids'
+        }
+
+        checklist = Checklist.new(expected)
+        checklist.client = client
+
+        checklist.update_fields({})
+
+        expected.each do |key, value|
+          expect(checklist.send(value)).to eq expected[key]
+        end
+      end
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,257 @@
+require "spec_helper"
+
+include Trello
+include Trello::Authorization
+
+describe Client do
+
+  let(:client) { Client.new }
+  let(:auth_policy) { double }
+
+  before do
+    allow(Authorization::AuthPolicy)
+      .to receive(:new)
+           .and_return(auth_policy)
+
+    allow(auth_policy)
+      .to receive(:authorize) { |request| request }
+  end
+
+  describe "and how it handles RestClient exceptions" do
+    context "with RestClient::Exception sans HTTP code" do
+      let(:rc_exception_without_http_code) { RestClient::Exception.new }
+
+      before do
+        allow(TInternet)
+          .to receive(:execute_core)
+          .and_raise(rc_exception_without_http_code)
+      end
+
+      it "bubbles up RestClient::Exception errors that don't contain an HTTP code" do
+        expect { client.get "/xxx" }.to raise_error rc_exception_without_http_code
+      end
+    end
+
+    context "with RestClient::Exception that contains HTTP code" do
+      let(:response_with_non_200_status) { double "A fake 404 response",
+                                              code: 404,
+                                              body: "404 error response"}
+      let(:rc_exception_with_http_code) { RestClient::Exception.new(double("404 error response", {:code => 404, :body => "404 error response"}))}
+
+      before do
+        allow(TInternet)
+          .to receive(:execute_core)
+          .and_raise(rc_exception_with_http_code)
+      end
+
+      it "raises Error" do
+
+        expect(TInternet)
+          .to receive(:try_execute)
+          .and_return(response_with_non_200_status)
+
+        expect { client.get "/xxx" }.to raise_error(Error, "404 error response")
+      end
+    end
+  end
+
+  describe "and how it handles authorization" do
+    let (:fake_ok_response) do
+      double "A fake OK response",
+             code: 200,
+             body: "A fake response body"
+    end
+    let(:client) { Client.new }
+    let(:auth_policy) { double }
+
+    before do
+      allow(TInternet)
+        .to receive(:execute)
+             .and_return fake_ok_response
+
+      allow(Authorization::AuthPolicy)
+        .to receive(:new)
+             .and_return(auth_policy)
+
+      allow(auth_policy)
+        .to receive(:authorize) { |request| request }
+    end
+
+    it "authorizes before it queries the internet" do
+      expect(auth_policy)
+        .to receive(:authorize)
+             .once
+             .ordered
+
+      expect(TInternet)
+        .to receive(:execute)
+             .once
+             .ordered
+
+      client.get "/xxx"
+    end
+
+    it "queries the internet with expanded earl and query parameters" do
+      expected_uri = Addressable::URI.parse("https://api.trello.com/1/xxx?a=1&b=2")
+      expected_request = Request.new :get, expected_uri, {}
+
+      expect(TInternet)
+        .to receive(:execute)
+             .once
+             .with expected_request
+
+      client.get "/xxx", a: "1", b: "2"
+    end
+
+    it "encodes parameters" do
+      expected_uri = Addressable::URI.parse("https://api.trello.com/1/xxx?name=Jazz%20Kang")
+      expected_request = Request.new :get, expected_uri, {}
+
+      expect(TInternet)
+        .to receive(:execute)
+             .once
+             .with expected_request
+
+      client.get "/xxx", name: "Jazz Kang"
+    end
+
+    it "raises an error when response has non-200 status" do
+      expected_error_message = "An error response"
+      response_with_non_200_status = double "A fake OK response",
+                                            code: 404,
+                                            body: expected_error_message
+
+      expect(TInternet)
+        .to receive(:execute)
+             .and_return response_with_non_200_status
+
+      expect { client.get "/xxx" }.to raise_error expected_error_message
+    end
+
+    it "uses version 1 of the API" do
+      expect(TInternet)
+        .to receive(:execute)
+             .once do |request|
+        expect(request.uri.to_s).to match(/1\//)
+        fake_ok_response
+      end
+
+      client.get "/"
+    end
+
+    it "omits the \"?\" when no parameters" do
+      expect(TInternet)
+        .to receive(:execute)
+             .once do |request|
+        expect(request.uri.to_s).not_to match(/\?$/)
+        fake_ok_response
+      end
+
+      client.get "/xxx"
+    end
+
+    it "supports post" do
+      expect(TInternet)
+        .to receive(:execute)
+             .once
+             .and_return fake_ok_response
+
+      client.post "/xxx", { phil: "T' north" }
+    end
+
+    it "supplies the body for a post" do
+      expected_body = { name: "Phil", nickname: "The Crack Fox" }
+
+      expect(TInternet)
+        .to receive(:execute)
+             .once do |request|
+        expect(request.body).to eq expected_body
+        fake_ok_response
+      end
+
+      client.post "/xxx", expected_body
+    end
+
+    it "supplies the path for a post" do
+      expected_path = "/xxx"
+
+      expect(TInternet)
+        .to receive(:execute)
+             .once do |request|
+        expect(request.uri.path).to match(/#{expected_path}$/)
+        fake_ok_response
+      end
+
+      client.post "/xxx", {}
+    end
+
+    it "supports put" do
+      expect(TInternet)
+        .to receive(:execute)
+             .once
+             .and_return fake_ok_response
+
+      client.put "/xxx", { phil: "T' north" }
+    end
+
+    it "supplies the body for a put" do
+      expected_body = { name: "Phil", nickname: "The Crack Fox" }
+
+      expect(TInternet)
+        .to receive(:execute)
+             .once do |request|
+        expect(request.body).to eq expected_body
+        fake_ok_response
+      end
+
+      client.put "/xxx", expected_body
+    end
+
+    it "supplies the path for a put" do
+      expected_path = "/xxx"
+
+      expect(TInternet)
+        .to receive(:execute)
+             .once do |request|
+        expect(request.uri.path).to match(/#{expected_path}$/)
+        fake_ok_response
+      end
+
+      client.put "/xxx", {}
+    end
+
+    context "initialize" do
+      let(:client) do
+        Client.new(
+          consumer_key: 'consumer_key',
+          consumer_secret: 'consumer_secret',
+          oauth_token: 'oauth_token',
+          oauth_token_secret: 'oauth_token_secret'
+        )
+      end
+
+      it "is configurable" do
+        expect(client.consumer_key).to eq('consumer_key')
+        expect(client.consumer_secret).to eq('consumer_secret')
+        expect(client.oauth_token).to eq('oauth_token')
+        expect(client.oauth_token_secret).to eq('oauth_token_secret')
+      end
+    end
+
+    describe "configure" do
+      it "sets key attributes through config block" do
+        client.configure do |config|
+          config.consumer_key = 'consumer_key'
+          config.consumer_secret = 'consumer_secret'
+          config.oauth_token = 'oauth_token'
+          config.oauth_token_secret = 'oauth_token_secret'
+        end
+
+        expect(client.consumer_key).to eq('consumer_key')
+        expect(client.consumer_secret).to eq('consumer_secret')
+        expect(client.oauth_token).to eq('oauth_token')
+        expect(client.oauth_token_secret).to eq('oauth_token_secret')
+      end
+    end
+  end
+end