tdiary 5.2.2 → 5.2.3

data/vendor/bundle/ruby/3.1.0/gems/sequel-5.56.0/doc/testing.rdoc

@@ -1,186 +0,0 @@
-= Testing with Sequel
-
-Whether or not you use Sequel in your application, you are usually going to want to have tests that ensure that your code works.  When you are using Sequel, it's helpful to integrate it into your testing framework, and it's generally best to run each test in its own transaction if possible.  That keeps all tests isolated from each other, and it's simple as it handles all of the cleanup for you.  Sequel doesn't ship with helpers for common libraries, as the exact code you need is often application-specific, but this page offers some examples that you can either use directly or build on.
-
-== Transactional tests
-
-These run each test in its own transaction, the recommended way to test.
-
-=== minitest/spec
-
-==== with minitest-hooks    
-  require 'minitest/hooks/default'
-  
-  DB = Sequel.postgres # change if using sqlite etc
-  
-  class Minitest::HooksSpec
-    def around
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
-    end
-  end
-
-==== without minitest-hooks  
-  DB = Sequel.postgres # change if using sqlite etc
-  
-  class Minitest::Spec
-    def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
-    end
-  end
-
-=== minitest/test
-  DB = Sequel.postgres # change if using sqlite etc
-  
-  # Use this class as the base class for your tests
-  class SequelTestCase < Minitest::Test
-    def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
-    end
-  end
-
-=== rspec >= 2.8
-  DB = Sequel.postgres # change the database if you are using sqlite etc.
-  
-  RSpec.configure do |c|
-    c.around(:each) do |example|
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}
-    end
-  end
-
-== Transactional testing with multiple databases
-
-You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:
-
-  DB.transaction(:rollback=>:always)
-
-Use Sequel.transaction with an array of databases:
-
-  Sequel.transaction([DB1, DB2, DB3], :rollback=>:always)
-
-== Transactional testing with savepoints
-
-Using minitest/spec and minitest-hooks, and assuming your database supports it, you can use
-transactions around entire test suites, using savepoints around each test.  This can sigificantly
-speed up any test suite where there is a lot of shared setup in a before all hook.  By using
-savepoints per test, each test is isolated from each other, rolling back changes after it
-completes, and by using transactions per test suite, you only pay the cost to load the data once
-for the test suite, and it is automatically rolled back after the test suite completes.
-
-Example:
-
-  require 'minitest/hooks/default'
-  class Minitest::HooksSpec
-    def around
-      DB.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
-    end
-
-    def around_all
-      DB.transaction(:rollback=>:always){super}
-    end
-  end
-
-  describe "some large test suite" do
-    before(:all) do
-      DB[:table].import # Large number of rows
-    end
-  end
-
-== Nontransactional tests
-
-In some cases, it is not possible to use transactions.  For example, if you are testing a web application that is running in a separate process, you don't have access to that process's database connections, so you can't run your examples in transactions.  In that case, the best way to handle things is to cleanup after each test by deleting or truncating the database tables used in the test.
-
-The order in which you delete/truncate the tables is important if you are using referential integrity in your database (which you should be doing).  If you are using referential integrity, you need to make sure to delete in tables referencing other tables before the tables that are being referenced.  For example, if you have an +albums+ table with an +artist_id+ field referencing the +artists+ table, you want to delete/truncate the +albums+ table before the +artists+ table.  Note that if you have cyclic references in your database, you will probably need to write your own custom cleaning code.
-
-=== minitest/spec or rspec
-
-  describe "some test suite" do
-    after do
-      [:table1, :table2].each{|x| DB.from(x).truncate}
-      # or
-      [:table1, :table2].each{|x| DB.from(x).delete}
-    end
-  end
-
-=== minitest/test
-
-  class SomeTestClass < Minitest::Test
-    def teardown
-      [:table1, :table2].each{|x| DB.from(x).truncate}
-      # or
-      [:table1, :table2].each{|x| DB.from(x).delete}
-    end
-  end
-
-= Testing Sequel Itself
-
-Sequel has multiple separate test suites.  All test suites use minitest/spec, with the minitest-hooks, minitest-global_expectations, and minitest-shared_description extensions.  To install the dependencies necessary to test Sequel, run <tt>gem install --development sequel</tt>.
-
-== rake
-
-The default rake task runs Sequel's core, model, plugin, and extension specs, the same as <tt>rake spec</tt> or <tt>rake spec_core spec_model spec_plugin</tt>.
-
-== rake spec_core
-
-The +spec_core+ rake task runs Sequel's core specs.  These specs use a mocked database connection, and test for specific SQL used and for generally correct behavior.
-
-== rake spec_model
-
-The +spec_model+ rake task runs Sequel's model specs.  These specs also use a mocked database connection, and operate similar to the core tests.
-
-== rake spec_plugin
-
-The +spec_plugin+ rake task runs the specs for the plugins and extensions that ship with Sequel.  These also use a mocked database connection, and operate very similarly to the general Sequel core and model specs.
-
-== rake spec_core_ext
-
-The +spec_core_ext+ rake task runs the specs for the core_extensions extension.  These are run separately from the other extension tests to make sure none of the other extensions require the core_extensions.
-
-== rake spec_bin
-
-The +spec_bin+ rake task runs the specs for bin/sequel.  These use an SQLite3 database, and require either the sqlite3 (non-JRuby) or jdbc-sqlite3 (JRuby) gem.
-
-== rake spec_<i>adapter</i> (e.g. rake spec_postgres)
-
-The <tt>spec_<i>adapter</i></tt> specs run against a real database connection with nothing mocked, and test for correct results.  They are slower than the standard specs, but they will catch errors that are mocked out by the default specs, as well as show issues that only occur on a certain database, adapter, or a combination of the two.
-
-These specs are broken down into two parts.  For each database, there are specific specs that only apply to that database, and these are called the adapter specs.  There are also shared specs that apply to all (or almost all) databases, these are called the integration specs. For database types that don't have specific adapter tests, you can use <tt>rake spec_integration</tt> to just run the shared integration tests.
-
-Each adapter needs a specific gem installed in order to run.  Please see the {connecting to a database guide}[rdoc-ref:doc/opening_databases.rdoc] for which gem you need to install for the adapter you are testing.
-
-== Environment variables
-
-Sequel uses environment variables when testing to specify either the database to be tested or specify how testing should be done.  You can also specify the databases to test by copying <tt>spec/spec_config.rb.example</tt> to <tt>spec/spec_config.rb</tt> and modifying it.  See that file for details.  It may be necessary to use +spec_config.rb+ as opposed to an environment variable if your database connection cannot be specified by a connection string.
-
-Sequel does not create test databases automatically, except for file-based databases such as SQLite/H2/HSQLDB/Derby.  It's up to the user to create the test databases manually and give Sequel a valid connection string in an environment variable (or setup the connection object in +spec_config.rb+).
-
-=== Connection Strings
-
-The SEQUEL_INTEGRATION_URL environment variable specifies the Database connection URL to use for the adapter and integration specs.  Additionally, when running the adapter specs, you can also use the SEQUEL_<i>ADAPTER</i>_URL environment variable (e.g. SEQUEL_POSTGRES_URL for spec_postgres).
-
-=== Other
-
-SEQUEL_ASYNC_THREAD_POOL :: Use the async_thread_pool extension when running the specs
-SEQUEL_ASYNC_THREAD_POOL_PREEMPT :: Use the async_thread_pool extension when running the specs, with the :preempt_async_thread option
-SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
-SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
-SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
-SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
-SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
-SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
-SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
-SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
-SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
-SEQUEL_INTEGER64 :: Use the integer64 extension when running the adapter or integration specs
-SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when running the specs
-SEQUEL_MODEL_THROW_FAILURES :: Use the throw_failures plugin when running the specs
-SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
-SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
-SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
-SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
-SEQUEL_QUERY_PER_ASSOCIATION_DB_0_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
-SEQUEL_QUERY_PER_ASSOCIATION_DB_1_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
-SEQUEL_QUERY_PER_ASSOCIATION_DB_2_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
-SEQUEL_QUERY_PER_ASSOCIATION_DB_3_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
-SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
-SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs
-SEQUEL_TZINFO_VERSION :: Force the given tzinfo version when running the specs (e.g. '>=2')

data/vendor/bundle/ruby/3.1.0/gems/sequel-5.56.0/lib/sequel/adapters/jdbc/derby.rb

@@ -1,313 +0,0 @@
-# frozen-string-literal: true
-
-Sequel::JDBC.load_driver('org.apache.derby.jdbc.EmbeddedDriver', :Derby)
-require_relative 'transactions'
-require_relative '../utils/columns_limit_1'
-
-module Sequel
-  module JDBC
-    Sequel.synchronize do
-      DATABASE_SETUP[:derby] = proc do |db|
-        db.extend(Sequel::JDBC::Derby::DatabaseMethods)
-        db.dataset_class = Sequel::JDBC::Derby::Dataset
-        org.apache.derby.jdbc.EmbeddedDriver
-      end
-    end
-
-    module Derby
-      module DatabaseMethods
-        include ::Sequel::JDBC::Transactions
-
-        # Derby doesn't support casting integer to varchar, only integer to char,
-        # and char(254) appears to have the widest support (with char(255) failing).
-        # This does add a bunch of extra spaces at the end, but those will be trimmed
-        # elsewhere.
-        def cast_type_literal(type)
-          (type == String) ? 'CHAR(254)' : super
-        end
-
-        def database_type
-          :derby
-        end
-
-        def freeze
-          svn_version
-          super
-        end
-
-        # Derby uses an IDENTITY sequence for autoincrementing columns.
-        def serial_primary_key_options
-          {:primary_key => true, :type => Integer, :identity=>true, :start_with=>1}
-        end
-
-        # The SVN version of the database.
-        def svn_version
-          @svn_version ||= begin
-            v = synchronize{|c| c.get_meta_data.get_database_product_version}
-            v =~ /\((\d+)\)\z/
-            $1.to_i
-          end
-        end
-        
-        # Derby supports transactional DDL statements.
-        def supports_transactional_ddl?
-          true
-        end
-
-        private
-        
-        # Derby optimizes away Sequel's default check of SELECT NULL FROM table,
-        # so use a SELECT * FROM table there.
-        def _table_exists?(ds)
-          ds.first
-        end
-    
-        def alter_table_sql(table, op)
-          case op[:op]
-          when :rename_column
-            "RENAME COLUMN #{quote_schema_table(table)}.#{quote_identifier(op[:name])} TO #{quote_identifier(op[:new_name])}"
-          when :set_column_type
-            # Derby is very limited in changing a columns type, so adding a new column and then dropping the existing column is
-            # the best approach, as mentioned in the Derby documentation.
-            temp_name = :x_sequel_temp_column_x
-            [alter_table_sql(table, op.merge(:op=>:add_column, :name=>temp_name)),
-             from(table).update_sql(temp_name=>::Sequel::SQL::Cast.new(op[:name], op[:type])),
-             alter_table_sql(table, op.merge(:op=>:drop_column)),
-             alter_table_sql(table, op.merge(:op=>:rename_column, :name=>temp_name, :new_name=>op[:name]))]
-          when :set_column_null
-            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{op[:null] ? 'NULL' : 'NOT NULL'}"
-          else
-            super
-          end
-        end
-
-        # Derby does not allow adding primary key constraints to NULLable columns.
-        def can_add_primary_key_constraint_on_nullable_columns?
-          false
-        end
-
-        # Derby doesn't allow specifying NULL for columns, only NOT NULL.
-        def column_definition_null_sql(sql, column)
-          null = column.fetch(:null, column[:allow_null])
-          sql << " NOT NULL" if null == false || (null.nil? && column[:primary_key])
-        end
-    
-        # Add NOT LOGGED for temporary tables to improve performance.
-        def create_table_sql(name, generator, options)
-          s = super
-          s += ' NOT LOGGED' if options[:temp]
-          s
-        end
-
-        # Insert data from the current table into the new table after
-        # creating the table, since it is not possible to do it in one step.
-        def create_table_as(name, sql, options)
-          super
-          from(name).insert(sql.is_a?(Dataset) ? sql : dataset.with_sql(sql))
-        end
-
-        # Derby currently only requires WITH NO DATA, with a separate insert
-        # to import data.
-        def create_table_as_sql(name, sql, options)
-          "#{create_table_prefix_sql(name, options)} AS #{sql} WITH NO DATA"
-        end
-
-        # Temporary table creation on Derby uses DECLARE instead of CREATE.
-        def create_table_prefix_sql(name, options)
-          if options[:temp]
-            "DECLARE GLOBAL TEMPORARY TABLE #{quote_identifier(name)}"
-          else
-            super
-          end
-        end
-
-        DATABASE_ERROR_REGEXPS = {
-          /The statement was aborted because it would have caused a duplicate key value in a unique or primary key constraint or unique index/ => UniqueConstraintViolation,
-          /violation of foreign key constraint/ => ForeignKeyConstraintViolation,
-          /The check constraint .+ was violated/ => CheckConstraintViolation,
-          /cannot accept a NULL value/ => NotNullConstraintViolation,
-          /A lock could not be obtained due to a deadlock/ => SerializationFailure,
-        }.freeze
-        def database_error_regexps
-          DATABASE_ERROR_REGEXPS
-        end
-
-        # Use IDENTITY_VAL_LOCAL() to get the last inserted id.
-        def last_insert_id(conn, opts=OPTS)
-          statement(conn) do |stmt|
-            sql = 'SELECT IDENTITY_VAL_LOCAL() FROM sysibm.sysdummy1'
-            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
-            rs.next
-            rs.getLong(1)
-          end
-        end
-
-        # Handle nil values by using setNull with the correct parameter type.
-        def set_ps_arg_nil(cps, i)
-          cps.setNull(i, cps.getParameterMetaData.getParameterType(i))
-        end
-      
-        # Derby uses RENAME TABLE syntax to rename tables.
-        def rename_table_sql(name, new_name)
-          "RENAME TABLE #{quote_schema_table(name)} TO #{quote_schema_table(new_name)}"
-        end
-
-        # Primary key indexes appear to be named sqlNNNN on Derby
-        def primary_key_index_re
-          /\Asql\d+\z/i
-        end
-
-        # If an :identity option is present in the column, add the necessary IDENTITY SQL.
-        def type_literal(column)
-          if column[:identity]
-            sql = "#{super} GENERATED BY DEFAULT AS IDENTITY"
-            if sw = column[:start_with]
-              sql += " (START WITH #{sw.to_i}"
-              sql << " INCREMENT BY #{column[:increment_by].to_i}" if column[:increment_by]
-              sql << ")"
-            end
-            sql
-          else
-            super
-          end
-        end
-
-        # Derby uses clob for text types.
-        def uses_clob_for_text?
-          true
-        end
-
-        def valid_connection_sql
-          @valid_connection_sql ||= select(1).sql
-        end
-      end
-      
-      class Dataset < JDBC::Dataset
-        include ::Sequel::Dataset::ColumnsLimit1
-
-        # Derby doesn't support an expression between CASE and WHEN,
-        # so remove conditions.
-        def case_expression_sql_append(sql, ce)
-          super(sql, ce.with_merged_expression)
-        end
-
-        # If the type is String, trim the extra spaces since CHAR is used instead
-        # of varchar.  This can cause problems if you are casting a char/varchar to
-        # a string and the ending whitespace is important.
-        def cast_sql_append(sql, expr, type)
-          if type == String
-            sql << "RTRIM("
-            super
-            sql << ')'
-          else
-            super
-          end
-        end
-
-        def complex_expression_sql_append(sql, op, args)
-          case op
-          when :%, :'B~'
-            complex_expression_emulate_append(sql, op, args)
-          when :&, :|, :^, :<<, :>>
-            raise Error, "Derby doesn't support the #{op} operator"
-          when :**
-            sql << 'exp('
-            literal_append(sql, args[1])
-            sql << ' * ln('
-            literal_append(sql, args[0])
-            sql << "))"
-          when :extract
-            sql << args[0].to_s << '('
-            literal_append(sql, args[1])
-            sql << ')'
-          else
-            super
-          end
-        end
-
-        # Derby supports GROUP BY ROLLUP (but not CUBE)
-        def supports_group_rollup?
-          true
-        end
-
-        # Derby does not support IS TRUE.
-        def supports_is_true?
-          false
-        end
-
-        # Derby does not support IN/NOT IN with multiple columns
-        def supports_multiple_column_in?
-          false
-        end
-
-        private
-
-        def empty_from_sql
-          " FROM sysibm.sysdummy1"
-        end
-
-        # Derby needs a hex string casted to BLOB for blobs.
-        def literal_blob_append(sql, v)
-          sql << "CAST(X'" << v.unpack("H*").first << "' AS BLOB)"
-        end
-
-        # Derby needs the standard workaround to insert all default values into
-        # a table with more than one column.
-        def insert_supports_empty_values?
-          false
-        end
-
-        # Newer Derby versions can use the FALSE literal, but older versions need an always false expression.
-        def literal_false
-          if db.svn_version >= 1040133
-            'FALSE'
-          else
-            '(1 = 0)'
-          end
-        end
-
-        # Derby handles fractional seconds in timestamps, but not in times
-        def literal_sqltime(v)
-          v.strftime("'%H:%M:%S'")
-        end
-
-        # Newer Derby versions can use the TRUE literal, but older versions need an always false expression.
-        def literal_true
-          if db.svn_version >= 1040133
-            'TRUE'
-          else
-            '(1 = 1)'
-          end
-        end
-
-        # Derby supports multiple rows for VALUES in INSERT.
-        def multi_insert_sql_strategy
-          :values
-        end
-
-        # Emulate the char_length function with length
-        def native_function_name(emulated_function)
-          if emulated_function == :char_length
-            'length'
-          else
-            super
-          end
-        end
-
-        # Offset comes before limit in Derby
-        def select_limit_sql(sql)
-          if o = @opts[:offset]
-            sql << " OFFSET "
-            literal_append(sql, o)
-            sql << " ROWS"
-          end
-          if l = @opts[:limit]
-            sql << " FETCH FIRST "
-            literal_append(sql, l)
-            sql << " ROWS ONLY"
-          end
-        end
-      end
-    end
-  end
-end