github_api 0.8.11 → 0.9.0

data/lib/github_api/scopes.rb

@@ -11,7 +11,7 @@ module Github
     #
     def list(params={})
       response = get_request("/user", params)
-      response.oauth_scopes ? response.oauth_scopes.split(',') : response
+      response.headers.oauth_scopes ? response.headers.oauth_scopes.split(',') : response
     end
     alias :all :list
 

data/lib/github_api/search.rb

@@ -4,11 +4,6 @@ module Github
   class Search < API
     include Github::Utils::Url
 
-    # Creates new Search API
-    def initialize(options = {})
-      super(options)
-    end
-
     # Search issues
     #
     # Find issues by state and keyword.

data/lib/github_api/users.rb

@@ -20,24 +20,19 @@ module Github
       bio
     ].freeze
 
-    # Creates new Repos API
-    def initialize(options = {})
-      super(options)
-    end
-
     # Access to Users::Emails API
-    def emails
-      @emails ||= ApiFactory.new 'Users::Emails'
+    def emails(options={}, &block)
+      @emails ||= ApiFactory.new('Users::Emails', current_options.merge(options), &block)
     end
 
     # Access to Users::Followers API
-    def followers
-      @followers ||= ApiFactory.new 'Users::Followers'
+    def followers(options={}, &block)
+      @followers ||= ApiFactory.new('Users::Followers', current_options.merge(options), &block)
     end
 
     # Access to Users::Keys API
-    def keys
-      @keys ||= ApiFactory.new 'Users::Keys'
+    def keys(options={}, &block)
+      @keys ||= ApiFactory.new('Users::Keys', current_options.merge(options), &block)
     end
 
     # List all users.

data/lib/github_api/version.rb

@@ -3,8 +3,8 @@
 module Github
   module VERSION
     MAJOR = 0
-    MINOR = 8
-    PATCH = 11
+    MINOR = 9
+    PATCH = 0
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.');

data/spec/github/activity/notifications/get_spec.rb

@@ -30,7 +30,7 @@ describe Github::Activity::Notifications, '#get' do
 
     it "should return repository mash" do
       threads = subject.get thread_id
-      threads.should be_an Array
+      threads.should be_an Enumerable
       threads.should have(1).items
     end
 

data/spec/github/activity/starring/starred_spec.rb

@@ -40,7 +40,7 @@ describe Github::Activity::Starring, '#starred' do
 
     it "should return array of resources" do
       starred = subject.starred
-      starred.should be_an Array
+      starred.should be_an Enumerable
       starred.should have(1).items
     end
 

data/spec/github/activity/watching/watched_spec.rb

@@ -40,7 +40,7 @@ describe Github::Activity::Watching, '#watched' do
 
     it "should return array of resources" do
       watched = subject.watched
-      watched.should be_an Array
+      watched.should be_an Enumerable
       watched.should have(1).items
     end
 

data/spec/github/api_factory_spec.rb

@@ -4,28 +4,27 @@ require 'spec_helper'
 
 describe Github::ApiFactory do
 
+  subject(:factory) { described_class }
+
   context '#new' do
     it 'throws error if klass type is ommitted' do
-      expect { described_class.new nil }.to raise_error(ArgumentError)
+      expect { factory.new nil }.to raise_error(ArgumentError)
     end
 
     it 'instantiates a new object' do
-      described_class.new('Repos').should be_a Github::Repos
+      expect(factory.new('Repos')).to be_a Github::Repos
     end
   end
 
   context '#create_instance' do
-    it 'sets api client' do
-      instance = Github::Issues::Labels.new
-      Github.should_receive(:api_client=).twice().and_return instance
-      described_class.create_instance('Issues::Labels', {})
+    it 'creates class instance' do
+      expect(factory.create_instance('Issues::Labels', {})).to be_kind_of(Github::Issues::Labels)
     end
   end
 
   context '#convert_to_constant' do
     it 'knows how to convert nested classes' do
-      described_class.convert_to_constant('Issues::Labels').
-        should == Github::Issues::Labels
+      expect(factory.convert_to_constant('Issues::Labels')).to eql Github::Issues::Labels
     end
   end
 end # Github::ApiFactory

data/spec/github/api_spec.rb

@@ -39,13 +39,6 @@ describe Github::API do
     end
   end
 
-  context '_set_api_client' do
-    it 'should set instantiated api class as main api client' do
-      repos_instance = repos.new
-      Github.api_client.should eq repos_instance
-    end
-  end
-
   context 'normalize!' do
     before do
       @params = { 'a' => { :b => { 'c' => 1 }, 'd' => [ 'a', { :e => 2 }] } }

data/spec/github/authorization_spec.rb

@@ -6,17 +6,16 @@ describe Github::Authorization do
   let(:client_id) { '234jl23j4l23j4l' }
   let(:client_secret) { 'asasd79sdf9a7asfd7sfd97s' }
   let(:code) { 'c9798sdf97df98ds'}
-  let(:github) {
-    Github.new :client_id => client_id, :client_secret => client_secret
-  }
+  let(:options) { {} }
+
+  subject(:github) { Github.new options }
 
   after do
-    github.client_id, github.client_secret = nil, nil
     reset_authentication_for github
   end
 
   context '.client' do
-    it { github.should respond_to :client }
+    it { should respond_to :client }
 
     it "should return OAuth2::Client instance" do
       github.client.should be_a OAuth2::Client
@@ -39,12 +38,10 @@ describe Github::Authorization do
     let(:oauth) { OAuth2::Client.new(client_id, client_secret) }
 
     it "should throw an error if no client_id" do
-      github.client_id = nil
       expect { github.auth_code }.to raise_error(ArgumentError)
     end
 
     it "should throw an error if no client_secret" do
-      github.client_secret = nil
       expect { github.auth_code }.to raise_error(ArgumentError)
     end
 
@@ -57,9 +54,9 @@ describe Github::Authorization do
   end
 
   context "authorize_url" do
-    it "should respond to 'authorize_url' " do
-      github.should respond_to :authorize_url
-    end
+    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}/
@@ -75,14 +72,14 @@ describe Github::Authorization do
   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' " do
-      github.should respond_to :get_token
-    end
+    it { should respond_to(:get_token) }
 
     it "should make the authorization request" do
       expect {
@@ -97,11 +94,11 @@ describe Github::Authorization do
   end
 
   context ".authenticated?" do
-    it { github.should respond_to :authenticated? }
+    it { should respond_to(:authenticated?) }
 
     it "should return false if falied on basic authentication" do
       github.stub(:basic_authed?).and_return false
-      github.authenticated?.should be_false
+      expect(github.authenticated?).to be_false
     end
 
     it "should return true if basic authentication performed" do
@@ -120,7 +117,7 @@ describe Github::Authorization do
       github.stub(:basic_auth?).and_return false
     end
 
-    it { github.should respond_to :basic_authed? }
+    it { should respond_to(:basic_authed?) }
 
     it "should return false if login is missing" do
       github.stub(:login?).and_return false
@@ -130,41 +127,34 @@ describe Github::Authorization do
     it "should return true if login && password provided" do
       github.stub(:login?).and_return true
       github.stub(:password?).and_return true
-      github.basic_authed?.should be_true
+      expect(github.basic_authed?).to be_true
     end
   end
 
   context "authentication" do
-    it "should respond to 'authentication'" do
-      github.should respond_to :authentication
-    end
+    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
-      github.authentication.should be_empty
+      expect(github.authentication).to be_empty
     end
 
     context 'basic_auth' do
-      before do
-        github = Github.new :basic_auth => 'github:pass'
-      end
+      let(:options) { { :basic_auth => 'github:pass' } }
 
       it "should return hash with basic auth params" do
-        github.authentication.should be_a Hash
-        github.authentication.should have_key :basic_auth
+        expect(github.authentication).to be_a Hash
+        expect(github.authentication).to have_key(:basic_auth)
       end
     end
 
     context 'login & password' do
-      before do
-        github = Github.new :login => 'github', :password => 'pass'
-        github.basic_auth = nil
-      end
+      let(:options) { { :login => 'github', :password => 'pass' } }
 
       it "should return hash with login & password params" do
-        github.authentication.should be_a Hash
-        github.authentication.should have_key :login
+        expect(github.authentication).to be_a Hash
+        expect(github.authentication).to have_key(:login)
       end
     end
   end # authentication

data/spec/github/authorizations/create_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Authorizations, '#create' do
+  let(:basic_auth) { 'login:password' }
+  let(:request_path) { "/authorizations" }
+  let(:host) { "https://#{basic_auth}@api.github.com" }
+  let(:inputs) { { :scopes => ['repo'] } }
+
+  before {
+    stub_post(request_path, host).to_return(:body => body, :status => status,
+      :headers => {:content_type => "application/json; charset=utf-8"})
+  }
+
+  before { subject.basic_auth = basic_auth }
+
+  after { reset_authentication_for(subject) }
+
+  context "resouce created" do
+    let(:body) { fixture('auths/authorization.json') }
+    let(:status) { 201 }
+
+    it "should fail to get resource without basic authentication" do
+      reset_authentication_for subject
+      expect { subject.create }.to raise_error(ArgumentError)
+    end
+
+    it "should create resource successfully" do
+      subject.create inputs
+      a_post(request_path, host).with(inputs).should have_been_made
+    end
+
+    it "should return the resource" do
+      authorization = subject.create inputs
+      authorization.should be_a Github::ResponseWrapper
+    end
+
+    it "should get the authorization information" do
+      authorization = subject.create inputs
+      authorization.token.should == 'abc123'
+    end
+  end
+
+  it_should_behave_like 'request failure' do
+    let(:requestable) { subject.create inputs }
+  end
+
+end # create

data/spec/github/authorizations/delete_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Authorizations, '#delete' do
+  let(:basic_auth) { 'login:password' }
+  let(:request_path) { "/authorizations/#{authorization_id}" }
+  let(:host) { "https://#{basic_auth}@api.github.com" }
+  let(:authorization_id) { 1 }
+
+  before {
+    stub_delete(request_path, host).to_return(:body => body, :status => status,
+      :headers => {:content_type => "application/json; charset=utf-8"})
+  }
+
+  before { subject.basic_auth = basic_auth }
+
+  after { reset_authentication_for(subject) }
+
+  context "resouce deleted" do
+    let(:body) { '' }
+    let(:status) { 204 }
+
+    it "should fail to get resource without basic authentication" do
+      reset_authentication_for subject
+      expect { subject.delete nil }.to raise_error(ArgumentError)
+    end
+
+    it "should delete resource successfully" do
+      subject.delete authorization_id
+      a_delete(request_path, host).should have_been_made
+    end
+  end
+
+  it_should_behave_like 'request failure' do
+    let(:requestable) { subject.delete authorization_id }
+  end
+
+end # delete

data/spec/github/authorizations/get_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Authorizations, '#get' do
+  let(:basic_auth) { 'login:password' }
+  let(:request_path) { "/authorizations/#{authorization_id}" }
+  let(:host) { "https://#{basic_auth}@api.github.com" }
+  let(:authorization_id) { 1 }
+
+  before {
+    stub_get(request_path, host).to_return(:body => body, :status => status,
+      :headers => {:content_type => "application/json; charset=utf-8"})
+  }
+
+  before { subject.basic_auth = basic_auth }
+
+  after { reset_authentication_for(subject) }
+
+  context "resource found" do
+    let(:body) { fixture('auths/authorization.json') }
+    let(:status) { 200 }
+
+    it "should fail to get resource without authorization id" do
+      expect { subject.get nil }.to raise_error(ArgumentError)
+    end
+
+    it "should get the resource" do
+      subject.get authorization_id
+      a_get(request_path, host).should have_been_made
+    end
+
+    it "should get authorization information" do
+      authorization = subject.get authorization_id
+      authorization.id.should == authorization_id
+      authorization.token.should == 'abc123'
+    end
+
+    it "should return mash" do
+      authorization = subject.get authorization_id
+      authorization.should be_a Github::ResponseWrapper
+    end
+  end
+
+  it_should_behave_like 'request failure' do
+    let(:requestable) { subject.get authorization_id }
+  end
+
+end # list

data/spec/github/authorizations/list_spec.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Authorizations, '#list' do
+  let(:basic_auth) { 'login:password' }
+  let(:request_path) { "/authorizations" }
+  let(:host) { "https://#{basic_auth}@api.github.com" }
+
+  before {
+    stub_get(request_path, host).to_return(:body => body, :status => status,
+      :headers => {:content_type => "application/json; charset=utf-8"})
+  }
+
+  before { subject.basic_auth = basic_auth }
+
+  after { reset_authentication_for(subject) }
+
+  context "resource found" do
+    let(:body) { fixture('auths/authorizations.json') }
+    let(:status) { 200 }
+
+    it { should respond_to :all }
+
+    it "should fail to get resource without basic authentication" do
+      reset_authentication_for subject
+      expect { subject.list }.to raise_error(ArgumentError)
+    end
+
+    it "should get the resources" do
+      subject.list
+      a_get(request_path, host).should have_been_made
+    end
+
+    it_should_behave_like 'an array of resources' do
+      let(:requestable) { subject.list }
+    end
+
+    it "should get authorization information" do
+      authorizations = subject.list
+      authorizations.first.token.should == 'abc123'
+    end
+
+    it "should yield to a block" do
+      yielded = []
+      result = subject.list { |obj| yielded << obj }
+      yielded.should == result
+    end
+  end
+
+  it_should_behave_like 'request failure' do
+    let(:requestable) { subject.list }
+  end
+
+end # authorizations