rally_rest_api 0.6.3 → 0.6.6

data/Manifest.txt

@@ -18,6 +18,6 @@ test/query_result_spec.rb
 test/spec_typedef.rb
 test/tc_query_result.rb
 test/tc_rest_api.rb
-test/tc_rest_object.rb
+test/rest_object_spec.rb
 test/tc_rest_query.rb
 test/test_helper.rb

data/lib/rally_rest_api/query.rb

@@ -24,6 +24,14 @@ class NilClass
   end
 end
 
+class TrueClass
+  alias :to_q :to_s
+end
+
+class FalseClass
+  alias :to_q :to_s
+end
+
 # == Generate a query string for Rally's webservice query interface.
 # Arguments are:
 #  type - the type to query for
@@ -81,7 +89,7 @@ class RestQuery
     @query_string = "query=" << URI.escape(QueryBuilder.new("and", &block).to_q) if block_given?
     @query_string.gsub!("&", "%26")
     @args_for_paging = {}
-    [:workspace, :project, :project_scope_down, :project_scope_up].each { |k| @args_for_paging[k] = args[k] if args.key?(k) }
+    [:workspace, :project, :project_scope_down, :project_scope_up, :order, :fetch].each { |k| @args_for_paging[k] = args[k] if args.key?(k) }
     @query_params = process_args(args)
   end
 

data/lib/rally_rest_api/query_result.rb

@@ -17,6 +17,8 @@ require File.dirname(__FILE__) + '/rest_object'
 #
 # 
 class QueryResult < RestObject
+  include Enumerable
+
   attr_reader :total_result_count
   attr_reader :page_size
   attr_reader :start_index
@@ -78,4 +80,13 @@ class QueryResult < RestObject
      false
    end
 
+  def ref?(element) # :nodoc:
+    !element.nil? && 
+      !element.attributes["ref"].nil?
+  end
+
+  def terminal?(node)
+    !node.has_elements? || ref?(node)
+  end
+
 end

data/lib/rally_rest_api/rally_rest.rb

@@ -7,9 +7,8 @@ require 'ostruct'
 # RallyRestAPI - A Ruby-ized interface to Rally's REST webservice API
 #
 class RallyRestAPI
-  include RestBuilder
  
-  attr_reader :username, :password, :base_url, :raise_on_warning, :logger
+  attr_reader :username, :password, :base_url, :raise_on_warning, :logger, :builder
   attr_accessor :parse_collections_as_hash
 
   ALLOWED_TYPES = %w[subscription workspace project iteration release defect defect_suite test_case
@@ -25,29 +24,36 @@ class RallyRestAPI
   # * raise_on_warn - true|false|Exception Class. If you want exceptions raised on warnings. Default is false. if 'true' RuntimeException will be raised. If ExceptionClass, then an instance of that will be raised.
   # * logger    - a Logger to log to.
   #
-  def initialize(options = {:base_url => "https://rally1.rallydev.com/slm"})
+  def initialize(options = {})
     parse_options options
   end
 
   def parse_options(options)
     @username = options[:username]
     @password = options[:password]
-    @base_url = options[:base_url]
+    @base_url = options[:base_url] || "https://rally1.rallydev.com/slm"
     @raise_on_warning = options[:raise_on_warning]
     @logger = options[:logger]
     @parse_collections_as_hash = options[:parse_collections_as_hash] || false
+
+    if options[:builder]
+      builder = options[:builder] 
+    else
+      builder = RestBuilder.new(@base_url, @username, @password)
+    end
+    builder.logger = @logger if @logger
+    @builder = builder
   end
 
   # return an instance of User, for the currently logged in user. 
   def user
-    RestObject.new(self, read_rest("#{@base_url}/webservice/1.0/user", @username, @password))
+    RestObject.new(self, builder.read_rest("#{@base_url}/webservice/1.0/user", @username, @password))
   end
   alias :start :user # :nodoc:
 
   # This is deprecated, use create instead
   def method_missing(type, args, &block) # :nodoc:
-#    raise "'#{type}' is not a supported type. Supported types are: #{ALLOWED_TYPES.inspect}" unless ALLOWED_TYPES.include?(type.to_s)
-    create_rest(type, args, @username, @password)
+    raise "'#{type}' is not a supported method. Use create() instead"
   end
 
   # Create an object.
@@ -59,7 +65,7 @@ class RallyRestAPI
   # returns the created object as a RestObject.
   def create(type, values) # :yields: new_object
 #    raise "'#{type}' is not a supported type. Supported types are: #{ALLOWED_TYPES.inspect}" unless ALLOWED_TYPES.include?(type.to_s)
-    object = create_rest(type, values, @username, @password)
+    object = builder.create_rest(type, values, @username, @password)
     yield object if block_given?
     object
   end
@@ -68,10 +74,10 @@ class RallyRestAPI
   # Example :
   #   rally.find(:artifact, :page_size => 20, :start_index => 20) { equal :name, "name" }
   # See RestQuery for more info.
-  def find(type, args = {}, &query)
+  def find(type, args = {}, &query_block)
     # pass the args to RestQuery, make it generate the string and handle generating the query for the 
     # next page etc.
-    query = RestQuery.new(type, args, &query)
+    query = RestQuery.new(type, args, &query_block)
     query(query)
   end
 
@@ -92,7 +98,7 @@ class RallyRestAPI
   
   def query(query) # :nodoc:
     query_url = "#{@base_url}/webservice/1.0/#{query.type.to_s.to_camel}?" << query.to_q
-    xml = read_rest(query_url, @username, @password)
+    xml = builder.read_rest(query_url, @username, @password)
     QueryResult.new(query, self, xml)
   end
 

data/lib/rally_rest_api/rest_builder.rb

@@ -4,10 +4,15 @@ require 'rexml/document'
 require 'rubygems'	
 require 'builder'
 
-module RestBuilder # :nodoc:
+class RestBuilder # :nodoc:
+
+  attr_reader :base_url, :username, :password
+  attr_accessor :logger
+
+  def initialize(base_url, username, password)
+    @base_url, @username, @password = base_url, username, password
+  end
 
-  DEBUG = false
-  
   # create_rest - convert slm builder style:
   #    slm.feature(:name => "feature name")
   #
@@ -72,6 +77,7 @@ module RestBuilder # :nodoc:
     req.content_type = 'text/xml'
     http = Net::HTTP.new(url.host, url.port)
     http.use_ssl = true if url.scheme == "https"
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
     body = http.start { |http| http.request(req) }.body
     debug  "RestBuilder#send_request result = #{body}"
     check_for_errors(body)
@@ -175,5 +181,9 @@ module RestBuilder # :nodoc:
     COLLECTION_TYPES.include?(type)
   end
 
+  def debug(message)
+    @logger.debug message if @logger
+  end
+
 
 end

data/lib/rally_rest_api/rest_object.rb

@@ -1,5 +1,6 @@
 require 'logger'
 require File.dirname(__FILE__) + '/rest_builder'
+require 'builder/blankslate'
 
 # == An interface to a Rally resource
 # RestObject is an adapter that is initialized with a resource ref (URL) that represents a Rally object. The adapter
@@ -18,10 +19,8 @@ require File.dirname(__FILE__) + '/rest_builder'
 #
 #
 class RestObject
-  include RestBuilder
 
   attr_reader :username, :password, :rally_rest
-  alias :builder :rally_rest
 
   def initialize(rally_rest, document_content)
     @rally_rest = rally_rest
@@ -36,24 +35,32 @@ class RestObject
   end
 
   private
+  def terminal?(node)
+    !node.has_elements?
+  end
+
+  def terminal_object(node)
+    if ref?(node)
+      low_debug  "Returning RestObject for #{ node.to_s}"
+      return RestObject.new(rally_rest, node.to_s)
+    else
+      low_debug  "Returning text #{ node.text }"
+      return node.text
+    end
+  end
+
   def parse(node)
-    debug  "parse self = #{self.object_id} node = #{ node.to_s }"
+    low_debug  "parse self = #{self.object_id} node = #{ node.to_s }"
 
-    if !node.has_elements?
-      if ref?(node)
-	debug  "Returning RestObject for #{ node.to_s}"
-	return RestObject.new(@rally_rest, node.to_s)
-      else
-	debug  "Returning text #{ node.text }"
-	return node.text
-      end
+    if terminal? node
+      return terminal_object(node)
     end
+
     # Convert nodes with children into Hashes
     elements = {}
     class << elements
       def method_missing(sym, *args)
 	value = self[sym]
-#	raise "No matching element named #{sym}. Know values are #{self.keys.join(' ')}." if value.nil?
 	value
       end
     end
@@ -61,15 +68,15 @@ class RestObject
     #Add all the element's children to the hash.
     node.each_element do |e|
       name = underscore(e.name).to_sym
-      debug  "Looking at name = #{ name }"
+      low_debug  "Looking at name = #{ name }"
       case elements[name]
 	# We've not seen this element before
       when NilClass
-	debug  "NilClass name = #{ name }"
+	low_debug  "NilClass name = #{ name }"
 	# if we have a collection of things with refObjectName attributes, collect them into a hash 
 	# with the refObjectName as the key, unless we're told not to make hashs out of collections.
 	if named_collection?(e) && parse_collections_as_hash?
-	  debug  "Named collection #{ name }"
+	  low_debug  "Named collection #{ name }"
 	  elements[name] = {}
 	  e.elements.each do |child|
 	    ref_name = child.attributes["refObjectName"]
@@ -81,20 +88,20 @@ class RestObject
 	    end
 	  end
 	elsif collection?(e)
-	  debug  "Collection #{ name }"
+	  low_debug  "Collection #{ name }"
 	  elements[name] = []
 	  e.elements.each do |child|
 	    elements[name] << parse(child)
 	  end
 	else # a fully dressed object, without a name
-	  debug  "Fully Dressed object, without a name #{ name }"
+	  low_debug  "Fully Dressed object, without a name #{ name }"
 	  elements[name] = parse(e)
 	end
 
 	#Non-unique child elements become arrays: We've already
 	#created the array: just add the element.
       when Array
-	debug  "Array name = #{ name }"
+	low_debug  "Array name = #{ name }"
 	elements[name] << parse(e)
 
 	#We haven't created the array yet: do so,
@@ -103,7 +110,7 @@ class RestObject
 #      when Hash
 #	raise "Don't know how to deail with a named collection we've already seen! element = #{e}"
       else
-	debug  "creating and wrapping #{elements[name]}with an array name = #{ name }"
+	low_debug  "creating and wrapping #{elements[name]}with an array name = #{ name }"
 	elements[name] = [elements[name]]
 	elements[name] << parse(e)
       end
@@ -118,7 +125,7 @@ class RestObject
       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
       gsub(/([a-z\d])([A-Z])/,'\1_\2').
       tr("-", "_").
-      downcase
+      downcase.gsub(/_id$/,'_i_d')
   end
 
 
@@ -134,9 +141,9 @@ class RestObject
   alias :to_q :ref
 
   # The name of the object, without having to read the entire body
-  def name
-    @document.root.attributes["refObjectName"]
-  end
+   def name
+     @document.root.attributes["refObjectName"]
+   end
 
   # The type of the underlying resource
   def type
@@ -169,7 +176,7 @@ class RestObject
 
   def elements(read = @elements.nil?) #:nodoc:
     if read
-      @document_content = read_rest(self.ref, @username, @password)
+      @document_content = builder.read_rest(self.ref, @username, @password)
       @document = REXML::Document.new @document_content
       @elements = parse(@document.root)
     end
@@ -186,14 +193,14 @@ class RestObject
   
   # update the resource. This will re-read the resource after the update
   def update(args)
-    update_rest(self.type, self.ref, args, @username, @password)
+    builder.update_rest(self.type, self.ref, args, @username, @password)
     # need to deal with the block, setting up contexts etc
     self.elements(true)
   end
 
   # delete the resource
   def delete
-    delete_rest(self.ref, @username, @password)
+    builder.delete_rest(self.ref, @username, @password)
   end
 
   def method_missing(sym, *args) # :nodoc:
@@ -226,8 +233,15 @@ class RestObject
     self.rally_rest.parse_collections_as_hash?
   end
 
+  def low_debug(message)
+    # debug message
+  end
+  
   def debug(message) 
-#    @rally_rest.logger.debug(message) if @rally_rest.logger
+     @rally_rest.logger.debug(message) if @rally_rest.logger
   end
 
+  def builder
+    rally_rest.builder
+  end
 end

data/lib/rally_rest_api/typedef.rb

@@ -15,7 +15,13 @@ class TypeDefinition < RestObject # :nodoc:
   end
 
   def self.get_type_definition(workspace, type)
-    typedef = workspace.type_definitions.find { |td| td.element_name == type }
+    # This is a hack
+    typedefs = case workspace.type_definitions
+    	         when Hash : workspace.type_definitions.values.flatten
+	         when Array : workspace.type_definitions
+	       end
+    typedef = typedefs.find { |td| td.element_name == type }
+    # end hack
     TypeDefinition.new(typedef.rally_rest, typedef.body)
   end
 

data/lib/rally_rest_api/version.rb

@@ -2,7 +2,7 @@ module RallyRestVersion #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 6
-    TINY  = 3
+    TINY  = 6
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/query_result_spec.rb

@@ -1,8 +1,4 @@
-require 'rubygems'
-require 'spec'
-require 'builder'
-
-require File.dirname(__FILE__) + '/../lib/rally_rest_api/query_result'
+require 'test_helper'
 
 context "A QueryResult" do
 
@@ -14,7 +10,7 @@ context "A QueryResult" do
     @api.stub!(:parse_collections_as_hash?).and_return true
   end
 
-  def make_result(total, page_size, start_index)
+  def make_result(total = 20, page_size = 20, start_index = 1)
     result_count = total > page_size ? page_size : total
 
     b = Builder::XmlMarkup.new(:indent => 2)
@@ -79,8 +75,104 @@ context "A QueryResult" do
     result.results[19].name.should == "name19"
   end
 
+  specify "should return RestObjects for results" do
+    make_result.each { |o| o.should_be_instance_of RestObject }
+  end
 end
 
-context "A QueryResult with 2 pages" do
-  
+
+context "A QueryResult with full objects" do
+
+  setup do
+    @api = mock("RallyRestAPI")
+    @api.stub! :username
+    @api.stub! :password
+    @api.stub!(:logger).and_return(nil)
+    @api.stub!(:parse_collections_as_hash?).and_return true
+  end
+
+  def make_result(total = 20, page_size = 20, start_index = 1)
+    result_count = total > page_size ? page_size : total
+
+    b = Builder::XmlMarkup.new(:indent => 2)
+    xml = b.QueryResult {
+      b.TotalResultCount total
+      b.PageSize page_size
+      b.StartIndex start_index
+
+      if (result_count > 0)
+	b.Results {
+	  result_count.times do |i| 
+	    b.RefElement(:ref => "http", :refObjectName => "name#{i}") {
+	      b.Name("This is the name for #{i}")
+	    }
+	  end
+	}
+      else
+	b.Results
+      end
+    }
+
+    QueryResult.new(nil, @api, xml)
+  end
+
+  def query_result_xml(&block)
+    QueryResult.new(nil, @api, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>#{xml &block}")
+  end
+
+  def xml
+    yield Builder::XmlMarkup.new(:indent => 2)
+  end
+
+  specify "should return RestObjects for results" do
+    make_result.each { |o| o.should_be_instance_of RestObject }
+  end
+
+  specify "full object collections should lazy load only once" do
+    rest_builder = mock("RestBuilder")
+    rest_builder.
+      should_receive(:read_rest).
+      twice.
+      with(:any_args).
+      and_return( xml do |b| 
+		   b.iteration { 
+		     b.Name("name1")
+		     b.StartDate("12/12/01")
+		   } 
+		 end )
+
+    @api = RallyRestAPI.new(:builder => rest_builder)
+
+    object = query_result_xml do |b| 
+      b.QueryResult {
+	b.TotalResultCount 2
+	b.PageSize 20
+	b.StartIndex 1
+
+	b.Results {
+	  b.Card(:ref => "http", :refObjectName => "Card1") {
+	    b.Name("Card1")
+	    b.Description("Description1")
+	    b.Iteration(:ref => "http", :refObjectName => "name1")
+	  }
+	  b.Card(:ref => "http", :refObjectName => "Card2") {
+	    b.Name("Card2")
+	    b.Description("Description2")
+	    b.Iteration(:ref => "http", :refObjectName => "name1")
+	  }
+	}
+      }
+    end
+
+    object.total_result_count.should_be 2
+    object.results.should_be_instance_of Array
+    object.each_with_index do |c, i| 
+      c.name.should == "Card#{i + 1}"
+      c.description.should == "Description#{i + 1}"
+      c.iteration.start_date.should == "12/12/01"
+      c.iteration.start_date.should == "12/12/01"
+    end
+
+  end
+
 end

data/test/rest_object_spec.rb

@@ -0,0 +1,288 @@
+
+require 'test_helper'
+
+context "a RestObject" do
+
+  setup do
+    @api = RallyRestAPI.new
+  end
+
+  def rest_object(xml)
+    RestObject.new(@api, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>#{xml}")
+  end
+
+  def rest_object_xml(&block)
+    RestObject.new(@api, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>#{xml &block}")
+  end
+
+  def b 
+    @b ||= Builder::XmlMarkup.new(:indent => 2)
+  end
+
+  def xml
+    yield Builder::XmlMarkup.new(:indent => 2)
+  end
+
+  specify "should return the type of the resource from a ref" do
+    o = rest_object_xml do |b|
+      b.Object(:refObjectName => "name", :ref => "ref", :type => "Defect")
+    end
+    o.type.should == "Defect"
+  end
+
+  specify "should return the type of the resource from full object" do
+    o = rest_object_xml do |b|
+      b.Defect(:refObjectName => "name", :ref => "ref") {
+	b.Name("name")
+      }
+    end
+    o.type.should == "Defect"
+  end
+
+  specify "should return the ref of the resource " do
+    o = rest_object_xml do |b|
+      b.Defect(:refObjectName => "name", :ref => "ref") {
+	b.Name("name")
+      }
+    end
+    o.ref.should == "ref"
+  end
+
+  specify "should underscore element names" do
+    o = rest_object(%Q(<Object ref="bla">
+                              <TextNode>text</TextNode>
+                            </Object>))
+    o.text_node.should_not_be nil
+    o.TextNode.should_be nil
+    o.Text_Node.should_be nil
+    o.textnode.should_be nil
+  end
+
+  specify "should underscore elements ending in 'ID' correctly" do
+    o = rest_object(%Q(<Object ref="bla">
+                              <SalesforceCaseID>12345</SalesforceCaseID>
+                            </Object>))
+    o.salesforce_case_i_d.should == "12345"
+  end
+
+  specify "should return text nodes" do
+    xml = %Q(<Object ref="bla">
+               <TextNode>text</TextNode>
+             </Object>)
+    rest_object(xml).text_node.should == "text"
+  end
+
+  specify "should return nested text nodes" do
+    xml = %Q(<Object ref="bla">
+               <Nested>
+                 <TextNode>text</TextNode>
+               </Nested>
+             </Object>)
+    rest_object(xml).nested.text_node.should == "text"
+  end
+
+  specify "ref elements should lazy read" do
+    rest_builder = mock("RestBuilder")
+    rest_builder.
+      should_receive(:read_rest).
+      with(:any_args).
+      and_return( xml do |b| 
+		   b.TestCase { 
+		     b.Name("name1")
+		     b.Description("Description")
+		   } 
+		 end )
+
+    @api = RallyRestAPI.new(:builder => rest_builder)
+
+    object = rest_object_xml do |b| 
+      b.TestCase(:ref => "http", :name => "name1")
+    end
+    object.description.should == "Description"
+  end
+  
+  specify "nested ref elements should lazy read" do
+    rest_builder = mock("RestBuilder")
+    rest_builder.
+      should_receive(:read_rest).
+      with(:any_args).
+      and_return( xml do |b| 
+		   b.TestCase { 
+		     b.Name("name1")
+		     b.Description("Description")
+		   } 
+		 end )
+
+    @api = RallyRestAPI.new(:builder => rest_builder)
+
+    object = rest_object_xml do |b| 
+      b.Defect(:ref => "http") {
+	b.TestCase(:ref => "http", :refObjectName => "name1")
+      }
+    end
+    object.test_case.should_be_instance_of RestObject
+    object.test_case.type.should == "TestCase"
+    object.test_case.description.should == "Description"
+  end
+
+  specify "nested ref elements should lazy read only once" do
+    rest_builder = mock("RestBuilder")
+    rest_builder.
+      should_receive(:read_rest).
+      once.
+      with(:any_args).
+      and_return( xml do |b| 
+		   b.TestCase { 
+		     b.Name("name1")
+		     b.Description("Description")
+		   } 
+		 end )
+
+    @api = RallyRestAPI.new(:builder => rest_builder)
+
+    object = rest_object_xml do |b| 
+      b.Defect(:ref => "http") {
+	b.TestCase(:ref => "http", :refObjectName => "name1")
+      }
+    end
+    object.test_case.description.should == "Description"
+    object.test_case.description.should == "Description"
+  end
+
+  specify "full object collections should lazy load only once" do
+    rest_builder = mock("RestBuilder")
+    rest_builder.
+      should_receive(:read_rest).
+      once.
+      with(:any_args).
+      and_return( xml do |b| 
+		   b.iteration { 
+		     b.Name("name1")
+		     b.StartDate("12/12/01")
+		   } 
+		 end )
+
+    @api = RallyRestAPI.new(:builder => rest_builder)
+
+    object = rest_object_xml do |b| 
+      b.QueryResult {
+	b.Results {
+	  b.Card(:ref => "http", :refObjectName => "Card1") {
+	    b.Name("Card1")
+	    b.Description("Description1")
+	    b.Iteration(:ref => "http", :refObjectName => "name1")
+	  }
+	  b.Card(:ref => "http", :refObjectName => "Card2") {
+	    b.Name("Card2")
+	    b.Description("Description2")
+	    b.Iteration(:ref => "http", :refObjectName => "name1")
+	  }
+	}
+      }
+    end
+
+    object.results.length.should_be 2
+    object.results.should_be_instance_of Array
+    object.results.first.description.should == "Description1"
+    object.results.first.iteration.start_date.should == "12/12/01"
+    object.results.first.iteration.start_date.should == "12/12/01"
+  end
+
+  specify "collections are parsed as arrays " do
+    @api = RallyRestAPI.new(:parse_collections_as_hash => false)
+
+    object = rest_object_xml do |b|
+      b.Story(:refObjectName => "story", :ref => "http") {
+	b.Tasks {
+	  b.Task(:refObjectName => "task1", :ref => "ref")
+	  b.Task(:refObjectName => "task2", :ref => "ref")
+	  b.Task(:refObjectName => "task3", :ref => "ref")
+	}
+      }
+    end
+    object.tasks.should_be_instance_of Array
+    object.tasks.length.should_be 3
+  end
+
+  specify "collections are parsed as hashes " do
+    @api = RallyRestAPI.new(:parse_collections_as_hash => true)
+
+    object = rest_object_xml do |b|
+      b.Story(:refObjectName => "story", :ref => "http") {
+	b.Tasks {
+	  b.Task(:refObjectName => "task1", :ref => "ref")
+	  b.Task(:refObjectName => "task2", :ref => "ref")
+	  b.Task(:refObjectName => "task3", :ref => "ref")
+	}
+      }
+    end
+    object.tasks.should_be_instance_of Hash
+    object.tasks.length.should_be 3
+  end
+
+  specify "when collections are parsed as hashes, dup names should be in arrays " do
+    @api = RallyRestAPI.new(:parse_collections_as_hash => true)
+
+    object = rest_object_xml do |b|
+      b.Story(:refObjectName => "story", :ref => "http") {
+	b.Tasks {
+	  b.Task(:refObjectName => "task1", :ref => "ref")
+	  b.Task(:refObjectName => "task2", :ref => "ref")
+	  b.Task(:refObjectName => "task2", :ref => "ref")
+	}
+      }
+    end
+    object.tasks.should_be_instance_of Hash
+    object.tasks.length.should_be 2
+    object.tasks["task2"].should_be_instance_of Array
+    object.tasks["task2"].length.should_be 2
+  end
+
+  specify "when collections are parsed as hashes, unnamed elements should be in arrays " do
+    @api = RallyRestAPI.new(:parse_collections_as_hash => true)
+
+    object = rest_object_xml do |b|
+      b.Story(:refObjectName => "story", :ref => "http") {
+	b.Tasks {
+	  b.Task(:ref => "ref")
+	  b.Task(:ref => "ref")
+	  b.Task(:ref => "ref")
+	}
+      }
+    end
+    object.tasks.should_be_instance_of Array
+    object.tasks.length.should_be 3
+  end
+
+
+  specify "should lazy read from collections" do
+    rest_builder = mock("RestBuilder")
+    rest_builder.
+      should_receive(:read_rest).
+      twice.
+      with(:any_args).
+      and_return( xml do |b| 
+		   b.Task { 
+		     b.Name("name1")
+		     b.Description("Description")
+		   } 
+		 end )
+
+    @api = RallyRestAPI.new(:builder => rest_builder, :parse_collections_as_hash => false)
+
+    object = rest_object_xml do |b|
+      b.Story(:refObjectName => "story", :ref => "http") {
+	b.Tasks {
+	  b.Task(:refObjectName => "task1", :ref => "ref")
+	  b.Task(:refObjectName => "task2", :ref => "ref")
+	  b.Task(:refObjectName => "task3", :ref => "ref")
+	}
+      }
+    end
+
+    object.tasks.first.description.should == "Description"
+    object.tasks.first.description.should == "Description"
+    object.tasks.last.description.should == "Description"
+  end
+
+end

data/test/tc_rest_api.rb

@@ -9,9 +9,9 @@ class RestApiTestCase < Test::Unit::TestCase
   # We need to override post_xml from RestBuilder, So redefine it here
   # We want this post_xml to set the xml that was received onto the testcase
   # So create an xml= on the test, and pass the test into the RallyRestAPI
-  module LocalBuilder
-    def test=(test)
-	@test = test
+  class LocalBuilder < RestBuilder
+    def initialize(test)
+      @test = test
     end
     def post_xml(url, xml, username, password)
       @test.xml = xml
@@ -25,11 +25,7 @@ class RestApiTestCase < Test::Unit::TestCase
   
   def setup
     super
-    @api = RallyRestAPI.new
-    class << @api
-      include LocalBuilder
-    end
-    @api.test = self
+    @api = RallyRestAPI.new(:builder => LocalBuilder.new(self))
   end
 
   def preamble
@@ -41,7 +37,7 @@ class RestApiTestCase < Test::Unit::TestCase
   #  - String values
   def test_basic_create
     xml = "#{preamble}<Feature><Name>name</Name></Feature>"
-    @api.feature(:name => "name")
+    @api.create(:feature, :name => "name")
     assert_equal(xml, @xml)
   end
 
@@ -95,5 +91,9 @@ class RestApiTestCase < Test::Unit::TestCase
     @api.create(:feature, :dependents => [uc1, uc2])
     assert_equal(xml, @xml)
   end
+  
+  def test_default_base_url_should_be_rally_proudction
+    assert_equal("https://rally1.rallydev.com/slm", @api.base_url)
+  end
 
 end

data/test/tc_rest_query.rb

@@ -175,7 +175,19 @@ class TestRestQuery < Test::Unit::TestCase
 				 :order => [:package, :owner, :desc]) { equal :name, "name"}.to_q
     assert_equal("query=(Name = name)&order=Package, Owner desc", URI.unescape(query_string) )
   end
-  
+
+  def test_new_with_true_fetch_arg
+    query_string = RestQuery.new(:artifact, 
+				 :fetch => true) { equal :name, "name"}.to_q
+    assert_equal("query=(Name = name)&fetch=true", URI.unescape(query_string) )
+  end
+
+  def test_new_with_false_fetch_arg
+    query_string = RestQuery.new(:artifact, 
+				 :fetch => false) { equal :name, "name"}.to_q
+    assert_equal("query=(Name = name)&fetch=false", URI.unescape(query_string) )
+  end
+
   def test_next_page
     q = RestQuery.new(:artifact, 
 		      :pagesize => 10, 

data/test/test_helper.rb

@@ -1,2 +1,4 @@
 require 'test/unit'
+require 'rubygems'
+require 'spec'
 require File.dirname(__FILE__) + '/../lib/rally_rest_api'

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: rally_rest_api
 version: !ruby/object:Gem::Version 
-  version: 0.6.3
-date: 2007-01-03 00:00:00 -07:00
+  version: 0.6.6
+date: 2007-02-06 00:00:00 -07:00
 summary: A ruby-ized interface to Rally's REST webservices API
 require_paths: 
 - lib
@@ -49,18 +49,18 @@ files:
 - test/spec_typedef.rb
 - test/tc_query_result.rb
 - test/tc_rest_api.rb
-- test/tc_rest_object.rb
+- test/rest_object_spec.rb
 - test/tc_rest_query.rb
 - test/test_helper.rb
 test_files: 
 - test/tc_rest_api.rb
-- test/tc_rest_object.rb
 - test/query_result_spec.rb
 - test/tc_rest_query.rb
 - test/test_helper.rb
 - test/tc_query_result.rb
 - test/spec_typedef.rb
 - test/attribute_definition_spec.rb
+- test/rest_object_spec.rb
 rdoc_options: []
 
 extra_rdoc_files: []

data/test/tc_rest_object.rb

@@ -1,166 +0,0 @@
-
-require 'test/unit'
-require 'test/unit/testcase'
-require 'logger'
-
-require 'rubygems'
-require 'rally_rest_api'
-
-
-# We need to override read_rest from RestBuilder, So redefine it here
-# We need a way to inject the xml that will be read by a RestObject when 
-# it is converting itself from a ref.
-# So change the RestBuilder, which RestObject includes, and add a test=
-# so we can send in this instance of the test case
-module MyRestBuilder
-  def read_rest(url, username, password)
-    @@test.url = url
-    @@test.read_xml
-  end
-  
-  def MyRestBuilder.test=(test)
-    @@test = test
-  end
-end
-
-$GLOBAL_BINDING = binding
-
-class RestObjectTestCase < Test::Unit::TestCase
-  def url=(url)
-    @url = url
-  end
-  
-  def setup
-    super
-    @api = RallyRestAPI.new
-
-    s = <<-"EOF"
-    class Class
-      alias :old_new :new
-      def new(*args)
-	result = old_new(*args)
-	if result.kind_of?(RestObject)
-	  class << result
-	    include MyRestBuilder
-	  end
-	end
-	return result
-      end
-    end
-    EOF
-    eval(s, $GLOBAL_BINDING)
-    
-  end
-
-  def teardown
-    super
-    s = <<-"EOF"
-    class Class
-      alias :new :old_new
-    end
-    EOF
-    eval(s, $GLOBAL_BINDING)
-  end
-
-  def rest_object(xml)
-    o = RestObject.new(@api, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>#{xml}")
-    MyRestBuilder.test = self
-    o
-  end
-  
-  def test_equal_same_instance
-    xml = %Q(<Object ref="http"><TextNode>text</TextNode></Object>)
-    r1 = r2 = rest_object(xml)
-    assert(r1 == r2)
-  end
-
-  def test_equal_with_nil
-    xml = %Q(<Object ref="http"><TextNode>text</TextNode></Object>)
-    r1 = rest_object(xml)
-    assert(r1 != nil)
-  end
-
-  def test_equal_refs
-    r1 = rest_object(%Q(<Object ref="bla"><TextNode>text</TextNode></Object>))
-    r2 = rest_object(%Q(<Object ref="bla"><TextNode>not text</TextNode></Object>))
-    assert_equal(r1, r2)
-  end
-
-
-  def test_basic_text_node
-    xml = %Q(<Object ref="bla"><TextNode>text</TextNode></Object>)
-    assert_equal("text", rest_object(xml).text_node)
-  end
-
-  def test_nested_text_node
-    xml = %Q(<Object ref="bla"><Nested ref="bla/nested"><TextNode>text</TextNode></Nested></Object>)
-    assert_equal("text", rest_object(xml).nested.text_node)
-  end
-  
-  # make sure RestObject are being created
-  def test_ref_node
-    xml = %Q(<Object ref="http"><RefElement ref="http" refObjectName="name1"/></Object>)
-    assert_equal(RestObject, rest_object(xml).class)
-  end
-
-  def test_ref_node_reading
-    xml = %Q(<Object ref="bla"><Top ref="blabla"><RefElement ref="http" refObjectName="name1"/></Top></Object>)
-    # This will be the xml returned from read_rest
-    class << self
-      def read_xml
-	%Q(<RefElement><Foo>foo</Foo></RefElement>)
-      end
-    end
-
-    assert_equal("foo", rest_object(xml).top.ref_element.foo)
-  end
-
-  def test_ref_node_collection_reading
-    xml = %Q(<Object ref="bla"><Top ref="bla"><RefElements><RefElement ref="http1" refObjectName="name1"/><RefElement ref="http2" refObjectName="name2"/></RefElements></Top></Object>)
-    # This will be the xml returned from read_rest
-    class << self
-      def read_xml
-	%Q(<RefElement ref="http3" refObjectName="name1"><Name>name</Name><Description>Desc</Description></RefElement>)
-      end
-    end
-
-    assert_equal(2, rest_object(xml).top.ref_elements.length)
-    ref_element = rest_object(xml).top.ref_elements[0]
-
-    assert_equal("http1", ref_element.ref)
-    assert_equal("Desc", ref_element.description) # Force a read
-    assert_equal("http3", ref_element.ref)  # Post read
-  end
-
-  def test_ref_collection_with_dups_is_array
-    xml = %Q(<Object ref="bla"><Top ref="bla"><RefElements><RefElement ref="http1" refObjectName="name1"/><RefElement ref="http2" refObjectName="name2"/><RefElement ref="http3" refObjectName="name2"/><RefElement ref="http3" refObjectName="name2"/></RefElements></Top></Object>)
-    # This will be the xml returned from read_rest
-    class << self
-      def read_xml
-	%Q(<RefElement ref="http3" refObjectName="name1"><Name>name</Name><Description>Desc</Description></RefElement>)
-      end
-    end
-
-    assert_equal(4, rest_object(xml).top.ref_elements.length)
-  end
-
-  def test_named_collection_reading
-    xml = %Q(<Object ref="bla"><Top ref="bla"><NamedElements><NamedElement ref="http1" refObjectName="name1"><Name>name1</Name></NamedElement><NamedElement ref="http2" refObjectName="name2"><Name>name2</Name></NamedElement></NamedElements></Top></Object>)
-
-    assert_equal(2, rest_object(xml).top.named_elements.length)
-    named_element1 = rest_object(xml).top.named_elements[0]
-    assert_equal("name1", named_element1.name)
-
-    named_element2 = rest_object(xml).top.named_elements[1]
-    assert_equal("name2", named_element2.name)
-  end
-
-  def test_unnamed_collection_reading
-    xml = %Q(<Object ref="bla"><Top ref="bla"><NamedElements><NamedElement ref="http1"><Name>name1</Name></NamedElement><NamedElement ref="http2"><Name>name2</Name></NamedElement></NamedElements></Top></Object>)
-
-    assert_equal(2, rest_object(xml).top.named_elements.length)
-    assert_equal("name1", rest_object(xml).top.named_elements[0].name)
-    assert_equal("name2", rest_object(xml).top.named_elements[1].name)
-  end
-
-end