statesman 3.4.1 → 3.5.0

data/spec/generators/statesman/mongoid_transition_generator_spec.rb

@@ -4,18 +4,20 @@ require "generators/statesman/mongoid_transition_generator"
 
 describe Statesman::MongoidTransitionGenerator, type: :generator do
   describe "the model contains the correct words" do
-    before { run_generator %w[Yummy::Bacon Yummy::BaconTransition] }
     subject { file("app/models/yummy/bacon_transition.rb") }
 
-    it { is_expected.not_to contain(%r{:yummy/bacon}) }
+    before { run_generator %w[Yummy::Bacon Yummy::BaconTransition] }
+
+    it { is_expected.to_not contain(%r{:yummy/bacon}) }
     it { is_expected.to contain(/class_name: 'Yummy::Bacon'/) }
   end
 
   describe "the model contains the correct words" do
-    before { run_generator %w[Bacon BaconTransition] }
     subject { file("app/models/bacon_transition.rb") }
 
-    it { is_expected.not_to contain(/class_name:/) }
-    it { is_expected.not_to contain(/CreateYummy::Bacon/) }
+    before { run_generator %w[Bacon BaconTransition] }
+
+    it { is_expected.to_not contain(/class_name:/) }
+    it { is_expected.to_not contain(/CreateYummy::Bacon/) }
   end
 end

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -6,14 +6,9 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
     prepare_transitions_table
     prepare_other_model_table
     prepare_other_transitions_table
-  end
 
-  before do
     Statesman.configure { storage_adapter(Statesman::Adapters::ActiveRecord) }
-  end
-  after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
 
-  before do
     MyActiveRecordModel.send(:include, Statesman::Adapters::ActiveRecordQueries)
     MyActiveRecordModel.class_eval do
       def self.transition_class
@@ -36,9 +31,12 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
         :initial
       end
     end
+
+    MyActiveRecordModel.send(:has_one, :other_active_record_model)
+    OtherActiveRecordModel.send(:belongs_to, :my_active_record_model)
   end
-  before { MyActiveRecordModel.send(:has_one, :other_active_record_model) }
-  before { OtherActiveRecordModel.send(:belongs_to, :my_active_record_model) }
+
+  after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
 
   let!(:model) do
     model = MyActiveRecordModel.create
@@ -66,7 +64,7 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
       subject { MyActiveRecordModel.in_state(:succeeded) }
 
       it { is_expected.to include model }
-      it { is_expected.not_to include other_model }
+      it { is_expected.to_not include other_model }
     end
 
     context "given multiple states" do
@@ -104,23 +102,26 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
   describe ".not_in_state" do
     context "given a single state" do
       subject { MyActiveRecordModel.not_in_state(:failed) }
+
       it { is_expected.to include model }
-      it { is_expected.not_to include other_model }
+      it { is_expected.to_not include other_model }
     end
 
     context "given multiple states" do
-      subject { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+      subject(:not_in_state) { MyActiveRecordModel.not_in_state(:succeeded, :failed) }
+
       it do
-        is_expected.to match_array([initial_state_model,
-                                    returned_to_initial_model])
+        expect(not_in_state).to match_array([initial_state_model,
+                                             returned_to_initial_model])
       end
     end
 
     context "given an array of states" do
-      subject { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
+      subject(:not_in_state) { MyActiveRecordModel.not_in_state(%i[succeeded failed]) }
+
       it do
-        is_expected.to match_array([initial_state_model,
-                                    returned_to_initial_model])
+        expect(not_in_state).to match_array([initial_state_model,
+                                             returned_to_initial_model])
       end
     end
   end
@@ -143,6 +144,7 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
 
     describe ".in_state" do
       subject(:query) { MyActiveRecordModel.in_state(:succeeded) }
+
       specify { expect { query }.to_not raise_error }
     end
   end

data/spec/statesman/adapters/active_record_spec.rb

@@ -10,8 +10,10 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
   end
 
   before { MyActiveRecordModelTransition.serialize(:metadata, JSON) }
+
   let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:model) { MyActiveRecordModel.create(current_state: :pending) }
+
   it_behaves_like "an adapter", described_class, MyActiveRecordModelTransition
 
   describe "#initialize" do
@@ -98,13 +100,14 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
   end
 
   describe "#create" do
+    subject { -> { create } }
+
     let!(:adapter) do
       described_class.new(MyActiveRecordModelTransition, model, observer)
     end
     let(:from) { :x }
     let(:to) { :y }
     let(:create) { adapter.create(from, to) }
-    subject { -> { create } }
 
     context "when there is a race" do
       it "raises a TransitionConflictError" do
@@ -132,11 +135,13 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
             ActiveRecord::RecordNotUnique.new("unrelated", nil)
           end
         end
+
         it { is_expected.to raise_exception(ActiveRecord::RecordNotUnique) }
       end
 
       context "other errors" do
         let(:error) { StandardError }
+
         it { is_expected.to raise_exception(StandardError) }
       end
     end
@@ -150,6 +155,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
 
       context "with a previous transition" do
         let!(:previous_transition) { adapter.create(from, to) }
+
         its(:most_recent) { is_expected.to eq(true) }
 
         it "updates the previous transition's most_recent flag" do
@@ -248,6 +254,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
       context "with two previous transitions" do
         let!(:previous_transition) { adapter.create(from, to) }
         let!(:another_previous_transition) { adapter.create(from, to) }
+
         its(:most_recent) { is_expected.to eq(true) }
 
         it "updates the previous transition's most_recent flag" do
@@ -271,12 +278,13 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
 
       it "caches the transition" do
         expect_any_instance_of(MyActiveRecordModel).
-          to receive(:my_active_record_model_transitions).never
+          to_not receive(:my_active_record_model_transitions)
         adapter.last
       end
 
       context "after then creating a new transition" do
         before { adapter.create(:y, :z, []) }
+
         it "retrieves the new transition from the database" do
           expect(adapter.last.to_state).to eq("z")
         end
@@ -291,7 +299,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
           alternate_adapter.create(:y, :z, [])
 
           expect_any_instance_of(MyActiveRecordModel).
-            to receive(:my_active_record_model_transitions).never
+            to_not receive(:my_active_record_model_transitions)
           expect(adapter.last.to_state).to eq("y")
         end
 
@@ -323,10 +331,11 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
 
     context "with a pre-fetched transition history" do
       before { adapter.create(:x, :y) }
+
       before { model.my_active_record_model_transitions.load_target }
 
       it "doesn't query the database" do
-        expect(MyActiveRecordModelTransition).not_to receive(:connection)
+        expect(MyActiveRecordModelTransition).to_not receive(:connection)
         expect(adapter.last.to_state).to eq("y")
       end
     end
@@ -341,6 +350,7 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
     before do
       MyNamespace::MyActiveRecordModelTransition.serialize(:metadata, JSON)
     end
+
     let(:observer) { double(Statesman::Machine, execute: nil) }
     let(:model) do
       MyNamespace::MyActiveRecordModel.create(current_state: :pending)

data/spec/statesman/adapters/memory_spec.rb

@@ -4,6 +4,7 @@ require "statesman/adapters/memory_transition"
 
 describe Statesman::Adapters::Memory do
   let(:model) { Class.new { attr_accessor :current_state }.new }
+
   it_behaves_like "an adapter", described_class,
                   Statesman::Adapters::MemoryTransition
 end

data/spec/statesman/adapters/mongoid_spec.rb

@@ -6,8 +6,10 @@ require "mongoid"
 
 describe Statesman::Adapters::Mongoid, mongo: true do
   after { Mongoid.purge! }
+
   let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:model) { MyMongoidModel.create(current_state: :pending) }
+
   it_behaves_like "an adapter", described_class, MyMongoidModelTransition
 
   describe "#initialize" do
@@ -33,16 +35,18 @@ describe Statesman::Adapters::Mongoid, mongo: true do
 
     context "with a previously looked up transition" do
       before { adapter.create(:x, :y) }
+
       before { adapter.last }
 
       it "caches the transition" do
         expect_any_instance_of(MyMongoidModel).
-          to receive(:my_mongoid_model_transitions).never
+          to_not receive(:my_mongoid_model_transitions)
         adapter.last
       end
 
       context "and a new transition" do
         before { adapter.create(:y, :z) }
+
         it "retrieves the new transition from the database" do
           expect(adapter.last.to_state).to eq("z")
         end

data/spec/statesman/adapters/shared_examples.rb

@@ -13,8 +13,6 @@ require "spec_helper"
 #
 # NOTE This line cannot reasonably be shortened.
 shared_examples_for "an adapter" do |adapter_class, transition_class, options = {}|
-  # rubocop:enable Metrics/LineLength
-
   let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:adapter) do
     adapter_class.new(transition_class,
@@ -23,26 +21,29 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
 
   describe "#initialize" do
     subject { adapter }
+
     its(:transition_class) { is_expected.to be(transition_class) }
     its(:parent_model) { is_expected.to be(model) }
     its(:history) { is_expected.to eq([]) }
   end
 
   describe "#create" do
+    subject { -> { create } }
+
     let(:from) { :x }
     let(:to) { :y }
     let(:there) { :z }
     let(:create) { adapter.create(from, to) }
-    subject { -> { create } }
 
     it { is_expected.to change(adapter.history, :count).by(1) }
 
     context "the new transition" do
-      subject { create }
+      subject(:instance) { create }
+
       it { is_expected.to be_a(transition_class) }
 
-      it "should have the initial state" do
-        expect(subject.to_state.to_sym).to eq(to)
+      it "has the initial state" do
+        expect(instance.to_state.to_sym).to eq(to)
       end
 
       context "with no previous transition" do
@@ -51,6 +52,7 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
 
       context "with a previous transition" do
         before { adapter.create(from, to) }
+
         its(:sort_key) { is_expected.to be(20) }
       end
     end
@@ -87,33 +89,40 @@ shared_examples_for "an adapter" do |adapter_class, transition_class, options =
     end
 
     context "with metadata" do
-      let(:metadata) { { "some" => "hash" } }
       subject { adapter.create(from, to, metadata) }
+
+      let(:metadata) { { "some" => "hash" } }
+
       its(:metadata) { is_expected.to eq(metadata) }
     end
   end
 
   describe "#history" do
     subject { adapter.history }
+
     it { is_expected.to eq([]) }
 
     context "with transitions" do
       let!(:transition) { adapter.create(:x, :y) }
+
       it { is_expected.to eq([transition]) }
 
       context "sorting" do
-        let!(:transition2) { adapter.create(:x, :y) }
         subject { adapter.history }
 
+        let!(:transition2) { adapter.create(:x, :y) }
+
         it { is_expected.to eq(adapter.history.sort_by(&:sort_key)) }
       end
     end
   end
 
   describe "#last" do
+    subject { adapter.last }
+
     before { adapter.create(:x, :y) }
+
     before { adapter.create(:y, :z) }
-    subject { adapter.last }
 
     it { is_expected.to be_a(transition_class) }
     specify { expect(adapter.last.to_state.to_sym).to eq(:z) }

data/spec/statesman/callback_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe Statesman::Callback do
   let(:cb_lambda) { -> {} }
   let(:callback) do
-    Statesman::Callback.new(from: nil, to: nil, callback: cb_lambda)
+    described_class.new(from: nil, to: nil, callback: cb_lambda)
   end
 
   describe "#initialize" do
@@ -27,21 +27,24 @@ describe Statesman::Callback do
   end
 
   describe "#applies_to" do
+    subject { callback.applies_to?(from: from, to: to) }
+
     let(:callback) do
-      Statesman::Callback.new(from: :x, to: :y, callback: cb_lambda)
+      described_class.new(from: :x, to: :y, callback: cb_lambda)
     end
-    subject { callback.applies_to?(from: from, to: to) }
 
     context "with any from value" do
       let(:from) { nil }
 
       context "and an allowed to value" do
         let(:to) { :y }
+
         it { is_expected.to be_truthy }
       end
 
       context "and a disallowed to value" do
         let(:to) { :a }
+
         it { is_expected.to be_falsey }
       end
     end
@@ -51,17 +54,19 @@ describe Statesman::Callback do
 
       context "and an allowed 'from' value" do
         let(:from) { :x }
+
         it { is_expected.to be_truthy }
       end
 
       context "and a disallowed 'from' value" do
         let(:from) { :a }
+
         it { is_expected.to be_falsey }
       end
     end
 
     context "with any to and any from value on the callback" do
-      let(:callback) { Statesman::Callback.new(callback: cb_lambda) }
+      let(:callback) { described_class.new(callback: cb_lambda) }
       let(:from) { :x }
       let(:to) { :y }
 
@@ -70,37 +75,42 @@ describe Statesman::Callback do
 
     context "with any from value on the callback" do
       let(:callback) do
-        Statesman::Callback.new(to: %i[y z], callback: cb_lambda)
+        described_class.new(to: %i[y z], callback: cb_lambda)
       end
       let(:from) { :x }
 
       context "and an allowed to value" do
         let(:to) { :y }
+
         it { is_expected.to be_truthy }
       end
 
       context "and another allowed to value" do
         let(:to) { :z }
+
         it { is_expected.to be_truthy }
       end
 
       context "and a disallowed to value" do
         let(:to) { :a }
+
         it { is_expected.to be_falsey }
       end
     end
 
     context "with any to value on the callback" do
-      let(:callback) { Statesman::Callback.new(from: :x, callback: cb_lambda) }
+      let(:callback) { described_class.new(from: :x, callback: cb_lambda) }
       let(:to) { :y }
 
       context "and an allowed to value" do
         let(:from) { :x }
+
         it { is_expected.to be_truthy }
       end
 
       context "and a disallowed to value" do
         let(:from) { :a }
+
         it { is_expected.to be_falsey }
       end
     end
@@ -108,12 +118,14 @@ describe Statesman::Callback do
     context "with allowed 'from' and 'to' values" do
       let(:from) { :x }
       let(:to) { :y }
+
       it { is_expected.to be_truthy }
     end
 
     context "with disallowed 'from' and 'to' values" do
       let(:from) { :a }
       let(:to) { :b }
+
       it { is_expected.to be_falsey }
     end
   end