brisk-bills 0.6.0

data/vendor/plugins/active_scaffold/test/data_structures/action_link_test.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ActionLinkTest < Test::Unit::TestCase
+  def setup
+    @link = ActiveScaffold::DataStructures::ActionLink.new('foo')
+  end
+
+  def test_simple_attributes
+    assert_equal 'foo', @link.action
+    @link.action = 'bar'
+    assert_equal 'bar', @link.action
+
+    hash = {:a => :b}
+    @link.parameters = hash
+    assert_equal hash, @link.parameters
+
+    @link.label = 'hello world'
+    assert_equal 'hello world', @link.label
+
+    assert !@link.confirm
+    @link.confirm = true
+    assert @link.confirm
+
+    @link.label = 'Hello World'
+    assert_equal 'hello_world_authorized?', @link.security_method
+    @link.label = 'HelloWorld'
+    assert_equal 'hello_world_authorized?', @link.security_method
+    @link.security_method = 'blueberry_pie'
+    assert_equal 'blueberry_pie', @link.security_method
+
+    @link.type = :table
+    assert_equal :table, @link.type
+    @link.type = :record
+    assert_equal :record, @link.type
+
+    assert_equal :get, @link.method
+    @link.method = :put
+    assert_equal :put, @link.method
+  end
+
+  def test_position
+    @link.position = true
+
+    @link.type = :table
+    assert_equal :top, @link.position
+
+    @link.type = :record
+    assert_equal :replace, @link.position
+
+    @link.position = :before
+    assert_equal :before, @link.position
+
+    @link.position = false
+    assert_equal false, @link.position
+  end
+
+  def test_presentation_style
+    # default
+    assert @link.inline?
+    assert !@link.popup?
+    assert !@link.page?
+
+    @link.popup = true
+    assert !@link.inline?
+    assert @link.popup?
+    assert !@link.page?
+
+    @link.page = true
+    assert !@link.inline?
+    assert !@link.popup?
+    assert @link.page?
+
+    @link.inline = true
+    assert @link.inline?
+    assert !@link.popup?
+    assert !@link.page?
+  end
+end

data/vendor/plugins/active_scaffold/test/data_structures/action_links_test.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ActionLinksTest < Test::Unit::TestCase
+  def setup
+    @links = ActiveScaffold::DataStructures::ActionLinks.new
+  end
+
+  def test_add_and_find
+    # test adding with a shortcut
+    @links.add 'foo/bar'
+
+    assert_equal 1, @links.find_all{true}.size
+    assert_equal 'foo/bar', @links.find_all{true}[0].action
+    assert_equal 'foo/bar', @links['foo/bar'].action
+
+    # test adding an ActionLink object directly
+    @links.add ActiveScaffold::DataStructures::ActionLink.new('hello/world')
+
+    assert_equal 2, @links.find_all{true}.size
+
+    # test the << alias
+    @links << 'a/b'
+
+    assert_equal 3, @links.find_all{true}.size
+  end
+
+  def test_array_access
+    @link1 = ActiveScaffold::DataStructures::ActionLink.new 'foo/bar'
+    @link2 = ActiveScaffold::DataStructures::ActionLink.new 'hello_world'
+
+    @links.add @link1
+    @links.add @link2
+
+    assert_equal @link1, @links[@link1.action]
+    assert_equal @link2, @links[@link2.action]
+  end
+
+  def test_empty
+    assert @links.empty?
+    @links.add 'a'
+    assert !@links.empty?
+  end
+
+  def test_cloning
+    @links.add 'foo/bar'
+    @links_copy = @links.clone
+
+    assert !@links.equal?(@links_copy)
+    assert !@links['foo/bar'].equal?(@links_copy['foo/bar'])
+  end
+
+  def test_each
+    @links.add 'foo', :type => :table
+    @links.add 'bar', :type => :record
+
+    @links.each :table do |link|
+      assert_equal 'foo', link.action
+    end
+    @links.each :record do |link|
+      assert_equal 'bar', link.action
+    end
+  end
+  
+  def test_delete
+    @links.add 'foo'
+    @links.add 'bar'
+
+    @links.delete :foo
+    assert @links['foo'].nil?
+    begin
+      @links.delete :foo
+    @links.delete 'foo'
+    rescue
+      assert false, "deleting from action links when item doesn't exist should not throw an error"
+    end
+    assert !@links['bar'].nil?
+  end
+end

data/vendor/plugins/active_scaffold/test/data_structures/actions_test.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ActionsTest < Test::Unit::TestCase
+  def setup
+    @actions = ActiveScaffold::DataStructures::Actions.new(:a, 'b')
+  end
+
+  def test_initialization
+    assert @actions.include?('a')
+    assert @actions.include?(:b)
+    assert !@actions.include?(:c)
+  end
+
+  def test_exclude
+    assert @actions.include?('b')
+    @actions.exclude :b
+    assert !@actions.include?(:b)
+  end
+
+  def test_add
+    assert !@actions.include?(:c)
+    @actions.add 'c'
+    assert @actions.include?('c')
+  end
+end

data/vendor/plugins/active_scaffold/test/data_structures/association_column_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class AssociationColumnTest < Test::Unit::TestCase
+  def setup
+    @association_column = ActiveScaffold::DataStructures::Column.new('other_model', ModelStub)
+  end
+
+  def test_virtuality
+    assert @association_column.association
+    assert !@association_column.virtual?
+  end
+
+  def test_sorting
+    # sorting on association columns is method-based
+    hash = {:method => "other_model.to_s"}
+    assert_equal hash, @association_column.sort
+  end
+
+  def test_searching
+    # right now, there's no intelligent searching on association columns
+    assert !@association_column.searchable?
+  end
+
+  def test_association
+    assert @association_column.association.is_a?(ActiveRecord::Reflection::AssociationReflection)
+  end
+
+  def test_includes
+    assert_equal [:other_model], @association_column.includes
+  end
+
+  def test_plurality
+    assert @association_column.singular_association?
+    assert !@association_column.plural_association?
+
+    plural_association_column = ActiveScaffold::DataStructures::Column.new('other_models', ModelStub)
+    assert plural_association_column.plural_association?
+    assert !plural_association_column.singular_association?
+  end
+end

data/vendor/plugins/active_scaffold/test/data_structures/column_test.rb

@@ -0,0 +1,161 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class ColumnTest < Test::Unit::TestCase
+  def setup
+    @column = ActiveScaffold::DataStructures::Column.new(:a, ModelStub)
+  end
+
+  def test_column
+    assert @column.column.is_a?(ActiveRecord::ConnectionAdapters::Column)
+    assert @column.column.name == 'a'
+  end
+
+  def test_basic_properties
+    # test that it was set during initialization
+    assert_equal @column.name, :a
+    # test that we can change it
+    @column.name = :b
+    assert_equal @column.name, :b
+
+    # label
+    @column.label = 'foo'
+    assert_equal 'foo', @column.label
+
+    # description
+    @column.description = 'hello world'
+    assert_equal 'hello world', @column.description
+
+    # css class
+    @column.css_class = 'style_me'
+    assert_equal 'style_me', @column.css_class
+
+    # required
+    assert !@column.required?, 'default is false'
+    @column.required = true
+    assert @column.required?, 'can be changed'
+
+    # calculation
+    assert !@column.calculation?, 'default is nil'
+    @column.calculate = :sum
+    assert @column.calculation?, 'can be changed'
+  end
+
+  def test_field
+    assert_equal 'model_stubs.a', @column.send(:field)
+  end
+
+  def test_table
+    assert_equal 'model_stubs', @column.send(:table)
+  end
+
+  def test_equality
+    # create a separate columns object, and make sure it's not ==
+    columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b)
+    assert columns != @column
+
+    # create a separate action_columns object, and make sure it's not ==
+    columns = ActiveScaffold::DataStructures::ActionColumns.new(:a, :b)
+    assert columns != @column
+
+    # identity
+    assert @column == @column
+
+    # string comparison
+    assert @column == 'a'
+    assert @column != 'fake'
+
+    # symbol comparison
+    assert @column == :a
+    assert @column != :fake
+
+    # comparison with different object of same type
+    column2 = ActiveScaffold::DataStructures::Column.new(:fake, ModelStub)
+    assert @column != column2
+    column2.name = 'a'
+    assert @column == column2
+
+    # special comparisons
+    assert @column != nil
+    assert @column != ''
+    assert @column != 0
+  end
+
+  def test_searchable
+    @column.search_sql = nil
+    assert !@column.searchable?
+    @column.search_sql = true
+    assert @column.searchable?
+  end
+
+  def test_sortable
+    @column.sort = nil
+    assert !@column.sortable?
+    @column.sort = true
+    assert @column.sortable?
+  end
+
+  def test_custom_search
+    @column.search_sql = true
+    assert_equal 'model_stubs.a', @column.search_sql
+    @column.search_sql = 'foobar'
+    assert_equal 'foobar', @column.search_sql
+    assert @column.searchable?
+  end
+
+  def test_custom_sort
+    @column.sort = true
+    hash = {:sql => 'model_stubs.a'}
+    assert_equal hash, @column.sort
+    @column.sort_by :sql => 'foobar'
+    hash = {:sql => 'foobar'}
+    assert_equal hash, @column.sort
+
+    some_proc = proc {'foobar'}
+    @column.sort_by :method => some_proc
+    hash = {:method => some_proc}
+    assert_equal hash, @column.sort
+    assert @column.sortable?
+  end
+
+  def test_custom_sort__should_assert_keys
+    assert_raise(ArgumentError) { @column.sort_by :proc => "invalid config"  }
+    assert_raise(ArgumentError) { @column.sort={:proc => "invalid config" } }
+    assert_nothing_raised(ArgumentError) {@column.sort_by :method => "method"  }
+    assert_nothing_raised(ArgumentError) {@column.sort_by :sql => "method"  }
+  end
+  
+  def test_config_block
+    @column.configure do |config|
+      # we can use the config object
+      config.name = 'foo'
+      # or not
+      self.label = 'hello'
+    end
+
+    assert_equal 'foo', @column.name
+    assert_equal 'hello', @column.label
+  end
+
+  def test_action_link
+    link = ActiveScaffold::DataStructures::ActionLink.new('foo/bar')
+    @column.set_link link
+    assert_equal link, @column.link
+
+    @column.set_link 'hello_world'
+    assert_equal 'hello_world', @column.link.action
+    assert_equal @column.label, @column.link.label
+  end
+
+  def test_includes
+    assert_equal [], @column.includes
+    
+    # make sure that when a non-array comes in, an array comes out
+    @column.includes = :column_name
+    assert_equal([:column_name], @column.includes)
+
+    # make sure that when a non-array comes in, an array comes out
+    @column.includes = [:column_name]
+    assert_equal([:column_name], @column.includes)
+  end
+end

data/vendor/plugins/active_scaffold/test/data_structures/columns_test.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class ColumnsTest < Test::Unit::TestCase
+  def setup
+    @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b)
+  end
+
+  def test_initialization
+    assert_equal ModelStub, @columns.active_record_class
+
+    assert @columns.include?('a'), 'checking via string'
+    assert @columns.include?(:b), 'checking via symbol'
+    assert !@columns.include?(:c)
+  end
+
+  def test_add
+    assert !@columns.include?(:c)
+    @columns.add 'c'
+    assert @columns.include?('c')
+
+    # test the alias
+    assert !@columns.include?(:d)
+    @columns << :d
+    assert @columns.include?(:d)
+
+    # try adding an array of columns
+    assert !@columns.include?(:f)
+    @columns.add [:f, :g]
+    assert @columns.include?(:f)
+    assert @columns.include?(:g)
+  end
+
+  def test_finders
+    # test some basic assumptions before testing the finders
+    assert @columns.include?(:a)
+    assert @columns[:a].is_a?(ActiveScaffold::DataStructures::Column)
+
+    # test the single finders
+    assert @columns.find_by_name(:a).name == :a
+    assert @columns[:b].name == :b
+
+    # test the collection finders
+    found = @columns.find_by_names(:a, :b)
+    assert found.any? {|c| c.name == :a}
+    assert found.any? {|c| c.name == :b}
+  end
+
+  def test_each
+    @columns.each do |column|
+      assert [:a, :b].include?(column.name)
+    end
+  end
+
+  def test_block_config
+    assert !@columns.include?(:d)
+    assert !@columns.include?(:c)
+
+    @columns.configure do |config|
+      # test that we can use the config object
+      config << :d
+      # but test that we don't have to
+      add 'c'
+    end
+
+    assert @columns.include?(:d)
+    assert @columns.include?(:c)
+  end
+end