sequel 5.29.0 → 5.34.0

data/spec/extensions/pg_static_cache_updater_spec.rb

@@ -1,93 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_static_cache_updater extension" do
-  before do
-    @db = Sequel.connect('mock://postgres')
-    @db.extend_datasets{def quote_identifiers?; false end}
-    def @db.listen(chan, opts={})
-      execute("LISTEN #{chan}")
-      yield(*opts[:yield])
-    end
-    @db.extension(:pg_static_cache_updater)
-    @model = Class.new(Sequel::Model(@db[:table]))
-    @model.plugin :static_cache
-    @db.sqls
-  end
-
-  it "#create_static_cache_update_function should create a function in the database" do
-    @db.create_static_cache_update_function
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal " CREATE FUNCTION sequel_static_cache_update() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN PERFORM pg_notify(''sequel_static_cache_update'', TG_RELID::text); RETURN NULL; END ' "
-  end
-
-  it "#create_static_cache_update_function should support :channel_name and :function_name options" do
-    @db.create_static_cache_update_function(:channel_name=>'foo', :function_name=>'bar')
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal " CREATE FUNCTION bar() RETURNS trigger LANGUAGE plpgsql AS 'BEGIN PERFORM pg_notify(''foo'', TG_RELID::text); RETURN NULL; END ' "
-  end
-
-  it "#create_static_cache_update_trigger should create a trigger for the database table" do
-    @db.create_static_cache_update_trigger(:tab)
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal "CREATE TRIGGER sequel_static_cache_update AFTER INSERT OR UPDATE OR DELETE ON tab EXECUTE PROCEDURE sequel_static_cache_update()"
-  end
-
-  it "#create_static_cache_update_trigger should support :trigger_name and :function_name options" do
-    @db.create_static_cache_update_trigger(:tab, :trigger_name=>'foo', :function_name=>'bar')
-    @db.sqls.first.gsub(/\s+/, ' ').must_equal "CREATE TRIGGER foo AFTER INSERT OR UPDATE OR DELETE ON tab EXECUTE PROCEDURE bar()"
-  end
-
-  it "#default_static_cache_update_name should return the default name for function, trigger, and channel" do
-    @db.default_static_cache_update_name.must_equal :sequel_static_cache_update
-  end
-
-  it "#listen_for_static_cache_updates should listen for changes to model tables and reload model classes" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 1234]).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update", "SELECT * FROM table"]
-  end
-
-  it "#listen_for_static_cache_updates should not reload model classes if oid doesn't match" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345]).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update"]
-  end
-
-  it "#listen_for_static_cache_updates should support a single model argument" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates(@model, :yield=>[nil, nil, 1234]).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN sequel_static_cache_update", "SELECT * FROM table"]
-  end
-
-  it "#listen_for_static_cache_updates should support the :channel_name option" do
-    @db.fetch = {:v=>1234}
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :channel_name=>:foo).join
-    @db.sqls.must_equal ["SELECT CAST(CAST('table' AS regclass) AS oid) AS v LIMIT 1", "LISTEN foo"]
-  end
-
-  it "#listen_for_static_cache_updates should raise an error if given an empty array" do
-    @db.fetch = {:v=>1234}
-    proc{@db.listen_for_static_cache_updates([])}.must_raise(Sequel::Error)
-  end
-
-  it "#listen_for_static_cache_updates should raise an error if one of the models is not using the static cache plugin" do
-    @db.fetch = {:v=>1234}
-    proc{@db.listen_for_static_cache_updates(Class.new(Sequel::Model(@db[:table])))}.must_raise(Sequel::Error)
-  end
-
-  it "#listen_for_static_cache_updates should raise an error if the database doesn't respond to listen" do
-    @db = Sequel.mock(:host=>'postgres')
-    @db.extension(:pg_static_cache_updater)
-    @db.fetch = {:v=>1234}
-    proc{@db.listen_for_static_cache_updates(Class.new(Sequel::Model(@db[:table])))}.must_raise(Sequel::Error)
-  end
-
-  it "#listen_for_static_cache_updates should handle a :before_thread_exit option" do
-    a = []
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :before_thread_exit=>proc{a << 1}).join
-    a.must_equal [1]
-  end
-
-  it "#listen_for_static_cache_updates should call :before_thread_exit option even if listen raises an exception" do
-    a = []
-    @db.listen_for_static_cache_updates([@model], :yield=>[nil, nil, 12345], :after_listen=>proc{raise ArgumentError}, :before_thread_exit=>proc{a << 1}).join
-    a.must_equal [1]
-  end
-end

data/spec/extensions/pg_timestamptz_spec.rb

@@ -1,17 +0,0 @@
-require_relative "spec_helper"
-
-describe "pg_timestamptz extension" do
-  before do
-    @db = Sequel.mock(:host=>'postgres').extension :pg_timestamptz
-  end
-
-  it "should use timestamptz as default timestamp type" do
-    @db.create_table(:t){Time :t; DateTime :tz; Time :ot, :only_time=>true}
-    @db.sqls.must_equal ['CREATE TABLE "t" ("t" timestamptz, "tz" timestamptz, "ot" time)']
-  end
-
-  it "should use timestamptz when casting" do
-    @db.get(Sequel.cast('a', Time))
-    @db.sqls.must_equal ["SELECT CAST('a' AS timestamptz) AS \"v\" LIMIT 1"]
-  end
-end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -1,66 +0,0 @@
-require_relative "spec_helper"
-
-describe "prepared_statements_safe plugin" do
-  before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
-    @c = Class.new(Sequel::Model(@db[:people]))
-    @c.columns :id, :name, :i
-    @c.instance_variable_set(:@db_schema, {:i=>{}, :name=>{}, :id=>{:primary_key=>true}})
-    @c.plugin :prepared_statements_safe
-    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
-    @db.sqls
-  end
-
-  it "should load the prepared_statements plugin" do
-    @c.plugins.must_include(Sequel::Plugins::PreparedStatements)
-  end
-
-  it "should set default values correctly" do
-    @c.prepared_statements_column_defaults.must_equal(:name=>nil, :i=>nil)
-    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}, :bar=>{:ruby_default=>Sequel::CURRENT_TIMESTAMP}})
-    Class.new(@c).prepared_statements_column_defaults.must_equal(:name=>'foo')
-  end
-
-  it "should set default values when creating" do
-    @c.create
-    @db.sqls.must_equal ['INSERT INTO people (i, name) VALUES (NULL, NULL)', "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-    @c.create(:name=>'foo')
-    @db.sqls.must_equal ["INSERT INTO people (i, name) VALUES (NULL, 'foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-    @c.create(:name=>'foo', :i=>2)
-    @db.sqls.must_equal ["INSERT INTO people (i, name) VALUES (2, 'foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-  end 
-
-  it "should use database default values" do
-    @c.instance_variable_set(:@db_schema, {:i=>{:ruby_default=>2}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
-    c = Class.new(@c)
-    c.create
-    @db.sqls.must_equal ["INSERT INTO people (i, name) VALUES (2, 'foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-  end
-
-  it "should not set defaults for unparseable dataset default values" do
-    @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
-    c = Class.new(@c)
-    c.create
-    @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
-  end
-
-  it "should save all fields when updating" do
-    @p.update(:i=>3)
-    @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 3 WHERE (id = 1)"]
-  end
-
-  it "should work with abstract classes" do
-    c = Class.new(Sequel::Model)
-    c.plugin :prepared_statements_safe
-    c1 = Class.new(c)
-    def c1.get_db_schema; @db_schema = {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}} end
-    c1.set_dataset(:people)
-    c1.prepared_statements_column_defaults.must_equal(:name=>'foo')
-    Class.new(c1).prepared_statements_column_defaults.must_equal(:name=>'foo')
-  end
-
-  it "should freeze prepared statement column defaults when freezing model class" do
-    @c.freeze
-    @c.prepared_statements_column_defaults.frozen?.must_equal true
-  end
-end

data/spec/extensions/prepared_statements_spec.rb

@@ -1,177 +0,0 @@
-require_relative "spec_helper"
-
-describe "prepared_statements plugin" do
-  before do
-    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
-    @c = Class.new(Sequel::Model(@db[:people]))
-    @c.columns :id, :name, :i
-    @c.set_primary_key :id
-    @columns = "id, name, i"
-    @c.plugin :prepared_statements
-    @p = @c.load(:id=>1, :name=>'foo', :i=>2)
-    @ds = @c.dataset
-    @db.sqls
-  end
-
-  it "should work with implicit subqueries used for joined datasets" do
-    @c.dataset = @c.dataset.from(:people, :people2)
-    @db.sqls
-    @c[1].must_equal @p
-    @db.sqls.must_equal ["SELECT * FROM (SELECT * FROM people, people2) AS people WHERE (id = 1) LIMIT 1 -- read_only"]
-  end 
-
-  it "should correctly lookup by primary key for dataset using subquery" do
-    @c.dataset = @c.dataset.from(:people, :people2).from_self(:alias=>:people)
-    @db.sqls
-    @c[1].must_equal @p
-    @db.sqls.must_equal ["SELECT * FROM (SELECT * FROM people, people2) AS people WHERE (id = 1) LIMIT 1 -- read_only"]
-  end 
-
-  it "should use prepared statements for pk lookups only if default is not optimized" do
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal false 
-    @c.set_primary_key [:id, :name]
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
-    @c.set_primary_key :id
-    @c.dataset = @c.dataset.from(:people, :people2)
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
-    @c.dataset = @db[:people].select(:id, :name, :i)
-    @c.send(:use_prepared_statements_for_pk_lookup?).must_equal true
-  end
-
-  it "should raise Error for unsupported prepared statement types" do
-    proc{@p.send(:use_prepared_statements_for?, :foo)}.must_raise Sequel::Error
-  end
-
-  prepared_statements_spec = shared_description do
-    it "should correctly update instance" do
-      @p.update(:name=>'bar').must_equal @c.load(:id=>1, :name=>'bar', :i => 2)
-      @db.sqls.must_equal ["UPDATE people SET name = 'bar' WHERE (id = 1)"]
-    end
-
-    it "should correctly create instance if dataset supports insert_select" do
-      @c.dataset_module do
-        def supports_insert_select?
-          true
-        end
-        def supports_returning?(type)
-          true
-        end
-        def insert_select(h)
-          cache_set(:_fetch, :id=>1, :name=>'foo', :i => 2)
-          server(:default).with_sql_first(insert_select_sql(h))
-        end
-        def insert_select_sql(*v)
-          insert_sql(*v) << " RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
-        end
-      end
-      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') RETURNING #{@columns}"]
-    end
-  end
-
-  describe "when #use_prepared_statements_for? returns true" do
-    before do
-      @c.class_eval do
-        def self.use_prepared_statements_for_pk_lookup?; true end
-        def use_prepared_statements_for?(type) true end
-      end
-    end
-
-    include prepared_statements_spec
-
-    it "should correctly create instance" do
-      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT * FROM people WHERE id = 1"]
-    end
-
-    it "should correctly update instance when specifying server" do
-      @p.set_server(:read_only).update(:name=>'bar').must_equal @c.load(:id=>1, :name=>'bar', :i => 2)
-      @db.sqls.must_equal ["UPDATE people SET name = 'bar' WHERE (id = 1) -- read_only"]
-    end
-
-    it "should correctly create instance when specifying server" do
-      @c.new(:name=>'foo').set_server(:read_only).save.must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') -- read_only", "SELECT * FROM people WHERE id = 1 -- read_only"]
-    end
-
-    it "should correctly create instance if dataset supports insert_select when specifying server" do
-      @c.dataset_module do
-        def supports_insert_select?
-          true
-        end
-        def supports_returning?(type)
-          true
-        end
-        def insert_select(h)
-          cache_set(:_fetch, :id=>1, :name=>'foo', :i => 2)
-          server(:default).with_sql_first(insert_select_sql(h))
-        end
-        def insert_select_sql(*v)
-          insert_sql(*v) << " RETURNING #{(opts[:returning] && !opts[:returning].empty?) ? opts[:returning].map{|c| literal(c)}.join(', ') : '*'}"
-        end
-      end
-      @c.new(:name=>'foo').set_server(:read_only).save.must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo') RETURNING #{@columns} -- read_only"]
-    end
-
-    it "should work correctly when subclassing" do
-      c = Class.new(@c)
-      @db.sqls
-      c.load(:id=>1, :name=>'foo', :i=>2).save
-      @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 2 WHERE (id = 1)"]
-    end 
-
-    it "should correctly handle without schema type when placeholder type specifiers are required" do
-      @c.dataset = @ds.with_extend{def requires_placeholder_type_specifiers?; true end}
-      @p.save
-      @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 2 WHERE (id = 1)"]
-    end
-
-    it "should correctly handle with schema type when placeholder type specifiers are required" do
-      @c.dataset = @ds.with_extend do
-        def requires_placeholder_type_specifiers?; true end
-        def prepared_statement_modules
-          [Module.new do
-            def literal_symbol_append(sql, v)
-              if @opts[:bind_vars] && /\A\$(.*)\z/ =~ v
-                literal_append(sql, prepared_arg($1.split('__')[0].to_sym))
-              else
-                super
-              end
-            end
-          end]
-        end
-      end
-      @c.db_schema[:id][:type] = :integer
-      @p.save
-      @db.sqls.must_equal ["UPDATE people SET name = 'foo', i = 2 WHERE (id = 1)"]
-    end 
-  end
-
-  describe "when #use_prepared_statements_for? returns false" do
-    before do
-      @columns = "*"
-      @c.class_eval do
-        def self.use_prepared_statements_for_pk_lookup?; false end
-        def use_prepared_statements_for?(type) false end
-      end
-    end
-
-    include prepared_statements_spec
-
-    it "should correctly create instance" do
-      @c.create(:name=>'foo').must_equal @c.load(:id=>1, :name=>'foo', :i => 2)
-      @db.sqls.must_equal ["INSERT INTO people (name) VALUES ('foo')", "SELECT #{@columns} FROM people WHERE id = 1"]
-    end
-
-    it "should correctly lookup by primary key" do
-      @c[1].must_equal @p
-      @db.sqls.must_equal ["SELECT * FROM people WHERE id = 1 -- read_only"]
-    end 
-
-    it "should correctly delete instance" do
-      @p.destroy.must_equal @p
-      @db.sqls.must_equal ["DELETE FROM people WHERE id = 1"]
-    end
-  end
-end

data/spec/extensions/pretty_table_spec.rb

@@ -1,123 +0,0 @@
-require_relative "spec_helper"
-
-require 'stringio'
-Sequel.extension :pretty_table
-
-describe "Dataset#print" do
-  before do
-    @output = StringIO.new
-    @orig_stdout = $stdout
-    $stdout = @output
-    @dataset = Sequel.mock(:fetch=>[{:a=>1, :b=>2}, {:a=>3, :b=>4}, {:a=>5, :b=>6}])[:items].extension(:pretty_table)
-  end
-
-  after do
-    $stdout = @orig_stdout
-  end
-
-  it "should print out a table with the values" do
-    @dataset.print(:a, :b)
-    @output.rewind
-    @output.read.must_equal \
-      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
-  end
-
-  it "should default to the dataset's columns" do
-    @dataset.columns(:a, :b)
-    @dataset.print
-    @output.rewind
-    @output.read.must_equal \
-      "+-+-+\n|a|b|\n+-+-+\n|1|2|\n|3|4|\n|5|6|\n+-+-+\n"
-  end
-end
-
-describe "PrettyTable" do
-  before do
-    @data1 = [
-      {:x => 3, :y => 4}
-    ]
-    
-    @data2 = [
-      {:a => 23, :b => 45},
-      {:a => 45, :b => 2377}
-    ]
-
-    @data3 = [
-      {:aaa => 1},
-      {:bb => 2},
-      {:c => 3.1}
-    ]
-
-    @output = StringIO.new
-    @orig_stdout = $stdout
-    $stdout = @output
-  end
-
-  after do
-    $stdout = @orig_stdout
-  end
-  
-  it "should infer the columns if not given" do
-    Sequel::PrettyTable.print(@data1)
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+-+-+
-|x|y|
-+-+-+
-|3|4|
-+-+-+
-OUTPUT
-  end
-  
-  it "should have #string return the string without printing" do
-    Sequel::PrettyTable.string(@data1).must_equal((<<OUTPUT).chomp)
-+-+-+
-|x|y|
-+-+-+
-|3|4|
-+-+-+
-OUTPUT
-    @output.rewind
-    @output.read.must_equal ''
-  end
-  
-  it "should calculate the maximum width of each column correctly" do
-    Sequel::PrettyTable.print(@data2, [:a, :b])
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+--+----+
-|a |b   |
-+--+----+
-|23|  45|
-|45|2377|
-+--+----+
-OUTPUT
-  end
-
-  it "should also take header width into account" do
-    Sequel::PrettyTable.print(@data3, [:aaa, :bb, :c])
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+---+--+---+
-|aaa|bb|c  |
-+---+--+---+
-|  1|  |   |
-|   | 2|   |
-|   |  |3.1|
-+---+--+---+
-OUTPUT
-  end
-  
-  it "should print only the specified columns" do
-    Sequel::PrettyTable.print(@data2, [:a])
-    @output.rewind
-    @output.read.must_equal(<<OUTPUT)
-+--+
-|a |
-+--+
-|23|
-|45|
-+--+
-OUTPUT
-  end
-end