redbooth-ruby 0.0.2

data/spec/redbooth/request/base_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe Redbooth::Request::Base do
+  let(:consumer_key) { '_your_consumen_key_' }
+  let(:consumer_secret) { '_your_consumen_secret_' }
+  let(:info) { double(:info, session: session ) }
+  let(:session) { double(:session, valid?: true ) }
+  let(:request_base) { Redbooth::Request::Base.new(info) }
+  let(:connection) { double(:connection) }
+  let(:validator) { double(:validator) }
+
+  before :each do
+    allow(Redbooth::Request::Connection).to receive(:new).and_return(connection)
+    allow(Redbooth::Request::Validator).to receive(:new).and_return(validator)
+    Redbooth.config do |configuration|
+      configuration[:consumer_key] = consumer_key
+      configuration[:consumer_secret] = consumer_secret
+    end
+  end
+
+  describe "#perform" do
+    it 'raises AuthenticationError if request is not valid' do
+      allow(request_base).to receive(:valid?).and_return(false)
+      expect{request_base.perform}.to raise_error{ Redbooth::AuthenticationError }
+    end
+    it "performs an https request" do
+      allow_any_instance_of(Redbooth::Request::Base).to receive(:valid?).and_return(true)
+
+      expect(connection).to receive(:set_request_data)
+      expect(connection).to receive(:request)
+      expect(validator).to receive(:validated_response_for)
+
+      Redbooth::Request::Base.new(nil).perform
+    end
+  end
+
+  describe "#valid?" do
+    it 'is not valid if no info object given' do
+      expect(Redbooth::Request::Base.new(nil)).to_not be_valid
+    end
+    it 'is not valid if there is no session in info object' do
+      allow(info).to receive(:session).and_return(nil)
+      expect(request_base).to_not be_valid
+    end
+    it 'is not valid if session is invalid' do
+      allow(session).to receive(:valid?).and_return(false)
+      expect(request_base).to_not be_valid
+    end
+    it 'id valid othercase' do
+      expect(request_base).to be_valid
+    end
+  end
+end

data/spec/redbooth/request/collection_spec.rb

@@ -0,0 +1,104 @@
+require "spec_helper"
+
+describe Redbooth::Request::Collection, vcr: 'collection' do
+  include_context 'authentication'
+  let(:collection) { client.task(:index, per_page: 2) }
+
+  describe "#initialize" do
+    subject { collection }
+
+    it { should be_a Redbooth::Request::Collection }
+    it { expect(subject.response).to be_a(Redbooth::Request::Response) }
+    it { expect(subject.params).to be_a(Hash) }
+    it { expect(subject.method).to eql(:index) }
+    it { expect(subject.session).to eql(client.session) }
+    it { expect(subject.resource).to eql(Redbooth::Task) }
+  end
+
+  describe '#all' do
+    subject { collection.all }
+
+    it { should be_a Array }
+    it { expect(subject.first).to be_a(Redbooth::Task) }
+  end
+
+  describe '#total_pages' do
+    subject { collection.total_pages }
+
+    it { should be_a Integer }
+
+    context 'where endpoint is not paginated' do
+      before { collection.response.headers.delete('PaginationTotalPages') }
+
+      it { should be_nil }
+    end
+  end
+
+  describe '#per_page' do
+    subject { collection.per_page }
+
+    it { should be_a Integer }
+
+    context 'where endpoint is not paginated' do
+      before { collection.response.headers.delete('PaginationPerPage') }
+
+      it { should be_nil }
+    end
+  end
+
+  describe '#current_page' do
+    subject { collection.current_page }
+
+    it { should be_a Integer }
+
+    context 'where endpoint is not paginated' do
+      before { collection.response.headers.delete('PaginationCurrentPage') }
+
+      it { should be_nil }
+    end
+  end
+
+  describe '#count' do
+    subject { collection.count }
+
+    it { should be_a Integer }
+  end
+
+  describe '#next_page' do
+    subject { collection.next_page }
+
+    it { should be_a Redbooth::Request::Collection }
+
+    context 'where endpoint is not paginated' do
+      before { collection.response.headers.delete('PaginationCurrentPage') }
+
+      it { should be_nil }
+    end
+
+    context 'where is the last page' do
+      before { collection.response.headers['PaginationCurrentPage'] = collection.total_pages.to_s }
+
+      it { should be_nil }
+    end
+  end
+
+  describe '#prev_page' do
+    before { collection.response.headers['PaginationCurrentPage'] = 4 }
+    subject { collection.prev_page }
+
+    it { should be_a Redbooth::Request::Collection }
+
+    context 'where endpoint is not paginated' do
+      before { collection.response.headers.delete('PaginationCurrentPage') }
+
+      it { should be_nil }
+    end
+
+    context 'where is the first page' do
+      before { collection.response.headers['PaginationCurrentPage'] = 1 }
+
+      it { should be_nil }
+    end
+  end
+
+end

data/spec/redbooth/request/connection_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Redbooth::Request::Connection do
+  let(:consumer_key) { '_your_consumen_key_' }
+  let(:consumer_secret) { '_your_consumen_secret_' }
+  let(:access_token) do
+    {
+      token: '_your_user_token_',
+      secret: '_your_secret_token_'
+    }
+  end
+  let(:connection) { Redbooth::Request::Connection.new(info) }
+  let(:info) do
+    Redbooth::Request::Info.new(:get,
+                                nil,
+                                'user',
+                                {},
+                                { session: session }
+                               )
+  end
+  let(:client) { Redbooth::Client.new(session) }
+  let(:session) { Redbooth::Session.new(access_token) }
+  let(:redbooth_protocol) { Redbooth.configuration[:use_ssl] ? 'https' : 'http' }
+  let(:redbooth_url) { "#{redbooth_protocol}://#{Redbooth.configuration[:api_base]}/#{Redbooth.configuration[:api_base_path]}/#{Redbooth.configuration[:api_version]}" }
+
+  before :each do
+    Redbooth.config do |configuration|
+      configuration[:consumer_key] = consumer_key
+      configuration[:consumer_secret] = consumer_secret
+    end
+  end
+
+  describe '#set_request_data' do
+    it 'creates a request_data object' do
+      connection.set_request_data
+
+      expect(connection.request_data).to_not be_nil
+    end
+  end
+
+  describe '#request' do
+    it 'performs the actual request' do
+      connection.set_request_data
+      allow(connection).to receive(:set_request_data)
+
+      expect(connection.access_token).to receive(:send).with(*connection.request_data)
+
+      connection.request
+    end
+  end
+
+  describe '#request_data' do
+    it 'correctly formats the form data' do
+      info = double(
+        http_method: :post,
+        url: '/some/path',
+        data: params,
+        subdomain: Redbooth::DOMAIN_BASE,
+        session: session
+      )
+      connection = Redbooth::Request::Connection.new(info)
+      connection.set_request_data
+
+      expect(connection.request_data).to eq(
+        [
+          :post,
+          "#{redbooth_url}/some/path",
+          { body: { email: "abc_abc.com",
+                    event_types: ["user.created", "user.failed", "team.created", "documents.available"] }
+          }
+        ]
+      )
+    end
+  end
+
+  def params
+    {
+      email: "abc_abc.com",
+      event_types: ["user.created","user.failed", "team.created", "documents.available"]
+    }
+  end
+end

data/spec/redbooth/request/info_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Redbooth::Request::Info do
+  describe "#url" do
+    it "constructs the url" do
+      info = Redbooth::Request::Info.new(:get, nil, "random", {id: 1} )
+
+      expect(info.url).to match /random/
+    end
+  end
+
+  describe "#path_with_params" do
+    it "does nothing when no params" do
+      info = Redbooth::Request::Info.new(:get, nil, "random", nil)
+      path = "/path/to/someplace"
+
+      expect(info.path_with_params(path, {})).to eq path
+    end
+
+    it "constructs the path with params" do
+      info = Redbooth::Request::Info.new(:get, nil, "random", nil)
+      path = "/path/to/someplace"
+
+      expect(info.path_with_params(path, {random: "stuff"})).to eq "#{path}?random=stuff"
+    end
+  end
+end

data/spec/redbooth/request/response_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Redbooth::Request::Response do
+  let(:headers) { {} }
+  let(:status) { 200 }
+  let(:body) { '{"response":"ok"}' }
+  let(:response) { Redbooth::Request::Response.new(body: body,
+                                                   status: status,
+                                                   headers: headers) }
+
+  describe "#initialize" do
+    subject { response }
+
+    it { should be_a Redbooth::Request::Response }
+    it { expect(subject.data).to eq("response" => "ok") }
+    it { expect(subject.body).to eq(body) }
+    it { expect(subject.headers).to eq(headers) }
+    it { expect(subject.status).to eq(status) }
+
+    context 'with wrong json body' do
+      let(:body) { '<html> asdfasdf </html>' }
+
+      it { expect(subject.data).to be_empty }
+    end
+
+    context 'with empty body' do
+      let(:body) { nil }
+
+      it { expect(subject.data).to be_empty }
+    end
+  end
+end

data/spec/redbooth/request/validator_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Redbooth::Request::Validator do
+  let(:info) { Redbooth::Request::Info.new(:get, nil, "random", OpenStruct.new(id: 1)) }
+  let(:validator) { Redbooth::Request::Validator.new info }
+  let(:headers) { {} }
+  let(:response) { OpenStruct.new(body: '{"response":"ok"}', status: 200, headers: headers) }
+
+  describe "#validated_response_for" do
+    subject { validator.validated_response_for(response) }
+
+    it { should be_a Redbooth::Request::Response }
+    it { expect(subject.data).to eq("response" => "ok") }
+
+    context 'where 401 status code returned' do
+      let(:response) { OpenStruct.new(body: '{"error":{"message":"Unauthorized"}}', status: 401, headers: headers) }
+
+      it { expect{subject}.to raise_error(Redbooth::AuthenticationError) }
+
+      context 'where token was expired' do
+        before { headers['WWW-Authenticate'] = %{Bearer realm="Doorkeeper", error="invalid_token", error_description="The access token was expired"} }
+
+        it { expect{subject}.to raise_error(Redbooth::OauhtTokenExpired) }
+      end
+
+      context 'where token was revoked' do
+        before { headers['WWW-Authenticate'] = %{Bearer realm="Doorkeeper", error="invalid_token", error_description="The access token was revoked"} }
+
+        it { expect{subject}.to raise_error(Redbooth::OauhtTokenRevoked) }
+      end
+    end
+
+    context 'where 500 status code returned' do
+      let(:response) { OpenStruct.new(body: '{"error":{"message":"Something went wrong"}}', status: 500, headers: headers) }
+
+      it { expect{subject}.to raise_error(Redbooth::APIError) }
+    end
+
+    context 'where 404 status code returned' do
+      let(:response) { OpenStruct.new(body: '{"error":{"message":"There is no task with the given id in the system"}}', status: 404, headers: headers) }
+
+      it { expect{subject}.to raise_error(Redbooth::NotFound) }
+    end
+  end
+end

data/spec/redbooth/task_spec.rb

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+describe Redbooth::Task, vcr: 'tasks' do
+  include_context 'authentication'
+
+  let(:create_task_params) do
+    { project_id: 2,
+      name: 'new created task',
+      task_list_id: 3 }
+  end
+  let(:new_task) { Redbooth::Task.create(create_task_params.merge(session: session)) }
+  let(:task) do
+    Redbooth::Task.show(session: session, id: 1)
+  end
+
+  describe "#initialize" do
+    subject { task }
+
+    it { expect(subject.id).to eql 1 }
+    it { expect(subject.name).to eql 'Register all EarthworksYoga TLDs' }
+    it { expect(subject.description).to eql 'The ships hung in the sky in much the same way that bricks don\'t.' }
+    it { expect(subject.project_id).to eql 2 }
+    it { expect(subject.assigned_id).to eql 8 }
+    it { expect(subject.due_on).to eql '2014-11-04' }
+  end
+
+  describe ".show" do
+    it "makes a new GET request using the correct API endpoint to receive a specific task" do
+      expect(Redbooth).to receive(:request).with(:get, nil, "tasks/1", {}, { session: session }).and_call_original
+      task
+    end
+    it 'returns a task with the correct name' do
+      expect(task.name).to eql('Register all EarthworksYoga TLDs')
+    end
+    it 'returns a task with the correct id' do
+      expect(task.id).to eql(1)
+    end
+    it 'returns a task with the correct project_id' do
+      expect(task.project_id).to eql(2)
+    end
+    it 'returns a task with the correct assigned_id' do
+      expect(task.assigned_id).to eql(8)
+    end
+  end
+
+  describe ".update" do
+    subject { Redbooth::Task.update(session: session, id: 2, name: 'new test name') }
+
+    it "makes a new PUT request using the correct API endpoint to receive a specific task" do
+      expect(Redbooth).to receive(:request).with(:put, nil, "tasks/2", { name: 'new test name' }, { session: session }).and_call_original
+      subject
+    end
+
+    it { expect(subject.name).to eql 'new test name' }
+    it { expect(subject.id).to eql 2 }
+  end
+
+  describe ".create" do
+    subject { new_task }
+
+    it "makes a new POST request using the correct API endpoint to create a specific task" do
+      expect(Redbooth).to receive(:request).with(:post, nil, "tasks", create_task_params, { session: session }).and_call_original
+      subject
+    end
+
+    it { expect(subject.name).to eql 'new created task' }
+    it { expect(subject.project_id).to eql 2 }
+    it { expect(subject.task_list_id).to eql 3 }
+  end
+
+  describe ".delete" do
+    subject { Redbooth::Task.delete(session: session, id: new_task.id) }
+
+    it "makes a new DELETE request using the correct API endpoint to delete a specific task" do
+      expect(Redbooth).to receive(:request).with(:delete, nil, "tasks/#{new_task.id}", {}, { session: session }).and_call_original
+      subject
+    end
+  end
+
+  describe ".index" do
+    subject { Redbooth::Task.index(session: session) }
+
+    it "makes a new PUT request using the correct API endpoint to receive a specific task" do
+      expect(Redbooth).to receive(:request).with(:get, nil, "tasks", {}, { session: session }).and_call_original
+      subject
+    end
+
+    it { expect(subject.class).to eql Redbooth::Request::Collection }
+  end
+end

data/spec/redbooth/user_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Redbooth::User, vcr: 'users' do
+  include_context 'authentication'
+
+  let(:user) do
+    Redbooth::User.show(session: session, id: 1)
+  end
+
+  describe "#initialize" do
+    subject { user }
+
+    it { expect(subject.email).to eql('example_frank@redbooth.com') }
+    it { expect(subject.id).to eql(1) }
+    it { expect(subject.first_name).to eql('Frank') }
+    it { expect(subject.last_name).to eql('Kramer') }
+  end
+
+  describe ".show" do
+    subject { Redbooth::User.show(session: session, id: 1) }
+
+    it 'makes a new GET request using the correct API endpoint to receive a specific user' do
+      expect(Redbooth).to receive(:request).with(:get, nil, "users/1", {}, { session: session }).and_call_original
+      subject
+    end
+
+    it { expect(subject.email).to eql('example_frank@redbooth.com') }
+    it { expect(subject.id).to eql(1) }
+    it { expect(subject.first_name).to eql('Frank') }
+    it { expect(subject.last_name).to eql('Kramer') }
+  end
+end