dot_net_services 0.3.0 → 0.4.0

data/spec/unit/dot_net_services/session_spec.rb

@@ -1,247 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-module DotNetServices
-
-  describe Session do
-
-    describe "new(endpoint, auth_data = nil)" do
-      it "should take a relative path of the endpoint and convert to a full path" do
-        session = Session.new("/alexeyv/EchoService/")
-        session.endpoint.should == "#{DotNetServices.root_url}/alexeyv/EchoService/"
-      end
-
-      it "should not prefix an absolute endpoint path" do
-        Session.new("http://foo/").endpoint.should == "http://foo/"
-      end
-
-      it "should prefix relative endpoint path with a slash if necessary" do
-        Session.new("alexeyv/EchoService/").endpoint.should == "#{DotNetServices.root_url}/alexeyv/EchoService/"
-        Session.new("/alexeyv/EchoService/").endpoint.should == "#{DotNetServices.root_url}/alexeyv/EchoService/"
-      end
-
-      it "should append a slash to the endpoint path if necessary" do
-        Session.new("/alexeyv/EchoService").endpoint.should == "#{DotNetServices.root_url}/alexeyv/EchoService/"
-        Session.new("/alexeyv/EchoService/").endpoint.should == "#{DotNetServices.root_url}/alexeyv/EchoService/"
-        Session.new("http://foo").endpoint.should == "http://foo/"
-        Session.new("http://foo/").endpoint.should == "http://foo/"
-      end
-
-    end
-
-    describe "open" do
-      it "should create the session and return it" do
-        authenticator = mock('authenticator')
-        authenticator.should_receive(:authenticate)
-
-        session = Session.open("http://foo/", authenticator)
-
-        session.should be_instance_of(Session)
-        session.authenticator.should == authenticator
-        session.endpoint.should == "http://foo/"
-      end
-
-      it "should, given a block, pass the session to a block and return the result of the block" do
-        yielded_session = nil
-        result = Session.open("http://foo/") { |session| yielded_session = session; "been here"}
-
-        yielded_session.should be_instance_of(Session)
-        yielded_session.endpoint.should == "http://foo/"
-        result.should == "been here" 
-      end
-    end
-
-    describe "get(query_options=nil)" do
-      it "should send a get request to the endpoint and return the response" do
-        mock_http_get('foo', 80, '/')
-        result = Session.open("http://foo/") { |session| session.get }
-        result.should == :http_get_result 
-      end
-
-      it "should accept query options" do
-        mock_http_get('foo', 80, '/', 'bar=baz')
-        result = Session.open("http://foo/") { |session| session.get(:bar => 'baz') }
-        result.should == :http_get_result
-      end
-
-      it "should escape elements of the query" do
-        mock_http_get('foo', 80, '/', "foo=bar%2Bbaz%7Equx")
-        result = Session.open("http://foo/") { |session| session.get(:foo => "bar+baz~qux") }
-        result.should == :http_get_result
-      end
-
-      it "should pass a request through authentication handler" do
-        mock_http, mock_get = mock_http_get('foo', 80, '/')
-
-        authenticator = mock('authenticator')
-        authenticator.should_receive(:authenticate)
-        authenticator.should_receive(:enhance).with(mock_get)
-
-        result = Session.open("http://foo/", authenticator) { |session| session.get }
-        result.should == :http_get_result
-      end
-
-    end
-
-    describe "get_to_url(url, data=nil, content_type='application/x-www-form-urlencoded')" do
-
-      it "should get data from the URL under the endpoint" do
-        mock_http_get('foo', 80, '/services/suburl', "foo=bar")
-        result = Session.open("http://foo/services/") { |session| session.get_from_url('suburl', :foo => "bar") }
-        result.should == :http_get_result
-      end
-
-    end
-
-    describe "post(data=nil, content_type='application/x-www-form-urlencoded')" do
-      it "should pass data as URL encoded form if data is a Hash" do
-        mock_http_post_form('foo', 80, '/', :foo => 'bar')
-        result = Session.open("http://foo/") { |session| session.post(:foo => "bar") }
-        result.should == :http_post_result
-      end
-
-      it "should set data instead of form data on the Net::HTTP::Post instance, if content type is not url-encoded-form" do
-        mock_http = mock('http')
-        mock_post = mock('post')
-        Net::HTTP.should_receive(:start).with('foo', 80).and_yield(mock_http)
-        Net::HTTP::Post.should_receive(:new).with('/services/').and_return(mock_post)
-        mock_post.should_receive(:body=).with("post body")
-        mock_post.should_receive(:content_type=).with("text/plain")
-        mock_http.should_receive(:request).with(mock_post).and_return(:http_post_result)
-
-        result = Session.open("http://foo/services/") { |session| session.post("post body", "text/plain") }
-      end
-
-    end
-
-    describe "post_to_url(url, data=nil, content_type='application/x-www-form-urlencoded')" do
-
-      it "should post data to the URL under the endpoint" do
-        mock_http_post_form('foo', 80, '/services/suburl', :foo => 'bar')
-        result = Session.open("http://foo/services/") { |session| session.post_to_url('suburl', :foo => "bar") }
-        result.should == :http_post_result
-      end
-
-    end
-
-
-    describe "createmb" do
-      it "should make a createmb request" do
-        mock_createmb = mock('createmb')
-        Net::HTTP::CreateMB.should_receive(:new).with('/services/user/location/').and_return(mock_createmb)
-        mock_createmb.should_receive(:[]=).with(
-                "X-Process-At", "http://schemas.microsoft.com/ws/2007/08/connect/roles/relay")
-        mock_http = mock('http')
-        Net::HTTP.should_receive(:start).with(DotNetServices.relay_host, 80).and_yield(mock_http)
-        mock_http.should_receive(:request).with(mock_createmb).and_return(:response)
-        Session.open("http://#{DotNetServices.relay_host}/services/user/location") { |session| session.createmb }
-      end
-    end
-
-    describe "retrieve" do
-      it "should make a retrieve request" do
-        mock_retrieve = mock('retrieve')
-        Net::HTTP::Retrieve.should_receive(:new).with('/services/user/location/?timeout=10').and_return(mock_retrieve)
-        mock_retrieve.should_receive(:[]=).with(
-                'X-Process-At', "http://schemas.microsoft.com/ws/2007/08/connect/roles/relay")
-        mock_http = mock('http')
-        Net::HTTP.should_receive(:start).with(DotNetServices.relay_host, 80).and_yield(mock_http)
-        mock_http.should_receive(:request).with(mock_retrieve).and_return(:response)
-        actual_response = Session.open("http://#{DotNetServices.relay_host}/services/user/location") { |session| session.retrieve(:timeout => 10) }
-        actual_response.should == :response
-      end
-
-      it "should coerce the keys in options to strings and downcase them" do
-        mock_retrieve = mock('retrieve')
-        mock_retrieve.stub!(:[]=)
-        mock_http = mock('http')
-
-        Net::HTTP::Retrieve.should_receive(:new).with("/services/user/location/?timeout=5").and_return(mock_retrieve)
-        Net::HTTP::Retrieve.should_receive(:new).with("/services/user/location/?timeout=6").and_return(mock_retrieve)
-        Net::HTTP.should_receive(:start).twice.and_yield(mock_http)
-        mock_http.should_receive(:request).twice.with(mock_retrieve).and_return(:response)
-
-        Session.open("http://#{DotNetServices.relay_host}/services/user/location") do
-          |session|
-          session.retrieve :timeout => 5
-          session.retrieve "TIMEOUT" => 6
-        end
-      end
-
-      it "should insert a default timeout of 15 seconds if it's not provided" do
-        mock_retrieve = mock('retrieve')
-        mock_retrieve.stub!(:[]=)
-        mock_http = mock('http')
-
-        Net::HTTP::Retrieve.should_receive(:new).with("/services/user/location/?timeout=15").and_return(mock_retrieve)
-        Net::HTTP.should_receive(:start).and_yield(mock_http)
-        mock_http.should_receive(:request).with(mock_retrieve).and_return(:response)
-
-        Session.open("http://#{DotNetServices.relay_host}/services/user/location") do
-          |session|
-          session.retrieve
-        end
-      end
-
-    end
-
-    describe "get_from_relay" do
-
-      it "should set X-Process-At header and send to the bus as normal post" do
-        mock_http = mock('http')
-        Net::HTTP.should_receive(:start).with(DotNetServices.relay_host, 80).and_yield(mock_http)
-
-        mock_http.should_receive(:request) do |get_request|
-          get_request['X-Process-At'].should == 'http://schemas.microsoft.com/ws/2007/08/connect/roles/relay'
-          true
-        end
-
-        Session.open("http://#{DotNetServices.relay_host}/services/user/location") do
-          |session|
-          session.get_from_relay
-        end
-      end
-
-    end
-
-    describe "post_to_relay" do
-
-      it "should set X-Process-At header and send to the bus as normal post" do
-        mock_http = mock('http')
-        Net::HTTP.should_receive(:start).with(DotNetServices.relay_host, 80).and_yield(mock_http)
-
-        mock_http.should_receive(:request) do |post_request|
-          post_request['X-Process-At'].should == 'http://schemas.microsoft.com/ws/2007/08/connect/roles/relay'
-          true
-        end
-
-        Session.open("http://#{DotNetServices.relay_host}/services/user/location") do
-          |session|
-          session.post_to_relay
-        end
-      end
-
-    end
-
-    def mock_http_get(host, port, path, query = nil)
-      mock_http = mock('http')
-      mock_get = mock('get')
-      Net::HTTP.should_receive(:start).with(host, port).and_yield(mock_http)
-      path_and_query = query ? "#{path}?#{query}" : path
-      Net::HTTP::Get.should_receive(:new).with(path_and_query).and_return(mock_get)
-      mock_http.should_receive(:request).with(mock_get).and_return(:http_get_result)
-      [mock_http, mock_get]
-    end
-
-    def mock_http_post_form(host, port, path, form_data=nil)
-      mock_http = mock('http')
-      mock_post = mock('post')
-      Net::HTTP.should_receive(:start).with(host, port).and_yield(mock_http)
-      Net::HTTP::Post.should_receive(:new).with(path).and_return(mock_post)
-      mock_post.should_receive(:form_data=).with(form_data)
-      mock_post.should_receive(:content_type=).with('application/x-www-form-urlencoded')
-      mock_http.should_receive(:request).with(mock_post).and_return(:http_post_result)
-      [mock_http, mock_post]
-    end
-
-  end
-end