jasper-client 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 xforty technologies
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,116 @@
+= jasper_client
+
+A client API for accessing jasper reports repository service.  
+
+The list, get, and runReport actions are supported.
+
+JasperClient provides a mechanism to construct service requests
+using Xml::Builder.  Client methods (list, get, run_report) yield
+to a block which is passed a builder to the guts of the SOAP
+request.  This allows for an easy mechanism to create XML that
+is added to a request. 
+
+An example list request document:
+
+  <?xml version="1.0" encoding="utf-8"?>
+  <soapenv:Envelope 
+      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+      xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+      xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" 
+      xmlns:axis="http://axis2.ws.jasperserver.jaspersoft.com">
+    <soapenv:Body>
+      <axis:list soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+        <requestXmlString xsi:type="xsd:string">
+        <![CDATA[
+           <request operationName="list"> 
+             <argument name="LIST_RESOURCES"/> 
+             <argument name="RESOURCE_TYPE">reportUnit</argument> 
+             <argument name="START_FROM_DIRECTORY">/Reports/xforty</argument> 
+          </request>
+          ]]>
+        </requestXmlString>
+       </axis:list>
+    </soapenv:Body>
+  </soapenv:Envelope>
+
+When a call to list is made, a builder is passed to the block provided. 
+The above request could be executed using the list example below.  In
+a nuttshell, the caller needs to construct the body/ children of the 
+<request></request> element.  Short work can be made of this by
+telling builder what to construct.
+
+== Example list request
+
+A typical request might looks look like the following:
+
+  client = JasperClient::RepositoryService.new(wsdl, user, pass)
+  
+  response = client.list do |request|
+    request.argument :name => "LIST_RESOURCES"
+    request.argument 'reportUnit', :name => "RESOURCE_TYPE"
+    request.argument '/Reports/xforty', :name => 'START_FROM_DIRECTORY'
+  end
+  
+  response.success?
+
+For more information see JasperClient::RepositoryService::Response::ListResponse.
+
+== Example get request
+  
+  response = client.get do |req|
+    req.resourceDescriptor :name => 'jrlogo', :wsType => 'img', :uriString => '/Reports/xforty/user_list', :isNew => 'false'
+  end
+  
+  puts "Is successful: #{response.success?}"
+
+For more information see JasperClient::RepositoryService::Response::GetResponse.
+
+== Example runReport request
+
+  response = client.run_report do |req|
+    req.argument 'HTML', :name => 'RUN_OUTPUT_FORMAT'
+  
+    req.resourceDescriptor :name => 'JRLogo', 
+      :wsType => 'img', 
+      :uriString => '/reports/xforty/user_list', 
+      :isNew => 'false'
+  end
+  
+  puts "Is successful: #{response.success?}"
+  
+  puts "Parts? #{response.parts.count}"
+  
+  response.parts.each do |part|
+    puts "Part: #{part.suggested_filename}"
+  end
+
+For more information see JasperClient::RepositoryService::Response::RunReportResponse.
+
+The class of the request depends on the type of request.  It will be of
+type ListResponse, GetResponse, or RunReportResponse.
+
+Response types are specific to the request.  Response types include
+ListResponse, GetResponse, RunReportResponse, etc.  Non-report 
+responses tend to be focused around the Resource class, which 
+represnets <resourceDescriptor> xml response elements.
+
+== Reports
+
+Reports are unique.  A report response is a multipart related mime
+document. The parts include the XML SOAP response, the report content 
+(which might be a PDF, a CSV, or an HTML file with accompanying images 
+in their individual parts).
+
+== Future
+
+In the future helper methods for helping to hone in on various
+kinds of info from the server will be built.  For example, you might
+want ot just find or list particular resource types like reports, 
+queries, etc. 
+
+Additionaly, the ability to update resources could be provided, but 
+we didn't have any use for this right now so we didn't focus on this.
+
+== Copyright
+
+Copyright (c) 2010 xforty technologies. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "jasper-client"
+    gem.summary = %Q{Client for JasperServer}
+    gem.description = %Q{Client for JasperServer}
+    gem.email = "alibby@xforty.com"
+    gem.homepage = "http://github.com/alibby/jasper-client"
+    gem.authors = ["Andrew Libby"]
+    # gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "jasper-client #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Clean up everything (rcov, rdoc, pkg)"
+task :clean => [:clobber_rcov, :clobber_rdoc] do
+  rm_rf 'pkg'
+end
+
+
+  

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/jasper-client.rb

@@ -0,0 +1,9 @@
+
+require 'rubygems'
+require 'savon'
+require 'builder'
+require 'nokogiri'
+
+require 'jasper-client/string'
+require 'jasper-client/http_multipart'
+require 'jasper-client/jasper_client'

data/lib/jasper-client/http_multipart.rb

@@ -0,0 +1,132 @@
+require 'net/http'
+
+# A mixin to add basic RFC 2387 MIME Multipart/Related
+# response support. 
+#
+# A multipart http response has several sections which are
+# intended to be treated as indpendent objects.  The
+# Multipart/Related response is used when all of the objects
+# are related to one another.  Typcially multipart is used
+# to have alternative versions of the same content. This is
+# not the case with multipart related.
+#
+# This mixen was written while using the Savon SOAP API, but 
+# it's intended to be mixed in to Net::HTTP and does not have
+# any known dependencies on Savon.
+#
+# http://www.faqs.org/rfcs/rfc2387.html
+module HTTPMultipart
+  
+    # An RFC2387 multipart part.  
+    #
+    # http://www.faqs.org/rfcs/rfc2387.html
+    class Part
+      # This makes headers for each part have the same interface
+      # as they do on Net::HTTPResponse.
+      include ::Net::HTTPHeader
+      
+      attr_reader :body
+      # Initialize this response part.
+      def initialize(part_str) 
+        h,b = part_str.split("\r\n\r\n", 2)
+        initialize_http_header Hash[ *h.split("\r\n").map { |hdr| hdr.split(/:\s*/, 2) }.flatten ]
+        @body = b
+      end
+      
+      # Content type supertype (for text/html, this would be 'text')
+      def content_supertype
+        content_type.split('/')[0]
+      end
+      
+      # Content type subtype.  (for text/html, this woudl be 'html')
+      def content_subtype
+        content_type.split('/')[1]
+      end
+      
+      # The suggested filename is the content_id witout the surrounding <> characters.
+      # the extension is derived from the mime-subtype.  
+      def suggested_filename
+        "%s.%s" % [ content_id.first.gsub(/<|>/, ''), content_subtype ]
+      end
+      
+      # get the content id.  Each part has a content-id  It's typical to use this as a basis
+      # for a fhile name.
+      def content_id
+        to_hash.fetch('content-id')
+      end
+      
+      # Write the content from this part to a file having name.
+      def write_to_file(name = :internal)
+        name = suggested_filename if :internal == name
+        
+        open(name, 'w') do |fh|
+          fh.write self.body
+        end
+      end
+    end
+
+    # Am I multipart?
+    def multipart?
+      %w{multipart/related}.include? content_type
+    end
+    
+    # Fetch the multipart boundary.
+    def multipart_boundary
+      content_type_fields['boundary']
+    end
+    
+    # The ID of the "start part" or initial part of the multipart related
+    # response.  
+    def start
+      content_type_fields['start']
+    end
+    
+    # Return the start part.
+    def start_part
+      parts.select { |p| p.content_id.first == start }.first.body
+    end
+    
+    # return an array of parts.
+    def parts
+        pts = body.split("--%s" % [ multipart_boundary ])
+        pts.shift
+        pts.reject { |part| part == "--\r\n" }.map { |part| Part.new(part) }
+    end
+    
+    # Iterate through each part calling the block.
+    # A Part is yielded to the block.
+    def each_part(&block)
+      if multipart?
+        parts.each do |part|
+          yield part
+        end
+      else
+        yield self
+      end
+    end
+
+    private
+    
+    # Digest a content type header value into it's component parts.
+    # When we've got a multipart response, there are a few fields in the 
+    # content-type header like the boundary, start content id, etc.  For
+    # more info on this see RFC 2387 The MIME Multipart/Related content-type
+    def content_type_fields
+      headers_split = to_hash.fetch('content-type').first.split(/\s*;\s*/)
+      headers_split.shift # skip first element which is the mime type and subtype (text/xml or the like)
+      Hash[ *headers_split.map { |pair| 
+        
+        # The regex below is intended match things like charset="utf-8" and charset=utf-8.
+        matches = pair.match(/^(.*?)=(?:"(.*)"|(.*))$/)
+        matches[1,2] if matches
+      }.flatten ]
+    end
+end
+
+class Net::HTTPResponse
+  include HTTPMultipart
+end
+
+class Net::HTTPOK
+  include HTTPMultipart
+end

data/lib/jasper-client/jasper_client.rb

@@ -0,0 +1,250 @@
+# Contiainer for things belonging to jasper client.
+module JasperClient
+  # a Jasper Server resource.
+  #
+  # A Jasperserver resource is a generic concept used to represent almost anything
+  # in a jasper server.  It can be a file, an image, pre-run report output, a query, 
+  # a report control, etc.  We attempt to boil down the resource to something 
+  # relatively consumable by application developers.
+  class Resource
+    attr_reader :name, :type, :uri_string, :label, :description, :creation_date, :properties, :resources
+    
+    # Take a Nokogiri::XML object of a 
+    def initialize(soap)
+      return unless soap.respond_to?(:search)
+      
+      @name = soap['name']
+      @type = soap['wsType']
+      @uri_string = soap['uriString']
+      @label = soap.search('./label/node()').inner_text
+      @description = soap.search('./description/node()').inner_text
+      @createion_date = soap.search('./creation_date/node()').inner_text
+      
+      initialize_properties soap.search('./resourceProperty')
+      initialize_resources soap.search('./resourceDescriptor')
+    end
+    
+    private 
+    
+    # extract all <resourceProperty> tags from the resource and turn them
+    # into a hash in @properties.
+    def initialize_properties(properties)
+      @properties = Hash.new
+      properties.each do |prop|
+        @properties[prop['name']] = prop.inner_text.strip
+      end
+    end
+    
+    # extract all <resourceDescriptor> tags and turn them into Resource objects.
+    def initialize_resources(resources)
+      @resources = []
+      resources.each do |res|
+        @resources << Resources.new(res)
+      end
+    end
+  end
+  
+  # A crack at a Jasper Server client for the repository service.
+  #
+  # This client sits on top of several common Ruby APIs including
+  # the Savon SOAP API, XmlBuilder, and nokogiri.
+  class RepositoryService < ::Savon::Client
+  
+    # Set this to true if you'd like to have Savon log to stderr
+    ::Savon::Request.log = false;
+
+    # Request XML is built using the Request.
+    #
+    # A request looks like:
+    #
+    # <?xml version="1.0" encoding="utf-8"?>
+    # <soapenv:Envelope 
+    #     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
+    #     xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
+    #     xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" 
+    #     xmlns:axis="http://axis2.ws.jasperserver.jaspersoft.com">
+    #   <soapenv:Body>
+    #     <axis:list soapenv:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/">
+    #       <requestXmlString xsi:type="xsd:string">
+    #       <![CDATA[
+    #          <request operationName="list"> 
+    #            <argument name="LIST_RESOURCES"/> 
+    #            <argument name="RESOURCE_TYPE">reportUnit</argument> 
+    #            <argument name="START_FROM_DIRECTORY">/Reports/xforty</argument> 
+    #         </request>
+    #         ]]>
+    #       </requestXmlString>
+    #      </axis:list>
+    #   </soapenv:Body>
+    # </soapenv:Envelope>
+    #
+    # The soap envelope, body, and action (in this case axis:list) elements
+    # are automatically constructed by Savon.  The requestXmlString element and 
+    # sub elements are created by the build() method.  This method yields a builder
+    # that is expected to create the contents of the request element (the arugment 
+    # tags in this case).
+    class Request
+      attr_reader :name
+    
+      # Create a new Request.  The name passed is the
+      # request name (eg list, get, runReport).
+      def initialize(name)
+        @name = name
+      end
+    
+      # Takes a block which is yielded with an XML builder
+      # that represents the internal XML inside the <request>
+      # tags in the request.
+      def build(&block)
+        inner_xml = Builder::XmlMarkup.new :indent => 2
+        inner_xml.request 'operationName' => soap_method do |request|
+          yield request
+        end
+      
+        body = Builder::XmlMarkup.new :indent => 2
+        body.requestXmlString { |request_string| request_string.cdata! inner_xml.target! }
+      end
+    
+      # Returns the soap method name for this request.  
+      def soap_method
+        self.name.to_s.underscore
+      end
+    end
+
+    # A response subclass exists for each type of response.  There is a response type for
+    # each type of request (list, get, runReport).  Code common to all response types is
+    # put into the Response class, otherwise responses are named CamelizedRequestNameResponse.
+    # So for example ListResponse, GetResponse, RunReportResponse.
+    class Response
+      attr_reader :xml_doc, :resources
+    
+      # "0" if the request was successfully processed by the server.
+      def return_code
+        xml_doc.search('//returnCode').inner_text
+      end
+    
+      # return true if the response is successful.
+      def success?
+        "0" == return_code
+      end
+    
+      # return "OK" on success, since successful responses don't seem to have
+      # messages.  When the response is not successful, the message is pulled
+      # from the response xml.
+      def message
+        if success?
+          "OK"
+        else
+          xml_doc.search('//returnMessage/node()').inner_text
+        end
+      end
+      
+      # Search the response using xpath.  When this Responses xml_doc
+      # does not have a search method, a string with inner_text and inner_html
+      # methods are added.  The reson for this is so unwitting callers
+      # won't need to have the extra logic to make sure that that this response
+      # has a valid xml_doc.
+      def search(path)
+        return xml_doc.search(path) if xml_doc.respond_to?(:search)
+      
+        # return something that acts like a dom element (nokogiri)
+        x = ""
+        class << x
+          def inner_text; ""; end
+          alias inner_html inner_text
+        end
+        x
+      end
+      
+      # Extract resourceDescriptors from the response and drop them into @resources.
+      def collect_resources
+        @resources = @xml_doc.search('./resourceDescriptor').map { |r| Resource.new(r) }
+      end
+      
+      # Response from a list request.
+      class ListResponse < Response
+        # Initialize the list response from a Savon response.  The listReturn element is 
+        # pulled from the response, and each resourceDescriptor child of that element is
+        # collected into a list as each item in the list.
+        def initialize(savon_response)
+          soap_doc = Nokogiri::XML savon_response.to_xml
+          @xml_doc = Nokogiri::XML soap_doc.search('//listReturn/node()').inner_text
+          collect_resources
+        end
+      
+        # Get a list of items from the list response.  Each of the items in the list
+        # returned is a JasperClient::Resource.
+        def items
+          resources
+        end
+      end
+    
+      # Response from a get request.
+      class GetResponse < Response
+        # Initialize the list response from a Savon response.  The getReturn element is
+        # pulled from the response, and each resourceDescriptor is processed into info about
+        # the resource involved.
+        def initialize(savon_response)
+          savon_response.tap do |soap|
+            soap_doc = Nokogiri::XML soap.to_xml
+            @xml_doc = Nokogiri::XML soap_doc.search('//getReturn/node()').inner_text
+            collect_resources
+          end
+        end
+      end
+    
+      # Response from a runReport request.
+      class RunReportResponse < Response
+        attr_reader :http
+        def initialize(savon_response)
+          savon_response.tap do |soap|
+            @http = soap.http
+            xml = http.multipart? ? http.start_part : soap.http.body # soap.to_hash.fetch(:run_report_response).fetch(:run_report_return)
+            soap_doc = Nokogiri::XML xml
+            @xml_doc = Nokogiri::XML soap_doc.search('//runReportReturn/node()').inner_text
+          end
+        end
+        
+        # return the multipart related parts from the http response.
+        # When the response is not multipart, an empty list is returned.
+        def parts
+          http.multipart? ? http.parts : []
+        end
+      end
+    end
+  
+    attr_reader :wsdl_url, :username, :password
+  
+    # Initialize the JapserClient with a URL (points to the
+    # repository service), a username, and a password.
+    def initialize(wsdl_url, username, password)
+      @wsdl_url = wsdl_url.to_s
+      @username = username.to_s
+      @password = password.to_s
+      
+      super @wsdl_url
+      request.basic_auth @username, @password
+    end
+  
+    # return true if name indicates a supported request.
+    def supported_request?(name)
+      [:get, :list, :run_report].include? name.to_sym
+    end
+  
+    # Essentially a proxy to method_missing for Savon.  If the method call is
+    # to a known request type, build XML with a request object and then 
+    # execute the Savon request.
+    def method_missing(name, *params, &block)
+      if supported_request?(name)
+        req = Request.new(name)
+        request_xml = req.build(&block)
+      
+        savon_response = super(name) { |soap| soap.body = request_xml.to_s }
+        response_class = Response.const_get "%sResponse" % [ name.to_s.humpify.to_sym ]
+        response_class.new savon_response
+      else
+        super(name, params)
+      end
+    end
+  end
+end

data/lib/jasper-client/string.rb

@@ -0,0 +1,19 @@
+# Logic for both of these were lifted from the rails 
+# source tree. We don't call active support directly because
+# we didn't want to depend on those gems merely for these
+# two bits of functionality.
+class String
+  def underscore
+    word = self.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+  
+  def humpify
+    self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'jasper-client'
+
+class Test::Unit::TestCase
+end

data/test/test_jasper_client.rb

@@ -0,0 +1,98 @@
+require 'helper'
+
+class TestJasperClient < Test::Unit::TestCase
+  def setup_connection
+    wsdl = 'http://127.0.0.1:8080/jasperserver/services/repository?wsdl'
+    user = 'jasperadmin'
+    pass = user
+    JasperClient::RepositoryService.new(wsdl, user, pass)    
+  end
+  
+  def bad_connection
+    wsdl = 'http://127.0.0.1:8081/jasperserver/services/repository?wsdl'
+    user = 'jasperadmin'
+    pass = user
+    JasperClient::RepositoryService.new(wsdl, user, pass)
+  end
+  
+  should "respond to list requests" do 
+    client = setup_connection
+    response = client.list do |request|
+      request.argument :name => "LIST_RESOURCES"
+      request.argument 'reportUnit', :name => "RESOURCE_TYPE"
+      request.argument '/Reports/xforty', :name => 'START_FROM_DIRECTORY'
+    end
+
+    assert(response.return_code == "0")
+  end
+  
+  should "respond to get requests" do
+    client = setup_connection
+    response = client.get do |req|
+      req.resourceDescriptor :name => 'jrlogo', :wsType => 'img', :uriString => '/Reports/xforty/user_list', :isNew => 'false'
+    end
+    assert(response.return_code == "0")
+  end
+
+  should "respond to runReport requests" do
+    client = setup_connection
+    response = client.run_report do |req|
+      req.argument 'HTML', :name => 'RUN_OUTPUT_FORMAT'
+  
+      req.resourceDescriptor :name => 'JRLogo', 
+        :wsType => 'img', 
+        :uriString => '/reports/xforty/user_list', 
+        :isNew => 'false'
+    end
+    assert(response.return_code == "0")
+    assert(response.parts.count > 0)
+  end
+
+  should "should detect bad connection" do
+    assert_raise(Errno::ECONNREFUSED) do 
+      client = bad_connection
+      response = client.run_report do |req|
+        req.argument 'HTML', :name => 'RUN_OUTPUT_FORMAT'
+  
+        req.resourceDescriptor :name => 'JRLogo', 
+          :wsType => 'img', 
+          :uriString => '/reports/xforty/user_list', 
+          :isNew => 'false'
+      end
+    end
+  end
+
+  should "produce string message when report path is bad" do 
+    client = setup_connection
+    response = client.run_report do |req|
+      req.resourceDescriptor :name => 'jrlogo', :wsType => 'img', :uriString => '/Reports/xfortys/user_list', :isNew => 'false'
+    end
+    
+    assert(response.message.class == String)
+  end
+
+  should "return valid message on bad report path" do 
+    client = setup_connection
+    response = client.run_report do |req|
+      req.resourceDescriptor :name => 'jrlogo', :wsType => 'img', :uriString => '/Reports/xfortys/user_list', :isNew => 'false'
+    end
+    
+    assert(response.message.length > 0)
+  end
+  
+  should "fetch on a bad resource path should be unsuccessful" do
+    client = setup_connection
+    response = client.run_report do |req|
+      req.resourceDescriptor :name => 'jrlogo', :wsType => 'img', :uriString => '/Reports/xfortys/user_list', :isNew => 'false'
+    end
+    assert(response.success? == false)
+  end
+
+  should "fetch on a bad resource path should have non 'OK' message" do
+    client = setup_connection
+    response = client.run_report do |req|
+      req.resourceDescriptor :name => 'jrlogo', :wsType => 'img', :uriString => '/Reports/xfortys/user_list', :isNew => 'false'
+    end
+    assert(response.message != 'OK')
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: jasper-client
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andrew Libby
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-01 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Client for JasperServer
+email: alibby@xforty.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/jasper-client.rb
+- lib/jasper-client/http_multipart.rb
+- lib/jasper-client/jasper_client.rb
+- lib/jasper-client/string.rb
+- test/helper.rb
+- test/test_jasper_client.rb
+has_rdoc: true
+homepage: http://github.com/alibby/jasper-client
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Client for JasperServer
+test_files: 
+- test/helper.rb
+- test/test_jasper_client.rb