bumbleworks-api 0.0.1

data/lib/bumbleworks/api/lib/presenter.rb

@@ -0,0 +1,32 @@
+module Bumbleworks
+  module Api
+    class Presenter
+      attr_reader :presented
+
+      class << self
+        def present(presented)
+          if presented.is_a?(Array)
+            from_array(presented)
+          else
+            new(presented)
+          end
+        end
+
+        def from_array(array)
+          array.map { |presented|
+            new(presented, in_collection: true)
+          }
+        end
+      end
+
+      def initialize(presented, in_collection: false)
+        @presented = presented
+        @in_collection = in_collection
+      end
+
+      def in_collection?
+        @in_collection == true
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/entity_class_presenter.rb

@@ -0,0 +1,19 @@
+module Bumbleworks
+  module Api
+    class EntityClassPresenter < Presenter
+      def to_hash
+        {
+          :class => presented.name,
+          :count => presented.count,
+          :registered_processes => registered_processes
+        }
+      end
+
+      def registered_processes
+        presented.processes.map { |name, attributes|
+          attributes.merge(:name => name)
+        }
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/entity_presenter.rb

@@ -0,0 +1,13 @@
+module Bumbleworks
+  module Api
+    class EntityPresenter < Presenter
+      def to_hash
+        {
+          :identifier => presented.identifier,
+          :name => presented.to_s,
+          :process_count => presented.processes.count
+        }
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/error_presenter.rb

@@ -0,0 +1,15 @@
+module Bumbleworks
+  module Api
+    class ErrorPresenter < Presenter
+      def to_hash
+        {
+          :process_id => presented.wfid,
+          :expression_id => presented.expression.expid,
+          :error_class_name => presented.error_class_name,
+          :message => presented.message,
+          :backtrace => presented.backtrace
+        }
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/expression_presenter.rb

@@ -0,0 +1,17 @@
+module Bumbleworks
+  module Api
+    class ExpressionPresenter < Presenter
+      def to_hash
+        hash = {
+          :process_id => presented.process.id,
+          :expression_id => presented.expid,
+          :tree => presented.tree
+        }
+        if presented.error
+          hash.merge!(:error => ErrorPresenter.present(presented.error).to_hash)
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/process_presenter.rb

@@ -0,0 +1,32 @@
+module Bumbleworks
+  module Api
+    class ProcessPresenter < Presenter
+      def to_hash
+        {
+          :id => presented.id,
+          :definition_name => presented.definition_name,
+          :subscribed_events => presented.subscribed_events,
+          :entity_name => presented.entity_name
+        }.merge(extras)
+      end
+
+      def extras
+        if in_collection?
+          {}
+        else
+          {
+            :original_tree => presented.original_tree
+          }.merge(entity_hash)
+        end
+      end
+
+      def entity_hash
+        if presented.entity
+          { :entity => EntityPresenter.present(presented.entity).to_hash }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/task_presenter.rb

@@ -0,0 +1,15 @@
+module Bumbleworks
+  module Api
+    class TaskPresenter < Presenter
+      def to_hash
+        {
+          :id => presented.id,
+          :name => presented.to_s,
+          :role => presented.role,
+          :claimant => presented.claimant,
+          :process_id => presented.wfid
+        }
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/tracker_presenter.rb

@@ -0,0 +1,16 @@
+module Bumbleworks
+  module Api
+    class TrackerPresenter < Presenter
+      def to_hash
+        {
+          :id => presented.id,
+          :waiting_expression => presented.waiting_expression,
+          :original_hash => presented.original_hash,
+          :action => presented.action,
+          :conditions => presented.conditions,
+          :process_id => presented.wfid
+        }
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/presenters/worker_presenter.rb

@@ -0,0 +1,30 @@
+module Bumbleworks
+  module Api
+    class WorkerPresenter < Presenter
+      def to_hash
+        {
+          :id => presented.id,
+          :pid => presented.pid,
+          :name => presented.name,
+          :state => presented.state,
+          :ip => presented.ip,
+          :hostname => presented.hostname,
+          :system => presented.system,
+          :launched_at => presented.launched_at,
+          :updated_at => presented.updated_at,
+          :worker_class => presented.worker_class_name,
+          :uptime => presented.uptime,
+          :uptime_in_words => uptime_in_words,
+          :processed_last_minute => presented.processed_last_minute,
+          :wait_time_last_minute => presented.wait_time_last_minute,
+          :processed_last_hour => presented.processed_last_hour,
+          :wait_time_last_hour => presented.wait_time_last_hour
+        }
+      end
+
+      def uptime_in_words
+        TimeSupport.seconds_to_units_in_words(presented.uptime)
+      end
+    end
+  end
+end

data/lib/bumbleworks/api/lib/time_support.rb

@@ -0,0 +1,23 @@
+module TimeSupport
+  class << self
+    def seconds_to_units(seconds, include_zeros: false, round_seconds: true)
+      seconds = seconds.to_i if round_seconds
+      units = Hash[
+        [:days, :hours, :minutes, :seconds].zip(
+          [60, 60, 24].inject([seconds]) {|result, unitsize|
+            result.unshift(*result.shift.divmod(unitsize))
+            result
+          }
+        )
+      ]
+      units.reject! { |k,v| v == 0 } unless include_zeros
+      units
+    end
+
+    def seconds_to_units_in_words(seconds, **options)
+      seconds_to_units(seconds, options).map { |unit, num|
+        "#{num} #{unit}"
+      }.join(', ')
+    end
+  end
+end

data/lib/bumbleworks/api/version.rb

@@ -0,0 +1,5 @@
+module Bumbleworks
+  module Api
+    VERSION = "0.0.1"
+  end
+end

data/playground_setup.rb

@@ -0,0 +1,30 @@
+ENV['RORY_ENV'] ||= ENV['RACK_ENV'] || 'development'
+
+require 'bundler/setup'
+require 'bumbleworks/api'
+require_relative 'spec/fixtures/bumbleworks_config'
+require_relative 'spec/support/process_helpers'
+include ProcessHelpers
+
+Bumbleworks.start_worker!
+
+Widget.truncate!
+WidgetyFidget.truncate!
+
+widget_processes = 20.times.collect do |i|
+  Widget.new(i).launch_process('task_process')
+end
+
+5.times do |i|
+  WidgetyFidget.new(i)
+end
+
+wp = Bumbleworks.launch!('waiting_process')
+
+ProcessHelpers.wait_until(:timeout => 30) do
+  wp.reload.trackers.count == 4
+end
+
+widget_processes.first(3).each do |p|
+  p.tasks.map(&:complete)
+end

data/spec/controllers/entities_controller_spec.rb

@@ -0,0 +1,32 @@
+describe Bumbleworks::Api::EntitiesController do
+  describe "#types" do
+    it "returns entity types" do
+      get "/entities"
+      expect(last_response.body).to eq(
+        json_presentation_of(Bumbleworks.entity_classes)
+      )
+    end
+  end
+
+  describe "#index" do
+    it "returns all existing instances of a given entity type" do
+      foo, bar, baz = Widget.new('foo'),
+                      Widget.new('bar'),
+                      WidgetyFidget.new('baz')
+      get "/entities/widget"
+      expect(last_response.body).to eq(
+        json_presentation_of([foo, bar], :as => 'Entity')
+      )
+    end
+  end
+
+  describe "#show" do
+    it "returns requested instance" do
+      foo = Widget.new(130)
+      get "/entities/widget/130"
+      expect(last_response.body).to eq(
+        json_presentation_of(foo, :as => 'Entity')
+      )
+    end
+  end
+end

data/spec/controllers/errors_controller_spec.rb

@@ -0,0 +1,42 @@
+describe Bumbleworks::Api::ErrorsController do
+  let(:process) { Bumbleworks.launch!('error_process') }
+  let(:error) { Bumbleworks.errors.first }
+  before(:each) do
+    wait_until { process.reload.errors.count > 0 }
+  end
+
+  describe "#index" do
+    it "returns all errors" do
+      Bumbleworks.launch!('error_process')
+      wait_until { Bumbleworks.errors.count == 2 }
+      get "/errors"
+      expect(last_response.body).to eq(
+        json_presentation_of(Bumbleworks.errors, :as => 'Error')
+      )
+    end
+  end
+
+  describe "#show" do
+    it "returns requested error" do
+      get "/processes/#{process.id}/expressions/#{error.expression.expid}/error"
+      expect(last_response.body).to eq(
+        json_presentation_of(error, :as => 'Error')
+      )
+    end
+  end
+
+  describe "#replay" do
+    after(:each) do
+      NaughtyParticipant.naughty_is_ok = false
+    end
+
+    it "attempts to replay error and returns success" do
+      NaughtyParticipant.naughty_is_ok = true
+      put "/processes/#{process.id}/expressions/#{error.expression.expid}/error/replay"
+      wait_until { !process.reload.running? }
+      expect(last_response.body).to eq(
+        { :status => 'replayed' }.to_json
+      )
+    end
+  end
+end

data/spec/controllers/expressions_controller_spec.rb

@@ -0,0 +1,40 @@
+describe Bumbleworks::Api::ExpressionsController do
+  let(:process) { Bumbleworks.launch!('task_process') }
+  let(:expression) { process.expression_at_position('0_0_1') }
+  before(:each) do
+    wait_until { process.reload.tasks.count == 2 }
+  end
+
+  describe "#show" do
+    it "returns requested expression" do
+      get "/processes/#{process.id}/expressions/#{expression.expid}"
+      expect(last_response.body).to eq(
+        json_presentation_of(expression)
+      )
+    end
+  end
+
+  describe "#cancel" do
+    it "attempts to cancel expression and returns success" do
+      allow_any_instance_of(described_class).to receive(:expression).
+        and_return(expression)
+      expect(expression).to receive(:cancel!)
+      delete "/processes/#{process.id}/expressions/#{expression.expid}/cancel"
+      expect(last_response.body).to eq(
+        { :status => 'cancelled' }.to_json
+      )
+    end
+  end
+
+  describe "#kill" do
+    it "attempts to kill expression and returns success" do
+      allow_any_instance_of(described_class).to receive(:expression).
+        and_return(expression)
+      expect(expression).to receive(:kill!)
+      delete "/processes/#{process.id}/expressions/#{expression.expid}/kill"
+      expect(last_response.body).to eq(
+        { :status => 'killed' }.to_json
+      )
+    end
+  end
+end

data/spec/controllers/processes_controller_spec.rb

@@ -0,0 +1,50 @@
+describe Bumbleworks::Api::ProcessesController do
+  describe "#index" do
+    before(:each) do
+      allow(Bumbleworks::Api::ProcessPresenter).to receive(:present).
+        with(:processes).
+        and_return(:presented_processes)
+    end
+
+    it "returns requested page with requested number of processes" do
+      allow(Bumbleworks::Process).to receive(:all).
+        with(:limit => 12, :offset => 24).
+        and_return(:processes)
+      get "/processes?page=3&limit=12"
+      expect(last_response.body).to eq(
+        json_presentation_of(:processes, :as => 'Process')
+      )
+    end
+
+    it "defaults to limit 10" do
+      allow(Bumbleworks::Process).to receive(:all).
+        with(:limit => 10, :offset => 10).
+        and_return(:processes)
+      get "/processes?page=2"
+      expect(last_response.body).to eq(
+        json_presentation_of(:processes, :as => 'Process')
+      )
+    end
+
+    it "defaults to page 1" do
+      allow(Bumbleworks::Process).to receive(:all).
+        with(:limit => 3, :offset => 0).
+        and_return(:processes)
+      get "/processes?limit=3"
+      expect(last_response.body).to eq(
+        json_presentation_of(:processes, :as => 'Process')
+      )
+    end
+  end
+
+  describe "#show" do
+    it "returns requested instance" do
+      process = Bumbleworks.launch!('task_process', :entity => Widget.new(41))
+      wait_until { process.tasks.count == 2 }
+      get "/processes/#{process.id}"
+      expect(last_response.body).to eq(
+        json_presentation_of(process)
+      )
+    end
+  end
+end

data/spec/controllers/tasks_controller_spec.rb

@@ -0,0 +1,82 @@
+describe Bumbleworks::Api::TasksController do
+  let(:process) { Bumbleworks.launch!('task_process') }
+  before(:each) do
+    wait_until do
+      process.tasks.count == 2
+    end
+  end
+
+  describe "#index" do
+    it "returns all tasks" do
+      tasks = process.tasks.all
+      get "/tasks"
+      expect(last_response.body).to eq(
+        json_presentation_of(tasks)
+      )
+    end
+  end
+
+  describe "#show" do
+    it "returns requested task" do
+      task = process.tasks.first
+      get "/tasks/#{task.id}"
+      expect(last_response.body).to eq(
+        json_presentation_of(task)
+      )
+    end
+  end
+
+  describe "#claim" do
+    it "claims and returns task" do
+      task = process.tasks.first
+      put "/tasks/#{task.id}/claim", :claimant => "horatio"
+      expect(task.reload.claimant).to eq("horatio")
+      expect(last_response.body).to eq(
+        json_presentation_of(task)
+      )
+    end
+  end
+
+  describe "#release" do
+    it "releases and returns task" do
+      task = process.tasks.first
+      task.claim("whiskey")
+      put "/tasks/#{task.id}/release"
+      expect(task.reload.claimant).to be_nil
+      expect(last_response.body).to eq(
+        json_presentation_of(task)
+      )
+    end
+  end
+
+  describe "#complete" do
+    let(:task) { process.tasks.first }
+    before(:each) do
+      allow(Bumbleworks::Task).to receive(:find_by_id).
+        with(task.id).
+        and_return(task)
+    end
+
+    it "completes task and returns success" do
+      expect(task).to receive(:complete).with(:foo => "bar", "foo" => "bar")
+      put "/tasks/#{task.id}/complete", :foo => :bar
+      expect(last_response.body).to eq(
+        { :status => 'completed' }.to_json
+      )
+    end
+
+    it "returns 422 with error message if task not completable" do
+      allow(task).to receive(:complete).and_raise(
+        Bumbleworks::Task::NotCompletable, "uh oh you can't do that"
+      )
+      put "/tasks/#{task.id}/complete", :foo => :bar
+      expect(last_response.body).to eq(
+        {
+          :status => "not_completable",
+          :message => "uh oh you can't do that"
+        }.to_json
+      )
+      expect(last_response.status).to eq(422)
+    end
+  end
+end