fixman 0.1.0

data/lib/fixman/task.rb

@@ -0,0 +1,19 @@
+module Fixman
+  class Task
+    attr_reader :name, :condition
+
+    def initialize(name, condition, command, cleanup)
+      @name = name
+      @condition = condition
+      @command = command
+      @cleanup = cleanup
+    end
+
+    def run target
+      success = @command.call(target)
+      @cleanup.call(target)
+
+      success
+    end
+  end
+end

data/lib/fixman/task_parse_error.rb

@@ -0,0 +1,12 @@
+module Fixman
+  class TaskParseError < Exception
+    def initialize message, task_index
+      @message = message
+      @task_index = task_index
+    end
+
+    def message
+      "Task##{@task_index + 1}: #{@message}"
+    end
+  end
+end

data/lib/fixman/tester.rb

@@ -0,0 +1,69 @@
+require 'English'
+require 'stringio'
+
+module Fixman
+  class Tester
+    TERMINAL_WIDTH = 80
+
+    def initialize(configuration)
+      @conf = configuration
+      @target_cache = {}
+    end
+
+    def test
+      @conf.raw_tasks.each do |raw_task|
+        raw_task.refine.each do |task|
+          puts(test_task task)
+        end
+      end
+    end
+
+    private
+
+    def test_task task
+      puts "Collecting targets for #{task.name}..."
+      targets = collect task.condition
+      failures = []
+      puts "Running the #{task.name} on targets..."
+      targets.each do |target|
+        failures << target unless task.run target
+      end
+      report task.name, targets, failures
+    end
+
+    def collect(condition)
+      if @target_cache[condition]
+        @target_cache[condition]
+      else
+        targets = []
+        places_to_search = [@conf.fixtures_base]
+        places_to_search.each do |place|
+          # exclude symbolic links to avoid cycles
+          place.each_child do |child|
+            next if child.symlink?
+            targets << child if condition.call(child)
+            places_to_search << child if child.directory?
+          end
+        end
+        @target_cache[condition] = targets
+      end
+    end
+
+    def report(name, targets, failures)
+      n_of_targets = targets.size
+      n_of_successes = n_of_targets - failures.size
+
+      sio = StringIO.new
+      sio.puts "#{name} (#{n_of_successes}/#{n_of_targets})"
+      sio.puts '-' * TERMINAL_WIDTH
+      if n_of_successes == n_of_targets
+        sio.puts 'All targets ran as expected.'
+      else
+        sio.puts "Failing targets:"
+        sio.puts failures.sort
+      end
+      sio.puts
+      sio.string
+    end
+  end
+end

data/lib/fixman/utilities.rb

@@ -0,0 +1,8 @@
+module Fixman
+  module Utilities
+    def error message, exit_code = 1
+      STDERR.puts message
+      exit exit_code
+    end
+  end
+end

data/test/test_command_line.rb

@@ -0,0 +1,250 @@
+require 'fixman'
+require 'minitest'
+
+class TestCommandLine < Minitest::Test
+  extend Fixman::CommandLine
+
+  @@desired_input_index = 0
+
+  def test_parse_normal_options
+    options = TestCommandLine.parse_options! ['-c', 'my_conf.yaml']
+    assert_equal Pathname.new('my_conf.yaml'), options[:conf_path]
+
+    options = TestCommandLine.parse_options! []
+    assert_equal Pathname.new(Fixman::Configuration::DEFAULT_CONF_FILE),
+                 options[:conf_path]
+  end
+
+  def test_parse_option_leaves_positional
+    args = %w(hey -c mey yey -c key)
+    TestCommandLine.parse_options! args
+    assert_equal %w(hey yey), args
+
+    args = %w(hey)
+    TestCommandLine.parse_options! args
+    assert_equal %w(hey), args
+  end
+
+  def test_parse_normal_potisional
+    args = %w(add)
+    command, other_args = TestCommandLine.parse_positional_arguments!(args)
+    assert_equal [], args
+    assert_equal :add, command
+    assert_equal({}, other_args)
+
+    args = %w(update user/name)
+    command, other_args = TestCommandLine.parse_positional_arguments!(args)
+    assert_equal [], args
+    assert_equal :update, command
+    assert_equal({canonical_name: 'user/name', sha: nil}, other_args)
+
+    args = %w(uPdaTe uSEr/name someSHA)
+    command, other_args = TestCommandLine.parse_positional_arguments!(args)
+    assert_equal [], args
+    assert_equal :update, command
+    assert_equal({canonical_name: 'uSEr/name', sha: 'someSHA'}, other_args)
+
+    args = %w(fetch groupA groupB groupC)
+    command, other_args = TestCommandLine.parse_positional_arguments!(args)
+    assert_equal [], args
+    assert_equal :fetch, command
+    assert_equal({groups: [:groupa, :groupb, :groupc]}, other_args)
+  end
+
+  def test_start_session_optional
+    input = {}
+    template = { symbol: :test, prompt: 'Test prompt', label: '', type: :optional }
+    change_get_input "test value" do
+      assert_output(template[:prompt]) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input = { test: 'test value' }
+    assert_equal(expected_input, input)
+
+    template = { symbol: :test2, prompt: 'Another prompt', label: ''}
+    change_get_input "test value2" do
+      assert_output(template[:prompt]) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input[:test2] = 'test value2'
+    assert_equal(expected_input, input)
+  end
+
+  def test_start_session_mandatory
+    input = {}
+    template = {
+      symbol: :test,
+      prompt: 'Test prompt',
+      label: '',
+      type: :mandatory
+    }
+    change_get_input "TEST value" do
+      assert_output(template[:prompt]) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input = { test: 'TEST value' }
+    assert_equal(expected_input, input)
+
+    input = {}
+    change_get_input ['  ', '', 'TEST value'] do
+      assert_output(template[:prompt] * 3) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input = { test: 'TEST value' }
+    assert_equal(expected_input, input)
+  end
+
+  def test_start_session_single_choice
+    input = {}
+    template = {
+      symbol: :test,
+      prompt: 'Test prompt',
+      label: '',
+      type: :single_choice,
+      choices: %w(1 2 3 4)
+    }
+    change_get_input "2" do
+      assert_output(%r|1/2/3|) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input = { test: '2' }
+    assert_equal(expected_input, input)
+
+    input = {}
+    change_get_input ['  ', '5', '3'] do
+      assert_output(%r|1/2/3/4.*1/2/3/4|m) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input = { test: '3' }
+    assert_equal(expected_input, input)
+  end
+
+  def test_start_session_multiple_choice
+    input = {}
+    template = {
+      symbol: :test,
+      prompt: 'Test prompt',
+      label: '',
+      type: :multiple_choice,
+      choices: %w(RUby pytHOn elixir)
+    }
+    change_get_input "pytHOn" do
+      assert_output(%r|RUby/pytHOn/elixir|) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input = { test: ['pytHOn'] }
+    assert_equal(expected_input, input)
+
+    input = {}
+    change_get_input ['  ', '5,RUby', 'elixir,pytHOn'] do
+      assert_output(%r|RUby.*RUby|m) do
+        TestCommandLine.send(:start_session, input, template)
+      end
+    end
+    expected_input = { test: ['elixir', 'pytHOn'] }
+    assert_equal(expected_input, input)
+  end
+
+  def test_get_params
+    extra_templates = [
+      { 
+        symbol: :notes, 
+        prompt: 'Notes', 
+        label: 'Notes', 
+        type: :optional 
+      },
+      { 
+        symbol: :licence, 
+        prompt: 'Licence', 
+        label: 'Licence', 
+        type: :single_choice, 
+        choices: ['MIT', 'Apache'] 
+      }
+    ]
+
+    inputs = [
+      'https://github.com/madgen/fixman', 
+      'a , b, c',
+      'It is good to take notes',
+      'apache'
+    ]
+    params = []
+    expected_sha = 'fake SHA'
+    assert_output(/URL.*Notes.*Licence.*Apache/m) do
+      params = 
+      change_get_input inputs do
+        Fixman::Repository.stub(:retrieve_head_sha, expected_sha) do 
+          TestCommandLine.get_params extra_templates, %w(d a e b c)
+        end
+      end
+    end
+
+    assert_equal 'fixman', params[:name]
+    assert_equal 'madgen', params[:owner]
+    assert_equal inputs[0], params[:url]
+    assert_equal %w(a b c), params[:groups]
+    assert_equal inputs[2], params[:notes]
+    assert_equal 'Apache', params[:licence]
+    assert_equal expected_sha, params[:sha]
+
+    inputs = [
+      'https://bithub.com/madgen/fixman',
+      'fixman',
+      'madgen',
+      'a',
+      'It is good to take notes',
+      'mit'
+    ]
+    assert_output(/URL.*Notes.*Licence.*Apache/m) do
+      params = 
+      change_get_input inputs do
+        Fixman::Repository.stub(:retrieve_head_sha, expected_sha) do 
+          TestCommandLine.get_params extra_templates, %w(d a e b c)
+        end
+      end
+    end
+
+    assert_equal inputs[0], params[:url]
+    assert_equal inputs[1], params[:name]
+    assert_equal inputs[2], params[:owner]
+    assert_equal ['a'], params[:groups]
+    assert_equal inputs[4], params[:notes]
+    assert_equal 'MIT', params[:licence]
+    assert_equal expected_sha, params[:sha]
+  end
+
+  private
+
+  def change_get_input(desired_input)
+    TestCommandLine.instance_eval { undef :get_input }
+    TestCommandLine.define_singleton_method :get_input do
+      result =
+      if desired_input.is_a? String
+        desired_input
+      elsif desired_input.is_a? Array
+        desired_input[@@desired_input_index]
+      end
+      @@desired_input_index += 1
+      result
+    end
+
+    result = yield
+
+    TestCommandLine.instance_eval do
+      undef :get_input
+      @@desired_input_index = 0
+    end
+    TestCommandLine.define_singleton_method :get_input do
+      gets.chomp
+    end
+
+    result
+  end
+end

data/test/test_configuration.rb

@@ -0,0 +1,58 @@
+require 'fixman'
+require 'minitest'
+require 'classy_hash'
+
+class TestConfiguration < Minitest::Test
+  def test_validate_minimal_conf
+    conf_params = {
+      fixtures_base: 'hello',
+      tasks: [
+        {
+          name: 'test_task',
+          command: {
+            action: 'wc',
+          }
+        }
+      ],
+    }
+
+    assert_nil CH.validate(conf_params, Fixman::Configuration::CONF_SCHEMA)
+  end
+
+  def test_condition_schema_validation
+    schema = { condition: Fixman::Configuration::CONDITION_OR_CLEANUP_SCHEMA }
+
+    valid = {
+      condition: {
+        type: :ruby,
+        action: 'proc {}'
+      }
+    }
+    cond = valid[:condition]
+    assert_nil(CH.validate valid, schema)
+
+    cond[:type] = :shell
+    cond[:action] = 'wc'
+    assert_nil(CH.validate valid, schema)
+
+    cond.delete :type
+    assert_raises(RuntimeError) { CH.validate valid, schema }
+
+    cond[:type] = :something_else
+    assert_raises(RuntimeError) { CH.validate valid, schema }
+
+    cond[:type] = :ruby
+    cond[:action] = 'not a proc'
+    assert_raises(RuntimeError) { CH.validate valid, schema }
+
+    cond[:type] = :ruby
+    cond[:action] = 'proc {}'
+    cond[:exit_status] = 300
+    assert_nil CH.validate valid, schema
+
+    cond[:type] = :shell
+    cond[:action] = 'wc'
+    cond[:exit_status] = 300
+    assert_raises(RuntimeError) { CH.validate valid, schema }
+  end
+end

data/test/test_controller.rb

@@ -0,0 +1,16 @@
+require 'fixman'
+require 'minitest'
+require 'minitest/mock'
+
+class TestController < Minitest::Test
+
+  def test_write_ledger
+    original_ledger = ""
+    repos = Minitest::Mock.new.expect(:map, ['abc','def'])
+    Tempfile.open 'location' do |t|
+      Fixman::Controller.send :write_ledger, repos, original_ledger, t.path
+      t.rewind
+      assert_equal "---\n- abc\n- def\n", t.read
+    end
+  end
+end

data/test/test_fixman.rb

@@ -0,0 +1,7 @@
+require 'test_configuration'
+require 'test_command_line'
+require 'test_controller'
+require 'test_raw_task'
+require 'test_repository'
+require 'test_task'
+require 'test_tester'