ape 1.0.0 → 1.5.0

data/lib/ape/validator.rb

@@ -1,65 +1,93 @@
-#   Copyright © 2006 Sun Microsystems, Inc. All rights reserved
-#   Use is subject to license terms - see file "LICENSE"
-
-if RUBY_PLATFORM =~ /java/
-  require 'java'
-  CompactSchemaReader = com.thaiopensource.validate.rng.CompactSchemaReader
-  ValidationDriver = com.thaiopensource.validate.ValidationDriver
-  StringReader = java.io.StringReader
-  StringWriter = java.io.StringWriter
-  InputSource = org.xml.sax.InputSource
-  ErrorHandlerImpl = com.thaiopensource.xml.sax.ErrorHandlerImpl
-  PropertyMapBuilder = com.thaiopensource.util.PropertyMapBuilder
-  ValidateProperty = com.thaiopensource.validate.ValidateProperty
-end
-
 module Ape
-class Validator
-
-  attr_reader :error
-
-  def Validator.validate(schema, text, name, ape)
-    # Can do this in JRuby, not native Ruby (sigh)
-    if RUBY_PLATFORM =~ /java/
-      rnc_validate(schema, text, name, ape)
-    else
-      true
-    end
-  end
-
-  def Validator.rnc_validate(schema, text, name, ape)
-    schemaError = StringWriter.new
-    schemaEH = ErrorHandlerImpl.new(schemaError)
-    properties = PropertyMapBuilder.new
-    properties.put(ValidateProperty::ERROR_HANDLER, schemaEH)
-    error = nil
-    driver = ValidationDriver.new(properties.toPropertyMap, CompactSchemaReader.getInstance)
-    if driver.loadSchema(InputSource.new(StringReader.new(schema)))
-      begin
-        if !driver.validate(InputSource.new(StringReader.new(text)))
-          error = schemaError.toString
+  require 'rexml/document'
+  class ValidationError < StandardError ; end
+  
+  class Validator
+    require File.dirname(__FILE__) + '/validator_dsl.rb'
+    include Ape::ValidatorDsl
+    include Ape::Util
+    
+    attr_accessor :reporter, :authent
+    
+    def self.custom_validators(reporter, authent)
+      validators = []
+      Dir[Ape.home + '/validators/*.rb'].each do |v|
+        require v
+        class_name = v.gsub(/(.+\/validators\/)(.+)(.rb)/, '\2').gsub(/(^|_)(.)/) { $2.upcase }
+        validator = eval("#{class_name}.new", binding, __FILE__, __LINE__)
+        if validator.enabled?
+          validator.reporter = reporter
+          validator.authent = authent
+          validators << validator
         end
-      rescue org.xml.sax.SAXParseException
-        error = $!.to_s.sub(/\n.*$/, '')
       end
-    else
-      error = schemaError.toString
+      validators
     end
-
-    if !error
-      ape.good "#{name} passed schema validation."
-      true
-    else
-      # this kind of sucks, but I spent a looong time lost in a maze of twisty
-      #  little passages without being able to figure out how to
-      #  tell jing what name I'd like to call the InputSource
-      ape.error "#{name} failed schema validation:\n" + error.gsub('(unknown file):', 'Line ')
-      false
+    
+    def self.instance(key, reporter, authent = nil)
+      validator = resolve_plugin(key, 'validators', 'validator')
+      raise ValidationError, "Unknown validator #{key}" unless validator
+      validator.reporter = reporter
+      validator.authent = authent
+      validator
     end
+    
+=begin
+    Each validator implements its own bussiness logic. This method is executed by the main script
+  in order to assure that some aspect of atomPub implementation is correct
+=end
+    def validate(opts = {})
+      raise ValidationError, "superclass doesn't implement this method"
+    end
+    
+protected
+    # Fetch a feed and look up an entry by ID in it
+    def find_entry(feed_uri, name, id, report=false)
+      entries = Feed.read(feed_uri, name, reporter, report)
+      entries.each do |from_feed|
+        return from_feed if id == from_feed.child_content('id')
+      end
 
+      return "Couldn't find id #{id} in feed #{feed_uri}"
+    end
+    
+    def delete_entry(entry, name = nil)
+      link = entry.link('edit', self)
+      unless link
+        reporter.error(self, "Can't delete entry without edit link")
+        return false
+      end
+      deleter = Deleter.new(link, @authent)
+      worked = deleter.delete
+      
+      reporter.save_dialog(name, deleter) if name
+      if worked
+        reporter.success(self, "Entry deletion reported success.", name)
+      else
+        reporter.error(self, "Couldn't delete the entry: " + deleter.last_error, name)
+      end
+      return worked
+    end
+    
+    def method_missing(name, *args)
+      if (name == :enabled?)
+        new_method = self.class.send(:define_method, 'enabled?') do
+          return true
+        end
+      elsif (name == :deterministic?)
+        new_method = self.class.send(:define_method, 'deterministic?') do
+          return false
+        end
+      elsif (name == :manifest)
+        new_method = self.class.send(:define_method, 'manifest') do
+          return []
+        end
+      else
+        super
+      end
+      new_method.call(args) if new_method
+    end
+    
   end
-
+  Dir[File.dirname(__FILE__) + '/validators/*.rb'].each { |l| require l }
 end
-end
-
-

data/lib/ape/validator_dsl.rb

@@ -0,0 +1,40 @@
+module Ape
+  module ValidatorDsl
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def enabled
+        define_method('enabled?') do
+          return true
+        end
+      end
+      
+      def disabled
+        define_method('enabled?') do
+          return false
+        end
+      end
+
+      def deterministic
+        define_method('deterministic?') do
+          return true
+        end
+      end
+      
+      def nondeterministic
+        define_method('deterministic?') do
+          return false
+        end
+      end
+      
+      def requires_presence_of(*args)
+        define_method('manifest') do
+          return args
+        end
+      end
+    end
+    
+  end
+end

data/lib/ape/validators/entry_posts_validator.rb

@@ -0,0 +1,226 @@
+module Ape
+  class EntryPostsValidator < Validator
+    disabled
+    requires_presence_of :entry_collection
+    
+    def validate(opts = {})
+      entry_collection = opts[:entry_collection]
+      reporter.info(self, "Will use collection '#{entry_collection.title}' for entry creation.")
+      
+      collection_uri = entry_collection.href
+      entries = Feed.read(collection_uri, 'Entry collection', reporter)
+      
+      # * List the current entries, remember which IDs we've seen
+      reporter.info(self, "TESTING: Entry-posting basics.")
+      ids = []
+      unless entries.empty?
+        reporter.start_list(self, "Now in the Entries feed")
+        entries.each do |entry|
+          reporter.list_item(entry.summarize)
+          ids << entry.child_content('id')
+        end        
+      end 
+      
+      # Setting up to post a new entry
+      poster = Poster.new(collection_uri, @authent)
+      if poster.last_error
+        reporter.error(self, "Unacceptable URI for '#{entry_collection.title}' collection: " +
+            poster.last_error)
+        return
+      end
+
+      my_entry = Entry.new(Samples.basic_entry)
+
+      # ask it to use this in the URI
+      slug_num = rand(100000)
+      slug = "ape-#{slug_num}"
+      slug_re = %r{ape.?#{slug_num}}
+      poster.set_header('Slug', slug)
+
+      # add some categories to the entry, and remember which
+      @cats = Categories.add_cats(my_entry, entry_collection, @authent, reporter)
+
+      # * OK, post it
+      worked = poster.post(Names::AtomEntryMediaType, my_entry.to_s)
+      name = 'Posting new entry'
+      reporter.save_dialog(name, poster)
+      if !worked
+        reporter.error(self, "Can't POST new entry: #{poster.last_error}", name)
+        return
+      end
+
+      location = poster.header('Location')
+      unless location
+        reporter.error(self, "No Location header upon POST creation", name)
+        return
+      end
+      reporter.success(self, "Posting of new entry to the Entries collection " +
+          "reported success, Location: #{location}", name)
+
+      reporter.info(self, "Examining the new entry as returned in the POST response")
+      check_new_entry(my_entry, poster.entry, "Returned entry") if poster.entry
+
+      # * See if the Location uri can be retrieved, and check its consistency
+      name = "Retrieval of newly created entry"
+      new_entry = check_resource(location, name, Names::AtomMediaType)
+      return unless new_entry
+
+      # Grab its etag
+      etag = new_entry.header 'etag'
+
+      reporter.info(self, "Examining the new entry as retrieved using Location header in POST response:")
+
+      begin
+        new_entry = Entry.new(new_entry.body, location)
+      rescue REXML::ParseException
+        prob = $!.to_s.gsub(/\n/, '<br/>')
+        reporter.error(self, "New entry is not well-formed: #{prob}")
+        return
+      end
+
+      # * See if the slug was used
+      slug_used = false
+      new_entry.alt_links.each do |a|
+        href = a.attributes['href']
+        if href && href.index(slug_re)
+          slug_used = true
+        end
+      end
+      if slug_used
+        reporter.success(self, "Client-provided slug '#{slug}' was used in server-generated URI.")
+      else
+        reporter.warning(self, "Client-provided slug '#{slug}' not used in server-generated URI.")
+      end
+
+      check_new_entry(my_entry, new_entry, "Retrieved entry")
+
+      entry_id = new_entry.child_content('id')
+
+      # * fetch the feed again and check that version
+      from_feed = find_entry(collection_uri, "entry collection", entry_id)
+      if from_feed.class == String
+        reporter.success(self, "About to check #{collection_uri}")
+        Feed.read(collection_uri, "Can't find entry in collection", reporter)
+        reporter.error(self, "New entry didn't show up in the collections feed.")
+        return
+      end
+
+      reporter.info(self, "Examining the new entry as it appears in the collection feed:")
+
+      # * Check the entry from the feed
+      check_new_entry(my_entry, from_feed, "Entry from collection feed")
+     
+      edit_uri = new_entry.link('edit', self)
+      if !edit_uri
+        reporter.error(self, "Entry from Location header has no edit link.")
+        return
+      end
+
+      # * Update the entry, see if the update took
+      name = 'In-place update with put'
+      putter = Putter.new(edit_uri, @authent)
+
+      # Conditional PUT if an etag
+      putter.set_header('If-Match', etag) if etag
+
+      new_title = "Let’s all do the Ape!"
+      new_text = Samples.retitled_entry(new_title, entry_id)
+      response = putter.put(Names::AtomEntryMediaType, new_text)
+      reporter.save_dialog(name, putter)
+
+      if response
+        reporter.success(self, "Update of new entry reported success.", name)
+        from_feed = find_entry(collection_uri, "entry collection", entry_id)
+        if from_feed.class == String
+          check_resource(collection_uri, "Check collection after lost update")
+          reporter.error(self, "Updated entry ID #{entry_id} not found in entries collection.")
+          return
+        end
+        if from_feed.child_content('title') == new_title
+          reporter.success(self, "Title of new entry successfully updated.")
+        else
+          reporter.warning(self, "After PUT update of title, Expected " +
+            "'#{new_title}', but saw '#{from_feed.child_content('title')}'")
+        end
+      else
+        reporter.warning(self,"Can't update new entry with PUT: #{putter.last_error}", name)
+      end
+
+      # the edit-uri might have changed
+      return unless delete_entry(from_feed, 'New Entry deletion')
+
+      # See if it's gone from the feed
+      still_there = find_entry(collection_uri, "entry collection", entry_id)
+      if still_there.class != String
+        reporter.error(self, "Entry is still in collection post-deletion.")
+      else
+        reporter.success(self, "Entry not found in feed after deletion.")
+      end
+      
+    end
+    
+    def check_new_entry(as_posted, new_entry, desc)
+
+      if compare_entries(as_posted, new_entry, "entry as posted", desc)
+        reporter.success(self, "#{desc} is consistent with posted entry.")
+      end
+
+      # * See if the categories we sent made it in
+      cat_probs = false
+      @cats.each do |cat|
+        if !new_entry.has_cat(cat)
+          cat_probs = true
+          reporter.warning(self, "Provided category not in #{desc}: #{cat}")
+        end
+      end
+      reporter.success(self, "Provided categories included in #{desc}.") unless cat_probs
+
+      # * See if the dc:subject survived
+      dc_subject = new_entry.child_content(Samples.foreign_child, Samples.foreign_namespace)
+      if dc_subject
+        if dc_subject == Samples.foreign_child_content
+          reporter.success(self, "Server preserved foreign markup in #{desc}.")
+        else
+          reporter.warning(self, "Server altered content of foreign markup in #{desc}.")
+        end
+      else
+        reporter.warning(self, "Server discarded foreign markup in #{desc}.")
+      end
+    end
+
+    def compare_entries(e1, e2, e1Name, e2Name)
+      problems = 0
+      [ 'title', 'summary', 'content' ].each do |field|
+        problems += 1 if compare1(e1, e2, e1Name, e2Name, field)
+      end
+      return problems == 0
+    end
+
+    def compare1(e1, e2, e1Name, e2Name, field)
+      c1 = e1.child_content(field)
+      c2 = e2.child_content(field)
+      if c1 != c2
+        problem = true
+        if c1 == nil
+          reporter.warning(self, "'#{field}' absent in #{e1Name}.")
+        elsif c2 == nil
+          reporter.warning(self, "'#{field}' absent in #{e2Name}.")
+        else
+          t1 = e1.child_type(field)
+          t2 = e2.child_type(field)
+          if t1 != t2
+            reporter.warning(self, "'#{field}' has type='#{t1}' " +
+              "in #{e1Name}, type='#{t2}' in #{e2Name}.")
+          else
+            c1 = Escaper.escape(c1)
+            c2 = Escaper.escape(c2)
+            reporter.warning(self, "'#{field}' in #{e1Name} [#{c1}] " +
+              "differs from that in #{e2Name} [#{c2}].")
+          end
+        end
+      end
+      return problem
+    end
+    
+  end
+end

data/lib/ape/validators/media_linkage_validator.rb

@@ -0,0 +1,78 @@
+module Ape
+  class MediaLinkageValidator < Validator
+    disabled
+    requires_presence_of :media_collection
+    
+    def validate(opts = {})
+      reporter.info(self, "TESTING: Media collection re-ordering after PUT.")
+      coll = opts[:media_collection]
+      
+      # We'll post three mini entries to the collection
+      data = Samples.picture
+      poster = Poster.new(coll.href, @authent)
+      ['One', 'Two', 'Three'].each do |num|
+        slug = "Picture #{num}"
+        poster.set_header('Slug', slug)
+        name = "Posting pic #{num}"
+        worked = poster.post('image/jpeg', data)
+        reporter.save_dialog(name, poster)
+        if !worked
+          reporter.error(self, "Can't POST Picture #{num}: #{poster.last_error}", name)
+          return
+        end
+        sleep 2
+      end
+      
+      # grab the collection to gather the MLE ids
+      entries = Feed.read(coll.href, 'Pictures from multi-post', reporter)
+      if entries.size < 3 
+        reporter.error(self, "Pictures apparently not in collection")
+        return
+      end
+        
+      ids = entries.map { |e| e.child_content('id)') }
+      
+      # let's update one of them; have to fetch it first to get the ETag
+      two_media = entries[1].link('edit-media')
+      if !two_media
+        reporter.error(self, "Second entry from feed doesn't have an 'edit-media' link.")
+        return
+      end
+      two_resp = check_resource(two_media, 'Fetch image to get ETag', 'image/jpeg')
+      unless two_resp
+        reporter.error(self, "Can't fetch image to get ETag")
+        return
+      end
+      etag = two_resp.header 'etag'
+          
+      putter = Putter.new(two_media, @authent)
+      putter.set_header('If-Match', etag)
+      
+      name = 'Updating one of three pix with PUT'
+      if putter.put('image/jpeg', data)
+        reporter.success(self, "Update one of newly posted pictures went OK.")
+      else  
+        reporter.save_dialog(name, putter)
+        reporter.error(self, "Can't update picture at #{two_media}", name)
+        return
+      end
+      
+      # now the order should have changed
+      wanted = [ ids[2], ids[0], ids[1] ]
+      entries = Feed.read(coll.href, 'MLEs post-update', reporter)
+      entries.each do |from_feed|
+        want = wanted.pop
+        unless from_feed.child_content('id').eql?(want)
+          reporter.error(self, "Updating bits failed to re-order link entries in media collection.")
+          return
+        end
+        
+        # next to godliness
+        delete_entry(from_feed)
+        
+        break if wanted.empty?
+      end
+      reporter.success(self, "Entries correctly ordered after update of multi-post.")
+    end
+  end
+end