queue_classic 1.0.2 → 2.0.0rc1

data/lib/queue_classic/durable_array.rb

@@ -1,51 +0,0 @@
-module QC
-  class DurableArray
-
-    def initialize(database)
-      @database = database
-      @table_name = @database.table_name
-      @top_boundary = @database.top_boundary
-    end
-
-    def <<(details)
-      execute("INSERT INTO #{@table_name} (details) VALUES ($1)", OkJson.encode(details))
-      @database.notify if ENV["QC_LISTENING_WORKER"] == "true"
-    end
-
-    def count
-      execute("SELECT COUNT(*) FROM #{@table_name}")[0]["count"].to_i
-    end
-
-    def delete(job)
-      execute("DELETE FROM #{@table_name} WHERE id = $1;", job.id)
-      job
-    end
-
-    def search_details_column(q)
-      find_many { ["SELECT * FROM #{@table_name} WHERE details LIKE $1;", "%#{q}%"] }
-    end
-
-    def first
-      find_one { ["SELECT * FROM lock_head($1, $2);", @table_name, @top_boundary] }
-    end
-
-    def each
-      execute("SELECT * FROM #{@table_name} ORDER BY id ASC;").each do |r|
-        yield Job.new(r)
-      end
-    end
-
-    def find_one(&blk)
-      find_many(&blk).pop
-    end
-
-    def find_many
-      execute(*yield).map { |r| Job.new(r) }
-    end
-
-    def execute(sql, *params)
-      @database.execute(sql, *params)
-    end
-
-  end
-end

data/lib/queue_classic/job.rb

@@ -1,42 +0,0 @@
-module QC
-  class Job
-    attr_accessor :id, :details, :locked_at
-
-    def initialize(args={})
-      @id        = args["id"]
-      @details   = OkJson.decode(args["details"])
-      @locked_at = args["locked_at"]
-    end
-
-    def klass
-      eval(details["job"].split(".").first)
-    end
-
-    def method
-      details["job"].split(".").last
-    end
-
-    def signature
-      details["job"]
-    end
-
-    def params
-      return [] unless details["params"]
-      params = details["params"]
-      if params.length == 1
-        return params[0]
-      else
-        params
-      end
-    end
-
-    def work
-      if params.class == Array
-        klass.send(method,*params)
-      else
-        klass.send(method,params)
-      end
-    end
-
-  end
-end

data/lib/queue_classic/logger.rb

@@ -1,17 +0,0 @@
-module QC
-  module Logger
-
-    extend self
-
-    def ruby_logger
-      @@logger ||= ::Logger.new(STDOUT)
-    end
-
-    def puts(msg)
-      if VERBOSE
-        ruby_logger.debug(msg)
-      end
-    end
-
-  end
-end

data/test/database_helpers.rb

@@ -1,13 +0,0 @@
-module DatabaseHelpers
-
-  def init_db(table_name="queue_classic_jobs")
-    database = QC::Database.new(table_name)
-    database.execute("SET client_min_messages TO 'warning'")
-    database.execute("DROP TABLE IF EXISTS #{table_name} CASCADE")
-    database.execute("CREATE TABLE #{table_name} (id serial, details text, locked_at timestamp)")
-    database.load_functions
-    database.disconnect
-    database
-  end
-
-end

data/test/database_test.rb

@@ -1,73 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-context "DatabaseTest" do
-
-  setup do
-    @database = init_db
-  end
-
-  teardown do
-    @database.disconnect
-  end
-
-  test "drain_notify clears all of the notifications" do
-    @database.listen
-    @database.execute("NOTIFY queue_classic_jobs, 'hello'")
-
-    assert ! @database.connection.notifies.nil?
-    assert   @database.connection.notifies.nil?
-
-    @database.execute("NOTIFY queue_classic_jobs, 'hello'")
-    @database.execute("NOTIFY queue_classic_jobs, 'hello'")
-    @database.execute("NOTIFY queue_classic_jobs, 'hello'")
-
-    @database.drain_notify
-    assert   @database.connection.notifies.nil?
-  end
-
-  test "execute should return rows" do
-    result = @database.execute 'SELECT 11 foo, 22 bar;'
-    assert_equal [{'foo'=>'11', 'bar'=>'22'}], result.to_a
-  end
-
-  test "should raise error on failure" do
-    assert_raises PGError do
-      @database.execute 'SELECT unknown FROM missing;'
-    end
-  end
-
-  test "execute should accept parameters" do
-    result = @database.execute 'SELECT $2::int b, $1::int a, $1::int + $2::int c;', 123, '456'
-    assert_equal [{"a"=>"123", "b"=>"456", "c"=>"579"}], result.to_a
-  end
-
-  def job_count
-    @database.execute('SELECT COUNT(*) FROM queue_classic_jobs')[0].values.first.to_i
-  end
-
-  test "transaction should commit" do
-    assert_equal true, @database.transaction_idle?
-    assert_equal 0, job_count
-    @database.transaction do
-      assert_equal false, @database.transaction_idle?
-      assert_equal 0, job_count
-      @database.execute "INSERT INTO queue_classic_jobs (details) VALUES ('test');"
-      assert_equal false, @database.transaction_idle?
-      assert_equal 1, job_count
-    end
-    assert_equal true, @database.transaction_idle?
-    assert_equal 1, job_count
-  end
-
-  test "transaction should rollback if there's an error" do
-    assert_raises RuntimeError do
-      @database.transaction do
-        @database.execute "INSERT INTO queue_classic_jobs (details) VALUES ('test');"
-        assert_equal 1, job_count
-        raise "force rollback"
-      end
-    end
-    assert_equal 0, job_count
-  end
-
-end

data/test/durable_array_test.rb

@@ -1,94 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-context "DurableArray" do
-
-  setup do
-    @database = init_db
-    @array = QC::DurableArray.new(@database)
-  end
-
-  teardown do
-    @database.disconnect
-  end
-
-  test "decode json into hash" do
-    @array << {"test" => "ok"}
-    assert_equal({"test" => "ok"}, @array.first.details)
-  end
-
-  test "count returns number of rows" do
-    @array << {"test" => "ok"}
-    assert_equal 1, @array.count
-    @array << {"test" => "ok"}
-    assert_equal 2, @array.count
-  end
-
-  test "first returns first job" do
-    job = {"job" => "one"}
-    @array << job
-    assert_equal job, @array.first.details
-  end
-
-  test "passes through strings with quotes" do
-    job = {"foo'bar\"baz" => 'abc\\def'}
-    @array << job
-    assert_equal job, @array.first.details
-  end
-
-  test "passes through newlines" do
-    job = {"word" => "line1\nline2\nline3\n"}
-    @array << job
-    assert_equal job, @array.first.details
-  end
-
-  test "first returns first job when many are in the array" do
-    @array << {"job" => "one"}
-    @array << {"job" => "two"}
-    assert_equal({"job" => "one"}, @array.first.details)
-  end
-
-  test "find_many returns empty array when nothing is found" do
-    assert_equal([], @array.find_many {"select * from queue_classic_jobs"})
-  end
-
-  test "delete removes job from the array" do
-    @array << {"job" => "one"}
-    job = @array.first
-
-    assert_equal( {"job" => "one"}, job.details)
-
-    assert_equal(1,@array.count)
-    @array.delete(job)
-    assert_equal(0,@array.count)
-  end
-
-  test "delete returns job after delete" do
-    @array << {"job" => "one"}
-    job = @array.first
-
-    assert_equal({"job" => "one"}, job.details)
-
-    res = @array.delete(job)
-    assert_equal({"job" => "one"}, res.details)
-  end
-
-  test "each yields the details for each job" do
-    @array << {"job" => "one"}
-    @array << {"job" => "two"}
-    results = []
-    @array.each {|v| results << v.details}
-    assert_equal([{"job" => "one"},{"job" => "two"}], results)
-  end
-
-  test "search" do
-    @array << {"job" => "A.signature"}
-    jobs = @array.search_details_column("A.signature")
-    assert_equal "A.signature", jobs.first.signature
-  end
-
-  test "search when data will not match" do
-    @array << {"job" => "A.signature"}
-    jobs = @array.search_details_column("B.signature")
-    assert_equal [], jobs
-  end
-end

data/test/job_test.rb

@@ -1,82 +0,0 @@
-require File.expand_path("../helper.rb", __FILE__)
-
-context "Job" do
-
-  test "initialize takes details as JSON" do
-    job = QC::Job.new(
-      "id" => 1,
-      "details" => "{\"arg\":1}",
-      "locked_at" => nil
-    )
-    assert_equal({"arg" => 1}, job.details)
-  end
-
-  test "signature returns the class and method" do
-    job = QC::Job.new(
-      "id" => 1,
-      "details" => QC::OkJson.encode({"job" => "Class.method", "params" => []}),
-      "locked_at" => nil
-    )
-    assert_equal "Class.method", job.signature
-  end
-
-  test "method returns the class method" do
-    job = QC::Job.new(
-      "id" => 1,
-      "details" => QC::OkJson.encode({"job" => "Class.method", "params" => []}),
-      "locked_at" => nil
-    )
-    assert_equal "method", job.method
-  end
-
-  test "klass returns the class" do
-    class WhoHa; end
-    job = QC::Job.new(
-      "id" => 1,
-      "details" => QC::OkJson.encode({"job" => "WhoHa.method", "params" => []}),
-      "locked_at" => nil
-    )
-    assert_equal WhoHa, job.klass
-  end
-
-  test "klass returns the class when scoped to module" do
-    module Mod
-      class K
-      end
-    end
-
-    job = QC::Job.new(
-      "id" => 1,
-      "details" => QC::OkJson.encode({"job" => "Mod::K.method", "params" => []}),
-      "locked_at" => nil
-    )
-    assert_equal Mod::K, job.klass
-  end
-
-  test "params returns empty array when nil" do
-     job = QC::Job.new(
-      "id" => 1,
-      "details" => QC::OkJson.encode({"job" => "Mod::K.method", "params" => nil}),
-      "locked_at" => nil
-    )
-    assert_equal [], job.params
- end
-
-  test "params returns 1 items when there is 1 param" do
-    job = QC::Job.new(
-      "id" => 1,
-      "details" => QC::OkJson.encode({"job" => "Mod::K.method", "params" => ["arg"]}),
-      "locked_at" => nil
-    )
-    assert_equal "arg", job.params
-  end
-
-  test "params retuns many items when there are many params" do
-    job = QC::Job.new(
-      "id" => 1,
-      "details" => QC::OkJson.encode({"job" => "Mod::K.method", "params" => ["arg","arg"]}),
-      "locked_at" => nil
-    )
-    assert_equal ["arg","arg"], job.params
-  end
-end