github_api 0.8.2 → 0.8.3

data/spec/github/git_data_spec.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-
-describe Github::GitData do
-
-  its(:blobs)   { should be_a Github::GitData::Blobs }
-  its(:commits) { should be_a Github::GitData::Commits }
-  its(:references) { should be_a Github::GitData::References }
-  its(:tags)  { should be_a Github::GitData::Tags }
-  its(:trees) { should be_a Github::GitData::Trees }
-
-end # Github::GitData

data/spec/github/issues_spec.rb

@@ -1,284 +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' }
-  let(:issue_id) { 1347 }
-
-  after { reset_authentication_for github }
-
-  its(:comments) { should be_a Github::Issues::Comments }
-  its(:events)   { should be_a Github::Issues::Events }
-  its(:labels)   { should be_a Github::Issues::Labels }
-  its(:milestones) { should be_a Github::Issues::Milestones }
-
-  context '#list' do
-    it { should respond_to(:all) }
-
-    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.list
-        a_get("/issues").should have_been_made
-      end
-
-      it "should return array of resources" do
-        issues = github.issues.list
-        issues.should be_an Array
-        issues.should have(1).items
-      end
-
-      it "should be a mash type" do
-        issues = github.issues.list
-        issues.first.should be_a Hashie::Mash
-      end
-
-      it "should get issue information" do
-        issues = github.issues.list
-        issues.first.title.should == 'Found a bug'
-      end
-
-      it "should yield to a block" do
-        github.issues.should_receive(:list).and_yield('web')
-        github.issues.list { |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.list }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # list
-
-  describe '#list_repo' do
-    it { should respond_to :list_repository }
-
-    context "resource found" do
-      before do
-        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.list_repo nil, repo
-        }.to raise_error(ArgumentError)
-      end
-
-      it "should get the resources" do
-        github.issues.list_repo user, repo
-        a_get("/repos/#{user}/#{repo}/issues").should have_been_made
-      end
-
-      it "should return array of resources" do
-        repo_issues = github.issues.list_repo 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.list_repo user, repo
-        repo_issues.first.should be_a Hashie::Mash
-      end
-
-      it "should get repository issue information" do
-        repo_issues = github.issues.list_repo user, repo
-        repo_issues.first.title.should == 'Found a bug'
-      end
-
-      it "should yield to a block" do
-        github.issues.should_receive(:list_repo).with(user, repo).and_yield('web')
-        github.issues.list_repo(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.list_repo user, repo
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # list_repo
-
-  describe "#get" do
-    it { should respond_to :find }
-
-    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.get(user, repo, nil)}.to raise_error(ArgumentError)
-      end
-
-      it "should get the resource" do
-        github.issues.get 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.get user, repo, issue_id
-        issue.number.should == issue_id
-        issue.title.should == 'Found a bug'
-      end
-
-      it "should return mash" do
-        issue = github.issues.get 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.get user, repo, issue_id
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # get_issue
-
-  describe "#create" 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 user, repo, inputs.except('title')
-        }.to raise_error(Github::Error::RequiredParams)
-      end
-
-      it "should create resource successfully" do
-        github.issues.create 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 user, repo, inputs
-        issue.should be_a Hashie::Mash
-      end
-
-      it "should get the issue information" do
-        issue = github.issues.create(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 user, repo, inputs
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # create
-
-  describe "#edit" do
-    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
-        expect {
-          github.issues.edit nil, repo, issue_id
-        }.to raise_error(ArgumentError)
-      end
-
-      it "should edit the resource" do
-        github.issues.edit 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 user, repo, issue_id, inputs
-        issue.should be_a Hashie::Mash
-      end
-
-      it "should be able to retrieve information" do
-        issue = github.issues.edit 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 user, repo, issue_id, inputs
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # edit
-
-end # Github::Issues

data/spec/github/users/followers_spec.rb

@@ -1,172 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe Github::Users::Followers do
-  let(:github) { Github.new }
-  let(:user)   { 'peter-murach' }
-
-  after { reset_authentication_for github }
-
-  describe "#following" do
-    context "resource found for a user" do
-      before do
-        stub_get("/users/#{user}/following").
-          to_return(:body => fixture('users/followers.json'),
-            :status => 200,
-            :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should get the resources" do
-        github.users.followers.following user
-        a_get("/users/#{user}/following").should have_been_made
-      end
-
-      it "should return resource" do
-        followings = github.users.followers.following user
-        followings.should be_an Array
-        followings.should have(1).items
-      end
-
-      it "should be a mash type" do
-        followings = github.users.followers.following user
-        followings.first.should be_a Hashie::Mash
-      end
-
-      it "should get following users information" do
-        followings = github.users.followers.following user
-        followings.first.login.should == 'octocat'
-      end
-
-      it "should yield to a block" do
-        github.users.followers.should_receive(:following).with(user).and_yield('web')
-        github.users.followers.following(user) { |param| 'web' }
-      end
-    end
-
-    context "resource found for an authenticated user" do
-      before do
-        github.oauth_token = OAUTH_TOKEN
-        stub_get("/user/following").
-          with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-          to_return(:body => fixture('users/followers.json'),
-            :status => 200,
-            :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should get the resources" do
-        github.users.followers.following
-        a_get("/user/following").
-          with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-          should have_been_made
-      end
-    end
-
-    context "resource not found for a user" do
-      before do
-        stub_get("/users/#{user}/following").
-          to_return(:body => "", :status => [404, "Not Found"])
-      end
-
-      it "should return 404 with a message 'Not Found'" do
-        expect {
-          github.users.followers.following user
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # following
-
-  context '#following?' do
-    before do
-      github.oauth_token = OAUTH_TOKEN
-      stub_get("/user/following/#{user}").
-        with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-        to_return(:body => '',
-              :status => 204,
-              :headers => {:content_type => "application/json; charset=utf-8"})
-    end
-
-    it 'should raise error if username not present' do
-      expect {
-        github.users.followers.following? nil
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'should perform request' do
-      github.users.followers.following?(user)
-      a_get("/user/following/#{user}").
-        with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-        should have_been_made
-    end
-
-    it 'should return true if user is being followed' do
-      github.users.followers.following?(user).should be_true
-    end
-
-    it 'should return false if user is not being followed' do
-      stub_get("/user/following/#{user}").
-        with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-        to_return(:body => '',
-              :status => 404,
-              :headers => {:content_type => "application/json; charset=utf-8"})
-      github.users.followers.following?(user).should be_false
-    end
-  end # following?
-
-  context '#follow' do
-    before do
-      github.oauth_token = OAUTH_TOKEN
-      stub_put("/user/following/#{user}").
-        with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-        to_return(:body => '',
-              :status => 204,
-              :headers => {:content_type => "application/json; charset=utf-8"})
-    end
-
-    it "should raise error if gist id not present" do
-      expect {
-        github.users.followers.follow nil
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'successfully unfollows a user' do
-      github.users.followers.follow(user)
-      a_put("/user/following/#{user}").
-        with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-        should have_been_made
-    end
-
-    it "should return 204 with a message 'Not Found'" do
-      github.users.followers.follow(user).status.should be 204
-    end
-  end # follow
-
-  context '#unfollow' do
-    before do
-      github.oauth_token = OAUTH_TOKEN
-      stub_delete("/user/following/#{user}").
-        with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-        to_return(:body => '',
-              :status => 204,
-              :headers => {:content_type => "application/json; charset=utf-8"})
-    end
-
-    it "should raise error if gist id not present" do
-      expect {
-        github.users.followers.unfollow nil
-      }.to raise_error(ArgumentError)
-    end
-
-    it 'successfully unfollows a user' do
-      github.users.followers.unfollow(user)
-      a_delete("/user/following/#{user}").
-        with(:query => { :access_token => "#{OAUTH_TOKEN}"}).
-        should have_been_made
-    end
-
-    it "should return 204 with a message 'Not Found'" do
-      github.users.followers.unfollow(user).status.should be 204
-    end
-  end # unfollow
-
-end # Github::Users::Followers