dot_net_services 0.3.0 → 0.4.0

data/spec/unit/dot_net_services/authentication_spec.rb

@@ -1,289 +0,0 @@
-require "#{File.dirname(__FILE__)}/../../spec_helper"
-
-module DotNetServices
-
-  describe Authentication::UsernamePassword do
-
-    describe "acting as a hash key" do
-      before :each do
-        @auth = Authentication::UsernamePassword.new('frodo', 'passw0rd')
-      end
-
-      it "should not be equal to an instance of another class" do
-        different_class = stub('not the same class', :username => 'frodo', :password => 'passw0rd')
-        different_class.should_receive(:is_a?).with(Authentication::UsernamePassword).and_return(false)
-        @auth.should_not == different_class
-      end
-
-      it "should not be equal to an instance with different username or password" do
-        @auth.should_not == Authentication::UsernamePassword.new('gandalf', 'passw0rd')
-        @auth.should_not == Authentication::UsernamePassword.new('frodo', 'different passw0rd') 
-      end
-
-      it  "should equal to another instance with same username and password" do
-        @auth.should == @auth
-        @auth.should == Authentication::UsernamePassword.new('frodo', 'passw0rd') 
-      end
-
-      it "should adequately identify an instance in a hash" do
-        hash = {}
-        hash[@auth] = :found
-        hash[@auth].should == :found
-
-        equivalent_auth = Authentication::UsernamePassword.new('frodo', 'passw0rd')
-        hash[equivalent_auth].should == :found
-
-        different_auth = Authentication::UsernamePassword.new('frodo', 'different passw0rd')
-        hash[different_auth].should be_nil
-      end
-
-    end
-
-    describe "authenticate()" do
-
-      it "should obtain a token from DotNetServices STS" do
-        http = mock_http
-        response = mock('response')
-        Time.stub!(:now).and_return(Time.at(0))
-
-        http.should_receive(:get).with("/issuetoken.aspx?u=frodo&p=password").and_return(response)
-        response.should_receive(:is_a?).with(Net::HTTPOK).and_return(true)
-        response.stub!(:body).and_return('bWyFxQgby0gHyPWZ2LcIXnHgA1J5kALK4iM+QA==')
-
-        auth = Authentication::UsernamePassword.new('frodo', 'password')
-        auth.authenticate
-        auth.token.value.should == 'bWyFxQgby0gHyPWZ2LcIXnHgA1J5kALK4iM+QA=='
-        auth.token.expiry.should == Time.at(24 * 60 * 60)
-      end
-
-      it "should rewrite exception messages to avoid accidentally exposing username/password" do
-        http = mock_http
-        http.should_receive(:get).with("/issuetoken.aspx?u=frodo&p=password").and_raise("p=password")
-        auth = Authentication::UsernamePassword.new('frodo', 'password')
-
-        begin
-          auth.authenticate
-        rescue => e
-          e.should be_instance_of(AuthenticationError) 
-          e.message.should_not =~ /password/
-        end
-      end
-
-      it "should detect when the HTTP response code is wrong and blow up correctly" do
-        http = mock_http
-        not_found = stub("HTTPNotFound", :class => Net::HTTPNotFound)
-        not_found.should_receive(:is_a?).with(Net::HTTPOK).and_return(false)
-       
-        http.should_receive(:get).with("/issuetoken.aspx?u=frodo&p=password").and_return(not_found)
-        auth = Authentication::UsernamePassword.new('frodo', 'password')
-
-        lambda { auth.authenticate }.should raise_error(AuthenticationError,
-              "Failed to obtain a security token from the identity service. HTTP response was Net::HTTPNotFound")
-      end
-
-      # TODO Identity service response for this situation is not correct now. Implement test when they fix it
-      it "should detect an invalid user/password situation and blow up correctly"
-
-      # TODO asked MS what future-proof assertions can be made to see if it's a token
-      it "should detect when response is not a token and blow up correctly"
-#      do
-#        http = mock_http
-#        response = mock('response')
-#        http.should_receive(:get).with("/issuetoken.aspx?u=frodo&p=password").and_return(response)
-#        response.should_receive(:is_a?).with(Net::HTTPOK).and_return(true)
-#        response.stub!(:body).and_return('NOT A TOKEN')
-#
-#        auth = Authentication::UsernamePassword.new('frodo', 'password')
-#        proc { auth.authenticate }.should raise_error(
-#                AuthenticationError, "Response from identity service is not a valid token. " +
-#                    # TODO remove the line below when we are able to detect this situation explicitly
-#                     "This can indicate username/password mismatch.")
-#      end
-
-      it "should not acquire a new token if a token is already defined" do
-        token = Authentication::Token.new("nh8hUpTSAeMW0RVkMRRaZtxJqfM==")
-        auth = Authentication::UsernamePassword.new('frodo', 'password', token)
-        Net::HTTP.should_not_receive(:new)
-        auth.authenticate
-      end
-
-      it "should acquire new token if token is expired" do
-        expired_token = Authentication::Token.new('expired/token==', Time.now - 1)
-        new_token = Authentication::Token.new('new/token==', Time.now)
-        auth = Authentication::UsernamePassword.new('frodo', 'password', expired_token)
-
-        auth.should_receive(:acquire_token).and_return(new_token)
-        request = {}
-        auth.enhance(request)
-        auth.token.should equal(new_token)
-        request['X-MS-Identity-Token'].should == 'new/token=='
-      end
-
-      it "should acquire new token if token is not set" do
-        auth = Authentication::UsernamePassword.new('frodo', 'password')
-        auth.token.should be_nil
-        new_token = Authentication::Token.new('new/token==', Time.now)
-
-        auth.should_receive(:acquire_token).and_return(new_token)
-
-        request = {}
-        auth.enhance(request)
-        auth.token.should equal(new_token)
-        request['X-MS-Identity-Token'].should == 'new/token=='
-      end
-
-      def mock_http
-        http = mock('http')
-        Net::HTTP.should_receive(:new).with(DotNetServices.identity_host, 443).and_return(http)
-        http.should_receive(:use_ssl=).with(true)
-        http.should_receive(:verify_mode=).with(OpenSSL::SSL::VERIFY_NONE)
-        http
-      end
-
-    end
-
-    describe "enhance(request)" do
-
-      it "should put a token into X-MS-Identity-Token header" do
-        Time.stub!(:now).and_return(Time.at(0))
-        request = {}
-        token = Authentication::Token.new("a/token==", Time.at(1))
-        auth = Authentication::UsernamePassword.new('frodo', 'password', token)
-        auth.enhance(request)
-        request['X-MS-Identity-Token'].should == "a/token=="
-      end
-
-      it "should acquire the token if necessary" do
-        token = Authentication::Token.new("a/token==", Time.at(1))
-        auth = Authentication::UsernamePassword.new('frodo', 'password')
-        auth.should_receive(:acquire_token).and_return(token)
-        request = {}
-        auth.enhance(request)
-        request['X-MS-Identity-Token'].should == "a/token=="
-      end
-
-    end
-
-  end
-
-  describe Authentication::Anonymous do
-    describe "acting as a hash key" do
-      it "should equal to any instance of the same class" do
-        auth = Authentication::Anonymous.new
-        auth.should == auth
-        auth.should == Authentication::Anonymous.new
-        auth.should_not == Object.new
-      end
-
-      it "should have a constant hash" do
-        auth = Authentication::Anonymous.new
-        auth.hash.should == -1
-      end
-    end
-  end
-
-  describe "setup(auth_data)" do
-    it "should construct a user/password authentication handler given user and password" do
-      authenticator = Authentication.setup(:username => 'me', :password => 'himom')
-      authenticator.should be_instance_of(Authentication::UsernamePassword)
-    end
-
-    it "should construct an anonymous authentication handler given nothing" do
-      authenticator = Authentication.setup(nil)
-      authenticator.should be_instance_of(Authentication::Anonymous)
-    end
-
-    it "should construct an anonymous authentication handler given an empty hash" do
-      authenticator = Authentication.setup({})
-      authenticator.should be_instance_of(Authentication::Anonymous)
-    end
-
-    it "should construct a certificate authentication handler given certificate" do
-      authenticator = Authentication.setup(:certificate => 'foo')
-      authenticator.should be_instance_of(Authentication::Certificate)
-    end
-
-    it "should treat auth_data as auth handler if it's not a hash" do
-      authenticator = Authentication.setup(:foo)
-      authenticator.should == :foo
-    end
-
-    it "should blow up if username is given but password isn't, or vice versa" do
-      proc {
-        Authentication.setup(:username => 'foo')
-      }.should raise_error(ArgumentError, "Auth data specifies username, but no password.")
-
-      proc {
-        authenticator = Authentication.setup(:password => 'foo')
-      }.should raise_error(ArgumentError, "Auth data specifies password, but no username.")
-    end
-
-    it "should blow up if both username/password and certificate are in auth_data hash" do
-      proc {
-        authenticator = Authentication.setup(:username => 'foo', :password => 'bar', :certificate => 'baz')
-      }.should raise_error(ArgumentError, "Cannot determine authentication type from auth data.")
-    end
-
-    it "should blow up if given unknown options in auth data" do
-      proc {
-        authenticator = Authentication.setup(:username => 'foo', :password => 'bar', :something => true, :something_else => true)
-      }.should raise_error(ArgumentError, /^Auth data contains unknown options:/)
-    end
-
-    it "should cache authenticators" do
-      Authentication.instance_variable_get(:@cache).size.should == 0
-
-      anon_auth = Authentication.setup(nil)
-      Authentication.instance_variable_get(:@cache).length.should == 1
-
-      another_anon_auth = Authentication.setup(nil)
-      Authentication.instance_variable_get(:@cache).length.should == 1
-      another_anon_auth.should equal(anon_auth)
-
-      user_auth = Authentication.setup(:username => 'frodo', :password => 'passw0rd')
-      Authentication.instance_variable_get(:@cache).length.should == 2
-      another_user_auth = Authentication.setup(:username => 'frodo', :password => 'passw0rd')
-      Authentication.instance_variable_get(:@cache).length.should == 2
-      another_user_auth.should equal(user_auth)
-    end
-
-    it "should reacquire expired tokens" do
-      old_token = Authentication::Token.new('old/token==', Time.at(1))
-      new_token = Authentication::Token.new('new/token==', Time.at(4))
-
-      Time.stub!(:now).and_return(Time.at(0))
-      old_auth = Authentication.setup(:username => 'frodo', :password => 'passw0rd')
-
-      # old_auth will have to reacquire the token because the one it had initially will be expired
-      old_auth.should_receive(:acquire_token).twice.and_return(old_token, new_token)
-
-      old_auth.authenticate
-      old_auth.token.should equal(old_token)
-
-      Time.stub!(:now).and_return(Time.at(2))
-
-      new_auth = Authentication.setup(:username => 'frodo', :password => 'passw0rd')
-      new_auth.authenticate
-
-      new_auth.should equal(old_auth)
-      new_auth.token.should equal(new_token)
-    end
-
-  end
-
-  describe Authentication::Token do
-    it "should check that value is a well-formed token" do
-      lambda { Authentication::Token.new("foo") }.
-              should raise_error(AuthenticationError,
-                  /^Response from access control service doesn't seem to contain a valid authentication token/)
-    end
-
-    it "should ignore the rest of the body, if there is anything after the token (bug workaround)" do
-      token = Authentication::Token.new('bWyFxQgby0gHyPWZ2LcIXnHgA1J5kALK4iM+QA==<html>....</html>')
-      token.value.should == 'bWyFxQgby0gHyPWZ2LcIXnHgA1J5kALK4iM+QA=='
-    end
-
-  end
-
-end
-

data/spec/unit/dot_net_services/message_buffer_spec.rb

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