delta_test 0.1.0

data/spec/lib/delta_test/git_spec.rb

@@ -0,0 +1,178 @@
+require 'delta_test/git'
+
+describe DeltaTest::Git do
+
+  let(:out)            { '' }
+  let(:success_status) { [out, '', double(success?: true)] }
+  let(:error_status)   { ['', '', double(success?: false)] }
+
+  describe '::git_repo?' do
+
+    let(:command) { %q{git rev-parse --is-inside-work-tree} }
+
+    it 'should return false if `git` command is not exist' do
+      allow(Open3).to receive(:capture3).with(command, any_args).and_raise
+
+      result = nil
+
+      expect {
+        result = DeltaTest::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(DeltaTest::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(DeltaTest::Git.git_repo?).to be(false)
+    end
+
+  end
+
+  describe '::root_dir' do
+
+    let(:command) { %q{git 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 {
+        DeltaTest::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(DeltaTest::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(DeltaTest::Git.root_dir).to be_nil
+    end
+
+  end
+
+  describe '::rev_parse' do
+
+    let(:rev)     { 'HEAD' }
+    let(:command) { %Q{git rev-parse #{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 {
+        DeltaTest::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(DeltaTest::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(DeltaTest::Git.rev_parse(rev)).to be_nil
+    end
+
+  end
+
+  describe '::same_commit?' do
+
+    let(:map) do
+      {
+        'master'      => '0000000000000000000000000000000000000000',
+        'HEAD'        => '1111111111111111111111111111111111111111',
+        'feature/foo' => '1111111111111111111111111111111111111111',
+      }
+    end
+
+    before do
+      map.each do |name, commit_id|
+        allow(DeltaTest::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
+
+        is_same = (map[r1] == map[r2])
+
+        expect(DeltaTest::Git.same_commit?(r1, r2)).to be(is_same)
+      end
+    end
+
+  end
+
+  describe '::ls_files' do
+
+    let(:command) { %q{git ls-files -z} }
+    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 {
+        DeltaTest::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(DeltaTest::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(DeltaTest::Git.ls_files).to eq([])
+    end
+
+  end
+
+  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" }
+
+    it 'should raise an error if the command is not exist' do
+      allow(Open3).to receive(:capture3).with(command, any_args).and_raise
+
+      expect {
+        DeltaTest::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(DeltaTest::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(DeltaTest::Git.changed_files).to eq([])
+    end
+
+  end
+
+end

data/spec/lib/delta_test/related_spec_list_spec.rb

@@ -0,0 +1,182 @@
+require 'delta_test/related_spec_list'
+
+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' }
+
+  before do
+    DeltaTest.configure do |config|
+      config.base_path  = base_path
+      config.table_file = table_file_path
+    end
+  end
+
+  shared_examples :_mock_table_and_changed_files do
+
+    let(:table) do
+      table = DeltaTest::DependenciesTable.new
+
+      table['spec/foo_spec.rb'] << 'lib/foo.rb'
+      table['spec/bar_spec.rb'] << 'lib/bar.rb'
+      table['spec/baz_spec.rb'] << 'lib/baz.rb'
+      table['spec/other_spec.rb']
+      table['spec/mixed_spec.rb'] << 'lib/foo.rb'
+      table['spec/mixed_spec.rb'] << 'lib/bar.rb'
+
+      table
+    end
+
+    let(:changed_files) do
+      [
+        'lib/foo.rb',
+      ]
+    end
+
+    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)
+    end
+
+  end
+
+  describe '#load_table!' do
+
+    it 'should raise an error if a table file is not exist' do
+      expect {
+        list.load_table!
+      }.to raise_error(DeltaTest::TableNotFoundError)
+    end
+
+    it 'should load the table if exist' do
+      table_file
+
+      expect(list.table).to be_nil
+
+      expect {
+        list.load_table!
+      }.not_to raise_error
+
+      expect(list.table).to be_a(DeltaTest::DependenciesTable)
+    end
+
+  end
+
+  describe '#retrive_changed_files!' 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)
+
+      expect {
+        list.retrive_changed_files!(base, head)
+      }.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)
+
+      expect(list.changed_files).to be_a(Array)
+      expect(list.changed_files).not_to be_empty
+    end
+
+  end
+
+  describe '#related_spec_files' do
+
+    include_examples :_mock_table_and_changed_files
+
+    before do
+      table_file
+      list.load_table!
+      list.retrive_changed_files!(base, head)
+    end
+
+    describe 'Dependents' do
+
+      let(:related_spec_files) do
+        Set[
+          'spec/foo_spec.rb',
+          'spec/mixed_spec.rb',
+        ]
+      end
+
+      it 'should be included' do
+        expect(list.related_spec_files).to eq(related_spec_files)
+      end
+
+    end
+
+    describe 'Modified spec files' do
+
+      let(:changed_files) do
+        [
+          'lib/foo.rb',
+          'spec/baz_spec.rb',
+        ]
+      end
+
+      let(:related_spec_files) do
+        Set[
+          'spec/foo_spec.rb',
+          'spec/mixed_spec.rb',
+          'spec/baz_spec.rb',
+        ]
+      end
+
+      it 'should be included' do
+        expect(list.related_spec_files).to eq(related_spec_files)
+      end
+
+    end
+
+    describe 'Custom dependents' do
+
+      let(:custom_mappings) do
+        {
+          'spec/other_spec.rb' => [
+            'config/locales/**/*.yml',
+          ]
+        }
+      end
+
+      let(:changed_files) do
+        [
+          'lib/foo.rb',
+          'config/locales/something/en.yml',
+        ]
+      end
+
+      let(:related_spec_files) do
+        Set[
+          'spec/foo_spec.rb',
+          'spec/mixed_spec.rb',
+          'spec/other_spec.rb',
+        ]
+      end
+
+      before do
+        DeltaTest.configure do |config|
+          config.custom_mappings = custom_mappings
+        end
+      end
+
+      it 'should be included' do
+        expect(list.related_spec_files).to eq(related_spec_files)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/delta_test/spec_helpers_spec.rb

@@ -0,0 +1,72 @@
+require 'delta_test/spec_helpers'
+
+describe DeltaTest::SpecHelpers do
+
+  before do
+    @rspec_example_group = Class.new do
+      class << self
+        def before(_)
+          yield if block_given?
+        end
+
+        def after(_)
+          yield if block_given?
+        end
+
+        def metadata
+          { file_path: 'spec/foo/bar.rb' }
+        end
+      end
+    end
+
+    allow(DeltaTest).to receive(:active?).and_return(false)
+  end
+
+  it 'should define a global generator' do
+    expect(defined?($delta_test_generator)).not_to be(false)
+  end
+
+  describe 'when extending' do
+
+    context 'before :all' do
+
+      it 'should call it' do
+        expect(@rspec_example_group).to receive(:before).with(:context)
+        @rspec_example_group.extend DeltaTest::SpecHelpers
+      end
+
+      it 'should start the generator' do
+        expect($delta_test_generator).to receive(:start!).with("spec/foo/bar.rb")
+        @rspec_example_group.extend DeltaTest::SpecHelpers
+      end
+
+    end
+
+    context 'after :all' do
+
+      it 'should call it' do
+        expect(@rspec_example_group).to receive(:after).with(:context)
+        @rspec_example_group.extend DeltaTest::SpecHelpers
+      end
+
+      it 'should stop the generator' do
+        expect($delta_test_generator).to receive(:stop!)
+        @rspec_example_group.extend DeltaTest::SpecHelpers
+      end
+
+    end
+
+  end
+
+  describe 'when including' do
+
+    it 'should call it' do
+      expect(@rspec_example_group).to receive(:before)
+      @rspec_example_group.class_eval do
+        include DeltaTest::SpecHelpers
+      end
+    end
+
+  end
+
+end

data/spec/lib/delta_test/utils_spec.rb

@@ -0,0 +1,244 @@
+require 'delta_test/utils'
+
+describe DeltaTest::Utils do
+
+  describe '::regulate_filepath' do
+
+    let(:base_path) { Pathname.new('/base_path') }
+
+    it 'shoud return a relative path from `base_path`' do
+      absolute_path = Pathname.new('/base_path/foo/file_1.txt')
+      relative_path = Pathname.new('foo/file_1.txt')
+
+      expect(DeltaTest::Utils.regulate_filepath(absolute_path, base_path)).to eq(relative_path)
+    end
+
+    it 'shoud return a clean path' do
+      absolute_path = Pathname.new('./foo/file_1.txt')
+      relative_path = Pathname.new('foo/file_1.txt')
+
+      expect(DeltaTest::Utils.regulate_filepath(absolute_path, base_path)).to eq(relative_path)
+    end
+
+    it 'shoud not raise an error and return the path when a path is not started with `base_path`' do
+      path = Pathname.new('other/foo/file_1.txt')
+
+      expect(DeltaTest::Utils.regulate_filepath(path, base_path)).to eq(path)
+    end
+
+  end
+
+  describe '::find_file_upward' do
+
+    let(:file)      { FakeFS::FakeFile.new }
+    let(:file_name) { 'file' }
+
+    it 'should return a file path if a file is exist in the current directory' do
+      pwd       = '/a/b/c/d'
+      file_path = "/a/b/c/d/#{file_name}"
+
+      FakeFS::FileSystem.add(pwd)
+      FakeFS::FileSystem.add(file_path, file)
+
+      Dir.chdir(pwd) do
+        expect(DeltaTest::Utils.find_file_upward(file_name)).to eq(file_path)
+      end
+    end
+
+    it 'should return a file path if a file is exist at the parent directory' do
+      pwd       = '/a/b/c/d'
+      file_path = "/a/b/c/#{file_name}"
+
+      FakeFS::FileSystem.add(pwd)
+      FakeFS::FileSystem.add(file_path, file)
+
+      Dir.chdir(pwd) do
+        expect(DeltaTest::Utils.find_file_upward(file_name)).to eq(file_path)
+      end
+    end
+
+    it 'should return a file path if a file is exist at somewhere of parent directories' do
+      pwd       = '/a/b/c/d'
+      file_path = "/a/#{file_name}"
+
+      FakeFS::FileSystem.add(pwd)
+      FakeFS::FileSystem.add(file_path, file)
+
+      Dir.chdir(pwd) do
+        expect(DeltaTest::Utils.find_file_upward(file_name)).to eq(file_path)
+      end
+    end
+
+    it 'should return nil if a file is not exist in any parent directories' do
+      pwd       = '/a/b/c/d'
+      file_path = "/abc/#{file_name}"
+
+      FakeFS::FileSystem.add(pwd)
+      FakeFS::FileSystem.add(file_path, file)
+
+      Dir.chdir(pwd) do
+        expect(DeltaTest::Utils.find_file_upward(file_name)).to be_nil
+      end
+    end
+
+    context 'Multiple file names' do
+
+      let(:file_2)      { FakeFS::FakeFile.new }
+      let(:file_name_2) { 'file' }
+
+      it 'should return a file path if one of files is exist at somewhere of parent directories' do
+        pwd       = '/a/b/c/d'
+        file_path = "/a/#{file_name}"
+
+        FakeFS::FileSystem.add(pwd)
+        FakeFS::FileSystem.add(file_path, file)
+
+        Dir.chdir(pwd) do
+          expect(DeltaTest::Utils.find_file_upward(file_name, file_name_2)).to eq(file_path)
+        end
+      end
+
+      it 'should return the first match if one of files is exist at somewhere of parent directories' do
+        pwd         = '/a/b/c/d'
+        file_path   = "/a/#{file_name}"
+        file_path_2 = "/a/#{file_name_2}"
+
+        FakeFS::FileSystem.add(pwd)
+        FakeFS::FileSystem.add(file_path, file)
+        FakeFS::FileSystem.add(file_path_2, file)
+
+        Dir.chdir(pwd) do
+          expect(DeltaTest::Utils.find_file_upward(file_name, file_name_2)).to eq(file_path)
+          expect(DeltaTest::Utils.find_file_upward(file_name_2, file_name)).to eq(file_path_2)
+        end
+      end
+
+      it 'should return nil if non of files is not exist in any parent directories' do
+        pwd         = '/a/b/c/d'
+        file_path   = "/abc/#{file_name}"
+        file_path_2 = "/cba/#{file_name_2}"
+
+        FakeFS::FileSystem.add(pwd)
+        FakeFS::FileSystem.add(file_path, file)
+        FakeFS::FileSystem.add(file_path_2, file)
+
+        Dir.chdir(pwd) do
+          expect(DeltaTest::Utils.find_file_upward(file_name, file_name_2)).to be_nil
+        end
+      end
+
+    end
+
+  end
+
+  describe '::grep_pattern_to_regexp' do
+
+    # private method
+    let(:grep_pattern_to_regexp) { DeltaTest::Utils.method(:grep_pattern_to_regexp) }
+
+    it 'should return a Regexp' do
+      expect(grep_pattern_to_regexp.call('')).to be_a(Regexp)
+    end
+
+    it 'should wrap a pattern with ^ and $' do
+      regexp = grep_pattern_to_regexp.call('aaa')
+
+      expect(regexp).to be_a(Regexp)
+      expect(regexp.source).to eq('^aaa$')
+    end
+
+    it 'should escape any special characters in a pattern' do
+      regexp = grep_pattern_to_regexp.call('\?{}.')
+
+      expect(regexp).to be_a(Regexp)
+      expect(regexp.source).to eq('^\\\\\?\{\}\.$')
+    end
+
+    it 'should replace ** with super-directory wildcards' do
+      regexp = grep_pattern_to_regexp.call('a/**')
+
+      expect(regexp).to be_a(Regexp)
+      expect(regexp.source).to eq('^a/.*$')
+    end
+
+    it 'should care about trailling slash when **/' do
+      regexp = grep_pattern_to_regexp.call('a/**/path')
+
+      expect(regexp).to be_a(Regexp)
+      expect(regexp.source).to eq('^a/.*/?path$')
+    end
+
+    it 'should replace * with file/directory name wildcards' do
+      regexp = grep_pattern_to_regexp.call('a/*_file')
+
+      expect(regexp).to be_a(Regexp)
+      expect(regexp.source).to eq('^a/[^/]*_file$')
+    end
+
+  end
+
+  describe '::files_grep' do
+
+    let(:files) do
+      [
+        '/0',
+        '/a/b/c',
+        '/a/b/c/d',
+        '/a/b/c/d/e',
+        '/x/y/z',
+      ]
+    end
+
+    let(:patterns) do
+      [
+        '/a/**/*',
+      ]
+    end
+
+    let(:exclude_patterns) do
+      [
+        '/a/**/e',
+        '/x/y/*',
+      ]
+    end
+
+    it 'should return the whole files when the patterns is an empty array' do
+      expect(DeltaTest::Utils.files_grep(files, [])).to eq(files)
+    end
+
+    it 'should return the whole files when the exclude patterns is an empty array' do
+      expect(DeltaTest::Utils.files_grep(files, [], [])).to eq(files)
+    end
+
+    it 'should return files only matched with the patterns' do
+      matched_files = [
+        '/a/b/c',
+        '/a/b/c/d',
+        '/a/b/c/d/e',
+      ]
+
+      expect(DeltaTest::Utils.files_grep(files, patterns)).to eq(matched_files)
+    end
+
+    it 'should return files not matched with the exclude patterns' do
+      matched_files = [
+        '/0',
+        '/a/b/c',
+        '/a/b/c/d',
+      ]
+
+      expect(DeltaTest::Utils.files_grep(files, [], exclude_patterns)).to eq(matched_files)
+    end
+
+    it 'should return files not matched with an union of patterns' do
+      matched_files = [
+        '/a/b/c',
+        '/a/b/c/d',
+      ]
+
+      expect(DeltaTest::Utils.files_grep(files, patterns, exclude_patterns)).to eq(matched_files)
+    end
+
+  end
+
+end