bitbucket_rest_api2 0.2.0

data/spec/bitbucket_rest_api/request/jsonize_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe BitBucket::Request::Jsonize do
+  let(:jsonize) { described_class.new(lambda { |env| env }) }
+  before do
+    @env = {
+      body: {key1: 'val1'},
+      request_headers: {
+        'Content-Type' => 'application/json; charset=utf-8'
+      }
+    }
+  end
+
+  it "converts the body to json" do
+    expected = {body: "{\"key1\":\"val1\"}", request_headers: {"Content-Type"=>"application/json; charset=utf-8"}}
+    expect(jsonize.call(@env)).to eq expected
+  end
+end

data/spec/bitbucket_rest_api/request/oauth_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'rack/test'
+
+describe BitBucket::Request::OAuth do
+  include Rack::Test::Methods
+
+
+  let(:app) { ->(env) { [200, env, "app"] } }
+
+  let (:middleware) { BitBucket::Request::OAuth.new(app) }
+
+  let(:request) { Rack::MockRequest.new(middleware) }
+
+  it "add url key to env hash with URI value" do
+    query_string = "key1=val1&key2=val2"
+    code, env = middleware.call Rack::MockRequest.env_for("/?#{query_string}", {method: :post})
+    expect(code).to eq 200
+    expect(env[:url].query).to eq query_string
+  end
+
+  it "creates a empty hash if query of URI is empty" do
+    code, env = middleware.call Rack::MockRequest.env_for("/", {method: :get})
+    expect(code).to eq 200
+    expect(middleware.query_params(env[:url])).to eq({})
+  end
+end
+

data/spec/bitbucket_rest_api/request_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'bitbucket_rest_api/request'
+
+describe BitBucket::Request do
+  let(:fake_api) { (Class.new { include BitBucket::Request })}
+  let(:faraday_connection) { Faraday.new(:url => 'https://api.bitbucket.org') }
+
+  describe "request" do
+    it "raises an ArgumentError if an unsupported HTTP verb is used" do
+      expect { fake_api.new.request(:i_am_a_teapot, {}, '/') }.to raise_error(ArgumentError)
+    end
+
+    context "with a connection" do
+      before do
+        (fake_api).any_instance.stubs(:connection).returns(faraday_connection)
+        (fake_api).any_instance.stubs(:new_access_token).returns("12345")
+      end
+
+      it "supports get" do
+        stub_request(:get, "https://api.bitbucket.org/2.0/endpoint").
+         with(:headers => {
+          'Accept' => '*/*',
+          'Accept-Encoding' => 'gzip;q=2.0,deflate;q=0.6,identity;q=0.3',
+          'Authorization' => 'Bearer 12345',
+          'User-Agent' => 'Faraday v0.9.2'
+          })
+
+        fake_api.new.request(:get, '/2.0/endpoint', {}, {})
+      end
+
+      it "supports put" do
+        stub_request(:put, "https://api.bitbucket.org/2.0/endpoint").
+         with(:body => "{\"data\":{\"key\":\"value\"}}",
+          :headers => {
+            'Accept' => '*/*',
+            'Content-Type'=>'application/x-www-form-urlencoded',
+            'Authorization' => 'Bearer 12345',
+            'User-Agent' => 'Faraday v0.9.2'
+          })
+
+        fake_api.new.request(:put, '/2.0/endpoint', { 'data' => { 'key' => 'value'} }, {})
+      end
+
+      it "supports patch" do
+        stub_request(:patch, "https://api.bitbucket.org/2.0/endpoint").
+         with(:body => "{\"data\":{\"key\":\"value\"}}",
+          :headers => {
+            'Accept' => '*/*',
+            'Content-Type'=>'application/x-www-form-urlencoded',
+            'Authorization' => 'Bearer 12345',
+            'User-Agent' => 'Faraday v0.9.2'
+          })
+
+        fake_api.new.request(:patch, '/2.0/endpoint', { 'data' => { 'key' => 'value'} }, {})
+      end
+
+      it "supports delete" do
+        stub_request(:delete, "https://api.bitbucket.org/2.0/endpoint").
+         with(:headers => {
+          'Accept' => '*/*',
+          'Authorization' => 'Bearer 12345',
+          'User-Agent' => 'Faraday v0.9.2'
+          })
+        fake_api.new.request(:delete, '/2.0/endpoint', {}, {})
+      end
+
+      it "supports post" do
+        stub_request(:post, "https://api.bitbucket.org/2.0/endpoint").
+         with(:body => "{\"data\":{\"key\":\"value\"}}",
+          :headers => {
+            'Accept' => '*/*',
+            'Content-Type'=>'application/x-www-form-urlencoded',
+            'Authorization' => 'Bearer 12345',
+            'User-Agent' => 'Faraday v0.9.2'
+          })
+
+        fake_api.new.request(:post, '/2.0/endpoint', { 'data' => { 'key' => 'value'} }, {})
+      end
+    end
+  end
+end

data/spec/bitbucket_rest_api/response/jsonize_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe BitBucket::Response::Jsonize do
+  let(:jsonize) { described_class.new }
+  before do
+    @body = "{\"key1\":\"val1\"}"
+  end
+
+  it "parses the json and returns a hash" do
+    expect(jsonize.parse(@body)).to eq({"key1"=>"val1"})
+  end
+end

data/spec/bitbucket_rest_api/response/mashify_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe BitBucket::Response::Mashify do
+  # let(:mashify) { described_class.new }
+  describe 'parse' do
+    before do
+      @mashify = BitBucket::Response::Mashify.new
+      @string = "Fantastic week!"
+      @array = ['Monday', 'Tuesday']
+      @hash = {one: 'one', two: 'two', three: 'three'}
+      @array_with_hash = ['banana', 'apple', {:third => 'mango'}]
+    end
+    it 'parses a hash an returns a hashie mash' do
+      hashie_mash = @mashify.parse(@hash)
+      expect(hashie_mash.one).to eq("one")
+    end
+
+    it 'parses a hash that is within an array' do
+      array_hashie_mash = @mashify.parse(@array_with_hash)
+      expect(array_hashie_mash[2].third).to eq("mango")
+    end
+
+    it 'returns same object if the object does not contain a hash' do
+      string = @mashify.parse(@string)
+      array = @mashify.parse(@array)
+
+      expect(string).to eq(@string)
+      expect(array.length).to eq(2)
+      expect(array[0]).to eq("Monday")
+    end
+  end
+end

data/spec/bitbucket_rest_api/response/raise_error_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe BitBucket::Response::RaiseError do
+  describe '.on_complete' do
+    before do
+      @raise_error = BitBucket::Response::RaiseError.new
+    end
+
+    it 'raises a BadRequest error on 400 status code' do
+      expect{ @raise_error.on_complete({status: 400}) }.to raise_error BitBucket::Error::BadRequest
+    end
+
+    it 'raises an Unauthorized error on 401 status code' do
+      expect{ @raise_error.on_complete({status: 401}) }.to raise_error BitBucket::Error::Unauthorized
+    end
+
+    it 'raises a Forbidden error on 403 status code' do
+      expect{ @raise_error.on_complete({status: 403}) }.to raise_error BitBucket::Error::Forbidden
+    end
+
+    it 'raises a NotFound error on 404 status code' do
+      expect{ @raise_error.on_complete({status: 404}) }.to raise_error BitBucket::Error::NotFound
+    end
+
+    it 'raises an UnprocessableEntity error on 422 status code' do
+      expect{ @raise_error.on_complete({status: 422}) }.to raise_error BitBucket::Error::UnprocessableEntity
+    end
+
+    it 'raises an InternalServerError error on 500 status code' do
+      expect{ @raise_error.on_complete({status: 500}) }.to raise_error BitBucket::Error::InternalServerError
+    end
+
+    it 'raises a ServiceUnavailable error on 503 status code' do
+      expect{ @raise_error.on_complete({status: 503}) }.to raise_error BitBucket::Error::ServiceUnavailable
+    end
+
+    it 'raises a ServiceError when another status code' do
+      expect{ @raise_error.on_complete({status: 501}) }.to raise_error BitBucket::Error::ServiceError
+    end
+  end
+end

data/spec/bitbucket_rest_api/user_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe BitBucket::User do
+  let(:options) do
+    {
+      client_id:     'example_client_id',
+      client_secret: 'example_client_secret',
+      oauth_token:   'example_oauth_token',
+      oauth_secret:  'example_oauth_secret',
+      adapter:       :net_http
+    }
+  end
+
+  before do
+    @user = BitBucket::User.new(options)
+  end
+
+  describe '#profile' do
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:get, '/2.0/user', {}, {})
+      @user.profile
+    end
+  end
+
+  describe '#update' do
+    let(:params) do
+      { first_name: 'first-name', last_name: 'last-name', avatar: '' }
+    end
+
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:put, '/2.0/user', params, {})
+      @user.update(params)
+    end
+  end
+
+  describe '#privileges' do
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:get, '/2.0/user/privileges', {}, {})
+      @user.privileges
+    end
+  end
+
+  describe '#follows' do
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:get, '/2.0/user/follows', {}, {})
+      @user.follows
+    end
+  end
+
+  describe '#repositories' do
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:get, '/2.0/user/repositories', {}, {})
+      @user.repositories
+    end
+  end
+
+  describe '#repos' do
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:get, '/2.0/user/repositories', {}, {})
+      @user.repos
+    end
+  end
+
+  describe '#overview' do
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:get, '/2.0/user/repositories/overview', {}, {})
+      @user.overview
+    end
+  end
+
+  describe '#dashboard' do
+    it 'sends the request to the right url' do
+      expect(@user).to receive(:request).with(:get, '/2.0/user/repositories/dashboard', {}, {})
+      @user.dashboard
+    end
+  end
+end

data/spec/bitbucket_rest_api/utils/url_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe BitBucket::Utils::Url do
+  before do
+      @url_util = BitBucket::Utils::Url
+    end
+
+  describe '.build_query' do
+    it 'builds a query string from a params hash' do
+      expect(@url_util.build_query({key1: "val1", key2: "val2"})).to eq "key1=val1&key2=val2"
+    end
+
+    it 'builds a query string from a params hash when one value is an array' do
+      expect(@url_util.build_query({key1: "val1", key2: ["val2", "val3"]})).to eq "key1=val1&key2=val2&key2=val3"
+    end
+  end
+
+  describe '.parse_query' do
+    it 'builds a params hash from a query string' do
+      expect(@url_util.parse_query("key1=val1&key2=val2")).to eq({"key1" => "val1", "key2" => "val2"})
+    end
+
+    it 'builds a params hash from a query string when given multiple values for the same param' do
+      expect(@url_util.parse_query("key1=val1&key2=val2&key2=val3&key2=val4")).to eq({"key1" => "val1", "key2" => ["val2", "val3", "val4"]})
+    end
+  end
+
+  describe '.parse_query_for_param' do
+    it 'returns a value a query string given the key' do
+      expect(@url_util.parse_query_for_param("key1=val1&key2=val2", "key2")).to eq("val2")
+    end
+  end
+end

data/spec/bitbucket_rest_api/validations/format_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe BitBucket::Validations::Format do
+  let(:format) { Class.new.extend(described_class) }
+  before do
+    @permitted = {"param1" => ["val1", "val2"], "param2" => /^regexp$/}
+  end
+
+  describe ".assert_valid_values" do
+    it "raises an UnknownValue error when provided an unpermitted parameter" do
+      params = {"param1" => "unpermitted_value"}
+      expect{
+        format.assert_valid_values(@permitted, params)
+        }.to raise_error BitBucket::Error::UnknownValue
+
+      params = {"param2" => "unpermitted_value"}
+      expect{
+        format.assert_valid_values(@permitted, params)
+        }.to raise_error BitBucket::Error::UnknownValue
+    end
+
+    it "returns the params when provided with only permitted parameters" do
+      params = {"param1" => "val1", "param2" => "regexp"}
+      expect(
+        format.assert_valid_values(@permitted, params)
+        ).to eq({"param1" => "val1", "param2" => "regexp"})
+    end
+  end
+end

data/spec/bitbucket_rest_api/validations/presence_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe BitBucket::Validations::Presence do
+  let(:presence_checker) { Class.new.extend(described_class) }
+
+  describe "._validates_user_repo_params" do
+    it 'raises an ArgumentError if user_name or repo_name is nil' do
+      expect{presence_checker._validate_user_repo_params('user_name', nil)}.to raise_error ArgumentError
+      expect{presence_checker._validate_user_repo_params(nil, 'repo_name')}.to raise_error ArgumentError
+    end
+  end
+end

data/spec/bitbucket_rest_api/validations/required_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe BitBucket::Validations::Required do
+  class SpecClass
+    include BitBucket::Validations::Required
+  end
+
+  let(:spec_class) { SpecClass.new }
+  let(:params_with_blank) do
+    {
+      'title' => "mock_title",
+      'source' => {
+        'branch' => {
+          'name' => ""
+        }
+      }
+    }
+  end
+
+  describe '#parse_values' do
+    it 'parses a colon separated string to an array' do
+      result = spec_class.parse_values('hello:world')
+      expectation = ['hello', 'world']
+
+      expect(result).to eq(expectation)
+    end
+  end
+
+  describe '#assert_required_values_present' do
+    it 'raises an instance of BitBucket::Error::BlankValue if a required string is left blank' do
+      expect do
+        spec_class.assert_required_values_present(
+          params_with_blank,
+          'title',
+          'source:branch:name'
+        )
+      end.to raise_error(
+        BitBucket::Error::BlankValue,
+        "The value for: 'source:branch:name', cannot be blank :("
+      )
+    end
+  end
+end

data/spec/bitbucket_rest_api/validations/token_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe BitBucket::Validations::Token do
+  let(:token) { Class.new.extend(described_class) }
+
+  describe ".validates_token_for" do
+    it 'returns false if authentication token is not required' do
+      expect(token.validates_token_for(:get, '/anotherpath')).to be false
+    end
+
+    it 'returns true if authentication token is required' do
+      expect(token.validates_token_for(:get, '/user')).to be true
+      expect(token.validates_token_for(:get, '/repos/a/b/comments')).to be true
+    end
+  end
+end

data/spec/bitbucket_rest_api_spec.rb

@@ -0,0 +1,17 @@
+describe BitBucket do
+  let(:api) { BitBucket }
+
+  describe "register_constant" do
+    it "sets a constant" do
+      api.register_constant({const_1: 'value1'})
+    end
+  end
+
+  describe "lookup_constant" do
+    it "returns the constant's value" do
+      expect(api.lookup_constant('CONST_1')).to eq 'value1'
+      expect{ api.lookup_constant('UNKNOWN_CONSTANT')}.to raise_error NameError
+    end
+  end
+
+end