georgebrock-assert-microformats 0.1.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 George Brocklehurst
+
+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.markdown

@@ -0,0 +1,23 @@
+# AssertMicroformats #
+
+A Rails plugin to test pages that contain microformats.  Assert that certain microformats are present in the page, and that they have certain properties.
+
+
+## Setup ##
+
+    # In config/environments/test.rb
+    config.gem "georgebrock-assert-microformats", :source => "http://gems.github.com/", :lib => false
+
+## Example ##
+
+    # Ensure @response contains an hCard
+    assert_mf_hcard
+
+    # Ensure @response contains an hCard with fn set to 'George Brocklehurst'
+    assert_mf_hcard :fn => 'George Brocklehurst'
+
+    # Ensure the HTML in my_html contains an hCalendar event with summary set to 'My party'
+    assert_mf_hcalendar my_html, :summary => 'My party'
+
+
+Copyright &copy; 2009 <span class="vcard"><a href="http://georgebrock.com" class="url">George Brocklehurst</a></span>, released under the MIT license

data/Rakefile

@@ -0,0 +1,45 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require "rake/gempackagetask"
+require 'rubygems'
+
+spec = Gem::Specification.new do |s|
+  s.name              = "assert-microformats"
+  s.version           = "0.1.2"
+  s.summary           = "A Rails plugin to help with testing the presence and correctness of microformats markup"
+  s.author            = "George Brocklehurst"
+  s.email             = "george.brocklehurst@gmail.com"
+  s.homepage          = "http://github.com/georgebrock"
+  s.has_rdoc          = true
+  s.extra_rdoc_files  = %w(README.markdown)
+  s.rdoc_options      = %w(--main README.markdown)
+  s.files             = %w(MIT-LICENSE README.markdown Rakefile) + Dir.glob("{test,lib,rails}/**/*")
+  s.require_paths     = ["lib"]
+  s.add_dependency("mofo", ">= 0.2.0")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+  file = File.dirname(__FILE__) + "/#{spec.name}.gemspec"
+  File.open(file, "w") {|f| f << spec.to_ruby }
+end
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the assert-microformats plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the assert-microformats plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AssertMicroformats'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/assert_microformats.rb

@@ -0,0 +1,45 @@
+gem 'mofo'
+require 'mofo'
+
+module AssertMicroformats
+
+  MICROFORMATS = {}
+  ObjectSpace.each_object(Class){|klass|
+    next unless klass < Microformat
+    type = klass.name.downcase.to_sym
+    class_eval %%
+      def assert_mf_#{type} *args, &block
+        assert_microformat #{type.to_sym.inspect}, *args
+      end
+    %
+    MICROFORMATS[type] = klass
+  }
+
+  def assert_microformat(*args)
+    html = @response.nil? ? '' : @response.body
+    type = nil
+    properties = {}
+
+    args.each_with_index do |arg, index|
+      html = arg if arg.is_a?(String)
+      type = arg if arg.is_a?(Symbol)
+      properties = arg if arg.is_a?(Hash)
+    end
+
+    mf = MICROFORMATS[type] or raise ArgumentError.new('Unsupported microformat type')
+
+    instances = mf.find :all => {:text => html}
+    raise Test::Unit::AssertionFailedError.new("No instances of #{type} were found") unless instances.any?
+
+    instances.each do |instance|
+      return if properties.inject(true) do |found, pair|
+        prop, value = pair
+        found && instance.properties.include?(prop.to_s) && (instance.instance_eval(prop.to_s) == value)
+      end
+    end
+
+    raise Test::Unit::AssertionFailedError.new("#{instances.size} instances of #{type} were found, but none had the required properties")
+  end
+
+end
+

data/rails/init.rb

@@ -0,0 +1,3 @@
+require "assert_microformats"
+
+Test::Unit::TestCase.send :include, AssertMicroformats

data/test/assert_microformats_test.rb

@@ -0,0 +1,149 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class AssertMicroformatsTest < Test::Unit::TestCase
+
+  include AssertMicroformatsTestData
+
+  class MockTestResponse
+    attr_reader :body
+    def initialize(body)
+      @body = body || ''
+    end
+  end
+  def test_mock_test_response
+    string = "A unique string"
+    @response = MockTestResponse.new(string)
+    assert_equal string, @response.body
+    @response = nil
+  end
+
+  def test_should_fail_to_find_any_microformats_in_an_empty_string
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :hcard end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :hcalendar end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :hreview end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :hentry end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :hresume end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :xoxo end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :geo end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_microformat '', :xfn end
+  end
+
+  def test_should_fail_to_find_any_microformats_in_an_empty_string_using_dynamic_method_names
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_hcard '' end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_hcalendar '' end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_hreview '' end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_hentry '' end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_hresume '' end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_xoxo '' end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_geo '' end
+    assert_raise(Test::Unit::AssertionFailedError) do assert_mf_xfn '' end
+  end
+
+  def test_should_find_a_simple_hcard
+    assert_microformat hcards[:simple], :hcard
+    assert_mf_hcard hcards[:simple]
+  end
+
+  def test_should_find_a_simple_hcalendar_event
+    assert_microformat hcalendars[:simple], :hcalendar
+    assert_mf_hcalendar hcalendars[:simple]
+  end
+
+  def test_should_find_a_simple_hreview
+    assert_microformat hreviews[:simple], :hreview
+    assert_mf_hreview hreviews[:simple]
+  end
+
+  def test_should_find_a_simple_hentry
+    assert_microformat hentries[:simple], :hentry
+    assert_mf_hentry hentries[:simple]
+  end
+
+  def test_should_find_a_simple_hresume
+    assert_microformat hresumes[:simple], :hresume
+    assert_mf_hresume hresumes[:simple]
+  end
+
+  def test_should_find_a_simple_xoxo_outline
+    assert_microformat xoxo[:simple], :xoxo
+    assert_mf_xoxo xoxo[:simple]
+  end
+
+  def test_should_find_a_simple_geo_location
+    assert_microformat geo[:simple], :geo
+    assert_mf_geo geo[:simple]
+  end
+
+  def test_should_find_a_simple_xfn_relationship
+    assert_microformat xfn[:simple], :xfn
+    assert_mf_xfn xfn[:simple]
+  end
+
+  def test_should_not_find_hcalendar_when_only_hcard_is_present
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_microformat hcards[:simple], :hcalendar
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_mf_hcalendar hcards[:simple]
+    end
+  end
+
+  def test_should_raise_when_microformat_type_is_invalid
+    assert_raise(ArgumentError) do
+      assert_microformat '', :invalid_microformat_type
+    end
+  end
+
+  def test_should_only_match_microformats_which_match_the_given_properties
+    assert_microformat hcards[:simple], :hcard, :fn => 'George Brocklehurst'
+    assert_microformat hcards[:complex], :hcard, :fn => 'George Brocklehurst', :url => 'http://georgebrock.com', :tel => '(020)12312312'
+    assert_mf_hcard hcards[:simple], :fn => 'George Brocklehurst'
+    assert_mf_hcard hcards[:complex], :fn => 'George Brocklehurst', :url => 'http://georgebrock.com', :tel => '(020)12312312'
+  end
+
+  def test_should_not_match_microformats_which_do_not_match_the_given_properties
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_microformat hcards[:simple], :hcard, :fn => 'Someone Else'
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_mf_hcard hcards[:simple], :fn => 'Someone Else'
+    end
+  end
+
+  def test_should_not_match_microformats_which_only_match_some_of_the_given_properties
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_microformat hcards[:simple], :hcard, :fn => 'George Brocklehurst', :url => 'http://www.google.com'
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_mf_hcard hcards[:simple], :fn => 'George Brocklehurst', :url => 'http://www.google.com'
+    end
+  end
+
+  def test_should_not_match_microformats_that_do_not_have_some_of_the_given_properties
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_microformat hcards[:simple], :hcard, :fn => 'George Brocklehurst', :fakeprop => 'http://www.google.com'
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_mf_hcard hcards[:simple], :fn => 'George Brocklehurst', :fakeprop => 'http://www.google.com'
+    end
+  end
+
+  def test_should_not_match_microformats_that_do_not_have_any_of_the_given_properties
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_microformat hcards[:simple], :hcard, :fakeprop => 'http://www.google.com'
+    end
+    assert_raise(Test::Unit::AssertionFailedError) do
+      assert_mf_hcard hcards[:simple], :fakeprop => 'http://www.google.com'
+    end
+  end
+
+  def test_should_use_test_response_if_no_html_is_provided
+    @response = MockTestResponse.new(hcards[:simple])
+    assert_microformat @response.body, :hcard, :fn => 'George Brocklehurst'
+    assert_microformat :hcard, :fn => 'George Brocklehurst'
+    assert_mf_hcard @response.body, :fn => 'George Brocklehurst'
+    assert_mf_hcard
+    assert_mf_hcard :fn => 'George Brocklehurst'
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,56 @@
+RAILS_ENV = 'test'
+require 'rubygems'
+require 'test/unit'
+require File.join(File.dirname(__FILE__), "..", "rails", "init")
+module AssertMicroformatsTestData
+
+  def hcards
+    {
+      :simple => '<span class="vcard"><span class="fn">George Brocklehurst</span></span>',
+      :complex => '<div class="vcard"><a class="fn url" href="http://georgebrock.com">George Brocklehurst</a> <span class="tel">(020)12312312</span></div>'
+    }
+  end
+
+  def hcalendars
+    {
+      :simple => '<span class="vevent"><span class="summary">An event</span>, <span class="dtstart">2009-05-30</span></span>'
+    }
+  end
+
+  def hreviews
+    {
+      :simple => '<span class="hreview">A review of <span class="item vcard"><span class="fn org">Apple</span></span></span>'
+    }
+  end
+
+  def hentries
+    {
+      :simple => '<div class="hentry"><h1 class="entry-title">Test Entry</h1><span class="published">2009-05-30</span><p class="entry-title">An awesome test case for hEntry</p></div>'
+    }
+  end
+
+  def hresumes
+    {
+      :simple => '<div class="hresume"><address class="vcard"><span class="fn">George Brocklehurst</span></address></div>'
+    }
+  end
+
+  def xoxo
+    {
+      :simple => '<ol class="xoxo"><li>Does anyone know what XOXO is for?</li><li>And so on</li></ol>'
+    }
+  end
+
+  def geo
+    {
+      :simple => '<div class="geo"><span class="latitude">37.386013</span>, <span class="longitude">-122.082932</span></div>'
+    }
+  end
+
+  def xfn
+    {
+      :simple => '<a href="http://georgebrock.com" rel="me">My other website</a>'
+    }
+  end
+
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: georgebrock-assert-microformats
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- George Brocklehurst
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-01 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mofo
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.0
+    version: 
+description: 
+email: george.brocklehurst@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- test/assert_microformats_test.rb
+- test/test_helper.rb
+- lib/assert_microformats.rb
+- rails/init.rb
+has_rdoc: true
+homepage: http://github.com/georgebrock
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A Rails plugin to help with testing the presence and correctness of microformats markup
+test_files: []
+