sequel-sequence 0.3.0 → 0.4.1

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

@@ -12,13 +12,28 @@ class MysqlSequenceTest < Minitest::Test
   test 'adds sequence with default values' do
     with_migration do
       def up
-        # create_sequence :position, {start: 1, increment: 1} - default values
+        # create_sequence :position, {start: 1, increment: 1, numeric_label: 0} - default values
         create_sequence :position
       end
     end.up
 
-    assert_equal 1, MysqlDB.nextval(:position)
     assert_equal 2, MysqlDB.nextval(:position)
+    assert_equal 3, MysqlDB.nextval(:position)
+  end
+
+  test 'adds sequence with numeric_label' do
+    with_migration do
+      def up
+        # create_sequence :position, {start: 1, increment: 1, numeric_label: 0} - default values
+        create_sequence :position, numeric_label: 10
+      end
+    end.up
+
+    assert_equal 1, MysqlDB.currval(:position)
+
+    fiction_list = MysqlDB.fetch('SELECT fiction FROM position;').all
+    assert_equal 1, fiction_list.size
+    assert_equal 10, fiction_list.first[:fiction]
   end
 
   test 'adds sequence reader within model and its inherited class' do
@@ -28,15 +43,15 @@ class MysqlSequenceTest < Minitest::Test
       end
     end.up
 
-    class Ware < Sequel::Model; end
+    class Stuff < Sequel::Model; end
 
-    assert_equal 1, Ware.db.nextval('position')
-    assert_equal 2, Ware.db.nextval('position')
+    assert_equal 2, Stuff.db.nextval('position')
+    assert_equal 3, Stuff.db.nextval('position')
 
-    class InheritedWare < Ware; end
+    class InheritedStuff < Stuff; end
 
-    assert_equal 3, InheritedWare.db.nextval(:position)
-    assert_equal 4, InheritedWare.db.nextval(:position)
+    assert_equal 4, InheritedStuff.db.nextval(:position)
+    assert_equal 5, InheritedStuff.db.nextval(:position)
   end
 
   test 'adds sequence starting at 100' do
@@ -46,30 +61,34 @@ class MysqlSequenceTest < Minitest::Test
       end
     end.up
 
-    assert_equal 100, MysqlDB.nextval(:position)
     assert_equal 101, MysqlDB.nextval(:position)
+    assert_equal 102, MysqlDB.nextval(:position)
   end
 
-  test 'adds sequence incremented by 2' do
+  test 'adds a sequence that we are trying to increase by a value greater than 1' do
+    @step = 4
     with_migration do
       def up
-        create_sequence :position, increment: 2
+        create_sequence :position, increment: 4
       end
     end.up
 
-    assert_equal 1, MysqlDB.nextval(:position)
+    assert_equal 2, MysqlDB.nextval(:position)
     assert_equal 3, MysqlDB.nextval(:position)
+    assert_operator (2 + @step), :>, MysqlDB.nextval(:position)
   end
 
-  test 'adds sequence incremented by 2 (using :step alias)' do
+  test 'adds a sequence that we are trying to increase by a value greater than 1 (using :step alias)' do
+    @step = 4
     with_migration do
       def up
-        create_sequence :position, step: 2
+        create_sequence :position, step: 4
       end
     end.up
 
-    assert_equal 1, MysqlDB.nextval(:position)
+    assert_equal 2, MysqlDB.nextval(:position)
     assert_equal 3, MysqlDB.nextval(:position)
+    assert_operator (2 + @step), :>, MysqlDB.nextval(:position)
   end
 
   test "returns current/last sequence value, which doesn't increase by itself" do
@@ -80,33 +99,70 @@ class MysqlSequenceTest < Minitest::Test
     end.up
 
     MysqlDB.nextval(:position)
+    # changed value (=2) after default one (=1)
 
-    assert_equal 1, MysqlDB.currval(:position)
-    assert_equal 1, MysqlDB.lastval(:position)
-    assert_equal 1, MysqlDB.currval(:position)
-    assert_equal 1, MysqlDB.lastval(:position)
+    assert_equal 2, MysqlDB.currval(:position)
+    assert_equal 2, MysqlDB.lastval(:position)
+    assert_equal 2, MysqlDB.currval(:position)
+    assert_equal 2, MysqlDB.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
 
-    MysqlDB.nextval(:position)
     assert_equal MysqlDB.currval(:position), 1
 
+    MysqlDB.nextval(:position)
+    assert_equal MysqlDB.currval(:position), 2
+
     MysqlDB.setval(:position, 101)
-    # in mariaDB, 'lastval' only works after 'nextval' rather than  'setval'
-    assert_equal 1, MysqlDB.lastval(:position)
+    assert_equal 101, MysqlDB.lastval(:position)
+
+    assert_equal 102, MysqlDB.nextval(:position)
+  end
+
+  test 'sets a new sequence value less than the current one' do
+    with_migration do
+      def up
+        create_sequence :position, start: 100
+      end
+    end.up
+
+    assert_equal MysqlDB.currval(:position), 100
+
+    MysqlDB.nextval(:position)
+    assert_equal MysqlDB.currval(:position), 101
+
+    MysqlDB.setval(:position, 1)
+    assert_equal 101, MysqlDB.lastval(:position)
 
     MysqlDB.nextval(:position)
-    # now the value is correct
     assert_equal 102, MysqlDB.lastval(:position)
   end
 
-  test 'drops sequence and check_sequences' do
+  test 'sets a new sequence value with a label' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    MysqlDB.nextval(:position)
+    MysqlDB.nextval_with_label(:position, 1)
+    MysqlDB.nextval_with_label(:position, 1)
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position where fiction = 1;').all.size
+    assert_equal 2, fiction_set_size
+
+    # create_sequence + nextval
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position where fiction = 0;').all.size
+    assert_equal 2, fiction_set_size
+  end
+
+  test 'drops the sequence and the check_sequences' do
     with_migration do
       def up
         create_sequence :position
@@ -114,7 +170,7 @@ class MysqlSequenceTest < Minitest::Test
     end.up
 
     sequence = MysqlDB.check_sequences.find_all do |seq|
-      seq[:Tables_in_test] == 'position'
+      seq[:name] == 'position'
     end
 
     assert_equal 1, sequence.size
@@ -126,14 +182,40 @@ class MysqlSequenceTest < Minitest::Test
     end.down
 
     sequence = MysqlDB.check_sequences.find do |seq|
-      seq[:Tables_in_test] == 'position'
+      seq[:name] == 'position'
+    end
+
+    assert_nil sequence
+  end
+
+  test 'drops the sequence with the parameter if_exists' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    sequence = MysqlDB.check_sequences.find_all do |seq|
+      seq[:name] == 'position'
+    end
+
+    assert_equal 1, sequence.size
+
+    with_migration do
+      def down
+        drop_sequence :position, if_exists: true
+      end
+    end.down
+
+    sequence = MysqlDB.check_sequences.find do |seq|
+      seq[:name] == 'position'
     end
 
     assert_nil sequence
   end
 
   test 'orders sequences' do
-    list = MysqlDB.check_sequences.map { |s| s[:Tables_in_test] }
+    list = MysqlDB.check_sequences.map { |s| s[:name] }
     assert !list.include?('a')
     assert !list.include?('b')
     assert !list.include?('c')
@@ -141,42 +223,149 @@ class MysqlSequenceTest < Minitest::Test
     with_migration do
       def up
         drop_table :things, if_exists: true
-        create_sequence :c
-        create_sequence :a
+        create_sequence :c, { start: 1 }
+        create_sequence :a, { start: 3 }
         create_sequence :b
       end
     end.up
 
-    list = MysqlDB.check_sequences.map { |s| s[:Tables_in_test] }
+    list = MysqlDB.check_sequences.map { |s| s[:name] }
     assert list.include?('a')
     assert list.include?('b')
     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
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, MysqlDB.currval(:position_id)
+
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, MysqlDB.currval(:position_id)
+
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+  end
+
+  test 'recreates the same sequence with a smaller start value' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 100
+      end
+    end.up
+
+    assert_equal 100, MysqlDB.currval(:position_id)
+
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 100, MysqlDB.currval(:position_id)
+
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+  end
+
+  test 'recreates the same sequence with a greater start value' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, MysqlDB.currval(:position_id)
+
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 100
+      end
+    end.up
+
+    assert_equal 100, MysqlDB.currval(:position_id)
+
+    fiction_set_size = MysqlDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 2, fiction_set_size
+  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
+        create_table :creators do
           primary_key :id
           String :name, text: true
-          Bignum :position, null: false
+          Bignum :position
         end
-        set_column_default_nextval :builders, :position, :position_id
+        set_column_default_nextval :creators, :position, :position_id
       end
     end.up
 
-    class Builder < Sequel::Model; end
+    class Creator < Sequel::Model; end
 
-    builder1 = Builder.create(name: 'Builder 1')
-    pos1 = MysqlDB.currval(:position_id)
-    assert_equal pos1, builder1.reload.position
+    creator1 = Creator.create(name: 'Creator 1')
+    pos1 = MysqlDB.lastval(:position_id)
+    assert_equal pos1, creator1.reload.position
 
-    builder2 = Builder.create(name: 'Builder 2')
+    creator2 = Creator.create(name: 'Creator 2')
     pos2 = MysqlDB.currval(:position_id)
-    assert_equal pos2, builder2.reload.position
+    assert_equal pos2, creator2.reload.position
 
     assert_equal pos2 - pos1, 1
+
+    MysqlDB.nextval(:position_id)
+
+    creator4 = Creator.create(name: 'Creator 4')
+    pos4 = MysqlDB.currval(:position_id)
+    assert_equal pos4, creator4.reload.position
+
+    assert_equal pos4 - pos2, 2
+  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/sqlite_sequence_test.rb

@@ -12,7 +12,7 @@ class SqliteSequenceTest < Minitest::Test
   test 'adds sequence with default values' do
     with_migration do
       def up
-        # create_sequence :position, {start: 1, increment: 1} - default values
+        # create_sequence :position, {start: 1, increment: 1, numeric_label: 0} - default values
         create_sequence :position
       end
     end.up
@@ -126,8 +126,7 @@ class SqliteSequenceTest < Minitest::Test
     SQLiteDB.setval(:position, 1)
     assert_equal 101, SQLiteDB.lastval(:position)
 
-    SQLiteDB.nextval(:position)
-    assert_equal 102, SQLiteDB.lastval(:position)
+    assert_equal 102, SQLiteDB.nextval(:position)
   end
 
   test 'sets a new sequence value with a label' do
@@ -143,8 +142,9 @@ class SqliteSequenceTest < Minitest::Test
     fiction_set_size = SQLiteDB.fetch('SELECT * FROM position where fiction = 1;').all.size
     assert_equal 2, fiction_set_size
 
+    # create_sequence + nextval
     fiction_set_size = SQLiteDB.fetch('SELECT * FROM position where fiction = 0;').all.size
-    assert_equal 1, fiction_set_size
+    assert_equal 2, fiction_set_size
   end
 
   test 'drops the sequence and the check_sequences' do
@@ -166,14 +166,12 @@ 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 'dropsthe sequence with the parameter if_exists' do
+  test 'drops the sequence with the parameter if_exists' do
     with_migration do
       def up
         create_sequence :position
@@ -192,9 +190,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
@@ -220,10 +216,81 @@ class SqliteSequenceTest < Minitest::Test
     assert list.include?('c')
   end
 
+  test 'recreates the same sequence with the same start value' 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)
+
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, SQLiteDB.currval(:position_id)
+
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+  end
+
+  test 'recreates the same sequence with a smaller start value' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 100
+      end
+    end.up
+
+    assert_equal 100, SQLiteDB.currval(:position_id)
+
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 100, SQLiteDB.currval(:position_id)
+
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+  end
+
+  test 'recreates the same sequence with a greater start value' 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)
+
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 100
+      end
+    end.up
+
+    assert_equal 100, SQLiteDB.currval(:position_id)
+
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position_id where fiction = 0;').all.size
+    assert_equal 2, fiction_set_size
+  end
+
   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
@@ -254,4 +321,11 @@ class SqliteSequenceTest < Minitest::Test
 
     assert_equal pos4 - pos2, 2
   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,8 +10,10 @@ SQLiteDB = Sequel.connect(
 
 module SqliteTestHelper
   def recreate_table
-    SQLiteDB.drop_sequence 'position'
-    SQLiteDB.run 'DROP TABLE IF EXISTS objects'
+    SQLiteDB.drop_table :apprentices, if_exists: true
+    SQLiteDB.drop_sequence :position
+    SQLiteDB.drop_sequence :position_id, if_exists: true
+    SQLiteDB.drop_table :objects, if_exists: true
     SQLiteDB.drop_sequence 'a'
     SQLiteDB.drop_sequence 'b'
     SQLiteDB.drop_sequence 'c'
@@ -26,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'