hay 0.0.1.pre.alpha.1

data/test/unit/hay/route_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'hay/route'
+
+class Hay::RouteTest < Test::Unit::TestCase
+  setup do
+    dummy_route_klass = Class.new
+
+    Hay::Routes.expects(:register).with(dummy_route_klass)
+
+    dummy_route_klass.class_exec do
+      include Hay::Route
+
+      def tasks=(tasks)
+        @tasks = tasks
+      end
+
+      def tasks
+        @tasks
+      end
+    end
+
+    mock_agent = mock
+
+    @dummy_route = dummy_route_klass.new(mock_agent)
+  end
+
+  test '#ours? if task is ours' do
+
+    mock_message = mock
+
+    mock_task = mock
+    mock_message.expects(:task).returns(mock_task)
+
+    mock_task_class = mock
+    mock_task.expects(:class).returns(mock_task_class)
+
+    @dummy_route.tasks = [mock_task_class]
+
+    assert @dummy_route.ours?(mock_message)
+  end
+
+  test '#ours? if task is not ours' do
+    mock_message = mock
+
+    mock_task = mock
+    mock_message.expects(:task).returns(mock_task)
+    
+    mock_task_class = mock
+    mock_task.expects(:class).returns(mock_task_class)
+    
+    @dummy_route.tasks = []
+
+    assert !@dummy_route.ours?(mock_message)
+  end
+end

data/test/unit/hay/router_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'hay/router'
+
+class Hay::RouterTest < Test::Unit::TestCase
+  setup do
+    @mock_agent = mock
+
+    @router = Hay::Router.new(@mock_agent)
+  end
+
+  test '#push' do
+    mock_route_klass = mock
+
+    mock_message = mock
+    mock_message.expects(:destination).returns(mock_route_klass)
+
+    mock_route = mock
+    mock_route_klass.expects(:new).with(@mock_agent).returns(mock_route)
+
+    mock_route.expects(:push).with(mock_message)
+    
+    @router.push(mock_message)
+  end
+
+end

data/test/unit/hay/routes_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'hay/routes'
+
+class Hay::RoutesTest < Test::Unit::TestCase
+  setup do
+    @mock_route = mock
+
+    @mock_task_name = "mock.task"
+
+    mock_task_class = mock
+    mock_task_class.expects(:task_name).returns(@mock_task_name)
+
+    @mock_route.expects(:tasks).returns([mock_task_class])
+
+    Hay::Routes.register(@mock_route)
+
+    @mock_task = mock
+  end
+
+  test ".for_task found" do
+
+    @mock_task.expects(:task_name).returns(@mock_task_name)
+
+    router = Hay::Routes.for_task(@mock_task)
+    assert_equal @mock_route, router
+  end
+
+  test ".for_task not found" do
+    mock_task = mock
+    mock_task.expects(:task_name).returns("mock.othertask")
+
+    router = Hay::Routes.for_task(mock_task)
+    assert_equal nil, router
+  end
+end
+

data/test/unit/hay/task/decorator_test.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'hay/task/decorator'
+
+class Hay::Task::DecoratorTest < Test::Unit::TestCase
+  setup do
+    @mock_task = mock
+
+
+    @mock_flow = mock
+
+    @decorated_task = Hay::Task::Decorator.new(@mock_task)
+  end
+
+  def flows 
+    Hay::Task::Flow.expects(:new).returns(@mock_flow)
+  end
+
+  test "#flow" do
+    flows
+    result = @decorated_task.flow
+
+    assert_equal @mock_flow, result
+  end
+
+  test "#dehydrate" do
+    flows
+
+    mock_dehydrated_task = mock
+
+    @mock_task.expects(:task_name).returns("mock_task")
+    @mock_task.expects(:dehydrate).returns(mock_dehydrated_task)
+
+    mock_dehydrated_flow = mock
+    @mock_flow.expects(:dehydrate).returns(mock_dehydrated_flow)
+
+    expected = {"name" => "mock_task",
+                "task" => mock_dehydrated_task,
+                "flow" => mock_dehydrated_flow}
+    result = @decorated_task.dehydrate
+
+    assert_equal expected, result
+  end
+
+  test "#process" do
+    flows
+    
+    mock_dispatcher = mock
+
+    mock_resulter = mock
+    Hay::Task::Resulter.expects(:new).with(@mock_flow, mock_dispatcher).returns(mock_resulter)
+
+    @mock_task.expects(:process).with(mock_resulter)
+
+    @decorated_task.process(mock_dispatcher)
+  end
+
+  test "#other_method" do
+    mock_result = mock
+
+    @mock_task.expects(:delegated_method).returns(mock_result)
+
+    result = @decorated_task.delegated_method
+
+    assert_equal mock_result, result
+  end
+end
+

data/test/unit/hay/task/flow_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'hay/task/flow'
+
+class Hay::Task::FlowTest < Test::Unit::TestCase
+  test '.dehydrate tasks' do
+
+    mock_task = mock
+    mock_task.expects(:kind_of?).with(Hash).returns(false)
+
+    mock_dehydrated_task = mock
+    mock_task.expects(:dehydrate).returns(mock_dehydrated_task)
+
+    flow = Hay::Task::Flow.new([mock_task])
+    result = flow.dehydrate
+
+    assert_equal 1, result.length
+    assert_equal mock_dehydrated_task, result.first
+  end
+
+  test '.dehydrate hashes' do
+
+    mock_task = mock
+    mock_task.expects(:kind_of?).with(Hash).returns(true)
+
+    flow = Hay::Task::Flow.new([mock_task])
+    result = flow.dehydrate
+
+    assert_equal 1, result.length
+    assert_equal mock_task, result.first
+  end
+  test '.inflate' do
+
+    mock_task = mock
+
+    mock_template = mock
+    Hay::Task::Template.expects(:new).with(mock_task).returns(mock_template)
+
+    flow = Hay::Task::Flow.new([mock_task])
+    result = flow.inflate
+
+    assert_equal 1, result.length
+    assert_equal mock_template, result.first
+  end
+end

data/test/unit/hay/task/hydrator_test.rb

@@ -0,0 +1,38 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'hay/task/hydrator'
+
+class Hay::Task::HydratorTest < Test::Unit::TestCase
+  test '.hydrate' do
+
+    mock_task_name = 'mock_task'
+    
+    mock_hash = mock
+    mock_hash.expects(:[]).with('name').returns(mock_task_name)
+
+    mock_task_class = mock
+    Hay::Tasks.expects(:for_name).with(mock_task_name).returns(mock_task_class)
+
+    mock_hash_task = mock
+    mock_hash.expects(:[]).with('task').returns(mock_hash_task)
+
+    mock_hash_flow = mock
+    mock_hash.expects(:[]).with('flow').returns(mock_hash_flow)
+
+    mock_flow = mock
+    Hay::Task::Flow.expects(:new).with(mock_hash_flow).returns(mock_flow)
+
+    mock_task = mock
+    mock_task_class.expects(:new).with(mock_hash_task).returns(mock_task)
+
+    mock_hay_task = mock
+    mock_task.expects(:to_hay).returns(mock_hay_task)
+
+    mock_hay_task.expects(:flow=).with(mock_flow)
+
+    hydrator = Hay::Task::Hydrator.new(mock_hash)
+    
+    result = hydrator.hydrate
+    assert_equal mock_hay_task, result
+  end
+end

data/test/unit/hay/task/hydrators_test.rb

@@ -0,0 +1,26 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'hay/task/hydrators'
+
+class Hay::Task::HydratorsTest < Test::Unit::TestCase
+  test '.for' do
+    mock_task = mock
+
+    mock_task_name = "mock_task"
+    mock_task.expects(:task_name).twice.returns(mock_task_name)
+
+    mock_hydrator_class = mock
+
+    Hay::Task::Hydrators.register(mock_task, mock_hydrator_class)
+
+    params = {'name' => mock_task_name}
+
+    mock_hydrator = mock
+    mock_hydrator_class.expects(:new).with(params).returns(mock_hydrator)
+
+    hydrator = Hay::Task::Hydrators.for(params)
+
+    assert_equal mock_hydrator, hydrator
+
+  end
+end

data/test/unit/hay/task/resulter_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'hay/task/resulter'
+
+class Hay::Task::ResulterTest < Test::Unit::TestCase
+  test 'submit' do
+    mock_flow = mock
+    mock_router = mock
+
+    mock_hydrator = mock
+
+    mock_tasks = 5.times.map { mock }
+
+    mock_data = mock
+    mock_hydrator.expects(:hydrate_with).with(mock_data).returns(mock_tasks)
+
+    Hay::Task::Template::Hydrator.expects(:new).returns(mock_hydrator)
+
+    mock_tasks.each {|t|
+      mock_router.expects(:push).with(t)
+    }
+
+    resulter = Hay::Task::Resulter.new(mock_flow, mock_router)
+
+    resulter.submit(mock_data)
+  end
+end

data/test/unit/hay/task/template/hash_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../../../../test_helper', __FILE__)
+
+require 'hay/task/template/hash'
+require 'hay/task/hydrators'
+
+class Hay::Task::Template::HashTest < Test::Unit::TestCase
+  test '#render' do
+    mock_params = mock
+    mergable_params = {"bar" => "barval"}
+
+    mock_name = "mock_task"
+
+    mock_params.expects(:fetch).with("name").returns(mock_name)
+
+    mock_merged_task = mock
+
+    mock_task_hydrator = mock
+    mock_task_hydrator.expects(:hydrate).returns(mock_merged_task)
+
+    mock_merged_params = mock
+    mock_params.expects(:merge).with(mergable_params).returns(mock_merged_params)
+
+    Hay::Task::Hydrators.expects(:for).with(mock_merged_params).returns(mock_task_hydrator)
+
+    template = Hay::Task::Template::Hash.new(mock_params)
+
+    result = template.render(mergable_params)
+    assert_equal mock_merged_task, result
+  end
+end

data/test/unit/hay/task/template/hydrator_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../../../../test_helper', __FILE__)
+
+require 'hay/task/template/hydrator'
+require 'hay/task/registry'
+
+class Hay::Task::Template::HydratorTest < Test::Unit::TestCase
+  test 'hydrate_with' do
+    mock_flow = mock
+
+    mock_tasks = 5.times.map do
+      mock
+    end
+
+    mock_templates = 5.times.map do |x|
+      t = mock
+      t.expects(:render).returns(mock_tasks[x])
+      t
+    end
+
+    mock_flow.expects(:inflate).returns(mock_templates)
+
+    h = Hay::Task::Template::Hydrator.new(mock_flow)
+
+    result_tasks = h.hydrate_with({"foo" => "bar"})
+
+    assert_equal mock_tasks, result_tasks
+  end
+end
+
+

data/test/unit/hay/task/template/task_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../../../../test_helper', __FILE__)
+
+require 'hay/tasks'
+require 'hay/task/template/hash'
+
+class Hay::Task::Template::TaskTest < Test::Unit::TestCase
+  test '#render' do
+    mock_template_task = mock
+    mock_task = mock
+
+    mock_template_task.expects(:task_name).returns("mock_task")
+    mock_template_task.expects(:payload).returns("foo" => "fooval")
+
+
+    mock_template_task_flow = mock
+    mock_template_task.expects(:flow).returns(mock_template_task_flow)
+
+    mock_task_factory = mock
+    mock_task_factory.expects(:new).with({"foo" => "fooval", "bar" => "barval"}).returns(mock_task)
+
+    mock_hay_task = mock
+    mock_task.expects(:to_hay).returns(mock_hay_task)
+
+    mock_hay_task.expects(:flow=).with(mock_template_task_flow)
+
+    Hay::Tasks.expects(:for).with("mock_task").returns(mock_task_factory)
+
+    template = Hay::Task::Template::Task.new(mock_template_task)
+    result = template.render({"bar" => "barval"})
+
+    assert_equal mock_hay_task, result
+  end
+end

data/test/unit/hay/task/template_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path('../../../test_helper', __FILE__)
+
+require 'hay/task/registry'
+require 'hay/task/templates'
+
+require 'hay/task/template/hash'
+require 'hay/task/template/task'
+
+class Hay::Task::TemplateTest < Test::Unit::TestCase
+  test '.new raises on unknown task class' do
+    mock_task = mock
+    mock_task.expects(:class).returns("mock_task")
+
+    Hay::Task::Templates.expects(:for).with(mock_task).returns(nil)
+    
+    assert_raise(Hay::Task::Exception::UnknownTemplateError){
+      Hay::Task::Template.new(mock_task)
+    }
+  end
+
+  test '.new returns when valid' do
+    mock_task = mock
+
+    mock_task_template = mock
+
+    Hay::Task::Templates.expects(:for).with(mock_task).returns(mock_task_template)
+
+    mock_template_instance = mock
+
+    mock_task_template.expects(:new).with(mock_task).returns(mock_template_instance)
+
+    result = Hay::Task::Template.new(mock_task)
+
+    assert_equal mock_template_instance, result
+  end
+end

data/test/unit/hay/task_test.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+require 'hay/task'
+
+class Hay::TaskTest < Test::Unit::TestCase
+end

data/test/unit/test_helper.rb

@@ -0,0 +1,24 @@
+if ENV["COVERAGE"]
+  require 'coveralls'
+  require 'codeclimate-test-reporter'
+  require 'simplecov'
+  SimpleCov.start do
+    add_group "Lib", "lib"
+    add_filter "/test/"
+    command_name "Unit Tests"
+    formatter SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      Coveralls::SimpleCov::Formatter,
+      CodeClimate::TestReporter::Formatter
+    ]
+  end
+end
+
+require 'test/unit'
+
+ENV["HAY_ENV"] = "test"
+
+require 'mocha/setup'
+
+module TestHelper
+end

metadata

@@ -0,0 +1,206 @@
+--- !ruby/object:Gem::Specification
+name: hay
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre.alpha.1
+platform: ruby
+authors:
+- Ed Carrel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: punchout
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A generic workflow definition framework.
+email:
+- edward@carrel.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- hay.gemspec
+- lib/hay.rb
+- lib/hay/consumer.rb
+- lib/hay/dispatcher.rb
+- lib/hay/message.rb
+- lib/hay/queue.rb
+- lib/hay/route.rb
+- lib/hay/router.rb
+- lib/hay/routes.rb
+- lib/hay/task.rb
+- lib/hay/task/decorator.rb
+- lib/hay/task/exception.rb
+- lib/hay/task/exception/transient_exception.rb
+- lib/hay/task/exception/unknown_template_error.rb
+- lib/hay/task/flow.rb
+- lib/hay/task/hydrator.rb
+- lib/hay/task/hydrator/registry.rb
+- lib/hay/task/hydrators.rb
+- lib/hay/task/registry.rb
+- lib/hay/task/resolver.rb
+- lib/hay/task/resolver/hash.rb
+- lib/hay/task/resolver/registry.rb
+- lib/hay/task/resolver/task.rb
+- lib/hay/task/resolvers.rb
+- lib/hay/task/resulter.rb
+- lib/hay/task/template.rb
+- lib/hay/task/template/hash.rb
+- lib/hay/task/template/hydrator.rb
+- lib/hay/task/template/registry.rb
+- lib/hay/task/template/task.rb
+- lib/hay/task/templates.rb
+- lib/hay/tasks.rb
+- lib/hay/version.rb
+- rakelib/hay/rake.rb
+- test/alfalfa.log
+- test/integration/hay_test.rb
+- test/simplecov_helper.rb
+- test/unit/hay/dispatcher_test.rb
+- test/unit/hay/message_test.rb
+- test/unit/hay/route_test.rb
+- test/unit/hay/router_test.rb
+- test/unit/hay/routes_test.rb
+- test/unit/hay/task/decorator_test.rb
+- test/unit/hay/task/flow_test.rb
+- test/unit/hay/task/hydrator_test.rb
+- test/unit/hay/task/hydrators_test.rb
+- test/unit/hay/task/resulter_test.rb
+- test/unit/hay/task/template/hash_test.rb
+- test/unit/hay/task/template/hydrator_test.rb
+- test/unit/hay/task/template/task_test.rb
+- test/unit/hay/task/template_test.rb
+- test/unit/hay/task_test.rb
+- test/unit/test_helper.rb
+homepage: https://github.com/azanar/hay
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A workflow definition framework.
+test_files:
+- test/alfalfa.log
+- test/integration/hay_test.rb
+- test/simplecov_helper.rb
+- test/unit/hay/dispatcher_test.rb
+- test/unit/hay/message_test.rb
+- test/unit/hay/route_test.rb
+- test/unit/hay/router_test.rb
+- test/unit/hay/routes_test.rb
+- test/unit/hay/task/decorator_test.rb
+- test/unit/hay/task/flow_test.rb
+- test/unit/hay/task/hydrator_test.rb
+- test/unit/hay/task/hydrators_test.rb
+- test/unit/hay/task/resulter_test.rb
+- test/unit/hay/task/template/hash_test.rb
+- test/unit/hay/task/template/hydrator_test.rb
+- test/unit/hay/task/template/task_test.rb
+- test/unit/hay/task/template_test.rb
+- test/unit/hay/task_test.rb
+- test/unit/test_helper.rb