elevate 0.5.0 → 0.6.0

data/lib/elevate/task_context.rb

@@ -1,4 +1,10 @@
 module Elevate
+  # A blank slate for hosting task blocks.
+  #
+  # Because task blocks run in another thread, it is dangerous to expose them
+  # to the calling context. This class acts as a sandbox for task blocks. 
+  #
+  # @api private
   class TaskContext
     def initialize(args, &block)
       metaclass = class << self; self; end

data/lib/elevate/version.rb

@@ -1,3 +1,3 @@
 module Elevate
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/spec/elevate_spec.rb

@@ -0,0 +1,159 @@
+module Bacon
+  class Context
+    include ::Elevate
+  end
+end
+
+describe Elevate do
+  extend WebStub::SpecHelpers
+
+  describe "#async" do
+    it "runs the specified task asynchronously" do
+      async do
+        task do
+          true
+        end
+
+        on_finish do |result, exception|
+          @called = result
+          resume
+        end
+      end
+
+      wait_max 1.0 do
+        @called.should.be.true
+      end
+    end
+
+    it "passes provided args to the task as instance variables" do
+      async name: "harry" do
+        task do
+          @name
+        end
+
+        on_finish do |name, exception|
+          @result = name
+          resume
+        end
+      end
+
+      wait_max 1.0 do
+        @result.should == "harry"
+      end
+    end
+
+    it "allows tasks to report progress" do
+      @updates = []
+
+      async do
+        task do
+          sleep 0.1
+          yield 1
+          sleep 0.2
+          yield 2
+          sleep 0.3
+          yield 3
+
+          true
+        end
+
+        on_update do |count|
+          @updates << count
+        end
+
+        on_finish do |result, exception|
+          resume
+        end
+      end
+
+      wait_max 1.0 do
+        @updates.should == [1,2,3]
+      end
+    end
+
+    describe "timeouts" do
+      before do
+        stub_request(:get, "http://example.com/").
+          to_return(body: "Hello!", content_type: "text/plain", delay: 1.0)
+      end
+
+      it "does not cancel the operation if it completes in time" do
+        @timed_out = false
+
+        async do
+          timeout 3.0
+
+          task do
+            Elevate::HTTP.get("http://example.com/")
+
+            "finished"
+          end
+
+          on_finish do |result, exception|
+            @result = result
+            resume
+          end
+        end
+
+        wait_max 5.0 do
+          @result.should == "finished"
+          @timed_out.should.be.false
+        end
+      end
+
+      it "stops the operation when timeout interval has elapsed" do
+        @result = nil
+
+        @task = async do
+          timeout 0.5
+
+          task do
+            Elevate::HTTP.get("http://example.com/")
+
+            "finished"
+          end
+
+          on_finish do |result, exception|
+            @result = result
+            resume
+          end
+        end
+
+        wait_max 5.0 do
+          @result.should.not == "finished"
+
+          @task.timed_out?.should.be.true
+        end
+      end
+
+      it "invokes on_timeout when a timeout occurs" do
+        @result = ""
+        @timed_out = false
+
+        async do
+          timeout 0.5
+
+          task do
+            Elevate::HTTP.get("http://example.com/")
+
+            "finished"
+          end
+
+          on_timeout do
+            @timed_out = true
+          end
+
+          on_finish do |result, exception|
+            @result = result
+            resume
+          end
+        end
+
+        wait_max 5.0 do
+          @result.should.not == "finished"
+          @timed_out.should.be.true
+        end
+      end
+    end
+  end
+end

data/spec/http/{http_request_spec.rb → request_spec.rb}

@@ -1,4 +1,4 @@
-describe Elevate::HTTP::HTTPRequest do
+describe Elevate::HTTP::Request do
   extend WebStub::SpecHelpers
 
   before do
@@ -11,15 +11,15 @@ describe Elevate::HTTP::HTTPRequest do
   end
 
   it "requires a valid HTTP method" do
-    lambda { Elevate::HTTP::HTTPRequest.new(:invalid, @url) }.should.raise(ArgumentError)
+    lambda { Elevate::HTTP::Request.new(:invalid, @url) }.should.raise(ArgumentError)
   end
 
   it "requires a URL starting with http" do
-    lambda { Elevate::HTTP::HTTPRequest.new(:get, "asdf") }.should.raise(ArgumentError)
+    lambda { Elevate::HTTP::Request.new(:get, "asdf") }.should.raise(ArgumentError)
   end
 
   it "requires the body to be an instance of NSData" do
-    lambda { Elevate::HTTP::HTTPRequest.new(:get, @url, body: @body) }.should.raise(ArgumentError)
+    lambda { Elevate::HTTP::Request.new(:get, @url, body: @body) }.should.raise(ArgumentError)
   end
 
   describe "fulfilling a GET request" do
@@ -27,7 +27,7 @@ describe Elevate::HTTP::HTTPRequest do
       stub_request(:get, @url).
         to_return(body: @body, headers: {"Content-Type" => "text/plain"}, status_code: 201)
 
-      @request = Elevate::HTTP::HTTPRequest.new(:get, @url)
+      @request = Elevate::HTTP::Request.new(:get, @url)
       @response = @request.response
     end
 
@@ -52,7 +52,7 @@ describe Elevate::HTTP::HTTPRequest do
     before do
       stub_request(:get, @url).with(headers: { "API-Token" => "abc123" }).to_return(body: @body)
 
-      @request = Elevate::HTTP::HTTPRequest.new(:get, @url, headers: {})
+      @request = Elevate::HTTP::Request.new(:get, @url, headers: { "API-Token" => "abc123" })
       @response = @request.response
     end
 
@@ -67,7 +67,7 @@ describe Elevate::HTTP::HTTPRequest do
     end
 
     it "sends the body as part of the request" do
-      request = Elevate::HTTP::HTTPRequest.new(:post, @url, body: @body.dataUsingEncoding(NSUTF8StringEncoding))
+      request = Elevate::HTTP::Request.new(:post, @url, body: @body.dataUsingEncoding(NSUTF8StringEncoding))
       response = request.response
 
       NSString.alloc.initWithData(response.body, encoding:NSUTF8StringEncoding).should == @body
@@ -82,9 +82,9 @@ describe Elevate::HTTP::HTTPRequest do
     it "aborts the request" do
       start = Time.now
 
-      request = Elevate::HTTP::HTTPRequest.new(:get, @url)
-      request.start()
-      request.cancel()
+      request = Elevate::HTTP::Request.new(:get, @url)
+      request.send
+      request.cancel
 
       response = request.response # simulate blocking
       finish = Time.now
@@ -93,9 +93,9 @@ describe Elevate::HTTP::HTTPRequest do
     end
 
     it "sets the response to nil" do
-      request = Elevate::HTTP::HTTPRequest.new(:get, @url)
-      request.start()
-      request.cancel()
+      request = Elevate::HTTP::Request.new(:get, @url)
+      request.send
+      request.cancel
 
       request.response.should.be.nil
     end

data/spec/http_spec.rb

@@ -0,0 +1,195 @@
+describe Elevate::HTTP do
+  extend WebStub::SpecHelpers
+
+  before  { disable_network_access! }
+  after   { enable_network_access! }
+
+  before do
+    @url = "http://www.example.com/"
+  end
+
+  Elevate::HTTP::Request::METHODS.each do |m|
+    describe ".#{m}" do
+      it "synchronously issues a HTTP #{m} request" do
+        stub = stub_request(m, @url)
+        Elevate::HTTP.send(m, @url)
+
+        stub.should.be.requested
+      end
+    end
+  end
+
+  describe "Request options" do
+    it "encodes query string of :headers" do
+      stub = stub_request(:get, "#{@url}?a=1&b=hello&c=4.2")
+
+      Elevate::HTTP.get(@url, query: { a: 1, b: "hello", c: "4.2" })
+
+      stub.should.be.requested
+    end
+
+    it "sends headers specified by :headers" do
+      stub = stub_request(:get, @url).
+        with(headers: { "API-Key" => "secret" })
+
+      Elevate::HTTP.get(@url, headers: { "API-Key" => "secret" })
+
+      stub.should.be.requested
+    end
+
+    it "sends body content specified by :body" do
+      stub = stub_request(:post, @url).with(body: "hello")
+
+      Elevate::HTTP.post(@url, body: "hello".dataUsingEncoding(NSUTF8StringEncoding))
+
+      stub.should.be.requested
+    end
+
+    describe "with a JSON body" do
+      it "encodes JSON dictionary specified by :json" do
+        stub = stub_request(:post, @url).with(body: '{"test":"secret"}')
+
+        Elevate::HTTP.post(@url, json: { "test" => "secret" })
+
+        stub.should.be.requested
+      end
+
+      it "encodes JSON array specified by :json" do
+        stub = stub_request(:post, @url).with(body: '["1","2"]')
+
+        Elevate::HTTP.post(@url, json: ["1", "2"])
+
+        stub.should.be.requested
+      end
+
+      it "sets the correct Content-Type" do
+        stub = stub_request(:post, @url).
+          with(body: '{"test":"secret"}', headers: { "Content-Type" => "application/json" })
+
+        Elevate::HTTP.post(@url, json: { "test" => "secret" })
+
+        stub.should.be.requested
+      end
+    end
+
+    describe "with a form body" do
+      it "encodes form data specified by :form" do
+        stub = stub_request(:post, @url).with(body: { "test" => "secret", "user" => "matt" })
+
+        Elevate::HTTP.post(@url, form: { "test" => "secret", "user" => "matt" })
+
+        stub.should.be.requested
+      end
+
+      it "sets the correct Content-Type" do
+        stub = stub_request(:post, @url).
+          with(body: { "test" => "secret", "user" => "matt" }, headers: { "Content-Type" => "application/x-www-form-urlencoded" })
+
+        Elevate::HTTP.post(@url, form: { "test" => "secret", "user" => "matt" })
+
+        stub.should.be.requested
+      end
+    end
+  end
+
+  describe "Response" do
+    it "returns a Response" do
+      stub_request(:get, @url).
+        to_return(body: "hello",
+                  headers: { "X-TestHeader" => "Value" }, 
+                  status_code: 204)
+
+      response = Elevate::HTTP.get(@url)
+
+      NSString.alloc.initWithData(response.body, encoding: NSUTF8StringEncoding).should == "hello"
+      NSString.alloc.initWithData(response.raw_body, encoding: NSUTF8StringEncoding).should == "hello"
+      response.error.should.be.nil
+      response.headers.keys.should.include("X-TestHeader")
+      response.status_code.should == 204
+      response.url.should == @url
+    end
+
+    describe "when the response is encoded as JSON" do
+      it "should automatically decode it" do
+        stub_request(:get, @url).
+          to_return(json: { user_id: "3", token: "secret" })
+
+        response = Elevate::HTTP.get(@url)
+
+        response.body.should == { "user_id" => "3", "token" => "secret" }
+      end
+
+      describe "when a JSON dictionary is returned" do
+        it "the returned response should behave like a Hash" do
+          stub_request(:get, @url).
+            to_return(json: { user_id: "3", token: "secret" })
+
+          response = Elevate::HTTP.get(@url)
+
+          response["user_id"].should == "3"
+        end
+      end
+
+      describe "when a JSON array is returned" do
+        it "the returned response should behave like an Array" do
+          stub_request(:get, @url).
+            to_return(json: ["apple", "orange", "pear"])
+
+          response = Elevate::HTTP.get(@url)
+
+          response.length.should == 3
+        end
+      end
+    end
+
+    describe "when the response is redirected" do
+      it "redirects to the final URL" do
+        @redirect_url = @url + "redirected"
+
+        stub_request(:get, @redirect_url).to_return(body: "redirected")
+        stub_request(:get, @url).to_redirect(url: @redirect_url)
+
+        response = Elevate::HTTP.get(@url)
+        response.url.should == @redirect_url
+      end
+
+      describe "with an infinite redirect loop" do
+        before do
+          @url2 = @url + "redirect"
+
+          stub_request(:get, @url).to_redirect(url: @url2)
+          stub_request(:get, @url2).to_redirect(url: @url)
+        end
+
+        it "raises a RequestError" do
+          lambda { Elevate::HTTP.get(@url) }.
+            should.raise(Elevate::HTTP::RequestError)
+        end
+      end
+    end
+
+    #describe "when the response has a HTTP error status" do
+      #it "raises RequestError" do
+        #stub_request(m, @url).to_return(status_code: 422)
+
+        #lambda { Elevate::HTTP.send(m, @url) }.should.raise(Elevate::HTTP::RequestError)
+      #end
+    #end
+
+    describe "when the request cannot be fulfilled" do
+      it "raises a RequestError" do
+        lambda { Elevate::HTTP.get(@url) }.
+          should.raise(Elevate::HTTP::RequestError)
+      end
+    end
+
+    describe "when the Internet connection is offline" do
+      it "raises an OfflineError" do
+        stub_request(:get, @url).to_fail(code: NSURLErrorNotConnectedToInternet)
+
+        lambda { Elevate::HTTP.get(@url) }.
+          should.raise(Elevate::HTTP::OfflineError)
+      end
+    end
+  end
+end

data/spec/io_coordinator_spec.rb

@@ -30,6 +30,14 @@ describe Elevate::IOCoordinator do
           lambda { @coordinator.send(method, "hello") }.should.raise(Elevate::CancelledError)
         end
       end
+
+      describe "when IO has timed out" do
+        it "raises TimeoutError" do
+          @coordinator.cancel(Elevate::TimeoutError)
+
+          lambda { @coordinator.send(method, "hello") }.should.raise(Elevate::TimeoutError)
+        end
+      end
     end
   end