mnogootex 0.2.1 → 2.0.0

data/spec/mnogootex/job/porter_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mnogootex/job/porter'
+
+require 'mnogootex/utils'
+
+describe Mnogootex::Job::Porter do
+  # NOTE: using mktmpdir instead of tmpdir allows parallelization
+  let(:test_dir) { Pathname.new(Dir.mktmpdir).join('mnogootex-test') }
+  before { test_dir.mkpath }
+  after { test_dir.rmtree }
+
+  describe '.new' do
+    it 'requires a source' do
+      expect { described_class.new hid: '1', source_path: nil }.to raise_exception(TypeError)
+    end
+
+    it 'requires source to exist' do
+      expect { described_class.new hid: '1', source_path: 'foobar' }.to raise_exception(Errno::ENOENT)
+    end
+
+    it 'accepts string as source' do
+      expect { described_class.new hid: '1', source_path: test_dir.to_s }.to_not raise_exception
+    end
+
+    it 'accepts pathname as source' do
+      expect { described_class.new hid: '1', source_path: test_dir }.to_not raise_exception
+    end
+  end
+
+  describe '#target_dir' do
+    before do
+      test_dir.join('a').mkpath
+      test_dir.join('b').mkpath
+      test_dir.join('a', 'main.file').write('')
+      test_dir.join('b', 'main.file').write('')
+    end
+    let(:porter_a1) { described_class.new hid: '1', source_path: test_dir.join('a', 'main.file') }
+    let(:porter_a2) { described_class.new hid: '2', source_path: test_dir.join('a', 'main.file') }
+    let(:porter_b1) { described_class.new hid: '1', source_path: test_dir.join('b', 'main.file') }
+
+    it 'has a deterministic location' do
+      hash = Mnogootex::Utils.short_md5(test_dir.join('a', 'main.file').realpath.to_s)
+      expect(porter_a1.target_dir.to_s).
+        to match(%r{\A.+/mnogootex/#{hash}/1\z})
+    end
+
+    it 'discriminates by hid' do
+      expect(porter_a1.target_dir).to_not eq(porter_a2.target_dir)
+    end
+
+    it 'discriminates by source' do
+      expect(porter_a1.target_dir).to_not eq(porter_b1.target_dir)
+    end
+  end
+
+  describe '#target_path' do
+    let(:source_path) { test_dir.join('a', 'main.file') }
+    let(:porter) { described_class.new hid: '1', source_path: source_path }
+
+    before do
+      source_path.dirname.mkpath
+      source_path.write('')
+    end
+
+    it 'rescopes source basename into target dirname' do
+      expect(porter.target_path.basename).to eq(source_path.basename)
+      expect(porter.target_path.dirname).to eq(porter.target_dir)
+    end
+  end
+
+  describe '#provide' do
+    let(:source_path) { test_dir.join('A', 'main.file') }
+
+    before do
+      test_dir.join('A', 'B').mkpath
+      test_dir.join('A', 'main.file').write('')
+      test_dir.join('A', '.mnogootexrc').write('')
+      test_dir.join('A', '.dotfile').write('')
+      test_dir.join('A', 'B', 'ancillary.file').write('')
+    end
+
+    subject { described_class.new hid: 'job_id', source_path: source_path }
+
+    it 'creates target directory' do
+      subject.provide
+      expect(subject.target_dir).to be_directory
+    end
+
+    it 'ignores configuration file' do
+      test_dir.join('A', '.mnogootexrc').unlink
+      subject.provide
+      expect(subject.target_dir.join('.mnogootexrc')).to_not exist
+    end
+
+    it 'creates link to source' do
+      subject.provide
+      expect(subject.target_dir.join('.mnogootex.src').readlink).to eq(source_path.realpath)
+    end
+
+    def relative_subtree(pathname)
+      Pathname.glob(pathname.join('**', '{.*,*}')).map do |child|
+        child.relative_path_from(pathname)
+      end.sort
+    end
+
+    it 'copies all source files' do
+      subject.provide
+      subject.target_dir.join('.mnogootex.src').unlink
+      source_path.dirname.join('.mnogootexrc').unlink
+      # NOTE: unlinking so comparison is easier to write
+      expect(relative_subtree(source_path.dirname)).
+        to eq(relative_subtree(subject.target_dir))
+    end
+  end
+
+  describe '#clobber' do
+    let(:source_path) { test_dir.join('A', 'main.file') }
+
+    before do
+      test_dir.join('A', 'B').mkpath
+      test_dir.join('A', 'main.file').write('')
+    end
+
+    subject { described_class.new hid: 'job_id', source_path: source_path }
+
+    it 'cleans up target dir if it exists' do
+      subject.provide
+      expect(subject.target_dir).to exist
+      subject.clobber
+      expect(subject.target_dir).to_not exist
+    end
+
+    it 'does nothing if target dir does not exist' do
+      expect(subject.target_dir).to_not exist
+      expect { subject.clobber }.to_not raise_exception
+    end
+  end
+end

data/spec/mnogootex/job/runner_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'mnogootex/job/runner'
+
+require 'tmpdir'
+
+describe Mnogootex::Job::Runner do
+  let(:test_dir) { Pathname.new(Dir.mktmpdir) }
+  before { test_dir.mkpath }
+  after { test_dir.rmtree }
+
+  it 'executes commandline in given dir' do
+    runner = described_class.new(cmd: 'pwd', chdir: test_dir)
+    expect(runner).to be_successful
+    expect(runner.log_lines.join.chomp).to eq(test_dir.realpath.to_s)
+  end
+
+  describe '#alive?' do
+    it 'is true if thread is running' do
+      runner = described_class.new(cmd: 'sleep 0.05', chdir: test_dir)
+      expect(runner).to be_alive
+    end
+
+    it 'is false if thread is dead' do
+      runner = described_class.new(cmd: ':', chdir: test_dir)
+      sleep 0.05
+      expect(runner).to_not be_alive
+    end
+  end
+
+  describe '#successful?' do
+    it 'is true on zero exit status' do
+      runner = described_class.new(cmd: 'exit 0', chdir: test_dir)
+      expect(runner).to be_successful
+    end
+
+    it 'is false on nonzero exit status' do
+      runner = described_class.new(cmd: 'exit 1', chdir: test_dir)
+      expect(runner).to_not be_successful
+    end
+  end
+
+  describe '#count_lines' do
+    let!(:lns) { <<~SHELL }
+      lns () { i=1; while [ "$i" -le $1 ]; do echo $i; i=$(( i + 1 )); done };
+    SHELL
+
+    context 'dead process' do
+      subject { described_class.new(cmd: "#{lns} lns 3", chdir: test_dir) }
+
+      before do
+        subject.successful? # waits on threads
+      end
+
+      it 'plateaus immediately at log lines count' do
+        [3, 3].each { |n| expect(subject.count_lines).to eq(n) }
+      end
+    end
+
+    context 'alive process' do
+      subject { described_class.new(cmd: "#{lns} lns 3; sleep 0.20", chdir: test_dir) }
+
+      before do
+        subject
+        sleep 0.02
+      end
+
+      it 'unitarily increases from zero then plateaus at current line count' do
+        [0, 1, 2, 3, 3, 3].each { |n| expect(subject.count_lines).to eq(n) }
+      end
+    end
+  end
+end

data/spec/mnogootex/log/processor_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'yaml'
+
+require 'mnogootex/log/processor'
+
+describe Mnogootex::Log::Processor do
+  describe '.strings_to_lines!' do
+    it 'converts strings into lines' do
+      strings = "foo\nbar\n".lines
+
+      described_class.strings_to_lines! strings
+
+      expect(strings).to eq [
+        Mnogootex::Log::Line.new('foo'),
+        Mnogootex::Log::Line.new('bar')
+      ]
+    end
+  end
+
+  describe '.tag_lines!' do
+    it 'tags using short matchers' do
+      lines = [Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new]
+
+      matchers = [Mnogootex::Log::Matcher.new(/foo/, :foo)]
+
+      described_class.tag_lines! lines, matchers: matchers
+
+      expect(lines.map(&:level)).to eq([nil, :foo, nil])
+    end
+
+    it 'tags using long matchers' do
+      lines = [Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new,
+               Mnogootex::Log::Line.new]
+
+      matchers = [Mnogootex::Log::Matcher.new(/foo/, :foo, 3)]
+
+      described_class.tag_lines! lines, matchers: matchers
+
+      expect(lines.map(&:level)).to eq([nil, nil, :foo, :foo, :foo, nil, nil])
+    end
+
+    it 'tags abiding to matchers order' do
+      lines = [Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new('something')]
+
+      matchers = [Mnogootex::Log::Matcher.new(/foo/, :winner, 1),
+                  Mnogootex::Log::Matcher.new(/foo/, :loser, 1),
+                  Mnogootex::Log::Matcher.new(//, :anything, 1)]
+
+      described_class.tag_lines! lines, matchers: matchers
+
+      expect(lines.map(&:level)).to eq(%i[winner anything])
+    end
+  end
+
+  describe '.filter_lines!' do
+    it 'raises on line with unknown level' do
+      lines = [Mnogootex::Log::Line.new('foo', :bar)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0) }
+
+      expect do
+        described_class.filter_lines! lines,
+                                      levels: levels,
+                                      min_level: :foo
+      end.to raise_exception KeyError
+    end
+
+    it 'raises on unknown min level' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0) }
+
+      expect do
+        described_class.filter_lines! lines,
+                                      levels: levels,
+                                      min_level: :bar
+      end.to raise_exception KeyError
+    end
+
+    it 'filters tagged lines by minimum level' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo),
+               Mnogootex::Log::Line.new('bar', :bar),
+               Mnogootex::Log::Line.new('baz', :baz)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0),
+                 bar: Mnogootex::Log::Level.new(1),
+                 baz: Mnogootex::Log::Level.new(2) }
+
+      described_class.filter_lines! lines,
+                                    levels: levels,
+                                    min_level: :bar
+
+      expect(lines.map(&:text)).to eq(%w[bar baz])
+    end
+  end
+
+  describe '.colorize_lines!' do
+    it 'raises on unknown min level' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo)]
+
+      levels = { bar: Mnogootex::Log::Level.new(0) }
+
+      expect do
+        described_class.colorize_lines! lines, levels: levels
+      end.to raise_exception KeyError
+    end
+
+    it 'colorizes tagged lines' do
+      lines = [Mnogootex::Log::Line.new('foo', :foo),
+               Mnogootex::Log::Line.new('bar', :bar),
+               Mnogootex::Log::Line.new('baz', :baz)]
+
+      levels = { foo: Mnogootex::Log::Level.new(0, :foo, :red),
+                 bar: Mnogootex::Log::Level.new(1, :bar, :green),
+                 baz: Mnogootex::Log::Level.new(2, :baz, :blue) }
+
+      described_class.colorize_lines! lines, levels: levels
+
+      expect(lines.map(&:text)).to eq %W{\e[0;31;49mfoo\e[0m
+                                         \e[0;32;49mbar\e[0m
+                                         \e[0;34;49mbaz\e[0m}
+    end
+  end
+
+  describe '.render_lines!' do
+    it 'renders lines to indented terminated strings' do
+      lines = [Mnogootex::Log::Line.new('foo'),
+               Mnogootex::Log::Line.new('bar'),
+               Mnogootex::Log::Line.new('baz')]
+
+      described_class.render_lines! lines, indent_width: 2
+
+      expect(lines).to eq ["  foo\n", "  bar\n", "  baz\n"]
+    end
+  end
+
+  describe '#run' do
+    log = <<~LOG
+      This is generic irrelevant information.
+      Hey, I'm warning you, dude. Stuff is gonna get bad.
+      This is also a known irrelevant information flood...
+        ... telling you that you'd better pay attention to warnings.
+      I warned you, dude. Here's an ERROR. :(
+    LOG
+
+    levels = { trace: Mnogootex::Log::Level.new(0, :trace),
+               warning: Mnogootex::Log::Level.new(1, :warning, :yellow),
+               error: Mnogootex::Log::Level.new(2, :error, :red) }
+
+    matchers = [Mnogootex::Log::Matcher.new(/error/i, :error, 1),
+                Mnogootex::Log::Matcher.new(/warning/i, :warning, 1),
+                Mnogootex::Log::Matcher.new(/flood/, :trace, 2),
+                Mnogootex::Log::Matcher.new(//, :trace, 1)]
+
+    it 'can be initilized and run' do
+      my_processor = described_class.new matchers: matchers,
+                                         levels: levels,
+                                         min_level: :warning,
+                                         colorize: true,
+                                         indent_width: 4
+
+      expect(my_processor.run(log.lines)).to eq(
+        ["    \e[0;33;49mHey, I'm warning you, dude. Stuff is gonna get bad.\e[0m\n",
+         "    \e[0;31;49mI warned you, dude. Here's an ERROR. :(\e[0m\n"],
+      )
+    end
+
+    it 'can disable colorization' do
+      my_processor = described_class.new matchers: matchers,
+                                         levels: levels,
+                                         min_level: :warning,
+                                         colorize: false,
+                                         indent_width: 4
+
+      expect(my_processor.run(log.lines)).to eq(
+        ["    Hey, I'm warning you, dude. Stuff is gonna get bad.\n",
+         "    I warned you, dude. Here's an ERROR. :(\n"],
+      )
+    end
+
+    it 'does not mutate given lines' do
+      my_processor = described_class.new matchers: matchers,
+                                         levels: levels,
+                                         min_level: :warning,
+                                         colorize: true,
+                                         indent_width: 4
+
+      log_lines = log.lines
+      expect { my_processor.run(log_lines) }.to_not(change { log_lines })
+    end
+  end
+end

data/spec/mnogootex/utils_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'tmpdir'
+
+require 'mnogootex/utils'
+
+describe Mnogootex::Utils do
+  describe '.short_md5' do
+    it 'gives expected hash for empty string' do
+      expect(described_class.short_md5('')).to eq('1B2M2Y8AsgTpgAmY7PhCfg')
+    end
+
+    it 'gives an url/path-safe hash' do
+      expect(described_class.short_md5('Knuth')).to eq('KyIs0ZIec5GkG7_G-clv6Q')
+    end
+  end
+
+  describe '.humanize_bytes' do
+    it 'rounds to smaller unit' do
+      expect(described_class.humanize_bytes(1023 * 1024)).to eq('1023Kb')
+      expect(described_class.humanize_bytes(1024 * 1024)).to eq('1Mb')
+      expect(described_class.humanize_bytes(1025 * 1024)).to eq('1Mb')
+    end
+
+    it 'covers a reasonable scale' do
+      %w[b Kb Mb Gb Tb Pb Eb Zb Yb].each_with_index do |unit, index|
+        expect(described_class.humanize_bytes((2**10)**index)).to eq("1#{unit}")
+      end
+    end
+  end
+
+  describe '.dir_size' do
+    let(:tmpdir) { Pathname.new(Dir.mktmpdir) }
+    before { tmpdir.mkpath }
+    after { tmpdir.rmtree }
+
+    it 'measures an empty dir' do
+      expect(described_class.dir_size(tmpdir)).to eq(0)
+    end
+
+    it 'measures a subtree' do
+      tmpdir.join('foo').write('foo' * 100)
+      tmpdir.join('bar').write('bar' * 200)
+      tmpdir.join('baz').mkpath
+      tmpdir.join('baz', 'qux').write('qux' * 300)
+      # NOTE: dir size is fs dependent, so let's not care about that
+      expect(described_class.dir_size(tmpdir.to_s)).to eq(300 + 600 + tmpdir.join('baz').size + 900)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'timeout'
+
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+
+  SimpleCov.configure do
+    track_files 'lib/**/*.rb'
+    add_filter '/spec/'
+  end
+
+  # SimpleCov.at_exit do
+  #   SimpleCov.result.format!
+  #   puts "#{SimpleCov.result.covered_percent.floor}%"
+  # end
+
+  SimpleCov.start
+end
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.fail_fast = true
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+  #   # This allows you to limit a spec run to individual examples or groups
+  #   # you care about by tagging them with `:focus` metadata. When nothing
+  #   # is tagged with `:focus`, all examples get run. RSpec also provides
+  #   # aliases for `it`, `describe`, and `context` that include `:focus`
+  #   # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+  #
+  #   # Allows RSpec to persist some state between runs in order to support
+  #   # the `--only-failures` and `--next-failure` CLI options. We recommend
+  #   # you configure your source control system to ignore this file.
+  #   config.example_status_persistence_file_path = "spec/examples.txt"
+  #
+  #   # Limits the available syntax to the non-monkey patched syntax that is
+  #   # recommended. For more details, see:
+  #   #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  #   config.disable_monkey_patching!
+  #
+  #   # This setting enables warnings. It's recommended, but in some cases may
+  #   # be too noisy due to issues in dependencies.
+  #   config.warnings = true
+  #
+  #   # Many RSpec users commonly either run the entire suite or an individual
+  #   # file, and it's useful to allow more verbose output when running an
+  #   # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+  #
+  #   # Print the 10 slowest examples and example groups at the
+  #   # end of the spec run, to help surface which specs are running
+  #   # particularly slow.
+  #   config.profile_examples = 10
+  #
+  #   # Run specs in random order to surface order dependencies. If you find an
+  #   # order dependency and want to debug it, you can fix the order by providing
+  #   # the seed, which is printed after each run.
+  #   #     --seed 1234
+  config.order = :random
+  #
+  #   # Seed global randomization in this process using the `--seed` CLI option.
+  #   # Setting this allows you to use `--seed` to deterministically reproduce
+  #   # test failures related to randomization by passing the same `--seed` value
+  #   # as the one that triggered the failure.
+  #   Kernel.srand config.seed
+
+  # # Timeout to help mutant
+  # config.around(:each) do |example|
+  #   Timeout.timeout(0.1, &example)
+  # end
+end