singularity_dsl 1.2.5

data/spec/singularity_dsl/dsl/batch_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/batch'
+
+# dummy class to use for block contexts
+class TestObject
+  def meth
+  end
+end
+
+describe 'Batch' do
+  context '#initialize' do
+    it 'converts name to symbol' do
+      batch = SingularityDsl::Dsl::Batch.new('test', self)
+      expect(batch.name).to eql(:test)
+    end
+  end
+
+  context '#execute' do
+    it 'executes block in passed context' do
+      dummy = TestObject.new
+      dummy.stub(:meth)
+      batch = SingularityDsl::Dsl::Batch.new('test', dummy) do |thing|
+        thing.meth
+      end
+      expect(dummy).to receive(:meth)
+      batch.execute
+    end
+  end
+end

data/spec/singularity_dsl/dsl/changeset_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/changeset'
+
+# container to include DslChangeset
+class ChangesetTest
+  include SingularityDsl::Dsl::Changeset
+end
+
+describe 'DslChangeset' do
+  let(:instance) { ChangesetTest.new }
+  before :each do
+    instance.changeset = %w(something.php something.js something.css)
+  end
+
+  context '#files_changed?' do
+    it 'correct eval for single file type' do
+      expect(instance.files_changed? 'php').to eql true
+    end
+
+    it 'correct eval for multiple file types' do
+      expect(instance.files_changed? %w(js css)).to eql true
+    end
+  end
+
+  context '#changed_files' do
+    before :each do
+      ::File.stub(:exist?)
+            .with('something.css')
+            .and_return(true)
+      ::File.stub(:exist?)
+            .with('something.js')
+            .and_return(true)
+      ::File.stub(:exist?)
+            .with('something.php')
+            .and_return(false)
+    end
+
+    it 'correct eval for single file type' do
+      expect(instance.changed_files 'css').to eql %w(something.css)
+    end
+
+    it 'correct eval for multiple file types' do
+      expect(instance.changed_files %w(js css))
+        .to eql %w(something.css something.js)
+    end
+
+    it 'filters for existing files' do
+      expect(instance.changed_files %w(php js css))
+        .to eql %w(something.css something.js)
+      expect(instance.changed_files 'php').to eql []
+    end
+  end
+end

data/spec/singularity_dsl/dsl/dsl_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/dsl'
+require 'singularity_dsl/dsl/registry'
+require 'singularity_dsl/task'
+
+class TestTask < SingularityDsl::Task
+end
+
+describe 'Dsl' do
+  let(:dsl) { SingularityDsl::Dsl::Dsl.new }
+
+  context '#initialize' do
+    it 'creates registry' do
+      expect(dsl.registry).to be_a_kind_of SingularityDsl::Dsl::Registry
+    end
+  end
+
+  context '#define_task' do
+    it 'creates task function for given task' do
+      dsl.define_task TestTask
+      expect(dsl.singleton_methods).to include :testtask
+    end
+
+    it 'throws when tasks have the same name' do
+      dsl.define_task TestTask
+      expect { dsl.define_task TestTask }
+        .to raise_error RuntimeError, /task name clash/
+    end
+  end
+
+  context '#load_tasks_in_path' do
+    it 'does not load tasks that have already been required' do
+      path = ::File.dirname(__FILE__) + '/../../lib/singularity_dsl/tasks'
+      expect(dsl).to receive(:load_tasks).with []
+      dsl.load_tasks_in_path path
+    end
+
+    it 'actually loads new tasks from dir' do
+      path = ::File.dirname(__FILE__) + '/stubs/tasks'
+      dsl.load_tasks_in_path path
+      expect(dsl.singleton_methods).to include :dummytask
+    end
+  end
+end

data/spec/singularity_dsl/dsl/event_store_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/event_store'
+
+# container to include DslEventStore
+class EventStoreTest
+  include SingularityDsl::Dsl::EventStore
+end
+
+describe 'DslEventStore' do
+  let(:instance) { EventStoreTest.new }
+
+  context '#on_error' do
+    it 'creates an error_proc' do
+      expect(instance.error_proc).to be_a_kind_of Proc
+      instance.on_error {}
+      expect(instance.error_proc).to be_a_kind_of Proc
+    end
+  end
+
+  context '#on_fail' do
+    it 'creates an fail_proc' do
+      expect(instance.fail_proc).to be_a_kind_of Proc
+      instance.on_fail {}
+      expect(instance.fail_proc).to be_a_kind_of Proc
+    end
+  end
+
+  context '#on_success' do
+    it 'creates an error_proc' do
+      expect(instance.success_proc).to be_a_kind_of Proc
+      instance.on_success {}
+      expect(instance.success_proc).to be_a_kind_of Proc
+    end
+  end
+
+  context '#always' do
+    it 'creates an error_proc' do
+      expect(instance.always_proc).to be_a_kind_of Proc
+      instance.always {}
+      expect(instance.always_proc).to be_a_kind_of Proc
+    end
+  end
+end

data/spec/singularity_dsl/dsl/registry_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/registry'
+require 'singularity_dsl/task'
+
+class TestTask < SingularityDsl::Task
+end
+
+describe 'DslRegistry' do
+  before :each do
+    @instance = SingularityDsl::Dsl::Registry.new
+  end
+
+  context '#initialize' do
+    it 'creates empty task_list array' do
+      expect(@instance.run_list).to be_kind_of Array
+      expect(@instance.run_list).to be_empty
+    end
+  end
+
+  context '#add_task' do
+    it 'adds tasks' do
+      task = TestTask.new
+      @instance.add_task task
+      expect(@instance.run_list).to_not be_empty
+      expect(@instance.run_list).to eql [task]
+    end
+
+    it 'fails when non-task is given' do
+      expect { @instance.add_task 'fail' }
+        .to raise_error ::RuntimeError, /Non-Task given - /
+    end
+
+    it 'fails when raw task is given' do
+      expect { @instance.add_task SingularityDsl::Task.new }
+        .to raise_error ::RuntimeError, /Cannot use raw Task objects - /
+    end
+  end
+end

data/spec/singularity_dsl/dsl/runner_spec.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/dsl'
+require 'singularity_dsl/dsl/runner'
+require 'singularity_dsl/runstate'
+require 'singularity_dsl/task'
+
+describe 'DslRunner' do
+  let(:runner) { SingularityDsl::Dsl::Runner.new }
+
+  context '#initialize' do
+    it 'creates base state' do
+      expect(runner.state).to be_kind_of SingularityDsl::Runstate
+    end
+
+    it 'creates base DSL' do
+      expect(runner.dsl).to be_kind_of SingularityDsl::Dsl::Dsl
+    end
+  end
+
+  context '#execute' do
+    it 'taps & evaluates failed task.execute statuses correctly' do
+      task = SingularityDsl::Task.new
+      task.stub(:execute).and_return true
+      runner.dsl.registry.stub(:run_list).and_return [task]
+      expect(runner).to receive(:record_failure).with task
+      expect(runner).to receive(:resource_fail).with task
+      runner.execute
+    end
+  end
+
+  context '#load_ex_script' do
+    it 'instance_evals contents of a file' do
+      ::File.stub(:read).and_return('0')
+      expect(runner.dsl).to receive(:instance_eval).with('0')
+      runner.load_ex_script 'foo'
+    end
+  end
+end

data/spec/singularity_dsl/dsl/stubs/tasks/dummy_task.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+class DummyTask < Task
+end

data/spec/singularity_dsl/dsl/utils_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'singularity_dsl/dsl/utils'
+
+class TestTask < SingularityDsl::Task
+end
+
+describe 'Utils' do
+  include SingularityDsl::Dsl::Utils
+
+  context '#task_name' do
+    it 'simplifies class names correctly' do
+      expect(task_name 'Foo::Bar::Blah').to eql 'Blah'
+    end
+  end
+
+  context '#task' do
+    it 'returns lowercase sym representing DSL fx' do
+      expect(task TestTask).to eql :testtask
+    end
+  end
+
+  context '#task_list' do
+    it 'returns array of tasks' do
+      tasks = task_list
+      expect(tasks).to be_a_kind_of Array
+      expect(tasks).to_not be_empty
+      tasks.each do |task|
+        expect(task <= SingularityDsl::Task).to eql true
+      end
+    end
+  end
+end

data/spec/singularity_dsl/git_helper_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'singularity_dsl/git_helper'
+
+describe 'GitHelper' do
+  before :each do
+    SingularityDsl::GitHelper
+      .any_instance
+      .stub(:git_installed)
+      .and_return true
+  end
+  let(:git) { SingularityDsl::GitHelper.new }
+
+  context '#initialize' do
+    it 'throws if git is not installed' do
+      SingularityDsl::GitHelper
+        .any_instance
+        .stub(:git_installed)
+        .and_return false
+      expect { SingularityDsl::GitHelper.new }
+        .to(raise_error ArgumentError, /git not installed/)
+    end
+  end
+
+  context '#clean_reset' do
+    it 'fails when reset fails' do
+      git.stub(:reset).and_return 1
+      git.stub(:clean).and_return 0
+      expect { git.clean_reset }
+        .to(raise_error RuntimeError, /failed to clean/)
+    end
+
+    it 'fails when clean fails' do
+      git.stub(:reset).and_return 0
+      git.stub(:clean).and_return 1
+      expect { git.clean_reset }
+        .to(raise_error RuntimeError, /failed to clean/)
+    end
+
+    it 'fails when both reset & clean fail' do
+      git.stub(:reset).and_return 1
+      git.stub(:clean).and_return 1
+      expect { git.clean_reset }
+        .to(raise_error RuntimeError, /failed to clean/)
+    end
+  end
+
+  context '#merge_remote' do
+    it 'generates & calls correct cmd' do
+      git.stub(:remotes).and_return []
+      git.stub(:exec).with('git fetch --all')
+      git.stub(:exec).with('git merge bar/foo').and_return 0
+      git.merge_remote 'foo', 'bar'
+    end
+  end
+
+  context '#diff_remote' do
+    it 'generates & calls correct cmd w/ single flag' do
+      git.stub(:remotes).and_return []
+      git.stub(:exec).with('git fetch --all')
+      git.stub(:exec).with('git diff bar/foo --flag').and_return 0
+      git.diff_remote 'foo', 'bar', '--flag'
+    end
+
+    it 'generates & calls correct cmd w/ multiple flags' do
+      git.stub(:remotes).and_return []
+      git.stub(:exec).with('git fetch --all')
+      git.stub(:exec).with('git diff bar/foo --flag --other').and_return 0
+      git.diff_remote 'foo', 'bar', %w(--flag, --other)
+    end
+  end
+end

data/spec/singularity_dsl/runstate_spec.rb

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+require 'singularity_dsl/runstate'
+
+describe 'Runstate' do
+  before :each do
+    @instance = SingularityDsl::Runstate.new
+  end
+
+  context '#initialize' do
+    it 'sets error & failed to false' do
+      expect(@instance.error).to eql false
+      expect(@instance.failed).to eql false
+    end
+
+    it 'starts of with empty failure & error arrays' do
+      expect(@instance.errors).to be_kind_of Array
+      expect(@instance.errors).to be_empty
+      expect(@instance.failures).to be_kind_of Array
+      expect(@instance.failures).to be_empty
+    end
+  end
+
+  context '#add_failure' do
+    it 'sets failed to true' do
+      @instance.add_failure 'failed'
+      expect(@instance.failed).to eql true
+    end
+
+    it 'adds failure' do
+      @instance.add_failure 'failed'
+      expect(@instance.failures).to eql ['failed']
+    end
+
+    it 'does NOT affect error state' do
+      @instance.add_failure 'failed'
+      expect(@instance.error).to eql false
+    end
+  end
+
+  context '#add_error' do
+    it 'sets error to true' do
+      @instance.add_error 'error'
+      expect(@instance.error).to eql true
+    end
+
+    it 'adds error' do
+      @instance.add_error 'error'
+      expect(@instance.errors).to eql ['error']
+    end
+
+    it 'does NOT affect failed state' do
+      @instance.add_error 'error'
+      expect(@instance.failed).to eql false
+    end
+  end
+
+  context '#exit_code' do
+    it 'returns 1 on error' do
+      @instance.add_error 'error'
+      expect(@instance.exit_code).to eql 1
+    end
+
+    it 'returns 1 on failure' do
+      @instance.add_failure 'failure'
+      expect(@instance.exit_code).to eql 1
+    end
+
+    it 'returns 0 otherwise' do
+      expect(@instance.exit_code).to eql 0
+    end
+  end
+end

data/spec/singularity_dsl/task_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'singularity_dsl/task'
+
+describe 'Task' do
+  context '#initialize' do
+    it 'does nothing if no block given' do
+      expect(SingularityDsl::Task).to_not receive :instance_eval
+      SingularityDsl::Task.new
+    end
+
+    it 'evals given block if given' do
+      expect(Kernel).to receive(:puts).with('woooooo')
+      SingularityDsl::Task.new { Kernel.puts 'woooooo' }
+    end
+  end
+
+  context '#validate_file' do
+    it 'throws if file DNE' do
+      expect { SingularityDsl::Task.new.validate_file('asdbfadf') }
+        .to raise_error(ArgumentError, /Cannot find/)
+    end
+  end
+
+  context '#task_name' do
+    it 'returns false' do
+      expect(SingularityDsl::Task.new.task_name).to eql false
+    end
+  end
+
+  context '#execute' do
+    it 'throws' do
+      expect { SingularityDsl::Task.new.execute }
+        .to raise_error(RuntimeError,
+                        'SingularityDsl::Task::execute not implemented')
+    end
+  end
+
+  context '#failed_status' do
+    it 'returns false for specific values' do
+      task = SingularityDsl::Task.new
+      expect(task.failed_status nil).to eql false
+      expect(task.failed_status 0).to eql false
+      expect(task.failed_status false).to eql false
+    end
+  end
+
+  context '#self.description' do
+    it 'auto-generates task description' do
+      expect(SingularityDsl::Task.new.description)
+        .to eql 'Runs SingularityDsl::Task task'
+    end
+  end
+end

data/spec/singularity_dsl/tasks/shell_task_spec.rb

@@ -0,0 +1,119 @@
+# encoding: utf-8
+
+require 'singularity_dsl/tasks/shell_task'
+
+describe 'ShellTask' do
+  let(:sh_task) { ShellTask.new }
+
+  context '#initialize' do
+    it 'starts with no conditionals' do
+      expect(sh_task.conditionals).to eql []
+    end
+
+    it 'has an echo notification as a default alt cmd' do
+      expect(sh_task.alternative)
+      .to eql 'echo "no alternative shell cmd defined"'
+    end
+  end
+
+  context '#condition' do
+    it 'throws when non string given' do
+      expect { sh_task.condition([]) }.to raise_error
+    end
+
+    it 'appends the cmd to conditionals array' do
+      sh_task.condition 'woo'
+      expect(sh_task.conditionals).to eql ['woo']
+    end
+  end
+
+  context '#no_fail' do
+    it 'fails when non-bool given' do
+      expect { sh_task.no_fail [] }.to raise_error
+    end
+  end
+
+  context '#alt' do
+    it 'throws when non string given' do
+      expect { sh_task.alt([]) }.to raise_error
+    end
+
+    it 'sets alternative cmd' do
+      sh_task.alt 'woo'
+      expect(sh_task.alternative).to eql 'woo'
+    end
+  end
+
+  context '#command' do
+    it 'sets commands!' do
+      cmd = 'echo "hi :)"'
+      sh_task.command cmd
+      expect(sh_task.shell.command).to eql cmd
+    end
+
+    it 'sets live_stream to STDOUT' do
+      cmd = 'echo "hi :)"'
+      sh_task.command cmd
+      expect(sh_task.shell.live_stream).to eql STDOUT
+    end
+  end
+
+  context '#task_name' do
+    it 'returns command' do
+      expect(sh_task.task_name).to eql false
+    end
+
+    it 'returns command' do
+      cmd = 'echo "hi :)"'
+      sh_task.command cmd
+      expect(sh_task.task_name).to eql 'echo "hi :)"'
+    end
+  end
+
+  context '#execute' do
+    it 'errors when command() was never called' do
+      expect { sh_task.execute }.to raise_error
+    end
+
+    it 'runs command returns correct status, with conditionals' do
+      cmd = 'echo "hi :)"'
+      alt = 'echo "no"'
+      sh_task.live_stream = false
+      sh_task.command cmd
+      sh_task.alt alt
+      sh_task.condition 'ls'
+      expect(sh_task).to_not receive(:command).with(alt)
+      expect(sh_task.shell).to receive(:run_command)
+      expect(sh_task.shell).to receive(:exitstatus).and_return 0
+      expect(sh_task.execute).to eql 0
+    end
+
+    it 'runs alternative command' do
+      cmd = 'echo "hi :)"'
+      alt = 'echo "no"'
+      sh_task.command cmd
+      sh_task.alt alt
+      sh_task.condition 'ls -z'
+      expect(sh_task).to_not receive(:command).with(cmd)
+      expect(sh_task).to receive(:command).with(alt)
+      expect(sh_task.shell).to receive(:run_command)
+      expect(sh_task.shell).to receive(:exitstatus).and_return 0
+      expect(sh_task.execute).to eql 0
+    end
+
+    it 'runs command returns correct status, no conditionals' do
+      sh_task.command 'echo "hi :)"'
+      expect(sh_task.shell).to receive(:run_command)
+      expect(sh_task.shell).to receive(:exitstatus).and_return 0
+      expect(sh_task.execute).to eql 0
+    end
+
+    it 'returns 0 if no_fail set' do
+      sh_task.command 'ls -z'
+      sh_task.no_fail true
+      expect(sh_task.shell).to receive(:run_command)
+      expect(sh_task.shell).to_not receive(:exitstatus)
+      expect(sh_task.execute).to eql 0
+    end
+  end
+end