bosh_cli 0.18 → 0.19

data/lib/cli/task_log_renderer.rb

@@ -6,6 +6,10 @@ module Bosh::Cli
     def self.create_for_log_type(log_type)
       if log_type == "event"
         EventLogRenderer.new
+      elsif log_type == "result"
+        # Null renderer doesn't output anything to screen, so it fits well
+        # in case we need to fetch task result log only, without rendering it
+        NullRenderer.new
       else
         TaskLogRenderer.new
       end
@@ -20,6 +24,11 @@ module Bosh::Cli
       @lock = Mutex.new
       @output = ""
       @time_adjustment = 0
+      @duration = nil
+    end
+
+    def duration_known?
+      false # TODO: make it available for basic renderer
     end
 
     def add_output(output)

data/lib/cli/task_tracker.rb

@@ -0,0 +1,168 @@
+# Copyright (c) 2009-2012 VMware, Inc.
+
+module Bosh
+  module Cli
+    # This class is responsible for tracking director tasks
+    class TaskTracker
+
+      MAX_POLLS = nil # not limited
+      POLL_INTERVAL = 1 # second
+
+      attr_reader :output
+
+      # @param [Bosh::Cli::Director] director
+      # @param [Integer] task_id
+      # @param [Hash] options
+      def initialize(director, task_id, options = {})
+        @director = director
+        @task_id = task_id
+        @options = options
+
+        @log_type = options[:log_type] || "event"
+        @use_cache = options.key?(:use_cache) ? @options[:use_cache] : true
+
+        @output = nil
+        @cache = Config.cache
+        @task = Bosh::Cli::DirectorTask.new(@director, @task_id, @log_type)
+
+        if options[:raw_output]
+          @renderer = Bosh::Cli::TaskLogRenderer.new
+        else
+          @renderer = Bosh::Cli::TaskLogRenderer.create_for_log_type(@log_type)
+        end
+      end
+
+      # Tracks director task. Blocks until task is in one of the 'finished'
+      # states (done, error, cancelled). Handles Ctrl+C by prompting to cancel
+      # task.
+      # @return [Symbol] Task status
+      def track
+        nl
+        @renderer.time_adjustment = @director.get_time_difference
+        say("Director task #{@task_id.to_s.yellow}")
+
+        cached_output = get_cached_task_output
+
+        if cached_output
+          task_status = @task.state.to_sym
+          output_received(cached_output)
+          @renderer.refresh
+        else
+          task_status = poll
+        end
+
+        if task_status == :error && interactive? && @log_type != "debug"
+          prompt_for_debug_log
+        else
+          print_task_summary(task_status)
+        end
+
+        save_task_output unless cached_output
+        task_status
+      end
+
+      def poll
+        polls = 0
+
+        while true
+          polls += 1
+          state = @task.state
+          output = @task.output
+
+          output_received(output)
+          @renderer.refresh
+
+          if finished?(state)
+            return state.to_sym
+          elsif MAX_POLLS && polls >= MAX_POLLS
+            return :track_timeout
+          end
+
+          sleep(POLL_INTERVAL)
+        end
+
+        :unknown
+      rescue Interrupt # Local ctrl-c handler
+        prompt_for_task_cancel
+      end
+
+      def prompt_for_debug_log
+        return unless interactive?
+        nl
+        confirm = ask("The task has returned an error status, " +
+                        "do you want to see debug log? [Yn]: ")
+        if confirm.empty? || confirm =~ /y(es)?/i
+          self.class.new(@director, @task_id,
+                         @options.merge(:log_type => "debug")).track
+        else
+          say("Please use 'bosh task #{@task_id}' command ".red +
+                "to see the debug log".red)
+        end
+      end
+
+      def prompt_for_task_cancel
+        return unless interactive?
+        nl
+        confirm = ask("Do you want to cancel task #{@task_id}? [yN] " +
+                        "(^C again to detach): ")
+
+        if confirm =~ /y(es)?/i
+          say("Cancelling task #{@task_id}...")
+          @director.cancel_task(@task_id)
+        end
+
+        poll
+      rescue Interrupt
+        nl
+        err("Task #{@task_id} is still running")
+      end
+
+      def print_task_summary(task_status)
+        output_received(@task.flush_output)
+        @renderer.finish(task_status)
+
+        nl
+        say("Task #{@task_id} #{task_status.to_s.yellow}")
+
+        if task_status == :done && @renderer.duration_known?
+          say("Started\t\t#{@renderer.started_at.utc.to_s}")
+          say("Finished\t#{@renderer.finished_at.utc.to_s}")
+          say("Duration\t#{format_time(@renderer.duration).yellow}")
+        end
+      end
+
+      private
+
+      # @param [String] output Output received from director task
+      def output_received(output)
+        return if output.nil?
+        @output ||= ""
+        @output << output
+        @renderer.add_output(output)
+      end
+
+      def finished?(state)
+        %(done error cancelled).include?(state)
+      end
+
+      def interactive?
+        Bosh::Cli::Config.interactive
+      end
+
+      def get_cached_task_output
+        return nil unless @use_cache
+        @cache.read(task_cache_key)
+      end
+
+      def save_task_output
+        return nil unless @output && @use_cache
+        @cache.write(task_cache_key, @output)
+      end
+
+      def task_cache_key
+        "task/#{@director.uuid}/#{@task_id}/#{@log_type}"
+      end
+
+    end
+  end
+end

data/lib/cli/templates/help_message.erb

@@ -36,6 +36,7 @@ Job management
 <%= command_usage(:stop_job) %>
 <%= command_usage(:restart_job) %>
 <%= command_usage(:recreate_job) %>
+<%= command_usage(:rename_job) %>
 
 Log management
 <%= command_usage(:fetch_logs) %>

data/lib/cli/version.rb

@@ -2,6 +2,6 @@
 
 module Bosh
   module Cli
-    VERSION = "0.18"
+    VERSION = "0.19"
   end
 end

data/lib/cli/versions_index.rb

@@ -38,14 +38,14 @@ module Bosh::Cli
 
       return nil if builds.empty?
 
-      sorted = builds.sort { |build1, build2|
+      sorted = builds.sort do |build1, build2|
         cmp = version_cmp(build2["version"], build1["version"])
         if cmp == 0
           raise "There is a duplicate version `#{build1["version"]}' " +
-                    "in index `#{@index_file}'"
+                  "in index `#{@index_file}'"
         end
         cmp
-      }
+      end
 
       sorted[0]["version"]
     end

data/spec/unit/biff_spec.rb

@@ -110,6 +110,11 @@ describe Bosh::Cli::Command::Biff do
     @biff.find_in("path1.path2.path3", obj).should == 3
   end
 
+  it "finds the object(boolean) path" do
+    obj = { "path1" => {"path2" => {"path3" => false}} }
+    @biff.find_in("path1.path2.path3", obj).should == false
+  end
+
   it "finds the object path in an array by the name key" do
     obj = { "by_key" => 1, "arr" => [{"name" => "by_name"}]}
     @biff.find_in("arr.by_name", obj).should == {"name" => "by_name"}

data/spec/unit/director_spec.rb

@@ -13,30 +13,30 @@ describe Bosh::Cli::Director do
   describe "fetching status" do
     it "tells if user is authenticated" do
       @director.should_receive(:get).with("/info", "application/json").
-          and_return([200, JSON.generate("user" => "adam")])
+        and_return([200, JSON.generate("user" => "adam")])
       @director.authenticated?.should == true
     end
 
     it "tells if user not authenticated" do
       @director.should_receive(:get).with("/info", "application/json").
-          and_return([403, "Forbidden"])
+        and_return([403, "Forbidden"])
       @director.authenticated?.should == false
 
       @director.should_receive(:get).with("/info", "application/json").
-          and_return([500, "Error"])
+        and_return([500, "Error"])
       @director.authenticated?.should == false
 
       @director.should_receive(:get).with("/info", "application/json").
-          and_return([404, "Not Found"])
+        and_return([404, "Not Found"])
       @director.authenticated?.should == false
 
       @director.should_receive(:get).with("/info", "application/json").
-          and_return([200, JSON.generate("user" => nil, "version" => 1)])
+        and_return([200, JSON.generate("user" => nil, "version" => 1)])
       @director.authenticated?.should == false
 
       # Backward compatibility
       @director.should_receive(:get).with("/info", "application/json").
-          and_return([200, JSON.generate("status" => "ZB")])
+        and_return([200, JSON.generate("status" => "ZB")])
       @director.authenticated?.should == true
     end
   end
@@ -53,157 +53,144 @@ describe Bosh::Cli::Director do
   describe "API calls" do
     it "creates user" do
       @director.should_receive(:post).
-          with("/users", "application/json",
-               JSON.generate("username" => "joe", "password" => "pass")).
-          and_return(true)
+        with("/users", "application/json",
+             JSON.generate("username" => "joe", "password" => "pass")).
+        and_return(true)
       @director.create_user("joe", "pass")
     end
 
     it "uploads stemcell" do
       @director.should_receive(:upload_and_track).
-          with("/stemcells", "application/x-compressed",
-               "/path", :log_type=>"event").and_return(true)
+        with("/stemcells", "application/x-compressed", "/path").
+        and_return(true)
       @director.upload_stemcell("/path")
     end
 
     it "lists stemcells" do
       @director.should_receive(:get).with("/stemcells", "application/json").
-          and_return([200, JSON.generate([]), {}])
+        and_return([200, JSON.generate([]), {}])
       @director.list_stemcells
     end
 
     it "lists releases" do
       @director.should_receive(:get).with("/releases", "application/json").
-          and_return([200, JSON.generate([]), {}])
+        and_return([200, JSON.generate([]), {}])
       @director.list_releases
     end
 
     it "lists deployments" do
       @director.should_receive(:get).with("/deployments", "application/json").
-          and_return([200, JSON.generate([]), {}])
+        and_return([200, JSON.generate([]), {}])
       @director.list_deployments
     end
 
     it "lists currently running tasks (director version < 0.3.5)" do
       @director.should_receive(:get).with("/info", "application/json").
-          and_return([200, JSON.generate({ :version => "0.3.2"})])
+        and_return([200, JSON.generate({ :version => "0.3.2"})])
       @director.should_receive(:get).
-          with("/tasks?state=processing", "application/json").
-          and_return([200, JSON.generate([]), {}])
+        with("/tasks?state=processing", "application/json").
+        and_return([200, JSON.generate([]), {}])
       @director.list_running_tasks
     end
 
     it "lists currently running tasks (director version >= 0.3.5)" do
       @director.should_receive(:get).
-          with("/info", "application/json").
-          and_return([200, JSON.generate({ :version => "0.3.5"})])
+        with("/info", "application/json").
+        and_return([200, JSON.generate({ :version => "0.3.5"})])
       @director.should_receive(:get).
-          with("/tasks?state=processing,cancelling,queued", "application/json").
-          and_return([200, JSON.generate([]), {}])
+        with("/tasks?state=processing,cancelling,queued", "application/json").
+        and_return([200, JSON.generate([]), {}])
       @director.list_running_tasks
     end
 
     it "lists recent tasks" do
       @director.should_receive(:get).
-          with("/tasks?limit=30", "application/json").
-          and_return([200, JSON.generate([]), {}])
+        with("/tasks?limit=30", "application/json").
+        and_return([200, JSON.generate([]), {}])
       @director.list_recent_tasks
 
       @director.should_receive(:get).
-          with("/tasks?limit=100", "application/json").
-          and_return([200, JSON.generate([]), {}])
+        with("/tasks?limit=100", "application/json").
+        and_return([200, JSON.generate([]), {}])
       @director.list_recent_tasks(100000)
     end
 
     it "uploads release" do
       @director.should_receive(:upload_and_track).
-          with("/releases", "application/x-compressed",
-               "/path", :log_type => "event").
-          and_return(true)
+        with("/releases", "application/x-compressed", "/path").
+        and_return(true)
       @director.upload_release("/path")
     end
 
     it "gets release info" do
       @director.should_receive(:get).
-          with("/releases/foo", "application/json").
-          and_return([200, JSON.generate([]), { }])
+        with("/releases/foo", "application/json").
+        and_return([200, JSON.generate([]), { }])
       @director.get_release("foo")
     end
 
     it "gets deployment info" do
       @director.should_receive(:get).
-          with("/deployments/foo", "application/json").
-          and_return([200, JSON.generate([]), { }])
+        with("/deployments/foo", "application/json").
+        and_return([200, JSON.generate([]), { }])
       @director.get_deployment("foo")
     end
 
     it "deletes stemcell" do
       @director.should_receive(:request_and_track).
-          with(:delete, "/stemcells/ubuntu/123",
-               nil, nil, :log_type => "event").
-          and_return(true)
+        with(:delete, "/stemcells/ubuntu/123").and_return(true)
       @director.delete_stemcell("ubuntu", "123")
     end
 
     it "deletes deployment" do
       @director.should_receive(:request_and_track).
-          with(:delete, "/deployments/foo",
-               nil, nil, :log_type => "event").
-          and_return(true)
+        with(:delete, "/deployments/foo").and_return(true)
       @director.delete_deployment("foo")
     end
 
     it "deletes release (non-force)" do
       @director.should_receive(:request_and_track).
-          with(:delete, "/releases/za",
-               nil, nil, :log_type => "event").
-          and_return(true)
+        with(:delete, "/releases/za").and_return(true)
       @director.delete_release("za")
     end
 
     it "deletes release (force)" do
       @director.should_receive(:request_and_track).
-          with(:delete, "/releases/zb?force=true",
-               nil, nil, :log_type => "event").
-          and_return(true)
+        with(:delete, "/releases/zb?force=true").and_return(true)
       @director.delete_release("zb", :force => true)
     end
 
     it "deploys" do
       @director.should_receive(:request_and_track).
-          with(:post, "/deployments", "text/yaml",
-               "manifest", :log_type => "event").
-          and_return(true)
+        with(:post, "/deployments", "text/yaml", "manifest").and_return(true)
       @director.deploy("manifest")
     end
 
     it "changes job state" do
       @director.should_receive(:request_and_track).
-          with(:put, "/deployments/foo/jobs/dea?state=stopped",
-               "text/yaml", "manifest", :log_type => "event").
-          and_return(true)
+        with(:put, "/deployments/foo/jobs/dea?state=stopped",
+             "text/yaml", "manifest").and_return(true)
       @director.change_job_state("foo", "manifest", "dea", nil, "stopped")
     end
 
     it "changes job instance state" do
       @director.should_receive(:request_and_track).
-          with(:put, "/deployments/foo/jobs/dea/0?state=detached",
-               "text/yaml", "manifest", :log_type => "event").
-          and_return(true)
+        with(:put, "/deployments/foo/jobs/dea/0?state=detached",
+             "text/yaml", "manifest").and_return(true)
       @director.change_job_state("foo", "manifest", "dea", 0, "detached")
     end
 
     it "gets task state" do
       @director.should_receive(:get).
-          with("/tasks/232").
-          and_return([200, JSON.generate({ "state" => "done" })])
+        with("/tasks/232").
+        and_return([200, JSON.generate({ "state" => "done" })])
       @director.get_task_state(232).should == "done"
     end
 
     it "whines on missing task" do
       @director.should_receive(:get).
-          with("/tasks/232").
-          and_return([404, "Not Found"])
+        with("/tasks/232").
+        and_return([404, "Not Found"])
       lambda {
         @director.get_task_state(232).should
       }.should raise_error(Bosh::Cli::MissingTask)
@@ -211,17 +198,17 @@ describe Bosh::Cli::Director do
 
     it "gets task output" do
       @director.should_receive(:get).
-          with("/tasks/232/output", nil,
-               nil, { "Range" => "bytes=42-" }).
-          and_return([206, "test", { :content_range => "bytes 42-56/100" }])
+        with("/tasks/232/output", nil,
+             nil, { "Range" => "bytes=42-" }).
+        and_return([206, "test", { :content_range => "bytes 42-56/100" }])
       @director.get_task_output(232, 42).should == ["test", 57]
     end
 
     it "doesn't set task output new offset if it wasn't a partial response" do
       @director.should_receive(:get).
-          with("/tasks/232/output", nil, nil,
-               { "Range" => "bytes=42-" }).
-          and_return([200, "test"])
+        with("/tasks/232/output", nil, nil,
+             { "Range" => "bytes=42-" }).
+        and_return([200, "test"])
       @director.get_task_output(232, 42).should == ["test", nil]
     end
 
@@ -231,8 +218,8 @@ describe Bosh::Cli::Director do
       Time.stub!(:now).and_return(now)
 
       @director.should_receive(:get).with("/info").
-          and_return([200, JSON.generate("version" => 1),
-                      { :date => server_time.rfc822 }])
+        and_return([200, JSON.generate("version" => 1),
+                    { :date => server_time.rfc822 }])
       @director.get_time_difference.to_i.should == 100
     end
 
@@ -241,59 +228,65 @@ describe Bosh::Cli::Director do
   describe "checking status" do
     it "considers target valid if it responds with 401 (for compatibility)" do
       @director.stub(:get).
-          with("/info", "application/json").
-          and_return([401, "Not authorized"])
+        with("/info", "application/json").
+        and_return([401, "Not authorized"])
       @director.exists?.should be_true
     end
 
     it "considers target valid if it responds with 200" do
       @director.stub(:get).
-          with("/info", "application/json").
-          and_return([200, JSON.generate("name" => "Director is your friend")])
+        with("/info", "application/json").
+        and_return([200, JSON.generate("name" => "Director is your friend")])
       @director.exists?.should be_true
     end
   end
 
   describe "tracking request" do
     it "starts polling task if request responded with a redirect to task URL" do
+      options = { :arg1 => 1, :arg2 => 2 }
+
       @director.should_receive(:request).
-          with(:get, "/stuff", "text/plain", "abc").
-          and_return([302, "body", { :location => "/tasks/502" }])
-      @director.should_receive(:poll_task).
-          with("502", :arg1 => 1, :arg2 => 2).
-          and_return("polling result")
+        with(:get, "/stuff", "text/plain", "abc").
+        and_return([302, "body", { :location => "/tasks/502" }])
+
+      tracker = mock("tracker", :track => "polling result", :output => "foo")
+
+      Bosh::Cli::TaskTracker.should_receive(:new).
+        with(@director, "502", options).
+        and_return(tracker)
+
       @director.request_and_track(:get, "/stuff", "text/plain",
-                                  "abc", :arg1 => 1, :arg2 => 2).
-          should == ["polling result", "502"]
+                                  "abc", options).
+        should == ["polling result", "502", "foo"]
     end
 
-    it "considers all reponses but 302 a failure" do
+    it "considers all responses but 302 a failure" do
       [200, 404, 403].each do |code|
         @director.should_receive(:request).
-            with(:get, "/stuff", "text/plain", "abc").
-            and_return([code, "body", { }])
+          with(:get, "/stuff", "text/plain", "abc").
+          and_return([code, "body", {}])
         @director.request_and_track(:get, "/stuff", "text/plain",
                                     "abc", :arg1 => 1, :arg2 => 2).
-            should == [:failed, nil]
+          should == [:failed, nil, nil]
       end
     end
 
-    it "reports task as non trackable if its URL is unfamiliar" do
+    it "reports task as non-trackable if its URL is unfamiliar" do
       @director.should_receive(:request).
-          with(:get, "/stuff", "text/plain", "abc").
-          and_return([302, "body", { :location => "/track-task/502" }])
+        with(:get, "/stuff", "text/plain", "abc").
+        and_return([302, "body", { :location => "/track-task/502" }])
       @director.request_and_track(:get, "/stuff", "text/plain",
                                   "abc", :arg1 => 1, :arg2 => 2).
-          should == [:non_trackable, nil]
+        should == [:non_trackable, nil, nil]
     end
 
-    it "suppports uploading with progress bar" do
+    it "supports uploading with progress bar" do
       file = spec_asset("valid_release.tgz")
       f = Bosh::Cli::FileWithProgressBar.open(file, "r")
 
       Bosh::Cli::FileWithProgressBar.stub!(:open).with(file, "r").and_return(f)
       @director.should_receive(:request_and_track).
-          with(:post, "/stuff", "application/x-compressed", f, { })
+        with(:post, "/stuff", "application/x-compressed", f, { })
       @director.upload_and_track("/stuff", "application/x-compressed", file)
       f.progress_bar.finished?.should be_true
     end
@@ -308,16 +301,16 @@ describe Bosh::Cli::Director do
 
       client = mock("httpclient")
       client.should_receive(:send_timeout=).
-          with(Bosh::Cli::Director::API_TIMEOUT)
+        with(Bosh::Cli::Director::API_TIMEOUT)
       client.should_receive(:receive_timeout=).
-          with(Bosh::Cli::Director::API_TIMEOUT)
+        with(Bosh::Cli::Director::API_TIMEOUT)
       client.should_receive(:connect_timeout=).
-          with(Bosh::Cli::Director::CONNECT_TIMEOUT)
+        with(Bosh::Cli::Director::CONNECT_TIMEOUT)
       HTTPClient.stub!(:new).and_return(client)
 
       client.should_receive(:request).
-          with(:get, "http://target/stuff", :body => "payload",
-               :header => headers.merge("Authorization" => auth))
+        with(:get, "http://target/stuff", :body => "payload",
+             :header => headers.merge("Authorization" => auth))
       @director.send(:perform_http_request, :get,
                      "http://target/stuff", "payload", headers)
     end
@@ -351,7 +344,7 @@ describe Bosh::Cli::Director do
                                :headers => {})
 
           @director.should_receive(:perform_http_request).
-              and_return(mock_response)
+            and_return(mock_response)
           @director.request(:get, "/stuff", "application/octet-stream",
                             "payload", { :hdr1 => "a", :hdr2 => "b"})
         }.should raise_error(Bosh::Cli::DirectorError,
@@ -363,7 +356,7 @@ describe Bosh::Cli::Director do
                                :body => "error message goes here",
                                :headers => {})
           @director.should_receive(:perform_http_request).
-              and_return(mock_response)
+            and_return(mock_response)
           @director.request(:get, "/stuff", "application/octet-stream",
                             "payload", { :hdr1 => "a", :hdr2 => "b"})
         }.should raise_error(Bosh::Cli::DirectorError,
@@ -376,7 +369,7 @@ describe Bosh::Cli::Director do
                                :body => '{"c":"d","a":"b"}',
                                :headers => {})
           @director.should_receive(:perform_http_request).
-              and_return(mock_response)
+            and_return(mock_response)
           @director.request(:get, "/stuff", "application/octet-stream",
                             "payload", { :hdr1 => "a", :hdr2 => "b"})
         }.should raise_error(Bosh::Cli::DirectorError,
@@ -388,13 +381,15 @@ describe Bosh::Cli::Director do
     it "wraps director access exceptions" do
       [URI::Error, SocketError, Errno::ECONNREFUSED].each do |err|
         @director.should_receive(:perform_http_request).
-            and_raise(err.new("err message"))
+          and_raise(err.new("err message"))
         lambda {
           @director.request(:get, "/stuff", "app/zb", "payload", { })
         }.should raise_error(Bosh::Cli::DirectorInaccessible)
       end
+
       @director.should_receive(:perform_http_request).
-          and_raise(SystemCallError.new("err message"))
+        and_raise(SystemCallError.new("err message", 22))
+
       lambda {
         @director.request(:get, "/stuff", "app/zb", "payload", { })
       }.should raise_error Bosh::Cli::DirectorError
@@ -404,11 +399,12 @@ describe Bosh::Cli::Director do
       mock_response = mock("response", :code => 200,
                            :body => "test body", :headers => { })
       @director.should_receive(:perform_http_request).
-          and_yield("test body").and_return(mock_response)
+        and_yield("test body").and_return(mock_response)
 
-      code, filename, headers = @director.request(:get,
-                                                  "/files/foo", nil, nil,
-                                                  { }, { :file => true })
+      code, filename, headers =
+        @director.request(:get,
+                          "/files/foo", nil, nil,
+                          { }, { :file => true })
 
       code.should == 200
       File.read(filename).should == "test body"
@@ -416,96 +412,4 @@ describe Bosh::Cli::Director do
     end
   end
 
-  describe "polling jobs" do
-    it "polls until success" do
-      n_calls = 0
-
-      @director.stub!(:get_time_difference).and_return(0)
-      @director.should_receive(:get).
-          with("/tasks/1").exactly(5).times.
-          and_return {
-            n_calls += 1;
-            [200,
-             JSON.generate("state" => n_calls == 5 ? "done" : "processing")
-            ]
-          }
-      @director.should_receive(:get).
-          with("/tasks/1/output",
-               nil, nil, "Range" => "bytes=0-").
-          exactly(5).times.and_return(nil)
-
-      @director.poll_task(1, :poll_interval => 0, :max_polls => 1000).
-          should == :done
-    end
-
-    it "respects max polls setting" do
-      @director.stub!(:get_time_difference).and_return(0)
-      @director.should_receive(:get).with("/tasks/1").
-          exactly(10).times.
-          and_return [200, JSON.generate("state" => "processing")]
-      @director.should_receive(:get).
-          with("/tasks/1/output",
-               nil, nil, "Range" => "bytes=0-").
-          exactly(10).times.and_return(nil)
-
-      @director.poll_task(1, :poll_interval => 0, :max_polls => 10).
-          should == :track_timeout
-    end
-
-    it "respects poll interval setting" do
-      @director.stub(:get).and_return([200, "processing"])
-
-      @director.should_receive(:get).with("/tasks/1").
-        exactly(10).times.
-        and_return([200, JSON.generate("state" => "processing")])
-      @director.should_receive(:get).
-          with("/tasks/1/output", nil, nil,
-               "Range" => "bytes=0-").
-          exactly(10).times.and_return(nil)
-      @director.should_receive(:sleep).with(5).exactly(9).times.and_return(nil)
-
-      @director.poll_task(1, :poll_interval => 5, :max_polls => 10).
-          should == :track_timeout
-    end
-
-    it "stops polling and returns error if status is not HTTP 200" do
-      @director.stub!(:get_time_difference).and_return(0)
-
-      @director.should_receive(:get).
-          with("/tasks/1").
-          and_return([500, JSON.generate("state" => "processing")])
-
-      lambda {
-        @director.poll_task(1, :poll_interval => 0, :max_polls => 10)
-      }.should raise_error(Bosh::Cli::TaskTrackError,
-                           "Got HTTP 500 while tracking task state")
-    end
-
-    it "stops polling and returns error if task state is error" do
-      @director.stub!(:get_time_difference).and_return(0)
-
-      @director.stub(:get).
-        with("/tasks/1/output", nil, nil,
-             "Range" => "bytes=0-").
-        and_return([200, ""])
-
-      @director.stub(:get).
-        with("/tasks/1").
-        and_return([200, JSON.generate("state" => "error")])
-
-      @director.should_receive(:get).exactly(2).times
-
-      @director.poll_task(1, :poll_interval => 0, :max_polls => 10).
-          should == :error
-    end
-  end
-
-  it "calls cancel_task on the current task when cancel_current is called" do
-    task_num = 1
-    @director.stub(:cancel_task).and_return(["body", 200])
-    @director.should_receive(:cancel_task).once.with(task_num)
-    @director.should_receive(:say).once.with("Cancelling task ##{task_num}.")
-    @director.current_running_task = task_num
-    @director.cancel_current
-  end
 end