delta_test 0.1.0

data/spec/lib/delta_test/configuration_spec.rb

@@ -0,0 +1,353 @@
+describe DeltaTest::Configuration do
+
+  let(:configuration) { DeltaTest::Configuration.new }
+
+  describe '::new' do
+
+    let(:options) do
+      %i[
+        base_path
+        table_file
+        files
+      ]
+    end
+
+    it 'should set default values' do
+      options.each do |option|
+        expect(configuration.respond_to?(option)).to be(true)
+        expect(configuration.send(option)).not_to be_nil
+      end
+    end
+
+  end
+
+  describe '#base_path, #base_path=' do
+
+    it 'should return an instance of Pathname' do
+      expect(configuration.base_path).to be_a(Pathname)
+    end
+
+    it 'should store an instance of Pathname from a string in the setter' do
+      path = 'foo/bar'
+
+      expect {
+        configuration.base_path = path
+      }.not_to raise_error
+
+      expect(configuration.base_path).to be_a(Pathname)
+      expect(configuration.base_path.to_s).to eq(path)
+    end
+
+  end
+
+  describe '#table_file, #table_file=' do
+
+    it 'should return an instance of Pathname' do
+      expect(configuration.table_file).to be_a(Pathname)
+    end
+
+    it 'should store an instance of Pathname from a string in the setter' do
+      path = 'foo/bar'
+
+      expect {
+        configuration.table_file = path
+      }.not_to raise_error
+
+      expect(configuration.table_file).to be_a(Pathname)
+      expect(configuration.table_file.to_s).to eq(path)
+    end
+
+  end
+
+  describe '#validate!' do
+
+    describe '#base_path' do
+
+      it 'should raise an error if `base_path` is a relative path' do
+        configuration.base_path = "relative/path"
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/base_path/)
+      end
+
+      it 'should not raise if `base_path` is a absolute path' do
+        configuration.base_path = "/absolute/path"
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+
+    end
+
+    describe '#files' do
+
+      it 'should raise an error if `files` is not set' do
+        configuration.files = nil
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/files/)
+      end
+
+      it 'should raise an error if `files` is neither an array' do
+        configuration.files = {}
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/files/)
+      end
+
+      it 'should not raise if `files` is an array' do
+        configuration.files = []
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+
+    end
+
+    describe '#patterns' do
+
+      it 'should raise an error if `patterns` is not set' do
+        configuration.patterns = nil
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/patterns/)
+      end
+
+      it 'should raise an error if `patterns` is neither an array' do
+        configuration.patterns = {}
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/patterns/)
+      end
+
+      it 'should not raise if `patterns` is an array' do
+        configuration.patterns = []
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+
+    end
+
+    describe '#exclude_patterns' do
+
+      it 'should raise an error if `exclude_patterns` is not set' do
+        configuration.exclude_patterns = nil
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/patterns/)
+      end
+
+      it 'should raise an error if `exclude_patterns` is neither an array' do
+        configuration.exclude_patterns = {}
+
+        expect {
+          configuration.validate!
+        }.to raise_error(/exclude_patterns/)
+      end
+
+      it 'should not raise if `exclude_patterns` is an array' do
+        configuration.exclude_patterns = []
+
+        expect {
+          configuration.validate!
+        }.not_to raise_error
+      end
+
+    end
+
+  end
+
+  describe '#precalculate!' do
+
+    describe '#filtered_files' do
+
+      it 'should return an instance of Set' do
+        configuration.precalculate!
+        expect(configuration.filtered_files).to be_a(Set)
+      end
+
+      it 'should return a set of filtered file paths' do
+        base_path = '/base_path'
+        patterns = [
+          '**/*r'
+        ]
+        files = [
+          '/base_path/foo/bar',
+          '/base_path/foo/bar',
+          '/base_path/foo/bar/baz',
+        ]
+        filtered_files = Set[
+          Pathname.new('foo/bar'),
+        ]
+
+        configuration.base_path = base_path
+        configuration.files     = files
+        configuration.patterns  = patterns
+
+        configuration.precalculate!
+        expect(configuration.filtered_files).to eq(filtered_files)
+      end
+
+    end
+
+    describe '#table_file_path' do
+
+      it 'should return an absolute path to the table file if `table_file` is a relative' do
+        configuration.base_path  = '/base_path'
+        configuration.table_file = 'somewhere/table_file'
+
+        configuration.precalculate!
+        expect(configuration.table_file_path).to eq(Pathname.new('/base_path/somewhere/table_file'))
+      end
+
+      it 'should return the same value to the table file if `table_file` is a absolute' do
+        configuration.base_path  = '/base_path'
+        configuration.table_file = '/somewhere/table_file'
+
+        configuration.precalculate!
+        expect(configuration.table_file_path).to eq(Pathname.new('/somewhere/table_file'))
+      end
+
+    end
+
+  end
+
+  describe '#update' do
+
+    it 'should call `validate!` and `precalculate!` after the block' do
+      dummy = double
+      allow(dummy).to receive(:not_yet_called)
+      allow(dummy).to receive(:already_called)
+
+      expect(dummy).to receive(:not_yet_called).with(no_args).once.ordered
+      expect(configuration).to receive(:validate!).with(no_args).once.ordered
+      expect(configuration).to receive(:precalculate!).with(no_args).once.ordered
+      expect(dummy).to receive(:already_called).with(no_args).once.ordered
+
+      configuration.update do |config|
+        dummy.not_yet_called
+      end
+
+      dummy.already_called
+    end
+
+  end
+
+  describe 'Auto configuration' do
+
+    describe '#auto_configure!' do
+
+      it 'should call `load_from_file!`, `retrive_files_from_git_index!` and `update`' do
+        allow(configuration).to receive(:load_from_file!).and_return(true)
+        allow(configuration).to receive(:retrive_files_from_git_index!).and_return(true)
+
+        expect(configuration).to receive(:load_from_file!).with(no_args).once.ordered
+        expect(configuration).to receive(:retrive_files_from_git_index!).with(no_args).once.ordered
+        expect(configuration).to receive(:update).with(no_args).once.ordered
+
+        configuration.auto_configure!
+      end
+
+    end
+
+    describe '#load_from_file!' do
+
+      let(:pwd)             { '/path/to/pwd' }
+      let(:yaml_file_path)  { '/path/to/delta_test.yml' }
+      let(:table_file_path) { '/path/to/table_file' }
+
+      let(:yaml_file) do
+        file = FakeFS::FakeFile.new
+
+        file.content = <<-YAML
+  table_file: #{table_file_path}
+        YAML
+
+        file
+      end
+
+      before do
+        FakeFS::FileSystem.add(pwd)
+        Dir.chdir(pwd)
+      end
+
+      it 'should raise an error if no file is found' do
+        expect {
+          configuration.load_from_file!
+        }.to raise_error(DeltaTest::NoConfigurationFileFoundError)
+      end
+
+      it 'should set `base_path` to the directory of yaml file' do
+        FakeFS::FileSystem.add(yaml_file_path, yaml_file)
+
+        expect {
+          configuration.load_from_file!
+        }.not_to raise_error
+
+        expect(configuration.base_path).to eq(Pathname.new(File.dirname(yaml_file_path)))
+      end
+
+      it 'should set other option values from yaml' do
+        FakeFS::FileSystem.add(yaml_file_path, yaml_file)
+
+        expect {
+          configuration.load_from_file!
+        }.not_to raise_error
+
+        expect(configuration.table_file).to eq(Pathname.new(table_file_path))
+      end
+
+      it 'should raise an error if there is invalid option in yaml' do
+        FakeFS::FileSystem.add(yaml_file_path, yaml_file)
+        yaml_file.content = <<-YAML
+  foo: true
+        YAML
+
+        expect {
+          configuration.load_from_file!
+        }.to raise_error(DeltaTest::InvalidOptionError, /foo/)
+      end
+
+    end
+
+    describe 'retrive_files_from_git_index!' do
+
+      it 'should raise an error if not in git repo' do
+        allow(DeltaTest::Git).to receive(:git_repo?).with(no_args).and_return(false)
+
+        expect {
+          configuration.retrive_files_from_git_index!
+        }.to raise_error(DeltaTest::NotInGitRepositoryError)
+      end
+
+      it 'should set `files` from the file indices of git' do
+        files = [
+          'a/file_1',
+          'a/file_2',
+        ]
+
+        allow(DeltaTest::Git).to receive(:git_repo?).with(no_args).and_return(true)
+        allow(DeltaTest::Git).to receive(:ls_files).with(no_args).and_return(files)
+
+        expect {
+          configuration.retrive_files_from_git_index!
+        }.not_to raise_error
+
+        expect(configuration.files).to eq(files)
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/delta_test/dependencies_table_spec.rb

@@ -0,0 +1,129 @@
+require 'delta_test/dependencies_table'
+
+describe DeltaTest::DependenciesTable do
+
+  it 'should be a subclass of Hash' do
+    expect(DeltaTest::DependenciesTable).to be < Hash
+  end
+
+
+  let(:table) { DeltaTest::DependenciesTable.new }
+
+  describe '#[]' do
+
+    it 'should initiate an empty set if not accessed before' do
+      value = table[:foo]
+      expect(value).to be_a(Set)
+      expect(value).to be_empty
+    end
+
+    it 'should retain objects throughout accesses' do
+      foo_1 = table[:foo].object_id
+      foo_2 = table[:foo].object_id
+      expect(foo_1).to eq(foo_2)
+    end
+
+  end
+
+  describe '#add' do
+
+    let(:spec_file) { 'spec/foo_spec.rb' }
+    let(:base_path) { '/base_path' }
+
+    let(:files) do
+      ['foo/file_1.txt']
+    end
+
+    before do
+      DeltaTest.configure do |config|
+        config.base_path = base_path
+        config.files     = files
+      end
+    end
+
+    it 'should add a regulated file path' do
+      table.add(spec_file, '/base_path/foo/file_1.txt')
+      expect(table[spec_file]).to eq(Set[Pathname.new('foo/file_1.txt')])
+    end
+
+    it 'should add nothing if a file path is not included in `files` set' do
+      table.add(spec_file, '/base_path/foo/file_2.txt')
+      expect(table[spec_file]).to be_empty
+    end
+
+  end
+
+  describe '#without_default_proc' do
+
+    it 'should reset default_proc temporary inside a block' do
+      expect(table.default_proc).not_to be_nil
+      table.without_default_proc do
+        expect(table.default_proc).to be_nil
+      end
+      expect(table.default_proc).not_to be_nil
+    end
+
+  end
+
+  describe '#cleanup!' do
+
+    it 'should delete items where value is an empty set' do
+      table[:foo]
+      table[:bar] << 1
+      expect(table.keys).to eq([:foo, :bar])
+      table.cleanup!
+      expect(table.keys).to eq([:bar])
+    end
+
+  end
+
+  shared_examples :_create_table do
+
+    include_examples :create_table_file
+
+    let!(:table) do
+      table = DeltaTest::DependenciesTable.new
+
+      table[:foo] << 1
+      table[:foo] << 2
+      table[:bar] << 10
+      table[:bar] << 20
+
+      table
+    end
+
+  end
+
+  describe '#dump' do
+
+    include_examples :_create_table
+
+    it 'should dump a table object to a file' do
+      expect(table_file.content).to be_empty
+
+      expect {
+        table.dump(table_file_path)
+      }.not_to raise_error
+
+      expect(table_file.content).not_to be_empty
+    end
+
+  end
+
+  describe '::load' do
+
+    include_examples :_create_table
+
+    it 'should restore a table object from a file' do
+      table.dump(table_file_path)
+      restored_table = nil
+      expect {
+        restored_table = DeltaTest::DependenciesTable.load(table_file_path)
+      }.not_to raise_error
+      expect(restored_table).to be_a(DeltaTest::DependenciesTable)
+      expect(restored_table).to eq(table)
+    end
+
+  end
+
+end

data/spec/lib/delta_test/generator_spec.rb

@@ -0,0 +1,201 @@
+require 'delta_test/generator'
+
+describe DeltaTest::Generator do
+
+  include_examples :create_table_file
+
+  let(:base_path) { Pathname.new(File.expand_path('../../../fixtures', __FILE__)) }
+
+  let(:spec_file)   { 'foo/spec_file.rb' }
+  let(:spec_file_2) { 'foo/spec_file_2.rb' }
+
+  let(:files) do
+    [
+      'sample/alpha.rb',
+      'sample/beta.rb',
+      # 'sample/gamma.rb',  # intentionally omitted
+    ]
+  end
+
+  let(:generator) { DeltaTest::Generator.new }
+
+  before do
+    DeltaTest.configure do |config|
+      config.base_path  = base_path
+      config.table_file = table_file_path
+      config.files      = files
+    end
+
+    DeltaTest.active = true
+  end
+
+  after do
+    DeltaTest.active = false
+    RubyProf.stop if RubyProf.running?
+  end
+
+  describe '#setup!' do
+
+    it 'should setup a generator' do
+      expect {
+        generator.setup!(false)  # disable tearadown
+      }.not_to raise_error
+
+      expect(generator).to be_respond_to(:table)
+      expect(generator.table).to be_a(DeltaTest::DependenciesTable)
+    end
+
+  end
+
+  describe '#start!' do
+
+    before do
+      generator.setup!(false)  # disable tearadown
+    end
+
+    it 'should start ruby-prof' do
+      expect(RubyProf.running?).to be(false)
+
+      expect {
+        generator.start!(spec_file)
+      }.not_to raise_error
+
+      expect(RubyProf.running?).to be(true)
+    end
+
+    describe '#current_spec_file' do
+
+      it 'should be set' do
+        expect(generator.current_spec_file).to be_nil
+        generator.start!(spec_file)
+        expect(generator.current_spec_file).to eq(spec_file)
+      end
+
+      it 'should be regulated' do
+        expect(generator.current_spec_file).to be_nil
+        generator.start!('./%s' % spec_file)
+        expect(generator.current_spec_file).to eq(spec_file)
+      end
+
+    end
+
+  end
+
+  describe '#stop!' do
+
+    before do
+      generator.setup!(false)  # disable tearadown
+    end
+
+    it 'should stop ruby-prof' do
+      expect(RubyProf.running?).to be(false)
+      generator.start!(spec_file)
+      expect(RubyProf.running?).to be(true)
+      generator.stop!
+      expect(RubyProf.running?).to be(false)
+    end
+
+    it 'should unset current_spec_file' do
+      expect(generator.current_spec_file).to be_nil
+      generator.start!(spec_file)
+      expect(generator.current_spec_file).to eq(spec_file)
+      generator.stop!
+      expect(generator.current_spec_file).to be_nil
+    end
+
+  end
+
+  describe '#table' do
+
+    before do
+      generator.setup!(false)  # disable tearadown
+    end
+
+    it 'should return a set of source files' do
+      expect(generator.table).to be_empty
+
+      generator.start!(spec_file)
+      Sample::Alpha.new.alpha
+      generator.stop!
+
+      expect(generator.table.keys).to eq([spec_file])
+      expect(generator.table[spec_file]).to include(Pathname.new('sample/alpha.rb'))
+    end
+
+    it 'should return a set of source files for every spec files' do
+      expect(generator.table).to be_empty
+
+      generator.start!(spec_file)
+      Sample::Alpha.new.alpha
+      generator.stop!
+
+      generator.start!(spec_file_2)
+      Sample::Beta.new.beta
+      generator.stop!
+
+      expect(generator.table.keys).to eq([spec_file, spec_file_2])
+      expect(generator.table[spec_file]).to include(Pathname.new('sample/alpha.rb'))
+      expect(generator.table[spec_file_2]).to include(Pathname.new('sample/beta.rb'))
+    end
+
+    it 'should not include paths not included in `files`' do
+      expect(generator.table).to be_empty
+
+      generator.start!(spec_file)
+      Sample::Alpha.new.beta_gamma
+      generator.stop!
+
+      expect(generator.table.keys).to eq([spec_file])
+      expect(generator.table[spec_file]).to include(Pathname.new('sample/alpha.rb'))
+      expect(generator.table[spec_file]).to include(Pathname.new('sample/beta.rb'))
+      expect(generator.table[spec_file]).not_to include(Pathname.new('sample/gamma.rb'))
+    end
+
+  end
+
+  describe '#teardown!' do
+
+    context 'When not `setup!` is called yet' do
+
+      it 'should do nothing' do
+        expect {
+          generator.teardown!
+        }.not_to raise_error
+      end
+
+    end
+
+    context 'When `setup!` is called' do
+
+      before do
+        generator.setup!(false)  # disable tearadown
+      end
+
+      it 'should stop ruby-prof if running' do
+        expect(RubyProf.running?).to be(false)
+        generator.start!(spec_file)
+        expect(RubyProf.running?).to be(true)
+        generator.teardown!
+        expect(RubyProf.running?).to be(false)
+      end
+
+      it 'should save the table into a file' do
+        expect(generator.table).to be_empty
+
+        generator.start!(spec_file)
+        Sample::Alpha.new.beta_gamma
+        generator.stop!
+
+        expect(generator.table).not_to be_empty
+        expect(table_file.content).to be_empty
+
+        generator.teardown!
+
+        expect(table_file.content).not_to be_empty
+      end
+
+    end
+
+  end
+
+end