user-choices 1.1.0

data/test/source-tests.rb

@@ -0,0 +1,442 @@
+load "set-standalone-test-paths.rb" unless $started_from_rakefile
+require 'test/unit'
+require 's4t-utils'
+require 'builder'
+require 'user-choices'
+include S4tUtils
+require 'extensions/string'
+
+
+# The general contract of these objects.
+class TestAbstractSource < Test::Unit::TestCase
+  include UserChoices
+  
+  class SubHash < UserChoices::AbstractSource
+
+    # New never takes arguments. Class-specific initialization is done
+    # with an appropriately-named method.
+    # 
+    # That method must return self and set up the external_name hash 
+    # so that all symbols handled by this object can be given an external
+    # name.
+    def only_symbol(symbol, external_name, value)
+      @external_names[symbol] = external_name
+      @symbol = symbol
+      @value = value
+      self
+    end
+    
+    # After fill(), values have been read, but not checked.
+    def fill; self[@symbol] = @value; end
+    
+    def source; "the test hash"; end
+    
+  end
+
+  def test_specific_initializer_notes_external_names
+    sh = SubHash.new.only_symbol(:sym, "name", "val")
+    assert_equal('name', sh.external_names[:sym])
+  end
+
+  def test_filling_sets_values
+    sh = SubHash.new.only_symbol(:sym, "name", "val")
+    sh.fill
+    assert_equal('val', sh[:sym])
+  end
+  
+  def test_will_do_conversion_when_told
+    sh = SubHash.new.only_symbol(:sym, "name", "1")
+    sh.fill
+    
+    conversions = { :sym => [Conversion.for(:integer)] }
+    sh.apply(conversions)
+    assert_equal(1, sh[:sym])
+  end
+  
+  # Checking - really just want to know that the error message comes out right.
+  
+  def test_will_do_integer_error_checking_when_told
+    sh = SubHash.new.only_symbol(:sym, "name", "val")
+    sh.fill
+
+    conversions = { :sym => [Conversion.for(:integer)] }
+    assert_raises_with_matching_message(StandardError,
+            /^Error in the test hash: name's value must be an integer, and 'val' doesn't look right/) {
+      sh.apply(conversions)
+    }
+  end
+  
+
+  def test_will_do_boolean_error_checking_when_told
+    sh = SubHash.new.only_symbol(:sym, "name", "val")
+    sh.fill
+
+    conversions = { :sym => [Conversion.for(:boolean)] }
+    assert_raises_with_matching_message(StandardError,
+            /^Error in the test hash: name's value must be a boolean, and 'val' doesn't look right/) {
+      sh.apply(conversions)
+    }
+  end
+  
+
+  def test_will_do_alternative_error_checking_when_told
+    sh = SubHash.new.only_symbol(:sym, "name", "val")
+    sh.fill
+
+    conversions = { :sym => [Conversion.for(["foo", "bar"])] }
+    assert_raises_with_matching_message(StandardError,
+            /^Error in the test hash: name's value must be one of 'foo' or 'bar', and 'val' doesn't look right/) {
+      sh.apply(conversions)
+    }
+  end
+  
+
+  def test_will_do_exact_length_checking_when_told
+    sh = SubHash.new.only_symbol(:sym, "name", ["one", "two"])
+    sh.fill
+
+    conversions = { :sym => [Conversion.for([:string]),  # actually not needed.
+                             Conversion.for(:length => 5)] }
+    assert_raises_with_matching_message(StandardError,
+            /^Error in the test hash: name's value must be of length 5, and \["one", "two"\] doesn't look right/) {
+      sh.apply(conversions)
+    }
+  end
+  
+
+  def test_will_do_range_length_checking_when_told
+    sh = SubHash.new.only_symbol(:sym, "name", ["one", "two"])
+    sh.fill
+
+    conversions = { :sym => [Conversion.for([:string]),  # actually not needed.
+                             Conversion.for(:length => 3..5)] }
+    assert_raises_with_matching_message(StandardError,
+            /^Error in the test hash: name's value must be a list whose length is in this range: 3..5, and \["one", "two"\] doesn't look right/) {
+      sh.apply(conversions)
+    }
+  end
+  
+
+
+  def test_it_is_ok_for_key_not_to_appear
+    sh = SubHash.new.only_symbol(:sym, "name", "val")
+    sh.fill
+
+    conversions = { :another => [Conversion.for(:integer)] }
+    sh.apply(conversions)
+    assert_equal('val', sh[:sym])
+    assert_equal(nil, sh[:another])
+  end
+
+end
+
+class DefaultSourceTest < Test::Unit::TestCase
+  include UserChoices
+  
+  def setup
+    @choices = DefaultSource.new.use_hash(:a => 'a')
+    @choices.fill
+  end
+
+  def test_default_values_are_created_with_key_not_string
+    assert_equal(1, @choices.size)
+    assert_equal('a', @choices[:a])
+    assert_equal(':a', @choices.external_names[:a])
+  end
+
+  def test_nil_is_default_default
+    assert_nil(@choices[:foo])
+  end
+
+
+  def test_error_message_will_look_good
+    assert_raises_with_matching_message(StandardError,
+            /^Error in the default values: :a's value/) {
+      @choices.apply( :a => [Conversion.for(:integer)])
+    }
+  end
+
+  def test_value_conversions_are_from_strings
+    c = DefaultSource.new.use_hash(:a => '5')
+    c.fill
+    
+    c.apply(:a => [Conversion.for(:integer)])
+    assert_equal(5, c[:a])
+  end
+
+end
+
+class EnvironmentSourceTest < Test::Unit::TestCase
+  include UserChoices
+
+  def test_the_environment_args_of_interest_can_be_described_by_prefix
+    with_environment_vars('amazon_option' => "1") do
+      choices = EnvironmentSource.new.with_prefix('amazon_')
+      choices.fill
+      assert_true(choices.has_key?(:option))
+      assert_equal('1', choices[:option])
+    end
+  end
+
+  def test_the_environment_args_can_use_empty_string_as_the_prefix
+    # Though it's a silly thing to do.
+    with_environment_vars('amazon_option' => "1") do
+      choices = EnvironmentSource.new.with_prefix('')
+      choices.fill
+      assert_true(choices.has_key?(:amazon_option))
+      assert_equal('1', choices[:amazon_option])
+    end
+  end
+
+  def test_the_environment_args_of_interest_can_be_listed_explicitly
+    with_environment_vars('amazon_option' => "1",
+                          'root' => 'ok',
+                          '~' => 'ok, too') do
+      choices = EnvironmentSource.new.mapping(:option => 'amazon_option',
+                                               :root => 'root',
+                                               :home => '~')
+      choices.fill
+      assert_equal(3, choices.size)
+      assert_equal('1', choices[:option])
+      assert_equal('ok', choices[:root])
+      assert_equal('ok, too', choices[:home])
+    end
+  end
+  
+  def test_can_also_combine_both_forms
+    with_environment_vars('amazon_o' => "1",
+                          'other_option' => 'still found') do
+      choices = EnvironmentSource.new.with_prefix('amazon_').mapping(:other => 'other_option')
+      choices.fill
+
+      assert_equal(2, choices.size)
+      assert_equal('1', choices[:o])
+      assert_equal('still found', choices[:other])
+    end
+  end
+  
+  def test_the_order_of_combination_does_not_matter
+    with_environment_vars('amazon_o' => "1",
+                          'other_option' => 'still found') do
+      choices = EnvironmentSource.new.mapping(:other => 'other_option').with_prefix('amazon_')
+      choices.fill
+
+      assert_equal(2, choices.size)
+      assert_equal('1', choices[:o])
+      assert_equal('still found', choices[:other])
+    end
+  end
+  
+  def test_unmentioned_environment_vars_are_ignored
+    with_environment_vars('unfound' => "1") do
+      choices = EnvironmentSource.new.with_prefix("my_")
+      choices.fill
+      assert_true(choices.empty?)
+    end
+  end
+
+  def test_nil_is_default
+    with_environment_vars('found' => "1") do
+      choices = EnvironmentSource.new.mapping(:option => 'f')
+      choices.fill
+      assert_nil(choices[:foo])
+      assert_nil(choices[:option]) # for fun
+    end
+  end
+
+  def test_value_checking_is_set_up_properly
+    with_environment_vars('amazon_option' => "1") do
+      assert_raises_with_matching_message(StandardError,
+            /^Error in the environment: amazon_option's value/) {
+        choices = EnvironmentSource.new.with_prefix('amazon_')
+        choices.fill
+        choices.apply(:option => [Conversion.for(:boolean)])
+      }
+    end
+  end
+
+  def test_value_conversion_is_set_up_properly
+    with_environment_vars('a' => "1", 'names' => 'foo,bar') do
+      choices = EnvironmentSource.new.mapping(:a => 'a', :names => 'names')
+      choices.fill
+      choices.apply(:a => [Conversion.for(:integer)], 
+                    :names => [Conversion.for([:string])])
+      assert_equal(1, choices[:a])
+      assert_equal(['foo', 'bar'], choices[:names])
+    end
+  end
+
+
+end
+
+# Common behavior for all config files. Using XML as an example.
+class FileSourceTestCase < Test::Unit::TestCase
+  include UserChoices
+  
+  def setup
+    builder = Builder::XmlMarkup.new(:indent => 2)
+    @some_xml = builder.config {
+      builder.reverse("true")
+      builder.maximum("53")
+      builder.host('a.com')
+      builder.host('b.com')
+    }
+  end
+  
+
+  def test_config_file_need_not_exist
+    assert_false(File.exist?(".amazonrc"))
+    choices = XmlConfigFileSource.new.from_file(".amazonrc")
+
+    assert_true(choices.empty?)
+  end
+
+
+  def test_config_file_value_checking_is_set_up_properly
+    with_local_config_file(".amazonrc", @some_xml) do
+      assert_raises_with_matching_message(StandardError,
+           %r{Error in configuration file ./.amazonrc: maximum's value.*'low'.*'high'}) {
+        choices = XmlConfigFileSource.new.from_file(".amazonrc")
+        choices.fill
+        choices.apply(:maximum => [Conversion.for(['low', 'high'])])
+      }
+    end
+  end
+
+
+  def test_value_conversions_are_set_up_properly
+    with_local_config_file('.amazonrc', @some_xml) do
+      choices = XmlConfigFileSource.new.from_file('.amazonrc')
+      choices.fill
+      choices.apply(:maximum => [Conversion.for(:integer)])
+      assert_equal(53, choices[:maximum])
+    end
+  end
+
+
+
+  def test_unmentioned_values_are_nil
+    with_local_config_file('.amazonrc', @some_xml) do
+      choices = XmlConfigFileSource.new.from_file('.amazonrc')
+      choices.fill
+      assert_nil(choices[:unmentioned])
+    end
+  end
+
+  def test_dashed_choice_names_are_underscored
+    with_local_config_file('.amazonrc', "<config><the-name>5</the-name></config>") do
+      choices = XmlConfigFileSource.new.from_file('.amazonrc')
+      choices.fill
+      assert_equal('5', choices[:the_name])
+    end
+  end
+
+  
+end
+
+
+
+class XmlConfigFileSourceTestCase < Test::Unit::TestCase
+  include UserChoices
+
+  def setup
+    builder = Builder::XmlMarkup.new(:indent => 2)
+    @some_xml = builder.config {
+      builder.reverse("true")
+      builder.maximum("53")
+      builder.host('a.com')
+      builder.host('b.com')
+    }
+  end
+    
+  def test_xml_config_file_normal_use
+    with_local_config_file('.amazonrc', @some_xml) {
+      choices = XmlConfigFileSource.new.from_file(".amazonrc")
+      choices.fill
+      choices.apply(:reverse => [Conversion.for(:boolean)],
+                    :maximum => [Conversion.for(:integer)])
+
+      assert_equal(3, choices.size)
+      assert_equal(true, choices[:reverse])
+      assert_equal(53, choices[:maximum])
+      assert_equal(['a.com', 'b.com'], choices[:host])
+    }
+  end
+
+  def test_config_file_with_bad_xml
+    with_local_config_file('.amazonrc',"<malformed></xml>") {
+      assert_raise_with_matching_message(REXML::ParseException,
+          %r{Badly formatted configuration file ./.amazonrc: .*Missing end tag}) do
+              XmlConfigFileSource.new.from_file(".amazonrc")
+      end
+    }
+  end
+
+
+end
+
+
+class YamlConfigFileSourceTestCase < Test::Unit::TestCase
+  include UserChoices
+
+  def setup
+    @some_yaml = "
+    | ---
+    | reverse: true
+    | maximum: 53
+    | host:
+    |   - a.com
+    |   - b.com
+    | listarg: 1,2, 3
+    ".trim('|')
+  end
+  
+  def test_string_assurance
+    choices = YamlConfigFileSource.new
+    a = [1]
+    choices.ensure_element_is_string(a, 0)
+    assert_equal(["1"], a)
+    
+    h = {'foo' => false }
+    choices.ensure_element_is_string(h, 'foo')
+    assert_equal({'foo' => 'false'}, h)
+    
+    a = [1, 2.0, true, 'already']
+    choices.ensure_array_values_are_strings(a)
+    assert_equal(['1', '2.0', 'true', 'already'], a)
+
+    h = {'1' => '2', 'false' => true, 99 => 100 }
+    choices.ensure_hash_values_are_strings(h)
+    assert_equal({'1' => '2', 'false' => 'true', 99 => '100' }, h)
+
+    h = {'1' => '2', 'false' => [1, true], 99 => {100 => true}}
+    choices.ensure_hash_values_are_strings(h)
+    assert_equal({'1' => '2', 'false' => ['1', 'true'], 99 => {100 => 'true'} }, h)
+  end
+  
+  def test_yaml_config_file_normal_use
+    with_local_config_file('.amazonrc', @some_yaml) {
+      choices = YamlConfigFileSource.new.from_file(".amazonrc")
+      choices.fill
+
+      assert_equal(4, choices.size)
+      assert_equal("true", choices[:reverse])
+      assert_equal("53", choices[:maximum])
+      assert_equal(['a.com', 'b.com'], choices[:host])
+      assert_equal("1,2, 3", choices[:listarg])
+    }
+  end
+
+  def test_config_file_with_bad_yaml
+    with_local_config_file('.amazonrc',"foo:\n\tfred") {
+      assert_raise_with_matching_message(ArgumentError,
+          %r{Badly formatted configuration file ./.amazonrc: .*syntax error}) do
+              pp YamlConfigFileSource.new.from_file(".amazonrc"), 'should never have been reached'
+      end
+    }
+  end
+
+
+
+
+end