sitefuel 0.0.0a

data/test/test_AbstractExternalProgram.rb

@@ -0,0 +1,186 @@
+#
+# File::         test_AbstractExternalProgram.rb
+# Author::       wkm
+# Copyright::    2009
+# License::      GPL
+#
+# Unit tests for the AbstractExternalProgram wrapper.
+#
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+
+require 'sitefuel/external/AbstractExternalProgram'
+
+include SiteFuel::External
+
+# a wrapper around a generic program
+class BashProgram < AbstractExternalProgram
+  def self.program_name
+    'bash'
+  end
+end
+
+# a wrapper around a program which hopefully doesn't exist ;)
+class BadProgram < AbstractExternalProgram
+  def self.program_name
+    'foo183127cowsaydog'
+  end
+end
+
+class TestProgramA < AbstractExternalProgram
+  def self.program_name
+    './test/test_programs/versioning.rb'
+  end
+
+  def self.compatible_versions
+    '> 0.1'
+  end
+end
+
+class TestProgramB < TestProgramA
+  def self.option_version
+    '--version-2'
+  end
+
+  def self.compatible_versions
+    '> 0.1.2'
+  end
+end
+
+class TestProgramC < TestProgramA
+  def self.option_version
+    '--version-3'
+  end
+
+  def self.compatible_versions
+    '> 0.1.5'
+  end
+end
+
+class TestProgramD < TestProgramA
+  def self.option_version
+    '--version-4'
+  end
+
+  def self.compatible_versions
+    '> 0.5.2'
+  end
+end
+
+class TestExternalProgram < Test::Unit::TestCase
+
+  def test_program_finding
+    assert BashProgram.program_found?
+    assert_equal false, BadProgram.program_found?
+
+    assert TestProgramA.program_found?, 'Couldn\'t find test program "versioning.rb"'
+  end
+
+  def test_getting_program_version
+
+    # no real point testing against the bash version, who knows
+    # what they're running; just make sure we can get a version
+    assert_not_nil BashProgram.program_version
+
+    assert_equal '0.1.2', TestProgramA.program_version
+    assert_equal '0.1.2asdad', TestProgramB.program_version
+    assert_equal '0.2', TestProgramC.program_version
+    assert_equal '0.1.2', TestProgramD.program_version
+
+  end
+
+  def test_compatible_version
+    assert TestProgramA.compatible_version?
+    assert TestProgramB.compatible_version?
+    assert TestProgramC.compatible_version?
+    assert_equal false, TestProgramD.compatible_version?
+  end
+
+  def test_version_less?
+
+    # practical tests
+    assert AbstractExternalProgram.version_older?('1.5', '1.5')
+
+    assert AbstractExternalProgram.version_older?('1.5', '1.5.10')
+
+    assert !AbstractExternalProgram.version_older?('1.5', '1.4')
+
+    assert AbstractExternalProgram.version_older?('1.5', '1.5a')
+    assert AbstractExternalProgram.version_older?('1.5', '1.5A')
+    assert AbstractExternalProgram.version_older?('1.5', '1.5.a')
+    assert AbstractExternalProgram.version_older?('1.5', '1.5.A')
+
+    assert AbstractExternalProgram.version_older?('1.5', '1.51')
+    assert AbstractExternalProgram.version_older?('1.5', '1.5.1')
+    assert AbstractExternalProgram.version_older?('1.5', '1.5.0')
+
+    assert AbstractExternalProgram.version_older?('1.5', '2')
+    assert AbstractExternalProgram.version_older?('1.5', '2.0')
+    assert AbstractExternalProgram.version_older?('1.5', '2.1')
+    assert AbstractExternalProgram.version_older?('1.5', '5.1.5')
+
+    assert AbstractExternalProgram.version_older?('1.5.2', '1.5.2')
+    assert AbstractExternalProgram.version_older?('1.5.2', '1.5.3')
+    assert AbstractExternalProgram.version_older?('1.5.2', '1.5.2')
+    assert AbstractExternalProgram.version_older?('1.5.2', '1.6')
+    assert AbstractExternalProgram.version_older?('1.5.2', '2')
+
+    assert !AbstractExternalProgram.version_older?('1.5.2', '1.5')
+    
+    assert !AbstractExternalProgram.version_older?('1a', '1')
+  end
+
+  def test_test_version_number
+    assert AbstractExternalProgram.test_version_number('> 1.5', '1.5')
+    assert AbstractExternalProgram.test_version_number('> 1.5', '1.5.10')
+    
+    assert AbstractExternalProgram.test_version_number(['> 1.5'], '1.5.10')
+  end
+
+  def test_option_organizing
+    assert_equal [], AbstractExternalProgram.organize_options()
+    assert_equal [[:a],[:b],[:c]], AbstractExternalProgram.organize_options(:a, :b, :c)
+    assert_equal(
+            [[:a], [:b, 'val'], [:c]],
+            AbstractExternalProgram.organize_options(:a,
+                                                     :b, 'val',
+                                                     :c)
+    )
+
+    assert_equal(
+            [[:a, 'val1'], [:b, 'val2'], [:c, 'val3']],
+            AbstractExternalProgram.organize_options(:a, 'val1',
+                                                     :b, 'val2',
+                                                     :c, 'val3')
+    )
+
+    assert_equal(
+            [[:a, 'val1', 'val2']],
+            AbstractExternalProgram.organize_options(:a, 'val1', 'val2')
+    )
+  end
+
+
+  def test_option_creation
+    # here we want to test the sanity checks that are preformed when an option
+    # is created
+
+    # if there is a default there must be ${value} slot
+    assert_raises NoOptionValueSlot do
+      TestProgramA.option(:option1, '--someflag', 'defaultvalue')
+    end
+
+    # make sure the option wasn't added
+    assert !TestProgramA.options.include?(:option1)
+
+    # if there is a ${value} slot and no default, the option must
+    # have a value when it's being set
+    assert_nothing_raised { TestProgramA.option(:optionNoDef, '--someopt ${value}') }
+    assert_raises NoValueForOption do
+      TestProgramA.execute(:optionNoDef)
+    end
+  end
+  
+end

data/test/test_AbstractProcessor.rb

@@ -0,0 +1,237 @@
+#
+# File::       test_AbstractProcessor.rb
+# Author::     wkm
+# Copyright::  2009
+# License::    GPL
+#
+# Unit tests for the AbstractProcessor
+#
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'sitefuel/SiteFuelLogger'
+require 'sitefuel/processors/AbstractProcessor'
+
+require 'sitefuel/extensions/SymbolComparison'
+
+include SiteFuel
+include SiteFuel::Processor
+
+class TestAProcessor < AbstractProcessor
+  def filter_a; end
+  def filter_b; end
+  def filter_c; end
+  def filter_long_name; end
+
+  def self.file_patterns
+    [".testA", ".test-a", ".test.a", "_test_a"]
+  end
+
+  def self.default_filterset
+    :normal
+  end
+
+  def self.filterset_normal
+    [:a, :b]
+  end
+
+  def self.filterset_heavy
+    [:a, :b, :c]
+  end
+
+  def self.filterset_light
+    [:a]
+  end
+end
+
+class TestBProcessor < AbstractProcessor
+  def self.file_patterns
+    [/tpb.*fitz/, ".tpb"]
+  end
+end
+
+class TestAbstractProcessor < Test::Unit::TestCase
+
+  def test_filters
+    assert_equal [:a, :b, :c, :long_name], TestAProcessor.filters
+
+    ta = TestAProcessor.new
+    assert_nil ta.run_filter(:a)
+    assert_nil ta.run_filter(:b)
+    assert_nil ta.run_filter(:long_name)
+
+    assert_raise UnknownFilter do
+      ta.run_filter(:foo)
+    end
+
+    assert_equal [], TestBProcessor.filters
+  end
+
+  def test_file_patterns_01
+    assert TestAProcessor.processes_file?(".testA")
+    assert TestAProcessor.processes_file?(".test-a")
+    assert TestAProcessor.processes_file?(".test.a")
+    assert TestAProcessor.processes_file?("_test_a")
+
+    assert TestAProcessor.processes_file?("foo.testA")
+    assert TestAProcessor.processes_file?("foo.testa")
+    assert TestAProcessor.processes_file?("foo.test-a")
+    assert TestAProcessor.processes_file?("foo.test.a")
+    assert TestAProcessor.processes_file?("foo_test_a")
+
+    assert_equal false, TestAProcessor.processes_file?("footestA")
+    assert_equal false, TestAProcessor.processes_file?(":")
+    assert_equal false, TestAProcessor.processes_file?("testA")
+    assert_equal false, TestAProcessor.processes_file?("XtestA")
+    assert_equal false, TestAProcessor.processes_file?("XtestXA")
+  end
+
+  def test_file_patterns_02
+    # file extension tests
+    assert TestBProcessor.processes_file?("test.tpb")
+    assert TestBProcessor.processes_file?("foo.tpb")
+
+    # regexp file name test
+    assert TestBProcessor.processes_file?("tpb.foofoofitz")
+    assert_equal false, TestBProcessor.processes_file?("TPB.foofoofitz")
+  end
+
+  def test_processor_names
+    assert_equal "TestA", TestAProcessor.processor_name
+    assert_equal "TestB", TestBProcessor.processor_name
+  end
+
+  def test_processor_logging
+    log = SiteFuelLogger.instance
+    proc = TestAProcessor.new
+
+    log.level = Logger::UNKNOWN
+
+    # test fatal messages
+    fatal = log.fatal_count
+    proc.fatal 'Fatal error: fatal errors don\'t cause program halt.'
+    assert_equal fatal+1, log.fatal_count
+
+    # test error messages
+    error = log.error_count
+    proc.error 'Error: brain malfunction: cannot find Creativity.'
+    assert_equal error+1, log.error_count
+
+    # test warning messages
+    warn = log.warn_count
+    proc.warn 'Warning: impending doom...!'
+    assert_equal warn+1, log.warn_count
+
+    # test info messages
+    info = log.info_count
+    proc.info 'It\'s 77oC outside.'
+    assert_equal info+1, log.info_count
+
+    # test debugging messages
+    debug = log.debug_count
+    proc.debug 'testing the value of "i" :P'
+    assert_equal debug+1, log.debug_count
+  end
+
+  # filter set testing
+  def test_filtersets
+    assert_equal [:heavy, :light, :normal, :ignore].sort, TestAProcessor.filtersets.sort
+    assert_equal :normal, TestAProcessor.default_filterset
+
+    assert_equal [:a,:b], TestAProcessor.filters_in_filterset(:normal)
+    assert_equal [:a,:b,:c], TestAProcessor.filters_in_filterset(:heavy)
+    assert_equal [:a], TestAProcessor.filters_in_filterset(:light)
+  end
+
+  # execution list testing
+  def test_execution_list
+    a = TestAProcessor.new
+
+    # with normal filters
+    assert_equal [:b], a.add_filter(:b)
+    assert_equal [:b, :a], a.add_filter(:a)
+    assert_equal [:b, :a], a.execution_list
+
+    assert_equal [:b, :a, :c], a.add_filter(:c)
+    assert_equal [:b, :a, :c], a.execution_list
+
+    assert_equal [:a, :c], a.drop_filter(:b)
+    assert_equal [:c], a.drop_filter(:a)
+    assert_equal [], a.drop_filter(:c)
+
+    assert_equal [:c], a.add_filter(:c)
+    assert_equal [:c, :b], a.add_filter(:b)
+
+    assert_equal [], a.clear_filters
+    assert_equal [], a.execution_list
+
+
+    # test filter sets
+    assert_equal [:a,:b], a.add_filterset(:normal)
+    assert_equal [], a.clear_filters
+    assert_equal [], a.execution_list
+
+    assert_equal [:a,:b,:c], a.add_filterset(:heavy)
+    assert_equal [], a.clear_filters
+    assert_equal [], a.execution_list
+
+    # test filters *and* filter sets
+    assert_equal [:c], a.add_filter(:c)
+    assert_equal [:c, :a], a.add_filterset(:light)
+    assert_equal [], a.clear_filters
+    assert_equal [], a.execution_list
+
+    assert_equal [:a,:b], a.add_filterset(:normal)
+    assert_equal [:a,:b,:c], a.add_filter(:c)
+    assert_equal [], a.clear_filters
+    assert_equal [], a.execution_list
+  end
+
+  # configuration testing
+  def test_config_filters
+    a = TestAProcessor.new
+
+    a.configure({:filters => :a})
+    assert_equal [:a], a.execution_list
+
+    # test that filters are cleared before being set
+    a.configure({:filters => :b})
+    assert_equal [:b], a.execution_list
+
+    # test that filters aren't changed if they're not set
+#    a.configure({})
+#    assert_equal [:b], a.execution_list
+
+    a.configure({:filters => [:a]})
+    assert_equal [:a], a.execution_list
+
+    a.configure({:filters => [:a, :b]})
+    assert_equal [:a,:b], a.execution_list
+
+    a.configure({:filtersets => [:light]})
+    assert_equal [:a], a.execution_list
+
+    a.configure({:filtersets => :normal})
+    assert_equal [:a,:b], a.execution_list
+
+    # note: since we're doing #each_pair on a hash, order is not guaranteed,
+    # hence the #sort
+    a.configure({:filters => [:c], :filtersets => :light})
+    assert_equal [:c,:a].sort, a.execution_list.sort
+
+    a.configure({:filtersets => :ignore})
+    assert_equal [], a.execution_list
+  end
+
+  def test_config_resource_name
+    a = TestAProcessor.new
+    a.configure :resource_name => 'foo.file'
+    assert_equal 'foo.file', a.resource_name
+  end
+
+  # test attempts to add unknown filters/filtersets
+  def test_config_filters_negative
+
+  end
+end

data/test/test_AbstractStringBasedProcessor.rb

@@ -0,0 +1,48 @@
+#
+# File::      test_AbstractStringBasedProcessor.rb
+# Author::    wkm
+# Copyright:: 2009
+# License::   GPL
+#
+# Unit tests for the string-based processor abstraction
+#
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+require 'tempfile'
+require 'sitefuel/processors/AbstractStringBasedProcessor'
+
+include SiteFuel::Processor
+
+class StringProc1 < AbstractStringBasedProcessor
+  def self.default_filterset
+    :typical
+  end
+
+  def self.filterset_typical
+    [:test]
+  end
+
+  def filter_test
+    @document = @document.gsub('hello', 'goodbye')
+  end
+
+end
+
+class TestAbstractStringBasedProcessor < Test::Unit::TestCase
+  def test_processor_type
+    assert 'String', StringProc1.processor_type
+  end
+
+  def test_process_file
+    # create a test file to process
+    tf = Tempfile.new('abstract-string-based-processor.txt')
+    File.open(tf.path, 'w') do |f|
+      f.write('hello world')
+    end
+
+    proc = StringProc1.process_file(tf.path)
+    assert_equal 'goodbye world', proc.document
+  end
+end

data/test/test_AllProcessors.rb

@@ -0,0 +1,65 @@
+#
+# File::       test_AllProcessors.rb
+# Author::     wkm
+# Copyright::  2009
+# License::    GPL
+#
+# Programmatic tests run against all processors
+#
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'sitefuel/SiteFuelRuntime'
+require 'sitefuel/processors/AbstractStringBasedProcessor'
+
+include SiteFuel
+
+class TestAllProcessors < Test::Unit::TestCase
+
+  def setup
+    SiteFuelRuntime.load_processors
+    @processors = SiteFuelRuntime.
+            find_processors.
+            delete_if do |proc|
+              proc.to_s =~ /.*Test.*Processor/
+            end
+
+    @string_processors = Processor::AbstractStringBasedProcessor.
+            find_processors.
+            delete_if do |proc|
+              proc.to_s =~ /.*Test.*Processor/
+            end
+  end
+
+  # ensure that every filter in every filter set is known
+  def test_filter_sets
+    @processors.each do |proc|
+      proc.filtersets.each do |filterset|
+        proc.filters_in_filterset(filterset).each do |filter|
+          assert(
+            proc.filter?(filter),
+            'Filter %s in filterset %s isn\'t known for %s' %
+            [filter, filterset, proc]
+          )
+        end
+      end
+    end
+  end
+
+  # test that every processor has a default filterset
+  def test_default_filter_sets
+    @processors.each do |proc|
+      assert proc.filterset?(proc.default_filterset), 'Default filterset %s for %s isn\'t known'%[proc.default_filterset, proc]
+    end
+  end
+
+  # test that every string based processor's filters can handle the empty string
+  def test_string_based_empty_string
+    @string_processors.each do |proc|
+      proc.filters.each do |filter|
+        assert_nothing_raised { proc.filter_string(filter, '') }
+      end
+    end
+  end
+end

data/test/test_ArrayComparisons.rb

@@ -0,0 +1,32 @@
+#
+# File::       test_ArrayComparisons.rb
+# Author::     wkm
+# Copyright::  2009
+# License::    GPL
+#
+# Unit tests for the Array#ends_with? method.
+#
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'sitefuel/extensions/ArrayComparisons'
+
+class TestArrayComparisons < Test::Unit::TestCase
+  def test_ends_with
+
+    # positive tests
+    assert [1, 2, 3].ends_with?([2,3])
+    assert [1, 2, 3].ends_with?([])
+    assert [1, 2, 3].ends_with?([1, 2, 3])
+
+    assert [].ends_with?([])
+    assert [1].ends_with?([1])
+
+    # negative tests
+    assert ![1, 2, 3].ends_with?([1, 2])
+    assert ![].ends_with?([1])
+    assert ![1, 2, 3].ends_with?([1, 2, 3, 4])
+    
+  end
+end

data/test/test_CSSProcessor.rb

@@ -0,0 +1,120 @@
+#
+# File::       test_CSSProcessor.rb
+# Author::     wkm
+# Copyright::  2009
+# License::    GPL
+#
+# Unit tests for the CSSProcessor
+#
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'sitefuel/processors/CSSProcessor'
+require 'sitefuel/extensions/StringFormatting'
+
+include SiteFuel::Processor
+
+class TestCSSProcessor < Test::Unit::TestCase
+  def test_file_extensions
+    
+    # negative tests
+    assert_equal false, CSSProcessor.processes_file?("testcss")
+    assert_equal false, CSSProcessor.processes_file?("test.css.foo")
+
+    # positive tests
+    assert CSSProcessor.processes_file?("test.css")
+    assert CSSProcessor.processes_file?("test.CSS")
+    assert CSSProcessor.processes_file?("test.CsS")
+  end
+
+  def test_name
+    assert_equal "CSS", CSSProcessor.processor_name
+  end
+
+  def test_filter_strip_comments
+    assert_equal(
+      "\nbody {\n  margin: 5em; \n//\n}\n",
+      CSSProcessor.filter_string(
+        :strip_comments,
+        %q{
+          // this is a line comment on its own
+          body {
+            margin: 5em; // at the end of a line
+          /* and here
+             is a multi-line comment... */
+          }
+        }.align
+      )
+    )
+  end
+
+  def test_filter_clean_whitespace
+    assert_equal(
+      "body {\n// here's a little line comment. We want to be sure\n// it isn't mashed with the margin stuff below.\nmargin: 5em;\n}\n",
+      CSSProcessor.filter_string(
+        :clean_whitespace,
+        %q{
+          body {
+            // here's a little line comment. We want to be sure
+            // it isn't mashed with the margin stuff below.
+            margin: 5em;
+          }
+        }.align
+      )
+    )
+
+
+    # finally, let's test the strip_comments and clean_whitespace filters
+    # all together. (and incidentally test giving #filter_string an array)
+    assert_equal(
+      "body {\nmargin: 5em;\n}\n",
+      CSSProcessor.filter_string(
+        [:strip_comments, :clean_whitespace],
+        %q{
+          body {
+            // here's a little line comment. We want to be sure
+            // it isn't mashed with the margin stuff below.
+            margin: 5em;
+          }
+        }.align
+      )
+    )
+  end
+
+  # note that minification is based on CSSMin, so it's not too heavily tested
+  def test_minify
+    # test: whitespace removal; hexcode compaction; comment stripping
+    assert_equal(
+      "body{color:#000;}",
+      CSSProcessor.filter_string(
+        :minify,
+        <<-END
+          body {
+            /* comments should be stripped */
+            color: #000000;
+          }
+        END
+      )
+    )
+
+    assert_equal(
+      "h1 .header{color:white;margin:0;font-family:\"lucida grande\",lucida,verdana,sans-serif;}a:hover{text-decoration:none;}",
+      CSSProcessor.filter_string(
+        :minify,
+        <<-END
+          h1 .header
+          {
+            color: white;
+            margin: 0 0 0 0;
+            font-family: "lucida grande", lucida, verdana, sans-serif;
+          }
+
+          a:hover {
+            text-decoration: none;
+          }
+        END
+      )
+    )
+  end
+end