bradleypriest-mollom 0.2.3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jan De Poorter - Openminds BVBA
+ 
+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,37 @@
+== Mollom
+
+This is a Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assessment.
+
+== Installation
+
+You can either install the library as a gem
+  gem install mollom
+
+Or you can get the latest development version from GitHub:
+  git clone git://github.com/DefV/ruby-mollom.git
+
+== Usage
+
+After you have requested a public/private key-pair from Mollom (on http://www.mollom.com), you can start using this class.
+
+  require 'rubygems'
+  require 'mollom'
+  
+  m = Mollom.new(:private_key => 'your-private-key', :public_key => 'your-public-key')
+
+  content = m.check_content(:post_title => 'Mollem is an open API', 
+							:post_body => "Lorem Ipsum dolor...",
+							:author_name => 'Jan De Poorter',
+							:author_url => 'http://workswithruby.com')
+  if content.spam?
+	puts "You, sir, are a spammer.. Goodbye!"
+  elsif content.unsure?
+    # possible spam, possible ham, show CAPTCHA
+    puts "CAPTCHA: " + m.image_captcha(:session_id => content.session_id)["url"]
+    
+    captcha_correct = m.check_captcha(:session_id => content.session_id, :solution => STDIN.gets.chomp)
+  else
+    puts "The post is perfect! No spam!"
+  end
+
+Copyright (c) 2008 Jan De Poorter - Openminds BVBA, released under the MIT license

data/Rakefile

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "bradleypriest-mollom"
+    gemspec.summary = "Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assesment."
+    gemspec.description = "Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assesment."
+    gemspec.email = "mollom@openminds.be"
+    gemspec.homepage = "http://mollom.rubyforge.com"
+    gemspec.authors = ["Jan De Poorter"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'docs'
+  rdoc.title    = "Mollom -- Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assesment."
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+}

data/VERSION

@@ -0,0 +1 @@
+0.2.3

data/lib/mollom/api_compatibility.rb

@@ -0,0 +1,16 @@
+class Mollom
+  module ApiCompatibility
+    def self.included base
+      base.class_eval do
+        alias checkContent check_content
+        alias getImageCaptcha image_captcha
+        alias getAudioCaptcha audio_captcha
+        alias checkCaptcha valid_captcha?
+        alias verifyKey key_ok?
+        alias getStatistics statistics
+        alias sendFeedback send_feedback
+        alias detectLanguage language_for
+      end
+    end
+  end
+end

data/lib/mollom/content_response.rb

@@ -0,0 +1,68 @@
+class Mollom
+  class ContentResponse
+    attr_reader :session_id
+    
+    # An assessment of the content's quality, between 0 and 1; 0 being very low, 1 being high quality if specified in check_content checks
+    attr_reader :quality
+    
+    # An assessment of the content's profanity level, between 0 and 1; 0 being non-profane, 1 being very profane if specified in check_content checks
+    attr_reader :profanity
+    
+    # An assessment of the content's sentiment, between 0 and 1; 0 being a very negative sentiment, 1 being a very positive sentiment if specified in check_content checks
+    attr_reader :sentiment
+    
+    # a list of structs containing pairs of language and confidence values if specified in checkContent checks
+    attr_reader :language
+
+    Unknown = 0
+    Ham  = 1
+    Spam = 2
+    Unsure = 3
+
+    # This class should only be initialized from within the +check_content+ command.
+    def initialize(hash)
+      @hash = hash
+      @spam_response = hash["spam"]
+      @session_id = hash["session_id"]
+      @quality = hash["quality"]
+      @profanity = hash["profanity"]
+      @sentiment = hash["sentiment"]
+      @language = hash["language"]
+    end
+    
+    # Is the content Spam?
+    def spam?
+      @spam_response == Spam
+    end
+
+    # Is the content Ham?
+    def ham?
+      @spam_response == Ham
+    end
+
+    # is Mollom unsure about the content?
+    def unsure?
+      @spam_response == Unsure
+    end
+
+    # is the content unknown?
+    def unknown?
+      @spam_response == Unknown
+    end
+
+    # Returns 'unknown', 'ham', 'unsure' or 'spam', depending on what the content is.
+    def to_s
+      case @spam_response
+      when Unknown 	then 'unknown'
+      when Ham 		then 'ham'
+      when Unsure 	then 'unsure'
+      when Spam 	then 'spam'
+      end
+    end
+    
+    # Returns the original hash for testing
+    def to_hash
+      @hash
+    end
+  end
+end

data/lib/mollom.rb

@@ -0,0 +1,215 @@
+require 'xmlrpc/client'
+require 'openssl'
+require 'base64'
+require 'mollom/content_response'
+require 'mollom/api_compatibility'
+
+# Mollom API requires this to change, but this gives a warning!
+# XMLRPC::Client::USER_AGENT = "Ruby Mollom/0.1"
+
+class Mollom
+  API_VERSION = '1.0'
+  STATIC_SERVER_LIST = [{:proto => 'http', :host => 'xmlrpc3.mollom.com'},
+                        {:proto => 'http', :host => 'xmlrpc2.mollom.com'},
+                        {:proto => 'http', :host => 'xmlrpc1.mollom.com'}].freeze
+  
+  module Errors
+    Standard = 1000
+    Refresh = 1100
+    TooBusy = 1200
+  end
+
+  attr_accessor :private_key, :public_key
+
+  # Creates a new Mollom object. Takes +private_key+ and +public_key+ as keys.
+  # 
+  #   Mollom.new(:private_key => 'qopzalnzanzajlazjna', :public_key => 'aksakzaddazidzaodjaz')
+  #   # => #<Mollom:0x5b6454 @public_key="aksakzaddazidzaodjaz", @private_key="qopzalnzanzajlazjna">
+  
+  def initialize options = {}
+    @private_key = options[:private_key]
+    @public_key = options[:public_key]
+  end
+
+  # Checks the content whether it is spam, ham (not spam), or undecided, and gives a quality assessment of the content.
+  # Possible content keys are:
+  #  session_id     # => If you allready have a session_id
+  #  post_title     # => The title
+  #  post_body      # => The main content of the post.
+  #  author_name    # => The name of the post author
+  #  author_url     # => The url the author enters
+  #  author_mail    # => The author's email address
+  #  author_ip      # => The author's IP address
+  #  author_openid  # => The author's OpenID
+  #  author_id      # => The author's ID
+  #  checks         # => A comma-separated list of checks. Available checks include 'spam', 'quality', 'profanity', 'sentiment' and 'language'. E.g. 'spam,quality,sentiment'
+  #
+  # Only the +post_body+ key is required, all other keys are optional.
+  # This function returns a ContentResponse object.
+  #
+  #  response = mollom.check_content :post_title => 'Mollom rules!', 
+  #                                  :post_body => 'I think that mollom is so cool!', 
+  #                                  :author_name => 'Jan De Poorter', 
+  #                                  :author_url => 'http://www.openminds.be'
+  #  response.spam? # => false
+  #  response.ham?  # => true
+  def check_content content = {}
+    ContentResponse.new(send_command('mollom.checkContent', content))
+  end
+
+  # Requests an Image captcha from Mollom. It takes the optional <tt>session_id</tt> and <tt>author_ip</tt> keys, if you allready have a session.
+  # It returns a hash with the URL where the captcha can be found, and the session_id, to keep track of the current session (Needed later in <tt>Mollom#check_captcha</tt>)
+  #
+  #  captcha = mollom.image_captcha :author_ip => '172.16.0.1'
+  #  captcha['url']        # => http://xmlrpc1.mollom.com:80/a9616e6b4cd6a81ecdd509fa624d895d.png
+  #  captcha['session_id'] # => a9616e6b4cd6a81ecdd509fa624d895d
+  def image_captcha info = {}
+    send_command('mollom.getImageCaptcha', info)
+  end
+
+  # Requests an Audio captcha from Mollom. It takes the optional +session_id+ and +author_ip+ keys, if you allready have a session.
+  # It returns a hash with the URL where the captcha can be found, and the session_id, to keep track of the current session (Needed later in <tt>Mollom#check_captcha</tt>)
+  #
+  #  captcha = mollom.audio_captcha :author_ip => '172.16.0.2', :session_id => 'a9616e6b4cd6a81ecdd509fa624d895d'
+  #  captcha['url']        # => http://xmlrpc1.mollom.com:80/a9616e6b4cd6a81ecdd509fa624d895d.mp3
+  #  captcha['session_id'] # => a9616e6b4cd6a81ecdd509fa624d895d
+  def audio_captcha info = {}
+    send_command('mollom.getAudioCaptcha', info)
+  end
+
+  # Checks with mollom if the given captcha (by the user) is correct. Takes +session_id+ and +solution+ keys. Both keys are required.
+  # Returns true if the captcha is valid, false if it is incorrect
+  #
+  #  captcha = mollom.image_captcha :author_ip => '172.16.0.1'
+  #  # show to user... input from user
+  #  return = mollom.valid_captcha? :session_id => captcha['session_id'], :solution => 'abcDe9'
+  #  return # => true
+  def valid_captcha? info = {}
+    send_command('mollom.checkCaptcha', info)
+  end
+
+  # Standard check to see if your public/private keypair are recognized. Takes no options
+  def key_ok?
+    send_command('mollom.verifyKey')
+  rescue XMLRPC::FaultException
+    false
+  end
+
+  # Gets some statistics from Mollom about your site.
+  #
+  # The type has to be passed. Possible types:
+  #  total_days
+  #  total_accepted
+  #  total_rejected
+  #  yesterday_accepted
+  #  yesterday_rejected
+  #  today_accepted
+  #  today_rejected
+  #
+  #  mollom.statistics :type => 'total_accepted' # => 123
+  def statistics options = {}
+    send_command('mollom.getStatistics', options)
+  end
+
+  # Send feedback to Mollom about a certain content. Required keys are +session_id+ and +feedback+. 
+  # 
+  # Feedback can be any of
+  #  spam
+  #  profanity
+  #  low-quality
+  #  unwanted
+  #
+  #  mollom.send_feedback :session_id => 'a9616e6b4cd6a81ecdd509fa624d895d', :feedback => 'unwanted'
+  def send_feedback feedback = {}
+    send_command('mollom.sendFeedback', feedback)
+  end
+  
+  # Gets language of input text.
+  #
+  # mollom.language_for 'This is my text'
+  def language_for text
+    send_command('mollom.detectLanguage', :text => text)
+  end
+
+  # Gets a list of servers from Mollom. You should cache this information in your application in a temporary file or in a database. You can set this with Mollom#server_list=
+  # 
+  # Takes an optional parameter +refresh+, which resets the cached value.
+  #
+  #  mollom.server_list
+  #  # => [{:proto=>"http", :host=>"88.151.243.81"}, {:proto=>"http", :host=>"82.103.131.136"}]
+  def server_list refresh = false
+    return @server_list if @server_list && !refresh
+    STATIC_SERVER_LIST.each do |static_server|
+      @server_list = get_server_list_from(static_server)
+      return @server_list if @server_list
+    end
+    # Should have returned a server_list here..
+    raise(Error.new("Can't get mollom server-list"))
+  end
+  
+  # Sets the server list used to contact Mollom. This should be used to set the list of cached servers.
+  #
+  # If you try to set a faulty server list, the function will silently fail, so we can get the server-list from Mollom.
+  def server_list=(list)
+    # Check if we get an actual serverlist-array
+    if list.is_a?(Array) && list.all? {|hash| hash.has_key?(:host) && hash.has_key?(:proto) } 
+      @server_list = list
+    end
+  end
+
+  private
+  def get_server_list_from(server)
+    XMLRPC::Client.new(server[:host], "/#{API_VERSION}").call('mollom.getServerList', authentication_hash).collect do |server| 
+        proto, ip = server.split('://')
+        {:proto => proto, :host => ip}
+    end
+  rescue StandardError, Exception
+    nil
+  end
+  
+  def send_command(command, data = {})
+    server_list.each do |server|
+      begin
+        client = XMLRPC::Client.new(server[:host], "/#{API_VERSION}")
+        return client.call(command, data.merge(authentication_hash))
+      # TODO: Rescue more stuff (Connection Timeout and such)
+      rescue RuntimeError
+        next
+      rescue XMLRPC::FaultException => error
+        case error.faultCode
+        when Errors::Standard
+          raise Error.new(error.faultString)
+        when Errors::Refresh # Refresh server list please!
+          # we take this one out of our loop
+          raise
+        when Errors::TooBusy # Server is too busy, take the next one
+          next
+        else
+          next
+        end
+      end
+    end
+    raise Mollom::NoAvailableServers
+  rescue XMLRPC::FaultException
+    # We know it is Errors::Refresh
+    server_list(true)
+    retry
+  end
+  
+  # Creates a HMAC-SHA1 Hash with the current timestamp, a nonce, and your private key.
+  def authentication_hash
+    now = Time.now.gmtime.strftime('%Y-%m-%dT%H:%M:%S.000+0000')
+    nonce = Kernel.rand(2**31) # Random signed int
+
+    hash = Base64.encode64(
+      OpenSSL::HMAC.digest(OpenSSL::Digest::SHA1.new, @private_key, "#{now}:#{nonce}:#{@private_key}")
+    ).chomp
+
+    return :public_key=> @public_key, :time => now, :hash => hash, :nonce => nonce
+  end
+
+  class Error < StandardError; end
+  class NoAvailableServers < Error; end
+  
+  include ApiCompatibility
+end

data/mollom.gemspec

@@ -0,0 +1,52 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mollom}
+  s.version = "0.2.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jan De Poorter"]
+  s.date = %q{2010-07-26}
+  s.description = %q{Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assesment.}
+  s.email = %q{mollom@openminds.be}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/mollom.rb",
+     "lib/mollom/api_compatibility.rb",
+     "lib/mollom/content_response.rb",
+     "mollom.gemspec",
+     "pkg/mollom-0.1.1.gem",
+     "test/content_response_test.rb",
+     "test/mollom_test.rb"
+  ]
+  s.homepage = %q{http://mollom.rubyforge.com}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assesment.}
+  s.test_files = [
+    "test/content_response_test.rb",
+     "test/mollom_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/content_response_test.rb

@@ -0,0 +1,33 @@
+require "test/unit"
+
+require "mollom"
+
+class TestContentResponse < Test::Unit::TestCase
+  def test_spam
+    cr = Mollom::ContentResponse.new('spam' => 2, 'session_id' => '1', 'quality' => '10')
+    assert cr.spam?
+    assert !cr.ham?
+    assert_equal 'spam', cr.to_s
+  end
+  
+  def test_ham
+    cr = Mollom::ContentResponse.new('spam' => 1, 'session_id' => '1', 'quality' => '10')
+    assert cr.ham?
+    assert !cr.spam?
+    assert_equal 'ham', cr.to_s
+  end
+  
+  def test_unknown
+    cr = Mollom::ContentResponse.new('spam' => 0, 'session_id' => '1', 'quality' => '10')
+    assert cr.unknown?
+    assert !cr.unsure?
+    assert_equal 'unknown', cr.to_s
+  end
+  
+  def test_unsure
+    cr = Mollom::ContentResponse.new('spam' => 3, 'session_id' => '1', 'quality' => '10')
+    assert cr.unsure?
+    assert !cr.unknown?
+    assert_equal 'unsure', cr.to_s
+  end
+end

data/test/mollom_test.rb

@@ -0,0 +1,271 @@
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+require 'mollom'
+
+class Mollom
+  # Unprivate all methods
+  public :authentication_hash
+  public :server_list
+  public :send_command
+end
+
+class TestMollom < Test::Unit::TestCase
+  def setup
+    @mollom = Mollom.new(:private_key => 'xxxxxxxxx', :public_key => 'yyyyyyyyy')
+  end
+  
+  def test_initialize
+    assert_equal 'xxxxxxxxx', @mollom.private_key
+    assert_equal 'yyyyyyyyy', @mollom.public_key
+  end
+  
+  def test_authentication_hash
+    time = mock
+    time.expects(:strftime).with('%Y-%m-%dT%H:%M:%S.000+0000').returns('2008-04-01T13:54:26.000+0000')
+    Time.expects(:now).returns(stub(:gmtime => time))
+    Kernel.expects(:rand).with(2**31).returns(42)
+    hash = @mollom.authentication_hash
+    assert_equal("oWN15TqrbLVdTAgcuDmofskaNyM=", hash[:hash])
+    assert_equal('yyyyyyyyy', hash[:public_key])
+    assert_equal('2008-04-01T13:54:26.000+0000', hash[:time])
+    assert_equal(42, hash[:nonce])
+  end
+  
+  def test_server_list
+    Mollom.any_instance.expects(:get_server_list_from).with(:host => 'xmlrpc3.mollom.com', :proto => 'http').returns([{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'https'}])
+    assert_equal [{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'https'}], @mollom.server_list
+  end
+
+  def test_server_list_with_first_server_bad
+    Mollom.any_instance.expects(:get_server_list_from).with(:host => 'xmlrpc3.mollom.com', :proto => 'http').returns(nil)
+    Mollom.any_instance.expects(:get_server_list_from).with(:host => 'xmlrpc2.mollom.com', :proto => 'http').returns([{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'https'}])
+    assert_equal [{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'https'}], @mollom.server_list
+  end
+
+  def test_server_list_with_all_servers_bad
+    Mollom.any_instance.expects(:get_server_list_from).with(:host => 'xmlrpc3.mollom.com', :proto => 'http').returns(nil)
+    Mollom.any_instance.expects(:get_server_list_from).with(:host => 'xmlrpc2.mollom.com', :proto => 'http').returns(nil)
+    Mollom.any_instance.expects(:get_server_list_from).with(:host => 'xmlrpc1.mollom.com', :proto => 'http').returns(nil)
+    assert_raise(Mollom::Error) { @mollom.server_list }
+  end
+  
+  def test_get_server_list_from_with_ok_return
+    xml_rpc = mock
+    xml_rpc.expects(:call).times(1).with('mollom.getServerList', is_a(Hash)).returns(['http://172.16.0.1', 'http://172.16.0.2', 'https://172.16.0.2'])
+    XMLRPC::Client.stubs(:new).with('xmlrpc.mollom.com', '/1.0').returns(xml_rpc)
+    assert_equal([{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'https'}], @mollom.send(:get_server_list_from, {:host => 'xmlrpc.mollom.com', :proto => 'http'}))
+  end
+  
+  def test_get_server_list_from_with_raising_return
+    xml_rpc = mock
+    xml_rpc.expects(:call).times(1).with('mollom.getServerList', is_a(Hash)).raises(XMLRPC::FaultException.new(1000, "Broken mollom"))
+    XMLRPC::Client.stubs(:new).with('xmlrpc.mollom.com', '/1.0').returns(xml_rpc)
+    assert_equal(nil, @mollom.send(:get_server_list_from, {:host => 'xmlrpc.mollom.com', :proto => 'http'}))
+  end
+
+  def test_get_server_list_from_with_timemout
+    xml_rpc = mock
+    xml_rpc.expects(:call).times(1).with('mollom.getServerList', is_a(Hash)).raises(Timeout::Error)
+    XMLRPC::Client.stubs(:new).with('xmlrpc.mollom.com', '/1.0').returns(xml_rpc)
+    assert_equal(nil, @mollom.send(:get_server_list_from, {:host => 'xmlrpc.mollom.com', :proto => 'http'}))
+  end
+
+  def test_server_list_force_reload
+    Mollom.any_instance.expects(:get_server_list_from).times(2).with(:host => 'xmlrpc3.mollom.com', :proto => 'http').returns([{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'https'}])
+    
+    @mollom.server_list
+    @mollom.server_list
+    @mollom.server_list
+    @mollom.server_list(true)
+  end
+  
+  def test_server_list_setter_with_good_list
+    @mollom.server_list = [{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}]
+    assert_equal [{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}], @mollom.instance_variable_get('@server_list')
+  end
+  
+  def test_send_command_with_old_server_list
+    @mollom.server_list = [{:ip => '172.16.0.1', :proto => 'http'}, {:ip => '172.16.0.2', :proto => 'http'}]
+    assert_equal nil, @mollom.instance_variable_get('@server_list')
+  end
+
+  def test_send_command_with_bad_server_list
+    @mollom.server_list = "404 Not Found Bad User Input"
+    assert_equal nil, @mollom.instance_variable_get('@server_list')
+  end
+
+  
+  def test_send_command_with_good_server
+    Mollom.any_instance.expects(:server_list).returns([{:host => '172.16.0.1', :proto => 'http'}])
+    xml_rpc = mock
+    xml_rpc.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo'))
+    XMLRPC::Client.expects(:new).with('172.16.0.1', '/1.0').returns(xml_rpc)
+    
+    @mollom.send_command('mollom.testMessage', {:options => 'foo'})
+  end
+  
+  
+  def test_send_command_with_bad_http_response
+    Mollom.any_instance.expects(:server_list).returns([{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}])
+    xml_rpc = mock
+    xml_rpc.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo')).raises(RuntimeError.new('HTTP-Error: 302 Found'))
+    xml_rpc2 = mock
+    xml_rpc2.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo'))
+    
+    XMLRPC::Client.expects(:new).with('172.16.0.1', '/1.0').returns(xml_rpc)
+    XMLRPC::Client.expects(:new).with('172.16.0.2', '/1.0').returns(xml_rpc2)
+    @mollom.send_command('mollom.testMessage', {:options => 'foo'})
+  end
+  
+  def test_send_command_with_bad_server
+    Mollom.any_instance.expects(:server_list).returns([{:host => '172.16.0.1', :proto => 'http'}, {:host => '172.16.0.2', :proto => 'http'}])
+    xml_rpc = mock
+    xml_rpc.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo')).raises(XMLRPC::FaultException.new(1200, "Redirect"))
+    xml_rpc2 = mock
+    xml_rpc2.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo'))
+    
+    XMLRPC::Client.expects(:new).with('172.16.0.1', '/1.0').returns(xml_rpc)
+    XMLRPC::Client.expects(:new).with('172.16.0.2', '/1.0').returns(xml_rpc2)
+    @mollom.send_command('mollom.testMessage', {:options => 'foo'})
+  end
+  
+  def test_send_command_with_reload_exception
+    Mollom.any_instance.stubs(:server_list).returns([{:host => '172.16.0.1', :proto => 'http'}], [{:host => '172.16.0.2', :proto => 'http'}])
+    xml_rpc = mock
+    xml_rpc.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo')).raises(XMLRPC::FaultException.new(1100, "Refresh"))
+    xml_rpc2 = mock
+    xml_rpc2.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo'))
+
+    XMLRPC::Client.expects(:new).with('172.16.0.1', '/1.0').returns(xml_rpc)
+    XMLRPC::Client.expects(:new).with('172.16.0.2', '/1.0').returns(xml_rpc2)
+    @mollom.send_command('mollom.testMessage', {:options => 'foo'})
+  end
+  
+  def test_send_command_with_bad_command
+    Mollom.any_instance.expects(:server_list).returns([{:host => '172.16.0.1', :proto => 'http'}])
+    xml_rpc = mock
+    xml_rpc.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo')).raises(XMLRPC::FaultException.new(1000, "Fault String"))
+    XMLRPC::Client.expects(:new).with('172.16.0.1', '/1.0').returns(xml_rpc)
+    
+    assert_raise(Mollom::Error) { @mollom.send_command('mollom.testMessage', {:options => 'foo'}) }
+  end
+  
+  def test_send_command_with_bad_server_and_no_more_available
+    Mollom.any_instance.expects(:server_list).returns([{:host => '172.16.0.1', :proto => 'http'}])
+    xml_rpc = mock
+    xml_rpc.expects(:call).with('mollom.testMessage', has_entry(:options => 'foo')).raises(XMLRPC::FaultException.new(1200, "Redirect"))
+    
+    XMLRPC::Client.expects(:new).with('172.16.0.1', '/1.0').returns(xml_rpc)
+    
+    assert_raise(Mollom::NoAvailableServers) { @mollom.send_command('mollom.testMessage', {:options => 'foo'}) }
+  end
+  
+  def test_check_content
+    options = {:author_ip => '172.16.0.1', :post_body => 'Lorem Ipsum'}
+    
+    assert_command 'mollom.checkContent', :with => options, :returns => {"spam" => 1, "quality" => 0.40, "session_id" => 1} do
+      cr = @mollom.check_content(options)
+      assert cr.ham?
+      assert_equal 1, cr.session_id
+      assert_equal 0.40, cr.quality
+    end
+  end  
+  
+  def test_check_content_with_checks
+    options = {:author_ip => '172.16.0.1', :post_body => 'Lorem Ipsum', :checks => 'spam,quality,sentiment'}
+    
+    assert_command 'mollom.checkContent', :with => options, :returns => {"spam" => 1, "quality" => 0.40, "session_id" => 1, "sentiment" => 0.25, 'profanity' => 0.10 } do
+      cr = @mollom.check_content(options)
+      assert cr.ham?
+      assert_equal 1, cr.session_id
+      assert_equal 0.40, cr.quality
+      assert_equal 0.25, cr.sentiment
+      assert_equal 0.10, cr.profanity
+      assert cr.respond_to? :to_hash
+    end
+  end
+  
+  def test_image_captcha
+    options = {:author_ip => '172.16.0.1'}
+    
+    assert_command 'mollom.getImageCaptcha', :with => options, :returns => {'url' => 'http://xmlrpc1.mollom.com:80/a9616e6b4cd6a81ecdd509fa624d895d.png', 'session_id' => 'a9616e6b4cd6a81ecdd509fa624d895d'} do
+      @mollom.image_captcha(:author_ip => '172.16.0.1')
+    end
+  end
+  
+  def test_audio_captcha
+    options = {:author_ip => '172.16.0.1'}
+    
+    assert_command 'mollom.getAudioCaptcha', :with => options, :returns => {'url' => 'http://xmlrpc1.mollom.com:80/a9616e6b4cd6a81ecdd509fa624d895d.mp3', 'session_id' => 'a9616e6b4cd6a81ecdd509fa624d895d'} do
+      @mollom.audio_captcha(options)
+    end
+  end
+  
+  def test_valid_captcha
+    options = {:session_id => 'a9616e6b4cd6a81ecdd509fa624d895d', :solution => 'foo'}
+    
+    assert_command 'mollom.checkCaptcha', :with => options, :returns => true do
+      assert @mollom.valid_captcha?(options)
+    end
+  end
+
+  def test_key_ok
+    assert_command 'mollom.verifyKey', :returns => true do
+      assert @mollom.key_ok?
+    end
+  end
+  
+  def test_invalid_key
+    assert_command 'mollom.verifyKey', :raises => internal_server_error do
+      assert !@mollom.key_ok?
+    end
+  end
+  
+  def test_statistics
+    assert_command 'mollom.getStatistics', :with => {:type => 'total_accepted'}, :returns => 12 do
+      @mollom.statistics(:type => 'total_accepted')
+    end
+  end
+  
+  def test_send_feedback
+    assert_command 'mollom.sendFeedback', :with => {:session_id => 1, :feedback => 'profanity'} do
+      @mollom.send_feedback :session_id => 1, :feedback => 'profanity'
+    end
+  end
+  
+  def test_detect_language
+    assert_command 'mollom.detectLanguage', :with => {:text => 'Dit is nederlands'}, :returns => [{"confidence"=>0.332, "language"=>"nl"}] do
+      assert_equal [{"confidence"=>0.332, "language"=>"nl"}], @mollom.language_for('Dit is nederlands')
+    end
+  end
+  
+  def test_api_compatability
+    assert @mollom.respond_to? :checkContent
+    assert @mollom.respond_to? :getImageCaptcha
+    assert @mollom.respond_to? :getAudioCaptcha
+    assert @mollom.respond_to? :checkCaptcha
+    assert @mollom.respond_to? :verifyKey
+    assert @mollom.respond_to? :getStatistics
+    assert @mollom.respond_to? :sendFeedback 
+    assert @mollom.respond_to? :detectLanguage
+  end
+  
+  private
+  def assert_command command, options = {}
+    expectation = Mollom.any_instance.expects(:send_command)
+    expectation.with do |*arguments|
+      arguments.first == command &&
+      (!options[:with] || options[:with] == arguments.last)
+    end
+    expectation.returns(options[:returns]) if options[:returns]
+    expectation.raises(options[:raises]) if options[:raises]
+    
+    yield
+  end
+  
+  def internal_server_error
+    XMLRPC::FaultException.new(1000, "Internal server error due to malformed request, or the hamster powering the server died...")
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: bradleypriest-mollom
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.2.3
+platform: ruby
+authors: 
+- Jan De Poorter
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-12 00:00:00 +12:00
+default_executable: 
+dependencies: []
+
+description: Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assesment.
+email: mollom@openminds.be
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/mollom.rb
+- lib/mollom/api_compatibility.rb
+- lib/mollom/content_response.rb
+- mollom.gemspec
+- pkg/mollom-0.1.1.gem
+- test/content_response_test.rb
+- test/mollom_test.rb
+has_rdoc: true
+homepage: http://mollom.rubyforge.com
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Ruby class for easy interfacing with the mollom.com open API for spam detection and content quality assesment.
+test_files: 
+- test/content_response_test.rb
+- test/mollom_test.rb