USER_PATH = "user.json"

DEAUTH_PATH = "user/deauthorize.json"

def deauthorize

return nil unless verify_token

get_get_response( build_url(DEAUTH_PATH) )

end

def deauthorize

success_json = @user_api.deauthorize

record_err(@user_api)

is_success?(success_json)

end

sched_array.deep_symbolize_keys!

extract_key(new_order_json, "updates")

end

def shuffle_updates(id, options = {})

shuffle_json = @update_api.shuffle_updates(id, options)

record_err(@update_api)

extract_key(shuffle_json, "updates")

def extract_key(json, key)

return json[key] if json.present?

end

Modelled after [Octokit](https://github.com/octokit/octokit.rb) <3, this is a lightweight client for the [Buffer API](https://buffer.com/developers/api), which is intended to return (mostly) JSON as opposed to objects.

[](https://travis-ci.org/kaneda/buffer-ruby)

* [OAuth](https://buffer.com/developers/api/oauth)

* [Users](https://buffer.com/developers/api/user)

* [Profiles](https://buffer.com/developers/api/profiles)

* [Updates](https://buffer.com/developers/api/updates)

* [Links](https://buffer.com/developers/api/links)

* [Info](https://buffer.com/developers/api/info)

* [Errors](https://buffer.com/developers/api/errors)

* Automated builds through Travis-CI

* Automated tests using RSpec

auth_tok = buffer_client.get_auth_token

:auth_token => auth_tok

| Client call | Input | Output | Notes

| :---------: | :------ | :------ | :---------

| [get_auth_token](https://buffer.com/developers/api/oauth) | | Auth Token:String | ENV variables "BUFFER_KEY" and "BUFFER_SECRET" must be defined here |

| get_user_id | | ID:String | Convenience wrapper, calls get_user_json under the hood |

| [get_user_json](https://buffer.com/developers/api/user#user) | | User:Hash | |

| [deauthorize](https://buffer.com/developers/api/user#deauthorize) | | Success:Boolean | |

| [get_user_profiles](https://buffer.com/developers/api/profiles#profiles) | | Profiles:Array<Hash> | |

| [get_user_profile](https://buffer.com/developers/api/profiles#profilesid) | Profile ID:String | Profile:Hash | |

| [get_schedule](https://buffer.com/developers/api/profiles#schedules) | Profile ID:String | Schedule:Hash | |

| [update_schedule](https://buffer.com/developers/api/profiles#schedulesupdate) | Profile ID:String, Schedule:Hash | Success:Boolean | See below for schedule representation |

| [get_update](https://buffer.com/developers/api/updates#updatesid) | Social Media Post ID:String | Update:Hash | |

| [get_pending_updates](https://buffer.com/developers/api/updates#updatespending) | Profile ID:String, Options:Hash (optional) | UpdateResult:Hash | See Buffer API doc (link to the left) for optional parameters. "updates" key contains the Updates:Array<Hash> |

| [get_sent_updates](https://buffer.com/developers/api/updates#updatessent) | Profile ID:String, Options:Hash (optional) | UpdateResult:Hash | See Buffer API doc (link to the left) for optional parameters. "updates" key contains the Updates:Array<Hash> |

| [get_interactions](https://buffer.com/developers/api/updates#updatesinteractions) | Social Media Post ID:String, Event:ENUM, Options:Hash (optional) | Interactions:Hash | See [event types](https://bufferapp.com/developers/api/info#configuration) for possible event values and Buffer API doc (link to the left) for optional parameters. "interactions" key contains the Interactions:Array<Hash> |

| [reorder_updates](https://buffer.com/developers/api/updates#updatesreorder) | Profile ID:String, Updates:Array, Options:Hash (optional) | Updates:Array<Hash> | |

| [shuffle_updates](https://buffer.com/developers/api/updates#updatesshuffle) | Profile ID:String, Options:Hash (optional) | Updates:Array<Hash> | |

| [create_update](https://buffer.com/developers/api/updates#updatescreate) | Profile IDs:Array, Options:Hash (optional) | Update:Hash | Note that for the "media" option, please specify each media option in the hash separately, e.g. ```{ "media[link]" => "http%3A%2F%2Fgoogle.com", "media[description]" => "The%20google%20homepage" }```. See all available options in the Buffer docs (link to the left) |

| [update_status](https://buffer.com/developers/api/updates#updatesupdate) | Social Media Post ID:String, Text:String, Options:Hash (optional) | Update:Hash | For the "media" option see the note on create_update above |

| [share_update](https://buffer.com/developers/api/updates#updatesshare) | Social Media Post ID:String | Success:Boolean | |

| [destroy_update](https://buffer.com/developers/api/updates#updatesdestroy) | Social Media Post ID:String | Success:Boolean | |

| [move_to_top](https://buffer.com/developers/api/updates#updatesmovetotop) | Social Media Post ID:String | Success:Boolean | |

| [get_shares](https://buffer.com/developers/api/links#shares) | Unencodded URL:String | Shares:Integer | You can pass a normal URL here, the client will encode it. This is one of the only calls to not require an auth_token |

| [get_configuration](https://buffer.com/developers/api/info#configuration) | | Configuration:Hash | "services" key has internal keys for each service |

Note that you can make the keys symbols or strings, the client will accept either one.

4. Once approved [squash your commits](http://davidwalsh.name/squash-commits-git)

Twitter: [@kanedasan](https://twitter.com/kanedasan)

require 'action_dispatch'

require 'uri'

require_relative '../../../../lib/api/helpers/api_helpers.rb'

describe ApiHelpers do

let(:base_api) { build(:base_api) }

let(:options) do

{

:key => "value",

:key_2 => "value_2"

}

end

let(:err) { "An error" }

describe "#build_options_string" do

let(:path_regex) do

/\A(\w+=[\w\d]+(&\w+=[\w\d]+)+)*\Z/

end

it "returns a string representing a valid path" do

expect(base_api.build_options_string(options)).to match(path_regex)

end

end

describe "#build_url" do

let(:path) { "some_path" }

let(:auth_tok) { "123456789" }

it "returns a valid URL when given only a path" do

expect(base_api.build_url(path, {}, false)).to match(URI::regexp)

end

it "returns a valid URL when given a path and options" do

expect(base_api.build_url(path, options, false)).to match(URI::regexp)

end

it "returns a valid URL when given a path and an auth token" do

base_api.instance_variable_set(:@auth_token, auth_tok)

expect(base_api.build_url(path)).to match(URI::regexp)

end

it "returns a valid URL when given a path, options, and an auth token" do

base_api.instance_variable_set(:@auth_token, auth_tok)

expect(base_api.build_url(path, options)).to match(URI::regexp)

end

end

describe "#set_err" do

let(:response_code) { "403" }

let(:err) { "An error" }

let(:err_2) { "A second err" }

let(:json_with_error) { { "error" => err } }

let(:json_with_code) { { "code" => "1001" } }

let(:json_with_other) { { "other" => "stuff" } }

it "returns the default error when response is blank" do

expect(base_api.set_err(response_code, {})).to eq(ApiHelpers::DEFAULT_ERR)

end

it "returns an error when the error key is present in the response" do

expect(base_api.set_err(response_code, json_with_error)).to eq(err)

end

it "returns another error when only the code key is present" do

allow_any_instance_of(BaseApi).to receive(:get_error_message).and_return(err_2)

expect(base_api.set_err(response_code, json_with_code)).to eq(err_2)

end

it "returns the default error when response is present but neither error nor code is present" do

expect(base_api.set_err(response_code, json_with_other)).to eq(ApiHelpers::DEFAULT_ERR)

end

end

describe "#has_data?" do

let(:empty_response) do

ActionDispatch::Response.new(500, {}, "")

end

let(:valid_response) do

ActionDispatch::Response.new(200, {}, "A body")

end

it "returns false when passed a blank response" do

expect(base_api.has_data?(empty_response)).to eq(false)

end

it "returns true when passed a response with a body" do

expect(base_api.has_data?(valid_response)).to eq(true)

end

end

describe "#parse_data" do

let(:bad_json) { '{"foo": "bar"' }

let(:bad_json_err) { "Failed to parse JSON return from Buffer" }

let(:bad_response) do

ActionDispatch::Response.new(403, {}, bad_json)

end

let(:good_json) { "#{bad_json} }" }

let(:good_response) do

ActionDispatch::Response.new(200, {}, good_json)

end

it "returns nil and sets @error if the response is invalid JSON" do

json = base_api.parse_data(bad_response)

expect(json).to be_nil

expect(base_api.error).to include(bad_json_err)

end

it "returns a hash when passed good JSON" do

json = base_api.parse_data(good_response)

expect(json).to be_present

expect(json.is_a?(Hash)).to eq(true)

end

end

describe "#get_error_message" do

let(:event_err) { "Event type not supported." }

let(:http_code) { "400" }

let(:err_code) { "1029" }

it "returns the event err when the given codes are passed" do

expect(base_api.get_error_message(http_code, err_code)).to eq(event_err)

end

it "returns the default error when the http code is unknown" do

expect(base_api.get_error_message("10101", err_code)).to eq(ApiHelpers::DEFAULT_ERR)

end

it "returns the default error when the error code is unknown" do

expect(base_api.get_error_message(http_code, "10101")).to eq(ApiHelpers::DEFAULT_ERR)

end

end

require_relative '../../../lib/api/update_api.rb'

describe UpdateApi do

let(:update_api) { build(:update_api) }

let(:id) { "123456789" }

let(:path) { "some_path" }

before(:each) do

allow_any_instance_of(UpdateApi).to receive(:verify_token).and_return(true)

end

describe "#build_profile_url" do

it "returns a proper profile URL" do

expected_val = "#{UpdateApi::PROFILE_PATH}/#{id}/#{path}"

expect(update_api.send(:build_profile_url, id, path)).to include(expected_val)

end

end

describe "#build_update_url" do

it "returns a proper update URL" do

expected_val = "#{UpdateApi::UPDATE_PATH}/#{id}/#{path}"

expect(update_api.send(:build_update_url, id, path)).to include(expected_val)

end

end