1
0
mirror of https://github.com/funamitech/mastodon synced 2024-12-12 13:48:35 +09:00
YuruToot/spec/models/session_activation_spec.rb

142 lines
4.1 KiB
Ruby
Raw Normal View History

# frozen_string_literal: true
require 'rails_helper'
RSpec.describe SessionActivation do
describe '#detection' do
let(:session_activation) { Fabricate(:session_activation, user_agent: 'Chrome/62.0.3202.89') }
it 'sets a Browser instance as detection' do
expect(session_activation.detection).to be_a Browser::Chrome
end
end
describe '#browser' do
before do
allow(session_activation).to receive(:detection).and_return(detection)
end
let(:detection) { instance_double(Browser::Chrome, id: 1) }
let(:session_activation) { Fabricate(:session_activation) }
it 'returns detection.id' do
expect(session_activation.browser).to be 1
end
end
describe '#platform' do
before do
allow(session_activation).to receive(:detection).and_return(detection)
end
let(:session_activation) { Fabricate(:session_activation) }
let(:detection) { instance_double(Browser::Chrome, platform: instance_double(Browser::Platform, id: 1)) }
it 'returns detection.platform.id' do
expect(session_activation.platform).to be 1
end
end
describe '.active?' do
subject { described_class.active?(id) }
2023-05-04 12:49:08 +09:00
context 'when id is absent' do
let(:id) { nil }
it 'returns nil' do
expect(subject).to be_nil
end
end
2023-05-04 12:49:08 +09:00
context 'when id is present' do
let(:id) { '1' }
let!(:session_activation) { Fabricate(:session_activation, session_id: id) }
2023-05-04 12:49:08 +09:00
context 'when id exists as session_id' do
it 'returns true' do
expect(subject).to be true
end
end
2023-05-04 12:49:08 +09:00
context 'when id does not exist as session_id' do
before do
session_activation.update!(session_id: '2')
end
it 'returns false' do
expect(subject).to be false
end
end
end
end
describe '.activate' do
let(:options) { { user: Fabricate(:user), session_id: '1' } }
it 'calls create! and purge_old' do
2023-11-07 18:46:28 +09:00
allow(described_class).to receive(:create!).with(**options)
allow(described_class).to receive(:purge_old)
described_class.activate(**options)
2023-11-07 18:46:28 +09:00
expect(described_class).to have_received(:create!).with(**options)
expect(described_class).to have_received(:purge_old)
end
it 'returns an instance of SessionActivation' do
expect(described_class.activate(**options)).to be_a described_class
end
end
describe '.deactivate' do
2023-05-04 12:49:08 +09:00
context 'when id is absent' do
let(:id) { nil }
it 'returns nil' do
2023-02-17 21:45:27 +09:00
expect(described_class.deactivate(id)).to be_nil
end
end
2023-05-04 12:49:08 +09:00
context 'when id exists' do
2023-11-09 21:57:23 +09:00
let!(:session_activation) { Fabricate(:session_activation) }
2023-11-09 21:57:23 +09:00
it 'destroys the record' do
described_class.deactivate(session_activation.session_id)
2023-11-09 21:57:23 +09:00
expect { session_activation.reload }.to raise_error(ActiveRecord::RecordNotFound)
end
end
end
describe '.purge_old' do
2023-11-09 21:57:23 +09:00
around do |example|
before = Rails.configuration.x.max_session_activations
Rails.configuration.x.max_session_activations = 1
example.run
Rails.configuration.x.max_session_activations = before
end
2023-11-09 21:57:23 +09:00
let!(:oldest_session_activation) { Fabricate(:session_activation, created_at: 10.days.ago) }
let!(:newest_session_activation) { Fabricate(:session_activation, created_at: 5.days.ago) }
it 'preserves the newest X records based on config' do
described_class.purge_old
2023-11-09 21:57:23 +09:00
expect { oldest_session_activation.reload }.to raise_error(ActiveRecord::RecordNotFound)
expect { newest_session_activation.reload }.to_not raise_error
end
end
describe '.exclusive' do
2023-11-09 21:57:23 +09:00
let!(:unwanted_session_activation) { Fabricate(:session_activation) }
let!(:wanted_session_activation) { Fabricate(:session_activation) }
2023-11-09 21:57:23 +09:00
it 'preserves supplied record and destroys all others' do
described_class.exclusive(wanted_session_activation.session_id)
2023-11-09 21:57:23 +09:00
expect { unwanted_session_activation.reload }.to raise_error(ActiveRecord::RecordNotFound)
expect { wanted_session_activation.reload }.to_not raise_error
end
end
end