delta_test 0.2.0 → 1.0.0

data/spec/lib/delta_test/git_spec.rb

@@ -6,92 +6,118 @@ describe DeltaTest::Git do
   let(:success_status) { [out, '', double(success?: true)] }
   let(:error_status)   { ['', '', double(success?: false)] }
 
-  describe '::git_repo?' do
+  let(:git) { DeltaTest::Git.new('.') }
 
-    let(:command) { %q{git rev-parse --is-inside-work-tree} }
+  describe '.new' do
+
+    it 'sholud execute commands in the specified directory' do
+      dir = '/dir'
+      git = DeltaTest::Git.new(dir)
+      expect(git.dir).to be_a_kind_of(Pathname)
+      expect(git.dir.to_s).to eq(dir)
+    end
+
+  end
+
+  describe '#git_repo?' do
+
+    let(:subcommand) { ['rev-parse --is-inside-work-tree'] }
+
+    before do
+      allow(git).to receive(:git_repo?).and_call_original
+    end
 
     it 'should return false if `git` command is not exist' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_raise
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
 
       result = nil
 
       expect {
-        result = DeltaTest::Git.git_repo?
+        result = git.git_repo?
       }.not_to raise_error
 
       expect(result).to be(false)
     end
 
     it 'should return true exit code is 0' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(success_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
 
-      expect(DeltaTest::Git.git_repo?).to be(true)
+      expect(git.git_repo?).to be(true)
     end
 
     it 'should return false exit code not is 0' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(error_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
 
-      expect(DeltaTest::Git.git_repo?).to be(false)
+      expect(git.git_repo?).to be(false)
     end
 
   end
 
-  describe '::root_dir' do
+  describe '#root_dir' do
 
-    let(:command) { %q{git rev-parse --show-toplevel} }
-    let(:out)     { '/root/dir' }
+    let(:subcommand) { ['rev-parse --show-toplevel'] }
+    let(:out)        { '/root/dir' }
 
     it 'should raise an error if the command is not exist' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_raise
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
 
       expect {
-        DeltaTest::Git.root_dir
+        git.root_dir
       }.to raise_error
     end
 
     it 'should return a root directory path if success' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(success_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
 
-      expect(DeltaTest::Git.root_dir).to eq(out)
+      expect(git.root_dir).to eq(out)
     end
 
     it 'should return nil if error' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(error_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
 
-      expect(DeltaTest::Git.root_dir).to be_nil
+      expect(git.root_dir).to be_nil
     end
 
   end
 
-  describe '::rev_parse' do
+  describe '#rev_parse' do
 
-    let(:rev)     { 'HEAD' }
-    let(:command) { %Q{git rev-parse #{rev}} }
-    let(:out)     { '818b60efa12b4bd99815e9b550185d1fb6244663' }
+    let(:rev)        { 'HEAD' }
+    let(:subcommand) { ['rev-parse %s', rev] }
+    let(:out)        { '818b60efa12b4bd99815e9b550185d1fb6244663' }
 
     it 'should raise an error if the command is not exist' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_raise
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
 
       expect {
-        DeltaTest::Git.rev_parse(rev)
+        git.rev_parse(rev)
       }.to raise_error
     end
 
     it 'should return a commit id if success' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(success_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
 
-      expect(DeltaTest::Git.rev_parse(rev)).to eq(out)
+      expect(git.rev_parse(rev)).to eq(out)
     end
 
     it 'should return nil if error' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(error_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
 
-      expect(DeltaTest::Git.rev_parse(rev)).to be_nil
+      expect(git.rev_parse(rev)).to be_nil
     end
 
   end
 
-  describe '::same_commit?' do
+  describe '#same_commit?' do
 
     let(:map) do
       {
@@ -103,74 +129,289 @@ describe DeltaTest::Git do
 
     before do
       map.each do |name, commit_id|
-        allow(DeltaTest::Git).to receive(:rev_parse).with(name).and_return(commit_id)
+        allow(git).to receive(:rev_parse).with(name).and_return(commit_id)
       end
     end
 
     it 'should compare two names by thier commit ids' do
       names = map.values
       names.product(names).each do |r1, r2|
-        expect(DeltaTest::Git).to receive(:rev_parse).with(r1).ordered
-        expect(DeltaTest::Git).to receive(:rev_parse).with(r2).ordered
+        expect(git).to receive(:rev_parse).with(r1).ordered
+        expect(git).to receive(:rev_parse).with(r2).ordered
 
         is_same = (map[r1] == map[r2])
 
-        expect(DeltaTest::Git.same_commit?(r1, r2)).to be(is_same)
+        expect(git.same_commit?(r1, r2)).to be(is_same)
       end
     end
 
   end
 
-  describe '::ls_files' do
+  describe '#ls_files' do
 
-    let(:command) { %q{git ls-files -z} }
-    let(:out)     { "/a/file/1\x0/a/file/2\x0/a/file/3" }
+    let(:subcommand) { ['ls-files -z %s', '.'] }
+    let(:out)        { "/a/file/1\x0/a/file/2\x0/a/file/3" }
 
     it 'should raise an error if the command is not exist' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_raise
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
 
       expect {
-        DeltaTest::Git.ls_files
+        git.ls_files
       }.to raise_error
     end
 
     it 'should return an array if success' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(success_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
 
-      expect(DeltaTest::Git.ls_files).to eq(out.split("\x0"))
+      expect(git.ls_files).to eq(out.split("\x0"))
     end
 
     it 'should return an empty array if error' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(error_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
 
-      expect(DeltaTest::Git.ls_files).to eq([])
+      expect(git.ls_files).to eq([])
     end
 
   end
 
-  describe '::changed_files' do
+  describe '#changed_files' do
 
-    let(:command) { %q{git --no-pager diff --name-only -z master HEAD} }
-    let(:out)     { "/a/file/1\x0/a/file/2\x0/a/file/3" }
+    let(:subcommand) { ['diff --name-only -z %s %s %s', 'master', 'HEAD', '.'] }
+    let(:out)        { "/a/file/1\x0/a/file/2\x0/a/file/3" }
 
     it 'should raise an error if the command is not exist' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_raise
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
 
       expect {
-        DeltaTest::Git.changed_files
+        git.changed_files
       }.to raise_error
     end
 
     it 'should return an array if success' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(success_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
 
-      expect(DeltaTest::Git.changed_files).to eq(out.split("\x0"))
+      expect(git.changed_files).to eq(out.split("\x0"))
     end
 
     it 'should return an empty array if error' do
-      allow(Open3).to receive(:capture3).with(command, any_args).and_return(error_status)
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
+
+      expect(git.changed_files).to eq([])
+    end
+
+  end
+
+  describe '#ls_hashes' do
+
+    let(:subcommand) { [%q{log -z -n %d --format='%%H'}, 10] }
+    let(:out)        { "0000\x01111\x02222" }
+
+    it 'should raise an error if the command is not exist' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
+
+      expect {
+        git.ls_hashes(10)
+      }.to raise_error
+    end
+
+    it 'should return an array if success' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
+
+      expect(git.ls_hashes(10)).to eq(out.split("\x0"))
+    end
+
+    it 'should return an empty array if error' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
+
+      expect(git.ls_hashes(10)).to eq([])
+    end
+
+  end
+
+  describe '#remote_url' do
+
+    let(:subcommand) { ['config --get remote.origin.url'] }
+    let(:out)        { 'git@example.com:test/test.git' }
+
+    it 'should raise an error if the command is not exist' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
+
+      expect {
+        git.remote_url
+      }.to raise_error
+    end
+
+    it 'should return an url if success' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
+
+      expect(git.remote_url).to eq(out)
+    end
+
+    it 'should return nil if error' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
+
+      expect(git.remote_url).to be_nil
+    end
+
+  end
+
+  describe '#has_remote?' do
+
+    let(:subcommand) { ['config --get remote.origin.url'] }
+    let(:out)        { 'git@example.com:test/test.git' }
+
+    it 'should return false if the command is not exist' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
+
+      res = nil
+
+      expect {
+        res = git.has_remote?
+      }.not_to raise_error
+      expect(res).to be(false)
+    end
+
+    it 'should return true if it has a remote origin' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
+
+      expect(git.has_remote?).to be(true)
+    end
+
+    it 'should return false if not' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
+
+      expect(git.has_remote?).to be(false)
+    end
+
+  end
+
+  describe '#pull' do
+
+    let(:subcommand) { ['pull origin master'] }
+
+    it 'should raise an error if the command is not exist' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
+
+      expect {
+        git.pull
+      }.to raise_error
+    end
+
+    it 'should return true if success' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
+
+      expect(git.pull).to be(true)
+    end
+
+    it 'should return false if error' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
+
+      expect(git.pull).to be(false)
+    end
+
+  end
+
+  describe '#push' do
+
+    let(:subcommand) { ['push origin master'] }
+
+    it 'should raise an error if the command is not exist' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
+
+      expect {
+        git.push
+      }.to raise_error
+    end
+
+    it 'should return true if success' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
+
+      expect(git.push).to be(true)
+    end
+
+    it 'should return false if error' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
+
+      expect(git.push).to be(false)
+    end
+
+  end
+
+  describe '#add' do
+
+    let(:subcommand) { ['add %s', '/a/path'] }
+
+    it 'should raise an error if the command is not exist' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
+
+      expect {
+        git.add('/a/path')
+      }.to raise_error
+    end
+
+    it 'should return true if success' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
+
+      expect(git.add('/a/path')).to be(true)
+    end
+
+    it 'should return false if error' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
+
+      expect(git.add('/a/path')).to be(false)
+    end
+
+  end
+
+  describe '#commit' do
+
+    let(:subcommand) { ['commit -m %s', 'message'] }
+
+    it 'should raise an error if the command is not exist' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_raise
+
+      expect {
+        git.commit('message')
+      }.to raise_error
+    end
+
+    it 'should return true if success' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(success_status)
+
+      expect(git.commit('message')).to be(true)
+    end
+
+    it 'should return false if error' do
+      expect(git).to receive(:exec).with(*subcommand).and_call_original
+      allow(Open3).to receive(:capture3).and_return(error_status)
 
-      expect(DeltaTest::Git.changed_files).to eq([])
+      expect(git.commit('message')).to be(false)
     end
 
   end

data/spec/lib/delta_test/profiler_spec.rb

@@ -6,7 +6,7 @@ describe DeltaTest::Profiler do
     DeltaTest::Profiler.clean!
   end
 
-  describe '::start!' do
+  describe '.start!' do
 
     it 'should start profiler' do
       expect(DeltaTest::Profiler.running?).to be(false)
@@ -20,7 +20,7 @@ describe DeltaTest::Profiler do
 
   end
 
-  describe '::stop!' do
+  describe '.stop!' do
 
     it 'should not raise error if the profiler not yet started' do
       expect {
@@ -43,7 +43,7 @@ describe DeltaTest::Profiler do
 
   end
 
-  describe '::last_result' do
+  describe '.last_result' do
 
     it 'should retrun an array if not yet started' do
       files = DeltaTest::Profiler.last_result

data/spec/lib/delta_test/related_spec_list_spec.rb

@@ -4,16 +4,14 @@ describe DeltaTest::RelatedSpecList do
 
   include_examples :defer_create_table_file
 
-  let(:base) { 'master' }
-  let(:head) { 'feature/foo' }
   let(:list) { DeltaTest::RelatedSpecList.new }
 
-  let(:base_path) { '/base_path' }
+  let(:base_commit) { '1111111111111111111111111111111111111111' }
+  let(:base_path)   { '/base_path' }
 
   before do
     DeltaTest.configure do |config|
-      config.base_path  = base_path
-      config.table_file = table_file_path
+      config.base_path = base_path
     end
   end
 
@@ -41,8 +39,8 @@ describe DeltaTest::RelatedSpecList do
     before do
       allow(DeltaTest::DependenciesTable).to receive(:load).with(Pathname.new(table_file_path)).and_return(table)
 
-      allow(DeltaTest::Git).to receive(:git_repo?).and_return(true)
-      allow(DeltaTest::Git).to receive(:changed_files).with(base, head).and_return(changed_files)
+      allow(list.git).to receive(:git_repo?).and_return(true)
+      allow(list.git).to receive(:changed_files).with(base_commit).and_return(changed_files)
     end
 
   end
@@ -51,7 +49,7 @@ describe DeltaTest::RelatedSpecList do
 
     it 'should raise an error if a table file is not exist' do
       expect {
-        list.load_table!
+        list.load_table!(table_file_path)
       }.to raise_error(DeltaTest::TableNotFoundError)
     end
 
@@ -61,7 +59,7 @@ describe DeltaTest::RelatedSpecList do
       expect(list.table).to be_nil
 
       expect {
-        list.load_table!
+        list.load_table!(table_file_path)
       }.not_to raise_error
 
       expect(list.table).to be_a(DeltaTest::DependenciesTable)
@@ -74,17 +72,17 @@ describe DeltaTest::RelatedSpecList do
     include_examples :_mock_table_and_changed_files
 
     it 'shoud raise an error if the directory is not managed by git' do
-      allow(DeltaTest::Git).to receive(:git_repo?).and_return(false)
+      allow(list.git).to receive(:git_repo?).and_return(false)
 
       expect {
-        list.retrive_changed_files!(base, head)
+        list.retrive_changed_files!(base_commit)
       }.to raise_error(DeltaTest::NotInGitRepositoryError)
     end
 
     it 'shoud retrive a list of changed files' do
       expect(list.changed_files).to be_nil
 
-      list.retrive_changed_files!(base, head)
+      list.retrive_changed_files!(base_commit)
 
       expect(list.changed_files).to be_a(Array)
       expect(list.changed_files).not_to be_empty
@@ -98,8 +96,8 @@ describe DeltaTest::RelatedSpecList do
 
     before do
       table_file
-      list.load_table!
-      list.retrive_changed_files!(base, head)
+      list.load_table!(table_file_path)
+      list.retrive_changed_files!(base_commit)
     end
 
     describe '#dependents' do

data/spec/lib/delta_test/stats_spec.rb

@@ -0,0 +1,89 @@
+require 'delta_test/stats'
+require 'delta_test/git'
+
+describe DeltaTest::Stats do
+
+  describe '.new' do
+
+    it 'should initialize git instances for base_path and stats_path' do
+      expect(DeltaTest::Git).to receive(:new).with(DeltaTest.config.base_path)
+      expect(DeltaTest::Git).to receive(:new).with(DeltaTest.config.stats_path)
+      expect {
+        DeltaTest::Stats.new
+      }.not_to raise_error
+    end
+
+  end
+
+  let(:stats) { DeltaTest::Stats.new }
+
+  let(:commit_hashes) do
+    [
+      '4444444444444444444444444444444444444444',
+      '3333333333333333333333333333333333333333',
+      '2222222222222222222222222222222222222222',
+      '1111111111111111111111111111111111111111',
+      '0000000000000000000000000000000000000000',
+    ]
+  end
+
+  let(:files) do
+    [
+      '11/11111111111111111111111111111111111111/foo.txt',
+      '11/11111111111111111111111111111111111111/table.marshal',
+      '33/33333333333333333333333333333333333333/bar.txt',
+      '33/33333333333333333333333333333333333333/table.marshal',
+    ]
+  end
+
+  before do
+    allow_any_instance_of(DeltaTest::Git).to receive(:ls_hashes)
+      .with(DeltaTest.config.stats_life)
+      .and_return(commit_hashes)
+    allow_any_instance_of(DeltaTest::Git).to receive(:ls_files).and_return([])
+  end
+
+  describe '#base_commit' do
+
+    it 'should return a base commit if exists' do
+      allow_any_instance_of(DeltaTest::Git).to receive(:ls_files).and_return(files)
+      expect(stats.base_commit).to eq('3333333333333333333333333333333333333333')
+    end
+
+    it 'should return nil if not exists' do
+      expect(stats.base_commit).to be_nil
+    end
+
+  end
+
+  describe '#commit_dir' do
+
+    let(:commit_dir) { DeltaTest.config.stats_path.join('33/33333333333333333333333333333333333333') }
+
+    it 'should return a file for the commit hash if base_commit exists' do
+      allow_any_instance_of(DeltaTest::Git).to receive(:ls_files).and_return(files)
+      expect(stats.commit_dir).to eq(commit_dir)
+    end
+
+    it 'should return nil if base_commit does not exist' do
+      expect(stats.commit_dir).to be_nil
+    end
+
+  end
+
+  describe '#table_file_path' do
+
+    let(:table_file_path) { DeltaTest.config.stats_path.join('33/33333333333333333333333333333333333333/table.marshal') }
+
+    it 'should return a path of table file' do
+      allow_any_instance_of(DeltaTest::Git).to receive(:ls_files).and_return(files)
+      expect(stats.table_file_path).to eq(table_file_path)
+    end
+
+    it 'should return nil if base_commit does not exist' do
+      expect(stats.table_file_path).to be_nil
+    end
+
+  end
+
+end

data/spec/lib/delta_test/utils_spec.rb

@@ -2,7 +2,7 @@ require 'delta_test/utils'
 
 describe DeltaTest::Utils do
 
-  describe '::regulate_filepath' do
+  describe '.regulate_filepath' do
 
     let(:base_path) { Pathname.new('/base_path') }
 
@@ -28,7 +28,7 @@ describe DeltaTest::Utils do
 
   end
 
-  describe '::find_file_upward' do
+  describe '.find_file_upward' do
 
     let(:file)      { FakeFS::FakeFile.new }
     let(:file_name) { 'file' }
@@ -131,7 +131,7 @@ describe DeltaTest::Utils do
 
   end
 
-  describe '::grep_pattern_to_regexp' do
+  describe '.grep_pattern_to_regexp' do
 
     # private method
     let(:grep_pattern_to_regexp) { DeltaTest::Utils.method(:grep_pattern_to_regexp) }
@@ -177,7 +177,7 @@ describe DeltaTest::Utils do
 
   end
 
-  describe '::files_grep' do
+  describe '.files_grep' do
 
     let(:files) do
       [