sequel-sequence 0.4.0 → 0.4.2

data/test/mysql_test_helper.rb

@@ -31,4 +31,9 @@ module MysqlTestHelper
 
     Class.new(migration_class, &block).new(MysqlDB)
   end
+
+  def sequence_table_exists?(name)
+    table_list = MysqlDB.fetch('SHOW TABLES;').all.map { |_key, value| value }
+    table_list.include?(name)
+  end
 end

data/test/postgresql_test_helper.rb

@@ -13,8 +13,10 @@ PostgresqlDB = Sequel.connect(
 
 module PostgresqlTestHelper
   def recreate_table
-    PostgresqlDB.run 'DROP TABLE IF EXISTS things'
+    PostgresqlDB.run 'DROP TABLE IF EXISTS masters'
     PostgresqlDB.run 'DROP SEQUENCE IF EXISTS position'
+    PostgresqlDB.run 'DROP SEQUENCE IF EXISTS position_id'
+    PostgresqlDB.run 'DROP TABLE IF EXISTS things'
     PostgresqlDB.run 'DROP SEQUENCE IF EXISTS a'
     PostgresqlDB.run 'DROP SEQUENCE IF EXISTS b'
     PostgresqlDB.run 'DROP SEQUENCE IF EXISTS c'

data/test/sequel/mariadb_sequence_test.rb

@@ -72,40 +72,77 @@ class MariadbSequenceTest < Minitest::Test
     assert_equal 3, MariaDB.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
 
-    MariaDB.nextval(:position)
-
-    assert_equal 1, MariaDB.currval(:position)
-    assert_equal 1, MariaDB.lastval(:position)
     assert_equal 1, MariaDB.currval(:position)
     assert_equal 1, MariaDB.lastval(:position)
+
+    MariaDB.nextval(:position)
+
+    assert_equal 2, MariaDB.currval(:position)
+    assert_equal 2, MariaDB.lastval(:position)
   end
 
-  test 'sets sequence value' do
+  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
+        create_sequence :position, start: 2, increment: 3
       end
     end.up
 
+    assert_equal 2, MariaDB.currval(:position)
+    assert_equal 2, MariaDB.lastval(:position)
+
     MariaDB.nextval(:position)
+
+    assert_equal 5, MariaDB.currval(:position)
+    assert_equal 5, MariaDB.lastval(:position)
+  end
+
+  test 'sets a new sequence value greater than the current one' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
     assert_equal MariaDB.currval(:position), 1
 
     MariaDB.setval(:position, 101)
-    # in MariaDB, 'lastval' only works after 'nextval' rather than  'setval'
-    assert_equal 1, MariaDB.lastval(:position)
+    # assert_equal 1, MariaDB.lastval(:position)
+    # we observe the modified behavior of the method
+    assert_equal 101, MariaDB.lastval(:position)
 
     MariaDB.nextval(:position)
-    # now the value is correct
+    # the value is correct in any case
     assert_equal 102, MariaDB.lastval(:position)
   end
 
+  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
+      end
+    end.up
+
+    assert_equal MariaDB.currval(:position), 100
+
+    MariaDB.nextval(:position)
+    assert_equal MariaDB.currval(:position), 101
+
+    MariaDB.setval(:position, 1)
+    assert_equal 101, MariaDB.lastval(:position)
+
+    assert_equal 102, MariaDB.nextval(:position)
+  end
+
   test 'drops sequence and check_sequences' do
     with_migration do
       def up
@@ -125,14 +162,18 @@ class MariadbSequenceTest < Minitest::Test
       end
     end.down
 
-    sequence = MariaDB.check_sequences.find do |seq|
-      seq[:Tables_in_test] == 'position'
-    end
+    sequence = MariaDB.check_sequences
 
-    assert_nil sequence
+    assert_equal 0, sequence.size
   end
 
   test 'orders sequences' do
+    with_migration do
+      def up
+        drop_table :wares, if_exists: true
+      end
+    end.up
+
     list = MariaDB.check_sequences.map { |s| s[:Tables_in_test] }
     assert !list.include?('a')
     assert !list.include?('b')
@@ -140,7 +181,6 @@ class MariadbSequenceTest < Minitest::Test
 
     with_migration do
       def up
-        drop_table :things, if_exists: true
         create_sequence :c
         create_sequence :a
         create_sequence :b
@@ -153,10 +193,21 @@ class MariadbSequenceTest < Minitest::Test
     assert list.include?('c')
   end
 
+  test 'checks custom sequence generated from code' do
+    assert_equal MariaDB.custom_sequence?(:c), false
+
+    with_migration do
+      def up
+        create_sequence :c
+      end
+    end.up
+
+    assert_equal MariaDB.custom_sequence?(:c), true
+  end
+
   test 'creates table that references sequence' do
     with_migration do
       def up
-        drop_table :builders, if_exists: true
         create_sequence :position_id, if_exists: false, start: 1
         create_table :builders do
           primary_key :id

data/test/sequel/mock_sequence_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'mock_test_helper'
+
+class MockSequenceTest < Minitest::Test
+  test 'checks check_options with params' do
+    mocked_method = Minitest::Mock.new
+    some_instance = MockDB
+
+    mocked_method.expect :call, true, [Sequel::Database::DANGER_OPT_INCREMENT]
+    some_instance.stub :log_info, mocked_method do
+      some_instance.check_options({ increment: 2 })
+    end
+    mocked_method.verify
+
+    mocked_method.expect :call, true, [Sequel::Database::DANGER_OPT_INCREMENT]
+    some_instance.stub :log_info, mocked_method do
+      some_instance.check_options({ step: 2 })
+    end
+    mocked_method.verify
+  end
+
+  test 'checks custom_sequence?' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.custom_sequence?(:position)
+    end
+  end
+
+  test 'checks check_sequences' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.check_sequences
+    end
+  end
+
+  test 'checks create_sequence' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.create_sequence(:position)
+    end
+  end
+
+  test 'checks drop_sequence' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.drop_sequence(:position)
+    end
+  end
+
+  test 'checks quote_name' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.quote_name(:position)
+    end
+  end
+
+  test 'checks quote' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.quote(:position)
+    end
+  end
+
+  test 'checks nextval_with_label' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.nextval_with_label(:position, 100)
+    end
+  end
+
+  test 'checks nextval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.nextval(:position)
+    end
+  end
+
+  test 'checks currval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.currval(:position)
+    end
+  end
+
+  test 'checks lastval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.lastval(:position)
+    end
+  end
+
+  test 'checks setval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.setval(:position, 100)
+    end
+  end
+
+  test 'checks build_exists_condition for a true condition' do
+    assert_equal Sequel::Database::IF_EXISTS, MockDB.build_exists_condition(true)
+  end
+
+  test 'checks build_exists_condition for a false condition' do
+    assert_equal Sequel::Database::IF_NOT_EXISTS, MockDB.build_exists_condition(false)
+  end
+
+  test 'checks build_exists_condition for a non boolean condition' do
+    assert_nil MockDB.build_exists_condition('')
+  end
+end

data/test/sequel/mysql_sequence_test.rb

@@ -91,20 +91,41 @@ class MysqlSequenceTest < Minitest::Test
     assert_operator (2 + @step), :>, MysqlDB.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, MysqlDB.currval(:position)
+    assert_equal 1, MysqlDB.lastval(:position)
+
     MysqlDB.nextval(:position)
-    # changed value (=2) after default one (=1)
 
     assert_equal 2, MysqlDB.currval(:position)
     assert_equal 2, MysqlDB.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, MysqlDB.currval(:position)
     assert_equal 2, MysqlDB.lastval(:position)
+
+    MysqlDB.nextval(:position)
+
+    # Doesn't support 'increment' value
+    assert_equal 3, MysqlDB.currval(:position)
+    assert_equal 3, MysqlDB.lastval(:position)
   end
 
   test 'sets a new sequence value greater than the current one' do
@@ -125,7 +146,7 @@ class MysqlSequenceTest < Minitest::Test
     assert_equal 102, MysqlDB.nextval(: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
@@ -215,6 +236,12 @@ class MysqlSequenceTest < Minitest::Test
   end
 
   test 'orders sequences' do
+    with_migration do
+      def up
+        drop_table :stuffs, if_exists: true
+      end
+    end.up
+
     list = MysqlDB.check_sequences.map { |s| s[:name] }
     assert !list.include?('a')
     assert !list.include?('b')
@@ -222,7 +249,6 @@ class MysqlSequenceTest < 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
@@ -235,18 +261,6 @@ class MysqlSequenceTest < Minitest::Test
     assert list.include?('c')
   end
 
-  test 'checks custom sequence generated from code' do
-    assert_equal MysqlDB.custom_sequence?(:c), false
-
-    with_migration do
-      def up
-        create_sequence :c
-      end
-    end.up
-
-    assert_equal MysqlDB.custom_sequence?(:c), true
-  end
-
   test 'recreates the same sequence with the same start value' do
     with_migration do
       def up
@@ -352,4 +366,32 @@ class MysqlSequenceTest < Minitest::Test
 
     assert_equal pos4 - pos2, 2
   end
+
+  test 'checks custom sequence generated from code' do
+    assert_equal MysqlDB.custom_sequence?(:c), false
+
+    with_migration do
+      def up
+        create_sequence :c
+      end
+    end.up
+
+    assert_equal MysqlDB.custom_sequence?(:c), true
+  end
+
+  test "catches a Mysql2::Error: «Table mysql_sequence doesn't exist»" do
+    assert !sequence_table_exists?('position')
+
+    MysqlDB.drop_table :mysql_sequence, if_exists: true
+
+    last_number = MysqlDB.lastval(:position)
+    assert_nil last_number
+  end
+
+  test 'creates a Sequence by calling DB.setval(position, 1) if it still does not exist' do
+    assert !sequence_table_exists?('position')
+
+    MysqlDB.setval(:position, 100)
+    assert_equal 100, MysqlDB.currval(:position)
+  end
 end

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

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
@@ -166,9 +187,7 @@ class SqliteSequenceTest < Minitest::Test
       end
     end.down
 
-    sequence = SQLiteDB.check_sequences.find do |seq|
-      seq[:name] == 'position'
-    end
+    sequence = (list = SQLiteDB.check_sequences).empty? ? nil : list
 
     assert_nil sequence
   end
@@ -192,14 +211,18 @@ class SqliteSequenceTest < Minitest::Test
       end
     end.down
 
-    sequence = SQLiteDB.check_sequences.find do |seq|
-      seq[:name] == 'position'
-    end
+    sequence = (list = SQLiteDB.check_sequences).empty? ? nil : list
 
     assert_nil sequence
   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')
@@ -207,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
@@ -295,7 +317,6 @@ class SqliteSequenceTest < Minitest::Test
   test 'creates table that references sequence' do
     with_migration do
       def up
-        drop_table :apprentices, if_exists: true
         create_sequence :position_id, if_exists: false, start: 1
         create_table :apprentices do
           primary_key :id
@@ -326,4 +347,23 @@ 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
 end

data/test/sqlite_test_helper.rb

@@ -10,9 +10,10 @@ SQLiteDB = Sequel.connect(
 
 module SqliteTestHelper
   def recreate_table
+    SQLiteDB.drop_table :apprentices, if_exists: true
     SQLiteDB.drop_sequence :position
     SQLiteDB.drop_sequence :position_id, if_exists: true
-    SQLiteDB.run 'DROP TABLE IF EXISTS objects'
+    SQLiteDB.drop_table :objects, if_exists: true
     SQLiteDB.drop_sequence 'a'
     SQLiteDB.drop_sequence 'b'
     SQLiteDB.drop_sequence 'c'
@@ -27,4 +28,10 @@ module SqliteTestHelper
 
     Class.new(migration_class, &block).new(SQLiteDB)
   end
+
+  def sequence_table_exists?(name)
+    sql = "SELECT name FROM sqlite_schema WHERE type ='table' AND name NOT LIKE 'sqlite_%';"
+    table_list = SQLiteDB.fetch(sql).all.map { |_key, value| value }
+    table_list.include?(name)
+  end
 end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'simplecov'
+
 SimpleCov.start
 
 require 'bundler/setup'