employer 0.0.1 → 0.1

data/spec/employer/employees/forking_employee_spec.rb

@@ -0,0 +1,6 @@
+require "employer/employees/forking_employee"
+require "support/shared_examples/employee"
+
+describe Employer::Employees::ForkingEmployee, unless: RUBY_PLATFORM =~ /java/ do
+  it_behaves_like "an employee"
+end

data/spec/employer/employees/threading_employee_spec.rb

@@ -0,0 +1,6 @@
+require "employer/employees/threading_employee"
+require "support/shared_examples/employee"
+
+describe Employer::Employees::ThreadingEmployee do
+  it_behaves_like "an employee"
+end

data/spec/employer/job_spec.rb

@@ -0,0 +1,89 @@
+require "employer/job"
+
+describe Employer::Job do
+  let(:job_class) do
+    Class.new do
+      include Employer::Job
+
+      attribute :name
+      attribute :shape
+    end
+  end
+  let(:job) { job_class.new }
+
+  before(:each) do
+    stub_const("Namespaced::TestJob", job_class)
+  end
+
+  it "adds id attribute" do
+    job.id.should be_nil
+    job.id = 1
+    job.id.should eq(1)
+  end
+
+  describe "#try_again?" do
+    it "returns false" do
+      job.try_again?.should be_false
+    end
+  end
+
+  describe ".attribute" do
+    it "adds attribute accessors" do
+      job.name.should be_nil
+      job.name = "Block"
+      job.name.should eq("Block")
+
+      job.shape.should be_nil
+      job.shape = :square
+      job.shape.should eq(:square)
+    end
+
+    it "registers attribute names" do
+      job_class.attribute_names.should eq([:name, :shape])
+      job.attribute_names.should eq([:name, :shape])
+    end
+  end
+
+  describe "#serialize" do
+    it "builds a Hash of id, class name and attributes" do
+      job = Namespaced::TestJob.new
+      job.id = 1
+      job.name = "Ball"
+      job.shape = :circle
+
+      job.serialize.should eq({id: 1, class: "Namespaced::TestJob", attributes: {name: "Ball", shape: :circle}})
+    end
+
+    it "leaves out id if it is nil" do
+      job = Namespaced::TestJob.new
+      job.name = "Ball"
+      job.shape = :circle
+
+      job.serialize.should eq({class: "Namespaced::TestJob", attributes: {name: "Ball", shape: :circle}})
+    end
+
+    it "leaves out attributes with a nil value" do
+      job = Namespaced::TestJob.new
+      job.id = 1
+      job.name = "Ball"
+
+      job.serialize.should eq({id: 1, class: "Namespaced::TestJob", attributes: {name: "Ball"}})
+    end
+  end
+
+  describe ".deserialize" do
+    it "sets the id and attributes" do
+      serialized_job = {id: 1, class: "Namespaced::TestJob", attributes: {name: "Ball", shape: :circle}}
+      job = Namespaced::TestJob.deserialize(serialized_job)
+      job.should be_instance_of(Namespaced::TestJob)
+      job.id.should eq(1)
+      job.name.should eq("Ball")
+      job.shape.should eq(:circle)
+    end
+
+    it "must have the right class name" do
+      serialized_job = {id: 1, class: "TestJob", attributes: {name: "Ball", shape: :circle}}
+      expect { Namespaced::TestJob.deserialize(serialized_job) }.to raise_error(Employer::Errors::JobClassMismatch)
+    end
+  end
+end

data/spec/employer/pipeline_spec.rb

@@ -0,0 +1,92 @@
+require "employer/pipeline"
+
+describe Employer::Pipeline do
+  let(:pipeline) { Employer::Pipeline.new }
+  let(:backend) { double("Pipeline backend") }
+  let(:job) { double("Job") }
+
+  it "has a pluggable backend" do
+    pipeline.backend = backend
+    pipeline.backend.should eq(backend)
+  end
+
+  describe "#enqueue" do
+    it "serializes and then enqueues jobs using its backend" do
+      job_id = 1
+      serialized_job = {class: "TestJob"}
+
+      job.should_receive(:serialize).and_return(serialized_job)
+      backend.should_receive(:enqueue).with(serialized_job).and_return(job_id)
+
+      pipeline.backend = backend
+      pipeline.enqueue(job).should eq(job_id)
+    end
+
+    it "fails when no backend is set" do
+      expect { pipeline.enqueue(job) }.to raise_error(Employer::Errors::PipelineBackendRequired)
+    end
+  end
+
+  describe "#dequeue" do
+    it "dequeues job using its backend and properly instantiates it" do
+      stub_const("TestJob", Class.new)
+      job_id = 1
+      job.stub(:id).and_return(job_id)
+      serialized_job = {id: job_id, class: "TestJob"}
+
+      backend.should_receive(:dequeue).and_return(serialized_job)
+      TestJob.should_receive(:deserialize).and_return(job)
+
+      pipeline.backend = backend
+      dequeued_job = pipeline.dequeue
+      dequeued_job.should eq(job)
+      dequeued_job.id.should eq(job_id)
+    end
+
+    it "returns nil when there is no job in the backend's queue" do
+      backend.should_receive(:dequeue).and_return(nil)
+      pipeline.backend = backend
+      pipeline.dequeue.should be_nil
+    end
+
+    it "fails when no backend is set" do
+      expect { pipeline.dequeue }.to raise_error(Employer::Errors::PipelineBackendRequired)
+    end
+  end
+
+  describe "#complete" do
+    it "completes job using its backend" do
+      backend.should_receive(:complete).with(job)
+      pipeline.backend = backend
+      pipeline.complete(job)
+    end
+
+    it "fails when no backend is set" do
+      expect { pipeline.complete(double) }.to raise_error(Employer::Errors::PipelineBackendRequired)
+    end
+  end
+
+  describe "#reset" do
+    it "resets the job using its backend" do
+      backend.should_receive(:reset).with(job)
+      pipeline.backend = backend
+      pipeline.reset(job)
+    end
+
+    it "fails when no backend is set" do
+      expect { pipeline.reset(double) }.to raise_error(Employer::Errors::PipelineBackendRequired)
+    end
+  end
+
+  describe "#fail" do
+    it "fails the job using its backend" do
+      backend.should_receive(:fail).with(job)
+      pipeline.backend = backend
+      pipeline.fail(job)
+    end
+
+    it "fails when no backend is set" do
+      expect { pipeline.fail(double) }.to raise_error(Employer::Errors::PipelineBackendRequired)
+    end
+  end
+end

data/spec/employer/workshop_spec.rb

@@ -0,0 +1,105 @@
+require "employer/workshop"
+
+describe Employer::Workshop do
+  before(:each) do
+    stub_const("Employer::Boss", Class.new)
+    stub_const("Employer::Pipeline", Class.new)
+    stub_const("Employer::Employees::ForkingEmployee", Class.new)
+    stub_const("Employer::Employees::ThreadingEmployee", Class.new)
+    stub_const("TestPipelineBackend", Class.new)
+  end
+
+  let(:boss) { double("Boss").as_null_object }
+  let(:config_code) do
+    <<CONFIG
+    pipeline_backend TestPipelineBackend.new
+    forking_employees 2
+CONFIG
+  end
+  let(:workshop) do
+    Employer::Boss.should_receive(:new).and_return(boss)
+    Employer::Workshop.setup(config_code)
+  end
+
+  describe ".setup" do
+    it "sets up a workshop" do
+      pipeline_backend = double("Pipeline backend")
+      TestPipelineBackend.should_receive(:new).and_return(pipeline_backend)
+      boss = double("Boss")
+      pipeline = double("Pipeline")
+      forking_employee1 = double("Forking Employee 1")
+      forking_employee2 = double("Forking Employee 2")
+      forking_employee3 = double("Forking Employee 3")
+      threading_employee1 = double("Threading Employee 1")
+      threading_employee2 = double("Threading Employee 2")
+
+      Employer::Boss.should_receive(:new).and_return(boss)
+      Employer::Pipeline.should_receive(:new).and_return(pipeline)
+      boss.should_receive(:pipeline=).with(pipeline)
+      boss.should_receive(:pipeline).and_return(pipeline)
+      pipeline.should_receive(:backend=).with(pipeline_backend)
+      Employer::Employees::ForkingEmployee.should_receive(:new).and_return(forking_employee1, forking_employee2, forking_employee3)
+      Employer::Employees::ThreadingEmployee.should_receive(:new).and_return(threading_employee1, threading_employee2)
+      boss.should_receive(:allocate_employee).with(forking_employee1)
+      boss.should_receive(:allocate_employee).with(forking_employee2)
+      boss.should_receive(:allocate_employee).with(forking_employee3)
+      boss.should_receive(:allocate_employee).with(threading_employee1)
+      boss.should_receive(:allocate_employee).with(threading_employee2)
+
+      config_code = <<CONFIG
+      pipeline_backend TestPipelineBackend.new
+      forking_employees 3
+      threading_employees 2
+CONFIG
+
+      workshop = Employer::Workshop.setup(config_code)
+      workshop.should be_instance_of(Employer::Workshop)
+    end
+  end
+
+  describe ".pipeline" do
+    it "sets up a pipeline to feed the workshop" do
+      boss = double("Boss").as_null_object
+      Employer::Boss.should_receive(:new).and_return(boss)
+      pipeline = double("Pipeline").as_null_object
+      boss.stub(:pipeline).and_return(pipeline)
+      Employer::Pipeline.should_receive(:new).and_return(pipeline)
+      pipeline_backend = double("Pipeline backend")
+      TestPipelineBackend.should_receive(:new).and_return(pipeline_backend)
+      File.should_receive(:read).with("config/employee.rb").and_return(config_code)
+
+      workshop_pipeline = Employer::Workshop.pipeline("config/employee.rb")
+      workshop_pipeline.should eq(pipeline)
+    end
+  end
+
+  describe "#run" do
+    it "should call manage on the boss" do
+      boss.should_receive(:manage)
+      workshop.run
+    end
+  end
+
+  describe "#stop" do
+    it "should call stop_managing on the boss" do
+      boss.should_receive(:stop_managing)
+      workshop.stop
+    end
+  end
+
+  describe "#stop_now" do
+    it "should call stop_managing and stop_employees on the boss" do
+      boss.should_receive(:stop_managing)
+      boss.should_receive(:stop_employees)
+      workshop.stop_now
+    end
+  end
+
+  describe "#pipeline" do
+    it "returns the pipeline" do
+      pipeline = double("Pipeline").as_null_object
+      boss.stub(:pipeline).and_return(pipeline)
+      workshop.pipeline.should eq(pipeline)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "pry"
+

data/spec/support/shared_examples/employee.rb

@@ -0,0 +1,132 @@
+shared_examples "an employee" do
+  let(:employee) { described_class.new }
+  let(:completing_job_class) do
+    Class.new do
+      def perform
+        sleep 0.2
+      end
+    end
+  end
+  let(:completing_job) { completing_job_class.new}
+  let(:failing_job_class) do
+    Class.new do
+      def perform
+        sleep 0.2
+        raise "Oops"
+      end
+    end
+  end
+  let(:failing_job) { failing_job_class.new}
+  let(:job) { double("Job") }
+
+  describe "#work" do
+    it "rejects a job while its already working on one" do
+      employee.should_receive(:free?).and_return(false)
+      expect { employee.work(job) }.to raise_error(Employer::Errors::EmployeeBusy)
+    end
+  end
+
+  describe "#work_in_progress?" do
+    it "is true while a job is running" do
+      employee.work(completing_job)
+      employee.work_in_progress?.should be_true
+      sleep 0.3
+      employee.work_in_progress?.should be_false
+    end
+  end
+
+  describe "#work_completed?" do
+    it "is true when a job completes" do
+      employee.work(completing_job)
+      employee.work_completed?.should be_false
+      sleep 0.3
+      employee.work_completed?.should be_true
+    end
+
+    it "is false when a job fails" do
+      employee.work(failing_job)
+      employee.work_completed?.should be_false
+      sleep 0.3
+      employee.work_completed?.should be_false
+    end
+  end
+
+  describe "#work_failed?" do
+    it "is true when a job fails" do
+      employee.work(failing_job)
+      employee.work_failed?.should be_false
+      sleep 0.3
+      employee.work_failed?.should be_true
+    end
+
+    it "is false when a job completes" do
+      employee.work(completing_job)
+      employee.work_failed?.should be_false
+      sleep 0.3
+      employee.work_failed?.should be_false
+    end
+  end
+
+  describe "#wait_for_completion" do
+    it "waits for the job to complete" do
+      employee.work(completing_job)
+      employee.wait_for_completion
+      employee.work_in_progress?.should be_false
+      employee.work_completed?.should be_true
+      employee.free?.should be_false
+    end
+  end
+
+  describe "#stop_working" do
+    it "stops job immediately" do
+      employee.work(completing_job)
+      employee.should_receive(:force_work_stop).and_call_original
+      employee.stop_working
+      employee.work_in_progress?.should be_false
+      employee.free?.should be_false
+    end
+
+    it "just returns if the job just completed" do
+      employee.work(completing_job)
+      employee.wait_for_completion
+      employee.should_receive(:force_work_stop).never
+      employee.stop_working
+    end
+
+    it "just returns if the job just failed" do
+      employee.work(failing_job)
+      employee.wait_for_completion
+      employee.should_receive(:force_work_stop).never
+      employee.stop_working
+    end
+  end
+
+  describe "#free" do
+    before(:each) do
+      employee.work(job)
+    end
+
+    it "clears job state after its completed a job, allowing for a new job to be worked on" do
+      employee.should_receive(:work_completed?).and_return(true)
+      employee.free
+      employee.free?.should be_true
+      employee.job.should be_nil
+    end
+
+    it "clears job state after it failed a job, allowing for a new job to be worked on" do
+      employee.should_receive(:work_completed?).and_return(false)
+      employee.should_receive(:work_failed?).and_return(true)
+      employee.free
+      employee.free?.should be_true
+      employee.job.should be_nil
+    end
+
+    it "does not clear job state while it is still busy" do
+      employee.should_receive(:work_completed?).and_return(false)
+      employee.should_receive(:work_failed?).and_return(false)
+      employee.free
+      employee.free?.should be_false
+      employee.job.should eq(job)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: employer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: '0.1'
   prerelease: 
 platform: ruby
 authors:
@@ -9,25 +9,101 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
-dependencies: []
+date: 2013-02-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.17'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - mark@without-brains.net
-executables: []
+executables:
+- employer
 extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .pryrc
+- .rspec
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/employer
 - employer.gemspec
 - lib/employer.rb
+- lib/employer/boss.rb
+- lib/employer/cli.rb
+- lib/employer/employees.rb
+- lib/employer/employees/abstract_employee.rb
+- lib/employer/employees/forking_employee.rb
+- lib/employer/employees/threading_employee.rb
+- lib/employer/errors.rb
+- lib/employer/errors/employee_busy.rb
+- lib/employer/errors/error.rb
+- lib/employer/errors/job_class_mismatch.rb
+- lib/employer/errors/no_employee_free.rb
+- lib/employer/errors/pipeline_backend_required.rb
+- lib/employer/job.rb
+- lib/employer/pipeline.rb
 - lib/employer/version.rb
-homepage: ''
-licenses: []
+- lib/employer/workshop.rb
+- spec/employer/boss_spec.rb
+- spec/employer/employees/forking_employee_spec.rb
+- spec/employer/employees/threading_employee_spec.rb
+- spec/employer/job_spec.rb
+- spec/employer/pipeline_spec.rb
+- spec/employer/workshop_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/employee.rb
+homepage: https://github.com/mkremer/employer
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -50,4 +126,12 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Job processing made easy
-test_files: []
+test_files:
+- spec/employer/boss_spec.rb
+- spec/employer/employees/forking_employee_spec.rb
+- spec/employer/employees/threading_employee_spec.rb
+- spec/employer/job_spec.rb
+- spec/employer/pipeline_spec.rb
+- spec/employer/workshop_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/employee.rb