github_api 0.3.4 → 0.3.5

data/spec/fixtures/users/user.json

@@ -1,32 +0,0 @@
-{
-  "login": "octocat",
-  "id": 1,
-  "avatar_url": "https://github.com/images/error/octocat_happy.gif",
-  "gravatar_id": "somehexcode",
-  "url": "https://api.github.com/users/octocat",
-  "name": "monalisa octocat",
-  "company": "GitHub",
-  "blog": "https://github.com/blog",
-  "location": "San Francisco",
-  "email": "octocat@github.com",
-  "hireable": false,
-  "bio": "There once was...",
-  "public_repos": 2,
-  "public_gists": 1,
-  "followers": 20,
-  "following": 0,
-  "html_url": "https://github.com/octocat",
-  "created_at": "2008-01-14T04:33:35Z",
-  "type": "User",
-  "total_private_repos": 100,
-  "owned_private_repos": 100,
-  "private_gists": 81,
-  "disk_usage": 10000,
-  "collaborators": 8,
-  "plan": {
-    "name": "Medium",
-    "space": 400,
-    "collaborators": 10,
-    "private_repos": 20
-  }
-}

data/spec/github/api_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Github::API do
-
-  let(:api) { Github::API.new }
-
-  before(:each) do
-    @params = { 'a' => { :b => { 'c' => 1 }, 'd' => [ 'a', { :e => 2 }] } }
-  end
-
-  it "should stringify all the keys inside nested hash" do
-    actual = api.send(:_normalize_params_keys, @params)
-    expected = { 'a' => { 'b'=> { 'c' => 1 }, 'd' => [ 'a', { 'e'=> 2 }] } }
-    actual.should == expected
-  end
-
-  it "should filter param keys" do
-    valid = ['a', 'b', 'e']
-    hash = {'a' => 1, 'b' => 3, 'c' => 2, 'd'=> 4, 'e' => 5 }
-    actual = api.send(:_filter_params_keys, valid, hash)
-    expected = {'a' => 1, 'b' => 3, 'e' => 5 }
-    actual.should == expected
-  end
-
-end

data/spec/github/authorization_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-
-describe Github::Authorization do
-
-  let(:client_id) { '234jl23j4l23j4l' }
-  let(:client_secret) { 'asasd79sdf9a7asfd7sfd97s' }
-  let(:code) { 'c9798sdf97df98ds'}
-  let(:github) { Github.new }
-
-  it "should instantiate oauth2 instance" do
-    github.client.should be_a OAuth2::Client
-  end
-
-  it "should assign site from the options hash" do
-    github.client.site.should == 'https://github.com'
-  end
-
-  it "should assign 'authorize_url" do
-    github.client.authorize_url.should == 'https://github.com/login/oauth/authorize'
-  end
-
-  it "should assign 'token_url" do
-    github.client.token_url.should == 'https://github.com/login/oauth/access_token'
-  end
-
-  context '.client' do
-    it { github.should respond_to :client }
-
-    it "should return OAuth2::Client instance" do
-      github.client.should be_a OAuth2::Client
-    end
-  end
-
-  context '.auth_code' do
-    let(:oauth) { OAuth2::Client.new(client_id, client_secret) }
-
-    before do
-      github = Github.new :client_id => client_id, :client_secret => client_secret
-    end
-
-    after do
-      github.client_id, github.client_secret = nil, nil
-    end
-
-    it "should throw an error if no client_id" do
-      github.client_id = nil
-      expect { github.auth_code }.should raise_error(ArgumentError)
-    end
-
-    it "should throw an error if no client_secret" do
-      github.client_secret = nil
-      expect { github.auth_code }.should 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
-    before do
-      github = Github.new :client_id => client_id, :client_secret => client_secret
-    end
-
-    it "should respond to 'authorize_url' " do
-      github.should respond_to :authorize_url
-    end
-
-    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
-    before do
-      github = Github.new :client_id => client_id, :client_secret => client_secret
-      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 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 { github.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
-    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
-    it { github.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
-      github.basic_authed?.should be_true
-    end
-  end
-
-  context "authentication" do
-    it "should respond to 'authentication'" do
-      github.should respond_to :authentication
-    end
-
-    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
-    end
-
-    context 'basic_auth' do
-      before do
-        github = Github.new :basic_auth => 'github:pass'
-      end
-
-      it "should return hash with basic auth params" do
-        github.authentication.should be_a Hash
-        github.authentication.should have_key :basic_auth
-      end
-    end
-
-    context 'login & password' do
-      before do
-        github = Github.new :login => 'github', :password => 'pass'
-      end
-
-      it "should return hash with login & password params" do
-        github.authentication.should be_a Hash
-        github.authentication.should have_key :login
-      end
-    end
-  end # authentication
-
-end # Github::Authorization

data/spec/github/authorizations_spec.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-
-describe Github::Authorizations do
-
-  let(:github) { Github.new }
-  let(:basic_auth) { 'login:password' }
-
-  before do
-    github.basic_auth = basic_auth
-  end
-
-  after do
-    reset_authentication_for github
-  end
-
-  describe "authorizations" do
-    context "resource found" do
-      before do
-        stub_get("/authorizations", "https://#{basic_auth}@api.github.com").
-          to_return(:body => fixture('auths/authorizations.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-
-      it "should fail to get resource without basic authentication" do
-        reset_authentication_for github
-        expect { github.oauth.authorizations }.to raise_error(ArgumentError)
-      end
-
-      it "should get the resources" do
-        github.oauth.authorizations
-        a_get("/authorizations", "https://#{basic_auth}@api.github.com").should have_been_made
-      end
-
-      it "should return array of resources" do
-        authorizations = github.oauth.authorizations
-        authorizations.should be_an Array
-        authorizations.should have(1).items
-      end
-
-      it "should be a mash type" do
-        authorizations = github.oauth.authorizations
-        authorizations.first.should be_a Hashie::Mash
-      end
-
-      it "should get authorization information" do
-        authorizations = github.oauth.authorizations
-        authorizations.first.token.should == 'abc123'
-      end
-
-      it "should yield to a block" do
-        github.oauth.should_receive(:authorizations).and_yield('web')
-        github.oauth.authorizations { |param| 'web' }
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/authorizations", "https://#{basic_auth}@api.github.com").
-          to_return(:body => "", :status => [404, "Not Found"])
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect { github.oauth.authorizations }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # authorizations
-
-  describe "authorization" do
-    let(:authorization_id) { 1 }
-
-    context "resource found" do
-      before do
-        stub_get("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").
-          to_return(:body => fixture('auths/authorization.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource without authorization id" do
-        expect { github.oauth.authorization nil }.to raise_error(ArgumentError)
-      end
-
-      it "should get the resource" do
-        github.oauth.authorization authorization_id
-        a_get("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").should have_been_made
-      end
-
-      it "should get authorization information" do
-        authorization = github.oauth.authorization authorization_id
-        authorization.id.should == authorization_id
-        authorization.token.should == 'abc123'
-      end
-
-      it "should return mash" do
-        authorization = github.oauth.authorization authorization_id
-        authorization.should be_a Hashie::Mash
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").
-          to_return(:body => fixture('auths/authorization.json'), :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to retrive resource" do
-        expect {
-          github.oauth.authorization authorization_id
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # authorization
-
-  describe "create_authorization" do
-    let(:inputs) { { :scopes => ['repo'] } }
-
-    context "resouce created" do
-
-      it "should fail to get resource without basic authentication" do
-        reset_authentication_for github
-        expect { github.oauth.create_authorization }.to raise_error(ArgumentError)
-      end
-
-      before do
-        stub_post("/authorizations", "https://#{basic_auth}@api.github.com").with(inputs).
-          to_return(:body => fixture('auths/authorization.json'), :status => 201, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should create resource successfully" do
-        github.oauth.create_authorization inputs
-        a_post("/authorizations", "https://#{basic_auth}@api.github.com").with(inputs).should have_been_made
-      end
-
-      it "should return the resource" do
-        authorization = github.oauth.create_authorization inputs
-        authorization.should be_a Hashie::Mash
-      end
-
-      it "should get the authorization information" do
-        authorization = github.oauth.create_authorization inputs
-        authorization.token.should == 'abc123'
-      end
-    end
-
-    context "failed to create resource" do
-      before do
-        stub_post("/authorizations", "https://#{basic_auth}@api.github.com").with(inputs).
-          to_return(:body => '', :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-
-      end
-
-      it "should fail to retrieve resource" do
-        expect {
-          github.oauth.create_authorization inputs
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # create_authorization
-
-  describe "update_authorization" do
-    let(:authorization_id) { 1 }
-    let(:inputs) { { :add_scopes => ['repo'] } }
-
-    context "resouce updated" do
-
-      it "should fail to get resource without basic authentication" do
-        reset_authentication_for github
-        expect { github.oauth.update_authorization }.to raise_error(ArgumentError)
-      end
-
-      before do
-        stub_patch("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").with(inputs).
-          to_return(:body => fixture('auths/authorization.json'), :status => 201, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should update resource successfully" do
-        github.oauth.update_authorization authorization_id, inputs
-        a_patch("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").with(inputs).should have_been_made
-      end
-
-      it "should return the resource" do
-        authorization = github.oauth.update_authorization authorization_id, inputs
-        authorization.should be_a Hashie::Mash
-      end
-
-      it "should get the authorization information" do
-        authorization = github.oauth.update_authorization authorization_id, inputs
-        authorization.token.should == 'abc123'
-      end
-    end
-
-    context "failed to update resource" do
-      before do
-        stub_patch("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").with(inputs).
-          to_return(:body => '', :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-
-      end
-
-      it "should fail to retrieve resource" do
-        expect {
-          github.oauth.update_authorization authorization_id, inputs
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # update_authorization
-
-  describe "delete_authorization" do
-    let(:authorization_id) { 1 }
-    let(:inputs) { { :add_scopes => ['repo'] } }
-
-    context "resouce deleted" do
-
-      it "should fail to get resource without basic authentication" do
-        reset_authentication_for github
-        expect { github.oauth.delete_authorization nil }.to raise_error(ArgumentError)
-      end
-
-      before do
-        stub_delete("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").
-          to_return(:body => '', :status => 204, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should delete resource successfully" do
-        github.oauth.delete_authorization authorization_id
-        a_delete("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").should have_been_made
-      end
-    end
-
-    context "failed to create resource" do
-      before do
-        stub_delete("/authorizations/#{authorization_id}", "https://#{basic_auth}@api.github.com").
-          to_return(:body => '', :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-
-      end
-
-      it "should fail to retrieve resource" do
-        expect {
-          github.oauth.delete_authorization authorization_id
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # delete_authorization
-
-end # Github::Authorizations