gitdocs 0.5.0 → 0.6.0

data/test/integration/web/share_management_test.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+
+require File.expand_path('../../test_helper', __FILE__)
+
+describe 'Manage which shares are being watched' do
+  it 'should update a share through the UI' do
+    gitdocs_add('local')
+    gitdocs_start
+    visit_and_click_link('Settings')
+
+    within('#settings') do
+      within('#share-0') do
+        fill_in('share[0][polling_interval]', with: '0.2')
+        select('Fetch only', from: 'share[0][sync_type]')
+      end
+      click_button('Save')
+    end
+
+    # Allow the asynchronous portion of the update finish before checking
+    # the result.
+    sleep(1)
+
+    click_link('Settings')
+    within('#settings') do
+      within('#share-0') do
+        page.must_have_field('share[0][polling_interval]', with: '0.2')
+        page.must_have_field('share[0][sync_type]', with: 'fetch')
+      end
+    end
+  end
+
+  describe 'remove a share' do
+    before { gitdocs_add('local') }
+
+    it do
+      gitdocs_start
+      visit_and_click_link('Settings')
+
+      within('#settings') do
+        within('#share-0') { click_link('Delete') }
+
+        page.must_have_css('.share', count: 0)
+      end
+    end
+  end
+end

data/test/support/git_factory.rb

@@ -0,0 +1,276 @@
+module GitFactory
+  class << self
+    attr_accessor :working_directory
+
+    def configure
+      yield self
+    end
+
+    # @return [Array<Hash>]
+    def users
+      [
+        { name: 'Art T. Fish', email: 'afish@example.com' },
+        { name: 'A U Thor',    email: 'author@example.com' }
+      ]
+    end
+
+    # @return [Array<String>]
+    def authors
+      users.map { |x| "#{x[:name]} <#{x[:email]}>" }
+    end
+
+    # @param [#to_s] repo_name
+    #
+    # @return [String]
+    def expand_path(repo_name, *filename_path)
+      File.expand_path(
+        File.join(
+          working_directory, repo_name.to_s, *filename_path
+        )
+      )
+    end
+
+    # @param [#to_s] repo_name
+    #
+    # @return [Rugged::Repository]
+    def rugged_repository(repo_name)
+      Rugged::Repository.new(expand_path(repo_name))
+    end
+
+    # @param [#to_s] repo_name
+    #
+    # @return [String]
+    def init(repo_name)
+      repository_path = expand_path(repo_name)
+
+      FileUtils.rm_rf(repository_path)
+      FileUtils.mkdir_p(File.dirname(repository_path))
+
+      repo = Rugged::Repository.init_at(repository_path)
+      repo.config['user.email'] = users[0][:email]
+      repo.config['user.name']  = users[0][:name]
+
+      repository_path
+    end
+
+    # @param [#to_s] repo_name
+    #
+    # @return [String]
+    def init_bare(repo_name)
+      repository_path = expand_path(repo_name)
+
+      FileUtils.rm_rf(repository_path)
+      FileUtils.mkdir_p(File.dirname(repository_path))
+
+      repo = Rugged::Repository.init_at(repository_path, :bare)
+      repo.config['user.email'] = users[0][:email]
+      repo.config['user.name']  = users[0][:name]
+
+      repository_path
+    end
+
+    # @param [#to_s] bare_repo_name
+    # @param [#to_s] repo_name
+    #
+    # @return [String]
+    def clone(bare_repo_name, repo_name)
+      bare_repository_path = expand_path(bare_repo_name)
+      repository_path      = expand_path(repo_name)
+
+      # assert bare_repository_path is a valid bare repository
+      FileUtils.rm_rf(repository_path)
+
+      repo = Rugged::Repository.clone_at(
+        bare_repository_path, repository_path
+      )
+      repo.config['user.email'] = users[0][:email]
+      repo.config['user.name']  = users[0][:name]
+
+      repository_path
+    end
+
+    # @param [#to_s] repo_name
+    # @param [String] directory_name
+    #
+    # @return [void]
+    def mkdir(repo_name, directory_name)
+      directory_path = expand_path(repo_name, directory_name)
+      FileUtils.mkdir_p(directory_path)
+    end
+
+    # @param [#to_s] repo_name
+    # @param [String] filename
+    # @param [String] content
+    #
+    # @return [void]
+    def write(repo_name, filename, content)
+      file_path = expand_path(repo_name, filename)
+      FileUtils.mkdir_p(File.dirname(file_path))
+      File.write(file_path, content)
+    end
+
+    # @param [#to_s] repo_name
+    # @param [String] filename
+    # @param [String] content
+    #
+    # @return [void]
+    def append(repo_name, filename, content)
+      file_path = expand_path(repo_name, filename)
+      FileUtils.mkdir_p(File.dirname(file_path))
+      File.open(file_path, 'a') { |f| f << content }
+    end
+
+    # @param [#to_s] repo_name
+    # @param [String] filename
+    #
+    # @return [void]
+    def rm(repo_name, filename)
+      file_path = expand_path(repo_name, filename)
+      FileUtils.rm_rf(file_path)
+    end
+
+    # @param [#to_s] repo_name
+    # @param [String] filename
+    # @param [String] content
+    # @param [String] author_id
+    #
+    # @return [void]
+    def commit(repo_name, filename, content, author_id = 0)
+      commit_message = 'commit'
+      write(repo_name, filename, content)
+
+      repository_path = expand_path(repo_name)
+      `cd #{repository_path} ; git add #{filename}; git commit -m '#{commit_message}' --author='#{authors[author_id]}'`
+      `cd #{repository_path} ; git rev-parse HEAD`.strip
+    end
+
+    # @overload bare_commit(repo_name, filename, content)
+    #   @param [#to_s] repo_name
+    #   @param [String] filename
+    #   @param [String] content
+    #
+    # @overload  bare_commit(repo_name, filename, content, author_id)
+    #   @param [#to_s] repo_name
+    #   @param [String] filename
+    #   @param [String] content
+    #   @param [String] author_id
+    #
+    # @return [void]
+    def bare_commit(repo_name, filename, content, author_id = 0)
+      commit_message = 'commit'
+      repo = rugged_repository(repo_name)
+
+      index = Rugged::Index.new
+      index.add(
+        path: filename,
+        oid:  repo.write(content, :blob),
+        mode: 0100644
+      )
+
+      author_hash = {
+        email: users[author_id][:email],
+        name:  users[author_id][:name],
+        time:  Time.now
+      }
+
+      Rugged::Commit.create(
+        repo,
+        tree:       index.write_tree(repo),
+        author:     author_hash,
+        committer:  author_hash,
+        message:    commit_message,
+        parents:    repo.empty? ? [] : [repo.head.target].compact,
+        update_ref: 'HEAD'
+      )
+    end
+  end
+end
+
+module GitInspector
+  class << self
+    # @param [#to_s] repo_name
+    #
+    # @return [Integer]
+    def commit_count(repo_name)
+      repo = GitFactory.rugged_repository(repo_name)
+      walker = Rugged::Walker.new(repo)
+      walker.push(repo.head.target)
+      walker.count
+    rescue Rugged::ReferenceError
+      # The repo does not have a head => no commits.
+      0
+    end
+
+    # @param [to_s] repo_name
+    #
+    # @return [Boolean]
+    def clean?(repo_name)
+      repo = GitFactory.rugged_repository(repo_name)
+      repo.diff_workdir(
+        repo.head.target, include_untracked: true
+      ).deltas.empty?
+    rescue Rugged::Error
+      false
+    end
+
+    # @param [#to_s] repo_name
+    #
+    # @return [String]
+    def remote_oid(repo_name)
+      repo = GitFactory.rugged_repository(repo_name)
+      branch = repo.branches['origin/master']
+      return unless branch
+      branch.target_id
+    end
+
+    # @param [#to_s] repo_name
+    #
+    # @return [nil]
+    # @return [String]
+    def last_message(repo_name)
+      repo = GitFactory.rugged_repository(repo_name)
+      walker = Rugged::Walker.new(repo)
+      walker.push(repo.head.target)
+      commit = walker.first
+      return unless commit
+      commit.message
+    rescue Rugged::ReferenceError
+      # The repo does not have a head => no commits => no head commit.
+      nil
+    end
+
+    # NOTE: This method is ignoring hidden files.
+    # @param [#to_s] repo_name
+    #
+    # @return [Integer]
+    def file_count(repo_name)
+      repository_path = GitFactory.expand_path(repo_name)
+      files = Dir.chdir(repository_path) { Dir.glob('*') }
+      files.count
+    end
+
+    # @param [#to_s] repo_name
+    # @param [String] filename
+    #
+    # @return [String]
+    def file_exist?(repo_name, filename)
+      file_path = GitFactory.expand_path(repo_name, filename)
+      File.exist?(file_path)
+    end
+
+    # @param [#to_s] repo_name
+    # @param [String] filename
+    #
+    # @return [nil]
+    # @return [String]
+    def file_content(repo_name, filename)
+      return unless file_exist?(repo_name, filename)
+      file_path = GitFactory.expand_path(repo_name, filename)
+      File.read(file_path)
+    end
+  end
+end
+
+GitFactory.configure do |config|
+  config.working_directory = Dir.tmpdir
+end

data/test/unit/browser_app_test.rb

@@ -0,0 +1,346 @@
+# -*- encoding : utf-8 -*-
+
+ENV['RACK_ENV'] = 'test'
+require File.expand_path('../test_helper', __FILE__)
+require 'rack/test'
+
+describe Gitdocs::BrowserApp do
+  include Rack::Test::Methods
+  def app
+    Gitdocs::BrowserApp
+  end
+
+  describe 'get /' do
+    describe 'with one share' do
+      before do
+        Gitdocs::Share.stubs(:all).returns([:one])
+        Gitdocs::Share.stubs(:first).returns(stub(id: :id))
+
+        get '/'
+      end
+      specify do
+        last_response.status.must_equal(302)
+        last_response.headers['Location'].must_equal('http://example.org/id/')
+      end
+    end
+
+    describe 'with multiple shares' do
+      before do
+        Gitdocs::Share.stubs(:all).returns(
+          [
+            stub(id: :id1, path: :path1),
+            stub(id: :id2, path: :path2)
+          ]
+        )
+
+        get '/'
+      end
+      specify do
+        last_response.status.must_equal(200)
+        last_response.body.must_include('Select a share to browse')
+        last_response.body.must_include('id1')
+        last_response.body.must_include('path1')
+        last_response.body.must_include('id2')
+        last_response.body.must_include('path2')
+      end
+    end
+  end
+
+  describe 'get /search' do
+    before do
+      Gitdocs::Search.stubs(:search).with('term').returns(results)
+
+      get '/search', q: 'term'
+    end
+
+    describe 'empty' do
+      let(:results) { {} }
+      specify do
+        last_response.status.must_equal(200)
+        last_response.body.must_include('Matches for "term"')
+        last_response.body.must_include('No results')
+      end
+    end
+
+    describe 'not empty' do
+      let(:results) do
+        descriptor1    = stub(name: 'repo1', index: 'index1')
+        search_result1 = stub(file: 'filename1', context: 'context1')
+        descriptor2    = stub(name: 'repo2', index: 'index2')
+        search_result2 = stub(file: 'filename2', context: 'context2')
+
+        {
+          descriptor1 => [search_result1],
+          descriptor2 => [search_result2]
+        }
+      end
+      specify do
+        last_response.status.must_equal(200)
+        last_response.body.must_include('Matches for "term"')
+        last_response.body.must_include('repo1')
+        last_response.body.must_include('/index1/filename1')
+        last_response.body.must_include('context1')
+        last_response.body.must_include('repo2')
+        last_response.body.must_include('/index2/filename2')
+        last_response.body.must_include('context2')
+      end
+    end
+  end
+
+  describe 'resource methods' do
+    let(:repository)      { stub(root: 'root_path') }
+    let(:repository_path) { stub }
+    before do
+      Gitdocs::Share
+        .stubs(:find)
+        .with(1234)
+        .returns(share = stub)
+      Gitdocs::Repository
+        .stubs(:new)
+        .with(share)
+        .returns(repository)
+      Gitdocs::Repository::Path
+        .stubs(:new)
+        .with(repository, '/path1/path2')
+        .returns(repository_path)
+    end
+
+    describe 'get /:id' do
+      describe 'meta' do
+        before do
+          repository_path.stubs(:meta).returns(key: :value)
+
+          get '/1234/path1/path2', mode: 'meta'
+        end
+        specify do
+          last_response.status.must_equal(200)
+          last_response.content_type.must_equal('application/json')
+          last_response.body.must_equal('{"key":"value"}')
+        end
+      end
+
+      describe 'edit' do
+        before do
+          repository_path.stubs(text?: text, content: :content)
+
+          get '/1234/path1/path2', mode: 'edit'
+        end
+
+        describe 'not text' do
+          let(:text) { false }
+          specify { last_response.status.must_equal(404) }
+        end
+
+        describe 'text' do
+          let(:text) { true }
+          specify do
+            last_response.status.must_equal(200)
+            last_response.body.must_include('content')
+          end
+        end
+      end
+
+      describe 'revisions' do
+        before do
+          repository_path.stubs(revisions: revisions)
+
+          get '/1234/path1/path2', mode: 'revisions'
+        end
+
+        describe 'none' do
+          let(:revisions) { [] }
+          specify do
+            last_response.status.must_equal(200)
+            last_response.body.must_include('No revisions for this file could be found.')
+          end
+        end
+
+        describe 'some' do
+          let(:revisions) do
+            [
+              {
+                commit:  'DEADBEEF',
+                subject: 'I am a commit',
+                author:  'Author <author@example.com>',
+                date:    Time.parse('2016-01-01')
+              }
+            ]
+          end
+          specify do
+            last_response.status.must_equal(200)
+            last_response.body.must_include('DEADBEEF')
+            last_response.body.must_include('?revision=DEADBEEF')
+            last_response.body.must_include('I am a commit')
+            last_response.body.must_include('Author <author@example.com>')
+            last_response.body.must_include(Time.parse('2016-01-01').iso8601)
+          end
+        end
+      end
+
+      describe 'raw' do
+        before do
+          repository_path.stubs(absolute_path: :absolute_path)
+          app.any_instance.stubs(:send_file).with(:absolute_path)
+
+          get '/1234/path1/path2', mode: 'raw'
+        end
+        specify { last_response.status.must_equal(200) }
+      end
+
+      describe 'simple show' do
+        describe 'directory' do
+          before do
+            repository_path.stubs(
+              directory?:   directory,
+              readme_path:  :readme_path,
+              file_listing: file_listing
+            )
+            app
+              .any_instance
+              .stubs(:file_content_render)
+              .with(:readme_path)
+              .returns(:readme_content)
+
+            get '/1234/path1/path2'
+          end
+
+          describe 'empty' do
+            let(:directory)    { true }
+            let(:file_listing) { [] }
+            specify do
+              last_response.status.must_equal(200)
+              last_response.body.must_include('No files were found in this directory.')
+              last_response.body.must_include('readme_content')
+            end
+          end
+
+          describe 'non-empty' do
+            let(:directory) { true }
+            let(:file_listing) do
+              [
+                stub(name: 'filename',  is_directory: false),
+                stub(name: 'directory', is_directory: true)
+              ]
+            end
+            specify do
+              last_response.status.must_equal(200)
+              last_response.body.must_include('/img/file.png')
+              last_response.body.must_include('filename')
+              last_response.body.must_include('/img/folder.png')
+              last_response.body.must_include('directory')
+              last_response.body.must_include('readme_content')
+            end
+          end
+        end
+
+        describe 'file' do
+          before do
+            repository_path.stubs(directory?: false)
+            repository_path
+              .stubs(:absolute_path)
+              .with('revision')
+              .returns(:revision_path)
+            app
+              .any_instance
+              .stubs(:file_content_render)
+              .with(:revision_path)
+              .returns(:content)
+
+            get '/1234/path1/path2', revision: 'revision'
+          end
+          specify do
+            last_response.status.must_equal(200)
+            last_response.body.must_include('content')
+          end
+        end
+      end
+    end
+
+    describe 'post /:id' do
+      before { repository_path.stubs(relative_path: 'path1/path2/new') }
+
+      describe 'upload' do
+        before do
+          repository_path.expects(:join).with(File.basename(__FILE__))
+          repository_path.expects(:mv).with(regexp_matches(/RackMultipart/))
+
+          post '/1234/path1/path2', file: Rack::Test::UploadedFile.new(__FILE__, 'text/plain')
+        end
+        specify do
+          last_response.status.must_equal(302)
+          last_response.headers['Location'].must_equal('http://example.org/1234/path1/path2/new')
+        end
+      end
+
+      describe 'empty file' do
+        before do
+          repository_path.expects(:join).with('new')
+          repository_path.expects(:touch)
+
+          post '/1234/path1/path2', filename: 'new', new_file: 'value'
+        end
+        specify do
+          last_response.status.must_equal(302)
+          last_response.headers['Location'].must_equal('http://example.org/1234/path1/path2/new?mode=edit')
+        end
+      end
+
+      describe 'directory' do
+        before do
+          repository_path.expects(:join).with('new')
+          repository_path.expects(:mkdir)
+
+          post '/1234/path1/path2', filename: 'new', new_directory: 'value'
+        end
+        specify do
+          last_response.status.must_equal(302)
+          last_response.headers['Location'].must_equal('http://example.org/1234/path1/path2/new')
+        end
+      end
+    end
+
+    describe 'put /:id' do
+      before { repository_path.stubs(relative_path: 'path1/path2') }
+
+      describe 'update and commit' do
+        before do
+          repository_path.expects(:write).with('data')
+          repository.expects(:write_commit_message).with('message')
+
+          put '/1234/path1/path2', data: 'data', message: 'message'
+        end
+        specify do
+          last_response.status.must_equal(302)
+          last_response.headers['Location'].must_equal('http://example.org/1234/path1/path2')
+        end
+      end
+
+      describe 'revert' do
+        before do
+          repository_path.expects(:revert).with('revision')
+          repository_path.stubs(relative_path: 'path1/path2')
+          repository.expects(:write_commit_message).with("Reverting 'path1/path2' to revision")
+
+          put '/1234/path1/path2', revision: 'revision'
+        end
+        specify do
+          last_response.status.must_equal(302)
+          last_response.headers['Location'].must_equal('http://example.org/1234/path1/path2')
+        end
+      end
+    end
+
+    describe 'delete /:id' do
+      before do
+        repository_path.expects(:remove)
+        repository_path.stubs(relative_dirname: 'path1')
+
+        delete '/1234/path1/path2'
+      end
+      specify do
+        last_response.status.must_equal(302)
+        last_response.headers['Location'].must_equal('http://example.org/1234/path1')
+      end
+    end
+  end
+end