fleakr 0.5.2 → 0.6.0

data/lib/fleakr/api/upload_request.rb

@@ -39,7 +39,7 @@ module Fleakr
         @options = options
         
         @parameters = ParameterList.new(upload_options)
-        @parameters << FileParameter.new('photo', filename)
+        parameters.add_upload_option(:photo, filename)
       end
       
       # A list of upload options for this upload request (see Fleakr::Api::Option)

data/lib/fleakr/api/value_parameter.rb

@@ -5,15 +5,15 @@ module Fleakr
     #
     # A simple name / value parameter for use in API calls
     #
-    class ValueParameter < Parameter
+    class ValueParameter
       
-      attr_reader :value
+      attr_reader :name, :value
      
       # Create a new parameter with the specified name / value pair.
       #
       def initialize(name, value, include_in_signature = true)
+        @name  = name
         @value = value
-        super(name, include_in_signature)
       end
       
       # Generate the query string representation of this parameter.

data/lib/fleakr/objects/authentication_token.rb

@@ -54,6 +54,10 @@ module Fleakr
         self.new(response.body)
       end
       
+      def user
+        User.find_by_id(user_id)
+      end
+      
     end
     
   end

data/lib/fleakr/objects/set.rb

@@ -24,8 +24,13 @@ module Fleakr
       flickr_attribute :id, :title, :description
       flickr_attribute :primary_photo_id, :from => '@primary'
       flickr_attribute :count, :from => '@photos'
+      flickr_attribute :user_id, :from => '@owner'
 
       find_all :by_user_id, :call => 'photosets.getList', :path => 'photosets/photoset'
+      
+      find_one :by_id, :using => :photoset_id, :call => 'photosets.getInfo', :path => 'photoset'
+
+      lazily_load :user_id, :with => :load_info
 
       # Save all photos in this set to the specified directory for the specified size.  Allowed
       # Sizes include <tt>:square</tt>, <tt>:small</tt>, <tt>:thumbnail</tt>, <tt>:medium</tt>,  
@@ -46,10 +51,29 @@ module Fleakr
         sprintf("%0#{self.count.length}d_", (index + 1))
       end
 
+      # Primary photo for this set. See Fleakr::Objects::Photo for more details.
+      #
       def primary_photo
         @primary_photo ||= Photo.find_by_id(primary_photo_id)
       end
       
+      # The URL for this set.
+      #
+      def url
+        "http://www.flickr.com/photos/#{user_id}/sets/#{id}/"
+      end
+      
+      # The user who created this set.
+      #
+      def user
+        User.find_by_id(user_id)
+      end
+   
+      def load_info # :nodoc:
+        response = Fleakr::Api::MethodRequest.with_response!('photosets.getInfo', :photoset_id => self.id)
+        self.populate_from(response.body)
+      end
+      
     end
   end
 end

data/lib/fleakr/support.rb

@@ -1,2 +1,3 @@
 require 'fleakr/support/attribute'
-require 'fleakr/support/object'
+require 'fleakr/support/object'
+require 'fleakr/support/request'

data/lib/fleakr/support/object.rb

@@ -26,7 +26,7 @@ module Fleakr
 
             class_eval <<-CODE
               def #{attribute}
-                @#{attribute} ||= #{target}.send("find_all_by_#{finder_attribute}".to_sym, self.id)
+                @#{attribute} ||= #{target}.send("find_all_by_#{finder_attribute}".to_sym, self.id, self.authentication_options)
               end
             CODE
           end
@@ -41,7 +41,7 @@ module Fleakr
               options.merge!(:#{attribute} => value)
               
               response = Fleakr::Api::MethodRequest.with_response!('#{options[:call]}', options)
-              (response.body/'rsp/#{options[:path]}').map {|e| #{target_class}.new(e) }
+              (response.body/'rsp/#{options[:path]}').map {|e| #{target_class}.new(e, options) }
             end
           CODE
         end
@@ -54,7 +54,7 @@ module Fleakr
               options.merge!(:#{attribute} => value)
               
               response = Fleakr::Api::MethodRequest.with_response!('#{options[:call]}', options)
-              #{self.name}.new(response.body)
+              #{self.name}.new(response.body, options)
             end
           CODE
         end
@@ -64,7 +64,10 @@ module Fleakr
 
           class_eval <<-CODE
             def search(*parameters)
-              parameters << {:#{key} => self.id}
+              options = {:#{key} => self.id}
+              options.merge!(self.authentication_options)
+              
+              parameters << options
               Fleakr::Objects::Search.new(*parameters).results
             end
           CODE
@@ -88,10 +91,11 @@ module Fleakr
     
       module InstanceMethods
       
-        attr_reader :document
+        attr_reader :document, :authentication_options
       
-        def initialize(document = nil)
+        def initialize(document = nil, options = {})
           self.populate_from(document) unless document.nil?
+          @authentication_options = options.extract!(:auth_token)
         end
       
         def populate_from(document)

data/lib/fleakr/support/request.rb

@@ -0,0 +1,23 @@
+module Fleakr
+  module Support # :nodoc:all
+    module Request
+   
+      attr_reader :parameters
+
+      def initialize(additional_parameters = {})
+        authenticate = additional_parameters.delete(:authenticate?)
+        authenticate = authenticate.nil? ? true : authenticate
+        
+        @parameters = Fleakr::Api::ParameterList.new(additional_parameters, authenticate)
+      end
+
+      def endpoint_uri
+        uri = URI.parse(endpoint_url)
+        uri.query = self.parameters.to_query
+        uri
+      end
+
+      
+    end
+  end
+end

data/lib/fleakr/version.rb

@@ -2,8 +2,8 @@ module Fleakr
   module Version # :nodoc:
     
     MAJOR = 0
-    MINOR = 5
-    TINY  = 2
+    MINOR = 6
+    TINY  = 0
     
     def self.to_s
       [MAJOR, MINOR, TINY].join('.')

data/test/fixtures/photosets.getInfo.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<rsp stat="ok">
+<photoset id="72157622660138146" owner="43955217@N05" primary="4042405768" secret="05ef8f3baf" server="3525" farm="4" photos="2">
+	<title>My First Set!</title>
+	<description>This is a description</description>
+</photoset>
+</rsp>

data/test/test_helper.rb

@@ -59,7 +59,7 @@ class Test::Unit::TestCase
         object = this_klass.new
         object.stubs(:id).with().returns('1')
 
-        target_klass.expects("find_all_by_#{finder_attribute}".to_sym).with('1').returns(results)
+        target_klass.expects("find_all_by_#{finder_attribute}".to_sym).with('1', {}).returns(results)
         object.send(attribute).should == results
       end
       
@@ -87,7 +87,7 @@ class Test::Unit::TestCase
       stub = stub()
       response = mock_request_cycle :for => options[:call], :with => params
 
-      klass.expects(:new).with(response.body).returns(stub)
+      klass.expects(:new).with(response.body, params).returns(stub)
       klass.send("find_by_#{options[:by]}".to_sym, condition_value).should == stub
     end
   end
@@ -111,7 +111,7 @@ class Test::Unit::TestCase
         stub = stub()
         stubs << stub
         
-        klass.expects(:new).with(element).returns(stub)
+        klass.expects(:new).with(element, finder_options).returns(stub)
       end
       
       klass.send("find_all_by_#{options[:by]}".to_sym, condition_value).should == stubs

data/test/unit/fleakr/api/authentication_request_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../../test_helper'
+
+module Fleakr::Api
+  class AuthenticationRequestTest < Test::Unit::TestCase
+    
+    context "An instance of AuthenticationRequest" do
+      
+      should "know the endpoint URL" do
+        request = AuthenticationRequest.new
+        request.endpoint_url.should == 'http://flickr.com/services/auth/'
+      end
+      
+      should "be able to make a request" do
+        endpoint_uri = stub()
+        
+        request = AuthenticationRequest.new
+        request.stubs(:endpoint_uri).with().returns(endpoint_uri)
+      
+        Net::HTTP.expects(:get_response).with(endpoint_uri).returns('response')
+      
+        request.response.should == 'response'
+      end
+      
+      should "know the authorization_url for the authentication request" do
+        response_headers = {'Location' => 'http://example.com/auth'}
+        response = stub() {|r| r.stubs(:header).with().returns(response_headers) }
+        
+        request = AuthenticationRequest.new
+        request.stubs(:response).with().returns(response)
+        
+        request.authorization_url.should == 'http://example.com/auth'
+      end
+      
+    end
+    
+  end
+end

data/test/unit/fleakr/api/file_parameter_test.rb

@@ -14,11 +14,6 @@ module Fleakr::Api
         FileUtils.rm_rf(@temp_dir)
       end
       
-      should "know not to include itself in the parameter signature" do
-        parameter = FileParameter.new('photo', @filename)
-        parameter.include_in_signature?.should be(false)
-      end
-      
       {'jpg' => 'image/jpeg', 'png' => 'image/png', 'gif' => 'image/gif'}.each do |ext, mime_type|
         should "know the correct MIME type for an extension of #{ext}" do
           parameter = FileParameter.new('photo', "#{@temp_dir}/image.#{ext}")

data/test/unit/fleakr/api/method_request_test.rb

@@ -3,92 +3,74 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Fleakr::Api
   class MethodRequestTest < Test::Unit::TestCase
 
-    context "An instance of MethodRequest" do
-
-      context "with API credentials" do
-
-        setup do
-          @api_key = 'f00b4r'
-          Fleakr.stubs(:api_key).with().returns(@api_key)
-          Fleakr.stubs(:shared_secret).with().returns('sekrit')
-        end
-
-        should "know the full query parameters" do
-          request = MethodRequest.new('flickr.people.findByUsername', :username => 'foobar')
-
-          request.parameters[:api_key].value.should  == @api_key
-          request.parameters[:method].value.should   == 'flickr.people.findByUsername'
-          request.parameters[:username].value.should == 'foobar'
-        end
-        
-        should "translate a shorthand API call" do
-          request = MethodRequest.new('people.findByUsername')
-          request.parameters[:method].value.should == 'flickr.people.findByUsername'
-        end
-        
-        should "know the endpoint with full parameters" do
-          query_parameters = 'foo=bar'
-        
-          request = MethodRequest.new('people.getInfo')
-          request.parameters.stubs(:to_query).returns(query_parameters)
-        
-          uri_mock = mock()
-          uri_mock.expects(:query=).with(query_parameters)
-          URI.expects(:parse).with("http://api.flickr.com/services/rest/").returns(uri_mock)
-        
-          request.__send__(:endpoint_uri).should == uri_mock
-        end
-        
-        should "be able to make a request" do
-          endpoint_uri = stub()
-          
-          request = MethodRequest.new('people.findByUsername')
-          request.stubs(:endpoint_uri).with().returns(endpoint_uri)
-        
-          Net::HTTP.expects(:get).with(endpoint_uri).returns('<xml>')
-        
-          request.send
-        end
-        
-        should "create a response from the request" do
-          response_xml  = '<xml>'
-          response_stub = stub()
-        
-          Net::HTTP.stubs(:get).returns(response_xml)
-          Response.expects(:new).with(response_xml).returns(response_stub)
-          
-          request = MethodRequest.new('people.findByUsername')
-          request.stubs(:endpoint_uri)
-        
-          request.send.should == response_stub
-        end
-        
-        should "be able to make a full request and response cycle" do
-          method = 'flickr.people.findByUsername'
-          params = {:username => 'foobar'}
-
-          response = stub(:error? => false)
-          
-          MethodRequest.expects(:new).with(method, params).returns(stub(:send => response))
-          
-          MethodRequest.with_response!(method, params).should == response
-        end
-        
-        should "raise an exception when the full request / response cycle has errors" do
-          method = 'flickr.people.findByUsername'
-          params = {:username => 'foobar'}
-          
-          response = stub(:error? => true, :error => stub(:code => '1', :message => 'User not found'))
-          
-          MethodRequest.expects(:new).with(method, params).returns(stub(:send => response))
-          
-          lambda do
-            MethodRequest.with_response!('flickr.people.findByUsername', :username => 'foobar')
-          end.should raise_error(Fleakr::ApiError)
-        end
-        
+    context "An instance of the MethodRequest class" do
+
+      should "know the endpoint URL" do
+        request = MethodRequest.new('people.findByUsername')
+        request.endpoint_url.should == 'http://api.flickr.com/services/rest/'
+      end
+
+      should "add the method name to the list of parameters" do
+        parameter_list = mock() {|p| p.expects(:add_option).with(:method, 'flickr.people.findByUsername') }
+        MethodRequest.any_instance.stubs(:parameters).with().returns(parameter_list)
+
+        MethodRequest.new('flickr.people.findByUsername')
+      end
+
+      should "translate a shorthand API call" do
+        request = MethodRequest.new('people.findByUsername')
+        request.method.should == 'flickr.people.findByUsername'
+      end
+
+      should "be able to make a request" do
+        endpoint_uri = stub()
+
+        request = MethodRequest.new('people.findByUsername')
+        request.stubs(:endpoint_uri).with().returns(endpoint_uri)
+
+        Net::HTTP.expects(:get).with(endpoint_uri).returns('<xml>')
+
+        request.send
+      end
+
+      should "create a response from the request" do
+        response_xml  = '<xml>'
+        response_stub = stub()
+
+        Net::HTTP.stubs(:get).returns(response_xml)
+        Response.expects(:new).with(response_xml).returns(response_stub)
+
+        request = MethodRequest.new('people.findByUsername')
+        request.stubs(:endpoint_uri)
+
+        request.send.should == response_stub
+      end
+
+      should "be able to make a full request and response cycle" do
+        method = 'flickr.people.findByUsername'
+        params = {:username => 'foobar'}
+
+        response = stub(:error? => false)
+
+        MethodRequest.expects(:new).with(method, params).returns(stub(:send => response))
+
+        MethodRequest.with_response!(method, params).should == response
       end
+
+      should "raise an exception when the full request / response cycle has errors" do
+        method = 'flickr.people.findByUsername'
+        params = {:username => 'foobar'}
+
+        response = stub(:error? => true, :error => stub(:code => '1', :message => 'User not found'))
+
+        MethodRequest.expects(:new).with(method, params).returns(stub(:send => response))
+
+        lambda do
+          MethodRequest.with_response!('flickr.people.findByUsername', :username => 'foobar')
+        end.should raise_error(Fleakr::ApiError)
+      end
+
     end
-    
+
   end
 end

data/test/unit/fleakr/api/parameter_list_test.rb

@@ -3,173 +3,192 @@ require File.dirname(__FILE__) + '/../../../test_helper'
 module Fleakr::Api
   class ParameterListTest < Test::Unit::TestCase
     
-    context "An instance of the ParameterList class" do
-      
+    context "An instance of the ParameterList class with an available API key" do
       setup do
-        @api_key = 'key'
-        @secret  = 'foobar'
-
-        Fleakr.stubs(:api_key).with().returns(@api_key)
+        @api_key_value = 'api_key_value'
+        Fleakr.stubs(:api_key).with().returns(@api_key_value)
+        
         @parameter_list = ParameterList.new
       end
-      
-      should "contain the :api_key by default" do
-        @parameter_list[:api_key].name.should == 'api_key'
-        @parameter_list[:api_key].value.should == @api_key
-        @parameter_list[:api_key].include_in_signature?.should be(true)
+
+      should "send the authentication token by default if it is available" do
+        @parameter_list.stubs(:authentication_token).with().returns('toke')
+        @parameter_list.send_authentication_token?.should be(true)
       end
       
-      should "be able to create an initial list of parameters" do
-        parameter_list = ParameterList.new(:one => 'two')
-        parameter_list[:one].value.should == 'two'
+      should "know not to send the authentication token" do
+        pl = ParameterList.new({}, false)
+        pl.stubs(:authentication_token).with().returns('toke')
+        
+        pl.send_authentication_token?.should be(false)
       end
       
-      should "be able to add parameters to its list" do
-        parameter = ValueParameter.new('foo', 'bar')
-        
-        @parameter_list << parameter
-        @parameter_list['foo'].should == parameter
+      should "know not to send the authentication token if it's not available from the global value" do
+        @parameter_list.stubs(:authentication_token).with().returns(nil)
+        @parameter_list.send_authentication_token?.should be(false)
       end
       
-      should "allow access to parameters by symbol" do
-        parameter = ValueParameter.new('foo', 'bar')
-        @parameter_list << parameter
-        
-        @parameter_list[:foo].should == parameter
+      should "have a default list of options" do
+        @parameter_list.default_options.should == {:api_key => @api_key_value}
       end
       
-      should "overwrite existing values when a duplicate is added" do
-        length = @parameter_list.instance_variable_get(:@list).length
-        2.times {@parameter_list << ValueParameter.new('foo', 'bar') }
+      should "use the authentication_token in the options if we're to authenticate" do
+        @parameter_list.stubs(:send_authentication_token?).with().returns(true)
+        @parameter_list.stubs(:authentication_token).with().returns('toke')
+        @parameter_list.stubs(:default_options).with().returns({})
         
-        @parameter_list.instance_variable_get(:@list).length.should == length + 1
+        @parameter_list.options.should == {:auth_token => 'toke'}
       end
       
-      should "be able to calculate the signature of the parameters" do
-        Fleakr.stubs(:shared_secret).with().returns(@secret)
-        
-        @parameter_list << ValueParameter.new('foo', 'bar')
-        @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}api_key#{@api_key}foobar")
+      should "add additional options from the constructor" do
+        pl = ParameterList.new(:foo => 'bar')
+        pl.options.should == {:foo => 'bar', :api_key => @api_key_value}
       end
       
-      should "use the correct order when signing a list of multiple parameters" do
-        Fleakr.stubs(:shared_secret).with().returns(@secret)
-        
-        @parameter_list << ValueParameter.new('z', 'a')
-        @parameter_list << ValueParameter.new('a', 'z')
-        
-        @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}azapi_key#{@api_key}za")
+      should "know that it doesn't need to sign the request by default" do
+        @parameter_list.sign?.should be(false)
       end
       
-      should "ignore the parameters that aren't included in the signature" do
-        Fleakr.stubs(:shared_secret).with().returns(@secret)
-        
-        @parameter_list << ValueParameter.new('foo', 'bar')
-        @parameter_list << ValueParameter.new('yes', 'no', false)
-        
-        @parameter_list.signature.should == Digest::MD5.hexdigest("#{@secret}api_key#{@api_key}foobar")
+      should "know that it needs to sign the request when a shared secret is available" do
+        Fleakr.expects(:shared_secret).with().returns('secrit')
+        @parameter_list.sign?.should be(true)
       end
       
-      should "be able to generate a boundary for post data" do
-        rand = '0.123'
+      should "be able to add an option to the list" do
+        @parameter_list.stubs(:default_options).with().returns({})
         
-        @parameter_list.stubs(:rand).with().returns(stub(:to_s => rand))
-        @parameter_list.boundary.should == Digest::MD5.hexdigest(rand)
+        @parameter_list.add_option(:foo, 'bar')
+        @parameter_list.options.should == {:foo => 'bar'}
       end
       
-      should "know that it doesn't need to sign the request by default" do
-        @parameter_list.sign?.should be(false)
+      should "have an empty list of upload options by default" do
+        @parameter_list.upload_options.should == {}
       end
       
-      should "know that it needs to sign the request when a shared secret is available" do
-        Fleakr.expects(:shared_secret).with().returns(@secret)
-        @parameter_list.sign?.should be(true)
+      should "be able to add an upload option to the list" do
+        @parameter_list.add_upload_option(:file, '/path/to/foo')
+        @parameter_list.upload_options.should == {:file => '/path/to/foo'}
       end
       
-      should "know that it doesn't need to authenticate the request by default" do
-        @parameter_list.authenticate?.should be(false)
+      should "be able to generate the list of parameters without a signature" do
+        @parameter_list.stubs(:options).with().returns({:foo => 'bar', :api_sig => '1234'})
+        @parameter_list.options_without_signature.should == {:foo => 'bar'}
       end
       
-      should "know to authenticate the request when a token is available" do
-        Fleakr.stubs(:token).with().returns(stub(:value => 'toke'))
-        parameter_list = ParameterList.new
+      should "be able to calculate the signature of the parameters" do
+        Fleakr.stubs(:shared_secret).with().returns('sekrit')
+        
+        options = {:api_key => @api_key_value, :foo => 'bar', :blip => 'zeeez'}
+        @parameter_list.stubs(:options_without_signature).with().returns(options)
 
-        parameter_list.authenticate?.should be(true)
+        @parameter_list.signature.should == Digest::MD5.hexdigest("sekritapi_key#{@api_key_value}blipzeeezfoobar")
       end
       
-      should "not authenticate the request if it's been specifically told not to" do
-        Fleakr.expects(:token).with().never
+      should "be able to generate a list of options with a signature" do
+        parameters = [ValueParameter.new('foo', 'bar')]
+        
+        @parameter_list.stubs(:options_without_signature).with().returns(:foo => 'bar')
+        @parameter_list.stubs(:signature).with().returns('sig')
         
-        parameter_list = ParameterList.new(:authenticate? => false)
-        parameter_list.authenticate?.should be(false)
+        @parameter_list.options_with_signature.should == {:foo => 'bar', :api_sig => 'sig'}
       end
       
+      should "know the auth token when provided to the constructor" do
+        pl = ParameterList.new(:auth_token => 'toke')
+        pl.authentication_token.should == 'toke'
+      end
+      
+      should "know the auth token when available as a global value" do
+        Fleakr.stubs(:auth_token).with().returns('toke')
+        
+        pl = ParameterList.new
+        pl.authentication_token.should == 'toke'
+      end
       
-      should "know to authenticate the request when asked" do
-        Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
+      should "know that there is no authentication token if it is not available as a param or global value" do
+        Fleakr.stubs(:auth_token).with().returns(nil)
         
-        parameter_list = ParameterList.new(:authenticate? => true)
-        parameter_list.authenticate?.should be(true)
+        pl = ParameterList.new
+        pl.authentication_token.should be_nil
+      end
+
+      should "be able to generate a boundary for post data" do
+        rand = '0.123'
+        
+        @parameter_list.stubs(:rand).with().returns(stub(:to_s => rand))
+        @parameter_list.boundary.should == Digest::MD5.hexdigest(rand)
+      end
+
+      should "be able to generate a list of parameters without a signature" do
+        parameter = stub()
+        
+        @parameter_list.stubs(:sign?).with().returns(false)
+        @parameter_list.expects(:options_without_signature).with().returns(:foo => 'bar')
+
+        ValueParameter.expects(:new).with(:foo, 'bar').returns(parameter)
+        
+        @parameter_list.list.should == [parameter]
       end
       
-      should "contain the :auth_token parameter in the list if the request is to be authenticated" do
-        Fleakr.expects(:token).with().returns(stub(:value => 'toke'))
+      should "be able to generate a list of parameters with a signature" do
+        parameter = stub()
         
-        parameter_list = ParameterList.new(:authenticate? => true)
-        auth_param = parameter_list[:auth_token]
+        @parameter_list.stubs(:sign?).with().returns(true)
+        @parameter_list.expects(:options_with_signature).with().returns(:foo => 'bar')
+
+        ValueParameter.expects(:new).with(:foo, 'bar').returns(parameter)
         
-        auth_param.name.should == 'auth_token'
-        auth_param.value.should == 'toke'
-        auth_param.include_in_signature?.should be(true)
+        @parameter_list.list.should == [parameter]
       end
       
-      should "include the signature in the list of parameters if the request is to be signed" do
-        parameter_list = ParameterList.new
+      should "be able to generate a list of parameters with upload parameters if available" do
+        value_parameter = stub()
+        file_parameter  = stub()
         
-        parameter_list.stubs(:sign?).with().returns(true)
-        parameter_list.stubs(:signature).with().returns('sig')
+        @parameter_list.stubs(:sign?).with().returns(true)
+        @parameter_list.expects(:options_with_signature).with().returns(:foo => 'bar')
+        @parameter_list.expects(:upload_options).with().returns(:file => 'path')
         
-        signature_param = parameter_list[:api_sig]
+        ValueParameter.expects(:new).with(:foo, 'bar').returns(value_parameter)
+        FileParameter.expects(:new).with(:file, 'path').returns(file_parameter)
         
-        signature_param.name.should == 'api_sig'
-        signature_param.value.should == 'sig'
-        signature_param.include_in_signature?.should be(false)
+        @parameter_list.list.should == [value_parameter, file_parameter]
       end
-      
+            
       context "with associated parameters" do
-      
+
         setup do
           @p1 = ValueParameter.new('a', 'b')
           @p2 = ValueParameter.new('c', 'd')
-      
+
           @p1.stubs(:to_query).with().returns('q1')
           @p1.stubs(:to_form).with().returns('f1')
-          
+
           @p2.stubs(:to_query).with().returns('q2')
           @p2.stubs(:to_form).with().returns('f2')
-      
-          @parameter_list.stubs(:list).with().returns('a' => @p1, 'c' => @p2)
+
+          @parameter_list.stubs(:list).with().returns([@p1, @p2])
         end
-      
+
         should "be able to generate a query representation of itself" do
           @parameter_list.to_query.should == 'q1&q2'
         end
-      
+
         should "be able to represent a form representation of itself" do
           @parameter_list.stubs(:boundary).returns('bound')
-          
+
           expected = 
             "--bound\r\n" +
             "f1" +
             "--bound\r\n" +
             "f2" +
             "--bound--"
-            
+
           @parameter_list.to_form.should == expected
         end
-        
+
       end
-      
+
     end
     
   end