upgrade: remove references to RestClient

CouchRest > 1.2 does not use RestClient anymore. So we should not try to
catch its errors.

2 files changed, 284 insertions, 0 deletions

diff --git a/vendor/gems/couchrest_session_store/test/database_method_test.rb b/vendor/gems/couchrest_session_store/test/database_method_test.rb
new file mode 100644
index 0000000..18985c3
--- /dev/null
+++ b/vendor/gems/couchrest_session_store/test/database_method_test.rb
@@ -0,0 +1,116 @@
+require_relative 'test_helper'
+
+class DatabaseMethodTest < MiniTest::Test
+
+  class TestModel < CouchRest::Model::Base
+    include CouchRest::Model::DatabaseMethod
+
+    use_database_method :db_name
+    property :dbname, String
+    property :confirm, String
+
+    def db_name
+      "test_db_#{self[:dbname]}"
+    end
+  end
+
+  def test_instance_method
+    doc1 = TestModel.new({:dbname => 'one'})
+    doc1.database.create!
+    assert doc1.database.root.ends_with?('test_db_one')
+    assert doc1.save
+    doc1.update_attributes(:confirm => 'yep')
+
+    doc2 = TestModel.new({:dbname => 'two'})
+    doc2.database.create!
+    assert doc2.database.root.ends_with?('test_db_two')
+    assert doc2.save
+    doc2.confirm = 'sure'
+    doc2.save!
+
+    doc1_copy = CouchRest.get([doc1.database.root, doc1.id].join('/'))
+    assert_equal "yep", doc1_copy["confirm"]
+
+    doc2_copy = CouchRest.get([doc2.database.root, doc2.id].join('/'))
+    assert_equal "sure", doc2_copy["confirm"]
+
+    doc1.database.delete!
+    doc2.database.delete!
+  end
+
+  def test_switch_db
+    doc_red = TestModel.new({:dbname => 'red', :confirm => 'rose'})
+    doc_red.database.create!
+    root = doc_red.database.root
+
+    doc_blue = doc_red.clone
+    doc_blue.dbname = 'blue'
+    doc_blue.database!
+    doc_blue.save!
+
+    doc_blue_copy = CouchRest.get([root.sub('red','blue'), doc_blue.id].join('/'))
+    assert_equal "rose", doc_blue_copy["confirm"]
+
+    doc_red.database.delete!
+    doc_blue.database.delete!
+  end
+
+  #
+  # A test scenario for database_method in which some user accounts
+  # are stored in a seperate temporary database (so that the test
+  # accounts don't bloat the normal database).
+  #
+
+  class User < CouchRest::Model::Base
+    include CouchRest::Model::DatabaseMethod
+
+    use_database_method :db_name
+    property :login, String
+    before_save :create_db
+
+    class << self
+      def get(id, db = database)
+        result = super(id, db)
+        if result.nil?
+          return super(id, choose_database('test-user'))
+        else
+          return result
+        end
+      end
+      alias :find :get
+    end
+
+    protected
+
+    def self.db_name(login = nil)
+      if !login.nil? && login =~ /test-user/
+        'tmp_users'
+      else
+        'users'
+      end
+    end
+
+    def db_name
+      self.class.db_name(self.login)
+    end
+
+    def create_db
+      unless database_exists?(db_name)
+        self.database!
+      end
+    end
+
+  end
+
+  def test_tmp_user_db
+    user1 = User.new({:login => 'test-user-1'})
+    assert user1.save
+    assert User.find(user1.id), 'should find user in tmp_users'
+    assert_equal user1.login, User.find(user1.id).login
+    assert_equal 'test-user-1', User.server.database('couchrest_tmp_users').get(user1.id)['login']
+    assert_raises CouchRest::NotFound do
+      User.server.database('couchrest_users').get(user1.id)
+    end
+  end
+
+end
diff --git a/vendor/gems/couchrest_session_store/test/session_store_test.rb b/vendor/gems/couchrest_session_store/test/session_store_test.rb
new file mode 100644
index 0000000..4fbf30b
--- /dev/null
+++ b/vendor/gems/couchrest_session_store/test/session_store_test.rb
@@ -0,0 +1,168 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+
+class SessionStoreTest < MiniTest::Test
+
+  def test_session_initialization
+    sid, session = store.send :get_session, env, nil
+    assert sid
+    assert_equal Hash.new, session
+  end
+
+  def test_normal_session_flow
+    sid, session = never_expiring_session
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+    store.send :destroy_session, env, sid, {}
+  end
+
+  def test_updating_session
+    sid, session = never_expiring_session
+    session[:bla] = "blub"
+    store.send :set_session, env, sid, session, {}
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+    store.send :destroy_session, env, sid, {}
+  end
+
+  def test_prevent_access_to_design_docs
+    sid = '_design/bla'
+    session = {views: 'my hacked view'}
+    assert_raises CouchRest::NotFound do
+      store_session(sid, session)
+    end
+  end
+
+  def test_unmarshalled_session_flow
+    sid, session = init_session
+    store_session sid, session, :marshal_data => false
+    new_sid, new_session = store.send(:get_session, env, sid)
+    assert_equal sid, new_sid
+    assert_equal session[:key], new_session["key"]
+    store.send :destroy_session, env, sid, {}
+  end
+
+  def test_unmarshalled_data
+    sid, session = init_session
+    store_session sid, session, :marshal_data => false
+    couch = CouchTester.new
+    data = couch.get(sid)["data"]
+    assert_equal session[:key], data["key"]
+  end
+
+  def test_logout_in_between
+    sid, session = never_expiring_session
+    store.send :destroy_session, env, sid, {}
+    other_sid, other_session = store.send(:get_session, env, sid)
+    assert_equal Hash.new, other_session
+  end
+
+  def test_can_logout_twice
+    sid, session = never_expiring_session
+    store.send :destroy_session, env, sid, {}
+    store.send :destroy_session, env, sid, {}
+    other_sid, other_session = store.send(:get_session, env, sid)
+    assert_equal Hash.new, other_session
+  end
+
+  def test_stored_and_not_expired_yet
+    sid, session = expiring_session
+    doc = CouchRest::Session::Document.fetch(sid)
+    expires = doc.send :expires
+    assert expires
+    assert !doc.expired?
+    assert (expires - Time.now) > 0, "Exiry should be in the future"
+    assert (expires - Time.now) <= 300, "Should expire after 300 seconds - not more"
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+  end
+
+  def test_stored_but_expired
+    sid, session = expired_session
+    other_sid, other_session = store.send(:get_session, env, sid)
+    assert_equal Hash.new, other_session, "session should have expired"
+    assert other_sid != sid
+  end
+
+  def test_find_expired_sessions
+    expired, expiring, never_expiring = seed_sessions
+    expired_session_ids = store.expired.map {|row| row['id']}
+    assert expired_session_ids.include?(expired)
+    assert !expired_session_ids.include?(expiring)
+    assert !expired_session_ids.include?(never_expiring)
+  end
+
+  def test_find_never_expiring_sessions
+    expired, expiring, never_expiring = seed_sessions
+    never_expiring_session_ids = store.never_expiring.map {|row| row['id']}
+    assert never_expiring_session_ids.include?(never_expiring)
+    assert !never_expiring_session_ids.include?(expiring)
+    assert !never_expiring_session_ids.include?(expired)
+  end
+
+  def test_cleanup_expired_sessions
+    sid, session = expired_session
+    store.cleanup(store.expired)
+    assert_raises CouchRest::NotFound do
+      CouchTester.new.get(sid)
+    end
+  end
+
+  def test_keep_fresh_during_cleanup
+    sid, session = expiring_session
+    store.cleanup(store.expired)
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+  end
+
+  def test_store_without_expiry
+    sid, session = never_expiring_session
+    couch = CouchTester.new
+    assert_nil couch.get(sid)["expires"]
+    assert_equal [sid, session], store.send(:get_session, env, sid)
+  end
+
+  def app
+    nil
+  end
+
+  def store(options = {})
+    @store ||= CouchRest::Session::Store.new(app, options)
+  end
+
+  def env(settings = {})
+    env ||= settings
+  end
+
+  # returns the session ids of an expired, and expiring and a never
+  # expiring session
+  def seed_sessions
+    [expired_session, expiring_session, never_expiring_session].map(&:first)
+  end
+
+  def never_expiring_session
+    store_session *init_session
+  end
+
+  def expiring_session
+    sid, session = init_session
+    store_session(sid, session, expire_after: 300)
+  end
+
+  def expired_session
+    expire_session *expiring_session
+  end
+
+  def init_session
+    sid, session = store.send :get_session, env, nil
+    session[:key] = "stub"
+    return sid, session
+  end
+
+  def store_session(sid, session, options = {})
+    store.send :set_session, env, sid, session, options
+    return sid, session
+  end
+
+  def expire_session(sid, session)
+    CouchTester.new.update sid,
+      "expires" => (Time.now - 10.minutes).utc.iso8601
+    return sid, session
+  end
+
+end