testability-driver 1.0.3 → 1.0.4

data/lib/tdriver/base/test_object/adapter.rb

@@ -27,96 +27,89 @@ module TDriver
       private
 
     		# special cases: allow partial match when value of type and attribute name matches
-        @@partial_match_allowed = [ 'list_item', 'text' ], ['application', 'fullname' ]
+        @@partial_match_allowed = [ 'list_item', 'text' ], [ 'application', 'fullname' ]
  
+        # TODO: document me
         def xpath_attributes( attributes, element_attributes, object_type )
-        
+
+          # collect attributes
           attributes = attributes.collect{ | key, values |
 
-            values = ( values.kind_of?( Array ) ? values : [ values ] ).collect{ | value |
+            # allow multiple values options for attribute, e.g. object which 'text' attribute value is either '1' or '2' 
+            ( values.kind_of?( Array ) ? values : [ values ] ).collect{ | value |
             
               # concatenate string if it contains single and double quotes, otherwise return as is
               value = xpath_literal_string( value )
 
               if @@partial_match_allowed.include?( [ object_type, key ] )
-            
-                # partial match allowed
-    						value = "[contains(.,#{ value })]"
-            
-              else
-              
-                # exact match required
-    						value = "=#{ value }"
-
-              end
-
-              if element_attributes
-              
-                prefix = "@#{key}#{value} or " 
+                
+                prefix_value = "[contains(.,#{ value })]"
+                attribute_value = "contains(value/text(),#{ value })"
               
               else
 
-                prefix = "" 
+                prefix_value = "=#{ value }"
+                attribute_value = "value/text()=#{ value }"
               
               end
-  
-              "#{ prefix }attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{key}' and .#{value}]"
-                  
-            }.join( " or " )
+
+              # construct xpath
+              "(#{ element_attributes ? "@#{ key }#{ prefix_value } or " : "" }attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ key }' and #{ attribute_value }])"
+     
+            }.join( ' or ' ) # join attribute alternative values
                     
-          }
+          }.join( ' and ' ) # join all required attributes
+                    
+          # return created xpath or nil if no attributes given 
+          if attributes.empty?
           
-          result = attributes.join(' and ')
-
-          if result.empty?
+            # no attributes given
+            nil
           
-            result = nil
-
           else
-
-            result = "(#{ result })" if element_attributes
+          
+            # return result 
+            attributes
           
           end
           
-          result
-                  
-        end
+        end # xpath_attributes
       
-    
-    end
+    end # static
 
     # TODO: document me
     def self.xpath_to_object( rules, find_all_children )
 
       # convert hash keys to downcased string
-      rules = Hash[ rules.collect{ | key, value | [ key.to_s.downcase, value ] } ]
+      rules = Hash[ rules.collect{ | key, value | [ key.to_s.downcase, value.to_s ] } ]
 
-      test_object_identification_attributes_array = []
+      # xpath container array
+      test_object_xpath_array = []
 
       # store and remove object element attributes from hash
-      object_element_attributes = rules.delete_keys!( "name", "type", "parent", "id" )
+      object_element_attributes = rules.delete_keys!( 'name', 'type', 'parent', 'id' )
 
-      # TODO: change "any" to "*"
       # children method may request test objects of any type
-      if object_element_attributes[ "type" ] == 'any' 
+      if object_element_attributes[ 'type' ] == '*' 
 
         # test object with any name, type, parent and id is allowed
-        test_object_identification_attributes_array << '@*'
+        test_object_xpath_array << '@*'
 
       else
 
         # required attributes          
-        test_object_identification_attributes_array << xpath_attributes( object_element_attributes, true, object_element_attributes[ "type" ] )
+        test_object_xpath_array << xpath_attributes( object_element_attributes, true, object_element_attributes[ 'type' ] )
       
       end
 
       # additional attributes, eg. :text, :x, :y etc. 
-      test_object_identification_attributes_array << xpath_attributes( rules, false, object_element_attributes[ "type" ] )
+      test_object_xpath_array << xpath_attributes( rules, false, object_element_attributes[ 'type' ] )
 
       # join required and additional attribute strings
-      test_object_identification_attributes = test_object_identification_attributes_array.compact.join(" and ")
+      test_object_xpath_string = test_object_xpath_array.compact.join( ' and ' )
 
-      find_all_children ? "*//object[#{ test_object_identification_attributes }]" : "objects[1]/object[#{ test_object_identification_attributes }]"
+      # return any child element under current node or only immediate child element 
+      find_all_children ? "*//object[#{ test_object_xpath_string }]" : "objects[1]/object[#{ test_object_xpath_string }]"
     
     end
 
@@ -183,54 +176,70 @@ module TDriver
     # TODO: document me
     def self.get_objects( source_data, rules, find_all_children )
 
-      rule = xpath_to_object( rules, find_all_children )
-
       [ 
         # perform xpath to source xml data
-        source_data.xpath( rule ),
+        source_data.xpath( rule = xpath_to_object( rules, find_all_children ) ),
+
+        # return also created xpath  
         rule 
       ]    
     
     end
 
+    # TODO: document me
     def self.test_object_hash( object_id, object_type, object_name )
     
+      # calculate test object hash
       ( ( ( 17 * 37 + object_id ) * 37 + object_type.hash ) * 37 + object_name.hash )
 
     end
 
     # Sort XML nodeset of test objects with layout direction
-    def self.sort_elements( nodeset, layout_direction = "LeftToRight" )
+    def self.sort_elements( nodeset, layout_direction = 'LeftToRight' )
 
-      attribute_pattern = "./attributes/attribute[@name='%s']/value/text()"
+      attribute_pattern = './attributes/attribute[@name="%s"]/value/text()'
 
       # collect only nodes that has x_absolute and y_absolute attributes
       nodeset.collect!{ | node |
 
-        #node unless node.at_xpath( attribute_pattern % 'x_absolute' ).to_s.empty? || node.at_xpath( attribute_pattern % 'y_absolute' ).to_s.empty?
-        node unless node.at_xpath( attribute_pattern % 'x_absolute' ).nil? || node.at_xpath( attribute_pattern % 'y_absolute' ).nil?
+        if node.at_xpath( attribute_pattern % 'x_absolute' ).nil? || node.at_xpath( attribute_pattern % 'y_absolute' ).nil?
+
+          #warn("Warning: Unable to sort object set due to object type of #{ node.attribute( 'type' ).inspect } does not have \"x_absolute\" or \"y_absolute\" attribute")
+
+          return nodeset
+
+        else
+
+          node
+
+        end
 
       }.compact!.sort!{ | element_a, element_b |
 
+        # retrieve element a's attributes x and y
         element_a_x = element_a.at_xpath( attribute_pattern % 'x_absolute' ).content.to_i
         element_a_y = element_a.at_xpath( attribute_pattern % 'y_absolute' ).content.to_i
 
+        # retrieve element b's attributes x and y
         element_b_x = element_b.at_xpath( attribute_pattern % 'x_absolute' ).content.to_i
         element_b_y = element_b.at_xpath( attribute_pattern % 'y_absolute' ).content.to_i
 
         case layout_direction
         
-          when "LeftToRight"
+          when 'LeftToRight'
 
+            # compare elements
             ( element_a_y == element_b_y ) ? ( element_a_x <=> element_b_x ) : ( element_a_y <=> element_b_y ) 
 
-          when "RightToLeft"
+          when 'RightToLeft'
 
+            # compare elements
             ( element_a_y == element_b_y ) ? ( element_b_x <=> element_a_x ) : ( element_a_y <=> element_b_y ) 
 
         else
 
-          Kernel::raise ArgumentError.new( "Unsupported layout direction #{ layout_direction.inspect }" )
+          # raise exception if layout direction it not supported 
+          Kernel::raise ArgumentError, "Unsupported layout direction #{ layout_direction.inspect }"
 
         end
 
@@ -257,24 +266,32 @@ module TDriver
     end
 
     # TODO: document me
-    def self.test_object_element_attribute( source_data, name, &block )
+    def self.test_object_element_attribute( source_data, attribute_name, *default, &block )
 
-      result = source_data.attribute( name )
+      result = source_data.attribute( attribute_name )
       
+      # if no attribute found call optional code block or raise exception 
       unless result
             
         if block_given?
-        
-          yield
+          
+          # pass return value of block as result
+          yield( attribute_name )
         
         else
         
-          # raise exception if no such attribute found
-          Kernel::raise MobyBase::AttributeNotFoundError.new(
+          # raise exception if no default value given
+          if default.empty?
+        
+            # raise exception if no such attribute found
+            Kernel::raise MobyBase::AttributeNotFoundError, "Could not find test object element attribute #{ attribute_name.inspect }"
+
+          else
           
-            "Could not find test object element attribute #{ attribute_name.inspect }"
-            
-          )
+            # pass default value as result
+            default.first
+          
+          end
         
         end
       
@@ -287,14 +304,14 @@ module TDriver
     end
 
     # TODO: document me
-    def self.test_object_attribute( source_data, attribute_name, &block )
+    def self.test_object_attribute( source_data, attribute_name, *default, &block )
 
       # TODO: consider using at_xpath and adding /value/text() to query string; however "downside" is that if multiple matches found only first value will be returned as result
 
       # retrieve attribute(s) from xml
       nodeset = source_data.xpath(
        
-        "attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ attribute_name.downcase }']" # /value/text()"
+        "attributes/attribute[translate(@name,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz')='#{ attribute_name.downcase }']"
         
       )
 
@@ -304,20 +321,26 @@ module TDriver
         if block_given?
 
           # pass return value of block as result
-          yield
+          yield( attribute_name )
 
         else
 
-          # raise exception if no such attribute found
-          Kernel::raise MobyBase::AttributeNotFoundError.new(
+          # raise exception if no default value given
+          if default.empty?
           
-            "Could not find attribute #{ attribute_name.inspect }" # for test object of type #{ type.to_s }"
-            
-          )
+            # raise exception if no such attribute found
+            Kernel::raise MobyBase::AttributeNotFoundError, "Could not find attribute #{ attribute_name.inspect }" # for test object of type #{ type.to_s }"
+
+          else
           
-        end
+            # pass default value as result
+            default.first
+          
+          end
+          
+        end # block_given?
 
-      else
+      else # not nodeset.empty?
       
         # attribute(s) found
         # Need to disable this for now 
@@ -331,17 +354,33 @@ module TDriver
     end
 
     # TODO: document me
-    def self.test_object_attributes( source_data )
-    
+    def self.test_object_attributes( source_data, inclusive_filter = [] )
+      
+      # convert all keys to lowercase
+      inclusive_filter.collect!{ | key | key.to_s.downcase } unless inclusive_filter.empty?
+      
       # return hash of test object attributes
       Hash[ 
 
         # iterate each attribute and collect name and value      
-        source_data.xpath( 'attributes/attribute' ).collect{ | test_object | 
+        source_data.xpath( 'attributes/attribute/value' ).collect{ | value | 
 
-          [ test_object.attribute( 'name' ), test_object.at_xpath( 'value/text()' ).to_s ]
+          # retrieve attribute name
+          name = value.parent.attribute('name').to_s
 
-        } 
+          # collect attribute elements name and content
+          unless inclusive_filter.empty?
+          
+            [ name, value.content ] if inclusive_filter.include?( name.downcase )
+                    
+          else
+
+            # pass the attribute pair - no filtering done
+            [ name, value.content ]
+          
+          end
+
+        }
 
       ]
 
@@ -372,7 +411,8 @@ module TDriver
       # iterate through each child object type attribute and create accessor method  
       source_data.xpath( 'objects/object/@type' ).each{ | object_type |
 
-        next if object_type.nil?
+        # skip if object type value is nil or empty due to child accessor cannot be created
+        next if object_type.nil? || object_type.to_s.empty?
 
         # convert attribute node value to string
         object_type = object_type.content
@@ -383,7 +423,7 @@ module TDriver
         # create child accessor method to test object unless already exists
         test_object.instance_eval(
 
-          "def #{object_type}(rules={}); raise TypeError,'parameter <rules> should be hash' unless rules.kind_of?(Hash); rules[:type]=:#{object_type}; child(rules); end;"
+          "def #{ object_type }( rules = {} ); raise TypeError,'parameter <rules> should be hash' unless rules.kind_of?( Hash ); rules[ :type ]=:#{ object_type }; child( rules ); end;"
 
         ) unless object_type.empty?
 
@@ -391,8 +431,179 @@ module TDriver
 
     end
 
+    # TODO: document me
+    def self.state_object_xml( source_data, id )
+    
+      # collect each object from source xml
+      objects = source_data.xpath( 'tasInfo/object' ).collect{ | element | element.to_s }.join
+    
+      # return xml root element
+      MobyUtil::XML.parse_string( 
+        "<sut name='sut' type='sut' id='#{ id }'><objects>#{ objects }</objects></sut>"
+      ).root
+    
+    end
+
+    def self.retrieve_parent_application( xml_source )
+
+      xml_source_iterator = xml_source.clone
+
+      while xml_source_iterator.kind_of?( MobyUtil::XML::Element )
+
+        if ( test_object_element_attribute( xml_source_iterator, 'type' ) == 'application' )
+
+          return xml_source_iterator
+
+        end
+
+        if xml_source_iterator.kind_of?( MobyUtil::XML::Element )
+
+          xml_source_iterator = xml_source_iterator.parent.parent
+
+        else
+        
+          # not found from xml tree
+          break
+        
+        end
+
+      end
+
+      #warn("warning: unable to retrieve parent application")
+
+      raise MobyBase::TestObjectNotFoundError, "Unable to retrieve parent application"
+
+      # return application object or nil if no parent found
+      # Does is make sense to return nil - shouldn't all test objects belong to an application? Maybe throw exception if application not found
+      
+      #nil
+    
+      #return @sut.child( :type => 'application' ) rescue nil
+          
+    end
+    
+    # TODO: document me
+    def self.get_xml_element_for_test_object( test_object )
+      
+      # retrieve nodeset from sut xml_data
+      nodeset = test_object.instance_variable_get( :@sut ).xml_data.xpath( test_object.instance_variable_get( :@x_path ) )
+
+      # raise exception if no test objects found 
+			Kernel::raise MobyBase::TestObjectNotFoundError if nodeset.empty?
+			
+      # return first test object from the nodeset
+			nodeset.first
+    
+    end
+
+    # TODO: document me    
+    def self.get_test_object_identifiers( xml_source, test_object = nil )
+
+      # retrieve parent xpath if test_object given
+      parent_xpath = test_object ? test_object.instance_variable_get( :@parent ).x_path : ""
+    
+      # retrieve type attribute
+      type = xml_source.attribute( 'type' )
+
+      # retrieve id attribute
+      id = xml_source.attribute( 'id' )
+
+      # retrieve env attribute
+      env = xml_source.attribute( 'env' )
+
+      # retrieve test object element attributes and return array containting xpath to test object, name, type and id elements
+      [ 
+        # x_path to test object
+        test_object ? "#{ parent_xpath }/*//object[@type='#{ type }' and @id='#{ id }']" : nil,
+
+        # test object name 
+        xml_source.attribute( 'name' ),
+        
+        # test object type 
+        type,
+        
+        # test object id 
+        id,
+
+        env
+        
+      ]
+
+    end
+
+    # TODO: document me
+    def self.hash_to_element_attributes( hash )
+
+      hash.collect{ | key, value | 
+
+        "#{ key.to_s }=\"#{ value.to_s }\"" 
+
+      }.join(' ')
+
+    end
+
+	  # TODO: document me
+    def self.merge_application_elements( xml_string )
+    
+      # parse the ui state xml
+      document_root = MobyUtil::XML.parse_string( xml_string ).root
+
+      # retrieve application objects as nodeset
+      nodeset = document_root.xpath('/tasMessage/tasInfo/object')
+
+      # check if multiple application objects found
+      if nodeset.count > 1
+
+        # new header, apply original element attributes
+        new_xml = "<tasMessage #{ hash_to_element_attributes( document_root.attributes )  }><tasInfo #{ hash_to_element_attributes( nodeset.first.parent.attributes ) }>"
+
+        # flag defining that is application element already created
+        application_element_set = false
+
+        # collect environment values
+        environments = document_root.xpath('/tasMessage/tasInfo/object[@type="application"]/@env').collect{ | attribute | attribute.to_s }
+
+        # iterate through each object found in xml
+        nodeset.each{ | object |        
+  
+          # only one application element
+          unless application_element_set
+          
+            #application_objects << object
+
+            # retrieve object attributes
+            attributes = object.attributes
+
+            # merge env to attributes hash
+            attributes['env'] = environments.join(';')
+
+            # add application object xml element to new xml string
+            new_xml << "<object #{ hash_to_element_attributes( attributes ) }>"
+          
+            # application element is now set, no need to do it again
+            application_element_set = true
+            
+          end
+
+          # append all found elements
+          object.xpath('./*').each{ | object | new_xml << object.to_s }
+          
+        }
+
+        # multiple applications found, return merged application xml
+        new_xml << "</object></tasInfo></tasMessage>"
+
+      else
+      
+        # only one application found, return data as is
+        xml_string
+      
+      end
+
+    end
+
     # enable hooking for performance measurement & debug logging
-    MobyUtil::Hooking.instance.hook_methods( self ) if defined?( MobyUtil::Hooking )
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
   end # TestObjectAdapter