linecook 0.6.2 → 1.0.0

data/lib/linecook/test.rb

@@ -1,172 +1,227 @@
-require 'linecook/cookbook'
-require 'linecook/recipe'
+require 'linecook/package'
 require 'linecook/test/file_test'
-require 'linecook/test/regexp_escape'
-require 'linecook/utils'
+require 'linecook/test/shell_test'
 
 module Linecook
   module Test
+    module ClassMethods
+      def host
+        @host ||= ENV['LINECOOK_TEST_HOST'] || name
+      end
+      
+      def use_host(host)
+        @host = host
+      end
+      
+      def only_hosts(*patterns)
+        patterns.collect! do |pattern|
+          pattern.kind_of?(Regexp) ? pattern : /\A#{pattern}\z/
+        end
+        
+        @skip_test_suite = false
+        unless patterns.any? {|pattern| host =~ pattern }
+          skip_test "not for host (#{host})"
+        end
+      end
+      
+      # Causes a test suite to be skipped.  If a message is given, it will
+      # print and notify the user the test suite has been skipped.
+      def skip_test(msg=nil)
+        @skip_test_suite = true
+        skip_messages << msg
+      end
+      
+      # Modifies the default suite method to skip the suit unless
+      # run_test_suite is true.  If the test is skipped, the skip_messages 
+      # will be printed along with the default 'Skipping <Test>' message.
+      def suite # :nodoc:
+        if (@skip_test_suite ||= false)
+          skip_message = skip_messages.compact.join(', ')
+          puts "Skipping #{name}#{skip_message.empty? ? '' : ': ' + skip_message}"
+
+          # return an empty test suite of the appropriate name
+          ::Test::Unit::TestSuite.new(name)
+        else
+          super
+        end
+      end
+      
+      protected
+      
+      def skip_messages # :nodoc:
+        @skip_messages ||= []
+      end
+    end
+  
+    module ModuleMethods
+      module_function
+    
+      def included(base)
+        base.extend ClassMethods
+        base.extend ModuleMethods unless base.kind_of?(Class)
+        super
+      end
+    end
+    
+    extend ModuleMethods
+    
     include FileTest
+    include ShellTest
     
-    attr_writer :cookbook
-    attr_writer :script
-    attr_writer :recipe
+    LINECOOK_DIR = File.expand_path('../../..', __FILE__)
+    LINECOOK = File.join(LINECOOK_DIR, 'bin/linecook')
+    
+    def method_dir
+      @host_method_dir ||= begin
+        if test_host = ENV['LINECOOK_TEST_HOST']
+          File.join(super, test_host)
+        else
+          super
+        end
+      end
+    end
+    
+    def remote_dir
+      method_dir[(user_dir.length + 1)..-1]
+    end
+    
+    def ssh_config_file
+      method_ssh_config_file = path('config/ssh')
+      File.file?(method_ssh_config_file) ? method_ssh_config_file : 'config/ssh'
+    end
+    
+    def setup_cookbook(configs=nil, project_dir=method_dir)
+      configs ||= Cookbook.config_file(project_dir)
+      @cookbook = Cookbook.setup(configs, project_dir)
+    end
     
     def cookbook
-      @cookbook ||= Cookbook.init(user_dir)
+      @cookbook ||= setup_cookbook
     end
     
-    def manifest
-      cookbook.manifest
+    def setup_package(env={})
+      @package = Package.setup(env, cookbook)
     end
     
-    def default_env
-      {Package::CONFIG_KEY => {Package::MANIFEST_KEY => manifest}}
+    def package
+      @package ||= setup_package
     end
     
-    def recipe
-      @recipe ||= Recipe.new('recipe', default_env)
-    end
-    
-    def build(env={})
-      env = Utils.deep_merge(default_env, env)
-      Recipe.build(env).export File.join(method_dir, 'scripts')
-    end
-    
-    # Asserts whether or not the a and b strings are equal, with a more
-    # readable output than assert_equal for large strings (especially large
-    # strings with significant whitespace).
-    #
-    # One gotcha is that assert_output_equal lstrips indentation off of 'a',
-    # so that these all pass:
-    #
-    #   assert_output_equal %q{
-    #   line one
-    #   line two
-    #   }, "line one\nline two\n"
-    #
-    #   assert_output_equal %q{
-    #     line one
-    #     line two
-    #   }, "line one\nline two\n
-    #
-    #     assert_output_equal %q{
-    #     line one
-    #     line two
-    #     }, "line one\nline two\n"
-    #
-    # Use the assert_output_equal! method to prevent indentation stripping.
-    def assert_output_equal(a, b, msg=nil)
-      a = strip_indent(a)
-      assert_output_equal!(a, b, msg)
+    def use_helpers(*helpers)
+      @helpers = helpers
     end
-
-    # Same as assert_output_equal but without indentation stripping.
-    def assert_output_equal!(a, b, msg=nil)
-      if a == b
-        assert true
-      else
-        flunk %Q{
-#{msg}
-==================== expected output ====================
-#{whitespace_escape(a)}
-======================== but was ========================
-#{whitespace_escape(b)}
-=========================================================
-}
-      end
+    
+    def helpers
+      @helpers ||= []
     end
-
-    # Asserts whether or not b is like a (which should be a Regexp), and
-    # provides a more readable output in the case of a failure as compared
-    # with assert_match.
-    #
-    # If a is a string, then indentation is stripped off and it is turned
-    # into a RegexpEscape. Using that syntax, all these pass:
-    #
-    #   assert_alike %q{
-    #   the time is: :...:
-    #   now!
-    #   }, "the time is: #{Time.now}\nnow!\n"
-    #
-    #   assert_alike %q{
-    #     the time is: :...:
-    #     now!
-    #   }, "the time is: #{Time.now}\nnow!\n"
-    #
-    #     assert_alike %q{
-    #     the time is: :...:
-    #     now!
-    #     }, "the time is: #{Time.now}\nnow!\n"
-    #
-    # Use assert_alike! to prevent indentation stripping (conversion to a
-    # RegexpEscape is still in effect).
-    def assert_alike(a, b, msg=nil)
-      a = strip_indent(a) if a.kind_of?(String)
-      assert_alike!(a, b, msg)
+    
+    def use_host(host)
+      @host = host
     end
-
-    # Same as assert_alike but without indentation stripping.
-    def assert_alike!(a, b, msg=nil)
-      a = RegexpEscape.new(a) if a.kind_of?(String)
-
-      if b =~ a
-        assert true
-      else
-        flunk %Q{
-#{msg}
-================= expected output like ==================
-#{whitespace_escape(a)}
-======================== but was ========================
-#{whitespace_escape(b)}
-=========================================================
-}
-      end
+    
+    def host
+      @host ||= self.class.host
     end
-
-    def assert_recipe(expected, &block)
-      recipe.instance_eval(&block)
+    
+    def runlist
+      @runlist ||= []
+    end
+    
+    def setup_recipe(target_name=package.next_target_name('recipe'), mode=0700, &block)
+      recipe = package.setup_recipe(target_name, mode)
+      helpers.each {|helper| recipe.extend helper }
+      
+      recipe.instance_eval(&block) if block_given?
+      runlist << target_name
+      
+      @recipe = recipe
+    end
+    
+    def recipe
+      @recipe ||= setup_recipe
+    end
+    
+    def assert_recipe(expected, recipe=setup_recipe, &block)
+      recipe.instance_eval(&block) if block_given?
+      recipe.close
+      
       assert_output_equal expected, recipe.result
+      recipe
     end
     
-    def assert_recipe_match(expected, &block)
-      recipe.instance_eval(&block)
+    def assert_recipe_matches(expected, recipe=setup_recipe, &block)
+      recipe.instance_eval(&block) if block_given?
+      recipe.close
+      
       assert_alike expected, recipe.result
+      recipe
     end
-
-    def assert_content(expected, build_path)
-      registry = recipe.close
-
-      assert_equal true, registry.has_key?(build_path), "not in registry: #{build_path}"
-      assert_output_equal expected, File.read(registry[build_path]), build_path
+    
+    def build_package(host=self.host)
+      package_dir = path("packages/#{host}")
+      
+      package.build
+      package.export package_dir
+      
+      package_dir
     end
     
-    private
-
-    # helper for stripping indentation off a string
-    def strip_indent(str) # :nodoc:
-      if str =~ /\A\s*?\n( *)(.*)\z/m
-        indent, str = $1, $2, $3
-
-        if indent.length > 0
-          str.gsub!(/^ {0,#{indent.length}}/, '')
-        end
-      end
-
-      str
+    def run_package(options={}, host=self.host)
+      options['remote_script'] ||= runlist.join(',')
+      
+      build_package host
+      run_project options, host
     end
-
-    # helper for formatting escaping whitespace into readable text
-    def whitespace_escape(str) # :nodoc:
-      str.to_s.gsub(/\s/) do |match|
-        case match
-        when "\n" then "\\n\n"
-        when "\t" then "\\t"
-        when "\r" then "\\r"
-        when "\f" then "\\f"
-        else match
+    
+    def build_project(options={})
+      options = {
+        'project_dir' => method_dir,
+        'quiet'       => true
+      }.merge(options)
+      
+      linecook('build', options)
+    end
+    
+    # pick up user dir as a gem... bundler!
+    def run_project(options={}, *package_names)
+      options = {
+        'ssh_config_file' => ssh_config_file,
+        'project_dir'     => method_dir,
+        'remote_dir'      => remote_dir,
+        'quiet'           => true,
+      }.merge(options)
+      
+      linecook('run', options, *package_names)
+    end
+    
+    def linecook(cmd, options={}, *args)
+      stdout = prepare("log/#{cmd}.out")
+      stderr = prepare("log/#{cmd}.err")
+      
+      command = "#{linecook_cmd(cmd, options, *args)} 2> '#{stderr}' > '#{stdout}'"
+      system(command)
+      
+      [File.read(stdout), "% #{command}\n#{File.read(stderr)}"]
+    end
+    
+    def linecook_cmd(cmd, options={}, *args)
+      opts = []
+      options.each_pair do |key, value|
+        key = key.gsub('_', '-')
+        
+        case value
+        when true
+          opts << "--#{key}"
+        when nil, false
+        else 
+          opts << "--#{key} '#{value}'"
         end
       end
+      
+      args = args.collect! {|arg| "'#{arg}'" }
+      
+      cmd = [LINECOOK, cmd] + opts.sort + args
+      cmd.join(' ')
     end
   end
 end

data/lib/linecook/test/command_parser.rb

@@ -0,0 +1,75 @@
+module Linecook
+  module Test
+    class CommandParser
+      attr_reader :ps1
+      attr_reader :ps2
+      attr_reader :prefix
+      attr_reader :suffix
+      
+      def initialize(options={})
+        options = {
+          :ps1 => '% ',
+          :ps2 => '> ',
+          :prefix => '0<&- 2>&1 ',
+          :suffix => ''
+        }.merge(options)
+        
+        @ps1 = options[:ps1]
+        @ps2 = options[:ps2]
+        @prefix = options[:prefix]
+        @suffix = options[:suffix]
+      end
+      
+      def parse_cmd(cmd)
+        cmd =~ /.*?#\s*(?:\[(\d+)\])?\s*(\.{3})?/
+        exit_status = $1 ? $1.to_i : 0
+        output = $2 ? nil : ""
+        
+        [cmd, output, exit_status]
+      end
+      
+      def parse(script)
+        commands = []
+        
+        command, output, exit_status = nil, "", 0
+        script.each_line do |line|
+          case
+          when line.index(ps1) == 0
+            if command
+              commands << ["#{prefix}#{command}#{suffix}", output, exit_status]
+            end
+            
+            command, output, exit_status = parse_cmd lchomp(ps1, line)
+            
+          when command.nil?
+            unless line.strip.empty?
+              command, output, exit_status = parse_cmd(line)
+            end
+            
+          when line.index(ps2) == 0
+            command << lchomp(ps2, line)
+          
+          when output.nil?
+            output = line
+          
+          else
+            output << line
+          end
+        end
+        
+        if command
+          commands << ["#{prefix}#{command}#{suffix}", output, exit_status]
+        end
+        
+        commands
+      end
+      
+      private
+      
+      def lchomp(prefix, line) # :nodoc:
+        length = prefix.length
+        line[length, line.length - length]
+      end
+    end
+  end
+end

data/lib/linecook/test/file_test.rb

@@ -4,11 +4,101 @@ module Linecook
       module ClassMethods
         attr_accessor :class_dir
         
-        def self.extended(base)
+        attr_reader :cleanup_method_registry
+        
+        def cleanup_methods
+          @cleanup_methods ||= begin
+            cleanup_methods = {}
+
+            ancestors.reverse.each do |ancestor|
+              next unless ancestor.kind_of?(ClassMethods)
+              ancestor.cleanup_method_registry.each_pair do |key, value|
+                if value.nil?
+                  cleanup_methods.delete(key)
+                else
+                  cleanup_methods[key] = value
+                end
+              end
+            end
+            
+            cleanup_methods
+          end
+        end
+        
+        def reset_cleanup_methods
+          @cleanup_methods = nil
+        end
+        
+        protected
+        
+        def self.initialize(base)
           # Infers the test directory from the calling file.
           #   'some_class_test.rb' => 'some_class_test'
-          calling_file = caller[2].gsub(/:\d+(:in .*)?$/, "")
+          calling_file = caller[1].gsub(/:\d+(:in .*)?$/, "")
           base.class_dir = calling_file.chomp(File.extname(calling_file))
+          
+          base.reset_cleanup_methods
+          unless base.instance_variable_defined?(:@cleanup_method_registry)
+            base.instance_variable_set(:@cleanup_method_registry, {})
+          end
+          
+          unless base.instance_variable_defined?(:@cleanup_paths)
+            base.instance_variable_set(:@cleanup_paths, ['.'])
+          end
+          
+          unless base.instance_variable_defined?(:@cleanup)
+            base.instance_variable_set(:@cleanup, true)
+          end
+        end
+        
+        def inherited(base) # :nodoc:
+          ClassMethods.initialize(base)
+          super
+        end
+        
+        def define_method_cleanup(method_name, dirs)
+          reset_cleanup_methods
+          cleanup_method_registry[method_name.to_sym] = dirs
+        end
+        
+        def remove_method_cleanup(method_name)
+          reset_cleanup_methods
+          cleanup_method_registry.delete(method_name.to_sym)
+        end
+        
+        def undef_method_cleanup(method_name)
+          reset_cleanup_methods
+          cleanup_method_registry[method_name.to_sym] = nil
+        end
+        
+        def cleanup_paths(*dirs)
+          @cleanup_paths = dirs
+        end
+        
+        def cleanup(*method_names)
+          if method_names.empty?
+            @cleanup = true
+          else
+            method_names.each do |method_name|
+              define_method_cleanup method_name, @cleanup_paths
+            end
+          end
+        end
+        
+        def no_cleanup(*method_names)
+          if method_names.empty?
+            @cleanup = false
+          else
+            method_names.each do |method_name|
+              undef_method_cleanup method_name
+            end
+          end
+        end
+        
+        def method_added(sym)
+          if @cleanup && !cleanup_method_registry.has_key?(sym.to_sym) && sym.to_s[0, 5] == "test_"
+            cleanup sym
+          end
         end
       end
     
@@ -16,61 +106,89 @@ module Linecook
         module_function
       
         def included(base)
-          base.extend base.kind_of?(Class) ? ClassMethods : ModuleMethods
+          base.extend ClassMethods
+          base.extend ModuleMethods unless base.kind_of?(Class)
+          
+          ClassMethods.initialize(base)
           super
         end
       end
-    
+      
       extend ModuleMethods
-    
-      attr_reader :user_dir
-      attr_reader :method_dir
-    
+      
       def setup
         super
-        @user_dir   = Dir.pwd
-        @method_dir = File.expand_path(method_name, self.class.class_dir)
-      
-        cleanup method_dir
-        FileUtils.mkdir_p method_dir
-        Dir.chdir method_dir
+        cleanup
       end
-    
-      def teardown
-        Dir.chdir user_dir
       
+      def teardown
+        Dir.chdir(user_dir)
+        
         unless ENV["KEEP_OUTPUTS"] == "true"
-          cleanup class_dir
+          cleanup
+          
+          dir = method_dir
+          while dir != class_dir
+            dir = File.dirname(dir)
+            Dir.rmdir(dir)
+          end rescue(SystemCallError)
         end
-      
+        
         super
       end
-    
-      def cleanup(dir)
-        FileUtils.rm_r(dir) if File.exists?(dir)
+      
+      def user_dir
+        @user_dir   ||= File.expand_path('.')
       end
-    
+      
+      def class_dir
+        @class_dir  ||= File.expand_path(self.class.class_dir, user_dir)
+      end
+      
+      def method_dir
+        @method_dir ||= File.expand_path(method_name.to_s, class_dir)
+      end
+      
+      def cleanup_methods
+        self.class.cleanup_methods
+      end
+      
+      def cleanup
+        if cleanup_paths = cleanup_methods[method_name.to_sym]
+          cleanup_paths.each {|relative_path| remove(relative_path) }
+        end
+      end
+      
       def path(relative_path)
-        File.expand_path(relative_path, method_dir)
+        path = File.expand_path(relative_path, method_dir)
+        
+        unless path.index(method_dir) == 0
+          raise "does not make a path relative to method_dir: #{relative_path.inspect}"
+        end
+        
+        path
       end
       
-      def prepare(relative_path)
+      def prepare(relative_path, content=nil, &block)
         target = path(relative_path)
         
-        target_dir = File.dirname(target)
-        FileUtils.mkdir_p(target_dir) unless File.exists?(target_dir)
+        if File.exists?(target)
+          FileUtils.rm(target)
+        else
+          target_dir = File.dirname(target)
+          FileUtils.mkdir_p(target_dir) unless File.exists?(target_dir)
+        end
+        
+        FileUtils.touch(target)
+        File.open(target, 'w') {|io| io << content } if content
+        File.open(target, 'a', &block) if block
         
         target
       end
       
-      def file(relative_path, &block)
-        target = prepare(relative_path)
-        block ? File.open(target, 'w', &block) : FileUtils.touch(target)
-        target
-      end
-    
-      def class_dir
-        self.class.class_dir
+      def remove(relative_path)
+        full_path = path(relative_path)
+        FileUtils.rm_r(full_path) if File.exists?(full_path)
       end
     end
   end