github_api 0.12.3 → 0.12.4

data/spec/github/api_factory_spec.rb

@@ -1,30 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::API::Factory do
-
-  subject(:factory) { described_class }
-
-  context '#new' do
-    it 'throws error if klass type is ommitted' do
-      expect { factory.new nil }.to raise_error(ArgumentError)
-    end
-
-    it 'instantiates a new object' do
-      expect(factory.new('Client::Repos')).to be_a Github::Client::Repos
-    end
-  end
-
-  context '#create_instance' do
-    it 'creates class instance' do
-      expect(factory.create_instance('Client::Issues::Labels', {})).to be_kind_of(Github::Client::Issues::Labels)
-    end
-  end
-
-  context '#convert_to_constant' do
-    it 'knows how to convert nested classes' do
-      expect(factory.convert_to_constant('Client::Issues::Labels')).to eql(Github::Client::Issues::Labels)
-    end
-  end
-end # Github::ApiFactory

data/spec/github/api_spec.rb

@@ -1,39 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::API do
-  subject { described_class.new(options) }
-
-  it { described_class.included_modules.should include Github::Authorization }
-  it { described_class.included_modules.should include Github::MimeType }
-  it { described_class.included_modules.should include Github::Request::Verbs }
-
-  context 'actions' do
-    let(:options) { { } }
-    let(:repos) { Github::Client::Repos }
-
-    it { should respond_to :api_methods_in }
-
-    it 'dynamically adds actions inspection to classes inheriting from api' do
-      repos.should respond_to :actions
-      repos.new.should respond_to :actions
-    end
-
-    it 'ensures output contains api methods' do
-      methods = [ 'method_a', 'method_b']
-      repos.stub(:instance_methods).and_return methods
-      expect(subject.api_methods_in(repos)).to eq(['method_a', 'method_b'])
-    end
-  end
-
-  context 'process_basic_auth' do
-    let(:options) { { :basic_auth => 'login:password' } }
-
-    its(:login) { should eq 'login' }
-
-    its(:password) { should eq 'password' }
-
-    its(:basic_auth) { should eq 'login:password' }
-  end
-end # Github::API

data/spec/github/authorization_spec.rb

@@ -1,163 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Authorization do
-  let(:client_id) { '234jl23j4l23j4l' }
-  let(:client_secret) { 'asasd79sdf9a7asfd7sfd97s' }
-  let(:code) { 'c9798sdf97df98ds'}
-  let(:site) { 'http://github-ent.example.com/' }
-  let(:options) { {:site => site} }
-
-  subject(:github) { Github.new options }
-
-  after do
-    reset_authentication_for github
-  end
-
-  context '.client' do
-    it { should respond_to :client }
-
-    it "should return OAuth2::Client instance" do
-      github.client.should be_a OAuth2::Client
-    end
-
-    it "should assign site from the options hash" do
-      github.client.site.should == site
-    end
-
-    it "should assign 'authorize_url" do
-      github.client.authorize_url.should == "#{site}login/oauth/authorize"
-    end
-
-    it "should assign 'token_url" do
-      github.client.token_url.should == "#{site}login/oauth/access_token"
-    end
-  end
-
-  context '.auth_code' do
-    let(:oauth) { OAuth2::Client.new(client_id, client_secret) }
-
-    it "should throw an error if no client_id" do
-      expect { github.auth_code }.to raise_error(ArgumentError)
-    end
-
-    it "should throw an error if no client_secret" do
-      expect { github.auth_code }.to raise_error(ArgumentError)
-    end
-
-    it "should return authentication token code" do
-      github.client_id = client_id
-      github.client_secret = client_secret
-      github.client.stub(:auth_code).and_return code
-      github.auth_code.should == code
-    end
-  end
-
-  context "authorize_url" do
-    let(:options) { {:client_id => client_id, :client_secret => client_secret} }
-
-    it { should respond_to(:authorize_url) }
-
-    it "should return address containing client_id" do
-      github.authorize_url.should =~ /client_id=#{client_id}/
-    end
-
-    it "should return address containing scopes" do
-      github.authorize_url(:scope => 'user').should =~ /scope=user/
-    end
-
-    it "should return address containing redirect_uri" do
-      github.authorize_url(:redirect_uri => 'http://localhost').should =~ /redirect_uri/
-    end
-  end
-
-  context "get_token" do
-    let(:options) { {:client_id => client_id, :client_secret => client_secret} }
-
-    before do
-      stub_request(:post, 'https://github.com/login/oauth/access_token').
-        to_return(:body => '', :status => 200, :headers => {})
-    end
-
-    it { should respond_to(:get_token) }
-
-    it "should make the authorization request" do
-      expect {
-        github.get_token code
-        a_request(:post, "https://github.com/login/oauth/access_token").should have_been_made
-      }.to raise_error(OAuth2::Error)
-    end
-
-    it "should fail to get_token without authorization code" do
-      expect { github.get_token }.to raise_error(ArgumentError)
-    end
-  end
-
-  context ".authenticated?" do
-    it { should respond_to(:authenticated?) }
-
-    it "should return false if falied on basic authentication" do
-      github.stub(:basic_authed?).and_return false
-      expect(github.authenticated?).to be_false
-    end
-
-    it "should return true if basic authentication performed" do
-      github.stub(:basic_authed?).and_return true
-      github.authenticated?.should be_true
-    end
-
-    it "should return true if basic authentication performed" do
-      github.stub(:oauth_token?).and_return true
-      github.authenticated?.should be_true
-    end
-  end
-
-  context ".basic_authed?" do
-    before do
-      github.stub(:basic_auth?).and_return false
-    end
-
-    it { should respond_to(:basic_authed?) }
-
-    it "should return false if login is missing" do
-      github.stub(:login?).and_return false
-      github.basic_authed?.should be_false
-    end
-
-    it "should return true if login && password provided" do
-      github.stub(:login?).and_return true
-      github.stub(:password?).and_return true
-      expect(github.basic_authed?).to be_true
-    end
-  end
-
-  context "authentication" do
-    it { should respond_to(:authentication) }
-
-    it "should return empty hash if no basic authentication params available" do
-      github.stub(:login?).and_return false
-      github.stub(:basic_auth?).and_return false
-      expect(github.authentication).to be_empty
-    end
-
-    context 'basic_auth' do
-      let(:options) { { :basic_auth => 'github:pass' } }
-
-      it "should return hash with basic auth params" do
-        expect(github.authentication).to be_a Hash
-        expect(github.authentication).to have_key(:basic_auth)
-      end
-    end
-
-    context 'login & password' do
-      let(:options) { { :login => 'github', :password => 'pass' } }
-
-      it "should return hash with login & password params" do
-        expect(github.authentication).to be_a Hash
-        expect(github.authentication).to have_key(:login)
-      end
-    end
-  end # authentication
-
-end # Github::Authorization

data/spec/github/client/activity/events/issue_spec.rb

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Client::Activity::Events, '#issue' do
-  let(:user)   { 'peter-murach' }
-  let(:repo)   { 'github' }
-  let(:request_path) { "/repos/#{user}/#{repo}/issues/events" }
-  let(:body) { fixture('events/events.json') }
-  let(:status) { 200 }
-
-  before {
-    stub_get(request_path).to_return(:body => body, :status => status,
-      :headers => {:content_type => "application/json; charset=utf-8"})
-  }
-
-  after { reset_authentication_for subject }
-
-  context "resource found" do
-    it { should respond_to :issue_events }
-
-    it "should fail to get resource without username" do
-      expect { subject.issue nil, repo }.to raise_error(ArgumentError)
-    end
-
-    it "should get the resources" do
-      subject.issue user, repo
-      a_get(request_path).should have_been_made
-    end
-
-    it_should_behave_like 'an array of resources' do
-      let(:requestable) { subject.issue user, repo }
-    end
-
-    it "should get event information" do
-      events = subject.issue user, repo
-      events.first.type.should == 'Event'
-    end
-
-    it "should yield to a block" do
-      yielded = []
-      result = subject.issue(user, repo) { |obj| yielded << obj }
-      yielded.should == result
-    end
-  end
-
-  it_should_behave_like 'request failure' do
-    let(:requestable) { subject.issue user, repo }
-  end
-
-end # issue

data/spec/github/client/activity/events/network_spec.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Client::Activity::Events, '#network' do
-  let(:user)   { 'peter-murach' }
-  let(:repo)   { 'github' }
-  let(:request_path) { "/networks/#{user}/#{repo}/events" }
-  let(:body) { fixture('events/events.json') }
-  let(:status) { 200 }
-
-  before {
-    stub_get(request_path).to_return(:body => body, :status => status,
-      :headers => {:content_type => "application/json; charset=utf-8"})
-  }
-
-  after { reset_authentication_for subject }
-
-  context "resource found" do
-    it "should fail to get resource without username" do
-      expect { subject.network nil, repo }.to raise_error(ArgumentError)
-    end
-
-    it "should get the resources" do
-      subject.network user, repo
-      a_get(request_path).should have_been_made
-    end
-
-    it_should_behave_like 'an array of resources' do
-      let(:requestable) { subject.network user, repo }
-    end
-
-    it "should get event information" do
-      events = subject.network user, repo
-      events.first.type.should == 'Event'
-    end
-
-    it "should yield to a block" do
-      yielded = []
-      result = subject.network(user, repo) { |obj| yielded << obj }
-      yielded.should == result
-    end
-  end
-
-  it_should_behave_like 'request failure' do
-    let(:requestable) { subject.network user, repo }
-  end
-
-end # network

data/spec/github/client/activity/events/org_spec.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Client::Activity::Events, '#organization' do
-  let(:org) { 'github' }
-  let(:request_path) { "/orgs/#{org}/events" }
-  let(:body) { fixture('events/events.json') }
-  let(:status) { 200 }
-
-  before {
-    stub_get(request_path).to_return(:body => body, :status => status,
-      :headers => {:content_type => "application/json; charset=utf-8"})
-  }
-
-  after { reset_authentication_for subject }
-
-  context "resource found" do
-    it { should respond_to :organization }
-
-    it "should fail to get resource without orgname" do
-      expect { subject.organization }.to raise_error(ArgumentError)
-    end
-
-    it "should get the resources" do
-      subject.organization org
-      a_get(request_path).should have_been_made
-    end
-
-    it_should_behave_like 'an array of resources' do
-      let(:requestable) { subject.org org }
-    end
-
-    it "should get event information" do
-      events = subject.organization org
-      events.first.type.should == 'Event'
-    end
-
-    it "should yield to a block" do
-      yielded = []
-      result = subject.organization(org) { |obj| yielded << obj }
-      yielded.should == result
-    end
-  end
-
-  it_should_behave_like 'request failure' do
-    let(:requestable) { subject.organization org }
-  end
-
-end # org

data/spec/github/client/activity/events/performed_spec.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Client::Activity::Events, '#performed' do
-  let(:user)   { 'peter-murach' }
-  let(:request_path) { "/users/#{user}/events" }
-  let(:body) { fixture('events/events.json') }
-  let(:status) { 200 }
-
-  before {
-    stub_get(request_path).to_return(:body => body, :status => status,
-      :headers => {:content_type => "application/json; charset=utf-8"})
-  }
-
-  after { reset_authentication_for subject }
-
-  context "resource found" do
-
-    it "should fail to get resource without username" do
-      expect { subject.performed }.to raise_error(ArgumentError)
-    end
-
-    it "should get the resources" do
-      subject.performed user
-      a_get(request_path).should have_been_made
-    end
-
-    it_should_behave_like 'an array of resources' do
-      let(:requestable) { subject.performed user }
-    end
-
-    it "should get event information" do
-      events = subject.performed user
-      events.first.type.should == 'Event'
-    end
-
-    it "should yield to a block" do
-      yielded = []
-      result = subject.performed(user) { |obj| yielded << obj }
-      yielded.should == result
-    end
-  end
-
-  context "all public resources found" do
-    let(:request_path) { "/users/#{user}/events/public" }
-
-    it "should get the resources" do
-      subject.performed user, :public => true
-      a_get(request_path).should have_been_made
-    end
-
-    it_should_behave_like 'an array of resources' do
-      let(:requestable) { subject.performed user, :public => true }
-    end
-
-    it "should get event information" do
-      events = subject.performed user, :public => true
-      events.first.type.should == 'Event'
-    end
-
-    it "should yield to a block" do
-      yielded = []
-      result = subject.performed(user, :public => true) { |obj| yielded << obj }
-      yielded.should == result
-    end
-  end
-
-  it_should_behave_like 'request failure' do
-    let(:requestable) { subject.performed user }
-  end
-
-end # performed