github_api 0.3.4 → 0.3.5

data/spec/github/gists/comments_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::Gists::Comments do
-  pending
-end

data/spec/github/gists_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::Gists do
-  pending
-end

data/spec/github/git_data/blobs_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::GitData::Blobs do
-  pending
-end

data/spec/github/git_data/commits_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::GitData::Commits do
-  pending
-end

data/spec/github/git_data/references_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::GitData::References do
-  pending
-end

data/spec/github/git_data/tags_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::GitData::Tags do
-  pending
-end

data/spec/github/git_data/trees_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::GitData::Trees do
-  pending
-end

data/spec/github/git_data_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::GitData do
-  pending
-end

data/spec/github/issues/comments_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::Issues::Comments do
-  pending
-end

data/spec/github/issues/events_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::Issues::Events do
-  pending
-end

data/spec/github/issues/labels_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::Issues::Labels do
-  pending
-end

data/spec/github/issues/milestones_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-describe Github::Issues::Milestones do
-  pending
-end

data/spec/github/issues_spec.rb

@@ -1,287 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Issues do
-
-  let(:issues_api) { Github::Issues }
-  let(:github) { Github.new }
-  let(:user)   { 'peter-murach' }
-  let(:repo)   { 'github' }
-
-  describe 'modules inclusion' do
-    it { issues_api.included_modules.should include Github::Issues::Comments }
-    it { issues_api.included_modules.should include Github::Issues::Events }
-    it { issues_api.included_modules.should include Github::Issues::Labels }
-    it { issues_api.included_modules.should include Github::Issues::Milestones }
-  end
-
-  describe 'issues' do
-    it { github.issues.should respond_to :issues }
-    it { github.issues.should respond_to :list_issues }
-
-    context "resource found" do
-      before do
-        stub_get("/issues").
-          to_return(:body => fixture('issues/issues.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should get the resources" do
-        github.issues.issues
-        a_get("/issues").should have_been_made
-      end
-
-      it "should return array of resources" do
-        issues = github.issues.issues
-        issues.should be_an Array
-        issues.should have(1).items
-      end
-
-      it "should be a mash type" do
-        issues = github.issues.issues
-        issues.first.should be_a Hashie::Mash
-      end
-
-      it "should get issue information" do
-        issues = github.issues.issues
-        issues.first.title.should == 'Found a bug'
-      end
-
-      it "should yield to a block" do
-        github.issues.should_receive(:issues).and_yield('web')
-        github.issues.issues { |param| 'web' }.should == 'web'
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/issues").
-          to_return(:body => "", :status => [404, "Not Found"])
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect { github.issues.issues }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # issues
-
-  describe 'repo_issues' do
-    it { github.issues.should respond_to :repo_issues }
-    it { github.issues.should respond_to :list_repo_issues }
-    it { github.issues.should respond_to :list_repository_issues }
-
-    context "resource found" do
-      before do
-        github.user, github.repo = nil, nil
-        stub_get("/repos/#{user}/#{repo}/issues").
-          to_return(:body => fixture('issues/issues.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should raise error if user-name empty" do
-        expect {
-          github.issues.repo_issues nil, repo
-        }.should raise_error(ArgumentError)
-      end
-
-      it "should get the resources" do
-        github.issues.repo_issues user, repo
-        a_get("/repos/#{user}/#{repo}/issues").should have_been_made
-      end
-
-      it "should return array of resources" do
-        repo_issues = github.issues.repo_issues user, repo
-        repo_issues.should be_an Array
-        repo_issues.should have(1).items
-      end
-
-      it "should be a mash type" do
-        repo_issues = github.issues.repo_issues user, repo
-        repo_issues.first.should be_a Hashie::Mash
-      end
-
-      it "should get repository issue information" do
-        repo_issues = github.issues.repo_issues user, repo
-        repo_issues.first.title.should == 'Found a bug'
-      end
-
-      it "should yield to a block" do
-        github.issues.should_receive(:issues).with(user, repo).and_yield('web')
-        github.issues.issues(user, repo) { |param| 'web' }.should == 'web'
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/issues").
-          to_return(:body => "", :status => [404, "Not Found"])
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect {
-          github.issues.repo_issues user, repo
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # repo_issues
-
-  describe "get_issue" do
-    let(:issue_id) { 1347 }
-
-    it { github.issues.should respond_to :issue }
-    it { github.issues.should respond_to :get_issue }
-
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/issues/#{issue_id}").
-          to_return(:body => fixture('issues/issue.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource without issue id" do
-        expect { github.issues.issue(user, repo, nil)}.to raise_error(ArgumentError)
-      end
-
-      it "should get the resource" do
-        github.issues.issue user, repo, issue_id
-        a_get("/repos/#{user}/#{repo}/issues/#{issue_id}").should have_been_made
-      end
-
-      it "should get issue information" do
-        issue = github.issues.issue user, repo, issue_id
-        issue.number.should == issue_id
-        issue.title.should == 'Found a bug'
-      end
-
-      it "should return mash" do
-        issue = github.issues.issue user, repo, issue_id
-        issue.should be_a Hashie::Mash
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/issues/#{issue_id}").
-          to_return(:body => fixture('issues/issue.json'), :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to retrive resource" do
-        expect {
-          github.issues.issue user, repo, issue_id
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # get_issue
-
-  describe "create_issue" do
-    let(:inputs) {
-      {
-         "title" =>  "Found a bug",
-         "body" => "I'm having a problem with this.",
-         "assignee" =>  "octocat",
-         "milestone" => 1,
-         "labels" => [
-           "Label1",
-           "Label2"
-         ]
-      }
-    }
-    context "resouce created" do
-      before do
-        stub_post("/repos/#{user}/#{repo}/issues").with(inputs).
-          to_return(:body => fixture('issues/issue.json'), :status => 201, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to create resource if 'title' input is missing" do
-        expect {
-          github.issues.create_issue user, repo, inputs.except('title')
-        }.to raise_error(ArgumentError)
-      end
-
-      it "should create resource successfully" do
-        github.issues.create_issue user, repo, inputs
-        a_post("/repos/#{user}/#{repo}/issues").with(inputs).should have_been_made
-      end
-
-      it "should return the resource" do
-        issue = github.issues.create_issue user, repo, inputs
-        issue.should be_a Hashie::Mash
-      end
-
-      it "should get the issue information" do
-        issue = github.issues.create_issue(user, repo, inputs)
-        issue.title.should == 'Found a bug'
-      end
-    end
-
-    context "failed to create resource" do
-      before do
-        stub_post("/repos/#{user}/#{repo}/issues").with(inputs).
-          to_return(:body => fixture('issues/issue.json'), :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should faile to retrieve resource" do
-        expect {
-          github.issues.create_issue user, repo, inputs
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # create_issue
-
-  describe "edit_issue" do
-    let(:issue_id) { 1349 }
-    let(:inputs) {
-      {
-         "title" =>  "Found a bug",
-         "body" => "I'm having a problem with this.",
-         "assignee" =>  "octocat",
-         "milestone" => 1,
-         "labels" => [
-           "Label1",
-           "Label2"
-         ]
-      }
-    }
-
-    context "resource edited successfully" do
-      before do
-        stub_patch("/repos/#{user}/#{repo}/issues/#{issue_id}").with(inputs).
-          to_return(:body => fixture("issues/issue.json"), :status => 200, :headers => { :content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to edit without 'user/repo' parameters" do
-        github.user, github.repo = nil, nil
-        expect {
-          github.issues.edit_issue nil, repo, issue_id
-        }.to raise_error(ArgumentError)
-      end
-
-      it "should edit the resource" do
-        github.issues.edit_issue user, repo, issue_id, inputs
-        a_patch("/repos/#{user}/#{repo}/issues/#{issue_id}").with(inputs).should have_been_made
-      end
-
-      it "should return resource" do
-        issue = github.issues.edit_issue user, repo, issue_id, inputs
-        issue.should be_a Hashie::Mash
-      end
-
-      it "should be able to retrieve information" do
-        issue = github.issues.edit_issue user, repo, issue_id, inputs
-        issue.title.should == 'Found a bug'
-      end
-    end
-
-    context "failed to edit resource" do
-      before do
-        stub_patch("/repos/#{user}/#{repo}/issues/#{issue_id}").with(inputs).
-          to_return(:body => fixture("issues/issue.json"), :status => 404, :headers => { :content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to find resource" do
-        expect {
-          github.issues.edit_issue user, repo, issue_id, inputs
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # edit_issue
-
-end # Github::Issues

data/spec/github/mime_type_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-describe Github::MimeType do
-
-  let(:github) { Github.new }
-
-  it "should lookup mime type for :full" do
-    github.lookup_mime(:full).should == 'full+json'
-  end
-
-  it "should lookup mime type for :html" do
-    github.lookup_mime(:html).should == 'html+json'
-  end
-
-  it "should lookup mime type for :html" do
-    github.lookup_mime(:text).should == 'text+json'
-  end
-
-  it "should lookup mime type for :raw" do
-    github.lookup_mime(:raw).should == 'raw+json'
-  end
-
-  it "should default to json if no parameters given" do
-    Github.should_receive(:parse).and_return 'application/json'
-    Github.parse.should == 'application/json'
-  end
-
-  it "should accept header for 'issue' request" do
-    Github.should_receive(:parse).with(:issue, :full).
-      and_return 'application/vnd.github-issue.full+json'
-    Github.parse(:issue, :full).should == 'application/vnd.github-issue.full+json'
-  end
-
-  it "should accept header for 'isssue comment' request" do
-    Github.should_receive(:parse).with(:issue_comment, :full).
-      and_return 'application/vnd.github-issuecomment.full+json'
-    Github.parse(:issue_comment, :full).should == 'application/vnd.github-issuecomment.full+json'
-  end
-
-  it "should accept header for 'commit comment' request" do
-    Github.should_receive(:parse).with(:commit_comment, :full).
-      and_return 'application/vnd.github-commitcomment.full+json'
-    Github.parse(:commit_comment, :full).should == 'application/vnd.github-commitcomment.full+json'
-  end
-
-  it "should accept header for 'pull requst' request" do
-    Github.should_receive(:parse).with(:pull_request, :full).
-      and_return 'application/vnd.github-pull.full+json'
-    Github.parse(:pull_request, :full).should == 'application/vnd.github-pull.full+json'
-  end
-
-  it "should accept header for 'pull comment' request" do
-    Github.should_receive(:parse).with(:pull_comment, :full).
-      and_return 'application/vnd.github-pullcomment.full+json'
-    Github.parse(:pull_comment, :full).should == 'application/vnd.github-pullcomment.full+json'
-  end
-
-  it "should accept header for 'gist comment' request" do
-    Github.should_receive(:parse).with(:gist_comment, :full).
-      and_return 'application/vnd.github-gistcomment.full+json'
-    Github.parse(:gist_comment, :full).should == 'application/vnd.github-gistcomment.full+json'
-  end
-
-  it "should accept header for 'blog' request" do
-    Github.should_receive(:parse).with(:blob, :blob).
-      and_return 'application/vnd.github-blob.raw'
-    Github.parse(:blob, :blob).should == 'application/vnd.github-blob.raw'
-  end
-
-end # Github::MimeType

data/spec/github/orgs/members_spec.rb

@@ -1,275 +0,0 @@
-require 'spec_helper'
-
-describe Github::Orgs::Members do
-
-  let(:github) { Github.new }
-  let(:member) { 'peter-murach' }
-  let(:org)    { 'github' }
-
-  describe "members" do
-    context "resource found" do
-      before do
-        stub_get("/orgs/#{org}/members").
-          to_return(:body => fixture('orgs/members.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource without org name" do
-        expect { github.orgs.members }.to raise_error(ArgumentError)
-      end
-
-      it "should get the resources" do
-        github.orgs.members org
-        a_get("/orgs/#{org}/members").should have_been_made
-      end
-
-      it "should return array of resources" do
-        members = github.orgs.members org
-        members.should be_an Array
-        members.should have(1).items
-      end
-
-      it "should be a mash type" do
-        members = github.orgs.members org
-        members.first.should be_a Hashie::Mash
-      end
-
-      it "should get members information" do
-        members = github.orgs.members org
-        members.first.login.should == 'octocat'
-      end
-
-      it "should yield to a block" do
-        github.orgs.should_receive(:members).with(org).and_yield('web')
-        github.orgs.members(org) { |param| 'web' }
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/orgs/#{org}/members").
-          to_return(:body => fixture('orgs/members.json'), :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect {
-          github.orgs.members org
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # members
-
-  describe "member?" do
-
-    context "with username ane reponame passed" do
-
-      context "this repo is being watched by the user"
-        before do
-          github.oauth_token = nil
-          github.user = nil
-          stub_get("/orgs/#{org}/members/#{member}").
-            to_return(:body => "", :status => 404, :headers => {:user_agent => github.user_agent})
-        end
-
-      it "should return false if resource not found" do
-        membership = github.orgs.member? org, member
-        membership.should be_false
-      end
-
-      it "should return true if resoure found" do
-          stub_get("/orgs/#{org}/members/#{member}").
-            to_return(:body => "", :status => 204, :headers => {:user_agent => github.user_agent})
-        membership = github.orgs.member? org, member
-        membership.should be_true
-      end
-
-    end
-
-    context "without org name and member name passed" do
-      it "should fail validation " do
-        expect { github.orgs.member?(nil, nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end # member?
-
-  describe "public_members" do
-    context "resource found" do
-      before do
-        stub_get("/orgs/#{org}/public_members").
-          to_return(:body => fixture('orgs/members.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource without org name" do
-        expect { github.orgs.public_members }.to raise_error(ArgumentError)
-      end
-
-      it "should get the resources" do
-        github.orgs.public_members org
-        a_get("/orgs/#{org}/public_members").should have_been_made
-      end
-
-      it "should return array of resources" do
-        public_members = github.orgs.public_members org
-        public_members.should be_an Array
-        public_members.should have(1).items
-      end
-
-      it "should be a mash type" do
-        public_members = github.orgs.public_members org
-        public_members.first.should be_a Hashie::Mash
-      end
-
-      it "should get public_members information" do
-        public_members = github.orgs.public_members org
-        public_members.first.login.should == 'octocat'
-      end
-
-      it "should yield to a block" do
-        github.orgs.should_receive(:public_members).with(org).and_yield('web')
-        github.orgs.public_members(org) { |param| 'web' }
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/orgs/#{org}/public_members").
-          to_return(:body => fixture('orgs/members.json'), :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect {
-          github.orgs.public_members org
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # public_members
-
-  describe "public_member?" do
-
-    context "with username ane reponame passed" do
-
-      context "this repo is being watched by the user"
-        before do
-          github.oauth_token = nil
-          github.user = nil
-          stub_get("/orgs/#{org}/public_members/#{member}").
-            to_return(:body => "", :status => 404, :headers => {:user_agent => github.user_agent})
-        end
-
-      it "should return false if resource not found" do
-        public_member = github.orgs.public_member? org, member
-        public_member.should be_false
-      end
-
-      it "should return true if resoure found" do
-          stub_get("/orgs/#{org}/public_members/#{member}").
-            to_return(:body => "", :status => 204, :headers => {:user_agent => github.user_agent})
-        public_member = github.orgs.public_member? org, member
-        public_member.should be_true
-      end
-
-    end
-
-    context "without org name and member name passed" do
-      it "should fail validation " do
-        expect { github.orgs.public_member?(nil, nil) }.to raise_error(ArgumentError)
-      end
-    end
-  end # public_member?
-
-  describe "publicize" do
-    context "request perfomed successfully" do
-      before do
-        stub_put("/orgs/#{org}/public_members/#{member}").
-          to_return(:body => fixture('orgs/members.json'), :status => 204, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource without org name" do
-        expect { github.orgs.publicize }.to raise_error(ArgumentError)
-      end
-
-      it "should get the resources" do
-        github.orgs.publicize org, member
-        a_put("/orgs/#{org}/public_members/#{member}").should have_been_made
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_put("/orgs/#{org}/public_members/#{member}").
-          to_return(:body => fixture('orgs/members.json'), :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect {
-          github.orgs.publicize org, member
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # publicize
-
-  describe "conceal" do
-    context "request perfomed successfully" do
-      before do
-        stub_delete("/orgs/#{org}/public_members/#{member}").
-          to_return(:body => fixture('orgs/members.json'), :status => 204, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource without org name" do
-        expect { github.orgs.conceal nil, nil }.to raise_error(ArgumentError)
-      end
-
-      it "should get the resources" do
-        github.orgs.conceal org, member
-        a_delete("/orgs/#{org}/public_members/#{member}").should have_been_made
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_delete("/orgs/#{org}/public_members/#{member}").
-          to_return(:body => fixture('orgs/members.json'), :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect {
-          github.orgs.conceal org, member
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # conceal
-
-  describe "delete_member" do
-    let(:hook_id) { 1 }
-
-    context "resource deleted successfully" do
-      before do
-        stub_delete("/orgs/#{org}/members/#{member}").
-          to_return(:body => '', :status => 204, :headers => { :content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to delete without org and member parameters" do
-        expect { github.repos.delete_hook nil, nil }.to raise_error(ArgumentError)
-      end
-
-      it "should delete the resource" do
-        github.orgs.delete_member org, member
-        a_delete("/orgs/#{org}/members/#{member}").should have_been_made
-      end
-    end
-
-    context "failed to edit resource" do
-      before do
-        stub_delete("/orgs/#{org}/members/#{member}").
-          to_return(:body => '', :status => 404, :headers => { :content_type => "application/json; charset=utf-8"})
-
-      end
-
-      it "should fail to find resource" do
-        expect {
-          github.orgs.delete_member org, member
-        }.to raise_error(Github::ResourceNotFound)
-      end
-    end
-  end # delete_member
-
-end # Github::Orgs::Members