shinq 0.8.1 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 013b8f719198d810d0b9928008308196c17f4000
-  data.tar.gz: e48fca8300e77ad5f830c0c290f723cf89a0fc78
+  metadata.gz: 64209cd09dc412fa47ad5de740fdc48a1a4882a6
+  data.tar.gz: ac63880ed26db5f5c417d068a1a5ca6c71d76cd5
 SHA512:
-  metadata.gz: 5d3dd629d17c5cd5865c3a7832f9cbf3c91437cc348a211a2abfb5063d776468cb8d511aede38acf8c4a811883a7fe469aa47308ccb0fcf048704084953bd12c
-  data.tar.gz: fff06dcd8d212d653a8445c201e8a983222b96a718c11ba7a3a267b86c7191acb9e7edcd42f653be66be846829e8417b586b70587ed94946e9747aeb6c28e276
+  metadata.gz: c55c274a6a76c8397cf344f10d8a1f692cea198e2c4f92474077771736f1f051f688334753da31d8f6c803b43cf43925ec6c05078bdff105e5d53503bff357a1
+  data.tar.gz: 611ff43357eeeef74737ed6d67432d706b2e0a10ad8746c224f2fddc786fe5425f8169faa4597eebebf17f663ac8de06a022b4be7b8ec32d9fa1d637f7048544

data/README.md

@@ -58,6 +58,7 @@ class CreateWorkerNames < ActiveRecord::Migration
     create_table :worker_names, id: false, options: "ENGINE=QUEUE" do |t|
       t.string :job_id, null: false
       t.string :title
+      t.integer :scheduled_at, limit: 8, default: 0, null: false
       t.datetime :enqueued_at, null: false
     end
   end
@@ -78,6 +79,7 @@ mysql> show create table worker_names\G
 Create Table: CREATE TABLE `worker_names` (
   `job_id` varchar(255) COLLATE utf8_unicode_ci NOT NULL,
   `title` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
+  `scheduled_at` bigint(20) NOT NULL DEFAULT '0',
   `enqueued_at` datetime NOT NULL
 ) ENGINE=QUEUE DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci
 ```

data/lib/generators/shinq/worker/templates/create_table_migration.erb

@@ -5,6 +5,7 @@ class <%= migration_class_name %> < ActiveRecord::Migration
 <% attributes.each do |attribute| -%>
       t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
 <% end -%>
+      t.integer :scheduled_at, limit: 8, default: 0, null: false
       t.datetime :enqueued_at, null: false
     end
   end

data/lib/shinq.rb

@@ -24,12 +24,20 @@ module Shinq
 
   def self.setup_db_connection(db_name)
     raise Shinq::ConfigurationError unless self.configuration.db_defined?(db_name)
-    @connections[db_name] = Mysql2::Client.new(self.configuration.db_config[db_name])
+    @connections[db_name.to_sym] = Mysql2::Client.new(self.configuration.db_config[db_name])
   end
 
   def self.connection(db_name: self.default_db)
     @connections ||= {}
-    @connections[db_name] ||= setup_db_connection(db_name)
+    @connections[db_name.to_sym] ||= setup_db_connection(db_name)
+  end
+
+  def self.clear_all_connections!
+    return unless @connections
+    @connections.each do |_db_name, connection|
+      connection && connection.close
+    end
+    @connections = {}
   end
 
   def self.logger

data/lib/shinq/active_job/queue_adapters/shinq_adapter.rb

@@ -9,6 +9,15 @@ module ActiveJob
             args: job.arguments.first
           )
         end
+
+        def enqueue_at(job, timestamp)
+          Shinq::Client.enqueue(
+            table_name: job.queue_name,
+            job_id: job.job_id,
+            args: job.arguments.first,
+            scheduled_at: timestamp,
+          )
+        end
       end
     end
   end

data/lib/shinq/cli.rb

@@ -15,6 +15,7 @@ module Shinq
     def initialize(args=ARGV)
       setup_option(args)
       bootstrap
+      initialize_shinq
     end
 
     def setup_option(args)
@@ -31,10 +32,7 @@ module Shinq
         end
 
         opt.on('-w', '--worker VALUE', 'Name of worker class') do |v|
-          worker_class = v.camelize.safe_constantize
-          raise OptionParseError, "worker class #{v.camelize} corresponding to #{v} does not exist" unless worker_class
           opts[:worker_name] = v
-          opts[:worker_class] = worker_class
         end
 
         opt.on('-p', '--process VALUE', 'Number of workers') do |v|
@@ -104,6 +102,11 @@ module Shinq
       end
     end
 
+    def initialize_shinq
+      Shinq::Client.fetch_column_names(table_name: Shinq.configuration.worker_name.pluralize)
+      Shinq.configuration.worker_class # check if worker_class is constantizable before running ServerEngine
+    end
+
     def run
       klass = !options.statistics.nil? && options.statistics ? Shinq::Statistics : Shinq::Launcher
 

data/lib/shinq/client.rb

@@ -8,13 +8,19 @@ module Shinq
       @builder ||= SQL::Maker.new(driver: 'mysql', auto_bind: true)
     end
 
-    def self.enqueue(table_name: , job_id: , args:)
+    def self.enqueue(table_name: , job_id: , args:, scheduled_at: nil)
+      if scheduled_at && !schedulable?(table_name: table_name)
+        raise ArgumentError, "table #{table_name} is not schedulable. You need column `scheduled_at`"
+      end
+
       case args
       when Hash
-        sql = builder.insert(table_name, args.merge(
+        attributes = args.merge(
           job_id: job_id,
-          enqueued_at: Time.now
-        ))
+          scheduled_at: scheduled_at ? scheduled_at.to_i : nil,
+          enqueued_at: Time.now,
+        ).compact
+        sql = builder.insert(table_name, attributes)
         Shinq.connection.query(sql)
       else
         raise ArgumentError, "`args` should be a Hash"
@@ -22,7 +28,9 @@ module Shinq
     end
 
     def self.dequeue(table_name:)
-      quoted = SQL::Maker::Quoting.quote(table_name)
+      condition = schedulable?(table_name: table_name) ? ":scheduled_at<=#{Time.now.to_i}" : ''
+      quoted = SQL::Maker::Quoting.quote("#{table_name}#{condition}")
+
       queue_timeout_quoted = SQL::Maker::Quoting.quote(Shinq.configuration.queue_timeout)
 
       wait_query = "queue_wait(#{quoted}, #{queue_timeout_quoted})"
@@ -52,6 +60,26 @@ module Shinq
       )
     end
 
+    def self.schedulable?(table_name:)
+      self.column_names(table_name: table_name).include?('scheduled_at')
+    end
+
+    def self.column_names(table_name:)
+      @column_names_by_table_name ||= {}
+      @column_names_by_table_name[table_name.to_sym] ||= begin
+        quoted = SQL::Maker::Quoting.quote(table_name)
+        column = Shinq.connection.query(<<-EOS).map { |record| record['column_name'] }
+select column_name from information_schema.columns where table_schema = database() and table_name = #{quoted}
+        EOS
+      end
+    end
+
+    def self.fetch_column_names(table_name:)
+      @column_names_by_table_name ||= {}
+      @column_names_by_table_name.delete(table_name.to_sym)
+      column_names(table_name: table_name)
+    end
+
     def self.done
       Shinq.connection.query('select queue_end()')
     end

data/lib/shinq/configuration.rb

@@ -10,7 +10,7 @@ module Shinq
   #   You may need to set it +false+ for jobs which take very long time to proceed.
   #   You may also need to handle performing error manually then.
   class Configuration
-    attr_accessor :require, :worker_name, :worker_class, :db_config, :queue_db, :default_db, :process, :graceful_kill_timeout, :queue_timeout, :daemonize, :statistics, :lifecycle, :abort_on_error
+    attr_accessor :require, :worker_name, :db_config, :queue_db, :default_db, :process, :graceful_kill_timeout, :queue_timeout, :daemonize, :statistics, :lifecycle, :abort_on_error
 
     DEFAULT = {
       require: '.',
@@ -27,6 +27,14 @@ module Shinq
       end
     end
 
+    def worker_class
+      worker_class = worker_name.camelize.safe_constantize
+      unless worker_class
+        raise ConfigurationError, "worker class #{worker_name.camelize} corresponding to #{worker_name} does not exist"
+      end
+      worker_class
+    end
+
     def default_db_config
       raise ConfigurationError if !(default_db && db_defined?(default_db))
       db_config[default_db]

data/lib/shinq/launcher.rb

@@ -3,6 +3,10 @@ require 'active_support/inflector'
 
 module Shinq
   module Launcher
+    def initialize
+      Shinq.clear_all_connections!
+    end
+
     # Wait configured queue and proceed each of them until stop.
     # @see Shinq::Configuration#abort_on_error
     def run

data/shinq.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "shinq"
-  spec.version       = '0.8.1'
+  spec.version       = '1.0.0.rc1'
   spec.authors       = ["Ryoichi SEKIGUCHI"]
   spec.email         = ["ryopeko@gmail.com"]
   spec.summary       = %q{Worker and enqueuer for Q4M using the interface of ActiveJob.}
@@ -23,6 +23,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "rspec-mocks"
   spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "timecop"
 
   spec.add_dependency "mysql2", ">= 0.3.16", "< 0.5"
   spec.add_dependency "sql-maker", "~> 0.0.4"

data/spec/db/structure.sql.erb

@@ -0,0 +1,15 @@
+DROP TABLE IF EXISTS `queue_test`;
+CREATE TABLE `queue_test` (
+  `job_id` varchar(255) NOT NULL,
+  `title` varchar(255),
+  `scheduled_at` bigint(20) NOT NULL DEFAULT '0',
+  `enqueued_at` datetime NOT NULL
+) ENGINE=<%= engine %>;
+
+DROP TABLE IF EXISTS `queue_test_without_scheduled_at`;
+
+CREATE TABLE `queue_test_without_scheduled_at` (
+  `job_id` varchar(255) NOT NULL,
+  `title` varchar(255),
+  `enqueued_at` datetime NOT NULL
+) ENGINE=<%= engine %>;

data/spec/helpers/my_worker.rb

@@ -0,0 +1,4 @@
+require 'active_job'
+class MyWorker < ActiveJob::Base
+  queue_as :my_workers
+end

data/spec/integration_spec.rb

@@ -3,7 +3,6 @@ require 'shinq'
 require 'shinq/client'
 
 describe "Integration", skip: ENV['TRAVIS'] do
-  let(:queue_table) { 'queue_test' }
 
   before do
     Shinq.configuration = {
@@ -13,28 +12,97 @@ describe "Integration", skip: ENV['TRAVIS'] do
   end
 
   after do
-    Shinq.connection.query("delete from #{queue_table}")
+    Shinq.clear_all_connections! # Return from owner mode
+    tables = Shinq.connection.query('show tables').flat_map(&:values)
+    tables.each do |table|
+      Shinq.connection.query("delete from #{table}")
+    end
+    Shinq.clear_all_connections!
   end
 
   describe "Shinq::Client.enqueue,dequeue" do
-    context "valid args" do
-      let(:args) { {title: 'foo'} }
+    before do
+      Timecop.freeze
+    end
+    after do
+      Timecop.return
+    end
+
+    context 'with scheduled_at on table' do
+      let(:queue_table) { 'queue_test' }
+      let(:job_id) { SecureRandom.uuid }
 
       before do
         Shinq::Client.enqueue(
           table_name: queue_table,
-          job_id: 'jobid',
-          args: args
+          job_id: job_id,
+          args: { title: :foo },
+          scheduled_at: scheduled_at
         )
+      end
 
-        @queue = Shinq::Client.dequeue(table_name: queue_table)
-        Shinq::Client.done
+      context 'when scheduled_at is not specified' do
+        let(:scheduled_at) { nil }
+
+        it 'can dequeue immediately' do
+          expect(Shinq::Client.dequeue(table_name: queue_table)[:job_id]).to eq job_id
+        end
       end
 
-      it { expect(@queue[:title]).to eq args[:title] }
+      context 'when scheduled_at is specified' do
+        let(:scheduled_at) { 1.minute.since }
+
+        it 'can not dequeue job immediately' do
+          expect(Shinq::Client.dequeue(table_name: queue_table)).to be nil
+        end
+
+        context 'when specified time elapsed' do
+          before do
+            Timecop.travel(scheduled_at)
+          end
+
+          it 'can dequeue job' do
+            expect(Shinq::Client.dequeue(table_name: queue_table)[:job_id]).to eq job_id
+          end
+        end
+      end
     end
 
-    context "invalid args" do
+    context 'without scheduled_at on table' do
+      let(:job_id) { SecureRandom.uuid }
+      let(:unschedulable_queue_table) { 'queue_test_without_scheduled_at' }
+
+      context 'when scheduled_at is not specified' do
+        before do
+          Shinq::Client.enqueue(
+            table_name: unschedulable_queue_table,
+            job_id: job_id,
+            args: { title: :foo },
+          )
+        end
+
+        it 'can dequeue job' do
+          expect(Shinq::Client.dequeue(table_name: unschedulable_queue_table)[:job_id]).to eq job_id
+        end
+      end
+
+      context 'when scheduled_at is specified' do
+        it 'cannot enqueue job' do
+          expect {
+            Shinq::Client.enqueue(
+              table_name: unschedulable_queue_table,
+              job_id: job_id,
+              args: { title: :foo },
+              scheduled_at: 1.minute.since,
+            )
+          }.to raise_error ArgumentError
+        end
+      end
+    end
+
+
+    context "with invalid args" do
+      let(:queue_table) { 'queue_test' }
       it {
         expect {
           Shinq::Client.enqueue(
@@ -48,6 +116,8 @@ describe "Integration", skip: ENV['TRAVIS'] do
   end
 
   describe "Shinq::Client.abort" do
+    let(:queue_table) { 'queue_test' }
+
     context "When client has a queue" do
       before do
         Shinq::Client.enqueue(
@@ -77,6 +147,8 @@ describe "Integration", skip: ENV['TRAVIS'] do
   end
 
   describe "Shinq::Client.queue_stats" do
+    let(:queue_table) { 'queue_test' }
+
     subject(:stats) {
       Shinq::Client.queue_stats(table_name: queue_table)
     }

data/spec/shinq/cli_spec.rb

@@ -2,9 +2,21 @@ require 'spec_helper'
 require 'shinq/cli'
 
 describe Shinq::CLI do
+  after do
+    Shinq.clear_all_connections!
+  end
+
   describe '.new' do
-    context 'when there are no arguments' do
-      it { expect { Shinq::CLI.new(%w(--require shinq/cli)) }.not_to raise_error }
+    context 'when there are require statement' do
+      it 'requires and run the code' do
+        # NOTE: As CLI alters global process irreversibly, we only check the result
+        Shinq::CLI.new(%W[
+          --require my_worker
+          --db-config #{File.expand_path('../config/database.yml', __dir__)}
+          --worker my_worker
+        ])
+        expect(defined? MyWorker).to eq 'constant'
+      end
     end
   end
 
@@ -13,8 +25,14 @@ describe Shinq::CLI do
       allow_any_instance_of(ServerEngine::Daemon).to receive(:run).and_return(nil)
     end
 
-    it 'launches Shinq::Launcher' do
-      Shinq::CLI.new(%w(--require shinq/cli)).run
+    it 'launches Shinq::Launcher backended by ServerEngine' do
+      expect {
+        Shinq::CLI.new(%W[
+          --require my_worker
+          --db-config #{File.expand_path('../config/database.yml', __dir__)}
+          --worker my_worker
+        ]).run
+      }.not_to raise_error
     end
   end
 end

data/spec/shinq/client_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'shinq'
+require 'shinq/client'
+
+describe Shinq::Client do
+  subject(:shinq_client) do
+    Shinq::Client.dup.tap do |client|
+      client.instance_variables.each do |variable|
+        client.remove_instance_variable(variable)
+      end
+    end
+  end
+
+  before do
+    Shinq.configuration = {
+      default_db: :test,
+      db_config: load_database_config
+    }
+  end
+
+  after do
+    Shinq.clear_all_connections!
+  end
+
+  describe '.schedulable?' do
+    context 'when target table have scheduled_at' do
+      it { expect(shinq_client.schedulable?(table_name: :queue_test)).to be true }
+    end
+
+    context 'when target table does NOT have scheduled_at' do
+      it { expect(shinq_client.schedulable?(table_name: :queue_test_without_scheduled_at)).to be false }
+    end
+  end
+
+  describe '.column_names' do
+    it 'fetches column_names' do
+      expect(shinq_client.column_names(table_name: :queue_test)).to eq(['job_id', 'title', 'scheduled_at', 'enqueued_at'])
+    end
+  end
+
+  describe 'fetch_column_names' do
+    it 'fetches column_names' do
+      expect(shinq_client.fetch_column_names(table_name: :queue_test)).to eq(['job_id', 'title', 'scheduled_at', 'enqueued_at'])
+    end
+  end
+end

data/spec/shinq/configuration_spec.rb

@@ -33,6 +33,21 @@ describe Shinq::Configuration do
     end
   end
 
+  describe '#worker_class' do
+    context 'when worker_name is valid' do
+      let(:configuration) { Shinq::Configuration.new(worker_name: 'shinq') }
+      it 'constantizes worker_name to corresponding constant' do
+        expect(configuration.worker_class).to eq Shinq
+      end
+    end
+
+    context 'when worker_name is invalid' do
+      let(:configuration) { Shinq::Configuration.new(worker_name: 'invalid_shinq') }
+
+      it {expect { configuration.worker_class }.to raise_error(Shinq::ConfigurationError)}
+    end
+  end
+
   describe "#default_db_config" do
     context "when default_db is present" do
       let(:configuration) { Shinq::Configuration.new({}) }

data/spec/shinq_spec.rb

@@ -3,29 +3,32 @@ require 'shinq'
 require 'shinq/configuration'
 require 'logger'
 
-def shinq_class
-  Shinq.dup
-end
-
 describe Shinq do
-  subject { shinq_class }
+  # remove instance variable deliberately or indeliberately defined by other specs
+  subject(:shinq) do
+    Shinq.dup.tap do |shinq|
+      shinq.instance_variables.each do |variable|
+        shinq.remove_instance_variable(variable)
+      end
+    end
+  end
+
+  after do
+    shinq.clear_all_connections!
+  end
 
   it { is_expected.to respond_to(:configuration) }
   it { is_expected.to respond_to(:configuration=) }
 
   describe ".configuration" do
     context "when configuration is not present" do
-      let(:shinq) { shinq_class }
-
       it { expect(shinq.configuration).to be_a_kind_of(Shinq::Configuration) }
     end
 
     context "when configuration is present" do
-      let(:shinq) {
-        shinq_class.tap {|s|
-          s.configuration = Hash.new
-        }
-      }
+      before do
+        shinq.configuration = Hash.new
+      end
 
       it { expect(shinq.configuration).to be_a_kind_of(Shinq::Configuration) }
     end
@@ -33,7 +36,6 @@ describe Shinq do
 
   describe ".configuration=" do
     context "when specify args is Hash" do
-      let(:shinq) { shinq_class }
       let(:args) { Hash.new }
 
       it 'is expect to return specified args' do
@@ -42,7 +44,6 @@ describe Shinq do
     end
 
     context "when specify args is Shinq::Configuration" do
-      let(:shinq) { shinq_class }
       let(:args) { Shinq::Configuration.new({}) }
 
       it 'is expect to return specified args' do
@@ -52,43 +53,56 @@ describe Shinq do
   end
 
   describe ".connection" do
+    context "when db_config is not present" do
+      it { expect{ shinq.connection(db_name: :unknown) }.to raise_error(Shinq::ConfigurationError) }
+    end
+
     context "when db_config is present" do
-      let(:shinq) { shinq_class }
+      before do
+        shinq.configuration = { db_config: load_database_config, default_db: :test }
+      end
 
-      it { expect{ shinq.connection(db_name: :unknown) }.to raise_error(Shinq::ConfigurationError) }
+      it do
+        shinq.connection(db_name: :test)
+        expect(shinq.connection(db_name: :test)).to be_a_kind_of(Mysql2::Client)
+      end
+    end
+  end
+
+  describe '.clear_all_connections!' do
+    before do
+      shinq.configuration = { db_config: load_database_config, default_db: :test }
+    end
+
+    context 'when there are no connections' do
+      it { expect { shinq.clear_all_connections! }.not_to raise_error }
     end
 
-    context "when db_config is not preset" do
-      let(:shinq) {
-        shinq_class.tap {|s|
-          s.configuration = {
-            db_config: load_database_config,
-            default_db: :test,
-          }
-        }
-      }
-
-      it { expect(shinq.connection(db_name: :test)).to be_a_kind_of(Mysql2::Client) }
+    context 'when there is a connection' do
+      let!(:connection) { shinq.connection(db_name: :test) }
+
+      it 'closes connection' do
+        shinq.clear_all_connections!
+        expect(connection.ping).to be false
+      end
+
+      it 'clears connection cache' do
+        shinq.clear_all_connections!
+        expect(shinq.connection(db_name: :test)).not_to eq connection
+      end
     end
   end
 
   describe ".logger" do
     context "when logger is not present" do
-      let(:shinq) {
-        shinq_class.tap {|s|
-          s.logger = nil
-        }
-      }
       it { expect(shinq.logger).to be nil }
     end
 
     context "when logger is present" do
       let(:logger) { Logger.new(STDOUT) }
-      let(:shinq) {
-        shinq_class.tap {|s|
-          s.logger = logger
-        }
-      }
+      before do
+        shinq.logger = logger
+      end
 
       it { expect(shinq.logger).to be logger }
     end

data/spec/spec_helper.rb

@@ -1,7 +1,13 @@
+ENV['RAILS_ENV'] ||= 'test'
+$LOAD_PATH << File.expand_path('../helpers', __FILE__)
+
 require 'rspec/mocks/standalone'
 require 'simplecov'
+require 'erb'
 require 'yaml'
 require 'active_support/core_ext/hash'
+require 'mysql2'
+require 'timecop'
 
 def load_database_config
   db_config = YAML.load_file(File.expand_path('./config/database.yml', __dir__)).symbolize_keys
@@ -25,8 +31,19 @@ RSpec.configure do |config|
   end
 
   config.before(:suite) do
+    # MySQL on Travis does not have Q4M plugins.
+    # We use QUEUE engine and run Q4M specific spec (integration_spec) only when ENV['TRAVIS'] is nil.
+    engine = ENV['TRAVIS'] ? 'InnoDB' : 'QUEUE' # Travis MySQL does not have Q4M plugins.
+    sql = ERB.new(File.read(File.expand_path('./db/structure.sql.erb', __dir__))).result(binding)
+
     connection = Mysql2::Client.new(load_database_config[:test].merge(flags: Mysql2::Client::MULTI_STATEMENTS))
-    connection.query(File.read(File.expand_path('./db/structure.sql', __dir__)))
+    result = connection.query(sql)
+
+    while connection.next_result
+      connection.store_result
+    end
+
+    connection.close
   end
 
   config.order = :random

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shinq
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Ryoichi SEKIGUCHI
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-08-01 00:00:00.000000000 Z
+date: 2017-08-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: mysql2
   requirement: !ruby/object:Gem::Requirement
@@ -214,9 +228,11 @@ files:
 - lib/shinq/statistics.rb
 - shinq.gemspec
 - spec/config/database.yml
-- spec/db/structure.sql
+- spec/db/structure.sql.erb
+- spec/helpers/my_worker.rb
 - spec/integration_spec.rb
 - spec/shinq/cli_spec.rb
+- spec/shinq/client_spec.rb
 - spec/shinq/configuration_spec.rb
 - spec/shinq_spec.rb
 - spec/spec_helper.rb
@@ -235,9 +251,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.8
@@ -246,9 +262,11 @@ specification_version: 4
 summary: Worker and enqueuer for Q4M using the interface of ActiveJob.
 test_files:
 - spec/config/database.yml
-- spec/db/structure.sql
+- spec/db/structure.sql.erb
+- spec/helpers/my_worker.rb
 - spec/integration_spec.rb
 - spec/shinq/cli_spec.rb
+- spec/shinq/client_spec.rb
 - spec/shinq/configuration_spec.rb
 - spec/shinq_spec.rb
 - spec/spec_helper.rb

data/spec/db/structure.sql

@@ -1,6 +0,0 @@
-DROP TABLE IF EXISTS `queue_test`;
-CREATE TABLE `queue_test` (
-  `job_id` varchar(255) NOT NULL,
-  `title` varchar(255),
-  `enqueued_at` datetime NOT NULL
-) ENGINE=QUEUE;