rally_rest_api 0.5.5

data/test/tc_query_result.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'test/unit/testcase'
+
+require 'rally_rest_api/rally_rest'
+
+class QueryResultTestCase < Test::Unit::TestCase
+  
+
+  def setup
+    @api = RallyRestAPI.new
+  end
+
+  def make_result(total, page_size, start_index)
+    xml = %Q(<QueryResult><TotalResultCount>#{total}</TotalResultCount><PageSize>#{page_size}</PageSize><StartIndex>#{start_index}</StartIndex><Results>)
+    page_size.times { |i| xml << %Q(<RefElement ref="http" refObjectName="name#{i}"/>) }
+    xml << %Q(</Results></QueryResult>)
+    xml
+  end
+  
+  def test_basic_numbers
+    result_xml = make_result(20, 20, 0)
+    result = QueryResult.new(nil, @api, result_xml)
+    assert_equal(20, result.total_result_count)
+    assert_equal(20, result.page_size)
+    assert_equal(0, result.start_index)
+    assert_equal(20, result.page_length)
+  end
+
+  def test_more_pages_when_no_pages
+    query_result_xml = make_result(20, 20, 0)
+    result = QueryResult.new(nil, @api, query_result_xml)
+    assert(! result.more_pages?, "No more pages when total == page size")
+  end
+
+  def test_more_pages_when_more_pages
+    query_result_xml = make_result(21, 20, 0)
+    result = QueryResult.new(nil, @api, query_result_xml)
+    assert(result.more_pages?, "Should have more pages when total != page size")
+  end
+
+end

data/test/tc_rest_api.rb

@@ -0,0 +1,98 @@
+require 'test/unit'
+require 'test/unit/testcase'
+
+require 'rally_rest_api/rally_rest'
+
+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
+    end
+    def post_xml(url, xml, username, password)
+      @test.xml = xml
+      "<CreateResult><Object/></CreateResult>"
+    end
+  end
+  
+  def xml=(xml)
+    @xml = xml
+  end
+  
+  def setup
+    super
+    @api = RallyRestAPI.new
+    class << @api
+      include LocalBuilder
+    end
+    @api.test = self
+  end
+
+  def preamble
+    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+  end
+
+  # This covers:
+  #  - Camel casing basic types and names
+  #  - String values
+  def test_basic_create
+    xml = "#{preamble}<Feature><Name>name</Name></Feature>"
+    @api.feature(:name => "name")
+    assert_equal(xml, @xml)
+  end
+
+  # test that types and keys are camel cased (at least with one underscore)
+  def test_camel_case
+    xml = "#{preamble}<UseCase><NameName>name</NameName></UseCase>"
+    @api.use_case(:name_name => "name")
+    assert_equal(xml, @xml)
+  end
+
+  def test_nil_value
+    xml = %Q(#{preamble}<UseCase><Name ref="null"/></UseCase>)
+    @api.use_case(:name => nil)
+    assert_equal(xml, @xml)
+  end
+
+  def test_time_value
+    time = Time.now
+    xml = "#{preamble}<UseCase><Time>#{time.iso8601}</Time></UseCase>"
+    @api.use_case(:time => time)
+    assert_equal(xml, @xml)
+  end
+
+  # check passing one RestObject as the value
+  def test_rest_object_value
+    rest_object_xml = %Q(<Feature ref="url"><Name>name</Name></Feature>)
+    rest_object = RestObject.new(@api, rest_object_xml)
+
+    xml = %Q(#{preamble}<Feature><UseCase ref="url"/></Feature>)
+    @api.feature(:use_case => rest_object)
+    assert_equal(xml, @xml)
+  end
+
+  # Check for passing a single RestObject as the value to a collection node
+  def test_rest_object_array_value
+    rest_object_xml = %Q(<UseCase ref="url"><Name>name</Name></UseCase>)
+    uc1 = RestObject.new(@api, rest_object_xml)
+
+    xml = %Q(#{preamble}<Feature><Dependents><UseCase ref="url"/></Dependents></Feature>)
+    @api.feature(:dependents => uc1)
+    assert_equal(xml, @xml)
+  end
+
+  # Check for passing an array of RestObjects as the value
+  def test_rest_object_array_value_multiple_values
+    rest_object_xml = %Q(<UseCase ref="url"><Name>name</Name></UseCase>)
+    uc1 = RestObject.new(@api, rest_object_xml)
+    uc2 = RestObject.new(@api, rest_object_xml)
+
+    xml = %Q(#{preamble}<Feature><Dependents><UseCase ref="url"/><UseCase ref="url"/></Dependents></Feature>)
+    @api.feature(:dependents => [uc1, uc2])
+    assert_equal(xml, @xml)
+  end
+
+end

data/test/tc_rest_object.rb

@@ -0,0 +1,146 @@
+
+require 'test/unit'
+require 'test/unit/testcase'
+
+require 'rally_rest_api/rally_rest'
+
+# 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_basic_text_node
+    xml = %Q(<Object><TextNode>text</TextNode></Object>)
+    assert_equal("text", rest_object(xml).text_node)
+  end
+
+  def test_nested_text_node
+    xml = %Q(<Object><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><Top><RefElement ref="http" refObjectName="name1"/></Top></Object>)
+    assert_equal(RestObject, rest_object(xml).top['name1'].class)
+  end
+
+  def test_ref_node_reading
+    xml = %Q(<Object><Top><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['name1'].foo)
+  end
+
+  def test_ref_node_collection_reading
+    xml = %Q(<Object><Top><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["name1"]
+
+    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><Top><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(2, rest_object(xml).top.ref_elements.length)
+    assert_equal(Array, rest_object(xml).top.ref_elements["name2"].class)
+    assert_equal(3, rest_object(xml).top.ref_elements["name2"].length)
+  end
+
+  def test_named_collection_reading
+    xml = %Q(<Object><Top><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["name1"]
+    assert_equal("name1", named_element1.name)
+
+    named_element2 = rest_object(xml).top.named_elements["name2"]
+    assert_equal("name2", named_element2.name)
+  end
+
+  def test_unnamed_collection_reading
+    xml = %Q(<Object><Top><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

data/test/tc_rest_query.rb

@@ -0,0 +1,197 @@
+
+require "test/unit"
+require 'rally_rest_api/query'
+
+class TestRestQuery < Test::Unit::TestCase
+  # RestQuery.find(:feature).where {  # default is and
+  #   equal :name, "name"  
+  #   or {
+  #     equal :name, "name"
+  #     equal :card.task.name, "task name"
+  #     less_than :plan_estimate, "10"
+  #   }
+  # }
+  def test_single_statement
+    assert_equal("(Name = name)", RestQuery.query { equal :name, "name"} )
+  end
+
+  def test_name_with_spaces
+    assert_equal("(Name = \"name name\")", RestQuery.query { equal :name, "name name"} )
+  end
+  
+  def test_attribute_camelized
+    assert_equal("(IterationName != iteration)", 
+    RestQuery.query { not_equal :iteration_name, "iteration"}
+    )
+  end
+  
+  def test_attribute_path_camelized
+    assert_equal("(Card.IterationName contains iteration)", 
+    RestQuery.query{ contains :'card.iteration_name', "iteration"} 
+    )
+  end
+  
+  def test_multiple_and_statements
+    assert_equal("((Name = name) and (Description > description))", 
+    RestQuery.query do
+      equal :name, "name"
+      greater_than :description, "description"
+    end
+    )
+    
+    assert_equal("(((Name = name) and (Description = description)) and (Notes <= notes))", 
+    RestQuery.query do
+      equal :name, "name"
+      equal :description, "description"
+      lte :notes, "notes"
+    end
+    )
+  end
+
+  def test_multiple_or_statements
+    assert_equal("((Name = name) or (Description >= description))", 
+    RestQuery.query do
+      _or_ do
+        equal :name, "name"
+        gte :description, "description"
+      end
+    end
+    )
+  end
+  
+  def test_multiple_ands_with_or
+    assert_equal("(((Name = name) and (Description >= description)) or (Notes = notes))",
+    RestQuery.query do
+      _or_ do      
+        _and_ do
+          equal :name, "name"
+          greater_than_equal :description, "description"
+        end
+        equal :notes, "notes"
+      end
+    end
+    )
+  end
+  
+  def test_multiple_ors_with_and
+    assert_equal("(((Name = name) or (Description = description)) and (Notes = notes))",
+    RestQuery.query do
+      _or_ do
+        equal :name, "name"
+        equal :description, "description"
+      end
+      equal :notes, "notes"
+    end
+    )
+  end
+  
+  def test_multiple_ors_with_multiple_ands
+    assert_equal("(((Name = name) or (Description = description)) and ((Notes = notes) and (StartDate = start)))",
+    RestQuery.query do
+      _or_ do
+        equal :name, "name"
+        equal :description, "description"
+      end
+      _and_ do
+        equal :notes, "notes"
+        equal :start_date, "start"
+      end
+    end
+    )
+  end
+  
+  def test_three_ors_with_three_ands
+    assert_equal("((((Name = name1) or (Description = description1)) or (Other = other1)) and (((Notes = notes2) and (StartDate = start2)) and (Other = other2)))",
+    RestQuery.query {
+      _and_ {
+        _or_ {
+          equal :name, "name1"
+          equal :description, "description1"
+          equal :other, "other1"
+        }
+        _and_ {
+          equal :notes, "notes2"
+          equal :start_date, "start2"
+          equal :other, "other2"
+        }
+      }
+    }
+    )
+  end
+  
+  def test_anded_ors
+    assert_equal("(((Name = name1) or (Name = name2)) and ((Name = name3) or (Name = name4)))", 
+    RestQuery.query do
+      _or_ do
+        equal :name, "name1"
+        equal :name, "name2"
+      end
+      _or_ do
+        equal :name, "name3"
+        equal :name, "name4"
+      end
+    end
+    )
+  end
+
+  def test_new_with_type_no_args
+    query_string = RestQuery.new(:artifact) { equal :name, "name"}.to_q
+    assert_equal("query=(Name = name)", URI.unescape(query_string) )    
+  end
+
+  def test_new_with_type_and_args
+    query_string = RestQuery.new(:artifact, 
+				 :pagesize => 10, 
+				 :start => 1) { equal :name, "name"}.to_q
+
+    # The parameters sometimes appear in a different order
+    unescaped_qs = URI.unescape(query_string)
+    assert(unescaped_qs =~ /&start=1/)
+    assert(unescaped_qs =~ /&pagesize=10/)
+    assert(unescaped_qs =~ /query=\(Name = name\)/)
+    # assert_equal("query=(Name = name)&pagesize=10&start=1", URI.unescape(query_string) )
+  end
+
+  def test_new_with_one_order_arg
+    query_string = RestQuery.new(:artifact, 
+				 :order => :package) { equal :name, "name"}.to_q
+    assert_equal("query=(Name = name)&order=Package", URI.unescape(query_string) )
+  end
+
+  def test_new_with_multiple_order_arg
+    query_string = RestQuery.new(:artifact, 
+				 :order => [:package, :owner]) { equal :name, "name"}.to_q
+    assert_equal("query=(Name = name)&order=Package, Owner", URI.unescape(query_string) )
+  end
+
+  def test_new_with_multiple_order_arg_desc
+    query_string = RestQuery.new(:artifact, 
+				 :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_next_page
+    q = RestQuery.new(:artifact, 
+		      :pagesize => 10, 
+		      :start => 1) { equal :name, "name"}
+    query_string = q.to_q
+
+    # The parameters sometimes appear in a different order
+    unescaped_qs = URI.unescape(query_string)
+    assert(unescaped_qs =~ /&start=1/)
+    assert(unescaped_qs =~ /&pagesize=10/)
+    assert(unescaped_qs =~ /query=\(Name = name\)/)
+    # assert_equal("query=(Name = name)&pagesize=10&start=1", URI.unescape(query_string) )
+    query_string = q.next_page(:pagesize => 20,
+			       :start => 20).to_q
+
+    # The parameters sometimes appear in a different order
+    unescaped_qs = URI.unescape(query_string)
+    assert(unescaped_qs =~ /&start=20/)
+    assert(unescaped_qs =~ /&pagesize=20/)
+    assert(unescaped_qs =~ /query=\(Name = name\)/)
+    # assert_equal("query=(Name = name)&pagesize=20&start=20", URI.unescape(query_string) )
+  end
+
+  
+end