tinybucket 0.1.0

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

@@ -0,0 +1,100 @@
+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_config) { {} }
+  let(:api) do
+    api = Tinybucket::Api::RepoApi.new(api_config)
+    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

@@ -0,0 +1,28 @@
+require 'spec_helper.rb'
+
+RSpec.describe Tinybucket::Api::ReposApi do
+  include ApiResponseMacros
+
+  let(:api_config) { {} }
+  let(:api) { Tinybucket::Api::ReposApi.new(api_config) }
+
+  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

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+RSpec.describe Tinybucket::Api::TeamApi do
+  include ApiResponseMacros
+
+  let(:api_config) { {} }
+  let(:api) do
+    Tinybucket::Api::TeamApi.new(api_config)
+  end
+
+  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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+RSpec.describe Tinybucket::Api::UserApi do
+  include ApiResponseMacros
+
+  let(:api_config) { {} }
+  let(:api) do
+    api = Tinybucket::Api::UserApi.new(api_config)
+    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
+end

data/spec/lib/tinybucket/api_factory_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe Tinybucket::ApiFactory do
+
+  describe 'create_instance' do
+    let(:klass_name) { 'PullRequests' }
+    let(:config) { {} }
+    let(:options) { {} }
+
+    subject do
+      Tinybucket::ApiFactory.create_instance(klass_name, config, options)
+    end
+
+    context 'with valid klass_name' do
+      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

@@ -0,0 +1,102 @@
+require 'spec_helper.rb'
+
+RSpec.describe Tinybucket::Client do
+  include ApiResponseMacros
+
+  let(:client) { Tinybucket::Client.new({}) }
+
+  describe 'new' do
+    let(:options) { {} }
+
+    context 'without block' do
+      subject { Tinybucket::Client.new(options) }
+      it { expect(subject.config).to eq(options) }
+    end
+
+    context 'with block' do
+      subject do
+        Tinybucket::Client.new do |config|
+          options.each_pair do |key, value|
+            config.send("#{key}=", value)
+          end
+        end
+      end
+      it { expect(subject.config).to eq(options) }
+    end
+  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::Model::Page) }
+      end
+      context 'with options' do
+        subject { client.repos(options) }
+        let(:options) { {} }
+        it { expect(subject).to be_instance_of(Tinybucket::Model::Page) }
+      end
+    end
+
+    context 'when get repositories of the owner' do
+      let(:owner) { 'test_owner' }
+      before { stub_apiresponse(:get, request_path) }
+
+      context 'without options' do
+        let(:request_path) { "/repositories/#{owner}" }
+        subject { client.repos(owner) }
+        it { expect(subject).to be_instance_of(Tinybucket::Model::Page) }
+      end
+      context 'with options' do
+        let(:request_path) { "/repositories/#{owner}" }
+        subject { client.repos(owner, options) }
+        let(:options) { {} }
+        it { expect(subject).to be_instance_of(Tinybucket::Model::Page) }
+      end
+    end
+
+    context 'when invalid argument passed' do
+      context 'with a integer' do
+        subject { client.repos(20) }
+        it { expect { subject }.to raise_error }
+      end
+
+      context 'with a string and string' do
+        subject { client.repos('test_owner', 'test_repository') }
+        it { expect { subject }.to raise_error }
+      end
+
+      context 'with three arguments' do
+        subject { client.repos('a', 'b', 'c') }
+        it { expect { subject }.to raise_error }
+      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

@@ -0,0 +1,30 @@
+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/model/branch_restriction_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe Tinybucket::Model::BranchRestriction do
+  include ApiResponseMacros
+
+  let(:owner) { 'test_owner' }
+  let(:slug)  { 'test_repo' }
+
+  # TODO: fix model_json
+  let(:model_json) { nil }
+
+  let(:model) do
+    m = Tinybucket::Model::BranchRestriction.new(model_json)
+    m.repo_owner = owner
+    m.repo_slug  = slug
+
+    m
+  end
+
+  before { stub_apiresponse(:get, request_path, stub_options) if request_path }
+
+  describe '#update' do
+    pending 'TODO implement method'
+  end
+
+  describe '#destroy' do
+    pending 'TODO implement method'
+  end
+end