Copied a bunch of examples from Titan.

test/Dockerfile

@@ -0,0 +1,9 @@
+FROM iron/ruby:dev
+
+WORKDIR /app
+ADD Gemfile* /app/
+RUN bundle install
+
+ADD . /app/
+
+# ENTRYPOINT ["ruby", "test.rb"]

test/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gem 'test-unit', '>3'
+gem 'worker_ruby', '>=0.3.5', :git => 'https://github.com/iron-io/worker_ruby'

test/Gemfile.lock

@@ -0,0 +1,30 @@
+GIT
+  remote: https://github.com/iron-io/worker_ruby
+  revision: cc72095f82eb9530d1e161b2dda9092f4068e4eb
+  specs:
+    worker_ruby (0.5.7)
+      json (~> 1.8, >= 1.8.3)
+      typhoeus (~> 1.0, >= 1.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ethon (0.9.0)
+      ffi (>= 1.3.0)
+    ffi (1.9.14)
+    json (1.8.3)
+    power_assert (0.3.0)
+    test-unit (3.2.1)
+      power_assert
+    typhoeus (1.1.0)
+      ethon (>= 0.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  test-unit (> 3)
+  worker_ruby (>= 0.3.5)!
+
+BUNDLED WITH
+   1.12.5

test/README.md

@@ -0,0 +1,21 @@
+
+The tests in these directory will test all the API endpoints and options.
+
+One time:
+
+```sh
+bundle install
+```
+
+Start `iron/worker-api` and `iron/worker-runner`
+
+Then:
+
+```sh
+HOST=localhost:8080 bundle exec ruby test.rb
+```
+
+To run single test, add `-n testname`
+
+To test private images use env variables `TEST_AUTH` and `TEST_PRIVATE_IMAGE`
+`TEST_AUTH` is encoded to base64 `user:pass` string.

test/build.sh

@@ -0,0 +1,3 @@
+set -ex
+
+docker build -t iron/worker-test .

test/run.sh

@@ -0,0 +1,4 @@
+set -ex
+
+./build.sh
+docker run --rm --link worker-api iron/worker-test bundle exec ruby test.rb

test/test.rb

@@ -0,0 +1,511 @@
+require 'test/unit'
+require 'worker_ruby'
+require 'net/http'
+
+class TestTitan < Test::Unit::TestCase
+
+    class << self
+        def startup
+            puts 'runs only once at start'
+            
+        end
+        def shutdown
+            puts 'runs only once at end'
+        end
+        
+    end
+
+
+  def setup
+    # puts "TEST SETUP"
+    # puts ENV['HOST']
+    host = ENV['HOST'] || "worker-api:8080"
+    IronWorker.configure do |config|
+      config.host = "#{host}"
+      config.scheme = "http"
+      # config.debugging = true
+    end
+
+    @titan = IronWorker::TasksApi.new
+    @titan_groups = IronWorker::GroupsApi.new
+  end
+
+  def wait_for_completion(j)
+    max = 120
+    i = 0
+    while true do
+      i += 1
+      if i >= max 
+        raise "Task never seemed to finish!"
+      end
+      task = @titan.groups_name_tasks_id_get(j.group_name, j.id).task
+      # puts "#{task.id} task status: #{task.status}"
+      if task.status != "delayed" && task.status != "queued" && task.status != "running"
+        return task
+      end
+      sleep 1
+    end
+  end
+
+  def wait_for_running(j)
+    max = 120
+    i = 0
+    while true do
+      i += 1
+      if i >= max 
+        raise "Task never seemed to start!"
+      end
+      task = @titan.groups_name_tasks_id_get(j.group_name, j.id).task
+      # puts "#{task.id} task status: #{task.status}"
+      if task.status == "delayed" || task.status == "queued"
+        sleep 1
+      elsif task.status == "running"
+        return task
+      else
+        raise "Task already finished"
+      end
+    end
+  end
+
+  def post_simple_task(group_name)
+    return @titan.groups_name_tasks_post(group_name, tasks: [{image: 'iron/hello', payload: {name: "Johnny Utah"}.to_json}])
+  end
+
+  def test_basics
+    puts 'test_basics'
+    group_name = 'basics'
+    r = post_simple_task(group_name)
+    assert_equal 1, r.tasks.length
+    task = r.tasks[0]
+    # puts "Task after put:"
+    # p task
+    assert task.id.length > 0
+    r = @titan.groups_name_tasks_id_get(group_name, task.id)
+    task = r.task
+    # puts "Task after get:"
+    # p task
+    assert task.id.length > 0
+    assert ["queued","running"].include? task.status
+    puts "task created at: #{task.created_at.to_time} vs #{Time.now-5}"
+    # The clock is getting off here. Wth?
+    assert task.created_at.to_time > (Time.now-5)
+    
+    task = wait_for_completion(task)
+    assert_equal "success", task.status
+    assert_equal nil, task.reason
+    assert task.started_at >= task.created_at
+    assert task.completed_at >= task.started_at
+
+    task = post_simple_task(group_name).tasks[0]
+    task = wait_for_completion(task)
+    assert_equal "success", task.status
+
+  end
+
+  def test_private_images
+    group_name = 'private_images'
+    if ENV['TEST_AUTH'] != nil
+      assert_not_nil ENV['TEST_AUTH']
+      assert_not_nil ENV['TEST_PRIVATE_IMAGE']
+      r = @titan.groups_name_tasks_post(group_name, tasks: [{image: ENV['TEST_PRIVATE_IMAGE'], payload: {name: "Johnny Utah"}.to_json}])
+      assert_equal 1, r.tasks.length
+      task = r.tasks[0]
+      puts "Task after put:"
+      # p task
+      assert task.id.length > 0
+      r = @titan.groups_name_tasks_id_get(group_name, task.id)
+      task = r.task
+      puts "Task after get:"
+      # p task
+      assert task.id.length > 0
+      assert ["queued","running"].include? task.status
+      puts "task created at: #{task.created_at.to_time} vs #{Time.now-5}"
+      # The clock is getting off here. Wth?
+      assert task.created_at.to_time > (Time.now-5)
+
+      task = wait_for_completion(task)
+      # p task
+      assert_equal "success", task.status
+      assert task.started_at > task.created_at
+      assert task.completed_at > task.started_at
+    end
+  end
+
+  def test_logs
+    group_name = 'logs'
+    input_string = "Test Input"
+    r_payload = @titan.groups_name_tasks_post(group_name, tasks: [{image: 'iron/echo:latest', payload: {input: input_string}.to_json }])
+    p r_payload
+    task = wait_for_completion(r_payload.tasks[0])
+    # p task
+    log = @titan.groups_name_tasks_id_log_get(group_name, r_payload.tasks[0].id)
+    # echo image log should be exactly the input string
+    assert_equal input_string, log.chomp
+  end
+
+  def test_get_tasks_by_group
+    now = Time.now()
+    group_name = "fortasklist"
+    image = 'iron/hello'
+    posted = []
+    10.times do |i|
+      posted << post_simple_task(group_name).tasks[0]
+    end
+      jarray = @titan.groups_name_tasks_get(group_name, created_after: now.to_datetime.rfc3339)
+    assert_equal 10, jarray.tasks.length
+    jarray.tasks.each do |task|
+        p task
+        assert_equal group_name, task.group_name
+        assert_equal image, task.image
+        assert task.created_at.to_time > now
+    end
+    wait_for_completion(posted.last)
+  end
+
+  def test_priorities
+    # Wait a while for earlier tasks from other tests to fizzle out so that
+    # their priorities do not affect things.
+    # Would be nice to have some way to clean the queues without having to
+    # sleep.
+    sleep 5
+    group_name = 'priorities'
+    # Test priorities from 0-2... but how to ensure this is reproducible?
+    # Post a bunch at once, then ensure start date on higher priority wins
+    tasks = []
+    10.times do |i|
+      priority = i < 5 ? 0 : i < 8 ? 1 : 2
+      j = {image: 'iron/echo:latest', priority: priority, payload: {input: "task-#{i}"}.to_json}
+      p j
+      tasks << j
+    end
+    tasks = @titan.groups_name_tasks_post(group_name, tasks: tasks).tasks
+    sleep 2
+    j4 = wait_for_completion(tasks[4]) # should in theory be the last one
+    puts "j4: #{j4.inspect}"
+    puts "j4 started_at: #{j4.started_at}"
+    j9 = wait_for_completion(tasks[9])
+    puts "j9 started_at: #{j9.started_at}"
+    assert j9.started_at <= j4.started_at
+    # Should add more comparisons here
+  end
+
+  # todo: Enable after fixing #176[]
+  #def test_delay
+  #  group_name = 'delay'
+  #  delayed_tasks = []
+  #  5.times do |i|
+  #    delayed_tasks << @titan.groups_name_tasks_post(group_name, tasks: [{image: 'treeder/echo:latest', delay: 5, payload: {input: 'Test Input'}.to_json }]).tasks[0]
+  #  end
+  #  p "Finished queueing tasks at #{Time.now}"
+  #  delayed_tasks.each do |task|
+  #    task_delay = @titan.groups_name_tasks_id_get(group_name, task.id).task
+  #    assert_equal "delayed", task_delay.status
+  #  end
+
+  #  sleep 2
+  #  delayed_tasks.each do |task|
+  #    task_delay = @titan.groups_name_tasks_id_get(group_name, task.id).task
+  #    assert_equal "delayed", task_delay.status
+  #  end
+
+  #  sleep 8
+  #  p "Starting to check queued/running/success status at #{Time.now}"
+  #  delayed_tasks.each do |task|
+  #    task_delay = @titan.groups_name_tasks_id_get(group_name, task.id).task
+  #    p "status is", task_delay.status
+  #    assert ["queued", "running", "success"].include?(task_delay.status)
+  #    if task_delay.status == "success"
+  #      assert task_delay.created_at.to_time < task_delay.started_at.to_time - 5
+  #    end
+  #  end
+  #end
+  
+  def test_error
+    group_name = 'error'
+    r = @titan.groups_name_tasks_post(group_name, tasks: [{image: 'iron/error'}])
+    p r
+    task = wait_for_completion(r.tasks[0])
+    assert_equal "error", task.status
+    assert_equal "bad_exit", task.reason
+  end
+
+  def test_timeout
+    group_name = 'timeout'
+    # this one should be fine
+    r1 = @titan.groups_name_tasks_post(group_name, tasks: [{
+      image: 'iron/sleeper:latest',
+      payload: {sleep: 10}.to_json,
+      timeout: 30
+      }])
+    # this one should timeout
+    r2 = @titan.groups_name_tasks_post(group_name, tasks: [{
+      image: 'iron/sleeper:latest',
+      payload: {sleep: 10}.to_json,
+      timeout: 5
+      }])
+    task1 = wait_for_completion(r1.tasks[0])
+    assert_equal "success", task1.status
+    task2 = wait_for_completion(r2.tasks[0])
+    assert_equal "error", task2.status
+    # Fix swagger reason enum thing!
+    assert_equal "timeout", task2.reason
+  end
+  
+  # need to set retry_id field before this test can run.
+  # todo: 
+  def test_autoretries
+    group_name = 'retries'
+    r = @titan.groups_name_tasks_post(group_name, tasks: [{
+        image: 'treeder/error:0.0.2', 
+        retries_delay: 5,
+        max_retries: 2
+    }])
+    task = wait_for_completion(r.tasks[0])
+    assert_equal "error", task.status
+    p task
+    # Fix this once retries set things correctly.
+    assert task.retry_at && task.retry_at != ""
+    assert_equal 2, task.max_retries
+    # should retry in 5 seconds. 
+    task2 = @titan.groups_name_tasks_id_get(group_name, task.retry_at).task
+    assert "delayed", task2.status # shouldn't start for 5 seconds
+    assert task2.id == task.retry_at
+    assert task2.retry_of == task.id
+    task2 = wait_for_completion(task2)
+    assert task.completed_at.to_time < task2.started_at.to_time - 5
+    assert_equal 1, task2.max_retries # decremented
+    # last retry
+    task3 = @titan.groups_name_tasks_id_get(group_name, task2.retry_at).task
+    assert "delayed", task3.status # shouldn't start for 5 seconds
+    task3 = wait_for_completion(task3)
+    assert task2.completed_at.to_time < task3.started_at.to_time - 5    
+    assert task3.retry_at == nil || task3.retry_at == 0    
+    assert task3.max_retries == nil || task3.max_retries == 0
+  end
+  
+  # todo: why is this commented out?
+  # todo: 
+  #def test_retries
+  #  group_name = 'retries'
+
+  #  # non-existent task
+  #  exc = assert_raise IronWorker::ApiError do
+  #    @titan.groups_name_tasks_id_retry_post(group_name, '-1')
+  #  end
+  #  assert_equal 404, exc.code
+
+  #  r = @titan.groups_name_tasks_post(group_name, tasks: [{
+  #        image: 'treeder/error:0.0.2',
+  #        retries_delay: 5,
+  #    }])
+
+  #  # task should not be retry-able until it is finished.
+  #  exc = assert_raise IronWorker::ApiError do
+  #    @titan.groups_name_tasks_id_retry_post(group_name, r.tasks[0].id)
+  #  end
+  #  assert_equal 409, exc.code
+
+  #  task = wait_for_completion(r.tasks[0])
+  #  assert_equal "error", task.status
+  #  assert_equal 0, task.max_retries
+  #  task2 = @titan.groups_name_tasks_id_retry_post(group_name, task.id).task
+  #  # should retry in 5 seconds.
+  #  task = @titan.groups_name_tasks_id_get(group_name, task.id).task
+  #  assert task.id, task2.retry_of
+  #  task2 = wait_for_completion(task2)
+  #  assert_equal task.max_retries, task2.max_retries
+  #end
+
+  def test_auto_groups
+    group_name = 'test_groups'
+    # todo: need to delete image before this. 
+    r = post_simple_task(group_name)
+    r = post_simple_task(group_name)
+    task = r.tasks[0]
+    iw = @titan_groups.groups_name_get(group_name)
+    assert_not_nil iw.group
+    assert iw.group.name == group_name
+    r = @titan_groups.groups_name_get(group_name)
+    assert_equal group_name, r.group.name
+    wait_for_completion(task)
+  end
+
+  # Try cancelling completed task
+  def test_cancel_succeeded
+    group_name = 'cancellation'
+
+    r = post_simple_task(group_name)
+    wait_for_completion(r.tasks[0])
+    exc = assert_raise IronWorker::ApiError do
+      @titan.groups_name_tasks_id_cancel_post(group_name, r.tasks[0].id)
+    end
+    assert_equal 409, exc.code
+  end
+
+  # Try cancelling failed task
+  def test_cancel_error
+    group_name = 'cancellation'
+    r = @titan.groups_name_tasks_post(group_name, tasks: [{
+        image: 'iron/error', 
+    }])
+    task = wait_for_completion(r.tasks[0])
+    assert_equal "error", task.status
+    exc = assert_raise IronWorker::ApiError do
+      @titan.groups_name_tasks_id_cancel_post(group_name, r.tasks[0].id)
+    end
+    assert_equal 409, exc.code
+  end
+
+  # Try cancelling running task
+  def test_cancel_running
+    group_name = 'cancellation'
+    r = @titan.groups_name_tasks_post(group_name, tasks: [{
+      image: 'iron/sleeper:latest',
+      payload: {sleep: 10}.to_json,
+      }])
+    task = wait_for_running(r.tasks[0])
+    r = @titan.groups_name_tasks_id_cancel_post(group_name, r.tasks[0].id)
+    assert_equal r.task.id, task.id
+    assert_equal r.task.status, "cancelled"
+
+    sleep 15
+    r = @titan.groups_name_tasks_id_get(group_name, task.id)
+    # The task should not transition to success or error
+    assert_equal r.task.status, "cancelled"
+  end
+
+  # Try cancelling cancelled task
+  def test_cancel_cancel
+    group_name = 'cancellation'
+    r = @titan.groups_name_tasks_post(group_name, tasks: [{
+      image: 'iron/sleeper:latest',
+      payload: {sleep: 10}.to_json,
+      }])
+    task = wait_for_running(r.tasks[0])
+    r = @titan.groups_name_tasks_id_cancel_post(group_name, task.id)
+    assert_equal r.task.id, task.id
+    assert_equal r.task.status, "cancelled"
+
+    sleep 15
+    r = @titan.groups_name_tasks_id_get(group_name, task.id)
+    # The task should not transition to success or error
+    assert_equal r.task.status, "cancelled"
+
+    exc = assert_raise IronWorker::ApiError do
+      @titan.groups_name_tasks_id_cancel_post(group_name, task.id)
+    end
+    assert_equal 409, exc.code
+  end
+
+  # Try cancelling queued task.
+  def test_cancel_queued
+    group_name = 'cancellation'
+    last_running_task = nil
+    last_task = nil
+    5.times do |i|
+      last_running_task = last_task
+      last_task = post_simple_task(group_name).tasks[0]
+    end
+
+    r = @titan.groups_name_tasks_id_get(group_name, last_task.id)
+    assert_equal r.task.status, "queued"
+    r = @titan.groups_name_tasks_id_cancel_post(group_name, last_task.id)
+    assert_equal r.task.id, last_task.id
+    assert_equal r.task.status, "cancelled"
+
+    task = wait_for_completion(last_running_task)
+    assert_equal task.status, "success"
+    sleep 2
+
+    r = @titan.groups_name_tasks_id_get(group_name, last_task.id)
+    # The task should not transition to success or error, nor should it have
+    # a log.
+    assert_equal last_task.id, r.task.id
+    assert_equal r.task.status, "cancelled"
+    puts "cancelled task id: #{r.task.id}"
+    exc = assert_raise IronWorker::ApiError do
+      @titan.groups_name_tasks_id_log_get(group_name, last_task.id)
+    end
+    assert_equal 404, exc.code
+  end
+
+  # Try cancelling non-existent task
+  def test_cancel_non_existent
+    group_name = 'cancellation'
+
+    exc = assert_raise IronWorker::ApiError do
+      @titan.groups_name_tasks_id_cancel_post(group_name, "-1")
+    end
+    assert_equal 404, exc.code
+  end
+
+  def test_cancel_delayed
+    group_name = 'cancellation'
+    task = @titan.groups_name_tasks_post(group_name, tasks: [{image: 'iron/hello', payload: {name: "Johnny Utah"}.to_json, delay: 5}]).tasks[0]
+
+    r = @titan.groups_name_tasks_id_get(group_name, task.id)
+    assert_equal r.task.status, "delayed"
+    r = @titan.groups_name_tasks_id_cancel_post(group_name, task.id)
+    assert_equal r.task.id, task.id
+    assert_equal r.task.status, "cancelled"
+
+    sleep 10
+    r = @titan.groups_name_tasks_id_get(group_name, task.id)
+    # The task should not transition to success or error, nor should it have
+    # a log.
+    assert_equal r.task.status, "cancelled"
+    exc = assert_raise IronWorker::ApiError do
+      @titan.groups_name_tasks_id_log_get(group_name, task.id)
+    end
+    assert_equal 404, exc.code
+  end
+  
+  def test_groups
+    group_name = 'groups_test'
+    g = @titan_groups.groups_name_put(group_name, group: {image: "iron/checker", env_vars: {"FOO"=>"bar", "DB_URL" => "postgres://abc.com/"}, max_concurrency: 10})
+    p g
+    g2 = @titan_groups.groups_name_get(group_name).group
+    assert_equal "bar", g2.env_vars["FOO"]
+    task = @titan.groups_name_tasks_post(group_name, tasks: [{payload: {env_vars: {"FOO"=>"bar"}}.to_json}]).tasks[0]
+    task = wait_for_completion(task)
+    assert_equal task.status, "success"
+    
+  end  
+  
+  def test_pagination
+      # post 50 tasks, get them in groups of 10 and compare ids/timestamps or something
+      group_name = 'paging_test'
+      posted_tasks = []
+      num_tasks = 25
+      num_tasks.times do |i|
+        task = @titan.groups_name_tasks_post(group_name, tasks: [{image: 'iron/hello', payload: {name: "Johnny Utah"}.to_json}]).tasks[0]
+        puts "posted task id #{task.id}"
+        posted_tasks << task        
+      end
+      
+      ji = num_tasks      
+      cursor = nil
+      n = 5
+      (num_tasks/n).times do |i|
+        tasksw = @titan.groups_name_tasks_get(group_name, n: n, cursor: cursor)
+        tasksw.tasks.each do |task|
+          ji -= 1
+          puts "got task #{task.id}"
+          assert_equal posted_tasks[ji].id, task.id 
+        end
+        cursor = tasksw.cursor      
+        puts "cursor #{cursor}"
+        break if cursor == nil   
+      end
+
+    wait_for_completion(posted_tasks.last)
+  end
+
+  def cancel_tasks(tasks) 
+    tasks.each do |j|
+      @titan.groups_name_tasks_id_cancel_post(j.group_name, j.id)
+    end
+
+  end
+  
+end

test/utils.rb

@@ -0,0 +1,38 @@
+require 'open3'
+
+class ExecError < StandardError 
+  attr_accessor :exit_status, :last_line
+  
+  def initialize(exit_status, last_line)
+    super("Error on cmd. #{exit_status}")
+    self.exit_status = exit_status
+    self.last_line = last_line
+  end
+end
+
+def stream_exec(cmd)
+  puts "Executing cmd: #{cmd}"
+  exit_status = nil
+  last_line = ""
+  Open3.popen2e(cmd) do |stdin, stdout_stderr, wait_thread|
+    Thread.new do
+      stdout_stderr.each {|l| 
+        puts l
+        # Save last line for error checking
+        last_line = l
+      }
+    end
+
+    # stdin.puts 'ls'
+    # stdin.close
+
+    exit_status = wait_thread.value
+    raise ExecError.new(exit_status, last_line) if exit_status.exitstatus != 0
+  end
+  return exit_status
+end
+
+def exec(cmd)
+  puts "Executing: #{cmd}"
+  puts `#{cmd}`
+end