door_mat 0.0.5

data/spec/controllers/door_mat/manage_email_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+module DoorMat
+  describe ManageEmailController do
+    routes { DoorMat::Engine.routes }
+    let(:user) { {email: 'user@example.com', password: 'k#dkvKfdj38g!'} }
+
+    describe '#create' do
+      render_views
+
+      it 'redirects back after successfully adding a new email' do
+        _, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        DoorMat.configuration.add_email_success_url = [ :request, :referer ]
+
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        allow(DoorMat::ActivityConfirmEmail).to receive(:for)
+        get :create, email: {address: 'other_user@example.com'}
+        expect(flash[:notice]).to match(/New email address successfully added/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+        DoorMat.configuration.add_email_success_url = [:main_app, :account_show_url]
+      end
+
+      it 'renders new if the submitted email is not valid' do
+        _, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        get :create, email: {address: 'invalid_email'}
+        expect(response.body).to match(/Address is invalid/)
+        expect(response).to have_http_status(200)
+      end
+
+    end
+
+    describe '#destroy' do
+
+      it 'can delete the non primary email attached to an actor' do
+        actor, session = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        email = actor.emails.first
+        email.confirmed!
+
+        other_email = DoorMat::Email.for('other_user@example.com')
+        controller = Object.new
+        allow(DoorMat::ActivityConfirmEmail).to receive(:for)
+        DoorMat::Process::ManageEmail.add(other_email, actor, controller)
+        other_email = actor.emails.last
+        other_email.primary!
+
+        TestHelper::sign_out(session)
+        actor, _ = TestHelper::sign_in_existing_actor('other_user@example.com', user[:password])
+
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        expect(actor.emails.count).to eq 2
+        get :destroy, {email: email.to_urlsafe_encoded}
+        expect(actor.emails.count).to eq 1
+        expect(flash[:notice]).to match(/Email deleted/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+      it 'can not delete the email used to sign in to the current session' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        email = actor.emails.first
+        email.confirmed!
+
+        other_email = DoorMat::Email.for('other_user@example.com')
+        controller = Object.new
+        allow(DoorMat::ActivityConfirmEmail).to receive(:for)
+        DoorMat::Process::ManageEmail.add(other_email, actor, controller)
+        other_email = actor.emails.last
+        other_email.primary!
+
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        expect(actor.emails.count).to eq 2
+        get :destroy, {email: email.to_urlsafe_encoded}
+        expect(actor.emails.count).to eq 2
+        expect(flash[:alert]).to match(/Can not delete the email address you are currently logged in with/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+      it 'can not delete the only email attached to an actor' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        email = actor.emails.first
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        expect(actor.emails.count).to eq 1
+        get :destroy, {email: email.to_urlsafe_encoded}
+        expect(actor.emails.count).to eq 1
+        expect(flash[:alert]).to match(/Can not delete the only email address associated with this account/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+      it 'can not delete the primary email attached to an actor' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+
+        other_email = DoorMat::Email.for('other_user@example.com')
+        controller = Object.new
+        allow(DoorMat::ActivityConfirmEmail).to receive(:for)
+        DoorMat::Process::ManageEmail.add(other_email, actor, controller)
+        other_email.primary!
+
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        expect(actor.emails.count).to eq 2
+        get :destroy, {email: other_email.to_urlsafe_encoded}
+        expect(actor.emails.count).to eq 2
+        expect(flash[:alert]).to match(/Primary email can not be deleted/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+      it 'can not delete an email attached to a different actor' do
+        actor = TestHelper::create_signed_up_actor_with_confirmed_email_address('other_user@example.com')
+        email = actor.emails.first
+        _, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        expect(actor.emails.count).to eq 1
+        expect(DoorMat::Email.all.count).to eq 2
+        get :destroy, {email: email.to_urlsafe_encoded}
+        expect(actor.emails.count).to eq 1
+        expect(DoorMat::Email.all.count).to eq 2
+        expect(flash[:alert]).to match(/The specified email can not be deleted/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+      it 'can not delete an email that is not in the system' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        email = DoorMat::Email.for('other_user@example.com')
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        expect(actor.emails.count).to eq 1
+        get :destroy, {email: email.to_urlsafe_encoded}
+        expect(actor.emails.count).to eq 1
+        expect(flash[:alert]).to match(/The specified email can not be deleted/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+    end
+
+    describe '#set_primary_email' do
+
+      it 'succeed at setting the primary email' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+        email = actor.emails.first
+        email.confirmed!
+
+        other_email = DoorMat::Email.for('other_user@example.com')
+        controller = Object.new
+        allow(DoorMat::ActivityConfirmEmail).to receive(:for)
+        DoorMat::Process::ManageEmail.add(other_email, actor, controller)
+        other_email = actor.emails.last
+        other_email.primary!
+
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        post :set_primary_email, {email: email.to_urlsafe_encoded}
+        expect(flash[:notice]).to match(/Primary email was set/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+      it 'fails at setting the primary email if the email is not confirmed' do
+        actor, _ = TestHelper::create_signed_in_actor_with_confirmed_email_address(user[:email], user[:password])
+
+        other_email = DoorMat::Email.for('other_user@example.com')
+        controller = Object.new
+        allow(DoorMat::ActivityConfirmEmail).to receive(:for)
+        DoorMat::Process::ManageEmail.add(other_email, actor, controller)
+        other_email = actor.emails.last
+        other_email.not_confirmed!
+
+        @request.headers["HTTP_REFERER"] = '/some_path'
+        post :set_primary_email, {email: other_email.to_urlsafe_encoded}
+        expect(flash[:alert]).to match(/Primary email could not be set/)
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/some_path')
+      end
+
+    end
+
+  end
+end

data/spec/controllers/door_mat/password_less_session_controller_spec.rb

@@ -0,0 +1,344 @@
+require 'spec_helper'
+
+module DoorMat
+  describe PasswordLessSessionController do
+    include EmailSpec::Helpers
+    include EmailSpec::Matchers
+
+    describe '#create' do
+      render_views
+
+      def accept_valid_token_get_request(via_post = true)
+        admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+        DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/access_token/big_ticket')
+        expect(DoorMat::AccessToken.first.single_use?).to be true
+
+        e = open_last_email_for("user1@example.com")
+        link_in_email = links_in_email(e).select {|url| /access_token/.match(url)}.first
+        token = test_only_session_guid_anywhere_regex.match(link_in_email)[0]
+        if via_post
+          post :access_token_post, access_token: {token_for: :big_ticket, identifier: token}, use_route: :door_mat
+        else
+          get :access_token, token_for: :big_ticket, token: token, use_route: :door_mat
+        end
+
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/draw_results')
+        expect(DoorMat::AccessToken.first.used?).to be true
+      end
+
+      it 'accepts a valid access token request via post' do
+        accept_valid_token_get_request(via_post = true)
+      end
+
+      it 'accepts a valid access token request via get' do
+        accept_valid_token_get_request(via_post = false)
+      end
+
+      def reject_token_request_that_fail_address_validation(via_post = true, validation_method = :reject_cheaters)
+        admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+        DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+
+        case validation_method
+          when :reject_cheaters
+            user_address = 'cheat@cheater.com'
+            DoorMat.configuration.password_less_sessions[:big_ticket][:validate] = -> (address) { /@cheater.com\z/.match(address).blank? } # Don't let those cheaters play the game...
+          when :existing_members_only
+            user_address = 'bob@example.com'
+            DoorMat.configuration.password_less_sessions[:big_ticket][:validate] = -> (address) { DoorMat::Email.count_matching(address) > 0 } # Must be a registered user to play the game...
+        end
+
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>user_address, "confirm_identifier"=>user_address}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/access_token/big_ticket')
+        expect(DoorMat::AccessToken.first.single_use?).to be true
+
+        e = open_last_email_for(user_address)
+        link_in_email = links_in_email(e).select {|url| /access_token/.match(url)}.first
+        token = test_only_session_guid_anywhere_regex.match(link_in_email)[0]
+        if via_post
+          post :access_token_post, access_token: {token_for: :big_ticket, identifier: token}, use_route: :door_mat
+        else
+          get :access_token, token_for: :big_ticket, token: token, use_route: :door_mat
+        end
+
+        expect(response).to have_http_status(200)
+        expect(response.body).to match(/Something looks wrong with your access token/)
+        expect(DoorMat::AccessToken.count).to eq(0)
+
+        DoorMat.configuration.password_less_sessions[:big_ticket][:validate] = false
+      end
+
+      it 'reject token requests that fail address validation via post' do
+        reject_token_request_that_fail_address_validation(via_post = true, validation_method = :reject_cheaters)
+        reject_token_request_that_fail_address_validation(via_post = true, validation_method = :existing_members_only)
+      end
+
+      it 'reject token requests that fail address validation via get' do
+        reject_token_request_that_fail_address_validation(via_post = false, validation_method = :reject_cheaters)
+        reject_token_request_that_fail_address_validation(via_post = false, validation_method = :existing_members_only)
+      end
+
+      def accept_token_request_that_succeed_address_validation(via_post = true, validation_method = :reject_cheaters)
+        admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+        DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+
+        user_address = 'bob@example.com'
+        case validation_method
+          when :reject_cheaters
+            DoorMat.configuration.password_less_sessions[:big_ticket][:validate] = -> (address) { /@cheater.com\z/.match(address).blank? } # Don't let those cheaters play the game...
+          when :existing_members_only
+            DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(user_address, 'user_password')
+            DoorMat.configuration.password_less_sessions[:big_ticket][:validate] = -> (address) { DoorMat::Email.count_matching(address) > 0 } # Must be a registered user to play the game...
+        end
+
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>user_address, "confirm_identifier"=>user_address}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/access_token/big_ticket')
+        expect(DoorMat::AccessToken.first.single_use?).to be true
+
+        e = open_last_email_for(user_address)
+        link_in_email = links_in_email(e).select {|url| /access_token/.match(url)}.first
+        token = test_only_session_guid_anywhere_regex.match(link_in_email)[0]
+        if via_post
+          post :access_token_post, access_token: {token_for: :big_ticket, identifier: token}, use_route: :door_mat
+        else
+          get :access_token, token_for: :big_ticket, token: token, use_route: :door_mat
+        end
+
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/draw_results')
+        expect(DoorMat::AccessToken.first.used?).to be true
+
+        DoorMat.configuration.password_less_sessions[:big_ticket][:validate] = false
+      end
+
+      it 'accept token requests that succeed address validation via post 1' do
+        accept_token_request_that_succeed_address_validation(via_post = true, validation_method = :reject_cheaters)
+      end
+
+      it 'accept token requests that succeed address validation via post 2' do
+        accept_token_request_that_succeed_address_validation(via_post = true, validation_method = :existing_members_only)
+      end
+
+      it 'accept token requests that succeed address validation via get 1' do
+        accept_token_request_that_succeed_address_validation(via_post = false, validation_method = :reject_cheaters)
+      end
+
+      it 'accept token requests that succeed address validation via get 1' do
+        accept_token_request_that_succeed_address_validation(via_post = false, validation_method = :existing_members_only)
+      end
+
+      def reject_malformed_late_inexistent_token_request(via_post = true)
+        admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+        DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+        expect(response).to have_http_status(302)
+        expect(response).to redirect_to('/access_token/big_ticket')
+        expect(DoorMat::AccessToken.first.single_use?).to be true
+
+        e = open_last_email_for("user1@example.com")
+        link_in_email = links_in_email(e).select {|url| /access_token/.match(url)}.first
+        token = test_only_session_guid_anywhere_regex.match(link_in_email)[0]
+
+        if via_post
+          post :access_token_post, access_token: {token_for: :big_ticket, identifier: token[0..-2]}, use_route: :door_mat
+        else
+          get :access_token, token_for: :big_ticket, token: token[0..-2], use_route: :door_mat
+        end
+
+        expect(response).to have_http_status(200)
+        expect(response.body).to match(/format of your access token is invalid/)
+        expect(DoorMat::AccessToken.first.used?).to be false
+
+        wait_two_days
+
+        if via_post
+          post :access_token_post, access_token: {token_for: :big_ticket, identifier: token}, use_route: :door_mat
+        else
+          get :access_token, token_for: :big_ticket, token: token, use_route: :door_mat
+        end
+
+        expect(response).to have_http_status(200)
+        expect(response.body).to match(/Something looks wrong with your access token/)
+        expect(DoorMat::AccessToken.count).to eq(0)
+
+        token[0..7] = 'deadbeef'
+        if via_post
+          post :access_token_post, access_token: {token_for: :big_ticket, identifier: token}, use_route: :door_mat
+        else
+          get :access_token, token_for: :big_ticket, token: token, use_route: :door_mat
+        end
+
+        expect(response).to have_http_status(200)
+        expect(response.body).to match(/Something looks wrong with your access token/)
+      end
+
+      it 'it rejects a malformed, late or inexistent token request via post' do
+        reject_malformed_late_inexistent_token_request(via_post = true)
+      end
+
+      it 'it rejects a malformed, late or inexistent token request via get' do
+        reject_malformed_late_inexistent_token_request(via_post = false)
+      end
+
+      it 'raise an exception' do
+        admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+        DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+
+        allow(DoorMat::PasswordLessSessionMailer).to receive(:send_token).and_raise(RuntimeError)
+        expect {
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+        }.to raise_error(RuntimeError)
+      end
+
+      it 'rejects a submission where identifier and confirmation does not match' do
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"wrong_email@example.com"}, "commit"=>"Request access token", "token_for"=>:big_ticket}
+        expect(response.body).to match(/The identifier provided does not match the confirmation field/)
+        expect(response).to have_http_status(200)
+      end
+
+      it 'rejects a submission where identifier is blank' do
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"", "confirm_identifier"=>"user1@example.com"}, "commit"=>"Request access token", "token_for"=>:big_ticket}
+        expect(response.body).to match(/The identifier can not be blank/)
+        expect(response).to have_http_status(200)
+      end
+
+      it 'rejects a submission where identifier is not a valid address' do
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"invalid_identifier", "confirm_identifier"=>"user1@example.com"}, "commit"=>"Request access token", "token_for"=>:big_ticket}
+        expect(response.body).to match(/The identifier is expected to be a valid email address/)
+        expect(response).to have_http_status(200)
+      end
+
+      it 'rejects a submission where token_for is not valid' do
+        post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com"}, "commit"=>"Request access token", "token_for"=>:invalid_token}
+        expect(response.body).to match(/Could not create a request token based on the information provided/)
+        expect(response).to have_http_status(200)
+      end
+
+      describe 'the public, private and remember me behavior' do
+
+        describe 'With default config' do
+
+          before(:context) do
+            reset_default_config
+          end
+          after (:context) do
+            reset_default_config
+          end
+
+          before(:example) do
+            admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+            DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+          end
+
+          it 'requests public_computer without remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"1", "remember_me"=>"0"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.public_computer?).to be true
+          end
+
+          it 'requests public_computer with remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"1", "remember_me"=>"1"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.public_computer?).to be true
+          end
+
+          it 'requests private_computer without remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"0", "remember_me"=>"0"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.private_computer?).to be true
+          end
+
+          it 'requests private_computer with remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"0", "remember_me"=>"1"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.private_computer?).to be true
+          end
+
+        end
+
+
+        describe 'When remember_me is allowed only on a private computer' do
+
+          before(:context) do
+            reset_default_config
+            DoorMat.configuration.allow_remember_me_feature = true
+          end
+          after (:context) do
+            reset_default_config
+          end
+
+          before(:example) do
+            admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+            DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+          end
+
+          it 'requests public_computer without remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"1", "remember_me"=>"0"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.public_computer?).to be true
+          end
+
+          it 'requests public_computer with remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"1", "remember_me"=>"1"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.public_computer?).to be true
+          end
+
+          it 'requests private_computer without remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"0", "remember_me"=>"0"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.private_computer?).to be true
+          end
+
+          it 'requests private_computer with remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"0", "remember_me"=>"1"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.remember_me?).to be true
+          end
+
+        end
+
+
+        describe 'When remember_me is allowed on both public and private computers' do
+
+          before(:context) do
+            reset_default_config
+            DoorMat.configuration.allow_remember_me_feature = true
+            DoorMat.configuration.remember_me_require_private_computer_confirmation = false
+          end
+          after (:context) do
+            reset_default_config
+          end
+
+          before(:example) do
+            admin = {email: Rails.application.secrets.admin_account_email, password: Rails.application.secrets.admin_account_pwd}
+            DoorMat::TestHelper.create_signed_up_actor_with_confirmed_email_address(admin[:email], admin[:password])
+          end
+
+          it 'requests public_computer without remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"1", "remember_me"=>"0"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.public_computer?).to be true
+          end
+
+          it 'requests public_computer with remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"1", "remember_me"=>"1"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.remember_me?).to be true
+          end
+
+          it 'requests private_computer without remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"0", "remember_me"=>"0"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.private_computer?).to be true
+          end
+
+          it 'requests private_computer with remember_me' do
+            post :create, {"utf8"=>"✓", "access_token"=>{"identifier"=>"user1@example.com", "confirm_identifier"=>"user1@example.com", "is_public"=>"0", "remember_me"=>"1"}, "commit"=>"Request access token", "token_for"=>:big_ticket}, use_route: :main_app
+            expect(DoorMat::AccessToken.first.remember_me?).to be true
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end