bitbuckets 0.2.0

data/lib/bitbucket_rest_api/users/account.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module BitBucket
+  class Users::Account < API
+    # API about users/account , please refer to
+    # https://confluence.atlassian.com/display/BITBUCKET/account+Resource
+    #
+
+    # GET the account profile
+    #
+    def profile(accountname)
+      response = get_request("/1.0/users/#{accountname}")
+    end
+
+    # GET the account plan
+    def plan(accountname)
+      response = get_request("/1.0/users/#{accountname}/plan")
+    end
+
+    # GET the emails
+    def emails(accountname)
+      response = get_request("/1.0/users/#{accountname}/emails")
+    end
+
+    # GET the followers
+    def followers(accountname)
+      response = get_request("/1.0/users/#{accountname}/followers")
+    end
+
+    # GET the events
+    def events(accountname)
+      response = get_request("/1.0/users/#{accountname}/events")
+    end
+
+    # GET the keys
+    def keys(accountname)
+      response = get_request("/1.0/users/#{accountname}/ssh-keys")
+    end
+
+    # POST a new key
+    # params should be in format {key: "", label:""}
+    def new_key(accountname, params)
+      response = post_request("/1.0/users/#{accountname}/ssh-keys/", params)
+    end
+
+    # DELETE a key
+    def delete_key(accountname, key_id)
+      response = delete_request("/1.0/users/#{accountname}/ssh-keys/#{key_id}")
+    end
+  end # Users::Account
+end # BitBucket

data/lib/bitbucket_rest_api/utils/url.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require 'cgi'
+
+module BitBucket
+  module Utils
+    module Url
+      module_function
+
+      DEFAULT_QUERY_SEP = /[&;] */n.freeze
+
+      KEY_VALUE_SEP = '='
+
+      def escape(s)
+        CGI.escape s.to_s
+      end
+
+      def unescape(s)
+        CGI.unescape s.to_s
+      end
+
+      def build_query(params)
+        params.map do |k, v|
+          if v.class == Array
+            build_query(v.map { |x| [k, x] })
+          else
+            v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
+          end
+        end.join('&')
+      end
+
+      def parse_query(query_string)
+        return '' if query_string.nil? || query_string.empty?
+
+        params = {}
+
+        query_string.split(DEFAULT_QUERY_SEP).each do |part|
+          k, v = part.split(KEY_VALUE_SEP, 2).map { |el| unescape(el) }
+
+          if cur = params[k]
+            if cur.class == Array
+              params[k] << v
+            else
+              params[k] = [cur, v]
+            end
+          else
+            params[k] = v
+          end
+        end
+        params
+      end
+
+      def parse_query_for_param(query_string, name)
+        parse_query(query_string).each do |key, val|
+          return val.first if (name == key) && val.is_a?(Array)
+          return val if name == key
+        end
+        nil
+      end
+    end # Url
+  end # Utils
+end # BitBucket

data/lib/bitbucket_rest_api/validations.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module BitBucket
+  module Validations
+    extend AutoloadHelper
+
+    autoload_all 'bitbucket_rest_api/validations',
+                 Presence: 'presence',
+                 Token: 'token',
+                 Format: 'format',
+                 Required: 'required'
+
+    include Presence
+    include Format
+    include Token
+    include Required
+
+    VALID_API_KEYS = %w[
+      page
+      per_page
+      jsonp_callback
+    ].freeze
+  end # Validation
+end # BitBucket

data/lib/bitbucket_rest_api/validations/format.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module BitBucket
+  module Validations
+    module Format
+      # Ensures that value for a given key is of the correct form whether
+      # matching regular expression or set of predefined values.
+      #
+      def assert_valid_values(permitted, params)
+        params.each do |k, v|
+          next unless permitted.keys.include?(k)
+          if permitted[k].is_a?(Array) && !permitted[k].include?(params[k])
+            raise BitBucket::Error::UnknownValue.new(k, v, permitted[k].join(', '))
+
+          elsif permitted[k].is_a?(Regexp) && permitted[k] !~ params[k]
+            raise BitBucket::Error::UnknownValue.new(k, v, permitted[k])
+          end
+        end
+      end
+    end # Format
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/presence.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module BitBucket
+  module Validations
+    module Presence
+      # Ensures that essential arguments are present before request is made
+      #
+      def _validate_presence_of(*params)
+        params.each do |param|
+          raise ArgumentError, 'parameter cannot be nil' if param.nil?
+        end
+      end
+
+      # Check if user or repository parameters are passed
+      #
+      def _validate_user_repo_params(user_name, repo_name)
+        raise ArgumentError, '[user] parameter cannot be nil' if user_name.nil?
+        raise ArgumentError, '[repo] parameter cannot be nil' if repo_name.nil?
+      end
+    end # Presence
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/required.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module BitBucket
+  module Validations
+    module Required
+      # Validate all keys present in a provided hash against required set,
+      # on mismatch raise BitBucket::Error::RequiredParams
+      # Note that keys need to be in the same format i.e. symbols or strings,
+      # otherwise the comparison will fail.
+      #
+      def assert_required_keys(required, provided)
+        result = required.all? do |key|
+          provided.has_deep_key? key
+        end
+        raise BitBucket::Error::RequiredParams.new(provided, required) unless result
+
+        result
+      end
+
+      # Validate that required values are not blank
+      # the *required are colon separated strings
+      # e.g. 'source:branch:name' tests value of params[:source][:branch][:name]
+      #
+      def assert_required_values_present(params, *required)
+        required.each do |encoded_string|
+          keys = parse_values(encoded_string)
+          value = keys.inject(params) { |params, key| params[key] }
+          next unless value.is_a?(String)
+          raise BitBucket::Error::BlankValue, encoded_string if value.empty?
+        end
+      end
+
+      def parse_values(string)
+        string.split(':')
+      end
+    end # Required
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/validations/token.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# TODO: Set token required calls
+
+module BitBucket
+  module Validations
+    module Token
+      TOKEN_REQUIRED = [
+        'get /user',
+        'get /user/emails',
+        'get /user/followers',
+        'get /user/following',
+        'get /user/keys',
+        'get /user/repos',
+        'patch /user',
+        'post /user/emails',
+        'post /user/keys',
+        'post /user/repos'
+      ].freeze
+
+      TOKEN_REQUIRED_REGEXP = [
+        %r{repos/.*/.*/comments}
+      ].freeze
+
+      # Ensures that required authentication token is present before
+      # request is sent.
+      #
+      def validates_token_for(method, path)
+        return true unless TOKEN_REQUIRED.grep("#{method} #{path}").empty?
+
+        token_required = false
+        TOKEN_REQUIRED_REGEXP.each do |regex|
+          token_required = true if "#{method} #{path}" =~ regex
+        end
+        token_required
+      end
+    end # Token
+  end # Validations
+end # BitBucket

data/lib/bitbucket_rest_api/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module BitBucket
+  module VERSION
+    MAJOR = 0
+    MINOR = 2
+    PATCH = 0
+
+    STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+  end
+end # BitBucket

data/lib/bitbuckets.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require_relative 'bitbucket_rest_api'

data/spec/bitbucket_rest_api/api/actions_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe BitBucket::API, '#actions' do
+  let(:api) { BitBucket::Repos::Keys }
+
+  context 'when class' do
+    it 'lists all available actions for an api' do
+      expect(api.actions).to match_array(%i[actions all create delete edit list])
+    end
+  end
+
+  context 'when instance' do
+    it 'lists all available actions for an api' do
+      expect(api.new.actions).to match_array(%i[actions all create delete edit list])
+    end
+  end
+end

data/spec/bitbucket_rest_api/api_factory_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe BitBucket::ApiFactory do
+  subject(:factory) { described_class }
+
+  context '#new' do
+    it 'throws error if klass type is ommitted' do
+      expect { factory.new nil }.to raise_error(ArgumentError)
+    end
+
+    it 'instantiates a new object' do
+      expect(factory.new('Issues')).to be_a BitBucket::Issues
+    end
+  end
+
+  context '#create_instance' do
+    it 'creates class instance' do
+      expect(factory.create_instance('User', {})).to be_kind_of(BitBucket::User)
+    end
+  end
+
+  context '#convert_to_constant' do
+    it 'knows how to convert nested classes' do
+      expect(factory.convert_to_constant('Repos::Changesets')).to eql(BitBucket::Repos::Changesets)
+    end
+  end
+end # BitBucket::ApiFactory

data/spec/bitbucket_rest_api/api_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe BitBucket::API do
+  let(:setup_options) { { user: 'test_user' } }
+  let(:bitbucket_api) { described_class.new(setup_options) }
+  after do
+    %i[user login password].each do |key|
+      bitbucket_api.send "clear_#{key}".to_sym
+    end
+  end
+
+  describe '#new' do
+    it 'passes options to bitbucket' do
+      described_class.new(setup_options)
+
+      expect(bitbucket_api.user).to eq(setup_options[:user])
+    end
+
+    context 'valid options' do
+      it 'sets valid options' do
+        setup_options = {
+          login: 'johnwick',
+          password: 'password'
+        }
+        bitbucket_api = described_class.new(setup_options)
+
+        expect(bitbucket_api.login).to eq('johnwick')
+        expect(bitbucket_api.password).to eq('password')
+      end
+
+      it 'ignores invalid options' do
+        setup_options = {
+          invalid_option: 'invalid option'
+        }
+
+        bitbucket_api = described_class.new(setup_options)
+
+        expect { bitbucket_api.invalid_option }.to raise_error(NoMethodError)
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    let(:setup_options) { { user: 'test_user' } }
+
+    it 'responds to attribute query' do
+      expect(bitbucket_api.user?).to eq(true)
+    end
+
+    it 'clears the attributes' do
+      bitbucket_api.clear_user
+
+      expect(bitbucket_api.user).to be_nil
+    end
+  end
+
+  describe '#_update_user_repo_params' do
+    it 'sets the username and repo_name' do
+      bitbucket_api._update_user_repo_params('test_user1', 'test_repo')
+
+      expect(bitbucket_api.user).to eq('test_user1')
+      expect(bitbucket_api.repo).to eq('test_repo')
+    end
+  end
+
+  describe '#_merge_user_into_params!' do
+    let(:params) { {} }
+
+    it 'takes a hash and merges user into it' do
+      bitbucket_api._merge_user_into_params!(params)
+
+      expect(params).to include('user')
+    end
+  end
+
+  describe '#_merge_user_repo_into_params!' do
+    let(:params) { {} }
+
+    it 'takes a hash and merges user into it' do
+      new_params = bitbucket_api._merge_user_repo_into_params!(params)
+
+      expect(new_params).to include('user')
+      expect(new_params).to include('repo')
+    end
+  end
+end

data/spec/bitbucket_rest_api/authorization_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe BitBucket::Authorization do
+  let(:oauth_api) { BitBucket::API.new(oauth_token: 'example_oauth_token') }
+  let(:basic_auth_api) { BitBucket::API.new(basic_auth: 'example_login:example_password') }
+  let(:basic_auth_api_hash) do
+    BitBucket::API.new(
+      basic_auth: { login: 'example_login', password: 'example_password' }
+    )
+  end
+  let(:login_and_password_api) do
+    BitBucket::API.new(
+      login: 'example_login',
+      password: 'example_password',
+      basic_auth: nil
+    )
+  end
+
+  describe '#authenticated?' do
+    context 'oauth authentication' do
+      it 'should return true if oauth is used' do
+        expect(oauth_api.authenticated?).to eq(true)
+      end
+    end
+
+    context 'basic authentication' do
+      it 'should return true if basic authentication is used' do
+        expect(basic_auth_api.authenticated?).to eq(true)
+      end
+    end
+  end
+
+  describe '#basic_authed?' do
+    context 'with basic_auth' do
+      it 'should return true if basic_auth is set' do
+        expect(basic_auth_api.basic_authed?).to eq(true)
+        expect(basic_auth_api_hash.basic_authed?).to eq(true)
+      end
+    end
+
+    context 'with login and password' do
+      it 'should return true if a login and password are set' do
+        expect(login_and_password_api.basic_authed?).to eq(true)
+      end
+    end
+  end
+
+  describe '#authentication' do
+    context 'with basic_auth as a string' do
+      it 'should return a hash containing the value for :basic_auth' do
+        expectation = { basic_auth: 'example_login:example_password' }
+
+        expect(basic_auth_api.authentication).to eq(expectation)
+      end
+    end
+
+    context 'with basic_auth as a hash' do
+      it 'should return a hash containing the value for :basic_auth' do
+        expectation = { basic_auth: { login: 'example_login', password: 'example_password' } }
+
+        expect(basic_auth_api_hash.authentication).to eq(expectation)
+      end
+    end
+
+    context 'with login and password' do
+      it 'should return a hash containing values for :login and :password' do
+        expectation = { login: 'example_login', password: 'example_password' }
+
+        expect(login_and_password_api.authentication).to eq(expectation)
+      end
+    end
+  end
+end