gitlab-akerl 4.0.0

data/spec/gitlab/error_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Gitlab::Error do
+  describe "#handle_message" do
+		require "stringio"
+
+    before do
+      request_object  = HTTParty::Request.new(Net::HTTP::Get, '/')
+      response_object = Net::HTTPOK.new('1.1', 200, 'OK')
+      body = StringIO.new("{foo:'bar'}")
+      def body.message; self.string; end
+
+      parsed_response = lambda { body }
+      response_object['last-modified'] = Date.new(2010, 1, 15).to_s
+      response_object['content-length'] = "1024"
+
+      response = HTTParty::Response.new(request_object, response_object, parsed_response, body: body)
+      @error = Gitlab::Error::ResponseError.new(response)
+
+      @array = Array.new(['First message.', 'Second message.'])
+      @obj_h = Gitlab::ObjectifiedHash.new(user: ['not set'],
+                                           password: ['too short'],
+                                           embed_entity: { foo: ['bar'], sna: ['fu'] })
+    end
+
+    context "when passed an ObjectifiedHash" do
+      it "should return a joined string of error messages sorted by key" do
+        expect(@error.send(:handle_message, @obj_h)).to eq("'embed_entity' (foo: bar) (sna: fu), 'password' too short, 'user' not set")
+      end
+    end
+
+    context "when passed an Array" do
+      it "should return a joined string of messages" do
+        expect(@error.send(:handle_message, @array)).to eq("First message. Second message.")
+      end
+    end
+
+    context "when passed a String" do
+      it "should return the String untouched" do
+        error = 'this is an error string'
+        expect(@error.send(:handle_message, error)).to eq('this is an error string')
+      end
+    end
+  end
+end

data/spec/gitlab/file_response_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Gitlab::FileResponse do
+  before do
+    @file_response = Gitlab::FileResponse.new StringIO.new("", 'rb+')
+  end
+
+  context '.empty?' do
+    it "shoudl return false" do
+      expect(@file_response.empty?).to be false
+    end
+  end
+
+  context '.to_hash' do
+    it "should have `filename` key and `data` key" do
+      h = @file_response.to_hash
+      expect(h.has_key?(:filename)).to be_truthy
+      expect(h.has_key?(:data)).to be_truthy
+    end
+  end
+
+  context '.parse_headers!' do
+    it "should parse headers" do
+      @file_response.parse_headers!('Content-Disposition' => 'attachment; filename=artifacts.zip')
+      expect(@file_response.filename).to eq "artifacts.zip"
+    end
+
+    it "should handle quoted filenames" do
+      @file_response.parse_headers!('Content-Disposition' => 'attachment; filename="artifacts.zip"')
+      expect(@file_response.filename).to eq "artifacts.zip"
+    end
+  end
+end

data/spec/gitlab/help_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Gitlab::Help do
+  describe ".ri_cmd" do
+    context "ri command found" do
+      it "should return the path to RI" do
+        allow(Gitlab::Help).to receive(:`).with(/which ri/).and_return('/usr/bin/ri')
+        expect(Gitlab::Help.ri_cmd).to eq('/usr/bin/ri')
+      end
+    end
+
+    context "ri command NOT found" do
+      it "should raise" do
+        allow(Gitlab::Help).to receive(:`).with(/which ri/).and_return('')
+        expect { Gitlab::Help.ri_cmd }.to raise_error RuntimeError
+      end
+    end
+  end
+
+  describe ".change_help_output!" do
+    before do
+      @cmd = "create_branch"
+      @help_output = "Gitlab.#{@cmd}(4, 'new-branch', 'master')"
+      @help_output_with_options = "Gitlab.groups({ per_page: 3 })"
+    end
+    it "should return a String of modified output" do
+      Gitlab::Help.change_help_output! @cmd, @help_output
+      expect(@help_output).to eq("Gitlab.create_branch 4 'new-branch' 'master'")
+    end
+    it "should format options hash and return a String of modified output" do
+      Gitlab::Help.change_help_output! 'groups', @help_output_with_options
+      expect(@help_output_with_options).to eq("Gitlab.groups \"{ per_page: 3 }\"")
+    end
+  end
+
+  describe ".namespace" do
+    before do
+      @cmd = 'create_tag'
+      @namespace = Gitlab::Help.namespace @cmd
+    end
+    it "should return the full namespace for a command" do
+      expect(@namespace).to be_a String
+      expect(@namespace).to eq("Gitlab::Client::Tags.#{@cmd}")
+    end
+  end
+end

data/spec/gitlab/objectified_hash_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Gitlab::ObjectifiedHash do
+  before do
+    @hash = { a: 1, b: 2, 'string' => 'string', symbol: :symbol }
+    @oh = Gitlab::ObjectifiedHash.new @hash
+  end
+
+  it "should objectify hash" do
+    expect(@oh.a).to eq(@hash[:a])
+    expect(@oh.b).to eq(@hash[:b])
+  end
+
+  describe "#to_hash" do
+    it "should return an original hash" do
+      expect(@oh.to_hash).to eq(@hash)
+    end
+
+    it "should have an alias #to_h" do
+      expect(@oh.respond_to?(:to_h)).to be_truthy
+    end
+  end
+
+  describe "#inspect" do
+    it "should return a formatted string" do
+      pretty_string = "#<#{@oh.class.name}:#{@oh.object_id} {hash: #{@hash}}"
+      expect(@oh.inspect).to eq(pretty_string)
+    end
+  end
+
+  describe "#respond_to" do
+    it "should return true for methods this object responds to through method_missing as sym" do
+      expect(@oh.respond_to?(:a)).to be_truthy
+    end
+
+    it "should return true for methods this object responds to through method_missing as string" do
+      expect(@oh.respond_to?('string')).to be_truthy
+    end
+
+    it "should not care if you use a string or symbol to reference a method" do
+      expect(@oh.respond_to?(:string)).to be_truthy
+    end
+
+    it "should not care if you use a string or symbol to reference a method" do
+      expect(@oh.respond_to?('symbol')).to be_truthy
+    end
+  end
+end

data/spec/gitlab/page_links_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Gitlab::PageLinks do
+  before do
+    @page_links = Gitlab::PageLinks.new('Link' => "<http://example.com/api/v3/projects?page=1&per_page=5>; rel=\"first\", <http://example.com/api/v3/projects?page=20&per_page=5>; rel=\"last\", <http://example.com/api/v3/projects?page=7&per_page=5>; rel=\"prev\", <http://example.com/api/v3/projects?page=9&per_page=5>; rel=\"next\"")
+  end
+
+  context '.extract_links' do
+    it 'should extract link header appropriately' do
+      expect(@page_links.last).to eql 'http://example.com/api/v3/projects?page=20&per_page=5'
+      expect(@page_links.first).to eql 'http://example.com/api/v3/projects?page=1&per_page=5'
+      expect(@page_links.next).to eql 'http://example.com/api/v3/projects?page=9&per_page=5'
+      expect(@page_links.prev).to eql 'http://example.com/api/v3/projects?page=7&per_page=5'
+    end
+  end
+end

data/spec/gitlab/paginated_response_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Gitlab::PaginatedResponse do
+  before do
+    array = [1, 2, 3, 4]
+    @paginated_response = Gitlab::PaginatedResponse.new array
+  end
+
+  it "should respond to *_page and has_*_page methods" do
+    expect(@paginated_response).to respond_to :first_page
+    expect(@paginated_response).to respond_to :last_page
+    expect(@paginated_response).to respond_to :next_page
+    expect(@paginated_response).to respond_to :prev_page
+    expect(@paginated_response).to respond_to :has_first_page?
+    expect(@paginated_response).to respond_to :has_last_page?
+    expect(@paginated_response).to respond_to :has_next_page?
+    expect(@paginated_response).to respond_to :has_prev_page?
+  end
+
+  context '.parse_headers!' do
+    it "should parse headers" do
+      @paginated_response.parse_headers!('Link' => "<http://example.com/api/v3/projects?page=1&per_page=5>; rel=\"first\", <http://example.com/api/v3/projects?page=20&per_page=5>; rel=\"last\"")
+      client = @paginated_response.client = double('client')
+      first_page_response = double('first_page_response')
+      last_page_response = double('last_page_response')
+      allow(client).to receive(:endpoint).and_return("http://example.com/api/v3")
+      allow(client).to receive(:get).with("/projects?page=1&per_page=5").and_return(first_page_response)
+      allow(client).to receive(:get).with("/projects?page=20&per_page=5").and_return(last_page_response)
+      expect(@paginated_response.has_first_page?).to be true
+      expect(@paginated_response.has_last_page?).to be true
+      expect(@paginated_response.has_next_page?).to be false
+      expect(@paginated_response.has_prev_page?).to be false
+      expect(@paginated_response.first_page).to be first_page_response
+      expect(@paginated_response.last_page).to be last_page_response
+      expect(@paginated_response.next_page).to be_nil
+      expect(@paginated_response.prev_page).to be_nil
+    end
+  end
+
+  context '.each_page' do
+    it "should iterate pages" do
+      next_page = double('next_page')
+      allow(@paginated_response).to receive(:has_next_page?).and_return(true)
+      allow(@paginated_response).to receive(:next_page).and_return(next_page)
+      allow(next_page).to receive(:has_next_page?).and_return(false)
+      expect { |b| @paginated_response.each_page(&b) }.to yield_successive_args(@paginated_response, next_page)
+    end
+  end
+
+  context '.auto_paginate' do
+    it "should returns an array if block is not given" do
+      next_page = double('next_page')
+      allow(@paginated_response).to receive(:has_next_page?).and_return(true)
+      allow(@paginated_response).to receive(:next_page).and_return(next_page)
+      allow(next_page).to receive(:has_next_page?).and_return(false)
+      allow(next_page).to receive(:to_ary).and_return([5, 6, 7, 8])
+      expect(@paginated_response.auto_paginate).to contain_exactly(1, 2, 3, 4, 5, 6, 7, 8)
+    end
+  end
+end

data/spec/gitlab/request_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Gitlab::Request do
+  it { should respond_to :get }
+  it { should respond_to :post }
+  it { should respond_to :put }
+  it { should respond_to :delete }
+  before do
+    @request = Gitlab::Request.new
+  end
+
+  describe ".default_options" do
+    it "should have default values" do
+      default_options = Gitlab::Request.default_options
+      expect(default_options).to be_a Hash
+      expect(default_options[:parser]).to be_a Proc
+      expect(default_options[:format]).to eq(:json)
+      expect(default_options[:headers]).to eq('Accept' => 'application/json')
+      expect(default_options[:default_params]).to be_nil
+    end
+  end
+
+  describe ".parse" do
+    it "should return ObjectifiedHash" do
+      body = JSON.unparse(a: 1, b: 2)
+      expect(Gitlab::Request.parse(body)).to be_an Gitlab::ObjectifiedHash
+      expect(Gitlab::Request.parse("true")).to be true
+      expect(Gitlab::Request.parse("false")).to be false
+
+      expect { Gitlab::Request.parse("string") }.to raise_error(Gitlab::Error::Parsing)
+    end
+  end
+
+  describe "#set_request_defaults" do
+    context "when endpoint is not set" do
+      it "should raise Error::MissingCredentials" do
+        @request.endpoint = nil
+        expect do
+          @request.set_request_defaults
+        end.to raise_error(Gitlab::Error::MissingCredentials, 'Please set an endpoint to API')
+      end
+    end
+
+    context "when endpoint is set" do
+      before(:each) do
+        @request.endpoint = 'http://rabbit-hole.example.org'
+      end
+
+      it "should set default_params" do
+        @request.set_request_defaults('sudoer')
+        expect(Gitlab::Request.default_params).to eq(sudo: 'sudoer')
+      end
+    end
+  end
+
+  describe "#set_authorization_header" do
+    it "should raise MissingCredentials when auth_token and private_token are not set" do
+      expect do
+        @request.send(:set_authorization_header, {})
+      end.to raise_error(Gitlab::Error::MissingCredentials)
+    end
+
+    it "should set the correct header when given a private_token" do
+      @request.private_token = 'ys9BtunN3rDKbaJCYXaN'
+      expect(@request.send(:set_authorization_header, {})).to eq("PRIVATE-TOKEN" => 'ys9BtunN3rDKbaJCYXaN')
+    end
+
+    it "should set the correct header when setting an auth_token via the private_token config option" do
+      @request.private_token = '3225e2804d31fea13fc41fc83bffef00cfaedc463118646b154acc6f94747603'
+      expect(@request.send(:set_authorization_header, {})).to eq("Authorization" => "Bearer 3225e2804d31fea13fc41fc83bffef00cfaedc463118646b154acc6f94747603")
+    end
+  end
+end

data/spec/gitlab/shell_history_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'tempfile'
+
+describe Gitlab::Shell::History do
+  context 'saving to a file' do
+    before do
+      @file = Tempfile.new('.gitlab_shell_history')
+      @history = Gitlab::Shell::History.new(file_path: @file.path)
+    end
+
+    after { @file.close(true) }
+
+    it 'saves the lines' do
+      @history << 'party on, dudes'
+      @history << 'be excellent to each other'
+      @history.save
+      expect(File.read @file.path).
+        to eq("party on, dudes\nbe excellent to each other\n")
+    end
+
+    it 'has the lines' do
+      @history << 'party on, dudes'
+      @history << 'be excellent to each other'
+      expect(@history.lines).
+        to eq(["party on, dudes", "be excellent to each other"])
+    end
+
+    it 'limits the lines to GITLAB_HISTFILESIZE' do
+      ENV['GITLAB_HISTFILESIZE'] = '2'
+      @history << 'bogus'
+      @history << 'party on, dudes'
+      @history << 'be excellent to each other'
+      @history.save
+      expect(@history.lines).
+        to eq(["party on, dudes", "be excellent to each other"])
+      expect(File.read @file.path).
+        to eq("party on, dudes\nbe excellent to each other\n")
+    end
+  end
+
+  context 'loading a file' do
+    before do
+      @file = load_fixture('shell_history')
+      @history = Gitlab::Shell::History.new(file_path: @file.path)
+    end
+
+    it 'has the lines' do
+      @history.load
+      expect(@history.lines).
+        to eq(["party on, dudes", "be excellent to each other"])
+    end
+  end
+end

data/spec/gitlab/shell_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Gitlab::Shell do
+  before do
+    Gitlab::Shell.setup
+  end
+
+  describe ".execute" do
+    context "invalid command" do
+      it "should raise" do
+        expect { Gitlab::Shell.execute 'foobar', [] }.to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  describe ".history" do
+    before do
+      @history = Gitlab::Shell.history
+    end
+
+    it "should return a Gitlab::Shell::History instance" do
+      expect(@history).to be_a Gitlab::Shell::History
+    end
+    it "should respond to :save" do
+      expect(@history).to respond_to :save
+    end
+    it "should respond to :load" do
+      expect(@history).to respond_to :load
+    end
+    it "should respond to :<<" do
+      expect(@history).to respond_to :<<
+    end
+  end
+
+  describe ".setup" do
+    it "should set the Readline completion_proc" do
+      completion = Readline.completion_proc
+      expect(completion).to be_truthy
+      expect(completion).to be_a Proc
+    end
+    it "should set the Readline completion_append_character" do
+      completion_character = Readline.completion_append_character
+      expect(completion_character).to eq(' ')
+    end
+  end
+
+  describe ".completion" do
+    before do
+      @comp = Gitlab::Shell.completion
+    end
+    it "should return a Proc object" do
+      expect(@comp).to be_a Proc
+    end
+    context "called with an argument" do
+      it "should return an Array of matching commands" do
+        completed_cmds = @comp.call 'group'
+        expect(completed_cmds).to be_a Array
+        expect(completed_cmds.sort).to eq(%w(group group_members group_projects group_search groups))
+      end
+    end
+  end
+
+  describe ".parse_input" do
+    context "with arguments" do
+      it "should set command & arguments" do
+        Gitlab::Shell.parse_input('create_branch 1 "api" "master"')
+        expect(Gitlab::Shell.command).to eq('create_branch')
+        expect(Gitlab::Shell.arguments).to eq(%w(1 api master))
+      end
+    end
+
+    context "without arguments" do
+      it 'should set command & empty arguments' do
+        Gitlab::Shell.parse_input('exit')
+        expect(Gitlab::Shell.command).to eq('exit')
+        expect(Gitlab::Shell.arguments).to be_empty
+      end
+    end
+  end
+end