tinybucket 1.3.0 → 1.4.0

data/spec/lib/tinybucket/api/repo_api_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper.rb'
-
-RSpec.describe Tinybucket::Api::RepoApi do
-  include ApiResponseMacros
-
-  let(:repo_owner) { 'test_owner' }
-  let(:repo_slug) { 'test_repo' }
-  let(:request_path) { nil }
-
-  let(:api) do
-    api = Tinybucket::Api::RepoApi.new
-    api.repo_owner = repo_owner
-    api.repo_slug  = repo_slug
-    api
-  end
-
-  it { expect(api).to be_a_kind_of(Tinybucket::Api::BaseApi) }
-
-  before { stub_apiresponse(:get, request_path) if request_path }
-
-  describe 'find' do
-    subject { api.find }
-
-    context 'when without repo_owner and repo_slug' do
-      let(:repo_owner) { nil }
-      let(:repo_slug) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when without repo_owner' do
-      let(:repo_owner) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when without repo_slug' do
-      let(:repo_slug) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with repo_owner and repo_slug' do
-      let(:request_path) { "/repositories/#{repo_owner}/#{repo_slug}" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Repository) }
-    end
-  end
-
-  describe 'watchers' do
-    subject { api.watchers }
-
-    context 'when without repo_owner and repo_slug' do
-      let(:repo_owner) { nil }
-      let(:repo_slug) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when without repo_owner' do
-      let(:repo_owner) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when without repo_slug' do
-      let(:repo_slug) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with repo_owner and repo_slug' do
-      let(:request_path) do
-        "/repositories/#{repo_owner}/#{repo_slug}/watchers"
-      end
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-
-  describe 'forks' do
-    subject { api.forks }
-
-    context 'when without repo_owner and repo_slug' do
-      let(:repo_owner) { nil }
-      let(:repo_slug) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when without repo_owner' do
-      let(:repo_owner) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when without repo_slug' do
-      let(:repo_slug) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with repo_owner and repo_slug' do
-      let(:request_path) do
-        "/repositories/#{repo_owner}/#{repo_slug}/forks"
-      end
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-end

data/spec/lib/tinybucket/api/repos_api_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper.rb'
-
-RSpec.describe Tinybucket::Api::ReposApi do
-  include ApiResponseMacros
-
-  let(:api) { Tinybucket::Api::ReposApi.new }
-
-  it { expect(api).to be_a_kind_of(Tinybucket::Api::BaseApi) }
-
-  describe 'list' do
-    subject { api.list(options) }
-
-    before { stub_apiresponse(:get, request_path) }
-
-    context 'without owner' do
-      let(:options) { {} }
-      let(:request_path) { '/repositories' }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-
-    context 'with owner' do
-      let(:options) { { owner: 'test_owner' } }
-      let(:request_path) { '/repositories/test_owner' }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-end

data/spec/lib/tinybucket/api/team_api_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tinybucket::Api::TeamApi do
-  include ApiResponseMacros
-
-  let(:api) { Tinybucket::Api::TeamApi.new }
-  let(:teamname) { 'test_team' }
-  let(:request_path) { nil }
-  before { stub_apiresponse(:get, request_path) if request_path }
-
-  it { expect(api).to be_a_kind_of(Tinybucket::Api::BaseApi) }
-
-  describe 'profile' do
-    subject { api.find(teamname) }
-
-    context 'when without teamname' do
-      let(:teamname) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with teamname' do
-      let(:request_path) { "/teams/#{teamname}" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Team) }
-    end
-  end
-
-  describe 'members' do
-    subject { api.members(teamname) }
-
-    context 'when without teamname' do
-      let(:teamname) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with teamname' do
-      let(:request_path) { "/teams/#{teamname}/members" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-
-  describe 'followers' do
-    subject { api.followers(teamname) }
-
-    context 'when without teamname' do
-      let(:teamname) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with teamname' do
-      let(:request_path) { "/teams/#{teamname}/followers" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-
-  describe 'following' do
-    subject { api.following(teamname) }
-
-    context 'when without teamname' do
-      let(:teamname) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with teamname' do
-      let(:request_path) { "/teams/#{teamname}/following" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-
-  describe 'repos' do
-    subject { api.repos(teamname) }
-
-    context 'when without teamname' do
-      let(:teamname) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with teamname' do
-      let(:request_path) { "/teams/#{teamname}/repositories" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-end

data/spec/lib/tinybucket/api/user_api_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tinybucket::Api::UserApi do
-  include ApiResponseMacros
-
-  let(:api) do
-    api = Tinybucket::Api::UserApi.new
-    api.username = user
-    api
-  end
-
-  let(:user) { 'test_owner' }
-  let(:request_path) { nil }
-  before { stub_apiresponse(:get, request_path) if request_path }
-
-  it { expect(api).to be_a_kind_of(Tinybucket::Api::BaseApi) }
-
-  describe 'profile' do
-    subject { api.profile }
-
-    context 'when without username' do
-      let(:user) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with username' do
-      let(:request_path) { "/users/#{user}" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Profile) }
-    end
-  end
-
-  describe 'followers' do
-    subject { api.followers }
-
-    context 'when without username' do
-      let(:user) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with username' do
-      let(:request_path) { "/users/#{user}/followers" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-
-  describe 'following' do
-    subject { api.following }
-
-    context 'when without username' do
-      let(:user) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with username' do
-      let(:request_path) { "/users/#{user}/following" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-
-  describe 'repos' do
-    subject { api.repos }
-
-    context 'when without username' do
-      let(:user) { nil }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-
-    context 'when with username' do
-      let(:request_path) { "/repositories/#{user}" }
-      it { expect(subject).to be_an_instance_of(Tinybucket::Model::Page) }
-    end
-  end
-end

data/spec/lib/tinybucket/api_factory_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tinybucket::ApiFactory do
-
-  describe 'create_instance' do
-    subject { Tinybucket::ApiFactory.create_instance(klass_name) }
-
-    context 'with valid klass_name' do
-      let(:klass_name) { 'PullRequests' }
-      it { expect(subject).to be_a_kind_of(Tinybucket::Api::BaseApi) }
-    end
-
-    context 'with invalid klass_name' do
-      let(:klass_name) { 'Invalid Klass Name' }
-      it { expect { subject }.to raise_error(ArgumentError) }
-    end
-  end
-end

data/spec/lib/tinybucket/client_spec.rb

@@ -1,100 +0,0 @@
-require 'spec_helper.rb'
-
-RSpec.describe Tinybucket::Client do
-  include ApiResponseMacros
-
-  let(:client) { Tinybucket::Client.new }
-
-  describe 'new' do
-    subject { Tinybucket::Client.new }
-    it { expect(subject).to be_an_instance_of(Tinybucket::Client) }
-  end
-
-  describe 'repos' do
-    context 'when get public repositories' do
-      before { stub_apiresponse(:get, '/repositories') }
-
-      context 'without options' do
-        subject { client.repos }
-        it { expect(subject).to be_instance_of(Tinybucket::Resource::Repos) }
-        it { expect(subject.instance_variable_get(:@owner)).to be_nil }
-      end
-      context 'with options' do
-        subject { client.repos(options) }
-        let(:options) { {} }
-        it { expect(subject).to be_instance_of(Tinybucket::Resource::Repos) }
-        it { expect(subject.instance_variable_get(:@owner)).to be_nil }
-      end
-    end
-
-    context 'when get repositories of the owner' do
-      let(:owner) { 'test_owner' }
-      let(:request_path) { "/repositories/#{owner}" }
-      before { stub_apiresponse(:get, request_path) }
-
-      context 'without options' do
-        subject { client.repos(owner) }
-        it { expect(subject).to be_instance_of(Tinybucket::Resource::Repos) }
-        it { expect(subject.instance_variable_get(:@owner)).to eq(owner) }
-      end
-      context 'with options' do
-        let(:options) { { page: 1 } }
-        subject { client.repos(owner, options) }
-        it { expect(subject).to be_instance_of(Tinybucket::Resource::Repos) }
-        it { expect(subject.instance_variable_get(:@owner)).to eq(owner) }
-      end
-      context 'with invalid options' do
-        subject { client.repos(owner, 'invalid options') }
-        it { expect { subject }.to raise_error(ArgumentError) }
-      end
-      context 'with invalid owner and options' do
-        let(:invalid_owner) { 200 }
-        let(:options) { { page: 1 } }
-        subject { client.repos(invalid_owner, options) }
-        it { expect { subject }.to raise_error(ArgumentError) }
-      end
-    end
-
-    context 'when invalid argument passed' do
-      context 'with a integer' do
-        subject { client.repos(20) }
-        it { expect { subject }.to raise_error(ArgumentError) }
-      end
-
-      context 'with a string and string' do
-        subject { client.repos('test_owner', 'test_repository') }
-        it { expect { subject }.to raise_error(ArgumentError) }
-      end
-
-      context 'with three arguments' do
-        subject { client.repos('a', 'b', 'c') }
-        it { expect { subject }.to raise_error(ArgumentError) }
-      end
-    end
-  end
-
-  describe 'repo' do
-    let(:repo_owner) { 'test_owner' }
-    let(:repo_slug) { 'test_repo' }
-
-    subject { client.repo(repo_owner, repo_slug) }
-
-    it 'return RepoApi instance' do
-      expect(subject).to be_instance_of(Tinybucket::Model::Repository)
-      expect(subject.repo_owner).to eq(repo_owner)
-      expect(subject.repo_slug).to eq(repo_slug)
-    end
-  end
-
-  describe 'team' do
-    let(:team) { 'test_team' }
-    subject { client.team(team) }
-    it { expect(subject).to be_instance_of(Tinybucket::Model::Team) }
-  end
-
-  describe 'user' do
-    let(:user) { 'test_owner' }
-    subject { client.user(user) }
-    it { expect(subject).to be_instance_of(Tinybucket::Model::Profile) }
-  end
-end

data/spec/lib/tinybucket/connection_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper.rb'
-
-RSpec.describe Tinybucket::Connection do
-
-  class MockApi
-    include Tinybucket::Connection
-
-    def config(key)
-      nil
-    end
-  end
-
-  let(:mock_api){ MockApi.new }
-
-  describe 'clear_cache' do
-    pending 'TODO: this method is required ?'
-  end
-
-  describe 'caching?' do
-    pending 'TODO: this method is required ?'
-  end
-
-  describe 'connection(options, parser)' do
-    subject{ mock_api.connection }
-
-    context 'when no params are given ' do
-      it { expect(subject).to be_instance_of(Faraday::Connection) }
-    end
-  end
-end

data/spec/lib/tinybucket/error/service_error_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tinybucket::Error::ServiceError do
-  context 'initialize' do
-    let(:env) do
-      {
-        response_headers: [],
-        method: 'POST',
-        url: 'https://api.example.org/path/to',
-        status: 500,
-        body: 'Internal Server Error'
-      }
-    end
-
-    subject { Tinybucket::Error::ServiceError.new(env) }
-
-    it { expect(subject).to be_an_instance_of(Tinybucket::Error::ServiceError) }
-    it { expect(subject.http_method).to eq(env[:method]) }
-    it { expect(subject.request_url).to eq(env[:url]) }
-    it { expect(subject.status_code).to eq(env[:status]) }
-    it { expect(subject.response_body).to eq(env[:body]) }
-  end
-end