sqewer 5.0.3 → 5.0.4

data/spec/sqewer/middleware_stack_spec.rb

@@ -1,69 +0,0 @@
-require_relative '../spec_helper'
-
-describe Sqewer::MiddlewareStack do
-  it 'returns a default instance' do
-    stacks = (1..100).map { described_class.default }
-    expect(stacks.uniq.length).to eq(1)
-  end
-  
-  describe '#around_deserialization' do
-    it 'works without any handlers added' do
-      stack = described_class.new
-      prepare_result = stack.around_deserialization(nil, 'msg-123', '{"body":"some text"}') { :prepared }
-      expect(prepare_result).to eq(:prepared)
-    end
-    
-    it 'works with an entire stack' do
-      called = []
-      handler = double('Some middleware')
-      allow(handler).to receive(:around_deserialization){|*a, &blk|
-        called << a
-        blk.call 
-      } 
-      
-      stack = described_class.new
-      stack << handler
-      stack << double('Object that does not handle around_deserialization')
-      stack << handler
-      stack << handler
-      result = stack.around_deserialization(nil, 'msg-123', '{"body":"some text"}') { :foo }
-      expect(result).to eq(:foo)
-      expect(called).not_to be_empty
-      
-      expect(called).to eq([
-          [nil, "msg-123", "{\"body\":\"some text\"}"],
-          [nil, "msg-123", "{\"body\":\"some text\"}"],
-          [nil, "msg-123", "{\"body\":\"some text\"}"]]
-      )
-    end
-  end
-  
-  describe '#around_execution' do
-    it 'works without any handlers added' do
-      stack = described_class.new
-      prepare_result = stack.around_execution(nil, nil) { :prepared }
-      expect(prepare_result).to eq(:prepared)
-    end
-    
-    it 'works with an entire stack' do
-      called = []
-      handler = double('Some middleware')
-      allow(handler).to receive(:around_execution){|*a, &blk|
-        called << a
-        blk.call
-      } 
-      
-      stack = described_class.new
-      stack << handler
-      stack << handler
-      stack << double('Object that does not handle around_execution')
-      stack << handler
-      
-      result = stack.around_execution(:some_job, :some_context) { :executed }
-      expect(result).to eq(:executed)
-      expect(called).not_to be_empty
-      
-      expect(called).to eq([[:some_job, :some_context], [:some_job, :some_context], [:some_job, :some_context]])
-    end
-  end
-end

data/spec/sqewer/serializer_spec.rb

@@ -1,118 +0,0 @@
-require_relative '../spec_helper'
-
-describe Sqewer::Serializer do
-  describe '.default' do
-    it 'returns the same Serializer instance' do
-      instances = (1..1000).map{ described_class.default }
-      instances.uniq!
-      expect(instances).to be_one
-      
-      the_instance = instances[0]
-      expect(the_instance).to respond_to(:serialize)
-      expect(the_instance).to respond_to(:unserialize)
-    end
-  end
-  
-  describe '#serialize' do
-    
-    it 'serializes a Job that has no to_h support without its kwargs' do
-      class JobWithoutToHash
-      end
-      job = JobWithoutToHash.new
-      expect(described_class.new.serialize(job)).to eq("{\"_job_class\":\"JobWithoutToHash\",\"_job_params\":null}")
-    end
-    
-    it 'serializes a Struct along with its members and the class name' do
-      class SomeJob < Struct.new :one, :two
-      end
-      
-      job = SomeJob.new(123, [456])
-      
-      expect(described_class.new.serialize(job)).to eq("{\"_job_class\":\"SomeJob\",\"_job_params\":{\"one\":123,\"two\":[456]}}")
-    end
-    
-    it 'adds _execute_after when the value is given' do
-      class ThirdJob < Struct.new :one, :two
-      end
-      
-      job = ThirdJob.new(123, [456])
-      res = described_class.new.serialize(job, Time.now.to_i + 1500)
-      parsed = JSON.load(res)
-      
-      expect(parsed["_execute_after"]).to be_within(10).of(Time.now.to_i + 1500)
-    end
-    
-    it 'raises an exception if the object is of an anonymous class' do
-      s = Struct.new(:foo)
-      o = s.new(1)
-      expect {
-        described_class.new.serialize(o)
-      }.to raise_error(described_class::AnonymousJobClass)
-    end
-  end
-  
-  it 'is able to roundtrip a job with a parameter' do
-    require 'ks'
-    
-    class LeJob < Ks.strict(:some_data)
-    end
-  
-    job = LeJob.new(some_data: 123)
-  
-    subject = described_class.new
-  
-    serialized = subject.serialize(job)
-    restored = subject.unserialize(serialized)
-  
-    expect(restored).to be_kind_of(LeJob)
-    expect(restored.some_data).to eq(123)
-  end
-  
-  describe '#unserialize' do
-    it 'wraps the job with a Resubmit when the _execute_after key hints that it is too early' do
-      class EvenSimplerJob; end
-    
-      timestamp_way_in_the_future = Time.now.to_i + (60 * 60 * 24 * 3)
-      blob  = '{"_job_class": "EvenSimplerJob", "_execute_after": %d}' % timestamp_way_in_the_future
-      built_job = described_class.new.unserialize(blob)
-    
-      expect(built_job).to be_kind_of(Sqewer::Resubmit)
-      expect(built_job.execute_after).to eq(timestamp_way_in_the_future)
-      
-      embedded_job = built_job.job
-      expect(embedded_job).to be_kind_of(EvenSimplerJob)
-    end
-    
-    it 'builds a job without keyword arguments if its constructor does not need any kwargs' do
-      class EvenSimplerJob; end
-    
-      blob  = '{"_job_class": "EvenSimplerJob"}'
-      built_job = described_class.new.unserialize(blob)
-    
-      expect(built_job).to be_kind_of(EvenSimplerJob)
-    
-      blob  = '{"_job_class": "EvenSimplerJob", "_job_params": null}'
-      built_job = described_class.new.unserialize(blob)
-    
-      expect(built_job).to be_kind_of(EvenSimplerJob)
-    end
-  
-    it 'raises an error if the job does not accept the keyword arguments given in the ticket' do
-      class MicroJob; end
-      blob  = '{"_job_class": "MicroJob", "_job_params":{"foo": 1}}'
-      expect {
-        described_class.new.unserialize(blob)
-      }.to raise_error(ArgumentError)
-    end
-  
-    it 'instantiates the job with keyword arguments' do
-      OtherValidJob = Ks.strict(:foo)
-    
-      blob  = '{"_job_class": "OtherValidJob", "_job_params": {"foo": 1}}'
-      built_job = described_class.new.unserialize(blob)
-    
-      expect(built_job).to be_kind_of(OtherValidJob)
-      expect(built_job.foo).to eq(1)
-    end
-  end
-end

data/spec/sqewer/simple_job_spec.rb

@@ -1,69 +0,0 @@
-require_relative '../spec_helper'
-
-describe Sqewer::SimpleJob do
-  it 'raises a clear error for an unknown attribute' do
-    example_class = Class.new do
-      attr_accessor :foo, :bar
-      include Sqewer::SimpleJob
-    end
-    
-    expect {
-      example_class.new(zoo: 1, bar: 2)
-    }.to raise_error(/Unknown attribute \:zoo for/)
-  end
-  
-  it 'uses defined accessors to provide decent string representation' do
-    example_class = Class.new do
-      attr_accessor :foo, :bar
-      include Sqewer::SimpleJob
-    end
-    
-    job = example_class.new(foo: 1, bar: 2)
-    expect(job.inspect).to include('Class')
-    expect(job.inspect).to include('{:foo=>1, :bar=>2}')
-  end
-  
-  it 'uses inspectable_attributes to limit the scope of .inspect' do
-    example_class = Class.new do
-      attr_accessor :foo, :bar
-      def inspectable_attributes
-        [:foo]
-      end
-      include Sqewer::SimpleJob
-    end
-    
-    job = example_class.new(foo: 1, bar: 2)
-    expect(job.inspect).to include('Class')
-    expect(job.inspect).to include('{:foo=>1}')
-    expect(job.inspect).not_to include('bar')
-  end
-  
-  it 'provides for a keyword argument constructor and a to_h method' do
-    example_class = Class.new do
-      attr_accessor :foo, :bar
-      include Sqewer::SimpleJob
-    end
-    
-    string_repr = example_class.to_s
-    
-    new_instance = example_class.new(foo: 1, bar: 2)
-    
-    expect(new_instance.foo).to eq(1)
-    expect(new_instance.bar).to eq(2)
-    
-    hash_repr = new_instance.to_h
-    expect(hash_repr).to eq({foo: 1, bar: 2})
-  end
-  
-  
-  it 'raises if arguments are forgotten' do
-    example_class = Class.new do
-      attr_accessor :foo, :bar
-      include Sqewer::SimpleJob
-    end
-    
-    expect {
-      example_class.new(foo: 1)
-    }.to raise_error('Missing job attribute :bar')
-  end
-end

data/spec/sqewer/submitter_spec.rb

@@ -1,61 +0,0 @@
-require_relative '../spec_helper'
-
-describe Sqewer::Submitter do
-  describe '.default' do
-    it 'returns a set up Submitter with the configured Connection and Serializer' do
-      expect(ENV).to receive(:fetch).with('SQS_QUEUE_URL').and_return('https://some-queue.aws.com')
-      
-      s = described_class.default
-      expect(s.connection).to respond_to(:send_message)
-      expect(s.serializer).to respond_to(:serialize)
-    end
-  end
-  
-  describe '#initialize' do
-    it 'creates a Submitter that you can submit jobs through' do
-      fake_serializer = double('Some serializer')
-      allow(fake_serializer).to receive(:serialize) {|object_to_serialize|
-        expect(object_to_serialize).not_to be_nil
-        'serialized-object-data'
-      }
-      
-      fake_connection = double('Some SQS connection')
-      expect(fake_connection).to receive(:send_message).at_least(5).times.with('serialized-object-data', {})
-      
-      subject = described_class.new(fake_connection, fake_serializer)
-      5.times { subject.submit!(:some_object) }
-    end
-    
-    it 'passes the keyword arguments to send_message on the connection' do
-      fake_serializer = double('Some serializer')
-      allow(fake_serializer).to receive(:serialize) {|object_to_serialize|
-        expect(object_to_serialize).not_to be_nil
-        'serialized-object-data'
-      }
-      
-      fake_connection = double('Some SQS connection')
-      expect(fake_connection).to receive(:send_message).with('serialized-object-data', {delay_seconds: 5})
-      
-      subject = described_class.new(fake_connection, fake_serializer)
-      subject.submit!(:some_object, delay_seconds: 5)
-    end
-    
-    it 'handles the massively delayed execution by clamping the delay_seconds to the SQS maximum, and saving the _execute_after' do
-      fake_serializer = double('Some serializer')
-      allow(fake_serializer).to receive(:serialize) {|object_to_serialize, timestamp_seconds|
-        
-        delay_by = Time.now.to_i + 4585659855
-        expect(timestamp_seconds).to be_within(20).of(delay_by)
-        
-        expect(object_to_serialize).not_to be_nil
-        'serialized-object-data'
-      }
-      
-      fake_connection = double('Some SQS connection')
-      expect(fake_connection).to receive(:send_message).with('serialized-object-data', {delay_seconds: 899})
-      
-      subject = described_class.new(fake_connection, fake_serializer)
-      subject.submit!(:some_object, delay_seconds: 4585659855)
-    end
-  end
-end

data/spec/sqewer/worker_spec.rb

@@ -1,112 +0,0 @@
-require_relative '../spec_helper'
-
-describe Sqewer::Worker, :sqs => true do
-  let(:test_logger) {
-    $stderr.sync = true
-    ENV['SHOW_TEST_LOGS'] ? Logger.new($stderr) : Logger.new(StringIO.new(''))
-  }
-  
-  it 'has all the necessary attributes' do
-    attrs = [:logger, :connection, :serializer, :middleware_stack, 
-      :execution_context_class, :submitter_class, :num_threads]
-    default_worker = described_class.default
-    attrs.each do | attr_name |
-      expect(default_worker).to respond_to(attr_name)
-      expect(default_worker.public_send(attr_name)).not_to be_nil
-    end
-  end
-    
-  it 'supports .default' do
-    default_worker = described_class.default
-    expect(default_worker).to respond_to(:start)
-    expect(default_worker).to respond_to(:stop)
-  end
-    
-  it 'instantiates a new worker object on every call to .default' do
-    workers = (1..10).map { described_class.default }
-    expect(workers.uniq.length).to eq(10)
-  end
-  
-  it 'instantiates a Logger to STDERR by default' do
-    expect(Logger).to receive(:new).with(STDERR)
-    worker = described_class.new
-  end
-  
-  it 'can go through the full cycle of initialize, start, stop, start, stop' do
-    worker = described_class.new(logger: test_logger)
-    worker.start
-    worker.stop
-    worker.start
-    worker.stop
-  end
-  
-  it 'raises a state exception if being stopped without being started' do
-    worker = described_class.new
-    expect {
-      worker.stop
-    }.to raise_error(/Cannot change state/)
-  end
-  
-  context 'when the job payload cannot be unserialized from JSON due to invalid syntax' do
-    it 'is able to cope with an exception when the job class is unknown (one of generic exceptions)' do
-      client = Aws::SQS::Client.new
-      client.send_message(queue_url: ENV.fetch('SQS_QUEUE_URL'), message_body: '{"foo":')
-      
-      worker = described_class.new(logger: test_logger)
-      
-      worker.start
-      sleep 2
-      worker.stop
-    end
-  end
-  
-  context 'when the job cannot be instantiated due to an unknown class' do
-    it 'is able to cope with an exception when the job class is unknown (one of generic exceptions)' do
-      payload = JSON.dump({_job_class: 'UnknownJobClass', _job_params: {arg1: 'some value'}})
-    
-      client = Aws::SQS::Client.new
-      client.send_message(queue_url: ENV.fetch('SQS_QUEUE_URL'), message_body: payload)
-      
-      worker = described_class.new(logger: test_logger)
-      
-      worker.start
-      sleep 2
-      worker.stop
-      
-#      expect(logger_output).to include('uninitialized constant UnknownJobClass')
-#      expect(logger_output).to include('Stopping (clean shutdown)')
-    end
-  end
-  
-  context 'with a job that spawns another job' do
-    it 'sets up the processing pipeline so that jobs can execute in sequence (with threads)' do
-      class SecondaryJob
-        def run
-          File.open(File.join(Dir.tmpdir, 'secondary-job-run'),'w') {}
-        end
-      end
-      
-      class InitialJob
-        def run(executor)
-          File.open(File.join(Dir.tmpdir, 'initial-job-run'),'w') {}
-          executor.submit!(SecondaryJob.new)
-        end
-      end
-      
-      payload = JSON.dump({_job_class: 'InitialJob'})
-      client = Aws::SQS::Client.new
-      client.send_message(queue_url: ENV.fetch('SQS_QUEUE_URL'), message_body: payload)
-      
-      worker = described_class.new(logger: test_logger, num_threads: 8)
-      
-      worker.start
-      
-      begin
-        wait_for { File.exist?(File.join(Dir.tmpdir, 'initial-job-run')) }.to eq(true)
-        wait_for { File.exist?(File.join(Dir.tmpdir, 'secondary-job-run')) }.to eq(true)
-      ensure
-        worker.stop
-      end
-    end
-  end
-end

data/spec/sqewer_module_spec.rb

@@ -1,14 +0,0 @@
-require_relative 'spec_helper'
-
-describe Sqewer do
-  it 'provides a #submit!() method that is a shortcut to the default submitter' do
-    fake_submitter = double('Submitter')
-    expect(Sqewer::Submitter).to receive(:default) { fake_submitter }
-    
-    first_job = double('Job1')
-    second_job = double('Job2')
-    
-    expect(fake_submitter).to receive(:submit!).with(first_job, second_job, {})
-    Sqewer.submit!(first_job, second_job)
-  end
-end