guard-cunit 0.0.1-x86-linux

data/guard-cunit.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib/",__FILE__)
+
+require "guard/cunit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "guard-cunit"
+  s.version     = Guard::CunitGuard::VERSION
+  s.authors	= ["Tea Cup On Rocking Chair"]
+  s.email       = ["strandjata@gmail.com"]
+  s.platform	= Gem::Platform::CURRENT
+  s.homepage    = "http://teacup-on-rockingchair.github.com/guard-cunit/"
+  s.summary     = %q{Guard gem for CUnit-driven projects}
+  s.description = %q{Guard Cunit should automatically build your C project and run CUnit based tests}
+
+  s.rubyforge_project = "guard-cunit"
+  
+  # specify any dependencies here; for example:
+  s.add_dependency 'guard', '>= 1.1'		
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'rspec'  
+
+  s.files         =  `git ls-files`.split("\n").delete_if {|x| x.match(/(.).gem\b/)}
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  
+end

data/lib/guard/cunit/cunit_parser.rb

@@ -0,0 +1,70 @@
+class TestOutput < String
+  # limit the output to given nr rows
+  def limit_to_rows(number_of_rows)
+    output = TestOutput.new("")
+    raws_count = 1;
+    self.lines.each do |current_line|
+      output += current_line
+      break if(raws_count == number_of_rows)
+      raws_count+=1
+    end
+    output=output+"..." if ( number_of_rows < self.lines.count )
+    output
+  end
+  
+  # bang version
+  def limit_to_rows!(number_of_rows)
+    self.replace(limit_to_rows(number_of_rows))
+  end
+
+end
+
+
+module Guard
+  class Cunit
+   class CunitParser
+     @output
+     @summary_output
+     @failures
+
+     #constructor
+     def initialize (task_output = nil)
+       parse_output( task_output ) unless task_output == nil
+     end
+     
+     #get cunit output
+     def parse_output( task_output )
+       @output = TestOutput.new(task_output.dup)
+       get_summary
+       get_failures
+     end
+     
+     # find summary of the cunit test reprot
+     def get_summary
+       @summary_output = TestOutput.new(@output[/Run Summary:[\w\W]*/])
+     end
+
+     #find failures from Cunit test report
+     def get_failures
+       @failures = TestOutput.new(@output[/Suite[\w\W]*/].sub(@summary_output,"").strip)
+       @failures.limit_to_rows!(3)
+     end
+
+     #display summary of the suites/tests/asserts
+     def cunit_output
+       @summary_output
+     end
+
+     #copy of the cunit output
+     def full_output
+       @output
+     end
+
+     #display failures output
+     def failures_output
+       @failures
+     end
+
+   end
+ end
+end

data/lib/guard/cunit/runner.rb

@@ -0,0 +1,99 @@
+require 'guard/cunit/cunit_parser'
+
+
+module Guard
+  class Cunit
+#
+# the class implements running and handling of results of the tasks that made up the cunit guard
+# 
+   class Runner
+     @@cunit_runner=''
+     @@project_builder=''
+     @@project_cleaner=''
+     @@project_libdir=''
+     
+     
+     def initialize
+       @parser = CunitParser.new()
+       @current_output = String.new("")
+     end
+     # set the executable file name to run CUNIT tests
+     def self.set_runner(name)
+       @@cunit_runner=name
+     end
+     
+     # set command to run to prepare build
+     def self.set_builder(name)
+       @@project_builder=name
+     end
+     
+      # set cleaner script/exe/command
+     def self.set_cleaner(name)
+       @@project_cleaner=name
+     end
+     
+     
+      # set directory where library under test is generated
+     def self.set_libdir(name)
+       @@project_libdir=name
+     end
+     
+     #
+     # run one phase of the guard via a system command/executable
+     #
+     def run_task(task_executable)
+       success = true
+       IO.popen(task_executable)  do |myio|
+         @current_output = myio.read
+       end
+       success = false unless $?.exitstatus == 0
+       UI.info @current_output
+       success
+     end
+     
+     # run clean before each run all start with clean
+     def run_clean
+       run_task(@@project_cleaner)
+     end
+     
+     # run unit tests via cunit executable
+     def run_tests
+       # setup environment so it should include lib dir for ld path
+       ENV["LD_LIBRARY_PATH"]="#{ENV["LD_LIBRARY_PATH"]}:#{@@project_libdir}"
+       
+       if( !File.exists? (@@cunit_runner) )
+         Notifier.notify("Pending", :title => "Test Not Defined", :image => :pending, :priority => 2)
+         success = false
+       else
+         success = run_task(@@cunit_runner)
+         @parser.parse_output(@current_output) unless (@cunit_output == nil)
+         if success == true
+           Notifier.notify("Success", :title => "Test Passed", :image => :passed, :priority => 2)
+         else
+           Notifier.notify("Failed", :title => "Test Failed", :image => :failed, :priority => 2,:message => @parser.failures_output)
+         end
+       end
+       success
+     end
+     
+     
+     # run make command to build the project
+     def run_make
+       success = run_task(@@project_builder)
+       Notifier.notify("Failed", :title => "Build Failed", :image => :failed, :priority => 2) unless success == true
+     end
+     # run them all
+     def run 
+       UI.info "Test runner: #{@@cunit_runner}"
+       UI.info "Builder:  #{@@project_builder}"
+       UI.info "Cleaner: #{@@project_cleaner}"
+       UI.info "Libdir: #{@@project_libdir}"
+       
+       run_clean
+       run_make
+       run_tests
+     end
+     
+   end
+ end
+end

data/lib/guard/cunit/templates/Guardfile

@@ -0,0 +1,12 @@
+#
+# Cunit Guardfile - keep dflt builders after guard watcher's block
+#
+guard 'cunit' do
+      watch(%r{((.+)\.c$)|((.+)\.h$)|((M|m)akefile$)} )	
+end
+
+set_builder "make 2>&1"
+set_cleaner "make clean"
+cunit_runner "#{File.basename(Dir.getwd)}_unit"
+libdir "#{Dir.getwd}"
+

data/lib/guard/cunit/version.rb

@@ -0,0 +1,7 @@
+#version
+module Guard
+  module CunitGuard
+# version of the gem
+    VERSION="0.0.1"
+  end
+end

data/lib/guard/cunit.rb

@@ -0,0 +1,69 @@
+require 'guard'
+require 'guard/guard'
+
+
+module Guard
+# main child class of Guard to nherit guard's behaviour
+  class Cunit < Guard 
+    autoload :Runner,    'guard/cunit/runner'
+# new method that also creates the runner class
+    def initialize(watchers = [], options = {})
+      super
+      @options = {
+        :all_on_start   => true,
+      }.update(options)
+      @runner    = Runner.new()
+    end
+    # Called when just `enter` is pressed
+    # This method should be principally used for long action like running all specs/tests/...
+    # @raise [:task_has_failed] when run_all has failed
+    def run_all
+      passed = @runner.run
+      throw :task_has_failed unless passed
+    end
+    def run_on_change(paths)
+      UI.info("Process changes in #{paths}")
+      passed = run_all
+    end
+  end
+
+#
+# add more behaviour to Guard's DSL to be able to configure executors 
+# of all the CUnit's Guard tasks
+#
+  class Dsl
+#
+# put default values to task executors
+#
+    def initialize
+      super
+      set_cleaner("make clean")
+      cunit_runner("#{File.basename(Dir.getwd)}_unit")
+      set_builder("make 2>&1")
+      libdir("#{Dir.getwd}")
+      @runner = Cunit::Runner.new
+    end
+
+    # dsl call to set cunit test executable
+    def cunit_runner (name)
+      Cunit::Runner.set_runner(name)
+    end
+    
+    # dsl call to set cunit build command/script, by default make
+    def set_builder (name)
+      Cunit::Runner.set_builder(name)
+    end
+    
+    #dsl call to set cunit clean command/script, by default 'make clean'
+    def set_cleaner (name)
+      Cunit::Runner.set_cleaner(name)
+    end
+    
+    # dsl call to set dir, where library under test is generated, by default current dir
+    def libdir(name)
+      Cunit::Runner.set_libdir(File.expand_path(name))
+    end
+
+  end
+  
+end

data/spec/guard_cunit_parser_spec.rb

@@ -0,0 +1,79 @@
+require "spec_helper.rb"
+
+
+describe Guard::Cunit::CunitParser do
+  before(:each) do
+
+@long_fake_output =  String.new("     CUnit - A unit testing framework for C - Version 2.1-2
+     http://cunit.sourceforge.net/
+
+Suite  Simple calc CUNIT suite, Test Addition test had failures:
+    1. simplecalc_test.c:7  - CU_FAIL(\"TODO\")
+    2. simplecalc_test.c:17  - CU_FAIL(\"TODO\")
+    3. simplecalc_test.c:27  - CU_FAIL(\"TODO\")
+    4. simplecalc_test.c:37  - CU_FAIL(\"TODO\")
+    5. simplecalc_test.c:47  - CU_FAIL(\"TODO\")
+    6. simplecalc_test.c:57  - CU_FAIL(\"TODO\")
+    7. simplecalc_test.c:67  - CU_FAIL(\"TODO\")
+    8. simplecalc_test.c:77  - CU_FAIL(\"TODO\")
+    9. simplecalc_test.c:87  - CU_FAIL(\"TODO\")
+    10. simplecalc_test.c:97  - CU_FAIL(\"TODO\")
+
+
+Run Summary:    Type  Total    Ran Passed Failed Inactive
+              suites      1      1    n/a      0        0
+               tests     10     10      0     10        0
+             asserts     10     10      0     10      n/a
+
+Elapsed time =    0.000 seconds")
+
+
+@fake_output =  String.new("     CUnit - A unit testing framework for C - Version 2.1-2
+     http://cunit.sourceforge.net/
+
+Suite  Simple calc CUNIT suite, Test Addition test had failures:
+    1. simplecalc_test.c:7  - CU_FAIL(\"TODO\")
+
+Run Summary:    Type  Total    Ran Passed Failed Inactive
+              suites      1      1    n/a      0        0
+               tests      1      1      0      1        0
+             asserts      1      1      0      1      n/a
+
+Elapsed time =    0.000 seconds")
+
+@fake_fail_summary = String.new("Suite  Simple calc CUNIT suite, Test Addition test had failures:
+    1. simplecalc_test.c:7  - CU_FAIL(\"TODO\")")
+
+@fake_summary = String.new("Run Summary:    Type  Total    Ran Passed Failed Inactive
+              suites      1      1    n/a      0        0
+               tests      1      1      0      1        0
+             asserts      1      1      0      1      n/a
+
+Elapsed time =    0.000 seconds")
+
+@shortened_fail_summary = String.new("Suite  Simple calc CUNIT suite, Test Addition test had failures:
+    1. simplecalc_test.c:7  - CU_FAIL(\"TODO\")
+    2. simplecalc_test.c:17  - CU_FAIL(\"TODO\")
+...")
+
+  end
+
+
+  it "should generate a UI summary and full output from given text input" do
+    parser = Guard::Cunit::CunitParser.new(@fake_output)
+    parser.full_output.should == @fake_output
+    parser.cunit_output.should == (@fake_summary)
+    parser.failures_output.should == (@fake_fail_summary)
+  end
+
+  it "failure summary should be maximum a 3 row output" do
+    parser = Guard::Cunit::CunitParser.new(@long_fake_output)
+    parser.failures_output.should == (@shortened_fail_summary)
+  end
+
+  it "should be able to init with no output and later trigger process" do
+    parser = Guard::Cunit::CunitParser.new()
+    parser.parse_output @long_fake_output
+    parser.failures_output.should == (@shortened_fail_summary)
+  end
+end

data/spec/guard_cunit_spec.rb

@@ -0,0 +1,198 @@
+require "spec_helper.rb"
+
+
+describe Guard::Cunit do
+
+  before (:all) do
+    @@first = true
+  end
+
+  def setup_guard
+    if @@first == true
+      Guard::setup
+      @@first = false
+    else
+      Guard::reload
+    end
+  end
+
+  before(:each) do
+    tmp_work_dir=TempPrjEnv.create_tmp_prj_dir
+    @work_dir = Dir.getwd
+    Dir.chdir(tmp_work_dir)
+    Guard::UI.stub(:info)
+     IO.stub(:popen)
+  end
+
+  after(:each) do
+    Dir.chdir(@work_dir)
+    TempPrjEnv.cleanup_tmp_prj_dir
+  end
+
+  it "should inherit Guard class" do
+    subject.class.ancestors.should include(Guard::Guard)
+  end
+
+  context "Run guard" do
+
+    it "should run build" do
+
+      guardfile_has_unit_test_exe()
+      popen_successfull_fake("make clean")
+      popen_successfull_fake("make 2>&1")
+      fake_test_exe("#{File.basename(Dir.getwd)}_unit",:pass)
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+      
+    end
+
+
+    it "should run build on changes " do
+      
+      cguard = Guard::Cunit.new
+      cguard.stub(:run_all).and_return(true)
+      Guard::UI.should_receive(:info).with("Process changes in #{File.basename(Dir.getwd)}")
+      
+      cguard.run_on_change("#{File.basename(Dir.getwd)}")
+      
+    end
+
+    it "should set libpath for executbles with current project directory by default" do
+      oldenv=ENV["LD_LIBRARY_PATH"]
+      guardfile_has_unit_test_exe()
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+      newenv =ENV["LD_LIBRARY_PATH"]
+      newenv.should match("#{oldenv}:#{Dir.getwd}")
+      ENV["LD_LIBRARY_PATH"]=oldenv
+    end
+
+
+    it "should set libpath to predefined lib directory when user has specified such in the Guardfile" do
+      oldenv=ENV["LD_LIBRARY_PATH"]
+      guardfile_has_unit_test_exe(:libdir=>'./lib')
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+      newenv =ENV["LD_LIBRARY_PATH"]
+      newenv.should match("#{oldenv}:#{Dir.getwd}/lib")
+      ENV["LD_LIBRARY_PATH"]=oldenv      
+    end
+
+
+    it "should run cunit test define in the Guardfile" do
+      guardfile_has_unit_test_exe(:test_exe => "jiji")
+      fake_test_exe("jiji",:pass)
+      cguard = Guard::Cunit.new
+      setup_guard
+      cguard.run_all
+
+      guardfile_has_unit_test_exe(:test_exe =>"didi")
+      fake_test_exe("didi",:pass)
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+      
+    end
+
+
+    it "should run predefined build command" do 
+      guardfile_has_unit_test_exe(:test_exe =>"jiji",:builder => "./make_all.sh")
+      fake_test_exe("jiji",:pass)
+      popen_successfull_fake("./make_all.sh")
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+
+    end
+
+    it "should run predefined clean command" do 
+      guardfile_has_unit_test_exe(:test_exe =>"jiji",:builder => "./make_all.sh",:cleaner=> "./clean_all.sh")
+      fake_test_exe("jiji",:pass)
+      popen_successfull_fake("./make_all.sh")
+      popen_successfull_fake("./clean_all.sh")
+      cguard = Guard::Cunit::Runner.new
+    setup_guard
+      cguard.run
+
+    end
+
+  end
+
+
+  context "Handle exit codes" do
+    it "should report failure on build failed" do
+      guardfile_has_unit_test_exe()
+      popen_successfull_fake("make clean")
+      popen_failing_fake("make 2>&1")
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run.should == false
+    end
+
+    it "should report failure on test failed" do
+      guardfile_has_unit_test_exe(:test_exe=>"jiji")
+      popen_successfull_fake("make clean")
+      popen_successfull_fake("make 2>&1")
+      fake_test_exe("jiji",:fail)
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run.should == false
+    end
+
+  end
+
+
+  context "Displaying notifications" do
+
+    it "should display failure if build fails" do
+      Guard::Notifier.stub(:notify) 
+      guardfile_has_unit_test_exe()
+      Guard::Notifier.should_receive(:notify).with("Failed", :title => "Build Failed", :image => :failed, :priority => 2)
+      popen_successfull_fake("make clean")
+      popen_failing_fake("make 2>&1")
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+    end
+
+    it "should display failure if test fails" do
+      IO.stub(:popen)
+      Guard::Notifier.stub(:notify) 
+      guardfile_has_unit_test_exe(:test_exe=>"jiji")
+      Guard::Notifier.should_receive(:notify).with("Failed", :title => "Test Failed", :image => :failed, :priority => 2, :message => anything() )
+      popen_successfull_fake("make clean")
+      popen_successfull_fake("make 2>&1")
+      fake_test_exe("jiji",:fail)
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+    end
+
+    it "should display pending if test is absent" do
+      Guard::Notifier.stub(:notify) 
+      guardfile_has_unit_test_exe()
+      Guard::Notifier.should_receive(:notify).with("Pending", :title => "Test Not Defined", :image => :pending, :priority => 2)
+      popen_successfull_fake("make clean")
+      popen_successfull_fake("make 2>&1")
+      cguard = Guard::Cunit::Runner.new
+      setup_guard
+      cguard.run
+    end
+
+    it "should display success if build and test succeeded" do
+      Guard::Notifier.stub(:notify) 
+      guardfile_has_unit_test_exe()
+      Guard::Notifier.should_receive(:notify).with("Success", :title => "Test Passed", :image => :passed, :priority => 2)
+      popen_successfull_fake("make clean")
+      popen_successfull_fake("make 2>&1")
+      fake_test_exe(nil,:pass)
+      cguard = Guard::Cunit::Runner.new
+      Guard.add_guard('cunit')
+      cguard.run
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,72 @@
+require 'rubygems'
+require 'guard'
+require 'guard/cunit'
+require 'guard/cunit/runner'
+require 'guard/cunit/cunit_parser'
+require 'rspec'
+
+# a class to set/cleanup environment for fake project
+class TempPrjEnv
+
+  @test_tmp = "./tmp"
+  @test_prj_dir="./tmp/1test_prj"
+
+  # create a tmp subdir and within it fake project directory
+  def self.create_tmp_prj_dir
+    begin
+      Dir.mkdir(@test_tmp)
+      Dir.mkdir(@test_prj_dir)
+    rescue
+    end
+    @test_prj_dir
+  end
+
+  # cleanup the subdir
+  def self.cleanup_tmp_prj_dir
+    begin
+      FileUtils.rm_rf(@test_prj_dir)
+      FileUtils.rm_rf(@test_tmp)
+    rescue
+      puts "Could not remove dirs"
+    end
+  end
+end
+
+# setup stub for system command with successful exit result
+def popen_successfull_fake(fakename)
+  IO.stub(:popen).with(fakename)
+  IO.should_receive(:popen).with(fakename)  { `(exit 0)`}
+end
+
+# setup stub for system command with failing exit result
+def popen_failing_fake(fakename)
+  IO.stub(:popen).with(fakename)
+  IO.should_receive(:popen).with(fakename)  { `(exit 1)`}
+end
+
+# fake the test executable runner, its existance and result
+def fake_test_exe(exe_name,successful = :fail)
+  exe_name="#{File.basename(Dir.getwd)}_unit" unless exe_name != nil
+  File.new(exe_name,"w+")
+  if successful == :pass
+    popen_successfull_fake(exe_name)
+  else
+    popen_failing_fake(exe_name)
+  end
+end
+
+# a generator for CUnit Guardfile
+def guardfile_has_unit_test_exe(params={ :test_exe=>nil, :builder=>nil, :cleaner=>nil, :libdir=>nil})
+  File.open("Guardfile","w+",0644) do |file|
+    file.puts "guard \'cunit\'  do"
+    
+    file.puts " set_builder \"#{params[:builder]}\"" unless (params[:builder] == nil)
+    file.puts " set_cleaner \"#{params[:cleaner]}\"" unless (params[:cleaner] == nil)
+    file.puts " cunit_runner \"#{params[:test_exe]}\"" unless (params[:test_exe] == nil)
+    file.puts " libdir \"#{params[:libdir]}\"" unless (params[:libdir] == nil)
+    
+    file.puts '    watch(%r{((.+)\.c$)|((.+)\.h$)|((M|m)akefile$)} )	'
+    file.puts 'end'
+  end
+end
+