From 065859b90cc5ef403b8f47bd5394b343e556cc4d Mon Sep 17 00:00:00 2001 From: Azul Date: Wed, 23 Mar 2016 21:48:52 +0100 Subject: upgrade: remove references to RestClient CouchRest > 1.2 does not use RestClient anymore. So we should not try to catch its errors. --- .../test/database_method_test.rb | 116 ++++++++++++++ .../test/session_store_test.rb | 168 +++++++++++++++++++++ 2 files changed, 284 insertions(+) create mode 100644 vendor/gems/couchrest_session_store/test/database_method_test.rb create mode 100644 vendor/gems/couchrest_session_store/test/session_store_test.rb (limited to 'vendor/gems/couchrest_session_store/test') 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 -- cgit v1.2.3