incline 0.1.5

data/test/lib/data_tables_request_test.rb

@@ -0,0 +1,245 @@
+require 'test_helper'
+
+class DataTablesRequestTest < ActiveSupport::TestCase
+
+  TEST_TABLE_NAME = "test_table_#{SecureRandom.random_number(1<<16).to_s(16).rjust(4,'0')}"
+  TEST_TABLE_CLASS = TEST_TABLE_NAME.classify.to_sym
+
+  def setup
+    # Create a test table.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::create_table TEST_TABLE_NAME do |t|
+        t.string  :name,              null: false,  limit: 100
+        t.string  :classification,                  limit: 100
+      end
+    end
+
+    # And then create a test model.
+    eval <<-EOM
+class #{TEST_TABLE_CLASS} < ActiveRecord::Base
+  self.table_name = #{TEST_TABLE_NAME.inspect}
+end
+    EOM
+
+    # Store the model class for use.
+    @model_class = self.class.const_get TEST_TABLE_CLASS
+
+    @model_class.create name: 'Fred Flintstone', classification: 'Cartoon Character'
+    @model_class.create name: 'Barney Rubble', classification: 'Cartoon Character'
+    @model_class.create name: 'Homer Simpson', classification: 'Cartoon Character'
+    @model_class.create name: 'Percy Jackson', classification: 'Book Character'
+    @model_class.create name: 'Harry Potter', classification: 'Book Character'
+    @model_class.create name: 'George Washington', classification: 'Historical Figure'
+    @model_class.create name: 'Albert Einstein', classification: 'Historical Figure'
+
+    @columns = [
+        { data: 'dt_name', name: 'name', searchable: true, orderable: true },
+        { data: 'dt_class', name: 'classification', searchable: true, orderable: true },
+    ]
+
+  end
+
+  def teardown
+    # Undefine the model class (or at least remove it from the Object namespace).
+    self.class.send :remove_const, TEST_TABLE_CLASS
+
+    # Remove the table from the database.
+    silence_stream STDOUT do
+      ActiveRecord::Migration::drop_table TEST_TABLE_NAME
+    end
+  end
+
+  test 'should flag as not provided' do
+    request = Incline::DataTablesRequest.new do
+      @model_class.all
+    end
+    assert_not request.provided?
+  end
+
+  test 'should require a block' do
+    assert_raises ::ArgumentError do
+      Incline::DataTablesRequest.new
+    end
+  end
+
+  test 'should retrieve all records' do
+    request = Incline::DataTablesRequest.new(
+        draw: 1,
+        start: 0,
+        length: 5,
+        columns: @columns
+    ) do
+      @model_class.all
+    end
+    assert request.provided?
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 1, request.draw
+    assert_equal 7, request.records_total
+    assert_equal 7, request.records_filtered
+    assert_equal 5, request.records.count
+    assert_equal 'Fred Flintstone', request.records.first.name
+
+    request = Incline::DataTablesRequest.new(
+        draw: 10,
+        start: 5,
+        length: 5,
+        columns: @columns
+    ) do
+      @model_class.all
+    end
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 10, request.draw
+    assert_equal 7, request.records_total
+    assert_equal 7, request.records_filtered
+    assert_equal 2, request.records.count
+    assert_equal 'George Washington', request.records.first.name
+  end
+
+  test 'should honor the ordering' do
+    request = Incline::DataTablesRequest.new(
+        draw: 2,
+        start: 0,
+        length: 5,
+        columns: @columns,
+        order: [ { column: 0, dir: 'asc' } ]
+    ) do
+      @model_class.all
+    end
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 2, request.draw
+    assert_equal 'Albert Einstein', request.records.first.name
+
+    request = Incline::DataTablesRequest.new(
+        draw: 2,
+        start: 0,
+        length: 5,
+        columns: @columns,
+        order: [ { column: 1, dir: 'asc' }, { column: 0, dir: 'asc' } ]
+    ) do
+      @model_class.all
+    end
+    assert_equal 'Harry Potter', request.records.first.name
+  end
+
+  test 'should search by text' do
+    request = Incline::DataTablesRequest.new(
+        draw: 3,
+        start: 0,
+        length: 5,
+        columns: @columns,
+        search: { value: 'toon', regex: false },
+        order: [ { column: 0, dir: 'asc' } ]
+    ) do
+      @model_class.all
+    end
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 3, request.draw
+    assert_equal 7, request.records_total
+    assert_equal 3, request.records_filtered
+    assert_equal 3, request.records.count
+    assert_equal 'Barney Rubble', request.records.first.name
+
+    c = @columns.dup
+    c[0][:search] = { value: 'ar', regex: false }
+    request = Incline::DataTablesRequest.new(
+        draw: 3,
+        start: 0,
+        length: 5,
+        columns: c,
+        order: [ { column: 0, dir: 'desc' } ]
+    ) do
+      @model_class.all
+    end
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 7, request.records_total
+    assert_equal 2, request.records_filtered
+    assert_equal 2, request.records.count
+    assert_equal 'Harry Potter', request.records.first.name
+  end
+
+  test 'should search by regex' do
+    request = Incline::DataTablesRequest.new(
+        draw: 4,
+        start: 0,
+        length: 5,
+        columns: @columns,
+        search: { value: /book/i, regex: true },
+        order: [ { column: 0, dir: 'asc' } ]
+    ) do
+      @model_class.all
+    end
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 4, request.draw
+    assert_equal 7, request.records_total
+    assert_equal 2, request.records_filtered
+    assert_equal 2, request.records.count
+    assert_equal 'Harry Potter', request.records.first.name
+
+    c = @columns.dup
+    c[0][:search] = { value: /[ts]on/i, regex: true }
+    request = Incline::DataTablesRequest.new(
+        draw: 4,
+        start: 0,
+        length: 5,
+        columns: c,
+        order: [ { column: 0, dir: 'desc' } ]
+    ) do
+      @model_class.all
+    end
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 7, request.records_total
+    assert_equal 4, request.records_filtered
+    assert_equal 4, request.records.count
+    assert_equal 'Percy Jackson', request.records.first.name
+  end
+
+  test 'should handle errors' do
+    request = Incline::DataTablesRequest.new(
+        draw: 5,
+        start: 0,
+        length: 5,
+        columns: @columns
+    ) do
+      raise 'Uh oh, something bad happened.'
+    end
+
+    assert request.provided?
+    assert request.error?
+    assert_equal 'Uh oh, something bad happened.', request.error
+    assert_equal 5, request.draw
+    assert_equal 0, request.records_total
+    assert_equal 0, request.records_filtered
+    assert_equal 0, request.records.count
+  end
+
+  test 'should refresh' do
+    request = Incline::DataTablesRequest.new(
+        draw: 6,
+        start: 0,
+        length: 5,
+        columns: @columns,
+        search: { value: 'toon', regex: false },
+        order: [ { column: 0, dir: 'desc' } ]
+    ) do
+      @model_class.all
+    end
+    assert_not request.error?, "Did not expect #{request.error.inspect}"
+    assert_equal 6, request.draw
+    assert_equal 7, request.records_total
+    assert_equal 3, request.records_filtered
+    assert_equal 3, request.records.count
+    assert_equal 'Homer Simpson', request.records.first.name
+
+    @model_class.create name: 'Lisa Simpson', classification: 'Cartoon Character'
+    assert_nil request.records.find{|i| i.name == 'Lisa Simpson'}
+
+    assert_equal request, request.refresh!
+    assert_equal 6, request.draw
+    assert_equal 8, request.records_total
+    assert_equal 4, request.records_filtered
+    assert_equal 4, request.records.count
+    assert_equal 'Lisa Simpson', request.records.first.name
+  end
+
+
+end

data/test/lib/date_time_formats_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+class DateTimeFormatsTest < ActiveSupport::TestCase
+
+  test 'should process valid US dates' do
+    {
+        '12/31/2016' => { year: 2016, month: 12, day: 31 },
+        '12/31/2016 11:35' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35 },
+        '12/31/2016 11:35:48' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48 },
+        '12/31/2016 11:35:48.1024' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024 },
+        '12/31/2016 11:35:48.1024 PM' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, ampm: 'P' },
+        '12/31/2016 11:35:48.1024 AM' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, ampm: 'A' },
+        '12/31/2016 11:35:48.0001' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: '0001' },
+        '1/1/2017 1:15' => { year: 2017, month: 1, day: 1, hour: 1, minute: 15 },
+        '01/01/2017 01:15' => { year: 2017, month: '01', day: '01', hour: '01', minute: 15 },
+        '1/1/16' => { year: 16, month: 1, day: 1 },
+        '12/31/2016 11:35PM' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, ampm: 'P' },
+        '12/31/2016 11:35P' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, ampm: 'P' },
+        '12/31/2016 11:35 PM' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, ampm: 'P' },
+        '12/31/2016 11:35 P' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, ampm: 'P' },
+    }.each do |dt, parts|
+      match = Incline::DateTimeFormats::US_DATE_FORMAT.match(dt)
+      assert match, "Should match '#{dt}'."
+      parts.each do |k,v|
+        assert_equal v.to_s, match[k.to_s.upcase], "Part #{k} does not equal '#{v}' for '#{dt}'."
+      end
+    end
+  end
+
+  test 'should reject invalid US dates' do
+    [
+        '12.31.2016',
+        '12-31-2016',
+        '12/31/2016 1550',
+        '12/31/201612:25',
+        '12/31/2016 AM',
+        '12/31/2016 12 PM',
+        '12/31/2016 12P'
+    ].each do |dt|
+      assert_nil Incline::DateTimeFormats::US_DATE_FORMAT.match(dt), "Should not match '#{dt}'."
+    end
+  end
+
+  test 'should process valid ISO-ish dates' do
+    {
+        '2016-12-31' => { year: 2016, month: 12, day: 31 },
+        '2016-12-31 11:35' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35 },
+        '2016-12-31 11:35:48' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48 },
+        '2016-12-31 11:35:48.1024' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024 },
+        '2016-12-31 11:35:48.0001' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: '0001' },
+        '2016-12-31 11:35:48.1024 -05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-05:00' },
+        '2016-12-31 11:35:48.1024-05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-05:00' },
+        '2016-12-31 11:35:48.1024 -0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-0500' },
+        '2016-12-31 11:35:48.1024-0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-0500' },
+        '2016-12-31 11:35:48.1024 +05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+05:00' },
+        '2016-12-31 11:35:48.1024+05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+05:00' },
+        '2016-12-31 11:35:48.1024 +0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+0500' },
+        '2016-12-31 11:35:48.1024+0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+0500' },
+        '2016-12-31 11:35:48.1024Z' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: 'Z' },
+        '2016-12-31 11:35:48.1024 Z' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: 'Z' },
+        '2017-1-1 1:15' => { year: 2017, month: 1, day: 1, hour: 1, minute: 15 },
+        '2017-01-01 01:15' => { year: 2017, month: '01', day: '01', hour: '01', minute: 15 },
+        '2016-12-31T11:35' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35 },
+        '2016-12-31T11:35:48' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48 },
+        '2016-12-31T11:35:48.1024' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024 },
+        '2016-12-31T11:35:48.1024 -05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-05:00' },
+        '2016-12-31T11:35:48.1024-05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-05:00' },
+        '2016-12-31T11:35:48.1024 -0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-0500' },
+        '2016-12-31T11:35:48.1024-0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-0500' },
+        '2016-12-31T11:35:48.1024 +05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+05:00' },
+        '2016-12-31T11:35:48.1024+05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+05:00' },
+        '2016-12-31T11:35:48.1024 +0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+0500' },
+        '2016-12-31T11:35:48.1024+0500' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '+0500' },
+        '2016-12-31T11:35:48.1024Z' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: 'Z' },
+        '2016-12-31T11:35:48.1024 Z' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: 'Z' },
+        '2016-12-31T11:35:48.0001' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: '0001' },
+        '2017-1-1T1:15' => { year: 2017, month: 1, day: 1, hour: 1, minute: 15 },
+        '2017-01-01T01:15' => { year: 2017, month: '01', day: '01', hour: '01', minute: 15 },
+        '16-1-1' => { year: 16, month: 1, day: 1 },
+        '2016-12-31 11:35 PM' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, ampm: 'P' },
+        '2016-12-31 11:35:48 PM' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, ampm: 'P' },
+        '2016-12-31 11:35P' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, ampm: 'P' },
+        '2016-12-31 11:35:48P' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, ampm: 'P' },
+        '2016-12-31 11:35:48.1024 PM -05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-05:00', ampm: 'P' },
+        '2016-12-31 11:35:48.1024P-05:00' => { year: 2016, month: 12, day: 31, hour: 11, minute: 35, second: 48, fraction: 1024, tz: '-05:00', ampm: 'P' },
+    }.each do |dt, parts|
+      match = Incline::DateTimeFormats::ALMOST_ISO_DATE_FORMAT.match(dt)
+      assert match, "Should match '#{dt}'."
+      parts.each do |k,v|
+        assert_equal v.to_s, match[k.to_s.upcase], "Part #{k} does not equal '#{v}' for '#{dt}'."
+      end
+    end
+  end
+
+  test 'should reject invalid ISO-ish dates' do
+    [
+        '2016.12.31',
+        '2016/12/31',
+        '2016-12-31 1550',
+        '2016-12-3112:25',
+        '2016-12-31 -05:00',
+        '2016-12-31-05:00',
+        '2016-12-31 11:45:00 05:00',
+        '2016-12-31Z',
+        '2016-12-31 Z'
+    ].each do |dt|
+      assert_nil Incline::DateTimeFormats::ALMOST_ISO_DATE_FORMAT.match(dt), "Should not match '#{dt}'."
+    end
+  end
+
+end

data/test/lib/global_status_test.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+class GlobalStatusTest < ActiveSupport::TestCase
+
+  def setup
+    @stat = Incline::GlobalStatus.new
+  end
+
+  test 'should allow locking' do
+    begin
+      assert @stat.acquire_lock
+      assert @stat.is_locked?
+      assert @stat.have_lock?
+      assert Incline::GlobalStatus::locked?
+    ensure
+      @stat.release_lock
+    end
+    assert_not @stat.is_locked?
+    assert_not @stat.have_lock?
+    assert_not Incline::GlobalStatus::locked?
+  end
+
+  test 'should allow blocks' do
+    # block is successful, but @stat cannot acquire a lock.
+    Incline::GlobalStatus::lock_for do |stat|
+      assert stat
+      assert stat.is_locked?
+      assert stat.have_lock?
+      assert @stat.is_locked?
+      assert_not @stat.have_lock?
+      assert_not @stat.acquire_lock
+    end
+    assert_not @stat.is_locked?
+
+    # @stat is successful, but block cannot acquire a lock.
+    begin
+      assert @stat.acquire_lock
+      assert @stat.is_locked?
+      assert @stat.have_lock?
+      assert Incline::GlobalStatus::locked?
+      Incline::GlobalStatus::lock_for do |stat|
+        assert_not stat
+      end
+    ensure
+      @stat.release_lock
+    end
+  end
+
+  test 'should be able to set status' do
+    Incline::GlobalStatus::lock_for do |stat|
+      assert stat
+
+      # We haven't set a status, so the default messages should be in place.
+      # There should be no percentage yet either.
+      data = stat.get_status
+      assert data.is_a?(::Hash)
+      assert data[:locked]
+      assert_equal 'The current process is busy.', data[:message]
+      assert data[:percent].blank?
+
+      # The helpers should match.
+      assert_equal data[:message], stat.get_message
+      assert_nil stat.get_percentage
+
+      # The message should be slightly different, but otherwise the data is the same.
+      data = Incline::GlobalStatus::current
+      assert data.is_a?(::Hash)
+      assert data[:locked]
+      assert_equal 'The system is busy.', data[:message]
+      assert data[:percent].blank?
+
+      # Set the message.
+      stat.set_status 'Doing something.', 25
+
+      # The new status should be set correctly.
+      data = stat.get_status
+      assert_equal 'Doing something.', data[:message]
+      assert_equal '25', data[:percent]
+      assert_equal data[:message], stat.get_message
+      assert_equal 25, stat.get_percentage
+
+      # And this should be the same.
+      data = Incline::GlobalStatus::current
+      assert_equal 'Doing something.', data[:message]
+      assert_equal '25', data[:percent]
+    end
+  end
+
+end

data/test/lib/json_log_formatter_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+require 'json'
+require 'ansi/code'
+
+class JsonLogFormatterTest < ActiveSupport::TestCase
+
+  def setup
+    @fmt = Incline::JsonLogFormatter.new
+  end
+
+  test 'should create valid JSON' do
+    t = Time.now
+    s = @fmt.call(Logger::WARN, t, :ignored, 'Something happened!')
+    assert_not s.blank?
+
+    # ends with CRLF?
+    assert s =~ /\r\n\Z/
+
+    h = JSON.parse(s.strip) rescue nil
+    assert h.is_a?(::Hash)
+    assert_equal 'WARN',                          h['level']
+    assert_equal t.strftime('%Y-%m-%d %H:%M:%S'), h['time']
+    assert_equal 'Something happened!',           h['message']
+    assert_equal Rails.application.app_name,      h['app_name']
+    assert_equal Rails.application.app_version,   h['app_version']
+    assert_equal Process.pid,                     h['process_id']
+  end
+
+  test 'should log all CRLF as LF' do
+    h = JSON.parse(@fmt.call(Logger::INFO, Time.now, :ignored, "This message has \r\n CRLF \r\n sequences in it!\r\n").strip)
+    assert_not h['message'] =~ /\r\n/
+    assert h['message'] =~ /\n/
+  end
+
+  test 'should strip out ANSI formatting' do
+    test = 'This text has ' + ANSI.ansi('red', :bright, :red) + ' and ' + ANSI.ansi('green', :green) + ' text.'
+    clean = 'This text has red and green text.'
+    assert_not_equal clean, test
+    h = JSON.parse(@fmt.call(Logger::INFO, Time.now, :ignored, test))
+    assert_equal clean, h['message']
+  end
+
+end

data/test/lib/log_test.rb

@@ -0,0 +1,36 @@
+require 'test_helper'
+
+class LogTest < ActiveSupport::TestCase
+
+  def setup
+    @io = StringIO.new
+  end
+
+  test 'output is always set' do
+    assert Incline::Log::get_output
+  end
+
+  test 'output can be changed' do
+    begin
+      Incline::Log::set_output @io
+      assert_equal @io, Incline::Log::get_output
+
+      Incline::Log::debug   'This is a debug message.'
+      Incline::Log::info    'This is an informative message.'
+      Incline::Log::warn    'This is a warning message.'
+      Incline::Log::error   'This is an error message.'
+
+      assert @io.string =~ /DEBUG/
+      assert @io.string =~ /INFO/
+      assert @io.string =~ /WARN/
+      assert @io.string =~ /ERROR/
+
+    ensure
+      Incline::Log::set_output false
+    end
+    assert_not_equal @io, Incline::Log::get_output
+    Incline::Log::info 'If you see this, everything is OK.'
+    assert_not @io.string =~ /everything is OK/
+  end
+
+end

data/test/lib/recaptcha_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+class RecaptchaTest < ActiveSupport::TestCase
+  
+  test 'should be disabled by default in test mode' do
+    assert ::Incline::Recaptcha.disabled?
+  end
+  
+  test 'should enable for testing' do
+    assert_not ::Incline::Recaptcha.send :enabled_for_testing?
+    ::Incline::Recaptcha.send(:enable_for_testing) do
+      assert ::Incline::Recaptcha.send :enabled_for_testing?
+    end
+    assert_not ::Incline::Recaptcha.send :enabled_for_testing?
+  end
+  
+  test 'when configured should allow testing' do
+    skip if ::Incline::Recaptcha.public_key.blank? || ::Incline::Recaptcha.private_key.blank?
+
+    assert ::Incline::Recaptcha.disabled?
+    ::Incline::Recaptcha.send(:enable_for_testing) do
+      assert_not ::Incline::Recaptcha.disabled?
+    end
+    assert ::Incline::Recaptcha.disabled?
+  end
+  
+  test 'add should work appropriately' do
+    assert ::Incline::Recaptcha.add.blank?
+
+    ::Incline::Recaptcha.send(:enable_for_testing, 'my_site_key', 'my_secret_key') do
+      html = ::Incline::Recaptcha.add
+      assert_not html.blank?
+      assert html =~ /my_site_key/
+      assert_nil html =~ /my_secret_key/
+    end
+  end
+  
+  test 'verify should work appropriately' do
+    
+    assert_raises ::ArgumentError do
+      ::Incline::Recaptcha.verify
+    end
+    
+    
+    # fake request class.
+    req = Class.new do
+      def params
+        @params ||= { 'g-recaptcha-response' => ::Incline::Recaptcha::DISABLED.partition('|')[2] }
+      end
+      def remote_ip
+        @remote_ip ||= ::Incline::Recaptcha::DISABLED.partition('|')[0]
+      end
+    end.new
+    
+    # and standard parameters.
+    rem_ip, _, resp = ::Incline::Recaptcha::DISABLED.partition('|')
+
+    # these are all valid method calls.
+    assert ::Incline::Recaptcha.verify(req)
+    assert ::Incline::Recaptcha.verify(request: req)
+    assert ::Incline::Recaptcha.verify(remote_ip: rem_ip, response: resp)
+    
+    req.params['g-recaptcha-response'] = 'something-invalid'
+    
+    # these should all fail
+    assert_not ::Incline::Recaptcha.verify(req)
+    assert_not ::Incline::Recaptcha.verify(request: req)
+    assert_not ::Incline::Recaptcha.verify(remote_ip: rem_ip, response: 'something-invalid')
+    
+  end
+  
+  
+  
+  
+end

data/test/lib/user_manager_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class UserManagerTest < ::ActiveSupport::TestCase
+  
+  class MyAuthEngine < ::Incline::AuthEngineBase
+    def initialize(options = {})
+      @valid_password = options[:valid_password] || 'password'
+    end
+    
+    def authenticate(email, password, client_ip)
+      return nil unless password == @valid_password
+      ::Incline::User.find_by(email: email)
+    end
+  end
+  
+  def setup
+    @manager = ::Incline::UserManager.new valid_password: 'super-secret'
+    @user = incline_users(:one)
+  end
+  
+  test 'password should be based on database value' do
+    assert_nil @manager.authenticate(@user.email, 'super-secret', '0.0.0.0')
+    assert @manager.authenticate(@user.email, 'Password123', '0.0.0.0')
+  end
+  
+  test 'password should be based on auth engine' do
+    @manager.register_auth_engine ::UserManagerTest::MyAuthEngine, 'example.com'
+    assert @manager.authenticate(@user.email, 'super-secret', '0.0.0.0')
+    assert_nil @manager.authenticate(@user.email, 'Password123', '0.0.0.0')
+  end
+  
+  test 'default instance also works with auth engine' do
+    assert ::Incline::UserManager.authenticate(@user.email, 'Password123', '0.0.0.0')
+    assert_nil ::Incline::UserManager.authenticate(@user.email, 'password', '0.0.0.0')
+    begin
+      ::Incline::UserManager.register_auth_engine(::UserManagerTest::MyAuthEngine, 'example.com')
+      assert_nil ::Incline::UserManager.authenticate(@user.email, 'Password123', '0.0.0.0')
+      assert ::Incline::UserManager.authenticate(@user.email, 'password', '0.0.0.0')
+    ensure
+      ::Incline::UserManager.clear_auth_engine('example.com')
+    end
+    
+  end
+  
+  
+  
+end

data/test/lib/work_path_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class WorkPathTest < ActiveSupport::TestCase
+
+  test 'should have a location' do
+    assert Incline::WorkPath::location
+    assert Dir.exist?(Incline::WorkPath::location)
+    path = Incline::WorkPath::path_for 'test.file'
+
+    File.write path, 'Hello World'
+    assert File.exist?(path)
+    assert_equal 'Hello World', File.read(path)
+
+    File.delete path
+    assert_not File.exist?(path)
+  end
+
+end