github_api 0.7.0 → 0.7.1

data/spec/github/repos/forks/list_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Repos::Forks, '#list' do
+  let(:user) { 'peter-murach' }
+  let(:repo) { 'github' }
+  let(:request_path) { "/repos/#{user}/#{repo}/forks" }
+
+  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
+    let(:body)   { fixture('repos/forks.json') }
+    let(:status) { 200 }
+
+    it { should respond_to :all }
+
+    it "should fail to get resource without username" do
+      expect { subject.list }.to raise_error(ArgumentError)
+    end
+
+    it "should get the resources" do
+      subject.list user, repo
+      a_get(request_path).should have_been_made
+    end
+
+    it "should return array of resources" do
+      forks = subject.list user, repo
+      forks.should be_an Array
+      forks.should have(1).items
+    end
+
+    it "should be a mash type" do
+      forks = subject.list user, repo
+      forks.first.should be_a Hashie::Mash
+    end
+
+    it "should get fork information" do
+      forks = subject.list user, repo
+      forks.first.name.should == 'Hello-World'
+    end
+
+    it "should yield to a block" do
+      subject.should_receive(:list).with(user, repo).and_yield('web')
+      subject.list(user, repo) { |param| 'web' }
+    end
+  end
+
+  context "resource not found" do
+    let(:body)   { "" }
+    let(:status) { [404, "Not Found"] }
+
+    it "should return 404 with a message 'Not Found'" do
+      expect {
+        subject.list user, repo
+      }.to raise_error(Github::Error::NotFound)
+    end
+  end
+end # list

data/spec/github/repos/get_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Repos, '#get' do
+  let(:user) { 'peter-murach' }
+  let(:repo) { 'github' }
+  let(:request_path) { "/repos/#{user}/#{repo}" }
+
+  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
+    let(:body)   { fixture('repos/repo.json') }
+    let(:status) { 200 }
+
+    it { should respond_to(:find) }
+
+    it "should raise error when no user/repo parameters" do
+      expect { subject.get nil, repo }.to raise_error(ArgumentError)
+    end
+
+    it "should raise error when no repository" do
+      expect { subject.get user, nil }.to raise_error(ArgumentError)
+    end
+
+    it "should find resources" do
+      subject.get user, repo
+      a_get(request_path).should have_been_made
+    end
+
+    it "should return repository mash" do
+      repository = subject.get user, repo
+      repository.should be_a Hashie::Mash
+    end
+
+    it "should get repository information" do
+      repository = subject.get user, repo
+      repository.name.should == 'Hello-World'
+    end
+  end
+
+  context "resource not found" do
+    let(:body)   { '' }
+    let(:status) { 404 }
+
+    it "should fail to get resource" do
+      expect {
+        subject.get user, repo
+      }.to raise_error(Github::Error::NotFound)
+    end
+  end
+end # get

data/spec/github/repos/languages_spec.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Repos, '#languages' do
+  let(:user) { 'peter-murach' }
+  let(:repo) { 'github' }
+  let(:request_path) { "/repos/#{user}/#{repo}/languages" }
+
+  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
+    let(:body)   { fixture('repos/languages.json') }
+    let(:status) { 200 }
+
+    it "should raise error when no user/repo parameters" do
+      expect { subject.languages nil, repo }.to raise_error(ArgumentError)
+    end
+
+    it "should raise error when no repository" do
+      expect { subject.languages user, nil }.to raise_error(ArgumentError)
+    end
+
+    it "should find resources" do
+      subject.languages user, repo
+      a_get(request_path).should have_been_made
+    end
+
+    it "should return hash of languages" do
+      languages = subject.languages user, repo
+      languages.should be_an Hash
+      languages.should have(2).keys
+    end
+
+    it "should get language information" do
+      languages = subject.languages user, repo
+      languages.keys.first.should == 'Ruby'
+    end
+
+    it "should yield to a block" do
+      subject.should_receive(:languages).with(user, repo).and_yield('web')
+      subject.languages(user, repo) { |param| 'web'}
+    end
+  end
+
+  context "resource not found" do
+    let(:body)   { '' }
+    let(:status) { 404 }
+
+    it "should fail to get resource" do
+      expect {
+        subject.languages user, repo
+      }.to raise_error(Github::Error::NotFound)
+    end
+  end
+end # languages

data/spec/github/repos/list_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Repos, '#list' do
+  let(:user) { 'peter-murach' }
+  let(:repo) { 'github' }
+  let(:request_path) { "/user/repos?access_token=#{OAUTH_TOKEN}" }
+  let(:body)   { fixture('repos/repos.json') }
+  let(:status) { 200 }
+
+  after { reset_authentication_for subject }
+
+  it { should respond_to(:find) }
+
+  context "resource found for authenticated user" do
+    before {
+      subject.oauth_token = OAUTH_TOKEN
+      stub_get(request_path).to_return(:body => body, :status => status,
+        :headers => {:content_type => "application/json; charset=utf-8"} )
+      stub_get(request_path + "&sort=pushed").
+        to_return(:body => fixture('repos/repos_sorted_by_pushed.json'), :status => 200,:headers => {:content_type => "application/json; charset=utf-8"} )
+    }
+
+    it "fails if user is unauthenticated" do
+      subject.oauth_token = nil
+      stub_get("/user/repos").to_return(:body => '', :status => 401,
+        :headers => {:content_type => "application/json; charset=utf-8"} )
+      expect { subject.list }.to raise_error(Github::Error::Unauthorized)
+    end
+
+    it "should get the resources" do
+      subject.list
+      a_get(request_path).should have_been_made
+    end
+
+    it "should return array of resources" do
+      repositories = subject.list
+      repositories.should be_an Array
+      repositories.should have(1).items
+    end
+
+    it "should return array of resources sorted by pushed_at time" do
+      repositories = subject.list(:sort => 'pushed')
+      repositories.first.name.should == "Hello-World-2"
+    end
+
+    it "should get resource information" do
+      repositories = subject.list
+      repositories.first.name.should == 'Hello-World'
+    end
+
+    it "should yield repositories to a block" do
+      subject.should_receive(:list).and_yield('octocat')
+      subject.list { |repo| 'octocat' }
+    end
+  end
+
+  context "resource found for organization" do
+    let(:org) { '37signals' }
+    let(:request_path) { "/orgs/#{org}/repos" }
+
+    before {
+      stub_get(request_path).to_return(:body => body, :status => status,
+          :headers => {:content_type => "application/json; charset=utf-8"} )
+    }
+
+    it "should get the resources" do
+      subject.list :org => org
+      a_get(request_path).should have_been_made
+    end
+  end
+
+  context "resource found for organization" do
+    let(:request_path) { "/users/#{user}/repos" }
+
+    before {
+      stub_get(request_path).to_return(:body => body, :status => status,
+        :headers => {:content_type => "application/json; charset=utf-8"} )
+    }
+
+    it "should get the resources" do
+      subject.list :user => user
+      a_get(request_path).should have_been_made
+    end
+  end
+
+  context "rosource not found for authenticated user" do
+    before {
+      subject.oauth_token = OAUTH_TOKEN
+      stub_get(request_path).to_return(:body => '', :status => 404,
+          :headers => {:content_type => "application/json; charset=utf-8"} )
+    }
+
+    it "fail to find resources" do
+      expect { subject.list }.to raise_error(Github::Error::NotFound)
+    end
+  end
+end # list

data/spec/github/repos/tags_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Repos, '#tags' do
+  let(:user) { 'peter-murach' }
+  let(:repo) { 'github' }
+  let(:request_path) { "/repos/#{user}/#{repo}/tags" }
+
+  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
+    let(:body) { fixture('repos/tags.json') }
+    let(:status) { 200 }
+
+    it "should raise error when no user/repo parameters" do
+      expect { subject.tags nil, repo }.to raise_error(ArgumentError)
+    end
+
+    it "should raise error when no repository" do
+      expect { subject.tags user, nil }.to raise_error(ArgumentError)
+    end
+
+    it "should find resources" do
+      subject.tags user, repo
+      a_get(request_path).should have_been_made
+    end
+
+    it "should return array of resources" do
+      tags = subject.tags user, repo
+      tags.should be_an Array
+      tags.should have(1).items
+    end
+
+    it "should get tag information" do
+      tags = subject.tags user, repo
+      tags.first.name.should == 'v0.1'
+    end
+
+    it "should yield to a block" do
+      subject.should_receive(:tags).with(user, repo).and_yield('web')
+      subject.tags(user, repo) { |param| 'web'}
+    end
+  end
+
+  context "resource not found" do
+    let(:body)   { '' }
+    let(:status) { 404 }
+
+    it "should fail to get resource" do
+      expect { subject.tags user, repo }.to raise_error(Github::Error::NotFound)
+    end
+  end
+end # tags

data/spec/github/repos/teams_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Github::Repos, '#teams' do
+  let(:user) { 'peter-murach' }
+  let(:repo) { 'github' }
+  let(:request_path) { "/repos/#{user}/#{repo}/teams" }
+
+  after { reset_authentication_for subject }
+
+  before {
+    stub_get(request_path).to_return(:body => body, :status => status,
+      :headers => {:content_type => "application/json; charset=utf-8"})
+  }
+
+  context "resource found" do
+   let(:body)   { fixture('repos/teams.json') }
+   let(:status) { 200 }
+
+    it "should raise error when no user/repo parameters" do
+      expect { subject.teams nil, repo }.to raise_error(ArgumentError)
+    end
+
+    it "should raise error when no repository" do
+      expect { subject.teams user, nil }.to raise_error(ArgumentError)
+    end
+
+    it "should find resources" do
+      subject.teams user, repo
+      a_get(request_path).should have_been_made
+    end
+
+    it "should return array of resources" do
+      teams = subject.teams user, repo
+      teams.should be_an Array
+      teams.should have(1).items
+    end
+
+    it "should get branch information" do
+      teams = subject.teams user, repo
+      teams.first.name.should == 'Owners'
+    end
+
+    it "should yield to a block" do
+      subject.should_receive(:teams).with(user, repo).and_yield('web')
+      subject.teams(user, repo) { |param| 'web'}
+    end
+  end
+
+  context "resource not found" do
+    let(:body)   { '' }
+    let(:status) { 404 }
+
+    it "should fail to get resource" do
+      expect { subject.teams user, repo }.to raise_error(Github::Error::NotFound)
+    end
+  end
+end # teams

data/spec/github/repos_spec.rb

@@ -2,595 +2,30 @@
 
 require 'spec_helper'
 
-describe Github::Repos do
-  let(:github) { Github.new }
-  let(:user) { 'peter-murach' }
-  let(:repo) { 'github' }
+describe Github::Repos, 'integration' do
 
-  after { reset_authentication_for github }
+  after { reset_authentication_for subject }
 
-  context 'access to apis' do
-    it { subject.collaborators.should be_a Github::Repos::Collaborators }
-    it { subject.commits.should be_a Github::Repos::Commits }
-    it { subject.downloads.should be_a Github::Repos::Downloads }
-    it { subject.forks.should be_a Github::Repos::Forks }
-    it { subject.hooks.should be_a Github::Repos::Hooks }
-    it { subject.keys.should be_a Github::Repos::Keys }
-    it { subject.watching.should be_a Github::Repos::Watching }
-    it { subject.pubsubhubbub.should be_a Github::Repos::PubSubHubbub }
-  end
+  its(:collaborators) { should be_a Github::Repos::Collaborators }
 
-  describe "#branches" do
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/branches").
-          to_return(:body => fixture('repos/branches.json'),
-              :status => 200,
-              :headers => {:content_type => "application/json; charset=utf-8"})
-      end
+  its(:commits)       { should be_a Github::Repos::Commits }
 
-      it "should raise error when no user/repo parameters" do
-        expect {
-          github.repos.branches nil, repo
-        }.to raise_error(ArgumentError, /\[user\] parameter cannot be nil/)
-      end
+  its(:downloads)     { should be_a Github::Repos::Downloads }
 
-      it "should raise error when no repository" do
-        expect {
-          github.repos.branches user, nil
-        }.to raise_error(ArgumentError, /\[repo\] parameter cannot be nil/)
-      end
+  its(:forks)         { should be_a Github::Repos::Forks }
 
-      it "should find resources" do
-        github.repos.branches user, repo
-        a_get("/repos/#{user}/#{repo}/branches").should have_been_made
-      end
+  its(:keys)          { should be_a Github::Repos::Keys }
 
-      it "should return array of resources" do
-        branches = github.repos.branches user, repo
-        branches.should be_an Array
-        branches.should have(1).items
-      end
+  its(:hooks)         { should be_a Github::Repos::Hooks }
 
-      it "should get branch information" do
-        branches = github.repos.branches user, repo
-        branches.first.name.should == 'master'
-      end
+  its(:merging)       { should be_a Github::Repos::Merging }
 
-      it "should yield to a block" do
-        block = lambda { |el| repo }
-        github.repos.should_receive(:branches).with(user, repo).and_yield repo
-        github.repos.branches(user, repo, &block)
-      end
-    end
+  its(:starring)      { should be_a Github::Repos::Starring }
 
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/branches").
-          to_return(:body => '', :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
+  its(:statuses)      { should be_a Github::Repos::Statuses }
 
-      end
+  its(:watching)      { should be_a Github::Repos::Watching }
 
-      it "should fail to get resource" do
-        expect {
-          github.repos.branches user, repo
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # branches
-
-  describe "#branch" do
-    let(:branch) { 'master' }
-
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/branches/#{branch}").
-          to_return(:body => fixture('repos/branch.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should find resources" do
-        github.repos.branch user, repo, branch
-        a_get("/repos/#{user}/#{repo}/branches/#{branch}").should have_been_made
-      end
-
-      it "should return repository mash" do
-        repo_branch = github.repos.branch user, repo, branch
-        repo_branch.should be_a Hashie::Mash
-      end
-
-      it "should get repository branch information" do
-        repo_branch = github.repos.branch user, repo, branch
-        repo_branch.name.should == 'master'
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/branches/#{branch}").
-          to_return(:body => '', :status => 404,
-            :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource" do
-        expect {
-          github.repos.branch user, repo, branch
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # branch
-
-  describe "contributors" do
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/contributors").
-          to_return(:body => fixture('repos/contributors.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should raise error when no user/repo parameters" do
-        expect {
-          github.repos.contributors nil, repo
-        }.to raise_error(ArgumentError, /\[user\] parameter cannot be nil/)
-      end
-
-      it "should raise error when no repository" do
-        expect {
-          github.repos.contributors user, nil
-        }.to raise_error(ArgumentError, /\[repo\] parameter cannot be nil/)
-      end
-
-      it "should find resources" do
-        github.repos.contributors user, repo
-        a_get("/repos/#{user}/#{repo}/contributors").should have_been_made
-      end
-
-      it "should return array of resources" do
-        contributors = github.repos.contributors user, repo
-        contributors.should be_an Array
-        contributors.should have(1).items
-      end
-
-      it "should get branch information" do
-        contributors = github.repos.contributors user, repo
-        contributors.first.login.should == 'octocat'
-      end
-
-      it "should yield to a block" do
-        github.repos.should_receive(:contributors).with(user, repo).and_yield('web')
-        github.repos.contributors(user, repo) { |param| 'web'}
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/contributors").
-          to_return(:body => '', :status => 404, 
-            :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource" do
-        expect {
-          github.repos.contributors user, repo
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # contributors
-
-  describe "#create" do
-    let(:inputs) { {:name => 'web', :description => "This is your first repo", :homepage => "https://github.com", :public => true, :has_issues => true, :has_wiki => true}}
-
-    context "resource created successfully for the authenticated user" do
-      before do
-        github.oauth_token = OAUTH_TOKEN
-        stub_post("/user/repos?access_token=#{OAUTH_TOKEN}").with(inputs).
-          to_return(:body => fixture('repos/repo.json'), :status => 201,
-            :headers => {:content_type => "application/json; charset=utf-8"} )
-      end
-
-      it "should faile to create resource if 'name' inputs is missing" do
-        expect {
-          github.repos.create inputs.except(:name)
-        }.to raise_error(Github::Error::RequiredParams)
-      end
-
-      it "should create resource" do
-        github.repos.create inputs
-        a_post("/user/repos?access_token=#{OAUTH_TOKEN}").with(inputs).should have_been_made
-      end
-
-      it "should return the resource" do
-        repository = github.repos.create inputs
-        repository.name.should == 'Hello-World'
-      end
-
-      it "should return mash type" do
-        repository = github.repos.create inputs
-        repository.should be_a Hashie::Mash
-      end
-    end
-
-    context "resource created for the authenticated user belonging to organization" do
-      let(:org) { '37signals' }
-      before do
-        github.oauth_token = OAUTH_TOKEN
-        stub_post("/orgs/#{org}/repos?access_token=#{OAUTH_TOKEN}").with(inputs).
-          to_return(:body => fixture('repos/repo.json'), :status => 201,:headers => {:content_type => "application/json; charset=utf-8"} )
-      end
-
-      it "should get the resource" do
-        github.repos.create inputs.merge(:org => org)
-        a_post("/orgs/#{org}/repos?access_token=#{OAUTH_TOKEN}").with(inputs).should have_been_made
-      end
-    end
-
-    context "failed to create" do
-      before do
-        github.oauth_token = OAUTH_TOKEN
-        stub_post("/user/repos?access_token=#{OAUTH_TOKEN}").with(inputs).
-          to_return(:body => '', :status => 404,:headers => {:content_type => "application/json; charset=utf-8"} )
-      end
-
-      it "should faile to retrieve resource" do
-        expect {
-          github.repos.create inputs
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end
-
-  describe "#edit" do
-    let(:inputs) do
-      { :name => 'web',
-        :description => "This is your first repo",
-        :homepage => "https://github.com",
-        :private => false,
-        :has_issues => true,
-        :has_wiki => true }
-    end
-
-    context "resource edited successfully" do
-      before do
-        stub_patch("/repos/#{user}/#{repo}").with(inputs).
-          to_return(:body => fixture("repos/repo.json"), :status => 200,
-            :headers => { :content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to edit without 'user/repo' parameters" do
-        expect { github.repos.edit user, nil }.to raise_error(ArgumentError)
-      end
-
-      it "should fail to edit resource without 'name' parameter" do
-        expect{
-          github.repos.edit user, repo, inputs.except(:name)
-        }.to raise_error(Github::Error::RequiredParams)
-      end
-
-      it "should edit the resource" do
-        github.repos.edit user, repo, inputs
-        a_patch("/repos/#{user}/#{repo}").with(inputs).should have_been_made
-      end
-
-      it "should return resource" do
-        repository = github.repos.edit user, repo, inputs
-        repository.should be_a Hashie::Mash
-      end
-
-      it "should be able to retrieve information" do
-        repository = github.repos.edit user, repo, inputs
-        repository.name.should == 'Hello-World'
-      end
-    end
-
-    context "failed to edit resource" do
-      before do
-        stub_patch("/repos/#{user}/#{repo}").with(inputs).
-          to_return(:body => fixture("repos/repo.json"), :status => 404,
-            :headers => { :content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to find resource" do
-        expect {
-          github.repos.edit user, repo, inputs
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # edit
-
-  describe "#get" do
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}").
-          to_return(:body => fixture('repos/repo.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should raise error when no user/repo parameters" do
-        # github.user, github.repo = nil, nil
-        expect {
-          github.repos.get nil, repo
-        }.to raise_error(ArgumentError, /\[user\] parameter cannot be nil/)
-      end
-
-      it "should raise error when no repository" do
-        # github.user, github.repo = nil, nil
-        expect {
-          github.repos.get user, nil
-        }.to raise_error(ArgumentError, /\[repo\] parameter cannot be nil/)
-      end
-
-      it "should find resources" do
-        github.repos.get user, repo
-        a_get("/repos/#{user}/#{repo}").should have_been_made
-      end
-
-      it "should return repository mash" do
-        repository = github.repos.get user, repo
-        repository.should be_a Hashie::Mash
-      end
-
-      it "should get repository information" do
-        repository = github.repos.get user, repo
-        repository.name.should == 'Hello-World'
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}").
-          to_return(:body => '', :status => 404,
-            :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource" do
-        expect {
-          github.repos.get user, repo
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # get
-
-  describe "#languages" do
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/languages").
-          to_return(:body => fixture('repos/languages.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should raise error when no user/repo parameters" do
-        expect {
-          github.repos.languages nil, repo
-        }.to raise_error(ArgumentError, /\[user\] parameter cannot be nil/)
-      end
-
-      it "should raise error when no repository" do
-        expect {
-          github.repos.languages user, nil
-        }.to raise_error(ArgumentError, /\[repo\] parameter cannot be nil/)
-      end
-
-      it "should find resources" do
-        github.repos.languages user, repo
-        a_get("/repos/#{user}/#{repo}/languages").should have_been_made
-      end
-
-      it "should return hash of languages" do
-        languages = github.repos.languages user, repo
-        languages.should be_an Hash
-        languages.should have(2).keys
-      end
-
-      it "should get language information" do
-        languages = github.repos.languages user, repo
-        languages.keys.first.should == 'Ruby'
-      end
-
-      it "should yield to a block" do
-        github.repos.should_receive(:languages).with(user, repo).and_yield('web')
-        github.repos.languages(user, repo) { |param| 'web'}
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/languages").
-          to_return(:body => '', :status => 404, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource" do
-        expect {
-          github.repos.languages user, repo
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # languages
-
-  describe "#list" do
-    context "resource found for authenticated user" do
-      before do
-        github.oauth_token = OAUTH_TOKEN
-        stub_get("/user/repos?access_token=#{OAUTH_TOKEN}").
-          to_return(:body => fixture('repos/repos.json'), :status => 200,:headers => {:content_type => "application/json; charset=utf-8"} )
-      end
-
-      it "fails if user is unauthenticated" do
-        github.oauth_token = nil
-        stub_get("/user/repos").
-          to_return(:body => '', :status => 401,:headers => {:content_type => "application/json; charset=utf-8"} )
-        expect { github.repos.list }.to raise_error(Github::Error::Unauthorized)
-      end
-
-      it "should get the resources" do
-        github.repos.list
-        a_get("/user/repos?access_token=#{OAUTH_TOKEN}").should have_been_made
-      end
-
-      it "should return array of resources" do
-        repositories = github.repos.list
-        repositories.should be_an Array
-        repositories.should have(1).items
-      end
-
-      it "should get resource information" do
-        repositories = github.repos.list
-        repositories.first.name.should == 'Hello-World'
-      end
-
-      it "should yield repositories to a block" do
-        github.repos.should_receive(:list).and_yield('octocat')
-        github.repos.list { |repo| 'octocat' }
-      end
-    end
-
-    context "resource found for organization" do
-      let(:org) { '37signals' }
-
-      before do
-        stub_get("/orgs/#{org}/repos").
-          to_return(:body => fixture('repos/repos.json'), :status => 200,
-            :headers => {:content_type => "application/json; charset=utf-8"} )
-      end
-
-      it "should get the resources" do
-        github.repos.list :org => org
-        a_get("/orgs/#{org}/repos").should have_been_made
-      end
-    end
-
-    context "resource found for organization" do
-      before do
-        stub_get("/users/#{user}/repos").
-          to_return(:body => fixture('repos/repos.json'), :status => 200,
-            :headers => {:content_type => "application/json; charset=utf-8"} )
-      end
-
-      it "should get the resources" do
-        github.repos.list :user => user
-        a_get("/users/#{user}/repos").should have_been_made
-      end
-    end
-
-    context "rosource not found for authenticated user" do
-      before do
-        github.oauth_token = OAUTH_TOKEN
-        stub_get("/user/repos?access_token=#{OAUTH_TOKEN}").
-          to_return(:body => '', :status => 404,
-            :headers => {:content_type => "application/json; charset=utf-8"} )
-      end
-
-      it "fail to find resources" do
-        expect { github.repos.list }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # list
-
-  describe "tags" do
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/tags").
-          to_return(:body => fixture('repos/tags.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should raise error when no user/repo parameters" do
-        expect {
-          github.repos.tags nil, repo
-        }.to raise_error(ArgumentError, /\[user\] parameter cannot be nil/)
-      end
-
-      it "should raise error when no repository" do
-        expect {
-          github.repos.tags user, nil
-        }.to raise_error(ArgumentError, /\[repo\] parameter cannot be nil/)
-      end
-
-      it "should find resources" do
-        github.repos.tags user, repo
-        a_get("/repos/#{user}/#{repo}/tags").should have_been_made
-      end
-
-      it "should return array of resources" do
-        tags = github.repos.tags user, repo
-        tags.should be_an Array
-        tags.should have(1).items
-      end
-
-      it "should get tag information" do
-        tags = github.repos.tags user, repo
-        tags.first.name.should == 'v0.1'
-      end
-
-      it "should yield to a block" do
-        github.repos.should_receive(:tags).with(user, repo).and_yield('web')
-        github.repos.tags(user, repo) { |param| 'web'}
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/tags").
-          to_return(:body => '', :status => 404,
-            :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource" do
-        expect {
-          github.repos.tags user, repo
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # tags
-
-  describe "#teams" do
-    context "resource found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/teams").
-          to_return(:body => fixture('repos/teams.json'), :status => 200, :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should raise error when no user/repo parameters" do
-        expect {
-          github.repos.teams nil, repo
-        }.to raise_error(ArgumentError, /\[user\] parameter cannot be nil/)
-      end
-
-      it "should raise error when no repository" do
-        expect {
-          github.repos.teams user, nil
-        }.to raise_error(ArgumentError, /\[repo\] parameter cannot be nil/)
-      end
-
-      it "should find resources" do
-        github.repos.teams user, repo
-        a_get("/repos/#{user}/#{repo}/teams").should have_been_made
-      end
-
-      it "should return array of resources" do
-        teams = github.repos.teams user, repo
-        teams.should be_an Array
-        teams.should have(1).items
-      end
-
-      it "should get branch information" do
-        teams = github.repos.teams user, repo
-        teams.first.name.should == 'Owners'
-      end
-
-      it "should yield to a block" do
-        github.repos.should_receive(:teams).with(user, repo).and_yield('web')
-        github.repos.teams(user, repo) { |param| 'web'}
-      end
-    end
-
-    context "resource not found" do
-      before do
-        stub_get("/repos/#{user}/#{repo}/teams").
-          to_return(:body => '', :status => 404,
-            :headers => {:content_type => "application/json; charset=utf-8"})
-      end
-
-      it "should fail to get resource" do
-        expect {
-          github.repos.teams user, repo
-        }.to raise_error(Github::Error::NotFound)
-      end
-    end
-  end # teams
+  its(:pubsubhubbub)  { should be_a Github::Repos::PubSubHubbub }
 
 end # Github::Repos