six-updater-web 0.10.8 → 0.11.1

data/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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

data/lib/vendor/plugins/active_scaffold/test/misc/configurable_test.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), '../test_helper.rb')
+
+class ConfigurableClass
+  FOO = 'bar'
+  def foo; FOO end
+  def self.foo; FOO end
+end
+
+
+class ConfigurableTest < Test::Unit::TestCase
+  ##
+  ## constants and methods for tests to check against
+  ##
+  def hello; 'world' end
+  HELLO = 'world'
+
+  def test_instance_configuration
+    ConfigurableClass.send :include, ActiveScaffold::Configurable
+
+    configurable_class = ConfigurableClass.new
+
+    ##
+    ## sanity checks
+    ##
+    # make sure the configure method is available
+    assert ConfigurableClass.respond_to?(:configure)
+    # make sure real functions still work
+    assert_equal 'bar', configurable_class.foo
+    # make sure other functions still don't work
+    assert_raise NoMethodError do
+      configurable_class.i_do_not_exist
+    end
+
+    ##
+    ## test normal block behaviors
+    ##
+    # functions
+    assert_equal hello, configurable_class.configure {hello}
+    # variables
+    assert_equal configurable_class, configurable_class.configure {configurable_class}
+    # constants
+    assert_equal HELLO, configurable_class.configure {HELLO}
+
+    ##
+    ## test extra "localized" block behavior
+    ##
+    # functions
+    assert_equal configurable_class.foo, configurable_class.configure {foo}
+    # constants - not working
+#    assert_equal configurable_class.FOO, configurable_class.configure {FOO}
+
+  end
+
+  def test_class_configuration
+    ConfigurableClass.send :extend, ActiveScaffold::Configurable
+
+    ##
+    ## sanity checks
+    ##
+    # make sure the configure method is available
+    assert ConfigurableClass.respond_to?(:configure)
+    # make sure real functions still work
+    assert_equal 'bar', ConfigurableClass.foo
+    # make sure other functions still don't work
+    assert_raise NoMethodError do
+      ConfigurableClass.i_do_not_exist
+    end
+
+    ##
+    ## test normal block behaviors
+    ##
+    # functions
+    assert_equal hello, ConfigurableClass.configure {hello}
+    # variables
+    assert_equal ConfigurableClass, ConfigurableClass.configure {ConfigurableClass}
+    # constants
+    assert_equal HELLO, ConfigurableClass.configure {HELLO}
+
+    ##
+    ## test extra "localized" block behavior
+    ##
+    # functions
+    assert_equal ConfigurableClass.foo, ConfigurableClass.configure {foo}
+    # constants - not working
+#    assert_equal ConfigurableClass.FOO, ConfigurableClass.configure {FOO}
+  end
+
+  def test_arity
+    ConfigurableClass.send :extend, ActiveScaffold::Configurable
+
+    # this is the main style
+    assert_equal 'foo', ConfigurableClass.configure {'foo'}
+    # but we want to let people accept the configurable class as the first argument, too
+    assert_equal 'bar', ConfigurableClass.configure {|a| a.foo}
+  end
+end