tinybucket 1.3.0 → 1.4.0

data/spec/lib/tinybucket/resource/watchers_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tinybucket::Resource::Watchers do
-  include ApiResponseMacros
-
-  let(:owner) { 'test_owner' }
-  let(:slug) { 'test_repo' }
-  let(:repo) do
-    Tinybucket::Model::Repository.new({}).tap do |m|
-      m.repo_owner = owner
-      m.repo_slug  = slug
-    end
-  end
-
-  let(:options) { {} }
-  let(:resource) { Tinybucket::Resource::Watchers.new(repo, options) }
-
-  describe 'Enumerable Methods' do
-    let(:params) { {} }
-    let(:request_path) do
-      "/repositories/#{owner}/#{slug}/watchers"
-    end
-    before { stub_enum_response(:get, request_path) }
-
-    describe '#take(1)' do
-      subject { resource.take(1) }
-      it { expect(subject).to be_an_instance_of(Array) }
-    end
-
-    describe '#each' do
-      it 'iterate models' do
-        resource.each do |m|
-          expect(m).to be_an_instance_of(Tinybucket::Model::Profile)
-        end
-      end
-    end
-  end
-end

data/spec/lib/tinybucket_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Tinybucket do
-
-  describe 'new' do
-    subject { Tinybucket.new }
-    it { expect(subject).to be_instance_of(Tinybucket::Client) }
-  end
-
-  describe 'config' do
-    subject { Tinybucket.config }
-    it { expect(subject).to be_an_instance_of(Tinybucket::Config) }
-  end
-
-  describe 'configure' do
-    subject(:config) { Tinybucket.config }
-    let(:logger) { Logger.new($stdout) }
-    let(:oauth_token) { 'test_oauth_token' }
-    let(:oauth_secret) { 'test_oauth_secret' }
-    let(:cache_store_options) { { logger: Tinybucket.logger } }
-
-    it 'is configurable' do
-      expect(config.logger).to be_nil
-
-      expect do
-        Tinybucket.configure do |config|
-          config.logger = logger
-          config.cache_store_options = cache_store_options
-          config.oauth_token = oauth_token
-          config.oauth_secret = oauth_secret
-        end
-      end.not_to raise_error
-
-      expect(config.logger).to eq(logger)
-      expect(config.cache_store_options).to eq(cache_store_options)
-      expect(config.oauth_token).to eq(oauth_token)
-      expect(config.oauth_secret).to eq(oauth_secret)
-    end
-
-    after { Tinybucket.instance_variable_set(:@config, nil) }
-  end
-end

data/spec/spec_helper.rb

@@ -1,45 +0,0 @@
-require 'rubygems'
-require 'bundler/setup'
-
-require 'rspec'
-require 'webmock/rspec'
-
-require 'pry'
-
-require 'coveralls'
-require 'simplecov'
-Coveralls.wear!
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-])
-SimpleCov.start do
-  add_filter '.bundle/'
-  add_filter 'spec'
-  add_filter 'features'
-end
-
-if ENV['CODECLIMATE_REPORT']
-  WebMock.disable_net_connect!(allow: 'codeclimate.com')
-  require 'codeclimate-test-reporter'
-  CodeClimate::TestReporter.start
-end
-
-require 'tinybucket'
-
-path = Pathname.new(Dir.pwd)
-Dir[path.join('spec/support/**/*.rb')].each { |f| require f }
-
-# configure tinybucket logger.
-Dir.mkdir('log') unless Dir.exist?('log')
-
-logger = Logger.new('log/test.log')
-logger.level = Logger::DEBUG
-Tinybucket.logger = logger
-
-RSpec.configure do |config|
-  config.extend FixtureMacros
-  config.include FixtureMacros
-  config.order = 'random'
-end

data/spec/support/api_response_macros.rb

@@ -1,74 +0,0 @@
-module ApiResponseMacros
-  def stub_apiresponse(method, path, options = {})
-    response_headers = { content_type: 'application/json' }.merge(options)
-
-    ext =
-      case response_headers[:content_type]
-      when 'plain/text' then; 'txt'
-      else                    'json'
-      end
-
-    stub_request(method, api_path(path))
-      .to_return(
-        status: (options[:status_code] || 200),
-        body: (options[:message] || fixture_json(method, path, ext)),
-        headers: response_headers)
-  end
-
-  def stub_enum_response(method, path)
-    response_headers = { content_type: 'application/json' }
-
-    first_page_json = fixture_json(method, path, 'json')
-
-    # stub for first page
-    stub_request(method, api_path(path))
-      .to_return(
-        status: 200,
-        body: first_page_json,
-        headers: response_headers)
-
-    # stub for second(last) page
-    next_url = JSON.parse(first_page_json)['next'] || api_path(path, page: 2)
-    stub_request(method, next_url)
-      .to_return(
-        status: 200,
-        body: last_page_json(api_path(path, page: 1)),
-        headers: response_headers)
-  end
-
-  private
-
-  def api_path(path, params = {})
-    'https://api.bitbucket.org/2.0' + path + query_string(params)
-  end
-
-  def query_string(params)
-    return '' if params.empty?
-
-    '?' + params.each_pair.map do |k, v|
-      URI.escape(k.to_s) + '=' + URI.escape(v.to_s)
-    end.join('&')
-  end
-
-  def fixture_json(method, path, ext)
-    parts = path.split('?')
-
-    path = 'spec/fixtures' + parts[0]
-    fname = method.to_s
-    fname += '_' + parts[1].gsub(/[\/??&=]/, '_') if parts[1].present?
-    fname += '.' + ext
-
-    File.read(path + '/' + fname)
-  end
-
-  def last_page_json(prev)
-    JSON.generate(
-      size: 1,
-      page: 2,
-      pagelen: 0,
-      next: nil,
-      previous: prev,
-      values: []
-    )
-  end
-end

data/spec/support/fixture_macros.rb

@@ -1,5 +0,0 @@
-module FixtureMacros
-  def load_json_fixture(suffix)
-    JSON.load(File.read('spec/fixtures/' + suffix + '.json'))
-  end
-end

data/spec/support/model_macros.rb

@@ -1,103 +0,0 @@
-module ModelMacros
-  RSpec.shared_examples 'model has acceptable_attributes' do |cls, model_json|
-    describe '#attribute=' do
-      subject { cls.new(json) }
-
-      context 'json contains only expected attrs' do
-        let(:json) { model_json }
-        it { expect { subject }.not_to raise_error }
-        it 'receive each attributes' do
-          json.each_pair do |key, value|
-            expect(subject.send(key.intern)).to eq(value)
-          end
-        end
-      end
-
-      context 'json contains un-acceptable attrs' do
-        let(:json) { model_json.merge('_un_acceptable_key' => 'some_value') }
-        it { expect { subject }.not_to raise_error }
-        it 'receive each acceptable attributes' do
-          model_json.each_pair do |key, value|
-            expect(subject.send(key.intern)).to eq(value)
-          end
-        end
-      end
-    end
-  end
-
-  RSpec.shared_examples 'the model is reloadable' do
-    describe '#load' do
-      before do
-        allow(@model).to \
-          receive_message_chain(:load_model, :attributes).and_return({})
-      end
-      subject { @model.load }
-
-      context 'when not loaded' do
-        it { expect(subject).to be_truthy }
-      end
-
-      context 'when load failed' do
-        let(:env) do
-          {
-            htt_method: :get,
-            request_url: 'https://localhost/path/to/resource',
-            status_code: 404,
-            response_body: 'not found'
-          }
-        end
-        before do
-          @model.stub(:load_model) { raise Tinybucket::Error::NotFound.new(env) }
-        end
-
-        it { expect { subject }.to raise_error(Tinybucket::Error::NotFound) }
-      end
-    end
-
-    describe '#loaded?' do
-      subject { @model.loaded? }
-
-      context 'when model is not loaded' do
-        it { expect(@model.loaded?).to be_falsey }
-      end
-
-      context 'when model is already loaded' do
-        before do
-          allow(@model).to \
-            receive_message_chain(:load_model, :attributes).and_return({})
-          @model.load
-        end
-        it { expect(subject).to be_truthy }
-      end
-    end
-
-    describe '#reload' do
-      subject { @model.reload }
-
-      context 'when load successfully' do
-        before do
-          allow(@model).to \
-            receive_message_chain(:load_model, :attributes).and_return({})
-          @model.load
-        end
-        it { expect(subject).to be_truthy }
-      end
-
-      context 'when load failed' do
-        let(:env) do
-          {
-            htt_method: :get,
-            request_url: 'https://localhost/path/to/resource',
-            status_code: 404,
-            response_body: 'not found'
-          }
-        end
-        before do
-          @model.stub(:load_model) { raise Tinybucket::Error::NotFound.new(env) }
-        end
-
-        it { expect { subject }.to raise_error(Tinybucket::Error::NotFound) }
-      end
-    end
-  end
-end