caren-api 0.3.5 → 0.4.0

data/README.rdoc

@@ -6,10 +6,10 @@ This is the reference implementation for the Caren CareProvider API (http://care
 
 To get started you will need a care provider API private/public keypair.
 
-* Generate a private key using: `openssl genrsa -out example 1024`
-* Extract the public key from it: `openssl rsa -in example -pubout -out example.pub`
+* Generate a private key using: pk = Caren::Api.generate_private_key
+* Extract the public key from it: pk.public_key
 * Send the public key to info@caren-cares.com with an access request.
-* Set your care provider url `Caren::Api.url` to the provided URL like https://example.caren-cares.com. 
+* Create an Api session and fill your private key and your care provider url (like https://example.caren-cares.com)
 
 == Getting information from Caren
 

data/VERSION

@@ -1 +1 @@
-0.3.5
+0.4.0

data/caren-api.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{caren-api}
-  s.version = "0.3.5"
+  s.version = "0.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andre Foeken"]
-  s.date = %q{2011-10-20}
+  s.date = %q{2011-10-21}
   s.description = %q{You can use this gem as inspiration of the base of your connections with Caren.}
   s.email = %q{andre.foeken@nedap.com}
   s.extra_rdoc_files = [

data/certs/caren-api.pub

@@ -1,6 +1,8 @@
------BEGIN PUBLIC KEY-----
-MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDll+UxqVoqgd6ZHkw8av/0XYbZ
-RP7JIZ8zNst1kK4SnBV0YZBlxl5j+1tRgjvzSUOxJehp0ikFquZk2dm9i7JHIeXL
-OnfSjN4Hbw/C/d8RXDcmbtF/7RmYs4mVrhQS5eQNR7bDo6NKA1UfDEB0OFIcvhks
-6ev6vuETYzu7Y+DroQIDAQAB
------END PUBLIC KEY-----
+-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEA3sPP1w5IMHMFD2swbNl6LBWBek8QckE9z0MRmIIe4hVTcQcoXRcZ
+bhK3r3l8yFbYjWjxEuWgk1JTdLx5Y+LjP0tbF4C+yTRZr8FmbEBVJ6Gan0AV0rmP
+AGyDY8YrrO3FI9A3L0TP1ZYpIY6Lt33zKXMECgHWpXmiQcvRPR2rXRrVZzC5m1zk
+/fZR+XGQyJ+vcO8MaTRUKs4l28Ih/hGXXGUgT4IYMdF+CIaoympBs8iMcchY4Idn
+DFdtNgG328QZUouHAa/kp46SC1Xo2DtwNNrJxsbQQyeABNCopGmsBJMmwQPfsV4I
+CH1U0hkEzBF2LsWJKRk1scTtVYiB8Kcu4QIDAQAB
+-----END RSA PUBLIC KEY-----

data/init.rb

@@ -1,4 +1 @@
-require "lib/caren.rb"
-
-Caren::Api.url = "https://www.carenzorgt.nl"
-Caren::Api.caren_public_key = Caren::Api.key_from_path("certs/caren-api.pub")
+require "lib/caren.rb"

data/lib/caren/base.rb

@@ -64,7 +64,7 @@ class Caren::Base
   
   # The absolute (constructed url) to the resource.
   def self.resource_url id=nil
-    "#{Caren::Api.url}#{self.resource_location}#{id}"
+    "#{self.resource_location}#{id}"
   end
   
   def self.search_url key, value

data/lib/caren/care_provider.rb

@@ -25,20 +25,20 @@ class Caren::CareProvider < Caren::Base
     ]
   end
     
-  def self.search key, value
-    from_xml Caren::Api.get( self.search_url(key,value) )
+  def self.search key, value, session
+    from_xml session.get( self.search_url(key,value) )
   end
   
-  def self.all
-    from_xml Caren::Api.get(self.resource_url)
+  def self.all session
+    from_xml session.get(self.resource_url)
   end
   
-  def update
-    Caren::Api.put(self.resource_url(self.id), self.to_xml)
+  def update session
+    session.put(self.resource_url(self.id), self.to_xml)
   end
   
-  def update_logo logo_hash_or_path
-    Caren::Api.put(self.resource_url(self.id), self.to_logo_xml(logo_hash_or_path))
+  def update_logo logo_hash_or_path, session
+    session.put(self.resource_url(self.id), self.to_logo_xml(logo_hash_or_path))
   end
     
   def as_xml

data/lib/caren/caren.rb

@@ -20,74 +20,74 @@ module Caren
 
   class Api
     
-    def self.url= url
-      Thread.current[:url] = url
-    end
-    
-    def self.url
-      Thread.current[:url]
+    class << self
+      attr_accessor :session
     end
         
-    def self.caren_public_key= key
-      Thread.current[:caren_public_key] = key
-    end
-    
-    # The public key file used to verify request coming from Caren
-    def self.caren_public_key
-      Thread.current[:caren_public_key]
-    end
-
-    def self.private_key= key
-      Thread.current[:private_key] = key
-    end
+    attr_accessor :url, :caren_public_key, :private_key
     
-    # The private key file used to sign requests coming from you
-    def self.private_key
-      Thread.current[:private_key]
+    # Initialize new API session. Specify your private key to sign outgoing messages and your care provider url.
+    # Optionally you can pass the caren public key used to verify incoming requests.
+    def initialize private_key, url, caren_public_key=nil
+      self.url = url
+      self.private_key = private_key
+      self.caren_public_key = caren_public_key || Caren::Api.key_from_path("certs/caren-api.pub")
     end
     
+    # Create key from string
     def self.key_from_string string
       OpenSSL::PKey::RSA.new(string)
     end
     
+    # Read a file and create key from string
     def self.key_from_path path
       self.key_from_string( File.read(path) )
     end
     
-    def self.generate_private_key
-      OpenSSL::PKey::RSA.generate( 1024 )
+    # Generate a new private key
+    def self.generate_private_key size=2048
+      OpenSSL::PKey::RSA.generate( size )
     end
     
-    def self.put url, xml
+    # URL from path using session base url
+    def url_for path
+      "#{self.url}#{path}"
+    end
+    
+    def put path, xml
       begin
-        response = RestClient.put url, xml, :content_type => :xml, :accept => :xml, :signature => Caren::Api.sign(xml)
+        timestamp = DateTime.now.to_i
+        response = RestClient.put url_for(path), xml, :content_type => :xml, :accept => :xml, :timestamp => timestamp, :signature => sign(timestamp,xml)
         return check_signature(response)
       rescue RestClient::Exception => e
         handle_error(e.response)
       end
     end
     
-    def self.post url, xml
+    def post path, xml
       begin
-        response = RestClient.post url, xml, :content_type => :xml, :accept => :xml, :signature => Caren::Api.sign(xml)
+        timestamp = DateTime.now.to_i
+        response = RestClient.post url_for(path), xml, :content_type => :xml, :accept => :xml, :timestamp => timestamp, :signature => sign(timestamp,xml)
         return check_signature(response)
       rescue RestClient::Exception => e
         handle_error(e.response)
       end
     end
     
-    def self.delete url
+    def delete path
       begin
-        response = RestClient.delete url, :content_type => :xml, :accept => :xml, :signature => Caren::Api.sign
+        timestamp = DateTime.now.to_i
+        response = RestClient.delete url_for(path), :content_type => :xml, :accept => :xml, :timestamp => timestamp, :signature => sign(timestamp)
         return check_signature(response)
       rescue RestClient::Exception => e
         handle_error(e.response)
       end
     end
     
-    def self.get url
+    def get path
       begin
-        response = RestClient.get url, :content_type => :xml, :accept => :xml, :signature => Caren::Api.sign
+        timestamp = DateTime.now.to_i
+        response = RestClient.get url_for(path), :content_type => :xml, :accept => :xml, :timestamp => timestamp, :signature => sign(timestamp)
         return check_signature(response)
       rescue RestClient::Exception => e
         handle_error(e.response)
@@ -103,11 +103,11 @@ module Caren
     end
     
     # Pass an XML string to be handled. Only a valid caren_objects xml hash will be parsed.
-    def self.incoming xml, signature
+    def incoming xml, signature
       if self.verify_signature(signature,xml)
         objects = []
         hash = Hash.from_xml(xml)["caren_objects"]
-        self.supported_incoming_objects.each do |key,klass|
+        Caren::Api.supported_incoming_objects.each do |key,klass|
           objects << (hash[key]||hash[key.to_s]||[]).map{ |h| klass.new(h) }
         end
         return objects.flatten
@@ -116,29 +116,30 @@ module Caren
       end
     end
     
-    # Sign your string using Caren::Api.private_key
-    def self.sign string=""
-      encrypted_digest = Caren::Api.private_key.sign( "sha1", string )
+    # Sign your string and timestamp using private key
+    # Timestamp is UNIX timestamp seconds since 1970
+    def sign timestamp, string=nil
+      encrypted_digest = self.private_key.sign( "sha1", string.to_s + timestamp.to_s )
       signature = CGI.escape(Base64.encode64(encrypted_digest))
       return signature
     end
         
-    private
-        
     # Check the signature of the response from rest-client
-    def self.check_signature response
-      return response if self.verify_signature( response.headers[:signature], response )
+    def check_signature response
+      return response if self.verify_signature( response.headers[:signature], response.headers[:timestamp], response )
       raise Caren::Exceptions::SignatureMismatch.new
     end
     
-    # Verify the signature using the caren public key file
-    def self.verify_signature signature, string=""
+    # Verify the signature using the caren public key
+    def verify_signature signature, timestamp, string=nil
       signature = Base64.decode64(CGI.unescape(signature))
-      Caren::Api.caren_public_key.verify( "sha1", signature, string )
+      self.caren_public_key.verify( "sha1", signature, string.to_s + timestamp.to_s )
     end
-    
+        
+    private
+                
     # Raise a Caren exception on errors
-    def self.handle_error response
+    def handle_error response
       errors = []
       doc = REXML::Document.new(response)
       doc.elements.each('errors/error') do |error|

data/lib/caren/external_message.rb

@@ -11,13 +11,13 @@ class Caren::ExternalMessage < Caren::Base
       :subject_id           # Integer (Caren person id)
     ]
   end
-  
-  def create
-    Caren::Api.post self.class.resource_url(self.subject_id), self.to_xml
+        
+  def create session
+    session.post self.class.resource_url(self.subject_id), self.to_xml
   end
   
-  def delete
-    Caren::Api.delete self.class.resource_url(self.subject_id,self.id)
+  def delete session
+    session.delete self.class.resource_url(self.subject_id,self.id)
   end
   
   def self.array_root
@@ -47,7 +47,7 @@ class Caren::ExternalMessage < Caren::Base
   end
   
   def self.resource_url subject_id, id=nil
-    "#{Caren::Api.url}#{self.resource_location % subject_id}#{id}"
+    "#{self.resource_location % subject_id}#{id}"
   end
     
 end

data/lib/caren/link.rb

@@ -11,18 +11,18 @@ class Caren::Link < Caren::Base
     ]
   end
   
-  def self.search key, value
-    from_xml Caren::Api.get( self.search_url(key,value) )
+  def self.search key, value, session
+    from_xml session.get( self.search_url(key,value) )
   end
   
-  def self.all
-    from_xml Caren::Api.get(self.resource_url)
+  def self.all session
+    from_xml session.get(self.resource_url)
   end
   
   # Request to create a new link. Example:
   # Caren::Link.new( :patient_number => 1234 ).create
-  def create
-    Caren::Api.post(self.resource_url, self.to_xml)
+  def create session
+    session.post(self.resource_url, self.to_xml)
   end
 
   def as_xml

data/spec/care_provider_spec.rb

@@ -72,33 +72,35 @@ describe "CareProvider", "REST methods" do
   before do
     care_providers = File.read("spec/fixtures/caren_care_providers.xml")
     care_providers_search = File.read("spec/fixtures/caren_care_providers_search.xml")
-    FakeWeb.register_uri(:put, Caren::CareProvider.resource_url(1), :signature => Caren::Api.sign )
     
-    FakeWeb.register_uri(:get, Caren::CareProvider.resource_url, :body => care_providers, 
-                                                                 :signature => Caren::Api.sign(care_providers) )
-                                                             
-    FakeWeb.register_uri(:get, "#{Caren::CareProvider.resource_url}?key=url-shortcut&value=pantein", 
-                                                                 :body => care_providers_search, 
-                                                                 :signature => Caren::Api.sign(care_providers_search) )
+    care_provider_url = Caren::Api.session.url_for( Caren::CareProvider.resource_url(1) )    
+    care_providers_url = Caren::Api.session.url_for( Caren::CareProvider.resource_url )
+    search_url = Caren::Api.session.url_for( "#{Caren::CareProvider.resource_url}?key=url-shortcut&value=pantein" )
+    
+    timestamp = DateTime.now.to_i
+    
+    FakeWeb.register_uri(:put, care_provider_url, :timestamp => timestamp, :signature => Caren::Api.session.sign(timestamp) )    
+    FakeWeb.register_uri(:get, care_providers_url, :body => care_providers, :timestamp => timestamp, :signature => Caren::Api.session.sign(timestamp,care_providers) )                                                             
+    FakeWeb.register_uri(:get, search_url, :body => care_providers_search, :timestamp => timestamp, :signature => Caren::Api.session.sign(timestamp,care_providers_search) )
   end
   
   it "should be able to update a care provider" do
-    lambda{ Caren::CareProvider.new( :id => 1, :name => "Test" ).update }.should_not raise_error
+    lambda{ Caren::CareProvider.new( :id => 1, :name => "Test" ).update( Caren::Api.session ) }.should_not raise_error
   end
   
   it "should be able to update the logo for a care provider" do
-    lambda{ Caren::CareProvider.new( :id => 1 ).update_logo( "spec/fixtures/bacon.jpg" ) }.should_not raise_error
+    lambda{ Caren::CareProvider.new( :id => 1 ).update_logo( "spec/fixtures/bacon.jpg", Caren::Api.session ) }.should_not raise_error
   end
   
   it "should be able to search for a specific care provider" do
-    care_providers = Caren::CareProvider.search :url_shortcut, "pantein"
+    care_providers = Caren::CareProvider.search :url_shortcut, "pantein", Caren::Api.session
     care_providers.should have(1).things
     care_providers.first.name.should == "Pantein"
     care_providers.first.url_shortcut.should == "pantein"
   end
   
   it "should be able to find all care providers" do
-    care_providers = Caren::CareProvider.all
+    care_providers = Caren::CareProvider.all Caren::Api.session
     care_providers.should have(2).things
     care_providers.first.name.should == "Demo"
     care_providers.first.url_shortcut.should == "demo"

data/spec/caren_spec.rb

@@ -3,54 +3,54 @@ require 'spec_helper'
 describe "Caren", "signature checks" do
   
   before do
-    @incorrect_url = "#{Caren::Api.url}/test_with_incorrect_signature"
-    @correct_url   = "#{Caren::Api.url}/test_with_correct_signature"
-    @error_url     = "#{Caren::Api.url}/test_with_errors"
+    @incorrect_url = "/test_with_incorrect_signature"
+    @correct_url   = "/test_with_correct_signature"
+    @error_url     = "/test_with_errors"
     
-    FakeWeb.register_uri(:get, @incorrect_url, :body => "TEST", :signature => "[INCORRECT]" )
-    FakeWeb.register_uri(:post, @incorrect_url, :body => "TEST", :signature => "[INCORRECT]" )
-    FakeWeb.register_uri(:put, @incorrect_url, :body => "TEST", :signature => "[INCORRECT]" )
-    FakeWeb.register_uri(:delete, @incorrect_url, :body => "TEST", :signature => "[INCORRECT]" )
+    FakeWeb.register_uri(:get, Caren::Api.session.url_for(@incorrect_url), :body => "TEST", :signature => "[INCORRECT]" )
+    FakeWeb.register_uri(:post, Caren::Api.session.url_for(@incorrect_url), :body => "TEST", :signature => "[INCORRECT]" )
+    FakeWeb.register_uri(:put, Caren::Api.session.url_for(@incorrect_url), :body => "TEST", :signature => "[INCORRECT]" )
+    FakeWeb.register_uri(:delete, Caren::Api.session.url_for(@incorrect_url), :body => "TEST", :signature => "[INCORRECT]" )
     
-    FakeWeb.register_uri(:get, @correct_url, :body => "TEST", :signature => Caren::Api.sign("TEST") )
-    FakeWeb.register_uri(:post, @correct_url, :body => "TEST", :signature => Caren::Api.sign("TEST") )
-    FakeWeb.register_uri(:put, @correct_url, :body => "TEST", :signature => Caren::Api.sign("TEST") )
-    FakeWeb.register_uri(:delete, @correct_url, :body => "TEST", :signature => Caren::Api.sign("TEST") )
+    FakeWeb.register_uri(:get, Caren::Api.session.url_for(@correct_url), :body => "TEST", :signature => Caren::Api.session.sign("TEST") )
+    FakeWeb.register_uri(:post, Caren::Api.session.url_for(@correct_url), :body => "TEST", :signature => Caren::Api.session.sign("TEST") )
+    FakeWeb.register_uri(:put, Caren::Api.session.url_for(@correct_url), :body => "TEST", :signature => Caren::Api.session.sign("TEST") )
+    FakeWeb.register_uri(:delete, Caren::Api.session.url_for(@correct_url), :body => "TEST", :signature => Caren::Api.session.sign("TEST") )
     
     errors = File.read "spec/fixtures/caren_care_provider_validation.xml"
     unauth = File.read "spec/fixtures/caren_unauthorized.xml"  
-    FakeWeb.register_uri(:get, @error_url, :status => 406, :body => errors, :signature => Caren::Api.sign(errors) )
-    FakeWeb.register_uri(:post, @error_url, :status => 406, :body => errors, :signature => Caren::Api.sign(errors) )
-    FakeWeb.register_uri(:put, @error_url, :status => 406, :body => errors, :signature => Caren::Api.sign(errors) )
-    FakeWeb.register_uri(:delete, @error_url, :status => 403, :body => unauth, :signature => Caren::Api.sign(unauth) )
+    FakeWeb.register_uri(:get, Caren::Api.session.url_for(@error_url), :status => 406, :body => errors, :signature => Caren::Api.session.sign(errors) )
+    FakeWeb.register_uri(:post, Caren::Api.session.url_for(@error_url), :status => 406, :body => errors, :signature => Caren::Api.session.sign(errors) )
+    FakeWeb.register_uri(:put, Caren::Api.session.url_for(@error_url), :status => 406, :body => errors, :signature => Caren::Api.session.sign(errors) )
+    FakeWeb.register_uri(:delete, Caren::Api.session.url_for(@error_url), :status => 403, :body => unauth, :signature => Caren::Api.session.sign(unauth) )
   end
     
   it "should not accept result swith an incorrect signature" do
-    lambda{ Caren::Api.get @incorrect_url }.should raise_error
-    lambda{ Caren::Api.post @incorrect_url, "" }.should raise_error
-    lambda{ Caren::Api.put @incorrect_url, "" }.should raise_error
-    lambda{ Caren::Api.delete @incorrect_url }.should raise_error
+    lambda{ Caren::Api.session.get @incorrect_url }.should raise_error
+    lambda{ Caren::Api.session.post @incorrect_url, "" }.should raise_error
+    lambda{ Caren::Api.session.put @incorrect_url, "" }.should raise_error
+    lambda{ Caren::Api.session.delete @incorrect_url }.should raise_error
   end
   
   it "should accept results with a correct signature" do
-    lambda{ Caren::Api.get @correct_url }.should_not raise_error
-    lambda{ Caren::Api.post @correct_url, "" }.should_not raise_error
-    lambda{ Caren::Api.put @correct_url, "" }.should_not raise_error
-    lambda{ Caren::Api.delete @correct_url }.should_not raise_error
+    lambda{ Caren::Api.session.get @correct_url }.should_not raise_error
+    lambda{ Caren::Api.session.post @correct_url, "" }.should_not raise_error
+    lambda{ Caren::Api.session.put @correct_url, "" }.should_not raise_error
+    lambda{ Caren::Api.session.delete @correct_url }.should_not raise_error
   end
   
   it "should be able to handle server side errors" do
     
-    lambda{ Caren::Api.get @error_url }.should raise_error(Caren::Exceptions::ServerSideError)
-    lambda{ Caren::Api.put @error_url, "" }.should raise_error(Caren::Exceptions::ServerSideError)
-    lambda{ Caren::Api.post @error_url, "" }.should raise_error(Caren::Exceptions::ServerSideError)
-    lambda{ Caren::Api.delete @error_url }.should raise_error(Caren::Exceptions::ServerSideError)
+    lambda{ Caren::Api.session.get @error_url }.should raise_error(Caren::Exceptions::ServerSideError)
+    lambda{ Caren::Api.session.put @error_url, "" }.should raise_error(Caren::Exceptions::ServerSideError)
+    lambda{ Caren::Api.session.post @error_url, "" }.should raise_error(Caren::Exceptions::ServerSideError)
+    lambda{ Caren::Api.session.delete @error_url }.should raise_error(Caren::Exceptions::ServerSideError)
       
   end
   
   it "should be able to handle authorization errors" do
     begin
-      Caren::Api.delete @error_url
+      Caren::Api.session.delete @error_url
     rescue Caren::Exceptions::ServerSideError => e
       e.errors.should have(1).things
       e.errors.first.class.should == Caren::Error
@@ -61,7 +61,7 @@ describe "Caren", "signature checks" do
   
   it "should be able to handle validation errors" do
     begin
-      Caren::Api.get @error_url
+      Caren::Api.session.get @error_url
     rescue Caren::Exceptions::ServerSideError => e
       e.errors.should have(1).things
       e.errors.first.class.should == Caren::ValidationError
@@ -73,7 +73,7 @@ describe "Caren", "signature checks" do
   
   it "should be able to handle incoming xml from caren" do
     incoming = File.read "spec/fixtures/incoming.xml"
-    results  = Caren::Api.incoming(incoming, Caren::Api.sign(incoming))
+    results  = Caren::Api.session.incoming(incoming, Caren::Api.session.sign(incoming))
     results.should have(4).things    
     external_messages = results.select{ |x| x.is_a?(Caren::ExternalMessage) }
     external_messages.first.id.should == 1    

data/spec/external_message_spec.rb

@@ -29,8 +29,12 @@ end
 describe "ExternalMessage", "REST methods" do
   
   before do
-    FakeWeb.register_uri(:post, Caren::ExternalMessage.resource_url(1), :status => 201, :signature => Caren::Api.sign )
-    FakeWeb.register_uri(:delete, Caren::ExternalMessage.resource_url(1,1), :signature => Caren::Api.sign )
+    post_url = Caren::Api.session.url_for( Caren::ExternalMessage.resource_url(1) )
+    delete_url = Caren::Api.session.url_for( Caren::ExternalMessage.resource_url(1,1) )    
+    timestamp = DateTime.now.to_i
+    
+    FakeWeb.register_uri(:post, post_url, :status => 201, :signature => Caren::Api.session.sign(timestamp), :timestamp => timestamp )
+    FakeWeb.register_uri(:delete, delete_url, :signature => Caren::Api.session.sign(timestamp), :timestamp => timestamp )
   end
   
   it "should be able to create an external message" do
@@ -38,11 +42,11 @@ describe "ExternalMessage", "REST methods" do
                                         :external_person_id => 1, 
                                         :body => "Test message", 
                                         :external_id => 1, 
-                                        :subject_id => 1 ).create }.should_not raise_error
+                                        :subject_id => 1 ).create(Caren::Api.session) }.should_not raise_error
   end
   
   it "should be able to delete an external message" do
-    lambda{ Caren::ExternalMessage.new( :subject_id => 1, :id => 1 ).delete }.should_not raise_error
+    lambda{ Caren::ExternalMessage.new( :subject_id => 1, :id => 1 ).delete(Caren::Api.session) }.should_not raise_error
   end
   
 end

data/spec/link_spec.rb

@@ -22,17 +22,23 @@ describe "Link", "REST methods" do
   before do
     links  = File.read("spec/fixtures/caren_links.xml")
     search = File.read("spec/fixtures/caren_links_search.xml")
-    FakeWeb.register_uri(:get, Caren::Link.resource_url, :body => links, :signature => Caren::Api.sign(links) )
-    FakeWeb.register_uri(:get, "#{Caren::Link.resource_url}?key=external-id&value=1", :body => search, :signature => Caren::Api.sign(search) )
-    FakeWeb.register_uri(:post, Caren::Link.resource_url, :status => 201, :signature => Caren::Api.sign )
+    
+    links_url  = Caren::Api.session.url_for(Caren::Link.resource_url)
+    search_url = Caren::Api.session.url_for("#{Caren::Link.resource_url}?key=external-id&value=1")
+    
+    timestamp = DateTime.now.to_i
+    
+    FakeWeb.register_uri(:get, links_url, :body => links, :timestamp => timestamp, :signature => Caren::Api.session.sign(timestamp,links) )
+    FakeWeb.register_uri(:get, search_url, :body => search, :timestamp => timestamp, :signature => Caren::Api.session.sign(timestamp,search) )
+    FakeWeb.register_uri(:post, links_url, :status => 201, :timestamp => timestamp, :signature => Caren::Api.session.sign(timestamp) )
   end
   
   it "should be able to create a new link using the API" do
-    lambda{ Caren::Link.new( :patient_number => "12345" ).create }.should_not raise_error
+    lambda{ Caren::Link.new( :patient_number => "12345" ).create(Caren::Api.session) }.should_not raise_error
   end
   
   it "should be find all links using the API" do
-    links = Caren::Link.all
+    links = Caren::Link.all(Caren::Api.session)
     links.should have(3).things
     links.first.id.should == 1
     links.first.status.should == "confirmed"
@@ -42,7 +48,7 @@ describe "Link", "REST methods" do
   end
   
   it "should be find a specific link using the API" do
-    links = Caren::Link.search(:external_id, 1)
+    links = Caren::Link.search(:external_id, 1, Caren::Api.session)
     links.should have(1).thing
   end
   

data/spec/spec_helper.rb

@@ -5,11 +5,9 @@ require 'fakeweb'
 require 'capybara'
 
 # For the tests we need to know both the public and private key, so we share them here.
-new_private_key = Caren::Api.generate_private_key
-
-Caren::Api.caren_public_key = new_private_key.public_key
-Caren::Api.private_key = new_private_key
-Caren::Api.url = "http://example.com"
+# We also use a smaller key here, to make the tests faster.
+new_private_key = Caren::Api.generate_private_key( 512 )
+Caren::Api.session = Caren::Api.new( new_private_key, "http://example.com", new_private_key.public_key )
 
 FakeWeb.allow_net_connect = false
 

metadata

@@ -4,10 +4,10 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 5
+  - 4
+  - 0
   segments_generated: true
-  version: 0.3.5
+  version: 0.4.0
 platform: ruby
 authors: 
 - Andre Foeken
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-20 00:00:00 +02:00
+date: 2011-10-21 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency