sequel 5.20.0 → 5.49.0

data/spec/extensions/index_caching_spec.rb

@@ -1,66 +0,0 @@
-require_relative "spec_helper"
-
-describe "index_caching extension" do
-  before do
-    @db = Sequel.connect('mock://postgres').extension(:index_caching)
-    @indexes = {'"table"'=>{:table_idx_unique=>{:columns=>[:first_col, :second_col], :unique=>true, :deferrable=>nil}}}
-    @filename = "spec/files/test_indexes_#$$.dump"
-    @db.instance_variable_set(:@indexes, @indexes)
-  end
-  after do
-    File.delete(@filename) if File.exist?(@filename)
-  end
-
-  it "#indexes should return cached index information" do
-    @db.indexes(:table).must_equal @indexes['"table"']
-    @db.indexes(:table, {}).must_equal @indexes['"table"']
-  end 
-
-  it "#indexes should skip cached information if given options" do
-    @db.indexes(:table, :schema=>:b).must_equal({})
-  end 
-
-  it "Database should remove cached indexes when schema is changed" do
-    @db.create_table(:table){Integer :a}
-    @db.indexes(:table).must_equal({})
-  end
-
-  it "Database#freeze should allow cached information to work" do
-    @db.freeze.indexes(:table).must_equal @indexes['"table"']
-  end
-  
-  it "Database#freeze should allow removing index information" do
-    @db.freeze
-    @db.create_table(:table){Integer :a}
-    @db.indexes(:table).must_equal({})
-  end
-
-  it "Database#dump_index_cache should dump the index cache to the given file" do
-    File.exist?(@filename).must_equal false
-    @db.dump_index_cache(@filename)
-    File.exist?(@filename).must_equal true
-    File.size(@filename).must_be :>,  0
-  end
-
-  it "Database#load_index_cache should load the index cache from the given file dumped by #dump_index_cache" do
-    @db.dump_index_cache(@filename)
-    db = Sequel::Database.new.extension(:index_caching)
-    db.load_index_cache(@filename)
-    db.extension(:index_caching)
-    @db.instance_variable_get(:@indexes).must_equal @indexes
-  end
-
-  it "Database#dump_index_cache? should dump the index cache to the given file unless the file exists" do
-    File.open(@filename, 'wb'){|f|}
-    File.size(@filename).must_equal 0
-    @db.dump_index_cache?(@filename)
-    File.size(@filename).must_equal 0
-  end
-
-  it "Database#load_index_cache? should load the index cache from the given file if it exists" do
-    db = Sequel::Database.new.extension(:index_caching)
-    File.exist?(@filename).must_equal false
-    db.load_index_cache?(@filename)
-    db.instance_variable_get(:@indexes).must_equal({})
-  end
-end

data/spec/extensions/inflector_spec.rb

@@ -1,183 +0,0 @@
-require_relative "spec_helper"
-
-Sequel.extension :inflector
-
-describe String do
-  it "#camelize and #camelcase should transform the word to CamelCase" do
-    "egg_and_hams".camelize.must_equal "EggAndHams"
-    "egg_and_hams".camelize(false).must_equal "eggAndHams"
-    "post".camelize.must_equal "Post"
-    "post".camelcase.must_equal "Post"
-  end
-
-  it "#constantize should eval the string to get a constant" do
-    "String".constantize.must_equal String
-    "String::Inflections".constantize.must_equal String::Inflections
-    proc{"BKSDDF".constantize}.must_raise NameError
-    proc{"++A++".constantize}.must_raise NameError
-  end
-  
-  it "#dasherize should transform underscores to dashes" do
-    "egg_and_hams".dasherize.must_equal "egg-and-hams"
-    "post".dasherize.must_equal "post"
-  end
-  
-  it "#demodulize should remove any preceding modules" do
-    "String::Inflections::Blah".demodulize.must_equal "Blah"
-    "String::Inflections".demodulize.must_equal "Inflections"
-    "String".demodulize.must_equal "String"
-  end
-  
-  it "#humanize should remove _i, transform underscore to spaces, and capitalize" do
-    "egg_and_hams".humanize.must_equal "Egg and hams"
-    "post".humanize.must_equal "Post"
-    "post_id".humanize.must_equal "Post"
-  end
-  
-  it "#titleize and #titlecase should underscore, humanize, and capitalize all words" do
-    "egg-and: hams".titleize.must_equal "Egg And: Hams"
-    "post".titleize.must_equal "Post"
-    "post".titlecase.must_equal "Post"
-  end
-  
-  it "#underscore should add underscores between CamelCased words, change :: to / and - to _, and downcase" do
-    "EggAndHams".underscore.must_equal "egg_and_hams"
-    "EGGAndHams".underscore.must_equal "egg_and_hams"
-    "Egg::And::Hams".underscore.must_equal "egg/and/hams"
-    "post".underscore.must_equal "post"
-    "post-id".underscore.must_equal "post_id"
-  end
-
-  it "#pluralize should transform words from singular to plural" do
-    "post".pluralize.must_equal "posts"
-    "octopus".pluralize.must_equal"octopuses"
-    "the blue mailman".pluralize.must_equal "the blue mailmen"
-    "CamelOctopus".pluralize.must_equal "CamelOctopuses"
-  end
-  
-  it "#singularize should transform words from plural to singular" do
-    "posts".singularize.must_equal "post"
-    "octopuses".singularize.must_equal "octopus"
-    "the blue mailmen".singularize.must_equal "the blue mailman"
-    "CamelOctopuses".singularize.must_equal "CamelOctopus"
-  end
-  
-  it "#tableize should transform class names to table names" do
-    "RawScaledScorer".tableize.must_equal "raw_scaled_scorers"
-    "egg_and_ham".tableize.must_equal "egg_and_hams"
-    "fancyCategory".tableize.must_equal "fancy_categories"
-  end
-  
-  it "#classify should tranform table names to class names" do
-    "egg_and_hams".classify.must_equal "EggAndHam"
-    "post".classify.must_equal "Post"
-  end
-  
-  it "#foreign_key should create a foreign key name from a class name" do
-    "Message".foreign_key.must_equal "message_id"
-    "Message".foreign_key(false).must_equal "messageid"
-    "Admin::Post".foreign_key.must_equal "post_id"
-  end
-end
-
-describe String::Inflections do
-  before do
-    @plurals, @singulars, @uncountables = String.inflections.plurals.dup, String.inflections.singulars.dup, String.inflections.uncountables.dup
-  end
-  after do
-    String.inflections.plurals.replace(@plurals)
-    String.inflections.singulars.replace(@singulars)
-    String.inflections.uncountables.replace(@uncountables)
-  end
-
-  it "should be possible to clear the list of singulars, plurals, and uncountables" do
-    String.inflections.clear(:plurals)
-    String.inflections.plurals.must_equal []
-    String.inflections.plural('blah', 'blahs')
-    String.inflections.clear
-    String.inflections.plurals.must_equal []
-    String.inflections.singulars.must_equal []
-    String.inflections.uncountables.must_equal []
-  end
-
-  it "should be able to specify new inflection rules" do
-    String.inflections do |i|
-      i.plural(/xx$/i, 'xxx')
-      i.singular(/ttt$/i, 'tt')
-      i.irregular('yy', 'yyy')
-      i.uncountable(%w'zz')
-    end
-    'roxx'.pluralize.must_equal 'roxxx'
-    'rottt'.singularize.must_equal 'rott'
-    'yy'.pluralize.must_equal 'yyy'
-    'yyy'.singularize.must_equal 'yy'
-    'zz'.pluralize.must_equal 'zz'
-    'zz'.singularize.must_equal 'zz'
-  end
-
-  it "should be yielded and returned by String.inflections" do
-    String.inflections{|i| i.must_equal String::Inflections}.must_equal String::Inflections
-  end
-end
-
-describe 'Default inflections' do
-  it "should support the default inflection rules" do
-    {
-      :test=>:tests,
-      :ax=>:axes,
-      :testis=>:testes,
-      :octopus=>:octopuses,
-      :virus=>:viruses,
-      :alias=>:aliases,
-      :status=>:statuses,
-      :bus=>:buses,
-      :buffalo=>:buffaloes,
-      :tomato=>:tomatoes,
-      :datum=>:data,
-      :bacterium=>:bacteria,
-      :analysis=>:analyses,
-      :basis=>:bases,
-      :diagnosis=>:diagnoses,
-      :parenthesis=>:parentheses,
-      :prognosis=>:prognoses,
-      :synopsis=>:synopses,
-      :thesis=>:theses,
-      :wife=>:wives,
-      :giraffe=>:giraffes,
-      :self=>:selves,
-      :dwarf=>:dwarves,
-      :hive=>:hives,
-      :fly=>:flies,
-      :buy=>:buys,
-      :soliloquy=>:soliloquies,
-      :day=>:days,
-      :attorney=>:attorneys,
-      :boy=>:boys,
-      :hoax=>:hoaxes,
-      :lunch=>:lunches,
-      :princess=>:princesses,
-      :matrix=>:matrices,
-      :vertex=>:vertices,
-      :index=>:indices,
-      :mouse=>:mice,
-      :louse=>:lice,
-      :quiz=>:quizzes,
-      :motive=>:motives,
-      :movie=>:movies,
-      :series=>:series,
-      :crisis=>:crises,
-      :person=>:people,
-      :man=>:men,
-      :woman=>:women,
-      :child=>:children,
-      :sex=>:sexes,
-      :move=>:moves
-    }.each do |k, v|
-      k.to_s.pluralize.must_equal v.to_s
-      v.to_s.singularize.must_equal k.to_s
-    end
-    [:equipment, :information, :rice, :money, :species, :series, :fish, :sheep, :news].each do |a|
-      a.to_s.pluralize.must_equal a.to_s.singularize
-    end
-  end
-end

data/spec/extensions/input_transformer_spec.rb

@@ -1,69 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::InputTransformer" do
-  before do
-    @c = Class.new(Sequel::Model)
-    @c.columns :name, :b
-    @c.plugin(:input_transformer, :reverser){|v| v.is_a?(String) ? v.reverse : v}
-    @o = @c.new
-  end
-
-  it "should apply transformation to input" do
-    @o.name = ' name '
-    @o.name.must_equal ' eman '
-    @o.name = [1, 2, 3]
-    @o.name.must_equal [1, 2, 3]
-  end
-
-  it "should have working .input_transformer_order" do
-    @c.input_transformer_order.must_equal [:reverser]
-    @c.plugin(:input_transformer, :reverser2){|v| v.is_a?(String) ? v.reverse : v}
-    @c.input_transformer_order.must_equal [:reverser2, :reverser]
-  end
-
-  it "should not apply any transformers by default" do
-    c = Class.new(Sequel::Model)
-    c.columns :name, :b
-    c.plugin :input_transformer
-    c.new(:name => ' name ').name.must_equal ' name '
-  end
-
-  it "should allow skipping of columns using .skip_input_transformer" do
-    @c.skip_input_transformer :reverser, :name
-    v = ' name '
-    @o.name = v
-    @o.name.must_be_same_as(v)
-  end
-
-  it "should work correctly in subclasses" do
-    o = Class.new(@c).new
-    o.name = ' name '
-    o.name.must_equal ' eman '
-  end
-
-  it "should raise an error if adding input filter without name" do
-    proc{@c.add_input_transformer(nil){}}.must_raise(Sequel::Error)
-    proc{@c.plugin(:input_transformer){}}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an error if adding input filter without block" do
-    proc{@c.add_input_transformer(:foo)}.must_raise(Sequel::Error)
-    proc{@c.plugin(:input_transformer, :foo)}.must_raise(Sequel::Error)
-  end
-
-  it "should apply multiple input transformers in reverse order of their call" do
-    @c.add_input_transformer(:add_bar){|v| v << 'bar'}
-    @c.add_input_transformer(:add_foo){|v| v << 'foo'}
-    @o.name = ' name '.dup
-    @o.name.must_equal 'raboof eman '
-  end
-
-  it "should freeze input transformers when freezing model class" do
-    @c.skip_input_transformer :reverser, :name
-    @c.freeze
-    @c.input_transformers.frozen?.must_equal true
-    skip = @c.instance_variable_get(:@skip_input_transformer_columns)
-    skip.frozen?.must_equal true
-    skip.values.all?(&:frozen?).must_equal true
-  end
-end

data/spec/extensions/insert_returning_select_spec.rb

@@ -1,72 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::InsertReturningSelect" do
-  before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :x=>2}, :autoid=>1)
-    @db.extend_datasets do
-      def supports_returning?(_) true end
-      def insert_select(*v) with_sql_first("#{insert_sql(*v)} RETURNING #{opts[:returning].map{|x| literal(x)}.join(', ')}") end
-    end
-    @Album = Class.new(Sequel::Model(@db[:albums].select(:id, :x)))
-    @Album.columns :id, :x
-    @db.sqls
-  end
-
-  it "should work if loaded into a model without a dataset that also uses the lazy_attributes or dataset associations plugins" do
-    c = Sequel::Model(@db)
-    c.plugin :insert_returning_select
-    c.columns :id, :x
-    c.plugin :lazy_attributes
-    c.plugin :dataset_associations
-
-    c.set_dataset @db[:albums].select(:id, :x)
-    c.plugin :lazy_attributes, :x
-    c.many_to_one :c, :key=>:id, :class=>c
-    @db.sqls
-
-    c.dataset.sql.must_equal 'SELECT id FROM albums'
-    c.create(:x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id']
-    c.load(:id=>2).x
-    @db.sqls.must_equal ['SELECT albums.x FROM albums WHERE (id = 2) LIMIT 1']
-    c.dataset.cs.sql.must_equal "SELECT id FROM albums WHERE (albums.id IN (SELECT albums.id FROM albums))"
-  end
-
-  it "should add a returning clause when inserting using selected columns" do
-    @Album.plugin :insert_returning_select
-    @Album.create(:x=>2).must_equal @Album.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id, x']
-  end
-
-  it "should not add a returning clause if selection does not consist of just columns" do
-    @Album.dataset = @Album.dataset.select_append(Sequel.as(1, :b))
-    @Album.plugin :insert_returning_select
-    @db.sqls.clear
-    @Album.create(:x=>2).must_equal @Album.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2)', 'SELECT id, x, 1 AS b FROM albums WHERE (id = 1) LIMIT 1']
-  end
-
-  it "should not add a returning clause if database doesn't support it" do
-    @db.extend_datasets{def supports_returning?(_) false end}
-    @Album.plugin :insert_returning_select
-    @Album.create(:x=>2).must_equal @Album.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2)', 'SELECT id, x FROM albums WHERE (id = 1) LIMIT 1']
-  end
-
-  it "should work correctly with subclasses" do
-    c = Class.new(Sequel::Model)
-    c.plugin :insert_returning_select
-    b = Class.new(c)
-    b.columns :id, :x
-    b.dataset = @db[:albums].select(:id, :x)
-    @db.sqls.clear
-    b.create(:x=>2).must_equal b.load(:id=>1, :x=>2)
-    @db.sqls.must_equal ['INSERT INTO albums (x) VALUES (2) RETURNING id, x']
-  end
-
-  it "should freeze instance_insert_dataset when freezing model class" do
-    @Album.plugin :insert_returning_select
-    @Album.freeze
-    @Album.instance_insert_dataset.frozen?.must_equal true
-  end
-end

data/spec/extensions/instance_filters_spec.rb

@@ -1,79 +0,0 @@
-require_relative "spec_helper"
-
-describe "instance_filters plugin" do
-  before do
-    @c = Class.new(Sequel::Model(:people))
-    @c.columns :id, :name, :num
-    @c.plugin :instance_filters
-    @p = @c.load(:id=>1, :name=>'John', :num=>1)
-    DB.sqls
-  end
-
-  it "should raise an error when updating a stale record" do
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.update(:name=>'Joe')}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
-  end 
-
-  it "should raise an error when destroying a stale record" do
-    @p.destroy
-    DB.sqls.must_equal ["DELETE FROM people WHERE id = 1"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.destroy}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
-  end 
-  
-  it "should work when using the prepared_statements plugin" do
-    @c.plugin :prepared_statements
-
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.update(:name=>'Joe')}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
-
-    @p = @c.load(:id=>1, :name=>'John', :num=>1)
-    @p.instance_variable_set(:@this, @p.this.with_numrows(1))
-    @c.instance_variable_set(:@fast_instance_delete_sql, nil)
-    @p.destroy
-    DB.sqls.must_equal ["DELETE FROM people WHERE (id = 1)"]
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
-    proc{@p.destroy}.must_raise(Sequel::Plugins::InstanceFilters::Error)
-    DB.sqls.must_equal ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
-    
-    @c.create.must_be_kind_of(@c)
-  end 
-  
-  it "should apply all instance filters" do
-    @p.instance_filter(:name=>'Jim')
-    @p.instance_filter{num > 2}
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"]
-  end 
-
-  it "should drop instance filters after updating" do
-    @p.instance_filter(:name=>'Joe')
-    @p.update(:name=>'Joe')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"]
-    @p.update(:name=>'Bob')
-    DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
-  end
-
-  it "shouldn't allow instance filters on frozen objects" do
-    @p.instance_filter(:name=>'Joe')
-    @p.freeze
-    proc{@p.instance_filter(:name=>'Jim')}.must_raise
-  end 
-
-  it "should have dup duplicate internal structures" do
-    @p.instance_filter(:name=>'Joe')
-    @p.dup.send(:instance_filters).must_equal @p.send(:instance_filters)
-    @p.dup.send(:instance_filters).wont_be_same_as(@p.send(:instance_filters))
-  end 
-end