dot_net_services 0.0.1

data/spec/unit/dot_net_services/message_buffer_spec.rb

@@ -0,0 +1,161 @@
+require "#{File.dirname(__FILE__)}/../../spec_helper"
+
+module DotNetServices
+  describe MessageBuffer do
+    describe "initialize(name, auth_data)" do
+      it "should create a session" do
+        Session.should_receive(:new).with('foo', :username => 'bar', :password => 'baz').and_return(:session)
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        mb.session.should == :session
+      end
+
+      it "should be possible to specify polling_interval"
+    end
+
+    describe "register" do
+      it "should register a message buffer" do
+        response = Net::HTTPCreated.new(nil, nil, nil)
+        
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        mb.session.should_receive(:createmb).and_return(response)
+        mb.register.should equal(mb)
+      end
+
+      it "should blow up if the response code is not 201 and the buffer cannot be queried" do
+        create_response = Net::HTTPInternalServerError.new(nil, nil, nil)
+        query_response = Net::HTTPNotFound.new(nil, nil, nil)
+
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        mb.session.should_receive(:createmb).and_return(create_response)
+        mb.session.should_receive(:get_from_relay).and_return(query_response)
+        proc { mb.register }.should raise_error(
+                 RuntimeError, "Creating VMB failed. Service responded with Net::HTTPInternalServerError")
+      end
+
+      it "should not blow up if the response code to CREATEMB is not 201, byt the buffer can be queried" do
+        create_response = Net::HTTPInternalServerError.new(nil, nil, nil)
+        query_response = Net::HTTPSuccess.new(nil, nil, nil)
+
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        mb.session.should_receive(:createmb).and_return(create_response)
+        mb.session.should_receive(:get_from_relay).and_return(query_response)
+        proc { mb.register }.should_not raise_error(
+                 RuntimeError, "Creating VMB failed. Service responded with Net::HTTPInternalServerError")
+      end
+
+    end
+
+    describe "open(&block)" do
+      it "should register the buffer if necessary" do
+        block = lambda { :foo }
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        mb.session.should_receive(:get_from_relay).and_return(Net::HTTPNotFound.new(nil, nil, nil))
+        mb.should_receive(:register).and_return(mb)
+        mb.open(&block)
+      end
+    end
+
+    describe "poll" do
+      it "should retrieve a single message from the buffer" do
+        response = Net::HTTPOK.new(nil, nil, nil)
+
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        mb.session.should_receive(:retrieve).with(:encoding => 'asreply', :timeout => nil).and_return(response)
+
+        message = mb.poll
+        
+        message.should == response
+      end
+
+      it "should return nil if no no message was retrieved in the buffer" do
+        response = Net::HTTPNoContent.new(nil, nil, nil)
+
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        mb.session.should_receive(:retrieve).and_return(response)
+
+        mb.poll.should be_nil
+      end
+
+      it "should recreate a buffer if the bus says it doesn't exist and poll again" do
+        not_found_response = Net::HTTPNotFound.new(nil, nil, nil)
+        created_response = Net::HTTPCreated.new(nil, nil, nil)
+
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+
+        mb.session.should_receive(:retrieve).with(:encoding => 'asreply', :timeout => nil).and_return(not_found_response)
+        mb.session.should_receive(:createmb).and_return(created_response)
+
+        message = mb.poll
+
+        message.should == nil
+      end
+
+    end
+
+    describe "delete()" do
+      it "should send a DELETE request to the relay" do
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        response = Net::HTTPNoContent.new(nil, nil, nil)
+
+        mb.session.should_receive(:delete).and_return(response)
+
+        mb.delete.should == mb
+      end
+
+      it "should do nothing if the response is NotFound (i.e., the VMB already doesn't exist"
+
+      it "should blow up if response is not NoContent, and not NotFound" do
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        response = Net::HTTPNotFound.new(nil, nil, nil)
+
+        mb.session.should_receive(:delete).and_return(response)
+
+        lambda { mb.delete }.should raise_error("Deleting VMB failed. Response was Net::HTTPNotFound")
+      end
+    end
+
+    describe "expires()" do
+      it "should do a GET to relay and return the value of 'expires' header" do
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+
+        response = Net::HTTPOK.new(nil, nil, nil)
+        response.should_receive(:[]).with('expires').and_return("Thu, 01 Dec 2009 16:00:00 GMT")
+
+        mb.session.should_receive(:get_from_relay).and_return(response)
+
+        mb.expires.should == DateTime.parse("2009-12-01 16:00:00 Z")
+      end
+
+      it "should blow up if response is not 200" do
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        response = Net::HTTPNotFound.new(nil, nil, nil)
+        mb.session.should_receive(:get_from_relay).and_return(response)
+
+        lambda { mb.expires }.should raise_error("Querying expiry status of VMB failed. Response was Net::HTTPNotFound")
+      end
+
+      it "should blow up if response has no expires header" do
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        response = Net::HTTPOK.new(nil, nil, nil)
+        response.should_receive(:[]).with('expires').and_return(nil)
+        mb.session.should_receive(:get_from_relay).and_return(response)
+
+        lambda { mb.expires }.should raise_error("Querying expiry status of VMB failed. Response doesn't have expires: header")
+      end
+    end
+
+    describe "keep_alive" do
+      it "should send an empty post to relay on buffer endpoint" do
+        mb = MessageBuffer.new('foo', :username => 'bar', :password => 'baz')
+        response = Net::HTTPOK.new(nil, nil, nil)
+        mb.session.should_receive(:post_to_relay).with("\n").and_return(response)
+        mb.keep_alive.should == mb
+      end
+    end
+
+    describe "subscribe" do
+      
+    end
+
+  end
+end

data/spec/unit/dot_net_services/session_spec.rb

@@ -0,0 +1,247 @@
+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

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: dot_net_services
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- ThoughtWorks
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-27 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: 
+email: dotnetsrv-ruby-users@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/dot_net_services
+- lib/dot_net_services/authentication.rb
+- lib/dot_net_services/error.rb
+- lib/dot_net_services/message_buffer.rb
+- lib/dot_net_services/session.rb
+- lib/dot_net_services.rb
+- lib/net
+- lib/net/http
+- lib/net/http/create_mb.rb
+- lib/net/http/retrieve.rb
+- lib/net/http/subscribe.rb
+- lib/net/http/unsubscribe.rb
+- spec/integration
+- spec/integration/end_to_end_spec.rb
+- spec/integration/TestService
+- spec/integration/TestService/Service
+- spec/integration/TestService/Service/AnonymousResourceService.cs
+- spec/integration/TestService/Service/App.config
+- spec/integration/TestService/Service/PlainTextService.cs
+- spec/integration/TestService/Service/Program.cs
+- spec/integration/TestService/Service/Properties
+- spec/integration/TestService/Service/Properties/AssemblyInfo.cs
+- spec/integration/TestService/Service/ResourceContract.cs
+- spec/integration/TestService/Service/ResourceService.cs
+- spec/integration/TestService/Service/Service.csproj
+- spec/integration/TestService/TestService.sln
+- spec/integration/vmb_spec.rb
+- spec/spec_helper.rb
+- spec/unit
+- spec/unit/dot_net_services
+- spec/unit/dot_net_services/authentication_spec.rb
+- spec/unit/dot_net_services/message_buffer_spec.rb
+- spec/unit/dot_net_services/session_spec.rb
+- README
+- LICENSE
+has_rdoc: true
+homepage: http://dotnetservicesruby.com/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: dotnetsrv-ruby
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: .NET Services for Ruby
+test_files: []
+