libdolt 0.15.0 → 0.16.0

data/test/libdolt/git/archiver_test.rb

@@ -29,30 +29,18 @@ class StubRepository
   end
 end
 
-class StubProcessStatus
-  attr_reader :exitstatus
-  def initialize(code)
-    @exitstatus = code
-  end
-end
-
 describe Dolt::Git::Archiver do
-  include EM::MiniTest::Spec
-
   describe "archive" do
     before do
       @archiver = Dolt::Git::Archiver.new("/work", "/cache")
     end
 
-    it "resolves with existing cached file" do
+    it "returns existing cached file" do
       File.stubs(:exists?).with("/cache/gts-mainline-master.tar.gz").returns(true)
       repo = StubRepository.new("gts/mainline")
 
-      @archiver.archive(repo, "master", :tar).then do |filename|
-        assert_equal "/cache/gts-mainline-master.tar.gz", filename
-        done!
-      end
-      wait!
+      filename = @archiver.archive(repo, "master", :tar)
+      assert_equal "/cache/gts-mainline-master.tar.gz", filename
     end
 
     it "generates tarball" do
@@ -60,19 +48,30 @@ describe Dolt::Git::Archiver do
 
       cmd = "sh -c 'git --git-dir /repos/gts/mainline.git archive --prefix='gts-mainline/' " +
         "--format=tar master | gzip -m > /work/gts-mainline-master.tar.gz'"
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).with(cmd).returns(d)
+      Dolt::Git.expects(:shell).with(cmd).returns(Dolt::FakeProcess.new(0))
+      FileUtils.stubs(:mv)
 
       @archiver.archive(repo, "master", :tar)
     end
 
+    it "does not allow arbitrary commands" do
+      repo = StubRepository.new("gts/mainline")
+
+      cmd = "sh -c 'git --git-dir /repos/gts/mainline.git archive --prefix='gts-mainline/' " +
+        "--format=tar master\\;\\ rm\\ -fr\\ / | gzip -m > /work/gts-mainline-master\\;\\ rm\\ -fr\\ -.tar.gz'"
+      Dolt::Git.expects(:shell).with(cmd).returns(Dolt::FakeProcess.new(0))
+      FileUtils.stubs(:mv)
+
+      @archiver.archive(repo, "master; rm -fr /", :tar)
+    end
+
     it "uses gzip format from string" do
       repo = StubRepository.new("gts/mainline")
 
       cmd = "sh -c 'git --git-dir /repos/gts/mainline.git archive --prefix='gts-mainline/' " +
         "--format=tar master | gzip -m > /work/gts-mainline-master.tar.gz'"
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).with(cmd).returns(d)
+      Dolt::Git.expects(:shell).with(cmd).returns(Dolt::FakeProcess.new(0))
+      FileUtils.stubs(:mv)
 
       @archiver.archive(repo, "master", "tar")
     end
@@ -82,8 +81,8 @@ describe Dolt::Git::Archiver do
 
       cmd = "sh -c 'git --git-dir /repos/gts/mainline.git archive --prefix='gts-mainline/' " +
         "--format=zip master > /work/gts-mainline-master.zip'"
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).with(cmd).returns(d)
+      Dolt::Git.expects(:shell).with(cmd).returns(Dolt::FakeProcess.new(0))
+      FileUtils.stubs(:mv)
 
       @archiver.archive(repo, "master", "zip")
     end
@@ -92,9 +91,7 @@ describe Dolt::Git::Archiver do
       FileUtils.expects(:mv).with("/work/gts-mainline-master.tar.gz",
                                   "/cache/gts-mainline-master.tar.gz")
       repo = StubRepository.new("gts/mainline")
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).returns(d)
-      d.succeed("", StubProcessStatus.new(0))
+      Dolt::Git.stubs(:open).returns(Dolt::FakeProcess.new(0))
 
       @archiver.archive(repo, "master", :tar)
     end
@@ -103,80 +100,20 @@ describe Dolt::Git::Archiver do
       FileUtils.expects(:mv).with("/work/gts-mainline-master.tar.gz",
                                   "/cache/gts-mainline-master.tar.gz").never
       repo = StubRepository.new("gts/mainline")
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).returns(d)
-      d.fail("", StubProcessStatus.new(1))
-
-      @archiver.archive(repo, "master", :tar)
-    end
-
-    it "resolves promise with generated filename" do
-      FileUtils.stubs(:mv)
-      repo = StubRepository.new("gts/mainline")
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).returns(d)
-      d.succeed("", StubProcessStatus.new(0))
-
-      @archiver.archive(repo, "master", :tar).then do |filename|
-        assert_equal "/cache/gts-mainline-master.tar.gz", filename
-        done!
-      end
-      wait!
-    end
-
-    it "rejects promise when failing to archive" do
-      repo = StubRepository.new("gts/mainline")
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).returns(d)
-      d.fail("It done failed", StubProcessStatus.new(1))
-
-      @archiver.archive(repo, "master", :tar).errback do |err|
-        assert_match "It done failed", err.message
-        done!
-      end
-      wait!
-    end
+      Dolt::Git.expects(:shell).returns(Dolt::FakeProcess.new(1))
 
-    it "does not spawn multiple identical processes" do
-      FileUtils.stubs(:mv)
-      repo = StubRepository.new("gts/mainline")
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).once.returns(d)
-      callbacks = 0
-      blk = lambda do |filename|
-        assert_equal "/cache/gts-mainline-master.tar.gz", filename
-        callbacks += 1
-        done! if callbacks == 2
+      assert_raises Exception do
+        @archiver.archive(repo, "master", :tar)
       end
-
-      @archiver.archive(repo, "master", :tar).then(&blk)
-      @archiver.archive(repo, "master", :tar).then(&blk)
-
-      wait!
-      d.succeed("", StubProcessStatus.new(0))
     end
 
-    it "spawns new process when format is different" do
+    it "returns generated filename" do
       FileUtils.stubs(:mv)
+      Dolt::Git.stubs(:open).returns(Dolt::FakeProcess.new(0))
       repo = StubRepository.new("gts/mainline")
-      d = EM::DefaultDeferrable.new
-      EMPessimistic::DeferrableChildProcess.expects(:open).twice.returns(d)
-      callbacks = 0
-
-      @archiver.archive(repo, "master", :tar).then do |filename|
-        assert_equal "/cache/gts-mainline-master.tar.gz", filename
-        callbacks += 1
-        done! if callbacks == 2
-      end
-
-      @archiver.archive(repo, "master", :zip).then do |filename|
-        assert_equal "/cache/gts-mainline-master.zip", filename
-        callbacks += 1
-        done! if callbacks == 2
-      end
 
-      wait!
-      d.succeed("", StubProcessStatus.new(0))
+      filename = @archiver.archive(repo, "master", :tar)
+      assert_equal "/cache/gts-mainline-master.tar.gz", filename
     end
   end
 end

data/test/libdolt/git/blame_test.rb

@@ -19,11 +19,9 @@ require "test_helper"
 require "libdolt/git/blame"
 
 describe Dolt::Git::Blame do
-  include EM::MiniTest::Spec
-
   describe "parse" do
     before do
-      @blame = <<-GIT
+      blame = <<-GIT
 906d67b4f3e5de7364ba9b57d174d8998d53ced6 1 1 17
 author Christian Johansen
 author-mail <christian@cjohansen.no>
@@ -93,7 +91,7 @@ beb65bee5619c651532179b19421363ead2c2a44 22 22
  end
       GIT
 
-      @blame = Dolt::Git::Blame.parse_porcelain(@blame)
+      @blame = Dolt::Git::Blame.parse_porcelain(blame)
     end
 
     it "has chunks" do
@@ -125,4 +123,42 @@ beb65bee5619c651532179b19421363ead2c2a44 22 22
       assert_equal @blame.chunks[2][:committer], @blame.chunks[0][:committer]
     end
   end
+
+  describe "parsing invalid data" do
+    before do
+      @blame = <<-EOF
+usage: git blame [options] [rev-opts] [rev] [--] file
+    [rev-opts] are documented in git-rev-list(1)
+
+    --incremental         Show blame entries as we find them, incrementally
+    -b                    Show blank SHA-1 for boundary commits (Default: off)
+    --root                Do not treat root commits as boundaries (Default: off)
+    --show-stats          Show work cost statistics
+    --score-debug         Show output score for blame entries
+    -f, --show-name       Show original filename (Default: auto)
+    -n, --show-number     Show original linenumber (Default: off)
+    -p, --porcelain       Show in a format designed for machine consumption
+    --line-porcelain      Show porcelain format with per-line commit information
+    -c                    Use the same output mode as git-annotate (Default: off)
+    -t                    Show raw timestamp (Default: off)
+    -l                    Show long commit SHA1 (Default: off)
+    -s                    Suppress author name and timestamp (Default: off)
+    -e, --show-email      Show author email instead of name (Default: off)
+    -w                    Ignore whitespace differences
+    --minimal             Spend extra cycles to find better match
+    -S <file>             Use revisions from <file> instead of calling git-rev-list
+    --contents <file>     Use <file>'s contents as the final image
+    -C[<score>]           Find line copies within and across files
+    -M[<score>]           Find line movements within and across files
+    -L <n,m>              Process only line range n,m, counting from 1
+    --abbrev[=<n>]        use <n> digits to display SHA-1s
+      EOF
+    end
+
+    it "raises an error" do
+      assert_raises Dolt::Git::InvalidBlameFormat do
+        Dolt::Git::Blame.parse_porcelain(@blame)
+      end
+    end
+  end
 end

data/test/libdolt/git/commit_test.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 #--
-#   Copyright (C) 2012 Gitorious AS
+#   Copyright (C) 2012-2013 Gitorious AS
 #
 #   This program is free software: you can redistribute it and/or modify
 #   it under the terms of the GNU Affero General Public License as published by
@@ -19,8 +19,6 @@ require "test_helper"
 require "libdolt/git/commit"
 
 describe Dolt::Git::Commit do
-  include EM::MiniTest::Spec
-
   describe "parse" do
     before do
       @log = <<-GIT

data/test/libdolt/git/repository_test.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 #--
-#   Copyright (C) 2012 Gitorious AS
+#   Copyright (C) 2012-2013 Gitorious AS
 #
 #   This program is free software: you can redistribute it and/or modify
 #   it under the terms of the GNU Affero General Public License as published by
@@ -19,274 +19,195 @@ require "test_helper"
 require "libdolt/git/repository"
 require "time"
 require "ostruct"
+require "mocha/setup"
 
 describe Dolt::Git::Repository do
-  include EM::MiniTest::Spec
   before { @repository = Dolt::Git::Repository.new(".") }
 
   describe "#submodules" do
-    it "returns deferrable" do
-      deferrable = @repository.submodules("master")
-      assert deferrable.respond_to?(:callback)
-      assert deferrable.respond_to?(:errback)
-    end
+    it "returns list of submodules" do
+      submodules = @repository.submodules("c1f6cd9")
+      url = "git://gitorious.org/gitorious/ui3.git"
 
-    it "yields list of submodules" do
-      @repository.submodules("c1f6cd9").callback do |submodules|
-        url = "git://gitorious.org/gitorious/ui3.git"
-        assert_equal [{ :path => "vendor/ui", :url => url }], submodules
-        done!
-      end
-    wait!
+      assert_equal [{ :path => "vendor/ui", :url => url }], submodules
     end
 
-    it "resolves with empty array if no submodules" do
-      @repository.submodules("26139a3").callback do |submodules|
-        assert_equal [], submodules
-        done!
-      end
-      wait!
+    it "returns empty array if no submodules" do
+      submodules = @repository.submodules("26139a3")
+      assert_equal [], submodules
     end
   end
 
   describe "#tree" do
     it "includes submodule data for trees" do
-      @repository.tree("3dc532f", "vendor").callback do |tree|
-        assert_equal({
+      tree = @repository.tree("3dc532f", "vendor")
+
+      assert_equal({
           :type => :submodule,
           :filemode => 57344,
           :name => "ui",
           :oid => "d167e3e1c17a27e4cf459dd380670801b0659659",
           :url => "git://gitorious.org/gitorious/ui3.git"
         }, tree.entries.first)
-        done!
-      end
-      wait!
     end
   end
 
   describe "#tree_entry" do
     it "includes submodule data for trees" do
-      @repository.tree_entry("3dc532f", "vendor").callback do |tree|
-        assert_equal({
+      tree = @repository.tree_entry("3dc532f", "vendor")
+
+      assert_equal({
           :type => :submodule,
           :filemode => 57344,
           :name => "ui",
           :oid => "d167e3e1c17a27e4cf459dd380670801b0659659",
           :url => "git://gitorious.org/gitorious/ui3.git"
         }, tree.entries.first)
-        done!
-      end
-      wait!
     end
 
-    it "yields blob" do
-      @repository.tree_entry("3dc532f", "Gemfile").callback do |blob|
-        assert blob.is_a?(Rugged::Blob)
-        assert_equal "source \"http://rubygems.org\"\n\ngemspec\n", blob.content
-        done!
-      end
-      wait!
+    it "returns blob" do
+      blob = @repository.tree_entry("3dc532f", "Gemfile")
+
+      assert blob.is_a?(Rugged::Blob)
+      assert_equal "source \"http://rubygems.org\"\n\ngemspec\n", blob.content
     end
   end
 
   describe "#blame" do
-    it "returns deferrable" do
-      deferrable = @repository.blame("master", "Gemfile")
-      assert deferrable.respond_to?(:callback)
-      assert deferrable.respond_to?(:errback)
-    end
-
-    it "yields blame" do
-      @repository.blame("master", "Gemfile").callback do |blame|
-        assert Dolt::Git::Blame === blame
-        done!
-      end
-      wait!
+    it "returns blame" do
+      blame = @repository.blame("master", "Gemfile")
+      assert Dolt::Git::Blame === blame
     end
 
     it "separates tree-like and path" do
-      def @repository.git(cmd); @cmd = cmd; end
-      def @repository.cmd; @cmd; end
-      @repository.blame("master", "Gemfile").callback
+      cmd = "git --git-dir #{@repository.path} blame -l -t -p master -- Gemfile"
+      Dolt::Git.expects(:shell).with(cmd).returns(Dolt::FakeProcess.new(0))
+      @repository.blame("master", "Gemfile")
+    end
 
-      assert_equal "blame -l -t -p master -- Gemfile", @repository.cmd
+    it "does not allow injecting evil commands" do
+      cmd = "git --git-dir #{@repository.path} blame -l -t -p master -- Gemfile\\; rm -fr /tmp"
+      Dolt::Git.expects(:shell).with(cmd).returns(Dolt::FakeProcess.new(0))
+      @repository.blame("master", "Gemfile; rm -fr /tmp")
     end
   end
 
   describe "#log" do
-    it "returns deferrable" do
-      deferrable = @repository.log("master", "Gemfile", 1)
-      assert deferrable.respond_to?(:callback)
-      assert deferrable.respond_to?(:errback)
-    end
-
-    it "yields commits" do
-      @repository.log("master", "dolt.gemspec", 2).callback do |log|
-        assert_equal 2, log.length
-        assert Hash === log[0]
-        done!
-      end
-      wait!
+    it "returns commits" do
+      log = @repository.log("master", "dolt.gemspec", 2)
+      assert_equal 2, log.length
+      assert Hash === log[0]
     end
   end
 
   describe "#tree_history" do
-    it "returns deferrable" do
-      deferrable = @repository.tree_history("master", "")
-      assert deferrable.respond_to?(:callback)
-      assert deferrable.respond_to?(:errback)
-    end
-
     it "fails if path is not a tree" do
-      deferrable = @repository.tree_history("master", "Gemfile")
-      deferrable.errback do |err|
+      assert_raises Exception do |err|
+        tree = @repository.tree_history("master", "Gemfile")
         assert_match /not a tree/, err.message
-        done!
       end
-      wait!
     end
 
     it "fails if path does not exist in ref" do
-      deferrable = @repository.tree_history("26139a3", "test")
-      deferrable.errback do |err|
+      assert_raises Rugged::IndexerError do |err|
+        tree = @repository.tree_history("26139a3", "test")
         assert_match /does not exist/, err.message
-        done!
       end
-      wait!
     end
 
-    it "yields tree with history" do
-      promise = @repository.tree_history("48ffbf7", "")
-      promise.callback do |log|
-        assert_equal 11, log.length
-        expected = {
-          :type => :blob,
-          :oid => "e90021f89616ddf86855d05337c188408d3b417e",
-          :filemode => 33188,
-          :name => ".gitmodules",
-          :history => [{
-                         :oid => "906d67b4f3e5de7364ba9b57d174d8998d53ced6",
-                         :author => { :name => "Christian Johansen",
-                           :email => "christian@cjohansen.no" },
-                         :summary => "Working Moron server for viewing blobs",
-                         :date => Time.parse("Mon Sep 10 15:07:39 +0200 2012"),
-                         :message => ""
-                       }]
-        }
+    it "returns tree with history" do
+      log = @repository.tree_history("48ffbf7", "")
 
-        assert_equal expected, log[0]
-        done!
-      end
+      assert_equal 11, log.length
+      expected = {
+        :type => :blob,
+        :oid => "e90021f89616ddf86855d05337c188408d3b417e",
+        :filemode => 33188,
+        :name => ".gitmodules",
+        :history => [{
+            :oid => "906d67b4f3e5de7364ba9b57d174d8998d53ced6",
+            :author => { :name => "Christian Johansen",
+              :email => "christian@cjohansen.no" },
+            :summary => "Working Moron server for viewing blobs",
+            :date => Time.parse("Mon Sep 10 15:07:39 +0200 2012"),
+            :message => ""
+          }]
+      }
 
-      promise.errback do |err|
-        puts "FAILED! #{err.inspect}"
-      end
-
-      wait!
+      assert_equal expected, log[0]
     end
 
-    it "yields nested tree with history" do
-      promise = @repository.tree_history("48ffbf7", "lib")
+    it "returns nested tree with history" do
+      log = @repository.tree_history("48ffbf7", "lib")
 
-      promise.callback do |log|
-        expected = [{
-                      :type => :tree,
-                      :oid => "58f84405b588699b24c619aa4cd83669c5623f88",
-                      :filemode => 16384,
-                      :name => "dolt",
-                      :history => [{
-                                     :oid => "8ab4f8c42511f727244a02aeee04824891610bbd",
-                                     :author => { :name => "Christian Johansen",
-                                       :email => "christian@gitorious.com" },
-                                     :summary => "New version",
-                                     :date => Time.parse("Mon Oct 1 16:34:00 +0200 2012"),
-                                     :message => ""
-                                   }]
-                    }]
-        assert_equal expected, log
-        done!
-      end
-
-      promise.errback do |err|
-        puts "FAILED! #{err.inspect}"
-      end
-
-      wait!
+      expected = [{
+          :type => :tree,
+          :oid => "58f84405b588699b24c619aa4cd83669c5623f88",
+          :filemode => 16384,
+          :name => "dolt",
+          :history => [{
+              :oid => "8ab4f8c42511f727244a02aeee04824891610bbd",
+              :author => { :name => "Christian Johansen",
+                :email => "christian@gitorious.com" },
+              :summary => "New version",
+              :date => Time.parse("Mon Oct 1 16:34:00 +0200 2012"),
+              :message => ""
+            }]
+        }]
+      assert_equal expected, log
     end
   end
 
   describe "#readme" do
-    it "returns deferrable" do
-      deferrable = @repository.readme("master")
-      assert deferrable.respond_to?(:callback)
-      assert deferrable.respond_to?(:errback)
-    end
-
-    it "yields single readme" do
+    it "returns single readme" do
       def @repository.tree(ref, path)
         entries = [{ :type => :blob, :name => "Readme" },
                    { :type => :blob, :name => "file.txt" },
                    { :type => :tree, :name => "dir" }]
         if ref == "master" && path == ""
-          When.resolve(OpenStruct.new(:entries => entries))
+          OpenStruct.new(:entries => entries)
         else
-          When.reject("Wrong ref/path")
+          raise Exception.new("Wrong ref/path")
         end
       end
 
-      @repository.readme("master").callback do |readmes|
-        assert_equal 1, readmes.length
-        assert_equal "Readme", readmes.first[:name]
-        done!
-      end
+      readmes = @repository.readme("master")
 
-      wait!
+      assert_equal 1, readmes.length
+      assert_equal "Readme", readmes.first[:name]
     end
 
-    it "does not yield trees" do
+    it "does not return trees" do
       def @repository.tree(ref, path)
         entries = [{ :type => :tree, :name => "Readme" },
                    { :type => :blob, :name => "file.txt" },
                    { :type => :tree, :name => "dir" }]
-        When.resolve(OpenStruct.new(:entries => entries))
-      end
-
-      @repository.readme("master").callback do |readmes|
-        assert_equal 0, readmes.length
-        done!
+        OpenStruct.new(:entries => entries)
       end
 
-      wait!
+      readmes = @repository.readme("master")
+      assert_equal 0, readmes.length
     end
 
-    it "yields all readmes" do
+    it "returns all readmes" do
       def @repository.tree(ref, path)
         entries = [{ :type => :blob, :name => "Readme.rdoc" },
                    { :type => :blob, :name => "readme" },
                    { :type => :blob, :name => "Readme.md" }]
-        When.resolve(OpenStruct.new(:entries => entries))
+        OpenStruct.new(:entries => entries)
       end
 
-      @repository.readme("master").callback do |readmes|
-        assert_equal 3, readmes.length
-        done!
-      end
-
-      wait!
+      readmes = @repository.readme("master")
+      assert_equal 3, readmes.length
     end
 
-    it "yields empty array of readmes when promise rejects" do
+    it "returns empty array of readmes when looking up tree fails" do
       def @repository.tree(ref, path)
-        When.reject(OpenStruct.new({ :message => "Unknown reason" }))
-      end
-
-      @repository.readme("master").callback do |readmes|
-        assert_equal 0, readmes.length
-        done!
+        raise Exception.new("Unknown reason")
       end
 
-      wait!
+      readmes = @repository.readme("master")
+      assert_equal 0, readmes.length
     end
   end
 end