sequel-sequence 0.4.1 → 0.5.0

data/test/sequel/postgresql_sequence_test.rb

@@ -72,33 +72,80 @@ class PostgresqlSequenceTest < Minitest::Test
     assert_equal 3, PostgresqlDB.nextval(:position)
   end
 
-  test "returns current/last sequence value, which doesn't increase by itself" do
+  test %( returns current/last sequence value, which doesn't increase by itself
+          for migration WITHOUT 'start' or 'increment' values ) do
     with_migration do
       def up
-        create_sequence :position, start: 2, increment: 2
+        create_sequence :position
       end
     end.up
 
+    # catch the 'start' value
+    assert_equal 1, PostgresqlDB.currval(:position)
+    # is the same value
+    assert_equal 1, PostgresqlDB.lastval(:position)
+
     PostgresqlDB.nextval(:position)
 
     assert_equal 2, PostgresqlDB.currval(:position)
     assert_equal 2, PostgresqlDB.lastval(:position)
+  end
+
+  test %( returns current/last sequence value, which doesn't increase by itself
+          for migration WITH 'start' and 'increment' values ) do
+    with_migration do
+      def up
+        create_sequence :position, start: 2, increment: 3
+      end
+    end.up
+
+    # catch the 'start' value
     assert_equal 2, PostgresqlDB.currval(:position)
+    # is the same value
     assert_equal 2, PostgresqlDB.lastval(:position)
+
+    PostgresqlDB.nextval(:position)
+
+    # support 'increment' value
+    assert_equal 5, PostgresqlDB.currval(:position)
+    assert_equal 5, PostgresqlDB.lastval(:position)
   end
 
-  test 'sets sequence value' do
+  test 'sets a new sequence value greater than the current one' do
     with_migration do
       def up
         create_sequence :position
       end
     end.up
 
-    PostgresqlDB.nextval(:position)
     assert_equal PostgresqlDB.currval(:position), 1
 
+    PostgresqlDB.nextval(:position)
+    assert_equal PostgresqlDB.currval(:position), 2
+
     PostgresqlDB.setval(:position, 101)
-    assert_equal 101, PostgresqlDB.currval(:position)
+    assert_equal 101, PostgresqlDB.lastval(:position)
+
+    assert_equal 102, PostgresqlDB.nextval(:position)
+  end
+
+  test 'sets a new sequence value less than the current one (change the value as an EXCEPTION)' do
+    with_migration do
+      def up
+        create_sequence :position, start: 100
+      end
+    end.up
+
+    assert_equal PostgresqlDB.currval(:position), 100
+
+    PostgresqlDB.nextval(:position)
+    assert_equal PostgresqlDB.currval(:position), 101
+
+    PostgresqlDB.setval(:position, 1)
+    assert_equal 1, PostgresqlDB.lastval(:position)
+
+    PostgresqlDB.nextval(:position)
+    assert_equal 2, PostgresqlDB.lastval(:position)
   end
 
   test 'drops sequence and check_sequences' do
@@ -128,6 +175,12 @@ class PostgresqlSequenceTest < Minitest::Test
   end
 
   test 'orders sequences' do
+    with_migration do
+      def up
+        drop_table :things, if_exists: true
+      end
+    end.up
+
     list = PostgresqlDB.check_sequences.map { |s| s[:sequence_name] }
     assert !list.include?('a')
     assert !list.include?('b')
@@ -135,7 +188,6 @@ class PostgresqlSequenceTest < Minitest::Test
 
     with_migration do
       def up
-        drop_table :things, if_exists: true
         create_sequence :c
         create_sequence :a
         create_sequence :b
@@ -186,4 +238,102 @@ class PostgresqlSequenceTest < Minitest::Test
 
     assert_equal pos2 - pos1, 1
   end
+
+  test 'checks exception for delete_to_currval method' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, PostgresqlDB.currval(:position_id)
+
+    assert_raises Sequel::MethodNotAllowed do
+      PostgresqlDB.delete_to_currval(:position_id)
+    end
+  end
+
+  test 'deletes sequences by "drop_sequence?"' do
+    with_migration do
+      def up
+        create_sequence :a
+        create_sequence :b
+        create_sequence :c
+      end
+    end.up
+
+    assert PostgresqlDB.custom_sequence?(:a)
+    assert PostgresqlDB.custom_sequence?(:b)
+    assert PostgresqlDB.custom_sequence?(:c)
+
+    PostgresqlDB.drop_sequence?(:a, :b, :c, :d)
+
+    assert !PostgresqlDB.custom_sequence?(:a)
+    assert !PostgresqlDB.custom_sequence?(:b)
+    assert !PostgresqlDB.custom_sequence?(:c)
+  end
+
+  test 'deletes if exists before creating! the sequence' do
+    with_migration do
+      def up
+        create_sequence! :position, { start: 1000, increment: 10 }
+      end
+    end.up
+
+    assert_equal 1000, PostgresqlDB.currval(:position)
+
+    10.times { PostgresqlDB.nextval(:position) }
+    assert_equal 1100, PostgresqlDB.currval(:position)
+
+    PostgresqlDB.create_sequence!(:position, { start: 1, increment: 1 })
+
+    assert_equal 1, PostgresqlDB.currval(:position)
+
+    10.times { PostgresqlDB.nextval(:position) }
+    assert_equal 11, PostgresqlDB.currval(:position)
+  end
+
+  test 'checks the BIGINT primery key for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { start: 9_223_372_036_854_775_800 }
+      end
+    end.up
+
+    assert_equal 9_223_372_036_854_775_800, PostgresqlDB.currval(:position)
+    assert_equal 9_223_372_036_854_775_801, PostgresqlDB.nextval(:position)
+  end
+
+  test 'checks the BIGINT primery key with negative value for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { minvalue: -9_223_372_036_854_775_808 }
+      end
+    end.up
+
+    assert_equal(-9_223_372_036_854_775_808, PostgresqlDB.currval(:position))
+    assert_equal(-9_223_372_036_854_775_807, PostgresqlDB.nextval(:position))
+  end
+
+  # https://www.postgresql.org/docs/current/sql-createsequence.html
+  test 'adds sequence with ext. params' do
+    with_migration do
+      def up
+        create_sequence :position, {
+          data_type: 'smallint',
+          minvalue: -250,
+          maxvalue: 250,
+          start: -1,
+          cache: 3,
+          cycle: 'CYCLE',
+          owned_by: 'NONE',
+          increment: 2,
+          if_exists: false
+        }
+      end
+    end.up
+
+    assert_equal(-1, PostgresqlDB.nextval('position'))
+    assert_equal 1, PostgresqlDB.nextval('position')
+  end
 end

data/test/sequel/sqlite_sequence_test.rb

@@ -76,20 +76,41 @@ class SqliteSequenceTest < Minitest::Test
     assert_operator (2 + @step), :>, SQLiteDB.nextval(:position)
   end
 
-  test "returns current/last sequence value, which doesn't increase by itself" do
+  test %( returns current/last sequence value, which doesn't increase by itself
+          for migration WITHOUT 'start' or 'increment' values ) do
     with_migration do
       def up
         create_sequence :position
       end
     end.up
 
+    # catch the 'start' value 'by default
+    assert_equal 1, SQLiteDB.currval(:position)
+    assert_equal 1, SQLiteDB.lastval(:position)
+
     SQLiteDB.nextval(:position)
-    # changed value (=2) after default one (=1)
 
     assert_equal 2, SQLiteDB.currval(:position)
     assert_equal 2, SQLiteDB.lastval(:position)
+  end
+
+  test %( returns current/last sequence value, which doesn't increase by itself
+          for migration WITH 'start' and 'increment' values ) do
+    with_migration do
+      def up
+        create_sequence :position, start: 2, increment: 3
+      end
+    end.up
+
+    # catch the 'start' value
     assert_equal 2, SQLiteDB.currval(:position)
     assert_equal 2, SQLiteDB.lastval(:position)
+
+    SQLiteDB.nextval(:position)
+
+    # Doesn't support 'increment' value
+    assert_equal 3, SQLiteDB.currval(:position)
+    assert_equal 3, SQLiteDB.lastval(:position)
   end
 
   test 'sets a new sequence value greater than the current one' do
@@ -111,7 +132,7 @@ class SqliteSequenceTest < Minitest::Test
     assert_equal 102, SQLiteDB.lastval(:position)
   end
 
-  test 'sets a new sequence value less than the current one' do
+  test 'sets a new sequence value less than the current one (does not change the value)' do
     with_migration do
       def up
         create_sequence :position, start: 100
@@ -196,6 +217,12 @@ class SqliteSequenceTest < Minitest::Test
   end
 
   test 'orders sequences' do
+    with_migration do
+      def up
+        drop_table :objects, if_exists: true
+      end
+    end.up
+
     list = SQLiteDB.check_sequences.map { |s| s[:name] }
     assert !list.include?('a')
     assert !list.include?('b')
@@ -203,7 +230,6 @@ class SqliteSequenceTest < Minitest::Test
 
     with_migration do
       def up
-        drop_table :things, if_exists: true
         create_sequence :c, { start: 1 }
         create_sequence :a, { start: 3 }
         create_sequence :b
@@ -322,10 +348,111 @@ class SqliteSequenceTest < Minitest::Test
     assert_equal pos4 - pos2, 2
   end
 
+  test 'checks custom sequence generated from code' do
+    assert_equal SQLiteDB.custom_sequence?(:c), false
+
+    with_migration do
+      def up
+        create_sequence :c
+      end
+    end.up
+
+    assert_equal SQLiteDB.custom_sequence?(:c), true
+  end
+
   test 'creates a Sequence by calling DB.setval(position, 1) if it still does not exist' do
     assert !sequence_table_exists?('position')
 
     SQLiteDB.setval(:position, 100)
     assert_equal 100, SQLiteDB.currval(:position)
   end
+
+  test 'deletes history from the sequence_table' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, SQLiteDB.currval(:position_id)
+
+    sequence_table_size = SQLiteDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 1, sequence_table_size
+
+    10.times { SQLiteDB.nextval(:position_id) }
+
+    assert_equal 11, SQLiteDB.currval(:position_id)
+
+    sequence_table_size = SQLiteDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 11, sequence_table_size
+
+    SQLiteDB.delete_to_currval(:position_id)
+
+    assert_equal 11, SQLiteDB.currval(:position_id)
+
+    sequence_table_size = SQLiteDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 1, sequence_table_size
+  end
+
+  test 'deletes sequences by "drop_sequence?"' do
+    with_migration do
+      def up
+        create_sequence :a
+        create_sequence :b
+        create_sequence :c
+      end
+    end.up
+
+    assert SQLiteDB.custom_sequence?(:a)
+    assert SQLiteDB.custom_sequence?(:b)
+    assert SQLiteDB.custom_sequence?(:c)
+
+    SQLiteDB.drop_sequence?(:a, :b, :c, :d)
+
+    assert !SQLiteDB.custom_sequence?(:a)
+    assert !SQLiteDB.custom_sequence?(:b)
+    assert !SQLiteDB.custom_sequence?(:c)
+  end
+
+  test 'deletes if exists before creating! the sequence' do
+    with_migration do
+      def up
+        create_sequence! :position, { start: 1000, increment: 10 }
+      end
+    end.up
+
+    assert_equal 1000, SQLiteDB.currval(:position)
+
+    10.times { SQLiteDB.nextval(:position) }
+    assert_equal 1010, SQLiteDB.currval(:position)
+
+    SQLiteDB.create_sequence!(:position, { start: 1, increment: 1 })
+
+    assert_equal 1, SQLiteDB.currval(:position)
+
+    10.times { SQLiteDB.nextval(:position) }
+    assert_equal 11, SQLiteDB.currval(:position)
+  end
+
+  test 'checks the BIGINT primery key for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { start: 9_223_372_036_854_775_800 }
+      end
+    end.up
+
+    assert_equal 9_223_372_036_854_775_800, SQLiteDB.currval(:position)
+    assert_equal 9_223_372_036_854_775_801, SQLiteDB.nextval(:position)
+  end
+
+  test 'checks the BIGINT primery key with negative value for a sequence table (does not support)' do
+    with_migration do
+      def up
+        create_sequence :position, { start: -9_223_372_036_854_775_807 }
+      end
+    end.up
+
+    assert_equal 0, SQLiteDB.currval(:position)
+    assert_equal 1, SQLiteDB.nextval(:position)
+  end
 end

data/test/sqlite_test_helper.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'logger'
+# require 'logger'
 
 SQLiteDB = Sequel.connect(
-  "sqlite://#{ENV.fetch('TEST_SQLITE_DATABASE', nil) || 'db/test.sqlite3'}",
-  loggers: [Logger.new($stdout)]
+  # loggers: [Logger.new($stdout)],
+  "sqlite://#{ENV.fetch('TEST_SQLITE_DATABASE', nil) || 'db/test.sqlite3'}"
 )
 
 module SqliteTestHelper

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-sequence
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Nikolai Bocharov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-28 00:00:00.000000000 Z
+date: 2023-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -19,7 +19,7 @@ dependencies:
         version: '5.28'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.73'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: '5.28'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.73'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -114,50 +114,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.22.0
-- !ruby/object:Gem::Dependency
-  name: mysql2
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.5.3
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.5.3
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.4
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.5.4
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.6.0
 description: |2
-      This gem provides a single interface for SEQUENCE functionality
+      This gem provides a single user-friendly interface for SEQUENCE functionality
       in Postgresql and MariaDB DBMS within the Sequel ORM.
       It also models the Sequences to meet the needs of SQLite and MySQL users.
 email:
@@ -168,6 +126,7 @@ extra_rdoc_files:
 - README.md
 - LICENSE.md
 files:
+- ".ci.gemfile"
 - ".github/ISSUE_TEMPLATE/bug_report.md"
 - ".github/ISSUE_TEMPLATE/feature_request.md"
 - ".github/PULL_REQUEST_TEMPLATE.md"