Add original option to RulesEngine::Outcome

lib/rules_engine/condition.rb

@@ -1,5 +1,10 @@
 class RulesEngine::Condition
- attr_accessor :name, :condition, :when_true, :when_false, :original, :override
+ attr_accessor :name,
+ :condition,
+ :when_true,
+ :when_false,
+ :original,
+ :override
 
  def initialize(options = {})
  @name = options.fetch(:name)

lib/rules_engine/outcome.rb

@@ -1,9 +1,13 @@
 class RulesEngine::Outcome
- attr_accessor :name, :values, :reference
+ attr_accessor :name,
+ :values,
+ :reference,
+ :original
 
  def initialize(options = {})
  @name = options.fetch(:name)
  @values = options.fetch(:values)
  @reference = options.fetch(:reference, nil)
+ @original = options.fetch(:original, nil)
  end
 end

spec/rules_engine/condition_spec.rb

@@ -1,24 +1,114 @@
 require 'spec_helper'
 
-describe 'Condition' do
- let(:true_action) { RulesEngine::Outcome.new(name: 'name', values: [{ reference: 'true action', parameter: '1' }]) }
- let(:false_action) { RulesEngine::Outcome.new(name: 'name', values: [{ reference: 'false action', parameter: '1' }]) }
+describe RulesEngine::Condition do
+ describe '.new' do
+  subject { described_class.new(options) }
 
- context 'Constructing a new instance from a hash' do
+ context 'where only required arguments are provided' do
+ let(:options) do
+ {
+ name: 'a condition',
+ condition: '2 > 1',
+ }
+ end
+
+ it 'sets name' do
+ expect(subject.name).to eq('a condition')
+ end
+
+ it 'sets condition' do
+ expect(subject.condition).to eq('2 > 1')
+ end
 
- let(:condition) { RulesEngine::Condition.new(name: 'name', condition: '2 > 1', when_true: true_action, when_false: false_action) }
+ it 'does not set when_true' do
+ expect(subject.when_true).to be_nil
+ end
 
- specify { expect(condition.name).to eq('name') }
- specify { expect(condition.condition).to eq('2 > 1') }
- specify { expect(condition.when_true).to eq(true_action) }
- specify { expect(condition.when_false).to eq(false_action) }
+ it 'does not set when_false' do
+ expect(subject.when_false).to be_nil
+ end
 
- context 'Missing required arguments' do
- context 'name' do
- specify { expect { RulesEngine::Condition.new(condition: '2 > 1', when_true: true_action, when_false: false_action) }.to raise_error }
+ it 'does not set original' do
+ expect(subject.original).to be_nil
  end
- context 'condition' do
- specify { expect { RulesEngine::Condition.new(name: 'name', when_true: true_action, when_false: false_action) }.to raise_error }
+
+ it 'does not set override' do
+ expect(subject.override).to be_nil
+ end
+ end
+
+ context 'where all available arguments are provided' do
+ let(:options) do
+ {
+ name: 'a condition',
+ condition: '2 > 1',
+ when_true: true_action,
+ when_false: false_action,
+ original: 'original condition',
+ override: true,
+ }
+ end
+
+ let(:true_action) do
+ RulesEngine::Outcome.new(
+ name: 'an outcome',
+ values: [{ reference: 'true action', parameter: '1' }],
+ )
+ end
+
+ let(:false_action) do
+ RulesEngine::Outcome.new(
+ name: 'another outcome',
+ values: [{ reference: 'false action', parameter: '1' }],
+ )
+ end
+
+ it 'sets name' do
+ expect(subject.name).to eq('a condition')
+ end
+
+ it 'sets condition' do
+ expect(subject.condition).to eq('2 > 1')
+ end
+
+ it 'sets when_true' do
+ expect(subject.when_true).to eq(true_action)
+ end
+
+ it 'sets when_false' do
+ expect(subject.when_false).to eq(false_action)
+ end
+
+ it 'sets original' do
+ expect(subject.original).to eq('original condition')
+ end
+
+ it 'sets override' do
+ expect(subject.override).to eq(true)
+ end
+ end
+
+ context 'where name argument is missing' do
+ let(:options) do
+ {
+ condition: '2 > 1',
+ }
+ end
+
+ specify do
+ expect { subject }.to raise_error(KeyError)
+ end
+ end
+
+ context 'where condition argument is missing' do
+ let(:options) do
+ {
+ name: 'a condition',
+ }
+ end
+
+ specify do
+ expect { subject }.to raise_error(KeyError)
  end
  end
  end

spec/rules_engine/outcome_spec.rb

@@ -1,27 +1,83 @@
 require 'spec_helper'
 
-describe 'Outcome' do
+describe RulesEngine::Outcome do
+ describe '.new' do
+ subject { described_class.new(options) }
 
- context 'Constructing a new instance from a hash' do
+ context 'where only required arguments are provided' do
+ let(:options) do
+ {
+ name: 'an outcome',
+ values: [{ parameter: 'some parameter', reference: 'some reference' }],
+ }
+ end
 
- let(:outcome) do
- RulesEngine::Outcome.new(name: 'some outcome',
- reference: 'outcome_reference',
- values: [{ parameter: 'some parameter', reference: 'some reference' }])
+ it 'sets name' do
+ expect(subject.name).to eq('an outcome')
+ end
+
+ it 'sets values' do
+ expect(subject.values).to eq([{ parameter: 'some parameter', reference: 'some reference' }])
+ end
+
+ it 'does not set reference' do
+ expect(subject.reference).to be_nil
+ end
+
+ it 'does not set original' do
+ expect(subject.original).to be_nil
+ end
  end
 
- specify { expect(outcome.name).to eq('some outcome') }
- specify { expect(outcome.reference).to eq('outcome_reference') }
- specify { expect(outcome.values.first[:parameter]).to eq('some parameter') }
- specify { expect(outcome.values.first[:reference]).to eq('some reference') }
- end
+ context 'where all available arguments are provided' do
+ let(:options) do
+ {
+ name: 'an outcome',
+ values: [{ parameter: 'some parameter', reference: 'some reference' }],
+ reference: 'outcome_reference',
+ original: 'original outcome',
+ }
+ end
+
+ it 'sets name' do
+ expect(subject.name).to eq('an outcome')
+ end
+
+ it 'sets values' do
+ expect(subject.values).to eq([{ parameter: 'some parameter', reference: 'some reference' }])
+ end
 
- context 'Missing required arguments' do
- context 'name' do
- specify { expect { RulesEngine::Outcome.new(values: [{ parameter: 'some parameter', reference: 'some reference' }]) }.to raise_error }
+ it 'sets reference' do
+ expect(subject.reference).to eq('outcome_reference')
+ end
+
+ it 'sets original' do
+ expect(subject.original).to eq('original outcome')
+ end
+ end
+
+ context 'where name argument is missing' do
+ let(:options) do
+ {
+ values: [{ parameter: 'some parameter', reference: 'some reference' }],
+ }
+ end
+
+ specify do
+ expect { subject }.to raise_error(KeyError)
+ end
  end
- context 'values' do
- specify { expect { RulesEngine::Outcome.new(name: 'some outcome') }.to raise_error }
+
+ context 'where values argument is missing' do
+ let(:options) do
+ {
+ name: 'an outcome',
+ }
+ end
+
+ specify do
+ expect { subject }.to raise_error(KeyError)
+ end
  end
  end
 end