redcrumbs 0.5.0 → 0.5.1

data/spec/redcrumbs/creation_spec.rb

@@ -0,0 +1,271 @@
+require 'spec_helper.rb'
+
+describe Redcrumbs::Creation do
+  let(:name){ 'Paperboy' }
+  let(:score){ 12934 }
+
+  describe 'model' do
+    subject { Game.create(:name => name, :highscore => score) }
+
+    context 'when created' do
+      it { expect(subject.crumbs.count).to eq(1) }
+    end
+
+    context 'when single tracked attribute updated' do
+      it do 
+        expect {
+          subject.update_attributes(:highscore => 12935) 
+        }.to change { subject.crumbs.count }.by(1)
+      end
+    end
+
+    context 'when multiple tracked attributes updated' do
+      it do 
+        expect {
+          subject.update_attributes(:highscore => 12935, :name => 'Paperboy 2') 
+        }.to change { subject.crumbs.count }.by(1)
+      end
+    end
+
+    context 'when updated twice' do
+      it do 
+        expect {
+          subject.update_attributes(:highscore => 12935)
+          subject.update_attributes(:name => 'Paperboy 2')
+        }.to change { subject.crumbs.count }.by(2)
+      end
+    end
+
+    context 'when untracked attribute updated' do
+      it do 
+        expect {
+          subject.update_attributes(:platform => 'Commodore 64')
+        }.to change { subject.crumbs.count }.by(0)
+      end
+    end
+  end
+
+
+  describe 'conditional creation' do
+    before { @default_options = Game.redcrumbs_options.dup }
+    after  { Game.redcrumbed(@default_options) }
+
+    context 'when `if` condition unsatisfied' do
+      before  { Game.redcrumbed(:only => [:name], :if => :new_record?) }
+      subject { Game.new(name: name) }
+
+      it { expect { subject.save }.to change { subject.crumbs.count }.by(0) }
+    end
+
+    context 'when `unless` condition satisfied' do
+      before  { Game.redcrumbed(:only => [:name], :unless => :persisted?) }
+      subject { Game.new(name: name) }
+
+      it { expect { subject.save }.to change { subject.crumbs.count }.by(0) }
+    end
+  end
+
+
+  describe "a created crumb's attributes" do
+    let(:computer_player) { ComputerPlayer.create(:name => 'Ramsey') }
+    let(:player) { Player.create(:name => 'Jon Hope') }
+
+    let(:game) { Game.create(:name => name, :highscore => score, :high_scorer => computer_player) }
+
+    before { game.update_attributes(:highscore => 15000, :platform => 'Amiga', :high_scorer => player) }
+
+    subject { game.crumbs.last }
+
+    it { is_expected.to have_attributes(:modifications => { 'highscore' => [12934, 15000] }) }
+    it { is_expected.to have_attributes(:subject_id => game.id) }
+    it { is_expected.to have_attributes(:subject_type => game.class.name) }
+    it { is_expected.to have_attributes(:creator_id => player.id) }
+    it { is_expected.to have_attributes(:creator_type => player.class.name) }
+    it { is_expected.to have_attributes(:target_id => computer_player.id) }
+    it { is_expected.to have_attributes(:target_type => computer_player.class.name) }
+  end
+
+
+  describe '.watched_changes' do
+    let(:game) { Game.create(:name => name, :highscore => score) }
+    subject { game.watched_changes }
+
+    context 'when changes made' do
+      before { game.assign_attributes(:name => 'Papergal', :platform => 'C64')}
+
+      it { is_expected.to include(:name) }
+      it { is_expected.not_to include(:platform) }
+    end
+
+    context 'when no changes made' do
+      it { is_expected.to eq({}) }
+    end
+  end
+
+
+  describe '.storable_attributes_keys' do
+    let!(:default_options) { Game.redcrumbs_options[:store].dup }
+    after { Game.redcrumbs_options[:store] = default_options}
+    subject { Game.new.storable_attributes_keys }
+
+    context 'when `only` set' do
+      before { Game.redcrumbs_options[:store] = {only: [:name]} }
+
+      it { is_expected.to eq([:name]) }
+    end
+
+    context 'when `except` set' do
+      before { Game.redcrumbs_options[:store] = {except: [:name]} }
+
+      it { is_expected.to include(:id, :created_at, :updated_at) }
+      it { is_expected.not_to include(:name) }
+    end
+
+    context 'when `only` and `except` set' do
+      before { Game.redcrumbs_options[:store] = {except: [:name], only: [:id]}}
+
+      it { is_expected.to eq([:id]) }
+    end
+
+    context 'when neither `only` or `except` set' do
+      before { Game.redcrumbs_options[:store] = {} }
+
+      it { is_expected.to eq([]) }
+    end
+  end
+
+
+  describe '.storeable_attributes' do
+    let!(:default_options) { Game.redcrumbs_options[:store].dup }
+    after { Game.redcrumbs_options[:store] = default_options}
+    subject { Game.new(name: name).storeable_attributes }
+
+    context 'when `only` set' do
+      before { Game.redcrumbs_options[:store] = {only: [:name]} }
+
+      it { is_expected.to eq({'name' => name}) }
+    end
+
+    context 'when `except` set' do
+      before { Game.redcrumbs_options[:store] = {except: [:name]} }
+
+      it { is_expected.to include('id', 'created_at', 'updated_at') }
+      it { is_expected.not_to include('name') }
+    end
+
+    context 'when `only` and `except` set' do
+      before { Game.redcrumbs_options[:store] = {except: [:name], only: [:id]}}
+
+      it { is_expected.to eq('id' => nil) }
+    end
+
+    context 'when neither `only` or `except` set' do
+      before { Game.redcrumbs_options[:store] = {} }
+
+      it { is_expected.to eq({}) }
+    end
+  end
+
+
+  describe '.storable_methods_names' do
+    let!(:default_options) { Game.redcrumbs_options[:store].dup }
+    after { Game.redcrumbs_options[:store] = default_options}
+    subject { Game.new.storable_methods_names }
+
+    context 'when `methods` set' do
+      before { Game.redcrumbs_options[:store] = {methods: [:persisted?]} }
+
+      it { is_expected.to eq([:persisted?]) }
+    end
+
+    context 'when `methods` not set' do
+      before { Game.redcrumbs_options[:store] = {} }
+
+      it { is_expected.to eq([]) }
+    end
+  end
+
+
+  describe '.storable_methods' do
+    let!(:default_options) { Game.redcrumbs_options[:store].dup }
+    after { Game.redcrumbs_options[:store] = default_options}
+    subject { Game.new.storable_methods }
+
+    context 'when `methods` set' do
+      before { Game.redcrumbs_options[:store] = {methods: [:persisted?]} }
+
+      it { is_expected.to include('persisted?') }
+    end
+
+    context 'when `methods` not set' do
+      before { Game.redcrumbs_options[:store] = {} }
+
+      it { is_expected.to eq({}) }
+    end
+  end
+
+
+  describe '.serialized_as_redcrumbs_subject' do
+    let!(:default_options) { Game.redcrumbs_options[:store].dup }
+    after { Game.redcrumbs_options[:store] = default_options}
+    subject { Game.new(name: name).serialized_as_redcrumbs_subject }
+
+    context 'when `store` set' do
+      before { Game.redcrumbs_options[:store] = {only: [:name]} }
+
+      it { is_expected.to eq({'name' => name}) }
+    end
+
+    context 'when `methods` set' do
+      before { Game.redcrumbs_options[:store] = {methods: [:persisted?]} }
+
+      it { is_expected.to eq({'persisted?' => false}) }
+    end
+
+    context 'when `store` and `methods` set' do
+      before { Game.redcrumbs_options[:store] = {only: [:name], methods: [:persisted?]} }
+
+      it { is_expected.to eq({'name' => name, 'persisted?' => false}) }
+    end
+
+    context 'when neither `store` or `methods` set' do
+      before { Game.redcrumbs_options[:store] = {} }
+
+      it { is_expected.to eq({}) }
+    end
+  end
+
+
+  describe '.create_crumb' do
+    let(:game) { Game.new(:name => name, :platform => 'C64') }
+    let(:crumb) { game.create_crumb }
+
+    context 'with created crumb' do
+      subject { crumb }
+      it { is_expected.to have_attributes(:subject => game)}
+      it { is_expected.to respond_to(:modifications)}
+    end
+
+    context 'with created crumb modifications' do
+      subject { crumb.modifications }
+
+      it { is_expected.to include(:name) }
+      it { is_expected.not_to include(:platform) }
+    end
+  end
+
+
+  describe '.notify_changes' do
+    let(:game) { Game.create(:name => name, :platform => 'C64') }
+
+    context 'without watched_changes' do
+      it { expect { game.notify_changes }.to change { game.crumbs.count }.by(0) }
+    end
+
+    context 'with watched_changes' do
+      before { game.name = 'Paperperson' }
+
+      it { expect { game.notify_changes }.to change { game.crumbs.count }.by(1) }
+    end
+  end
+end

data/spec/redcrumbs/crumb_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper.rb'
+
+describe Redcrumbs::Crumb do
+  let(:player) { Player.create(:name => 'Jon Hope') }
+  let(:player_2) { Player.create(:name => 'Ash Dwyer') }
+  let(:game) { Game.create(:name => 'Paperboy', :highscore => 4001) }
+
+  describe 'self.build_with_modifications' do
+    context 'when subject has no changes' do
+      subject { Redcrumbs::Crumb.build_with_modifications(game) }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when subject has no watched changes' do
+      before  { game.platform = 'Spectrum'}
+      subject { Redcrumbs::Crumb.build_with_modifications(game) }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when subject has changes' do
+      before { game.assign_attributes(:highscore => 19000, :name => 'Papergal') }
+
+      subject { Redcrumbs::Crumb.build_with_modifications(game).modifications }
+
+      it { is_expected.not_to eq({}) }
+      it { is_expected.to include('highscore' => [4001, 19000]) }
+      it { is_expected.to include('name' => ['Paperboy', 'Papergal']) }
+    end
+  end
+
+
+  describe 'subject' do
+    let(:crumb) { game.crumbs.last }
+
+    context 'when instantiating a stored subject' do
+      subject! { crumb.subject }
+
+      it { is_expected.to be_present }
+      it { expect(subject.id).to eq(game.id) }
+      it { expect(subject.name).to eq(game.name) }
+      it { expect(subject.highscore).to be_nil }
+      it { expect(crumb).not_to have_loaded_subject }
+    end
+
+    context 'when retrieving a full subject' do
+      subject! { crumb.full_subject }
+
+      it { is_expected.to be_present }
+      it { is_expected.to eq(game) }
+      it { expect(subject.highscore).to eq(game.highscore) }
+      it { expect(crumb).to have_loaded_subject }
+    end
+  end
+
+
+  describe 'creator' do
+    let!(:default_options) { Redcrumbs.store_creator_attributes.dup }
+    let(:crumb) { game.crumbs.last } 
+
+    before do
+      Redcrumbs.store_creator_attributes = [:name]
+      game.update_attributes(:highscore => 20000, :high_scorer => player)
+    end
+
+    after  { Redcrumbs.store_creator_attributes = default_options }
+
+    context 'when nil' do
+      subject(:creator) { game.crumbs.first.creator }
+
+      it { is_expected.not_to be_present }
+    end
+
+    context 'when instantiating from storage' do
+      subject!(:creator) { crumb.creator }
+
+      it { is_expected.to be_present }
+      it { expect(creator.id).to eq(player.id) }
+      it { expect(creator.name).to eq(player.name) }
+      it { expect(creator.created_at).to be_nil }
+      it { expect(crumb).not_to have_loaded_creator }
+    end
+
+    context 'when retrieving a full creator' do
+      subject!(:creator) { crumb.full_creator }
+
+      it { is_expected.to be_present }
+      it { is_expected.to eq(player) }
+      it { expect(creator.created_at.to_i).to eq(player.created_at.to_i) }
+      it { expect(crumb).to have_loaded_creator }
+    end
+  end
+
+
+  describe 'target' do
+    let!(:default_options) { Redcrumbs.store_target_attributes.dup }
+    let(:crumb) { game.crumbs.last } 
+
+    before do
+      Redcrumbs.store_target_attributes = [:name]
+      game.update_attributes(:highscore => 19890, :high_scorer => player)
+      game.update_attributes(:highscore => 20000, :high_scorer => player_2)
+    end
+
+    after  { Redcrumbs.store_target_attributes = default_options }
+
+    context 'when nil' do
+      subject(:target) { game.crumbs.first.target }
+
+      it { is_expected.not_to be_present }
+    end
+
+    context 'when instantiating from storage' do
+      subject!(:target) { crumb.target }
+
+      it { is_expected.to be_present }
+      it { expect(target.id).to eq(player.id) }
+      it { expect(target.name).to eq(player.name) }
+      it { expect(target.created_at).to be_nil }
+      it { expect(crumb).not_to have_loaded_target }
+    end
+
+    context 'when retrieving a full target' do
+      subject!(:target) { crumb.full_target }
+
+      it { is_expected.to be_present }
+      it { is_expected.to eq(player) }
+      it { expect(target.created_at.to_i).to eq(player.created_at.to_i) }
+      it { expect(crumb).to have_loaded_target }
+    end
+  end
+
+
+  describe 'self.initialize' do
+    context 'with modifications' do
+      subject { Redcrumbs::Crumb.new(modifications: {'name' => [nil, 'Paperboy']}).modifications }
+
+      it { is_expected.not_to eq({}) }
+      it { is_expected.to include('name' => [nil, 'Paperboy']) }
+    end
+
+    context 'with subject' do
+      subject { Redcrumbs::Crumb.new(subject: game) }
+
+      it { is_expected.to have_attributes(:subject => game) }
+      it { is_expected.to have_attributes(:subject_id => game.id) }
+      it { is_expected.to have_attributes(:subject_type => game.class.name) }
+    end
+  end
+
+
+  describe '.redis_key' do
+    let!(:crumb) { Redcrumbs::Crumb.new(subject: game) }
+
+    context 'when new' do
+      subject { crumb.redis_key }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when persisted' do
+      before  { crumb.save }
+      subject { crumb.redis_key }
+
+      it { is_expected.to eq("redcrumbs_crumbs:#{crumb.id}")}
+    end
+  end
+
+
+  describe '.mortal?' do
+    let!(:default_value) { Redcrumbs.mortality }
+
+    context 'when unpersisted' do
+      subject { Redcrumbs::Crumb.new(subject: game).mortal? }
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when mortal' do
+      before  { Redcrumbs.mortality = 30.days }
+      after   { Redcrumbs.mortality = default_value }
+      subject { Redcrumbs::Crumb.create(subject: game).mortal? }
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when immortal' do
+      before  { Redcrumbs.mortality = nil }
+      after   { Redcrumbs.mortality = default_value }
+      subject { Redcrumbs::Crumb.create.mortal? }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+
+  describe '.time_to_live' do
+    let!(:default_value) { Redcrumbs.mortality }
+
+    context 'when unpersisted' do
+      subject { Redcrumbs::Crumb.new(subject: game).time_to_live }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when immortal' do
+      before  { Redcrumbs.mortality = nil }
+      after   { Redcrumbs.mortality = default_value }
+      subject { Redcrumbs::Crumb.create(subject: game).time_to_live }
+
+      it { is_expected.to eq(-1) }
+    end
+
+    context 'when mortal' do
+      before  { Redcrumbs.mortality = 30.days }
+      after   { Redcrumbs.mortality = default_value }
+      subject { Redcrumbs::Crumb.create(subject: game) }
+
+      it { expect(subject.time_to_live).to be_truthy }
+      it { expect(subject.time_to_live).to be_within(2.seconds.to_i).of(30.days.to_i) }
+    end
+  end
+
+
+  describe '.expires_at' do
+    let!(:default_value) { Redcrumbs.mortality }
+
+    context 'when unpersisted' do
+      let(:crumb) { Redcrumbs::Crumb.new }
+      subject { crumb.expires_at }
+
+      it { is_expected.to be_nil }
+    end
+
+    context 'when mortal' do
+      before  { Redcrumbs.mortality = 30.days }
+      after   { Redcrumbs.mortality = default_value }
+      let(:crumb) { Redcrumbs::Crumb.create }
+      subject { crumb.expires_at.to_i }
+
+      it { is_expected.to be_truthy }
+      it { is_expected.to eq((Time.now + crumb.time_to_live).to_i) }
+    end
+
+    context 'when immortal' do
+      before  { Redcrumbs.mortality = nil }
+      after   { Redcrumbs.mortality = default_value }
+      subject { Redcrumbs::Crumb.new.expires_at }
+
+      it { is_expected.to be_nil }
+    end
+  end
+end