scripted 0.0.1

data/scripted.rb

@@ -0,0 +1,16 @@
+formatter "default"
+formatter "table"
+formatter "announcer"
+
+parallel do
+
+  run "rspec" do
+    `rspec -f Fivemat`
+  end
+
+  `cucumber`
+
+end
+
+# because cucumber accesses the file system, it cannot run two at the same time
+`cucumber -p wip`

data/spec/scripted/command_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Scripted::Command do
+
+  let(:command) { Scripted::Command.new("foo") }
+
+  it "has a name" do
+    expect(command.name).to eq "foo"
+  end
+
+  it "uses the name as shell function if no other command was specified" do
+    expect(command.executable).to be_a Scripted::Commands::Shell
+  end
+
+  specify "the sh method overrides the command to be run" do
+    command.define do
+      sh "bar"
+    end
+    expect(command.executable).to be_a Scripted::Commands::Shell
+  end
+
+  specify "the backtics also do a shell command" do
+    command.define do
+      `bar`
+    end
+    expect(command.executable).to be_a Scripted::Commands::Shell
+  end
+
+  specify "the rake method overrides the command to be run" do
+    command.define do
+      rake "db:migrate"
+    end
+    expect(command.executable).to be_a Scripted::Commands::Rake
+  end
+
+  specify "the ruby method stores a block" do
+    command.define do
+      ruby { 1 + 1 }
+    end
+    expect(command.executable).to be_a Scripted::Commands::Ruby
+  end
+
+  it "can be important" do
+    expect(command).not_to be_important
+    command.important!
+    expect(command).to be_important
+  end
+
+  it "can be unimportant" do
+    expect(command).not_to be_unimportant
+    command.unimportant!
+    expect(command).to be_unimportant
+  end
+
+  it "can be forced" do
+    expect(command).not_to be_forced
+    command.forced!
+    expect(command).to be_forced
+  end
+
+  it "can be only when failed" do
+    expect(command).not_to be_only_when_failed
+    command.only_when_failed!
+    expect(command).to be_only_when_failed
+  end
+
+  it "can be parallel" do
+    command = Scripted::Command.new("true", :parallel_id => 10)
+    expect(command.parallel_id).to eq 10
+  end
+
+end

data/spec/scripted/commands/ruby_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Scripted::Commands::Ruby do
+
+  it "evaluates a block" do
+    ruby = Scripted::Commands::Ruby.new(lambda { 1 })
+    expect(ruby.execute!).to eq 1
+  end
+
+end

data/spec/scripted/commands/shell_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Scripted::Commands::Shell do
+
+  it "executes a shell command" do
+    shell = Scripted::Commands::Shell.new("echo this is a test in capturing output")
+    r = with_io do |io|
+      shell.execute!(io)
+    end
+    expect(r.strip).to eq "this is a test in capturing output"
+  end
+
+  it "can fail" do
+    shell = Scripted::Commands::Shell.new("false")
+    expect{shell.execute!}.to raise_error Scripted::CommandFailed
+  end
+
+end

data/spec/scripted/configuration_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Scripted::Configuration do
+
+  it "can define groups" do
+    subject.group :foo
+    subject.group :bar
+    expect(subject).to have(2).groups
+  end
+
+  it "defines commands on the default group" do
+    subject.run "foo"
+    expect(subject).to have(1).groups
+  end
+
+  it "handles non existing files" do
+    subject.config_file "non-existing.rb"
+    expect { subject.load_files }.to raise_error Scripted::ConfigFileNotFound
+  end
+
+  it "adds the default file on demand" do
+    expect {
+      subject.with_default_config_file!
+    }.to change { subject.config_files }.to ["scripted.rb"]
+  end
+
+  it "does not allow setting out without a formatter" do
+    expect { subject.out "foo" }.to raise_error Scripted::NoFormatterForOutput
+  end
+
+  it "changes the last formatter to use a different output" do
+    subject.formatter :table, :out => "old.log"
+    expect { subject.out "new.log" }.to change { subject.formatters.first[:out] }.to "new.log"
+  end
+
+  it "can set multple formatter" do
+    subject.formatter :table, :out => "old.log"
+    subject.formatter :websocket
+    expect(subject).to have(2).formatters
+  end
+
+  it "reraises all configuration errors so they are easily rescued" do
+    expect {
+      subject.evaluate do
+        fooasdad
+      end
+    }.to raise_error Scripted::ConfigurationSyntaxError
+  end
+
+end

data/spec/scripted/formatters/websocket_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'scripted/formatters/websocket'
+
+describe Scripted::Formatters::Websocket do
+
+  it "uses websocket" do
+    pending "this test just puts the output for the moment"
+    command = Scripted::Commands::Shell.new(%~ruby -e "20.times { |i| print i; sleep 0.1 }"~)
+    Scripted::Formatters::Websocket.new("ws://....") do |log|
+      command.execute!(log)
+    end
+  end
+
+end

data/spec/scripted/group_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Scripted::Group do
+
+  let(:group) { Scripted::Group.new("foo") }
+
+  it "has a name" do
+    expect(group.name).to eq "foo"
+  end
+
+  it "defines commands" do
+    group.define do
+      run "echo 1"
+    end
+    expect(group.commands.first.name).to eq "echo 1"
+  end
+
+  it "can define multiple parallel blocks" do
+    command1 = command2 = command3 = command4 = nil
+
+    group.define do
+      parallel do
+        run("one") { command1 = self }
+        run("two") { command2 = self }
+      end
+      parallel do
+        run("three") { command3 = self }
+      end
+      run("four") { command4 = self }
+    end
+
+    expect(command1).to be_run_in_parallel_with(command2)
+    expect(command2).to be_run_in_parallel_with(command1)
+
+    expect(command3).not_to be_run_in_parallel_with(command1)
+    expect(command3).not_to be_run_in_parallel_with(command2)
+
+    expect(command1).not_to be_run_in_parallel_with(command3)
+    expect(command2).not_to be_run_in_parallel_with(command3)
+
+    expect(command4).not_to be_run_in_parallel_with(command1)
+    expect(command4).not_to be_run_in_parallel_with(command2)
+    expect(command4).not_to be_run_in_parallel_with(command3)
+    expect(command1).not_to be_run_in_parallel_with(command4)
+    expect(command2).not_to be_run_in_parallel_with(command4)
+    expect(command3).not_to be_run_in_parallel_with(command4)
+  end
+
+end

data/spec/scripted/running/run_command_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Scripted::Running::RunCommand do
+
+  let(:command)  { stub(:command, :unimportant? => false, :forced? => false, :important? => false, :only_when_failed? => false) }
+  let(:delegate) { mock :stub, :done => true, :halt! => true }
+  subject(:run_command) { Scripted::Running::RunCommand.new(command, logger) }
+  let(:logger) { mock(:logger).as_null_object }
+
+  def run
+    run_command.execute!(delegate)
+  end
+
+  context "when a command runs successfully" do
+
+    before do
+      Scripted::Running::Execute.stub :call do |command, delegate|
+        delegate.success!
+      end
+    end
+
+    it "notifies the delegate" do
+      expect(delegate).to receive(:done).once.with(run_command)
+      expect(delegate).to receive(:halt!).never
+      run
+    end
+
+    it "should be successful" do
+      run
+      expect(run_command).to be_success
+    end
+
+    it "should have executed" do
+      run
+      expect(run_command).to be_executed
+    end
+
+    it "should not be running" do
+      run
+      expect(run_command).not_to be_running
+    end
+
+    it "should not have halted" do
+      run
+      expect(run_command).not_to be_halted
+    end
+
+    it "should not have failed" do
+      run
+      expect(run_command).not_to be_failed
+    end
+
+    it "should have no exception" do
+      run
+      expect(run_command).not_to be_nil
+    end
+
+    it "should not be failed but unimportant" do
+      run
+      expect(run_command).not_to be_failed_but_unimportant
+    end
+
+  end
+
+  context "when a normal command fails" do
+
+    before do
+      Scripted::Running::Execute.stub :call do |command, delegate|
+        delegate.failed!(exception)
+      end
+    end
+
+    let(:exception) { RuntimeError.new("OH NOES") }
+
+    it "notifies the delegate" do
+      expect(delegate).to receive(:done).with(run_command)
+      run
+    end
+
+    it "should not be successful" do
+      run
+      expect(run_command).not_to be_success
+    end
+
+    it "should have executed" do
+      run
+      expect(run_command).to be_executed
+    end
+
+    it "should not be running" do
+      run
+      expect(run_command).not_to be_running
+    end
+
+    it "should have failed" do
+      run
+      expect(run_command).to be_failed
+    end
+
+    it "should not have halted" do
+      run
+      expect(run_command).not_to be_halted
+    end
+
+    it "should have a exception" do
+      run
+      expect(run_command).not_to be exception
+    end
+
+    it "should not be failed but unimportant" do
+      run
+      expect(run_command).not_to be_failed_but_unimportant
+    end
+
+    context "when the command is important" do
+
+      before do
+        command.stub(:important?).and_return(true)
+      end
+
+      it "should tell the delegate to halt" do
+        expect(delegate).to receive(:halt!)
+        run
+      end
+
+      it "should be halted" do
+        run
+        expect(run_command).to be_halted
+      end
+
+    end
+
+    context "when the command is unimportant" do
+
+      before do
+        command.stub(:unimportant?).and_return(true)
+      end
+
+      it "should be unimportant" do
+        expect(run_command).to be_unimportant
+      end
+
+      it "should not be failed" do
+        run
+        expect(run_command).not_to be_failed
+      end
+
+      it "should be failed but important" do
+        run
+        expect(run_command).to be_failed_but_unimportant
+      end
+
+    end
+
+  end
+
+end

data/spec/scripted/running/run_commands_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Scripted::Running::RunCommands do
+
+  let(:run_commands) { Scripted::Running::RunCommands.new(logger) }
+  let(:logger) { mock(:logger).as_null_object }
+
+  def parallel_id
+    @parallel_id ||= 0
+    @parallel_id += 1
+    @parallel_id
+  end
+
+  def run_command(options = {})
+    command = OpenStruct.new({:parallel_id => parallel_id}.merge(options))
+    Scripted::Running::RunCommand.new(command, logger)
+  end
+
+  before do
+    Scripted::Running::Execute.stub(:call) do |command, delegate|
+      if command.failed?
+        delegate.failed!(RuntimeError.new)
+      else
+        delegate.success!
+      end
+    end
+  end
+
+  context "with normal commands" do
+
+    it "executes them all" do
+
+      command1 = run_command
+      command2 = run_command
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).to be_executed
+
+      expect(run_commands).not_to be_failed
+
+    end
+
+    it "executes them all, even if one failed" do
+
+      command1 = run_command(:failed? => true)
+      command2 = run_command
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).to be_executed
+
+      expect(run_commands).to be_failed
+
+    end
+
+  end
+
+  context "with important commands" do
+
+    it "stops executing when an important command failed" do
+
+      command1 = run_command(:failed? => true, :important? => true)
+      command2 = run_command
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).not_to be_executed
+
+      expect(run_commands).to be_failed
+
+    end
+
+    it "still executes a forced command when an important command failed" do
+
+      command1 = run_command(:failed? => true, :important? => true)
+      command2 = run_command(:forced? => true)
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).to be_executed
+
+      expect(run_commands).to be_failed
+
+    end
+
+  end
+
+  context "with unimportant commands" do
+
+    it "is still successful when unimportant command fails" do
+      command1 = run_command(:failed? => true, :unimportant? => true)
+      command2 = run_command
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).to be_executed
+
+      expect(run_commands).not_to be_failed
+    end
+
+  end
+
+  context "with only_when_failed commands" do
+
+    it "doesn't execute only_when_failed-commands when nothing fails" do
+      command1 = run_command
+      command2 = run_command(:only_when_failed? => true)
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).not_to be_executed
+
+      expect(run_commands).not_to be_failed
+    end
+
+    it "executes only_when_failed-commands when another command failed" do
+      command1 = run_command(:failed? => true)
+      command2 = run_command(:only_when_failed? => true)
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).to be_executed
+
+      expect(run_commands).to be_failed
+    end
+
+    it "executes only_when_failed-commands when another command halted" do
+      command1 = run_command(:important? => true, :failed? => true)
+      command2 = run_command(:only_when_failed? => true)
+
+      run_commands.run [ command1, command2 ]
+
+      expect(command1).to be_executed
+      expect(command2).to be_executed
+
+      expect(run_commands).to be_failed
+    end
+
+  end
+
+end