dot_net_services 0.0.1

data/spec/integration/TestService/Service/ResourceService.cs

@@ -0,0 +1,58 @@
+namespace DotNetServicesRuby
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ServiceModel;
+    using System.ServiceModel.Channels;
+    
+    [ServiceBehavior(Name = "SyndicationService", Namespace = "http://samples.microsoft.com/ServiceModel/Relay/")]
+    class ResourceService : ResourceContract
+    {
+        class HimomBodyWriter : BodyWriter
+        {
+            string query;
+            string verb;
+            string body;
+
+            public HimomBodyWriter(string theQuery, string theVerb, string theBody) : base(true)
+            {
+                query = theQuery;
+                verb = theVerb;
+                body = theBody;
+            }
+
+            protected override void OnWriteBodyContents(System.Xml.XmlDictionaryWriter writer)
+            {
+                writer.WriteStartElement("body");
+                writer.WriteString("\n");
+                writer.WriteString("Hi, mom\n");
+                writer.WriteString("verb: " + verb + "\n");
+                writer.WriteString("query: " + query + "\n");
+                writer.WriteString("body: " + body + "\n");
+                writer.WriteEndElement();
+            }
+        }
+
+        public Message Process(Message message)
+        {
+            var httpRequest = (HttpRequestMessageProperty)(message.Properties["httpRequest"]);
+            
+            var query = httpRequest.QueryString;
+            var verb = httpRequest.Method;
+            var body = "";
+
+            Message response = Message.CreateMessage(message.Version, "GETRESPONSE", new HimomBodyWriter(query, verb, body));
+
+            HttpResponseMessageProperty responseProperty = new HttpResponseMessageProperty();
+            responseProperty.Headers.Add("Content-Type", "application/xml; charset=utf-8");
+            response.Properties.Add(HttpResponseMessageProperty.Name, responseProperty);
+            return response;
+        }
+
+        public Message ProcessPost(Message message)
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

data/spec/integration/TestService/Service/Service.csproj

@@ -0,0 +1,71 @@
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{27CF1BE6-0280-46F8-BB19-BC7147E02B6A}</ProjectGuid>
+    <OutputType>Exe</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>System.ServiceBus.Samples</RootNamespace>
+    <AssemblyName>Service</AssemblyName>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>2.0</OldToolsVersion>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.ServiceBus, Version=0.12.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Runtime.Serialization, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+    </Reference>
+    <Reference Include="System.ServiceModel, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL" />
+    <Reference Include="System.ServiceModel.Web">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AnonymousResourceService.cs" />
+    <Compile Include="PlainTextService.cs" />
+    <Compile Include="Program.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ResourceContract.cs" />
+    <Compile Include="ResourceService.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="App.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

data/spec/integration/TestService/TestService.sln

@@ -0,0 +1,33 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{F20C1D91-6F22-4047-85D9-423AB58D1C5C}"
+	ProjectSection(SolutionItems) = preProject
+		Readme.htm = Readme.htm
+	EndProjectSection
+	ProjectSection(WebsiteProperties) = preProject
+		Debug.AspNetCompiler.Debug = "True"
+		Release.AspNetCompiler.Debug = "False"
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Service", "Service\Service.csproj", "{27CF1BE6-0280-46F8-BB19-BC7147E02B6A}"
+	ProjectSection(WebsiteProperties) = preProject
+		Debug.AspNetCompiler.Debug = "True"
+		Release.AspNetCompiler.Debug = "False"
+	EndProjectSection
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{27CF1BE6-0280-46F8-BB19-BC7147E02B6A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{27CF1BE6-0280-46F8-BB19-BC7147E02B6A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{27CF1BE6-0280-46F8-BB19-BC7147E02B6A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{27CF1BE6-0280-46F8-BB19-BC7147E02B6A}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

data/spec/integration/end_to_end_spec.rb

@@ -0,0 +1,84 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe "end to end usage scenarios" do
+
+  it "should be able to perform a simple GET from the endpoint" do
+    result = DotNetServices::Session.open(anonymous_test_endpoint) { |s| s.get }
+    result.class.to_s.should == "Net::HTTPOK"
+    result.content_type.should == 'application/xml'
+    result.body.should =~ /^Hi, mom$/
+  end
+
+  it "should pass query string through a GET correctly" do
+    result = DotNetServices::Session.open(anonymous_test_endpoint) { |s| s.get :foo => 'bar' }
+    result.class.to_s.should == "Net::HTTPOK"
+    result.content_type.should == 'application/xml'
+    result.body.should =~ /^query: foo=bar/
+  end
+
+  it "should pass query string with URL escaped characters through a GET correctly" do
+    result = DotNetServices::Session.open(anonymous_test_endpoint) { |s| s.get :foo => 'b+a~r+' }
+    result.class.to_s.should == "Net::HTTPOK"
+    result.content_type.should == 'application/xml'
+    result.body.should =~ /^query: foo=b\+a~r/
+  end
+
+# This scenario doesn't work, known bug in CTP 12
+#  it "should pass a form data through a POST" do
+#    result = DotNetServices::Session.open(test_endpoint) { |s| s.post :foo => 'bar' }
+#    result.class.to_s.should == "Net::HTTPOK"
+#    result.content_type.should == 'application/xml'
+#    result.body.should =~ /^verb: POST$/
+#    result.body.should =~ /^body: foo=bar$/
+#  end
+
+  it "should obtain a security token" do
+    DotNetServices::Session.open(test_endpoint, :username => 'alexeyv', :password => '12345678') do
+      |session|
+      session.authenticator.token.should_not be_nil
+    end
+  end
+
+  it "should be able to do an authenticated GET" do
+    result = DotNetServices::Session.open(test_endpoint, :username => 'alexeyv', :password => '12345678') { |s| s.get }
+    result.class.to_s.should == "Net::HTTPOK"
+    result.body.should =~ /^Hi, mom$/
+    # TODO: once we know how, make sure that service has some idea of who is talking to it 
+  end
+
+  it "should pass a form data through an authenticated POST" do
+    result = DotNetServices::Session.open(test_endpoint, :username => 'alexeyv', :password => '12345678') { |s| s.post :foo => 'bar' }
+    result.class.to_s.should == "Net::HTTPOK"
+    result.content_type.should == 'application/xml'
+    result.body.should =~ /^verb: POST$/
+    result.body.should =~ /^body: foo=bar$/
+  end
+
+  it "plain text GET" do
+    result = DotNetServices::Session.open(plain_text_test_endpoint, :username => 'alexeyv', :password => '12345678') { |s| s.get :foo => 'bar' }
+    result.class.to_s.should == "Net::HTTPOK"
+    result.body.should == "hi mom"
+  end
+
+  it "plain text POST" do
+    result = DotNetServices::Session.open(plain_text_test_endpoint, :username => 'alexeyv', :password => '12345678') { |s| s.post :foo => 'bar' }
+    result.class.to_s.should == "Net::HTTPOK"
+    result.content_type.should == 'text/plain'
+    result.body.should =~ /^verb: POST$/
+    result.body.should =~ /^body: foo=bar$/
+  end
+  
+  it "should detect an invalid user/password situation and blow up correctly"
+
+
+#  it "should not be slow as a turtle with laryngitis walking through molasses in January" do
+#    start = Time.now
+#    10.times { DotNetServices::Session.open(anonymous_test_endpoint) { |s| s.get :foo => 'bar' } }
+#    duration = Time.now - start
+#
+#    if duration > 10
+#      raise "10 simple get requests took #{duration} seconds to perform. This is too long."
+#    end
+#  end
+
+end

data/spec/integration/vmb_spec.rb

@@ -0,0 +1,30 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe "end to end usage scenarios" do
+
+  it "should do end-to-end VMB interaction with itself" do
+    authenticator = DotNetServices::Authentication.setup(:username => 'RubyInterop', :password => '12345678')
+    authenticator.authenticate
+    authenticator.token.should_not be_nil
+
+    create_request = Net::HTTP::CreateMB.new("/services/RubyInterop/MessageBuffer")
+
+    authenticator.enhance(create_request)
+
+    puts
+    p create_request
+    create_request.each { |k, v| puts "#{k}: #{v}"}
+    puts
+    
+    result = Net::HTTP.start(DotNetServices.relay_host) { |http| http.request(create_request) }
+
+    p result
+    puts 
+    result.each { |k, v| puts "#{k}: #{v}"}
+    puts
+    puts result.body
+    puts
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
+require 'spec'
+require 'dot_net_services'
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    DotNetServices::Authentication.clear_cache!
+  end
+end
+
+def test_endpoint
+  DotNetServices.root_url + "/BillBoard/TestService/"
+end
+
+def anonymous_test_endpoint
+  DotNetServices.root_url + "/BillBoard/AnonymousTestService/"
+end
+
+def plain_text_test_endpoint
+  DotNetServices.root_url + "/BillBoard/PlainTextTestService/"
+end

data/spec/unit/dot_net_services/authentication_spec.rb

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