github_api 0.12.3 → 0.12.4

data/spec/github/request/jsonize_spec.rb

@@ -1,89 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Request::Jsonize do
-
-  let(:middleware) { described_class.new(lambda { |env| env }) }
-
-  def process(body, content_type=nil)
-    env = {:body => body, :request_headers => {} }
-    env[:request_headers]['Content-Type'] = content_type if content_type
-    middleware.call(env)
-  end
-
-  def result_body() result[:body] end
-  def result_type() result[:request_headers]['Content-Type'] end
-
-  context 'no body' do
-    let(:result) { process(nil) }
-
-    it "returns empty object" do
-      expect(result_body).to be_nil
-    end
-
-    it "doesn't add content type" do
-      expect(result_type).to be_nil
-    end
-  end
-
-  context 'empty body' do
-    let(:result) { process('') }
-
-    it "returns empty object" do
-      expect(result_body).to eq('')
-    end
-
-    it "doesn't add content type" do
-      expect(result_type).to be_nil
-    end
-  end
-
-  context 'string body' do
-    let(:result) { process('{"a":1}')}
-
-    it "doesn't change body" do
-      result_body.should eql '{"a":1}'
-    end
-
-    it "adds content type" do
-      result_type.should eql 'application/json'
-    end
-  end
-
-  context "object body" do
-    let(:result) { process({:a => 1})}
-
-    it "encodes body" do
-      result_body.should eql '{"a":1}'
-    end
-
-    it "adds content type" do
-      result_type.should eql 'application/json'
-    end
-  end
-
-  context "empty object body" do
-    let(:result) { process({})}
-
-    it "encodes body" do
-      result_body.should eql '{}'
-    end
-
-    it "adds content type" do
-      result_type.should eql 'application/json'
-    end
-  end
-
-  context 'object body with json type' do
-    let(:result) { process({:a => 1}, 'application/json; charset=utf-8')}
-
-    it "encodes body" do
-      result_body.should eql '{"a":1}'
-    end
-
-    it "doesn't change content type" do
-      result_type.should eql 'application/json; charset=utf-8'
-    end
-  end
-end # Github::Request::Jsonize

data/spec/github/request/oauth2_spec.rb

@@ -1,72 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Request::OAuth2 do
-  include Github::Utils::Url
-
-  def auth_header(env)
-    env[:request_headers]['Authorization']
-  end
-
-  def middleware
-    described_class.new(lambda { |env| env }, options)
-  end
-
-  def process(params={}, headers={})
-    env = {
-      :url => URI('http://example.com/?' + build_query(params)),
-      :request_headers => headers
-    }
-    middleware.call(env)
-  end
-
-  context 'no token configured' do
-    let(:options) { nil }
-
-    it "doesn't add params" do
-      result = process(:q => 'query')
-      result[:url].query.should eql 'q=query'
-    end
-
-    it "doesn't add headers" do
-      auth_header(process).should be_nil
-    end
-
-    it "allows for ad hoc access token" do
-      result = process(:q => 'query', :access_token => 'abc123')
-      result[:url].query.should eql 'access_token=abc123&q=query'
-    end
-
-    it "creates header for ad hoc access token" do
-      result = process(:q => 'query', :access_token => 'abc123')
-      auth_header(result).should eql 'token abc123'
-    end
-  end
-
-  context 'default token configured' do
-    let(:options) { 'ABC' }
-
-    it "adds access token to params" do
-      result = process(:q => 'query')
-      result[:url].query.should eql 'access_token=ABC&q=query'
-    end
-
-    it "creates header for access token" do
-      auth_header(process).should eql 'token ABC'
-    end
-
-    it "overrides default with explicit token" do
-      result = process(:q => 'query', :access_token => 'abc123')
-      result[:url].query.should eql 'access_token=abc123&q=query'
-      auth_header(result).should eql 'token abc123'
-    end
-
-    it "clears default token with explicit one" do
-      result = process(:q => 'query', :access_token => nil)
-      result[:url].query.should eql 'q=query&access_token'
-      auth_header(result).should be_nil
-    end
-  end
-
-end # Github::Request::OAuth2

data/spec/github/request/request_spec.rb

@@ -1,36 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::API, '#request' do
-  let(:token)      { "2fdsfdo23fsdf3omkhen34n2jh" }
-  let(:per_page)   { 100 }
-  let(:path)       { "/api/v3/repos/GitHub/issues-dev/issues" }
-  let(:url_prefix) { "https://my-company/api/v3/repos/GitHub/issues-dev/issues?access_token=#{token}&page=2&per_page=#{per_page}" }
-
-  let(:conn) { Faraday::Connection.new }
-
-  before {
-    conn.url_prefix = url_prefix
-    stub_get(path, 'https://my-company').
-      with(:query => {'access_token' => token, :page => 2, :per_page => per_page}).
-      to_return(:body => "", :status => 200, :headers =>{})
-  }
-
-  subject { described_class.new() }
-
-  it 'sets connection path correctly' do
-    expect(conn.path_prefix).to eql(path)
-  end
-
-  it 'responds to get request' do
-    expect(subject).to respond_to(:get_request)
-  end
-
-  it 'handles enterprise uri correctly' do
-    instance = Github::Request.new(:get, path, subject)
-    instance.stub(:connection).and_return conn
-    Github::Request.stub(:new).and_return instance
-    expect { subject.get_request(path) }.not_to raise_error()
-  end
-end

data/spec/github/request_spec.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Request do
-  let(:github)   { Github::API.new  }
-  let(:path)     { 'github.api/repos/users' }
-  let(:params)   { {} }
-  let(:request)  { double('request') }
-  let(:response) { double('response').as_null_object }
-
-  it "knows how to make get request" do
-    expect(Github::Request).to receive(:new).with(:get, path, github) { request }
-    expect(request).to receive(:call).with(github.current_options, params) { double(auto_paginate: true) }
-    github.get_request path, params
-  end
-
-  it "knows how to make patch request" do
-    expect(Github::Request).to receive(:new).with(:patch, path, github) { request }
-    expect(request).to receive(:call).with(github.current_options, params)
-    github.patch_request path, params
-  end
-
-  it "knows how to make post request" do
-    expect(Github::Request).to receive(:new).with(:post, path, github) { request }
-    expect(request).to receive(:call).with(github.current_options, params)
-    github.post_request path, params
-  end
-
-  it "knows how to make put request" do
-    expect(Github::Request).to receive(:new).with(:put, path, github) { request }
-    expect(request).to receive(:call).with(github.current_options, params)
-    github.put_request path, params
-  end
-
-  it "knows how to make delete request" do
-    expect(Github::Request).to receive(:new).with(:delete, path, github) { request }
-    expect(request).to receive(:call).with(github.current_options, params)
-    github.delete_request path, params
-  end
-end # Github::Request

data/spec/github/response_wrapper/eql_spec.rb

@@ -1,92 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::ResponseWrapper, '#eql?' do
-  let(:env) {
-     { :status => 404, :body => 'some',
-      :response_headers => {'Content-Type' => 'text/plain'} }
-  }
-  let(:res) { Faraday::Response.new env }
-  let(:object) { described_class.new res, nil }
-
-  subject { object.eql?(other) }
-
-  context 'with the same object' do
-    let(:other) { object }
-
-    it { expect(object.body).to eql('some') }
-
-    it { should be_true }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with an equivalent object' do
-    let(:other) { object.dup }
-
-    it { should be_true }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with object having a nil body' do
-    let(:other_env) { { :body => nil }}
-    let(:other_res) { Faraday::Response.new other_env }
-    let(:other) { described_class.new(other_res, nil) }
-
-    it { expect(other.body).to be_nil }
-
-    it { should be_false }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with object having different body' do
-    let(:other_env) { { :body => ["some"] }}
-    let(:other_res) { Faraday::Response.new other_env }
-    let(:other) { described_class.new(other_res, nil) }
-
-    it { expect(other.body).to eql(["some"]) }
-
-    it { should be_false }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with object having no environment' do
-    let(:other) {
-      ::Class.new do
-        def body; ['some'] end
-      end.new
-    }
-
-    it { should be_false }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-
-  context 'with object having no body' do
-    let(:other) {
-      ::Class.new do
-        def env; end
-      end.new
-    }
-
-    it { should be_false }
-
-    it 'is symmetric' do
-      should eql(other.eql?(object))
-    end
-  end
-end

data/spec/github/response_wrapper/headers_spec.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::ResponseWrapper, '#headers' do
-  let(:env) {
-    { :response_headers => {
-      'Content-Type' => "application/json; charset=utf-8",
-      'X-RateLimit-Remaining' => '4999',
-      'X-RateLimit-Limit' => '5000',
-      'X-RateLimit-Reset' => '1422262420',
-      'content-length' => '344',
-      'ETag' => "\"d9a88f20567726e29d35c6fae87cef2f\"",
-      'Server' => "nginx/1.0.4",
-      'Date' => "Sun, 05 Feb 2012 15:02:34 GMT",
-    }, :body => ['some'], :status => 200 }
-  }
-  let(:res) { Faraday::Response.new env }
-  let(:object) { described_class.new res, nil }
-
-  subject { object.headers }
-
-  its(:content_type) { should match 'application/json' }
-
-  its(:content_length) { should match '344' }
-
-  its(:ratelimit_limit) { should == '5000' }
-
-  its(:ratelimit_remaining) { should == '4999' }
-
-  its(:ratelimit_reset) { should == '1422262420' }
-
-  its(:status) { should be 200 }
-
-  its(:etag) { should eql "\"d9a88f20567726e29d35c6fae87cef2f\"" }
-
-  its(:date) { should eql "Sun, 05 Feb 2012 15:02:34 GMT" }
-
-  its(:server) { should eql "nginx/1.0.4" }
-end

data/spec/github/response_wrapper/overwrites_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::ResponseWrapper, 'overwrites' do
-  let(:object) { described_class.new res, nil }
-  let(:env) {
-     { :status => 404, :body => body,
-      :response_headers => {'Content-Type' => 'text/plain'} }
-  }
-  let(:res) { Faraday::Response.new env }
-  let(:body) { {'id' => 2456210, 'fork' => false, 'type' => 'repo' } }
-
-  it { expect(object.id).to eql(2456210) }
-
-  it { expect(object.fork).to be_false }
-
-  it { expect(object.type).to eql('repo') }
-end

data/spec/github/response_wrapper_spec.rb

@@ -1,104 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::ResponseWrapper do
-  let(:github) { Github.new }
-  let(:user)   { 'wycats' }
-  let(:res)    { github.activity.events.public({ 'per_page' => 20 }) }
-  let(:pages)  { ['1', '5', '6'] }
-  let(:link) {
-    "<https://api.github.com/users/wycats/repos?page=6&per_page=20>; rel=\"last\", <https://api.github.com/users/wycats/repos?page=1&per_page=20>; rel=\"first\""
-  }
-
-  before do
-    stub_get("/events").
-      with(:query => { 'per_page' => '20' }).
-      to_return(:body => fixture('events/events.json'),
-        :status => 200,
-        :headers => {
-          :content_type => "application/json; charset=utf-8",
-          'X-RateLimit-Remaining' => '4999',
-          'X-RateLimit-Limit' => '5000',
-          'content-length' => '344',
-          'etag' => "\"d9a88f20567726e29d35c6fae87cef2f\"",
-          'server' => "nginx/1.0.4",
-          'Date' => "Sun, 05 Feb 2012 15:02:34 GMT",
-          'Link' => link
-        })
-
-    ['', '1', '5', '6'].each do |page|
-    params = page.empty? ? {'per_page'=>'20'} : {'per_page'=>'20', 'page'=>page}
-    stub_get("/users/#{user}/repos").
-      with(:query => params).
-      to_return(:body => fixture('events/events.json'),
-        :status => 200,
-        :headers => {
-          :content_type => "application/json; charset=utf-8",
-          'X-RateLimit-Remaining' => '4999',
-          'X-RateLimit-Limit' => '5000',
-          'content-length' => '344',
-          'Date' => "Sun, 05 Feb 2012 15:02:34 GMT",
-          'Link' => link
-        })
-    end
-  end
-
-  it "should assess successful" do
-    res.success?.should be_true
-  end
-
-  it "should read response body" do
-    res.body.should_not be_empty
-  end
-
-  context "pagination methods" do
-    let(:links)       { Github::PageLinks.new({}) }
-    let(:current_api) { double(:api).as_null_object }
-    let(:iterator)    { Github::PageIterator.new(links, current_api) }
-
-    before do
-      described_class.stub(:page_iterator).and_return iterator
-    end
-
-    it "should respond to links" do
-      res.links.should be_a Github::PageLinks
-    end
-
-    %w[ next prev ].each do |link|
-      context "#{link}_page" do
-        it "responds to #{link}_page request" do
-          res.send(:"#{link}_page").should be_nil
-        end
-
-        it 'should have no link information' do
-          res.links.send(:"#{link}").should be_nil
-        end
-      end
-    end
-
-    %w[ first last].each do |link|
-      context "#{link}_page" do
-        it "should return resource if exists" do
-          res.send(:"#{link}_page").should_not be_empty
-        end
-
-        it "should have link information" do
-          res.send(:"#{link}_page").should_not be_nil
-        end
-      end
-    end
-
-    it 'finds single page successfully' do
-      iterator.stub(:get_page).and_return res
-      res.page(5).should eq res
-    end
-
-    it 'checks if there are more pages' do
-      res.should_receive(:has_next_page?).and_return true
-      res.has_next_page?.should be_true
-    end
-
-  end # pagination
-
-end # Github::ResponseWrapper