workerholic 0.0.2

data/spec/job_processor_spec.rb

@@ -0,0 +1,62 @@
+require_relative 'spec_helper'
+
+class SimpleJobTestWithError
+  include Workerholic::Job
+  job_options queue_name: TEST_SCHEDULED_SORTED_SET
+
+  def perform
+    raise Exception
+  end
+end
+
+describe Workerholic::JobProcessor do
+  it 'processes a simple job' do
+    job = Workerholic::JobWrapper.new(class: SimpleJobTest, arguments: ['test job'])
+    serialized_job = Workerholic::JobSerializer.serialize(job)
+
+    job_processor = Workerholic::JobProcessor.new(serialized_job)
+    simple_job_result = SimpleJobTest.new.perform('test job')
+
+    expect(job_processor.process).to eq(simple_job_result)
+  end
+
+  it 'processes a complex job' do
+    serialized_job = Workerholic::JobSerializer.serialize({
+      class: ComplexJobTest,
+      arguments: ['test job', { a: 1, b: 2 }, [1, 2, 3]],
+      statistics: Workerholic::Statistics.new.to_hash
+    })
+
+    job_processor = Workerholic::JobProcessor.new(serialized_job)
+
+    complex_job_result = ComplexJobTest.new.perform('test job', { a: 1, b: 2 }, [1, 2, 3])
+    expect(job_processor.process).to eq(complex_job_result)
+  end
+
+  # it 'raises a custom error when processing a job with error' do
+  #   serialized_job = Workerholic::JobSerializer.serialize({
+  #                      class: SimpleJobTestWithError,
+  #                      arguments: [],
+  #                      statistics: Workerholic::Statistics.new.to_hash
+  #                    })
+
+  #   job_processor = Workerholic::JobProcessor.new(serialized_job)
+
+  #   expect { job_processor.process }.to raise_error(Workerholic::JobProcessingError)
+  # end
+
+  it 'retries job when job processing fails' do
+    job = {
+      class: SimpleJobTestWithError,
+      arguments: [],
+      statistics: Workerholic::Statistics.new.to_hash
+    }
+    serialized_job = Workerholic::JobSerializer.serialize(job)
+
+    allow(Workerholic::JobRetry).to receive(:new)
+
+    expect(Workerholic::JobRetry).to receive(:new)
+
+    Workerholic::JobProcessor.new(serialized_job).process
+  end
+end

data/spec/job_retry_spec.rb

@@ -0,0 +1,59 @@
+require_relative 'spec_helper'
+
+class JobWithError
+  def perform
+    raise
+  end
+end
+
+describe Workerholic::JobRetry do
+  let(:redis) { Redis.new }
+
+  before { redis.del(TEST_SCHEDULED_SORTED_SET) }
+
+  it 'increments retry count' do
+    job = Workerholic::JobWrapper.new(class: JobWithError, arguments: [])
+
+    Workerholic::JobRetry.new(
+      job: job,
+      sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
+    )
+
+    expect(job.retry_count).to eq(1)
+  end
+
+  it 'schedules job by incrementing by 10 more seconds for every new retry' do
+    job = Workerholic::JobWrapper.new(class: JobWithError, arguments: [], retry_count: 2)
+
+    Workerholic::JobRetry.new(
+      job: job,
+      sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
+    )
+
+    expect((job.execute_at - Time.now.to_f).ceil).to eq(30)
+  end
+
+  it 'pushes job inside "workerholic:test:scheduled_jobs" sorted set' do
+    job = Workerholic::JobWrapper.new(class: JobWithError, arguments: [], retry_count: 2)
+
+    Workerholic::JobRetry.new(
+      job: job,
+      sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
+    )
+
+    serialized_job = Workerholic::JobSerializer.serialize(job)
+
+    expect(redis.zrange(TEST_SCHEDULED_SORTED_SET, 0, 0, with_scores: true).first).to eq([serialized_job, job.execute_at])
+  end
+
+  it 'discards job if retry count is greater than 5' do
+    job = Workerholic::JobWrapper.new(class: JobWithError, arguments: [], retry_count: 5)
+
+    Workerholic::JobRetry.new(
+      job: job,
+      sorted_set: Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET)
+    )
+
+    expect(redis.exists(TEST_SCHEDULED_SORTED_SET)).to eq(false)
+  end
+end

data/spec/job_scheduler_spec.rb

@@ -0,0 +1,66 @@
+require_relative 'spec_helper'
+
+class SimpleDelayedJobTest
+  include Workerholic::Job
+  job_options queue_name: TEST_SCHEDULED_SORTED_SET
+
+  def perform(n, s)
+    s
+  end
+end
+
+describe Workerholic::JobScheduler do
+  let(:scheduler) { Workerholic::JobScheduler.new(set_name: TEST_SCHEDULED_SORTED_SET, queue_name: TEST_QUEUE) }
+  let(:redis) { Redis.new }
+
+  before { redis.del(TEST_SCHEDULED_SORTED_SET) }
+
+  context 'with non-empty set' do
+    let(:serialized_job) do
+      job = Workerholic::JobWrapper.new(
+        class: ComplexJobTest,
+        arguments: ['test job', { a: 1, b: 2 }, [1, 2, 3]]
+      )
+
+      Workerholic::JobSerializer.serialize(job)
+    end
+
+    it 'checks the time for scheduled job inside sorted set' do
+      score = Time.now.to_f
+      scheduler.schedule(serialized_job, score)
+
+      expect(scheduler.job_due?).to eq(true)
+    end
+
+    it 'fetches a job from a sorted set' do
+      score = Time.now.to_f
+      scheduler.schedule(serialized_job, score)
+      scheduler.enqueue_due_jobs
+
+      expect(scheduler.sorted_set.empty?).to eq(true)
+    end
+
+    it 'enqueues due job to the main queue' do
+      score = Time.now.to_f
+      scheduler.schedule(serialized_job, score)
+      scheduler.enqueue_due_jobs
+
+      expect(scheduler.queue.empty?).to eq(false)
+      expect(scheduler.queue.dequeue).to eq(serialized_job)
+    end
+  end
+
+  context 'with delayed job option specified' do
+    it 'adds delayed job to the scheduled sorted set' do
+      SimpleDelayedJobTest.new.perform_delayed(2, 'test arg')
+
+      expect(scheduler.sorted_set.empty?).to eq(false)
+    end
+
+    it 'raises an ArgumentError if perform_delayed first argument is not of Numeric type' do
+      job = SimpleDelayedJobTest.new
+
+      expect { job.perform_delayed("wrong type", 'test arg') }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/job_serializer_spec.rb

@@ -0,0 +1,28 @@
+require_relative 'spec_helper'
+
+class JobTest; end
+
+describe Workerholic::JobSerializer do
+  it 'serializes a job' do
+    job = Workerholic::JobWrapper.new(
+      class: JobTest,
+      arguments: ['some_args', [1, 2, 3], true, { a: 'y' }, 1, :symptom]
+    )
+
+    serialized_job = Workerholic::JobSerializer.serialize(job)
+
+    expect(serialized_job).to eq(YAML.dump(job.to_hash))
+  end
+
+  it 'deserializes a job' do
+    job = Workerholic::JobWrapper.new(
+      class: JobTest,
+      arguments: ['some_args', [1, 2, 3], true, { a: 'y' }, 1, :symptom]
+    )
+
+    serialized_job = YAML.dump(job.to_hash)
+    deserialized_job = Workerholic::JobSerializer.deserialize(serialized_job)
+
+    expect(deserialized_job).to eq(job)
+  end
+end

data/spec/job_wrapper_spec.rb

@@ -0,0 +1,27 @@
+require_relative 'spec_helper'
+
+describe Workerholic::JobWrapper do
+  it 'returns a hash with job meta info and job stats info' do
+    job = Workerholic::JobWrapper.new(class: SimpleJobTest, arguments: ['test job'])
+
+    expected_result = {
+      class: SimpleJobTest,
+      arguments: ['test job'],
+      retry_count: 0,
+      execute_at: nil,
+      statistics: {
+        enqueued_at: nil,
+        errors: [],
+        started_at: nil,
+        completed_at: nil
+      }
+    }
+    expect(job.to_hash).to eq(expected_result)
+  end
+
+  it 'performs the job' do
+    job = Workerholic::JobWrapper.new(class: SimpleJobTest, arguments: ['test job'])
+
+    expect(job.perform).to eq('test job')
+  end
+end

data/spec/manager_spec.rb

@@ -0,0 +1,26 @@
+require_relative 'spec_helper'
+
+describe Workerholic::Manager do
+  it 'creates a number of workers based on workers count' do
+    manager = Workerholic::Manager.new
+
+    manager.workers.each { |worker| expect(worker).to be_a(Workerholic::Worker) }
+    expect(manager.workers.size).to eq(Workerholic::Manager::WORKERS_COUNT)
+  end
+
+  it 'creates a job scheduler' do
+    manager = Workerholic::Manager.new
+
+    expect(manager.scheduler).to be_a(Workerholic::JobScheduler)
+  end
+
+  it 'starts up the workers and the scheduler' do
+    manager = Workerholic::Manager.new
+
+    expect(manager.workers.first).to receive(:work)
+    expect(manager.scheduler).to receive(:start)
+    Thread.new { manager.start }
+
+    sleep(0.1)
+  end
+end

data/spec/queue_spec.rb

@@ -0,0 +1,16 @@
+require_relative 'spec_helper'
+
+describe Workerholic::Queue do
+  let(:queue) { Workerholic::Queue.new('test') }
+  let(:job) { 'test job' }
+
+  it 'enqueues a job' do
+    expect(queue.storage).to receive(:push).with(queue.name, job)
+    queue.enqueue(job)
+  end
+
+  it 'dequeues a job' do
+    expect(queue.storage).to receive(:pop).with(queue.name).and_return([queue.name,job])
+    queue.dequeue
+  end
+end

data/spec/sorted_set.rb

@@ -0,0 +1,25 @@
+require_relative 'spec_helper'
+
+describe Workerholic::SortedSet do
+  let(:job) {{ class: SimpleJobTest, arguments: [] }}
+  let(:redis) { Redis.new }
+  let(:sorted_set) { Workerholic::SortedSet.new(TEST_SCHEDULED_SORTED_SET) }
+
+  after { redis.del(TEST_SCHEDULED_SORTED_SET) }
+
+  it 'adds a serialized job to the sorted set' do
+    serialized_job = Workerholic::JobSerializer.serialize(job)
+    score = Time.now.to_f
+    expect(sorted_set.add(score, serialized_job)).to eq(true)
+  end
+
+  it 'removes due job from the sorted set' do
+    serialized_job = Workerholic::JobSerializer.serialize(job)
+    score = Time.now.to_f
+
+    sorted_set.add(score, serialized_job)
+    sorted_set.remove(score)
+
+    expect(redis.zcount(TEST_SCHEDULED_SORTED_SET, 0, '+inf')).to eq(0)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH << __dir__ + '/../lib/'
+
+require 'workerholic'
+
+require_relative 'helpers/helper_methods'
+require_relative 'helpers/job_tests'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

data/spec/statistics_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Workerholic::Statistics do
+  it 'initializes attributes with without an argument' do
+    statistics = Workerholic::Statistics.new
+    expect(statistics.enqueued_at).to be_nil
+    expect(statistics.errors).to eq([])
+    expect(statistics.started_at).to be_nil
+    expect(statistics.completed_at).to be_nil
+  end
+
+  it 'initializes attributes with arguments' do
+    enqueuing_time = Time.now.to_f - 86400
+    started_at_time = Time.now.to_f
+    completed_at_time = Time.now.to_f + 86400
+    options = {
+      enqueued_at: enqueuing_time,
+      errors: ['Your job is bad and you should feel bad'],
+      started_at: started_at_time,
+      completed_at: completed_at_time
+    }
+
+    expect(Workerholic::Statistics.new(options).to_hash).to eq(options)
+  end
+end

data/spec/storage_spec.rb

@@ -0,0 +1,17 @@
+require_relative 'spec_helper'
+
+describe Workerholic::Storage do
+  let(:storage) { Workerholic::Storage::RedisWrapper.new }
+  let(:queue_name) { TEST_QUEUE }
+  let(:job) { 'test job' }
+
+  it 'adds a job to the test queue' do
+    expect(storage.redis).to receive(:rpush).with(queue_name, job)
+    storage.push(queue_name, job)
+  end
+
+  it 'pops a job from the test queue' do
+    expect(storage.redis).to receive(:blpop).with(queue_name, 1)
+    storage.pop(queue_name)
+  end
+end

data/spec/worker_spec.rb

@@ -0,0 +1,59 @@
+require_relative 'spec_helper'
+
+class WorkerJobTest
+  @@job_status = 0
+
+  def self.reset
+    @@job_status = 0
+  end
+
+  def self.check
+    @@job_status
+  end
+
+  def perform
+    @@job_status += 1
+  end
+end
+
+describe Workerholic::Worker do
+  let(:redis) { Redis.new }
+  let(:job) do
+    {
+      class: WorkerJobTest,
+      arguments: [],
+      statistics: Workerholic::Statistics.new.to_hash
+    }
+  end
+
+  before do
+    redis.del(TEST_SCHEDULED_SORTED_SET)
+    WorkerJobTest.reset
+  end
+
+  context '#work' do
+    it 'polls a job from a thread' do
+      queue = Workerholic::Queue.new(TEST_QUEUE)
+      worker = Workerholic::Worker.new(queue)
+
+      serialized_job = Workerholic::JobSerializer.serialize(job)
+      redis.rpush(TEST_QUEUE, serialized_job)
+
+      worker.work
+
+      expect_during(1, false) { redis.exists(TEST_QUEUE) }
+    end
+
+    it 'processes a job from a thread' do
+      queue = Workerholic::Queue.new(TEST_QUEUE)
+      worker = Workerholic::Worker.new(queue)
+
+      serialized_job = Workerholic::JobSerializer.serialize(job)
+      redis.rpush(TEST_QUEUE, serialized_job)
+
+      worker.work
+
+      expect_during(1, 1) { WorkerJobTest.check }
+    end
+  end
+end