brisk-bills 0.6.0

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

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ErrorMessageTest < Test::Unit::TestCase
+  def setup
+    @error = ActiveScaffold::DataStructures::ErrorMessage.new 'foo'
+  end
+
+  def test_attributes
+    assert @error.public_attributes.has_key?(:error)
+    assert_equal 'foo', @error.public_attributes[:error]
+  end
+
+  def test_xml
+    xml = Hash.from_xml(@error.to_xml)
+    assert xml.has_key?('errors')
+    assert xml['errors'].has_key?('error')
+    assert_equal 'foo', xml['errors']['error']
+  end
+
+  def test_yaml
+    yml = nil
+    assert_nothing_raised do
+      yml = YAML.load(@error.to_yaml)
+    end
+    assert yml.has_key?(:error)
+    assert_equal 'foo', yml[:error]
+  end
+end

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

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class SetTest < Test::Unit::TestCase
+  def setup
+    @items = ActiveScaffold::DataStructures::Set.new(:a, :b)
+  end
+
+  def test_initialization
+    assert @items.include?(:a)
+    assert @items.include?(:b)
+    assert !@items.include?(:c)
+  end
+
+  def test_exclude
+    # exclude with a symbol
+    assert @items.include?(:b)
+    @items.exclude :b
+    assert !@items.include?(:b)
+
+    # exclude with a string
+    assert @items.include?(:a)
+    @items.exclude 'a'
+    assert !@items.include?(:a)
+  end
+
+  def test_exclude_array
+    # exclude with a symbol
+    assert @items.include?(:b)
+    @items.exclude [:a, :b]
+    assert !@items.include?(:b)
+    assert !@items.include?(:a)
+  end
+
+  def test_remove
+    assert @items.include?(:a)
+    @items.remove 'a'
+    assert !@items.include?(:a)
+  end
+
+  def test_add
+    # try adding a simple column using a string
+    assert !@items.include?(:c)
+    @items.add 'c'
+    assert @items.include?(:c)
+
+    # try adding a simple column using a symbol
+    assert !@items.include?(:d)
+    @items.add :d
+    assert @items.include?(:d)
+
+    # test that << also adds
+    assert !@items.include?(:e)
+    @items << "e"
+    assert @items.include?(:e)
+
+    # try adding an array of columns
+    assert !@items.include?(:f)
+    @items.add [:f, :g]
+    assert @items.include?(:f)
+    assert @items.include?(:g)
+
+  end
+
+  def test_length
+    assert_equal 2, @items.length
+  end
+
+  def test_block_config
+    @items.configure do |config|
+      # we may use the config argument
+      config.add :c
+      # or we may not
+      exclude :b
+    end
+
+    assert @items.include?(:c)
+    assert !@items.include?(:b)
+  end
+
+  def test_include
+    assert @items.include?(:a)
+    assert @items.include?(:b)
+    assert !@items.include?(:d)
+  end
+end

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

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class SortingTest < Test::Unit::TestCase
+  def setup
+    @columns = ActiveScaffold::DataStructures::Columns.new(ModelStub, :a, :b, :c, :d)
+    @sorting = ActiveScaffold::DataStructures::Sorting.new(@columns)
+  end
+
+  def test_add
+    @sorting.add :a, 'ASC'
+    # test adding by symbol
+    assert @sorting.sorts_on?(:a)
+    # test adding an uppercase string direction
+    assert_equal 'ASC', @sorting.direction_of(:a)
+
+    @sorting.add 'b', :ASC
+    # test adding by string
+    assert @sorting.sorts_on?(:b)
+    # test adding an uppercase symbol direction
+    assert_equal 'ASC', @sorting.direction_of(:b)
+
+    @sorting.add @columns[:c], 'desc'
+    # test adding by object
+    assert @sorting.sorts_on?(:c)
+    # test adding a lowercase string direction
+    assert_equal 'DESC', @sorting.direction_of(:c)
+
+    @sorting << [:d, :desc]
+    # testing adding with the alias
+    assert @sorting.sorts_on?(:d)
+    assert_equal 'DESC', @sorting.direction_of(:d)
+
+    @sorting.clear
+
+    # test adding without a direction (test default)
+    @sorting.add :a
+    assert_equal 'ASC', @sorting.direction_of(:a)
+
+    # test adding a bad column
+    assert_raises ArgumentError do
+      @sorting.add :foo
+    end
+
+    # test adding a bad direction
+    assert_raises ArgumentError do
+      @sorting.add :b, :FOO
+    end
+  end
+
+  def test_set
+    @sorting.add :a, 'ASC'
+    assert @sorting.sorts_on?(:a)
+
+    @sorting.set :b, 'DESC'
+    assert @sorting.instance_variable_get('@clauses').size == 1
+    assert !@sorting.sorts_on?(:a)
+    assert @sorting.sorts_on?(:b)
+    assert_equal 'DESC', @sorting.direction_of(:b)
+  end
+
+  def test_sorts_on
+    @sorting.add :a
+    @sorting.add :b
+
+    assert @sorting.sorts_on?(:a)
+    assert @sorting.sorts_on?(:b)
+    assert !@sorting.sorts_on?(:c)
+  end
+
+  def test_direction_of
+    @sorting.add :a, 'ASC'
+    @sorting.add :b, :DESC
+
+    assert_equal 'ASC', @sorting.direction_of(:a)
+    assert_equal 'DESC', @sorting.direction_of(:b)
+  end
+
+  def test_sorts_by_method
+    @columns[:a].sort_by :method => proc{0}
+
+    #test pure method sorting: true
+    @sorting.add :a
+    assert @sorting.sorts_by_method?
+
+    #test mixed sql/method sorting: raise error
+    assert_raise ArgumentError do
+      @sorting.add :b
+    end
+    
+    #test pure sql sorting: false
+    @sorting.clear
+    @sorting.add :b
+    assert !@sorting.sorts_by_method?
+  end
+end

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

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class ActiveScaffold::DataStructures::Column
+  def h(value)
+    value
+  end
+
+  def format_column(value)
+    value
+  end
+end
+
+class StandardColumnTest < Test::Unit::TestCase
+  def setup
+    @standard_column = ActiveScaffold::DataStructures::Column.new(ModelStub.columns.first.name, ModelStub)
+  end
+
+  def test_virtuality
+    assert @standard_column.column
+    assert !@standard_column.virtual?
+  end
+
+  def test_sorting
+    hash = {:sql => 'model_stubs.a'}
+    assert @standard_column.sortable?
+    assert_equal hash, @standard_column.sort # check default
+  end
+
+  def test_searching
+    assert @standard_column.searchable?
+    assert_equal 'model_stubs.a', @standard_column.search_sql # check default
+  end
+end

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

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+# require 'test/model_stub'
+
+class ActiveScaffold::DataStructures::Column
+  def h(value)
+    value
+  end
+
+  def format_column(value)
+    value
+  end
+end
+
+class VirtualColumnTest < Test::Unit::TestCase
+  def setup
+    @virtual_column = ActiveScaffold::DataStructures::Column.new(:fake, ModelStub)
+  end
+
+  def test_virtuality
+    assert !@virtual_column.column
+    assert !@virtual_column.association
+    assert @virtual_column.virtual?
+  end
+
+  def test_sorting
+    # right now, there's no intelligent sorting on virtual columns
+    assert !@virtual_column.sortable?
+  end
+
+  def test_searching
+    # right now, there's no intelligent searching on virtual columns
+    assert !@virtual_column.searchable?
+  end
+end

data/vendor/plugins/active_scaffold/test/extensions/active_record_test.rb

@@ -0,0 +1,45 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+#require 'test/model_stub'
+
+class ActiveRecordTest < Test::Unit::TestCase
+  def setup
+    @record = ModelStub.new
+  end
+
+  def test_to_label
+    # without anything defined, it'll use the to_s method (e.g. #<ModelStub:0xb7379300>)
+    assert_match /^#<[a-z]+:0x[0-9a-f]+>$/i, @record.to_label
+
+    class << @record
+      def to_s
+        'to_s'
+      end
+    end
+
+    assert_equal 'to_s', @record.to_label
+
+    class << @record
+      def title
+        'title'
+      end
+    end
+
+    assert_equal 'title', @record.to_label
+
+    class << @record
+      def label
+        'label'
+      end
+    end
+
+    assert_equal 'label', @record.to_label
+
+    class << @record
+      def name
+        'name'
+      end
+    end
+
+    assert_equal 'name', @record.to_label
+  end
+end

data/vendor/plugins/active_scaffold/test/extensions/array.rb

@@ -0,0 +1,12 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ArrayTest < Test::Unit::TestCase
+  def test_after
+    @sequence = ['a', 'b', 'c']
+
+    assert_equal 'b', @sequence.after('a')
+    assert_equal 'c', @sequence.after('b')
+    assert_equal 'a', @sequence.after('c')
+    assert_equal nil, @sequence.after('d')
+  end
+end

data/vendor/plugins/active_scaffold/test/misc/active_record_permissions.rb

@@ -0,0 +1,154 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class PermissionModel < ActiveRecord::Base
+  def self.columns; [] end
+
+  def authorized_for_read?; true; end
+  def authorized_for_update?; false; end
+  #def authorized_for_create?; end
+
+  def a1_authorized?; true; end
+  def a2_authorized?; false; end
+  #def a3_authorized?; end
+
+  def b1_authorized?; true; end
+  def b2_authorized?; false; end
+  #def b3_authorized?; end
+
+  def c1_authorized?; true; end
+  def c2_authorized?; false; end
+  #def c3_authorized?; end
+
+  def a3_authorized_for_create?; true; end
+  def b3_authorized_for_create?; false; end
+  #def c3_authorized_for_create?; end
+  def a2_authorized_for_create?; true; end
+  def b2_authorized_for_create?; false; end
+  #def c2_authorized_for_create?; end
+  def a1_authorized_for_create?; true; end
+  def b1_authorized_for_create?; false; end
+  #def c1_authorized_for_create?; end
+
+  def a3_authorized_for_read?; true; end
+  def b3_authorized_for_read?; false; end
+  #def c3_authorized_for_read?; end
+  def a2_authorized_for_read?; true; end
+  def b2_authorized_for_read?; false; end
+  #def c2_authorized_for_read?; end
+  def a1_authorized_for_read?; true; end
+  def b1_authorized_for_read?; false; end
+  #def c1_authorized_for_read?; end
+
+  def a3_authorized_for_update?; true; end
+  def b3_authorized_for_update?; false; end
+  #def c3_authorized_for_update?; end
+  def a2_authorized_for_update?; true; end
+  def b2_authorized_for_update?; false; end
+  #def c2_authorized_for_update?; end
+  def a1_authorized_for_update?; true; end
+  def b1_authorized_for_update?; false; end
+  #def c1_authorized_for_update?; end
+end
+
+class ActiveRecordPermissionsTest < Test::Unit::TestCase
+  def setup
+    @model = PermissionModel.new
+  end
+
+  # Combinations Legend:
+  #   columns are: action method, column method, action/column method
+  #   symbols are: is (a)bsent, returns (f)alse, returns (t)rue, or n/a (_)
+  def test_method_combinations_with_default_true
+    ActiveRecordPermissions.default_permission = true
+
+    pass(@model.authorized_for?(:column => :a3), '_a_')
+    fail(@model.authorized_for?(:column => :a2), '_f_')
+    pass(@model.authorized_for?(:column => :a1), '_t_')
+
+    pass(@model.authorized_for?(:action => :create), 'a__')
+    fail(@model.authorized_for?(:action => :update), 'f__')
+    pass(@model.authorized_for?(:action => :read), 't__')
+
+    pass(@model.authorized_for?(:action => :create, :column => :c3), 'aaa')
+    fail(@model.authorized_for?(:action => :create, :column => :b3), 'aaf')
+    pass(@model.authorized_for?(:action => :create, :column => :a3), 'aat')
+    fail(@model.authorized_for?(:action => :create, :column => :c2), 'afa')
+    fail(@model.authorized_for?(:action => :create, :column => :b2), 'aff')
+    fail(@model.authorized_for?(:action => :create, :column => :a2), 'aft')
+    pass(@model.authorized_for?(:action => :create, :column => :c1), 'ata')
+    fail(@model.authorized_for?(:action => :create, :column => :b1), 'atf')
+    pass(@model.authorized_for?(:action => :create, :column => :a1), 'att')
+
+    fail(@model.authorized_for?(:action => :update, :column => :c3), 'faa')
+    fail(@model.authorized_for?(:action => :update, :column => :b3), 'faf')
+    fail(@model.authorized_for?(:action => :update, :column => :a3), 'fat')
+    fail(@model.authorized_for?(:action => :update, :column => :c2), 'ffa')
+    fail(@model.authorized_for?(:action => :update, :column => :b2), 'fff')
+    fail(@model.authorized_for?(:action => :update, :column => :a2), 'fft')
+    fail(@model.authorized_for?(:action => :update, :column => :c1), 'fta')
+    fail(@model.authorized_for?(:action => :update, :column => :b1), 'ftf')
+    fail(@model.authorized_for?(:action => :update, :column => :a1), 'ftt')
+
+    pass(@model.authorized_for?(:action => :read, :column => :c3), 'taa')
+    fail(@model.authorized_for?(:action => :read, :column => :b3), 'taf')
+    pass(@model.authorized_for?(:action => :read, :column => :a3), 'tat')
+    fail(@model.authorized_for?(:action => :read, :column => :c2), 'tfa')
+    fail(@model.authorized_for?(:action => :read, :column => :b2), 'tff')
+    fail(@model.authorized_for?(:action => :read, :column => :a2), 'tft')
+    pass(@model.authorized_for?(:action => :read, :column => :c1), 'tta')
+    fail(@model.authorized_for?(:action => :read, :column => :b1), 'ttf')
+    pass(@model.authorized_for?(:action => :read, :column => :a1), 'ttt')
+  end
+
+  def test_method_combinations_with_default_false
+    ActiveRecordPermissions.default_permission = false
+
+    fail(@model.authorized_for?(:column => :a3), '_a_')
+    fail(@model.authorized_for?(:column => :a2), '_f_')
+    pass(@model.authorized_for?(:column => :a1), '_t_')
+
+    fail(@model.authorized_for?(:action => :create), 'a__')
+    fail(@model.authorized_for?(:action => :update), 'f__')
+    pass(@model.authorized_for?(:action => :read), 't__')
+
+    fail(@model.authorized_for?(:action => :create, :column => :c3), 'aaa')
+    fail(@model.authorized_for?(:action => :create, :column => :b3), 'aaf')
+    pass(@model.authorized_for?(:action => :create, :column => :a3), 'aat')
+    fail(@model.authorized_for?(:action => :create, :column => :c2), 'afa')
+    fail(@model.authorized_for?(:action => :create, :column => :b2), 'aff')
+    fail(@model.authorized_for?(:action => :create, :column => :a2), 'aft')
+    pass(@model.authorized_for?(:action => :create, :column => :c1), 'ata')
+    fail(@model.authorized_for?(:action => :create, :column => :b1), 'atf')
+    pass(@model.authorized_for?(:action => :create, :column => :a1), 'att')
+
+    fail(@model.authorized_for?(:action => :update, :column => :c3), 'faa')
+    fail(@model.authorized_for?(:action => :update, :column => :b3), 'faf')
+    fail(@model.authorized_for?(:action => :update, :column => :a3), 'fat')
+    fail(@model.authorized_for?(:action => :update, :column => :c2), 'ffa')
+    fail(@model.authorized_for?(:action => :update, :column => :b2), 'fff')
+    fail(@model.authorized_for?(:action => :update, :column => :a2), 'fft')
+    fail(@model.authorized_for?(:action => :update, :column => :c1), 'fta')
+    fail(@model.authorized_for?(:action => :update, :column => :b1), 'ftf')
+    fail(@model.authorized_for?(:action => :update, :column => :a1), 'ftt')
+
+    pass(@model.authorized_for?(:action => :read, :column => :c3), 'taa')
+    fail(@model.authorized_for?(:action => :read, :column => :b3), 'taf')
+    pass(@model.authorized_for?(:action => :read, :column => :a3), 'tat')
+    fail(@model.authorized_for?(:action => :read, :column => :c2), 'tfa')
+    fail(@model.authorized_for?(:action => :read, :column => :b2), 'tff')
+    fail(@model.authorized_for?(:action => :read, :column => :a2), 'tft')
+    pass(@model.authorized_for?(:action => :read, :column => :c1), 'tta')
+    fail(@model.authorized_for?(:action => :read, :column => :b1), 'ttf')
+    pass(@model.authorized_for?(:action => :read, :column => :a1), 'ttt')
+  end
+
+  private
+
+  def pass(value, message = nil)
+    assert value, "#{message} should pass"
+  end
+
+  def fail(value, message = nil)
+    assert !value, "#{message} should fail"
+  end
+end