librarian 0.1.1 → 0.1.2

data/spec/functional/cli_spec.rb

@@ -15,7 +15,7 @@ module Librarian
         end
 
         it "should print the version" do
-          stdout.should == strip_heredoc(<<-STDOUT)
+          expect(stdout).to eq strip_heredoc(<<-STDOUT)
             librarian-#{Librarian::VERSION}
             librarian-mock-#{Librarian::Mock::VERSION}
           STDOUT

data/spec/functional/posix_spec.rb

@@ -1,12 +1,10 @@
 require "librarian/posix"
 
+require "support/project_path_macro"
+
 describe Librarian::Posix do
+  include Support::ProjectPathMacro
 
-  let(:project_path) do
-    project_path = Pathname.new(__FILE__).expand_path
-    project_path = project_path.dirname until project_path.join("Rakefile").exist?
-    project_path
-  end
   let(:tmp_path) { project_path + "tmp/spec/functional/posix" }
   after { tmp_path.rmtree if tmp_path && tmp_path.exist? }
 
@@ -14,19 +12,19 @@ describe Librarian::Posix do
 
     it "returns the stdout" do
       res = described_class.run!(%w[echo hello there]).strip
-      res.should be == "hello there"
+      expect(res).to eq "hello there"
     end
 
     it "changes directory" do
       tmp_path.mkpath
       res = described_class.run!(%w[pwd], :chdir => tmp_path).strip
-      res.should be == tmp_path.to_s
+      expect(res).to eq tmp_path.to_s
     end
 
     it "reads the env" do
       res = described_class.run!(%w[env], :env => {"KOALA" => "BEAR"})
       line = res.lines.find{|l| l.start_with?("KOALA=")}.strip
-      line.should be == "KOALA=BEAR"
+      expect(line).to eq "KOALA=BEAR"
     end
 
   end

data/spec/functional/source/git/repository_spec.rb

@@ -6,17 +6,15 @@ require "librarian/posix"
 
 require "librarian/source/git/repository"
 
+require "librarian/mock/environment"
+
+require "support/project_path_macro"
+
 describe Librarian::Source::Git::Repository do
+  include Support::ProjectPathMacro
 
-  let(:env) do
-    double(:ui => nil, :logger => double(:debug => nil, :info => nil))
-  end
+  let(:env) { Librarian::Mock::Environment.new }
 
-  let(:project_path) do
-    project_path = Pathname.new(__FILE__).expand_path
-    project_path = project_path.dirname until project_path.join("Rakefile").exist?
-    project_path
-  end
   let(:tmp_path) { project_path + "tmp/spec/functional/source/git/repository" }
   after { tmp_path.rmtree if tmp_path && tmp_path.exist? }
   let(:git_source_path) { tmp_path + SecureRandom.hex(16) }
@@ -64,35 +62,35 @@ describe Librarian::Source::Git::Repository do
   end
 
   describe ".bin" do
-    specify { described_class.bin.should_not be_empty }
+    specify { expect(described_class.bin).to_not be_empty }
   end
 
   describe ".git_version" do
-    specify { described_class.git_version.should =~ /^\d+(\.\d+)+$/ }
+    specify { expect(described_class.git_version).to match( /^\d+(\.\d+)+$/ ) }
   end
 
   context "the original" do
     subject { described_class.new(env, git_source_path) }
 
     it "should recognize it" do
-      subject.should be_git
+      expect(subject).to be_git
     end
 
     it "should not list any remotes for it" do
-      subject.remote_names.should be_empty
+      expect(subject.remote_names).to be_empty
     end
 
     it "should not list any remote branches for it" do
-      subject.remote_branch_names.should be_empty
+      expect(subject.remote_branch_names).to be_empty
     end
 
     it "should have divergent shas for master, branch, tag, and atag" do
       revs = %W[ master #{branch} #{tag} #{atag} ]
       rev_parse = proc{|rev| git!(%W[rev-parse #{rev} --quiet]).strip}
       shas = Dir.chdir(git_source_path){revs.map(&rev_parse)}
-      shas.map(&:class).uniq.should be == [String]
-      shas.map(&:size).uniq.should be == [40]
-      shas.uniq.should be == shas
+      expect(shas.map(&:class).uniq).to eq [String]
+      expect(shas.map(&:size).uniq).to eq [40]
+      expect(shas.uniq).to eq shas
     end
   end
 
@@ -106,23 +104,53 @@ describe Librarian::Source::Git::Repository do
     let(:atag_sha) { subject.hash_from("origin", atag) }
 
     it "should recognize it" do
-      subject.should be_git
+      expect(subject).to be_git
     end
 
     it "should have a single remote for it" do
-      subject.should have(1).remote_names
+      expect(subject).to have(1).remote_names
     end
 
     it "should have a remote with the expected name" do
-      subject.remote_names.first.should == "origin"
+      expect(subject.remote_names.first).to eq "origin"
     end
 
     it "should have the remote branch" do
-      subject.remote_branch_names["origin"].should include branch
+      expect(subject.remote_branch_names["origin"]).to include branch
     end
 
     it "should be checked out on the master" do
-      subject.should be_checked_out(master_sha)
+      expect(subject).to be_checked_out(master_sha)
+    end
+
+    context "checking for commits" do
+      it "has the master commit" do
+        expect(subject).to have_commit(master_sha)
+      end
+
+      it "has the branch commit" do
+        expect(subject).to have_commit(branch_sha)
+      end
+
+      it "has the tag commit" do
+        expect(subject).to have_commit(tag_sha)
+      end
+
+      it "has the atag commit" do
+        expect(subject).to have_commit(atag_sha)
+      end
+
+      it "does not have a made-up commit" do
+        expect(subject).to_not have_commit(SecureRandom.hex(20))
+      end
+
+      it "does not have a tree commit" do
+        master_tree_sha = Dir.chdir(git_source_path) do
+          git!(%W[log -1 --no-color --format=tformat:%T master]).strip
+        end
+        expect(master_tree_sha).to match(/\A[0-9a-f]{40}\z/) # sanity
+        expect(subject).to_not have_commit(master_tree_sha)
+      end
     end
 
     context "checking out the branch" do
@@ -131,11 +159,11 @@ describe Librarian::Source::Git::Repository do
       end
 
       it "should be checked out on the branch" do
-        subject.should be_checked_out(branch_sha)
+        expect(subject).to be_checked_out(branch_sha)
       end
 
       it "should not be checked out on the master" do
-        subject.should_not be_checked_out(master_sha)
+        expect(subject).to_not be_checked_out(master_sha)
       end
     end
 
@@ -145,11 +173,11 @@ describe Librarian::Source::Git::Repository do
       end
 
       it "should be checked out on the tag" do
-        subject.should be_checked_out(tag_sha)
+        expect(subject).to be_checked_out(tag_sha)
       end
 
       it "should not be checked out on the master" do
-        subject.should_not be_checked_out(master_sha)
+        expect(subject).to_not be_checked_out(master_sha)
       end
     end
 
@@ -159,11 +187,11 @@ describe Librarian::Source::Git::Repository do
       end
 
       it "should be checked out on the annotated tag" do
-        subject.should be_checked_out(atag_sha)
+        expect(subject).to be_checked_out(atag_sha)
       end
 
       it "should not be checked out on the master" do
-        subject.should_not be_checked_out(master_sha)
+        expect(subject).to_not be_checked_out(master_sha)
       end
     end
   end

data/spec/functional/source/git_spec.rb

@@ -1,24 +1,37 @@
+require "fileutils"
 require "pathname"
 require "securerandom"
 
 require "librarian/error"
+require "librarian/posix"
 require "librarian/source/git"
+require "librarian/source/git/repository"
+require "librarian/mock/environment"
+
+require "support/project_path_macro"
 
 describe Librarian::Source::Git do
+  include Support::ProjectPathMacro
 
-  let(:project_path) do
-    project_path = Pathname.new(__FILE__).expand_path
-    project_path = project_path.dirname until project_path.join("Rakefile").exist?
-    project_path
-  end
   let(:tmp_path) { project_path + "tmp/spec/functional/source/git" }
   after { tmp_path.rmtree if tmp_path && tmp_path.exist? }
-  let(:cache_path) { tmp_path + "cache" }
+  let(:env_project_path) { tmp_path + "project" }
+
+  def cmd!(command)
+    Librarian::Posix.run! command
+  end
+
+  def git!(command)
+    cmd!([Librarian::Source::Git::Repository.bin] + command)
+  end
+
+  def new_env
+    Librarian::Mock::Environment.new(:project_path => env_project_path)
+  end
 
   context "when the remote is bad" do
     let(:remote) { tmp_path.join(SecureRandom.hex(8)).to_s }
-    let(:logger) { double(:debug => nil, :info => nil) }
-    let(:env) { double(:ui => nil, :logger => logger, :cache_path => cache_path) }
+    let(:env) { new_env }
     let(:source) { described_class.new(env, remote, {}) }
 
     it "fails when caching" do
@@ -27,4 +40,135 @@ describe Librarian::Source::Git do
     end
   end
 
+  context "when the remote has a repo" do
+    let(:remote) { tmp_path.join(SecureRandom.hex(8)).to_s }
+    let(:git_source_path) { Pathname.new(remote) }
+    let(:env) { new_env }
+    let(:source) { described_class.new(env, remote, {}) }
+
+    before do
+      git_source_path.mkpath
+      Dir.chdir(git_source_path) do
+        git! %W[init]
+        git! %W[config user.name Simba]
+        git! %W[config user.email simba@savannah-pride.gov]
+        FileUtils.touch "butter.txt"
+        git! %W[add butter.txt]
+        git! %W[commit -m #{"Initial Commit"}]
+      end
+    end
+
+    let(:sha) do
+      Dir.chdir(git_source_path) do
+        git!(%W[rev-parse master]).strip
+      end
+    end
+
+    context "when caching once" do
+      it "has the expected sha" do
+        expect{source.cache!}.to change{source.sha}.from(nil).to(sha)
+      end
+
+      it "records the history" do
+        expect{source.cache!}.to change{source.git_ops_count}.from(0).to(9)
+      end
+    end
+
+    context "when caching twice" do
+      before { source.cache! }
+
+      it "keeps the expected sha" do
+        expect{source.cache!}.to_not change{source.sha}
+      end
+
+      it "runs git commands once" do
+        expect{source.cache!}.to_not change{source.git_ops_count}
+      end
+    end
+
+    context "when caching twice from different sources" do
+      let(:other_source) { described_class.new(env, remote, {}) }
+      before { other_source.cache! }
+
+      it "has the expected sha" do
+        expect{source.cache!}.to change{source.sha}.from(nil).to(sha)
+      end
+
+      it "records the history" do
+        expect{source.cache!}.to change{source.git_ops_count}.from(0).to(1)
+      end
+    end
+
+    context "when caching twice from different sources, second time with sha" do
+      let(:other_source) { described_class.new(env, remote, {}) }
+      before { other_source.cache! }
+
+      let(:source) { described_class.new(env, remote, {:sha => sha}) }
+
+      it "has the expected sha" do
+        expect{source.cache!}.to_not change{source.sha}
+      end
+
+      it "records the history" do
+        expect{source.cache!}.to change{source.git_ops_count}.from(0).to(1)
+      end
+    end
+
+    context "when caching twice from different environments" do
+      let(:other_source) { described_class.new(new_env, remote, {}) }
+      before { other_source.cache! }
+
+      it "has the expected sha" do
+        expect{source.cache!}.to change{source.sha}.from(nil).to(sha)
+      end
+
+      it "records the history" do
+        expect{source.cache!}.to change{source.git_ops_count}.from(0).to(8)
+      end
+    end
+
+    context "when caching twice from different environments, second time with sha" do
+      let(:other_source) { described_class.new(new_env, remote, {}) }
+      before { other_source.cache! }
+
+      let(:source) { described_class.new(env, remote, {:sha => sha}) }
+
+      it "has the expected sha" do
+        expect{source.cache!}.to_not change{source.sha}
+      end
+
+      it "records the history" do
+        expect{source.cache!}.to change{source.git_ops_count}.from(0).to(3)
+      end
+    end
+
+    context "when the sha is missing from a cached repo" do
+      let(:other_source) { described_class.new(new_env, remote, {}) }
+      before { other_source.cache! }
+
+      before do
+        Dir.chdir(git_source_path) do
+          FileUtils.touch "jam.txt"
+          git! %w[add jam.txt]
+          git! %W[commit -m #{"Some Jam"}]
+        end
+      end
+
+      let(:source) { described_class.new(env, remote, {:sha => sha}) }
+
+      it "has a new remote sha" do
+        expect(sha).to_not eq(other_source.sha)
+      end
+
+      it "has the expected sha" do
+        expect{source.cache!}.to_not change{source.sha}
+      end
+
+      it "records the history" do
+        expect{source.cache!}.to change{source.git_ops_count}.from(0).to(8)
+      end
+    end
+
+  end
+
 end

data/spec/support/project_path_macro.rb

@@ -0,0 +1,14 @@
+module Support
+  module ProjectPathMacro
+
+    project_path = Pathname.new(__FILE__).expand_path
+    project_path = project_path.dirname until project_path.join("Rakefile").exist?
+
+    PROJECT_PATH = project_path
+
+    def project_path
+      PROJECT_PATH
+    end
+
+  end
+end

data/spec/unit/action/base_spec.rb

@@ -11,7 +11,7 @@ module Librarian
     it { should respond_to :environment }
 
     it "should have the environment that was assigned to it" do
-      action.environment.should be env
+      expect(action.environment).to be env
     end
 
   end

data/spec/unit/action/clean_spec.rb

@@ -30,7 +30,7 @@ module Librarian
             end
 
             it "should not try to clear the cache path" do
-              env.cache_path.should_receive(:rmtree).never
+              expect(env.cache_path).to receive(:rmtree).never
             end
           end
 
@@ -40,7 +40,7 @@ module Librarian
             end
 
             it "should try to clear the cache path" do
-              env.cache_path.should_receive(:rmtree).exactly(:once)
+              expect(env.cache_path).to receive(:rmtree).exactly(:once)
             end
           end
 
@@ -58,7 +58,7 @@ module Librarian
             end
 
             it "should not try to clear the install path" do
-              env.install_path.should_receive(:children).never
+              expect(env.install_path).to receive(:children).never
             end
           end
 
@@ -75,7 +75,7 @@ module Librarian
               env.stub_chain(:install_path, :children) { children }
 
               children.each do |child|
-                child.should_receive(:rmtree).exactly(:once)
+                expect(child).to receive(:rmtree).exactly(:once)
               end
             end
 
@@ -84,10 +84,10 @@ module Librarian
               env.stub_chain(:install_path, :children) { children }
 
               children.select(&:file?).each do |child|
-                child.should_receive(:rmtree).never
+                expect(child).to receive(:rmtree).never
               end
               children.reject(&:file?).each do |child|
-                child.should_receive(:rmtree).exactly(:once)
+                expect(child).to receive(:rmtree).exactly(:once)
               end
             end
           end