sequel 5.20.0 → 5.49.0

data/spec/extensions/auto_literal_strings_spec.rb

@@ -1,205 +0,0 @@
-require_relative "spec_helper"
-
-describe "Dataset#where" do
-  before do
-    @dataset = Sequel.mock[:test].extension(:auto_literal_strings)
-  end
-
-  it "should work with a string with placeholders and arguments for those placeholders" do
-    @dataset.where('price < ? AND id in ?', 100, [1, 2, 3]).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
-  end
-  
-  it "should use default behavior for array of conditions" do
-    @dataset.where([[:a, 1], [:b, 2]]).sql.must_equal 'SELECT * FROM test WHERE ((a = 1) AND (b = 2))'
-  end
-
-  it "should not modify passed array with placeholders" do
-    a = ['price < ? AND id in ?', 100, 1, 2, 3]
-    b = a.dup
-    @dataset.where(a)
-    b.must_equal a
-  end
-
-  it "should work with strings (custom SQL expressions)" do
-    @dataset.where('(a = 1 AND b = 2)').select_sql.must_equal "SELECT * FROM test WHERE ((a = 1 AND b = 2))"
-  end
-    
-  it "should work with a string with named placeholders and a hash of placeholder value arguments" do
-    @dataset.where('price < :price AND id in :ids', :price=>100, :ids=>[1, 2, 3]).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in (1, 2, 3))"
-  end
-    
-  it "should not modify passed array with named placeholders" do
-    a = ['price < :price AND id in :ids', {:price=>100}]
-    b = a.dup
-    @dataset.where(a)
-    b.must_equal a
-  end
-
-  it "should not replace named placeholders that don't exist in the hash" do
-    @dataset.where('price < :price AND id in :ids', :price=>100).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id in :ids)"
-  end
-  
-  it "should raise an error for a mismatched number of placeholders" do
-    proc{@dataset.where('price < ? AND id in ?', 100).select_sql}.must_raise(Sequel::Error)
-    proc{@dataset.where('price < ? AND id in ?', 100, [1, 2, 3], 4).select_sql}.must_raise(Sequel::Error)
-  end
-
-  it "should handle partial names" do
-    @dataset.where('price < :price AND id = :p', :p=>2, :price=>100).select_sql.must_equal "SELECT * FROM test WHERE (price < 100 AND id = 2)"
-  end
-
-  it "should handle ::cast syntax when no parameters are supplied" do
-    @dataset.where('price::float = 10', {}).select_sql.must_equal "SELECT * FROM test WHERE (price::float = 10)"
-    @dataset.where('price::float ? 10', {}).select_sql.must_equal "SELECT * FROM test WHERE (price::float ? 10)"
-  end
-
-  it "should affect select, delete and update statements when using strings" do
-    @d2 = @dataset.where('region = ?', 'Asia')
-    @d2.select_sql.must_equal "SELECT * FROM test WHERE (region = 'Asia')"
-    @d2.delete_sql.must_equal "DELETE FROM test WHERE (region = 'Asia')"
-    @d2.update_sql(:GDP => 0).must_equal "UPDATE test SET GDP = 0 WHERE (region = 'Asia')"
-    
-    @d3 = @dataset.where("a = 1")
-    @d3.select_sql.must_equal "SELECT * FROM test WHERE (a = 1)"
-    @d3.delete_sql.must_equal "DELETE FROM test WHERE (a = 1)"
-    @d3.update_sql(:GDP => 0).must_equal "UPDATE test SET GDP = 0 WHERE (a = 1)"
-  end
-  
-  it "should be composable using AND operator (for scoping) when using strings" do
-    @d2 = @dataset.where('region = ?', 'Asia')
-    @d2.where('GDP > ?', 1000).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > 1000))"
-    @d2.where(:name => ['Japan', 'China']).select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (name IN ('Japan', 'China')))"
-    @d2.where('GDP > ?').select_sql.must_equal "SELECT * FROM test WHERE ((region = 'Asia') AND (GDP > ?))"
-
-    @d3 = @dataset.where("a = 1")
-    @d3.where('b = 2').select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (b = 2))"
-    @d3.where(:c => 3).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (c = 3))"
-    @d3.where('d = ?', 4).select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (d = 4))"
-  end
-      
-  it "should be composable using AND operator (for scoping) with block and string" do
-    @dataset.where("a = 1").where{e < 5}.select_sql.must_equal "SELECT * FROM test WHERE ((a = 1) AND (e < 5))"
-  end
-end
-  
-describe "Dataset #first and #last" do
-  before do
-    @d = Sequel.mock(:fetch=>proc{|s| {:s=>s}})[:test].extension(:auto_literal_strings)
-  end
-  
-  it "should combine block and standard argument filters if argument is not an Integer" do
-    ds = @d.order(:name).freeze
-    5.times do
-      @d.first('y = 25'){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
-      ds.last('y = 16'){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
-      @d.first('y = ?', 25){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 25) AND (z > 26)) LIMIT 1')
-      ds.last('y = ?', 16){z > 26}.must_equal(:s=>'SELECT * FROM test WHERE ((y = 16) AND (z > 26)) ORDER BY name DESC LIMIT 1')
-    end
-  end
-end 
-
-describe "Dataset#exclude" do
-  before do
-    @dataset = Sequel.mock.dataset.from(:test).extension(:auto_literal_strings)
-  end
-
-  it "should parenthesize a single string condition correctly" do
-    @dataset.exclude("region = 'Asia' AND name = 'Japan'").select_sql.must_equal "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
-  end
-
-  it "should parenthesize an array condition correctly" do
-    @dataset.exclude('region = ? AND name = ?', 'Asia', 'Japan').select_sql.must_equal "SELECT * FROM test WHERE NOT (region = 'Asia' AND name = 'Japan')"
-  end
-end
-
-describe "Dataset#or" do
-  before do
-    @dataset = Sequel.mock.dataset.from(:test).extension(:auto_literal_strings)
-    @d1 = @dataset.where(:x => 1)
-  end
-
-  it "should accept string filters" do
-    @d1.or('y > ?', 2).sql.must_equal 'SELECT * FROM test WHERE ((x = 1) OR (y > 2))'
-  end
-end
-  
-describe "Dataset#having" do
-  before do
-    @dataset = Sequel.mock.dataset.from(:test).extension(:auto_literal_strings)
-    @grouped = @dataset.group(:region).select(:region, Sequel.function(:sum, :population), Sequel.function(:avg, :gdp))
-  end
-  
-  it "should handle string arguments" do
-    @grouped.having('sum(population) > 10').select_sql.must_equal "SELECT region, sum(population), avg(gdp) FROM test GROUP BY region HAVING (sum(population) > 10)"
-  end
-end
-
-describe "Dataset#join_table" do
-  before do
-    @d = Sequel.mock.dataset.from(:items).with_quote_identifiers(true).extension(:auto_literal_strings)
-  end
-
-  it "should support using a string as the join condition" do
-    @d.join(:categories, "c.item_id = items.id", :table_alias=>:c).sql.must_equal 'SELECT * FROM "items" INNER JOIN "categories" AS "c" ON (c.item_id = items.id)'
-  end
-end
-  
-describe "Dataset prepared statements and bound variables " do
-  before do
-    @db = Sequel.mock
-    @ds = @db[:items].with_extend{def insert_select_sql(*v) "#{insert_sql(*v)} RETURNING *" end}.extension(:auto_literal_strings)
-  end
-
-  it "should handle literal strings" do
-    @ds.filter("num = ?", :$n).call(:select, :n=>1)
-    @db.sqls.must_equal ['SELECT * FROM items WHERE (num = 1)']
-  end
-    
-  it "should handle subselects with strings" do
-    @ds.filter(:$b).filter(:num=>@ds.select(:num).filter("num = ?", :$n)).call(:select, :n=>1, :b=>0)
-    @db.sqls.must_equal ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num = 1))))']
-  end
-end
-  
-describe "Dataset#update_sql" do
-  before do
-    @ds = Sequel.mock.dataset.from(:items).extension(:auto_literal_strings)
-  end
-  
-  it "should accept strings" do
-    @ds.update_sql("a = b").must_equal "UPDATE items SET a = b"
-  end
-  
-  it "should accept literal strings" do
-    @ds.update_sql(Sequel.lit("a = b")).must_equal "UPDATE items SET a = b"
-  end
-
-  it "should accept hash" do
-    @ds.update_sql(:c => 'd').must_equal "UPDATE items SET c = 'd'"
-  end
-end 
-
-describe "Dataset::PlaceholderLiteralizer" do
-  before do
-    @c = Sequel::Dataset::PlaceholderLiteralizer
-    @db = Sequel.mock
-    @ds = @db[:items].extension(:auto_literal_strings)
-    @h = {:id=>1}
-    @ds.db.fetch = @h
-  end
-  
-  it "should handle calls with a placeholders used as filter arguments" do
-    loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
-    loader.first(:id=>1).must_equal @h
-    loader.first(Sequel.expr{a(b)}).must_equal @h
-    loader.first("a = 1").must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1)", "SELECT * FROM items WHERE a(b)", "SELECT * FROM items WHERE (a = 1)"]
-  end
-  
-  it "should handle calls with a placeholder used multiple times in different capacities" do
-    loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.where(a).where(:b=>a)}
-    loader.first("a = 1").must_equal @h
-    loader.first(["a = ?", 2]).must_equal @h
-    @db.sqls.must_equal ["SELECT * FROM items WHERE ((a = 1) AND (b = 'a = 1'))", "SELECT * FROM items WHERE ((a = 2) AND (b IN ('a = ?', 2)))"]
-  end
-end 

data/spec/extensions/auto_validations_spec.rb

@@ -1,229 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::AutoValidations" do
-  before do
-    db = Sequel.mock(:fetch=>proc{|sql| sql =~ /a{51}/ ? {:v=>0} : {:v=>1}})
-    def db.schema_parse_table(*) true; end
-    def db.schema(t, *)
-      t = t.first_source if t.is_a?(Sequel::Dataset)
-      return [] if t != :test
-      [[:id, {:primary_key=>true, :type=>:integer, :allow_null=>false}],
-       [:name, {:primary_key=>false, :type=>:string, :allow_null=>false, :max_length=>50}],
-       [:num, {:primary_key=>false, :type=>:integer, :allow_null=>true}],
-       [:d, {:primary_key=>false, :type=>:date, :allow_null=>false}],
-       [:nnd, {:primary_key=>false, :type=>:string, :allow_null=>false, :default=>'nnd'}]]
-    end
-    def db.supports_index_parsing?() true end
-    def db.indexes(t, *)
-      raise if t.is_a?(Sequel::Dataset)
-      return [] if t != :test
-      {:a=>{:columns=>[:name, :num], :unique=>true}, :b=>{:columns=>[:num], :unique=>false}}
-    end
-    @c = Class.new(Sequel::Model(db[:test]))
-    @c.send(:def_column_accessor, :id, :name, :num, :d, :nnd)
-    @c.raise_on_typecast_failure = false
-    @c.plugin :auto_validations
-    @m = @c.new
-    db.sqls
-  end
-
-  it "should have automatically created validations" do
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not present"], :name=>["is not present"])
-
-    @m.name = ''
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not present"])
-
-    @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
-
-    @m.set(:d=>Date.today, :num=>1)
-    @m.valid?.must_equal false
-    @m.errors.must_equal([:name, :num]=>["is already taken"])
-
-    @m.set(:name=>'a'*51)
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:name=>["is longer than 50 characters"])
-  end
-
-  it "should handle simple unique indexes correctly" do
-    def (@c.db).indexes(t, *)
-      raise if t.is_a?(Sequel::Dataset)
-      return [] if t != :test
-      {:a=>{:columns=>[:name], :unique=>true}}
-    end
-    @c.plugin :auto_validations
-    @m.set(:name=>'foo', :d=>Date.today)
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:name=>["is already taken"])
-  end
-
-  it "should validate using the underlying column values" do
-    @c.send(:define_method, :name){super() * 2}
-    @c.db.fetch = {:v=>0}
-    @m.set(:d=>Date.today, :num=>1, :name=>'b'*26)
-    @m.valid?.must_equal true
-  end
-
-  it "should handle databases that don't support index parsing" do
-    def (@m.db).supports_index_parsing?() false end
-    @m.model.send(:setup_auto_validations)
-    @m.set(:d=>Date.today, :num=>1, :name=>'1')
-    @m.valid?.must_equal true
-  end
-
-  it "should handle models that select from subqueries" do
-    @c.set_dataset @c.dataset.from_self
-    @c.send(:setup_auto_validations)
-  end
-
-  it "should support :not_null=>:presence option" do
-    @c.plugin :auto_validations, :not_null=>:presence
-    @m.set(:d=>Date.today, :num=>'')
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:name=>["is not present"])
-  end
-
-  it "should automatically validate explicit nil values for columns with not nil defaults" do
-    @m.set(:d=>Date.today, :name=>1, :nnd=>nil)
-    @m.id = nil
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:id=>["is not present"], :nnd=>["is not present"])
-  end
-
-  it "should allow skipping validations by type" do
-    @c = Class.new(@c)
-    @m = @c.new
-    @m.skip_auto_validations(:not_null) do
-      @m.valid?.must_equal true
-      @m.nnd = nil
-      @m.valid?.must_equal true
-    end
-    @m.set(:nnd => 'nnd')
-    @c.skip_auto_validations(:not_null)
-    @m.valid?.must_equal true
-    @m.nnd = nil
-    @m.valid?.must_equal true
-
-    @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
-
-    @m.skip_auto_validations(:types, :unique) do
-      @m.valid?.must_equal true
-    end
-    @m.skip_auto_validations(:types) do
-      @m.valid?.must_equal false
-      @m.errors.must_equal([:name, :num]=>["is already taken"])
-    end
-    @c.skip_auto_validations(:types)
-    @m.valid?.must_equal false
-    @m.errors.must_equal([:name, :num]=>["is already taken"])
-
-    @m.skip_auto_validations(:unique) do
-      @m.valid?.must_equal true
-    end
-    @c.skip_auto_validations(:unique)
-    @m.valid?.must_equal true
-
-    @m.set(:name=>'a'*51)
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:name=>["is longer than 50 characters"])
-
-    @m.skip_auto_validations(:max_length) do
-      @m.valid?.must_equal true
-    end
-    @c.skip_auto_validations(:max_length)
-    @m.valid?.must_equal true
-  end
-
-  it "should allow skipping all auto validations" do
-    @c = Class.new(@c)
-    @m = @c.new
-    @m.skip_auto_validations(:all) do
-      @m.valid?.must_equal true
-      @m.set(:d=>'/', :num=>'a', :name=>'1')
-      @m.valid?.must_equal true
-      @m.set(:name=>'a'*51)
-      @m.valid?.must_equal true
-    end
-    @m = @c.new
-    @c.skip_auto_validations(:all)
-    @m.valid?.must_equal true
-    @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.must_equal true
-    @m.set(:name=>'a'*51)
-    @m.valid?.must_equal true
-  end
-
-  it "should work correctly in subclasses" do
-    @c = Class.new(@c)
-    @m = @c.new
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not present"], :name=>["is not present"])
-
-    @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
-
-    @m.set(:d=>Date.today, :num=>1)
-    @m.valid?.must_equal false
-    @m.errors.must_equal([:name, :num]=>["is already taken"])
-
-    @m.set(:name=>'a'*51)
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:name=>["is longer than 50 characters"])
-  end
-
-  it "should work correctly in STI subclasses" do
-    @c.plugin(:single_table_inheritance, :num, :model_map=>{1=>@c}, :key_map=>proc{[1, 2]})
-    sc = Class.new(@c)
-    @m = sc.new
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not present"], :name=>["is not present"])
-
-    @m.set(:d=>'/', :num=>'a', :name=>'1')
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:d=>["is not a valid date"], :num=>["is not a valid integer"])
-
-    @m.db.sqls
-    @m.set(:d=>Date.today, :num=>1)
-    @m.valid?.must_equal false
-    @m.errors.must_equal([:name, :num]=>["is already taken"])
-    @m.db.sqls.must_equal ["SELECT count(*) AS count FROM test WHERE ((name = '1') AND (num = 1)) LIMIT 1"]
-
-    @m.set(:name=>'a'*51)
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:name=>["is longer than 50 characters"])
-  end
-
-  it "should work correctly when changing the dataset" do
-    @c.set_dataset(@c.db[:foo])
-    @c.new.valid?.must_equal true
-  end
-
-  it "should support setting validator options" do
-    sc = Class.new(@c)
-    sc.plugin :auto_validations, :max_length_opts=> {:message=> 'ml_message'}, :schema_types_opts=> {:message=> 'st_message'}, :explicit_not_null_opts=> {:message=> 'enn_message'}, :unique_opts=> {:message=> 'u_message'}
-
-    @m = sc.new
-    @m.set(:name=>'a'*51, :d => '/', :nnd => nil, :num=>1)
-    @m.valid?.must_equal false
-    @m.errors.must_equal(:name=>["ml_message"], :d=>["st_message"], :nnd=>["enn_message"])
-
-    @m = sc.new
-    @m.set(:name=>1, :num=>1, :d=>Date.today)
-    @m.valid?.must_equal false
-    @m.errors.must_equal([:name, :num]=>["u_message"])
-  end
-
-  it "should not allow modifying auto validation information for frozen model classes" do
-    @c.freeze
-    @c.auto_validate_not_null_columns.frozen?.must_equal true
-    @c.auto_validate_explicit_not_null_columns.frozen?.must_equal true
-    @c.auto_validate_max_length_columns.frozen?.must_equal true
-    @c.auto_validate_unique_columns.frozen?.must_equal true
-  end
-end

data/spec/extensions/blacklist_security_spec.rb

@@ -1,95 +0,0 @@
-require_relative "spec_helper"
-
-describe Sequel::Model, "#(set|update)_except" do
-  before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
-      plugin :blacklist_security
-      set_primary_key :id
-      columns :x, :y, :z, :id
-      set_restricted_columns :y
-    end
-    @c.strict_param_setting = false
-    @o1 = @c.new
-    DB.reset
-  end
-
-  it "should raise errors if not all hash fields can be set and strict_param_setting is true" do
-    @c.strict_param_setting = true
-    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, :x, :y)}.must_raise(Sequel::MassAssignmentRestriction)
-    proc{@c.new.set_except({:x => 1, :y => 2, :z=>3}, :x, :y)}.must_raise(Sequel::MassAssignmentRestriction)
-    (o = @c.new).set_except({:z => 3}, :x, :y)
-    o.values.must_equal(:z=>3)
-  end
-
-  it "#set_except should not set given attributes or the primary key" do
-    @o1.set_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
-    @o1.values.must_equal(:x => 1)
-    @o1.set_except({:x => 4, :y => 2, :z=>3, :id=>4}, :y, :z)
-    @o1.values.must_equal(:x => 4)
-  end
-
-  it "#update_except should not update given attributes" do
-    @o1.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
-    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
-    @c.new.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, :y, :z)
-    DB.sqls.must_equal ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE id = 10"]
-  end
-end
-
-describe Sequel::Model, ".restricted_columns " do
-  before do
-    @c = Class.new(Sequel::Model(:blahblah))
-    @c.class_eval do
-      plugin :blacklist_security
-      columns :x, :y, :z
-    end
-    @c.strict_param_setting = false
-    @c.instance_variable_set(:@columns, [:x, :y, :z])
-    DB.sqls
-  end
-  
-  it "should set the restricted columns correctly" do
-    @c.restricted_columns.must_be_nil
-    @c.set_restricted_columns :x
-    @c.restricted_columns.must_equal [:x]
-    @c.set_restricted_columns :x, :y
-    @c.restricted_columns.must_equal [:x, :y]
-  end
-
-  it "should not set restricted columns by default" do
-    @c.set_restricted_columns :z
-    i = @c.new(:x => 1, :y => 2, :z => 3)
-    i.values.must_equal(:x => 1, :y => 2)
-    i.set(:x => 4, :y => 5, :z => 6)
-    i.values.must_equal(:x => 4, :y => 5)
-
-    @c.dataset = @c.dataset.with_fetch(:x => 7)
-    i = @c.new
-    i.update(:x => 7, :z => 9)
-    i.values.must_equal(:x => 7)
-    DB.sqls.must_equal ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
-  end
-
-  it "should have allowed take precedence over restricted" do
-    @c.plugin :whitelist_security
-    @c.set_allowed_columns :x, :y
-    @c.set_restricted_columns :y, :z
-    i = @c.new(:x => 1, :y => 2, :z => 3)
-    i.values.must_equal(:x => 1, :y => 2)
-    i.set(:x => 4, :y => 5, :z => 6)
-    i.values.must_equal(:x => 4, :y => 5)
-
-    @c.dataset = @c.dataset.with_fetch(:y => 7)
-    i = @c.new
-    i.update(:y => 7, :z => 9)
-    i.values.must_equal(:y => 7)
-    DB.sqls.must_equal ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE id = 10"]
-  end
-
-  it "should freeze restricted_columns when freezing class" do
-    @c.set_restricted_columns :z
-    @c.freeze
-    @c.restricted_columns.frozen?.must_equal true
-  end
-end

data/spec/extensions/blank_spec.rb

@@ -1,69 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :blank
-
-describe "Object#blank?" do
-  it "it should be true if the object responds true to empty?" do
-    [].blank?.must_equal true
-    {}.blank?.must_equal true
-    o = Object.new
-    def o.empty?; true; end
-    o.blank?.must_equal true
-  end
-
-  it "it should be false if the object doesn't respond true to empty?" do
-    [2].blank?.must_equal false
-    {1=>2}.blank?.must_equal false
-    Object.new.blank?.must_equal false
-  end
-end
-
-describe "Numeric#blank?" do
-  it "it should always be false" do
-    1.blank?.must_equal false
-    0.blank?.must_equal false
-    -1.blank?.must_equal false
-    1.0.blank?.must_equal false
-    0.0.blank?.must_equal false
-    -1.0.blank?.must_equal false
-    10000000000000000.blank?.must_equal false
-    -10000000000000000.blank?.must_equal false
-    10000000000000000.0.blank?.must_equal false
-    -10000000000000000.0.blank?.must_equal false
-  end
-end
-
-describe "NilClass#blank?" do
-  it "it should always be true" do
-    nil.blank?.must_equal true
-  end
-end
-
-describe "TrueClass#blank?" do
-  it "it should always be false" do
-    true.blank?.must_equal false
-  end
-end
-
-describe "FalseClass#blank?" do
-  it "it should always be true" do
-    false.blank?.must_equal true
-  end
-end
-
-describe "String#blank?" do
-  it "it should be true if the string is empty" do
-    ''.blank?.must_equal true
-  end
-  it "it should be true if the string is composed of just whitespace" do
-    ' '.blank?.must_equal true
-    "\r\n\t".blank?.must_equal true
-    (' '*4000).blank?.must_equal true
-    ("\r\n\t"*4000).blank?.must_equal true
-  end
-  it "it should be false if the string has any non whitespace characters" do
-    '1'.blank?.must_equal false
-    ("\r\n\t"*4000 + 'a').blank?.must_equal false
-    ("\r\na\t"*4000).blank?.must_equal false
-  end
-end

data/spec/extensions/boolean_readers_spec.rb

@@ -1,93 +0,0 @@
-require_relative "spec_helper"
-
-describe Sequel::Model, "BooleanReaders plugin" do
-  before do
-    @db = Sequel.mock
-    def @db.supports_schema_parsing?() true end
-    def @db.schema(*args)
-      [[:id, {}], [:z, {:type=>:integer, :db_type=>'tinyint(1)'}], [:b, {:type=>:boolean, :db_type=>'boolean'}]]
-    end
-
-    @c = Class.new(Sequel::Model(@db[:items]))
-    @p = proc do
-      @columns = [:id, :b, :z]
-      def columns; @columns; end
-    end
-    @c.instance_eval(&@p)
-  end 
-
-  it "should create attribute? readers for all boolean attributes" do
-    @c.plugin(:boolean_readers)
-    o = @c.new
-    o.b?.must_be_nil
-    o.b = '1'
-    o.b?.must_equal true
-    o.b = '0'
-    o.b?.must_equal false
-    o.b = ''
-    o.b?.must_be_nil
-  end
-
-  it "should not create attribute? readers for non-boolean attributes" do
-    @c.plugin(:boolean_readers)
-    proc{@c.new.z?}.must_raise(NoMethodError)
-    proc{@c.new.id?}.must_raise(NoMethodError)
-  end
-
-  it "should accept a block to determine if an attribute is boolean" do
-    @c.plugin(:boolean_readers){|c| db_schema[c][:db_type] == 'tinyint(1)'}
-    proc{@c.new.b?}.must_raise(NoMethodError)
-    o = @c.new
-    o.z.must_be_nil
-    o.z?.must_be_nil
-    o.z = '1'
-    o.z.must_equal 1
-    o.z?.must_equal true
-    o.z = '0'
-    o.z.must_equal 0
-    o.z?.must_equal false
-    o.z = ''
-    o.z.must_be_nil
-    o.z?.must_be_nil
-  end
-
-  it "should create boolean readers when set_dataset is defined" do
-    c = Class.new(Sequel::Model(@db))
-    c.instance_eval(&@p)
-    c.plugin(:boolean_readers)
-    c.set_dataset(@db[:a])
-    o = c.new
-    o.b?.must_be_nil
-    o.b = '1'
-    o.b?.must_equal true
-    o.b = '0'
-    o.b?.must_equal false
-    o.b = ''
-    o.b?.must_be_nil
-    proc{o.i?}.must_raise(NoMethodError)
-
-    c = Class.new(Sequel::Model(@db))
-    c.instance_eval(&@p)
-    c.plugin(:boolean_readers){|x| db_schema[x][:db_type] == 'tinyint(1)'}
-    c.set_dataset(@db[:a])
-    o = c.new
-    o.z.must_be_nil
-    o.z?.must_be_nil
-    o.z = '1'
-    o.z.must_equal 1
-    o.z?.must_equal true
-    o.z = '0'
-    o.z.must_equal 0
-    o.z?.must_equal false
-    o.z = ''
-    o.z.must_be_nil
-    o.z?.must_be_nil
-    proc{o.b?}.must_raise(NoMethodError)
-  end
-
-  it "should handle cases where getting the columns raises an error" do
-    def @c.columns; raise Sequel::Error end
-    @c.plugin(:boolean_readers)
-    proc{@c.new.b?}.must_raise(NoMethodError)
-  end
-end