acts_as_textcaptcha 3.0.11 → 4.0.0

data/lib/acts_as_textcaptcha/textcaptcha_api.rb

@@ -0,0 +1,61 @@
+# simple wrapper for the textcaptcha.com API service
+# loads and parses captcha question and answers
+
+require 'rexml/document'
+
+module ActsAsTextcaptcha
+
+  # raised if an empty response is returned
+  class EmptyResponseError < StandardError; end;
+
+  class TextcaptchaApi
+
+    ENDPOINT = 'http://textcaptcha.com/api/'
+
+    def self.fetch(api_key, options = {})
+      begin
+        url = uri_parser.parse("#{ENDPOINT}#{api_key}")
+        http = Net::HTTP.new(url.host, url.port)
+        if options[:http_open_timeout]
+          http.open_timeout = options[:http_open_timeout]
+        end
+        if options[:http_read_timeout]
+          http.read_timeout = options[:http_read_timeout]
+        end
+
+        response = http.get(url.path)
+        if response.body.empty?
+          raise ActsAsTextcaptcha::EmptyResponseError
+        else
+          return parse(response.body)
+        end
+      rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
+        Errno::EHOSTUNREACH, EOFError, Errno::ECONNREFUSED, Errno::ETIMEDOUT,
+        Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
+        URI::InvalidURIError, ActsAsTextcaptcha::EmptyResponseError,
+        REXML::ParseException
+        # rescue from these errors and continue
+      end
+    end
+
+    def self.parse(xml)
+      parsed_xml = ActiveSupport::XmlMini.parse(xml)['captcha']
+      question = parsed_xml['question']['__content__']
+      if parsed_xml['answer'].is_a?(Array)
+        answers = parsed_xml['answer'].collect { |a| a['__content__'] }
+      else
+        answers = [parsed_xml['answer']['__content__']]
+      end
+
+      [question, answers]
+    end
+
+
+    private
+
+    def self.uri_parser
+      # URI.parse is deprecated in 1.9.2
+      URI.const_defined?(:Parser) ? URI::Parser.new : URI
+    end
+  end
+end

data/lib/acts_as_textcaptcha/textcaptcha_cache.rb

@@ -0,0 +1,34 @@
+# A simple cache for storing Textcaptcha answers
+# by default the underlying cache implementation is
+# the standard Rails.cache (ActiveSupport::Cache)
+
+module ActsAsTextcaptcha
+  class TextcaptchaCache
+
+    CACHE_KEY_PREFIX = 'acts_as_textcaptcha-'
+    DEFAULT_CACHE_EXPIRY_MINUTES = 10
+
+    def write(key, value, options = {})
+      unless options.has_key?(:expires_in)
+        options[:expires_in] = DEFAULT_CACHE_EXPIRY_MINUTES.minutes
+      end
+      Rails.cache.write(cache_key(key), value, options)
+    end
+
+    def read(key, options = nil)
+      Rails.cache.read(cache_key(key), options)
+    end
+
+    def delete(key, options = nil)
+      Rails.cache.delete(cache_key(key), options)
+    end
+
+    private
+
+    # since this cache may be shared with other objects
+    # a prefix is used in all cache keys
+    def cache_key(key)
+      "#{CACHE_KEY_PREFIX}#{key}"
+    end
+  end
+end

data/lib/acts_as_textcaptcha/textcaptcha_helper.rb

@@ -1,17 +1,19 @@
 module ActsAsTextcaptcha
   module TextcaptchaHelper
 
-    # builds html fields for spam question, answer and hidden encrypted spam answers
+    # builds html form fields for the textcaptcha
     def textcaptcha_fields(f, &block)
       model        = f.object
       captcha_html = ''
       if model.perform_textcaptcha?
-         captcha_html += f.hidden_field(:spam_answers)
-         if model.spam_answer
-           captcha_html += f.hidden_field(:spam_answer)
-         elsif model.spam_question
-           captcha_html += capture(&block)
-         end
+        if model.textcaptcha_key
+          captcha_html += f.hidden_field(:textcaptcha_key)
+          if model.textcaptcha_question
+            captcha_html += capture(&block)
+          elsif model.textcaptcha_answer
+            captcha_html += f.hidden_field(:textcaptcha_answer)
+          end
+        end
       end
 
       # Rails 2 compatability

data/lib/acts_as_textcaptcha/version.rb

@@ -1,3 +1,3 @@
 module ActsAsTextcaptcha
-  VERSION = "3.0.11"
+  VERSION = "4.0.0"
 end

data/lib/tasks/textcaptcha.rake

@@ -1,5 +1,3 @@
-require 'bcrypt'
-
 namespace :textcaptcha do
 
   desc "Creates a template config file in config/textcaptcha.yml"
@@ -10,17 +8,14 @@ namespace :textcaptcha do
       puts "\nOoops, a textcaptcha config file at #{dest} already exists ... aborting.\n\n"
     else
       config = ''
-      salt   = BCrypt::Engine.generate_salt
       f = File.open(src, 'r')
       f.each_line { |line| config += line }
-      config.gsub!(/RAKE_GENERATED_SALT_PLACEHOLDER/, salt)
       config.gsub!(/  api_key:(.*)# for gem test purposes only$/, "  api_key: PASTE_YOUR_TEXTCAPCHA_API_KEY_HERE")
-      config.gsub!(/  bcrypt_salt:(.*)# for gem test purposes only$/, "  bcrypt_salt: #{salt}")
 
       f = File.new(dest, 'w')
       f.write(config)
       f.close
-      puts "\ntextcaptcha.yml generated at #{dest} (with a new BCrypt salt)\nNOTE: edit this file and add your textcaptcha api key, grab one from http://textcaptcha.com/api\n\n"
+      puts "\ntextcaptcha.yml generated at #{dest}\nNOTE: edit this file and add your textcaptcha api key, grab one from http://textcaptcha.com/api\n\n"
     end
   end
 end

data/test/schema.rb

@@ -8,6 +8,10 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string :name
   end
 
+  create_table :fast_comments, :force => true do |t|
+    t.string :name
+  end
+
   create_table :reviews, :force => true do |t|
     t.string :name
   end

data/test/test_helper.rb

@@ -1,16 +1,21 @@
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)+'./../lib'))
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)+'./../lib/acts_as_textcaptcha'))
 
 ENV['RAILS_ENV'] = 'test'
 
+# confgure test coverage reporting
 if ENV['COVERAGE']
-  require "simplecov"
+  require 'simplecov'
   SimpleCov.start do
     add_filter '/test/'
+    add_filter '/vendor/'
   end
   SimpleCov.at_exit do
     SimpleCov.result.format!
     `open ./coverage/index.html` if RUBY_PLATFORM =~ /darwin/
   end
+elsif ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear!
 end
 
 require 'minitest/autorun'
@@ -18,9 +23,22 @@ require 'fakeweb'
 
 require 'rails/all'
 
+# silence warnings about I18n locales
+I18n.config.enforce_available_locales = true
+
 require 'acts_as_textcaptcha'
+require 'textcaptcha_cache'
+require 'textcaptcha_api'
 require './test/test_models'
 
 # load and initialize test db schema
 ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => 'acts_as_textcaptcha.sqlite3.db')
 load(File.dirname(__FILE__) + "/schema.rb")
+
+# initialize a Rails.cache (use a basic memory store in tests)
+RAILS_CACHE = ActiveSupport::Cache::MemoryStore.new
+
+# additional helper methods for use in tests
+def find_in_cache(key)
+  RAILS_CACHE.read("#{ActsAsTextcaptcha::TextcaptchaCache::CACHE_KEY_PREFIX}#{key}")
+end

data/test/test_models.rb

@@ -8,36 +8,36 @@ end
 
 class Comment < ActiveRecord::Base
   # inline options (symbol keys) with api_key only
-  acts_as_textcaptcha :api_key     => '8u5ixtdnq9csc84cok0owswgo',
-                      :bcrypt_salt => '$2a$10$j0bmycH.SVfD1b5mpEGPpe'
+  acts_as_textcaptcha :api_key => '8u5ixtdnq9csc84cok0owswgo'
+end
+
+class FastComment < ActiveRecord::Base
+  # inline options with super fast (0.006 seconds) cache expiry time
+  acts_as_textcaptcha :cache_expiry_minutes => '0.0001',
+                      :questions => [{ :question => '1+1', :answers => '2,two' }]
 end
 
 class Review < ActiveRecord::Base
   # inline options with all possible options
-  acts_as_textcaptcha 'api_key'     => '8u5ixtdnq9csc84cok0owswgo',
-                      'bcrypt_salt' => '$2a$10$j0bmycH.SVfD1b5mpEGPpe',
-                      'bcrypt_cost' => '3',
-                      'questions'   => [{ 'question' => 'The green hat is what color?', 'answers' => 'green' }]
+  acts_as_textcaptcha :api_key   => '8u5ixtdnq9csc84cok0owswgo',
+                      :questions => [{ :question => 'The green hat is what color?', :answers => 'green' }]
 end
 
 class MovieReview < ActiveRecord::Base
   # inline options with all possible options
-  acts_as_textcaptcha 'api_key'     => '8u5ixtdnq9csc84cok0owswgo',
-                      'bcrypt_salt' => '$2a$10$j0bmycH.SVfD1b5mpEGPpe',
-                      'bcrypt_cost' => '3',
-                      'questions'   => [{ 'Question' => 'The green hat is what color?', 'answers' => nil }]
+  acts_as_textcaptcha 'api_key'   => '8u5ixtdnq9csc84cok0owswgo',
+                      'questions' => [{ 'Question' => 'The green hat is what color?', 'answers' => nil }]
 end
 
 class Note < ActiveRecord::Base
   # inline options (string keys) with user defined questions only (no textcaptcha service)
-  acts_as_textcaptcha 'questions'   => [{ 'question' => '1+1', 'answers' => '2,two' }],
-                      'bcrypt_salt' => '$2a$10$j0bmycH.SVfD1b5mpEGPpe'
+  acts_as_textcaptcha 'questions' => [{ 'question' => '1+1', 'answers' => '2,two' }]
 
   # allows toggling perform_textcaptcha on/off (default on)
   attr_accessor :turn_off_captcha
 
   def perform_textcaptcha?
-    !turn_off_captcha
+    super && !turn_off_captcha
   end
 end
 
@@ -46,8 +46,7 @@ class Contact
   include ActiveModel::Validations
   include ActiveModel::Conversion
   extend  ActsAsTextcaptcha::Textcaptcha
-  acts_as_textcaptcha :questions   => [{ :question => 'one+1', :answers => "2,two,апельсин" }],
-                      :bcrypt_salt => '$2a$10$j0bmycH.SVfD1b5mpEGPpe'
+  acts_as_textcaptcha :questions => [{ :question => 'one+1', :answers => "2,two,апельсин" }]
 end
 
 # ActiveRecord model using the strong parameters gem
@@ -55,6 +54,5 @@ require 'strong_parameters'
 
 class StrongWidget < ActiveRecord::Base
   include ActiveModel::ForbiddenAttributesProtection
-  acts_as_textcaptcha 'questions'   => [{ 'question' => '1+1', 'answers' => '2,two' }],
-                      'bcrypt_salt' => '$2a$10$j0bmycH.SVfD1b5mpEGPpe'
+  acts_as_textcaptcha 'questions' => [{ 'question' => '1+1', 'answers' => '2,two' }]
 end

data/test/textcaptcha_api_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__)+'/test_helper')
+
+describe 'TextcaptchaApi' do
+
+  after(:each) do
+    FakeWeb.clean_registry
+  end
+
+  describe 'with a valid xml response' do
+
+    before(:each) do
+      body = "<captcha><question>1+1?</question><answer>1</answer><answer>2</answer><answer>3</answer></captcha>"
+      FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/abc|, :body => body)
+    end
+
+    it 'should fetch and parse an answer from the service' do
+      result = ActsAsTextcaptcha::TextcaptchaApi.fetch('abc')
+      result[0].must_equal '1+1?'
+      result[1].must_equal ['1', '2', '3']
+    end
+
+    it 'should allow http options to be set' do
+      result = ActsAsTextcaptcha::TextcaptchaApi.fetch('abc', { :http_read_timeout => 30,
+                                                                :http_open_timeout => 5 })
+      result.length.must_equal 2
+    end
+  end
+
+  it 'should return nil when Net::HTTP errors occur' do
+    [
+      SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
+      Errno::EHOSTUNREACH, EOFError, Errno::ECONNREFUSED, Errno::ETIMEDOUT,
+      Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError,
+      URI::InvalidURIError
+    ].each do |error|
+       FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/xyz|, :exception => error)
+       ActsAsTextcaptcha::TextcaptchaApi.fetch('xyz').must_equal nil
+     end
+  end
+
+  it 'should return nil when body cannot be parsed as XML' do
+    FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/jibber|, :body => 'here be gibberish')
+    ActsAsTextcaptcha::TextcaptchaApi.fetch('jibber').must_equal nil
+  end
+
+  it 'should return nil when body is empty' do
+    FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/empty|, :body => '')
+    ActsAsTextcaptcha::TextcaptchaApi.fetch('empty').must_equal nil
+  end
+end

data/test/textcaptcha_cache_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__)+'/test_helper')
+
+describe 'TextcaptchaCache' do
+
+  before(:each) do
+    @cache = ActsAsTextcaptcha::TextcaptchaCache.new
+    @cache.write('mykey', [1,2,3])
+  end
+
+  it 'should write to the cache' do
+    @cache.write('my-new-key', 'abc')
+    @cache.read('my-new-key').must_equal 'abc'
+  end
+
+  it 'should read from the cache' do
+    @cache.read('mykey').must_equal [1,2,3]
+  end
+
+  it 'should delete from the cache' do
+    @cache.read('mykey').must_equal [1,2,3]
+    @cache.delete('mykey')
+
+    @cache.read('mykey').must_equal nil
+  end
+end

data/test/textcaptcha_helper_test.rb

@@ -17,13 +17,13 @@ describe 'TextcaptchaHelper' do
     @note.textcaptcha
   end
 
-  def render_template(assigns)
+  def render_template(assigns = { :note => @note })
     template = <<-ERB
     <%= form_for(@note, :url => '/') do |f| %>
       <%= textcaptcha_fields(f) do %>
       <div class="field textcaptcha">
-        <%= f.label :spam_answer, @note.spam_question %><br/>
-        <%= f.text_field :spam_answer, :value => '' %>
+        <%= f.label :textcaptcha_answer, @note.textcaptcha_question %><br/>
+        <%= f.text_field :textcaptcha_answer, :value => '' %>
       </div>
       <% end %>
     <% end %>
@@ -32,19 +32,37 @@ describe 'TextcaptchaHelper' do
     Template.new([], assigns, @controller).render(:inline => template)
   end
 
-  it 'should render question and answer fields, with hidden spam_answers field' do
-    html = render_template({:note => @note})
+  it 'should render question and answer fields, with hidden textcaptcha_key field' do
+    html = render_template
 
-    html.must_match /\<label for\=\"note\_spam\_answer\"\>1\+1\<\/label\>/
-    html.must_match /\<input id\=\"note_spam_answers\" name\=\"note\[spam\_answers\]\" type\=\"hidden\" value\=\"(.*)\" \/\>/
+    assert_match /\<label for\=\"note_textcaptcha_answer\"\>1\+1\<\/label\>/, html
+    assert_match /\<input id\=\"note_textcaptcha_answer\" name\=\"note\[textcaptcha_answer\]\" size\=\"30\" type\=\"text\" value\=\"\" \/>/, html
+    assert_match /\<input id\=\"note_textcaptcha_key\" name\=\"note\[textcaptcha_key\]\" type\=\"hidden\" value\=\"([0-9a-f]{32})\" \/\>/, html
   end
 
-  it 'should render hidden answer and spam_answer fields when question has been answered OK (and not ask question)' do
-    @note.spam_answer = 2
-    html = render_template({:note => @note})
+  it 'should render hidden answer and textcaptcha_key when only answer is present' do
+    @note.textcaptcha_question = nil
+    @note.textcaptcha_answer   = 2
+    html = render_template
 
-    html.wont_match /\<label for\=\"note\_spam\_answer\"\>1\+1\<\/label\>/
-    html.must_match /\<input id\=\"note_spam_answers\" name\=\"note\[spam\_answers\]\" type\=\"hidden\" value\=\"(.*)\" \/\>/
-    html.must_match /\<input id\=\"note_spam_answer\" name\=\"note\[spam_answer\]\" type\=\"hidden\" value\=\"2\" \/\>/
+    refute_match /\<label for\=\"note_textcaptcha_answer\"\>1\+1\<\/label\>/, html
+    assert_match /\<input id\=\"note_textcaptcha_answer\" name\=\"note\[textcaptcha_answer\]\" type\=\"hidden\" value\=\"2\" \/>/, html
+    assert_match /\<input id\=\"note_textcaptcha_key\" name\=\"note\[textcaptcha_key\]\" type\=\"hidden\" value\=\"([0-9a-f]{32})\" \/\>/, html
+  end
+
+  it 'should not render any question or answer when perform_textcaptcha? is false' do
+    @note.turn_off_captcha = true
+    html = render_template
+
+    refute_match /note_textcaptcha_answer/, html
+    refute_match /note_textcaptcha_key/, html
+  end
+
+  it 'should not render any question or answer when textcaptcha_key is missing' do
+    @note.textcaptcha_key = nil
+    html = render_template
+
+    refute_match /note_textcaptcha_answer/, html
+    refute_match /note_textcaptcha_key/, html
   end
 end

data/test/textcaptcha_test.rb

@@ -10,40 +10,40 @@ describe 'Textcaptcha' do
     end
 
     it 'should validate an ActiveRecord object (with multiple correct answers)' do
-      @note.spam_question.must_equal('1+1')
+      @note.textcaptcha_question.must_equal('1+1')
       @note.valid?.must_equal false
-      @note.errors[:spam_answer].first.must_equal('is incorrect, try another question instead')
+      @note.errors[:textcaptcha_answer].first.must_equal('is incorrect, try another question instead')
 
-      @note.spam_answer = 'two'
+      @note.textcaptcha_answer = 'two'
       @note.valid?.must_equal true
-      @note.errors[:spam_answer].must_be_empty
+      @note.errors[:textcaptcha_answer].must_be_empty
 
-      @note.spam_answer = '2'
+      @note.textcaptcha_answer = '2'
       @note.valid?.must_equal true
-      @note.errors[:spam_answer].must_be_empty
+      @note.errors[:textcaptcha_answer].must_be_empty
     end
 
-    it 'should strip whitespace and downcase spam answer' do
-      @note.spam_answer = ' tWo '
+    it 'should strip whitespace and downcase answer' do
+      @note.textcaptcha_answer = ' tWo '
       @note.valid?.must_equal true
-      @note.errors[:spam_answer].must_be_empty
+      @note.errors[:textcaptcha_answer].must_be_empty
     end
 
     it 'should always be valid when record has been saved' do
-      @note.spam_answer = '2'
+      @note.textcaptcha_answer = '2'
       @note.save!
       @note.textcaptcha
 
-      @note.spam_answer = 'wrong answer'
+      @note.textcaptcha_answer = 'wrong answer'
       @note.new_record?.must_equal false
       @note.valid?.must_equal true
-      @note.errors[:spam_answer].must_be_empty
+      @note.errors[:textcaptcha_answer].must_be_empty
     end
 
     it 'should always be valid when perform_textcaptcha? is false' do
       @note.turn_off_captcha = true
       @note.valid?.must_equal true
-      @note.errors[:spam_answer].must_be_empty
+      @note.errors[:textcaptcha_answer].must_be_empty
 
       @note.save.must_equal true
     end
@@ -52,24 +52,13 @@ describe 'Textcaptcha' do
       @contact = Contact.new
       @contact.textcaptcha
 
-      @contact.spam_question.must_equal('one+1')
-      @contact.spam_answer = 'wrong'
+      @contact.textcaptcha_question.must_equal('one+1')
+      @contact.textcaptcha_answer = 'wrong'
       @contact.valid?.must_equal false
 
-      @contact.spam_answer = 'two'
+      @contact.textcaptcha_answer = 'two'
       @contact.valid?.must_equal true
-      @contact.errors[:spam_answer].must_be_empty
-    end
-
-    it 'should allow validation to be skipped' do
-      @note.valid?.must_equal false
-      @note.skip_textcaptcha = true
-      @note.valid?.must_equal true
-    end
-
-    it 'should protect skip_textcaptcha attribute from mass assignment' do
-      @note = Note.new(:skip_textcaptcha => true)
-      @note.skip_textcaptcha.must_equal nil
+      @contact.errors[:textcaptcha_answer].must_be_empty
     end
   end
 
@@ -80,36 +69,31 @@ describe 'Textcaptcha' do
     end
 
     it 'should work' do
-      @widget.spam_answers.must_be_nil
       @widget.textcaptcha
-      @widget.spam_question.must_equal('1+1')
+      @widget.textcaptcha_question.must_equal('1+1')
       @widget.valid?.must_equal false
-      @widget.errors[:spam_answer].first.must_equal('is incorrect, try another question instead')
+      @widget.errors[:textcaptcha_answer].first.must_equal('is incorrect, try another question instead')
 
-      @widget.spam_answer = 'two'
+      @widget.textcaptcha_answer = 'two'
       @widget.valid?.must_equal true
-      @widget.errors[:spam_answer].must_be_empty
+      @widget.errors[:textcaptcha_answer].must_be_empty
     end
   end
 
-  describe 'encryption' do
+  describe 'with fast expiry time' do
 
     before(:each) do
-      @note = Note.new
+      @comment = FastComment.new
     end
 
-    it 'should encrypt spam_answers (joined by - seperator) MD5 digested and using BCrypt engine with salt' do
-      @note.spam_answers.must_be_nil
-      @note.textcaptcha
-      encrypted_answers = [2,' TwO '].collect { |answer| BCrypt::Engine.hash_secret(Digest::MD5.hexdigest(answer.to_s.strip.downcase), '$2a$10$j0bmycH.SVfD1b5mpEGPpe', 1) }.join('-')
-      @note.spam_answers.must_equal('$2a$10$j0bmycH.SVfD1b5mpEGPpePFe1wBxOn7Brr9lMuLRxv6lg4ZYjJ22-$2a$10$j0bmycH.SVfD1b5mpEGPpe8v5mqqpDaExuS/hZu8Xkq8krYL/T8P.')
-      @note.spam_answers.must_equal(encrypted_answers)
-    end
+    it 'should work' do
+      @comment.textcaptcha
+      @comment.textcaptcha_question.must_equal('1+1')
+      @comment.textcaptcha_answer = 'two'
+      sleep(0.01)
 
-    it 'should raise error if bcyrpt salt is invalid' do
-      @note.textcaptcha_config[:bcrypt_salt] = 'bad salt'
-      proc { @note.textcaptcha }.must_raise BCrypt::Errors::InvalidSalt
-      @note.textcaptcha_config[:bcrypt_salt] ='$2a$10$j0bmycH.SVfD1b5mpEGPpe'
+      @comment.valid?.must_equal false
+      @comment.errors[:textcaptcha_answer].first.must_equal('was not submitted quickly enough, try another question instead')
     end
   end
 
@@ -119,17 +103,17 @@ describe 'Textcaptcha' do
       FakeWeb.clean_registry
     end
 
-    it 'should generate spam question from the service' do
+    it 'should generate a question from the service' do
       @review = Review.new
 
       @review.textcaptcha
-      @review.spam_question.wont_be_nil
-      @review.spam_question.wont_equal('The green hat is what color?')
+      @review.textcaptcha_question.wont_be_nil
+      @review.textcaptcha_question.wont_equal('The green hat is what color?')
 
-      @review.spam_answers.wont_be_nil
+      find_in_cache(@review.textcaptcha_key).wont_be_nil
 
       @review.valid?.must_equal false
-      @review.errors[:spam_answer].first.must_equal('is incorrect, try another question instead')
+      @review.errors[:textcaptcha_answer].first.must_equal('is incorrect, try another question instead')
     end
 
     it 'should parse a single answer from XML response' do
@@ -139,9 +123,8 @@ describe 'Textcaptcha' do
       FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :body => body)
 
       @review.textcaptcha
-      @review.spam_question.must_equal(question)
-      @review.spam_answers.must_equal('$2a$10$j0bmycH.SVfD1b5mpEGPpecvhlumIBvWXI4HQWk0xa74DebZDx772')
-      @review.spam_answers.split('-').length.must_equal(1)
+      @review.textcaptcha_question.must_equal(question)
+      find_in_cache(@review.textcaptcha_key).must_equal(['f6f7fec07f372b7bd5eb196bbca0f3f4'])
     end
 
     it 'should parse multiple answers from XML response' do
@@ -151,76 +134,46 @@ describe 'Textcaptcha' do
       FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :body => body)
 
       @review.textcaptcha
-      @review.spam_question.must_equal(question)
-      @review.spam_answers.split('-').length.must_equal(3)
+      @review.textcaptcha_question.must_equal(question)
+      find_in_cache(@review.textcaptcha_key).length.must_equal(3)
     end
 
-    describe 'service is unavailable' do
-
-      describe 'should fallback to a user defined question' do
-
-        before(:each) do
-          @review = Review.new
-        end
-
-        it 'when errors occur' do
-          [SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Errno::ECONNREFUSED, Errno::ETIMEDOUT,
-           Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, URI::InvalidURIError].each do |error|
-            FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :exception => error)
-            @review.textcaptcha
-            @review.spam_question.must_equal('The green hat is what color?')
-            @review.spam_answers.wont_be_nil
-          end
-        end
-
-        it 'when response is OK but body cannot be parsed as XML' do
-          FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :body => 'here be gibberish')
-          @review.textcaptcha
-          @review.spam_question.must_equal('The green hat is what color?')
-          @review.spam_answers.wont_be_nil
-        end
-
-        it 'when response is OK but empty' do
-          FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :body => '')
-          @review.textcaptcha
-          @review.spam_question.must_equal('The green hat is what color?')
-          @review.spam_answers.wont_be_nil
-        end
-      end
+    it 'should fallback to a user defined question when api returns nil' do
+      @review = Review.new
+      FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :body => '')
+      @review.textcaptcha
+      @review.textcaptcha_question.must_equal('The green hat is what color?')
+      find_in_cache(@review.textcaptcha_key).wont_be_nil
     end
 
-    it 'should not generate any spam question or answer when no user defined questions set' do
+    it 'should not generate any question or answer when no user defined questions set' do
       @comment = Comment.new
 
       FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :exception => SocketError)
       @comment.textcaptcha
-      @comment.spam_question.must_equal 'ActsAsTextcaptcha >> no API key (or questions) set and/or the textcaptcha service is currently unavailable (answer ok to bypass)'
-      @comment.spam_answers.must_equal 'ok'
+      @comment.textcaptcha_question.must_equal nil
+      @comment.textcaptcha_key.must_equal nil
     end
 
-    it 'should not generate any spam question or answer when user defined questions set incorrectly' do
+    it 'should not generate any question or answer when user defined questions set incorrectly' do
       @comment = MovieReview.new
 
       FakeWeb.register_uri(:get, %r|http://textcaptcha\.com/api/|, :exception => SocketError)
       @comment.textcaptcha
-      @comment.spam_question.must_equal 'ActsAsTextcaptcha >> no API key (or questions) set and/or the textcaptcha service is currently unavailable (answer ok to bypass)'
-      @comment.spam_answers.must_equal 'ok'
+      @comment.textcaptcha_question.must_equal nil
+      @comment.textcaptcha_key.must_equal nil
     end
   end
 
   describe 'configuration' do
 
     it 'should be configured with inline hash' do
-      Review.textcaptcha_config.must_equal({ :api_key     => '8u5ixtdnq9csc84cok0owswgo',
-                                             :bcrypt_salt => '$2a$10$j0bmycH.SVfD1b5mpEGPpe',
-                                             :bcrypt_cost => '3',
-                                             :questions   => [{ 'question' => 'The green hat is what color?', 'answers' => 'green' }]})
+      Review.textcaptcha_config.must_equal({ :api_key   => '8u5ixtdnq9csc84cok0owswgo',
+                                             :questions => [{ :question => 'The green hat is what color?', :answers => 'green' }]})
     end
 
     it 'should be configured with textcaptcha.yml' do
-      Widget.textcaptcha_config[:api_key].must_equal          '6eh1co0j12mi2ogcoggkkok4o'
-      Widget.textcaptcha_config[:bcrypt_salt].must_equal      '$2a$10$qhSefD6gKtmq6M0AzXk4CO'
-      Widget.textcaptcha_config[:bcrypt_cost].must_equal      1
+      Widget.textcaptcha_config[:api_key].must_equal '6eh1co0j12mi2ogcoggkkok4o'
       Widget.textcaptcha_config[:questions].length.must_equal 10
     end
   end