shrewd 0.0.0

data/spec/models/event_spec.rb

@@ -0,0 +1,50 @@
+# EventSpec
+#
+# Tests for the Shrewd::EventSpec class
+
+require 'shrewd/simulation'
+require 'shrewd/entities/event'
+require 'shrewd/entities/process'
+
+describe Shrewd::Event do
+
+  # Shared variables
+  let(:name) { 'Initial' }
+  let(:description) { 'Description' }
+  let(:processes) { [ Shrewd::Process.new('Process1'),
+                      Shrewd::Process.new('Process2') ] }
+
+  describe "initialization" do
+
+    context "with name only" do
+      before :each do
+        @event = Shrewd::Event.new(name)
+      end
+
+      it "should be valid" do
+        expect(@event).to be_an_instance_of Shrewd::Event
+        expect(@event.name).to eql name
+        expect(@event.description).to be_empty
+        expect(@event.processes).to eql Array.new
+        expect(@event.action).to be_nil
+      end
+
+    end
+
+    context "with all parameters" do
+      let(:action) { Proc.new { |variables| } }
+
+      before :each do
+        @event = Shrewd::Event.new(name, description, processes, action)
+      end
+
+      it "should be valid" do
+        expect(@event).to be_an_instance_of Shrewd::Event
+        expect(@event.name).to eql name
+        expect(@event.description).to eql description
+        expect(@event.processes).to eql processes
+        expect(@event.action).to eql action
+      end
+    end
+  end
+end

data/spec/models/process_spec.rb

@@ -0,0 +1,51 @@
+# ProcessSpec
+#
+# Tests for Shrewd::ProcessSpec class
+
+module Shrewd
+  require 'shrewd/entities/process'
+  require 'shrewd/entities/event'
+end
+
+describe Shrewd::Process do
+
+  describe "initialization" do
+    let(:name) { 'Service Event' }
+    let(:description) { 'Servicing a customer.' }
+    let(:event) { Shrewd::Event.new('Event') }
+    let(:conditions) { Proc.new { |variables| true } }
+    let(:delay) { Proc.new { |variables| 15 } }
+
+    context "with only name" do
+      before :each do
+        @process = Shrewd::Process.new(name)
+      end
+
+      it "should be valid" do
+        expect(@process).to be_an_instance_of Shrewd::Process
+        expect(@process.name).to eql name
+        expect(@process.description).to be_empty
+        expect(@process.event).to be_nil
+        expect(@process.conditions).to be_nil
+        expect(@process.delay).to be_nil
+      end
+    end
+
+    context "with all parameters" do
+      before :each do
+        @process = Shrewd::Process.new(name, description,
+                                       event, conditions, delay)
+      end
+
+      it "should be valid" do
+        expect(@process).to be_an_instance_of Shrewd::Process
+        expect(@process.name).to eql name
+        expect(@process.description).to eql description
+        expect(@process.event).to eql event
+        expect(@process.conditions).to eql conditions
+        expect(@process.delay).to eql delay
+      end
+    end
+  end
+
+end

data/spec/models/simulation_spec.rb

@@ -0,0 +1,180 @@
+# SimulationSpec
+#
+# Tests for the Shrewd::Simulation class
+
+require 'shrewd/simulation'
+
+describe Shrewd::Simulation do
+
+  # Shared variables
+  let(:state_variables) { [ Shrewd::Variable.new('Queue'),
+                            Shrewd::Variable.new('Employees', '', 5)] }
+  let(:process_length) { 20 }
+  let(:simulation_length) { 1000 }
+  let(:initial_processes) do
+    process = Shrewd::Process.new('Process1')
+    process.delay = Proc.new { process_length }
+
+    event = Shrewd::Event.new('Arrival')
+    event.processes << process
+    process.event = event
+    
+    [ process ]
+  end
+
+  # Create a simulation instance before each test
+  before :each do
+    @simulation = Shrewd::Simulation.new(state_variables, initial_processes)
+  end
+
+  # Validate new simulation instance
+  describe "#new" do
+    it "should be a simulation" do
+      expect(@simulation).to be_an_instance_of Shrewd::Simulation
+    end
+
+    it "instantiates variables correctly" do
+      variables = @simulation.instance_variable_get(:@variables)
+      expect(variables).to be_an_instance_of Hash
+
+      variables.values.each do |variable|
+        expect(variable).to be_an_instance_of Shrewd::Variable
+      end
+
+      variables.each do |key, value|
+        expect(key).to eql value.name.downcase.gsub(/\s+/,"_").to_sym
+      end
+
+      expect(@simulation.initial_processes).to be_an_instance_of Array
+      expect(@simulation.initial_processes).to eql initial_processes
+
+      @simulation.initial_processes.each do |process|
+        expect(process).to be_an_instance_of Shrewd::Process
+      end
+    end
+  end
+
+  describe "#start" do
+    before :each do
+      @simulation.start(simulation_length)
+    end
+
+    it "generates a start event" do
+      expect(@simulation.print_log.size).to eql (simulation_length/process_length) + 1
+      expect(@simulation.print_log.first[:event].name).to eql 'Start'
+    end
+  end
+
+  describe "#print_log" do
+    it "generates a log" do
+      expect(@simulation.print_log).to be_an_instance_of Array
+    end
+  end
+
+  describe "#create_initial_event" do
+    before :each do
+      @simulation.send(:create_initial_event)
+      @queue = @simulation.instance_variable_get(:@queue)
+    end
+
+    it "adds initial event to the queue" do
+      expect(@queue.size).to eql 1
+    end
+
+    it "creates initial event" do
+      initial_event = @queue.first[:event]
+      expect(initial_event).to be_an_instance_of Shrewd::Event
+      expect(initial_event.name).to eql 'Start'
+    end
+
+    it "adds initial processes to initial event" do
+      initial_event = @queue.first[:event]
+      expect(initial_event.processes.size).to be > 0
+      expect(initial_event.processes).to eql initial_processes
+    end
+  end
+
+  describe "#add_to_queue" do
+    let(:first_name) { 'First' }
+    let(:first_time) { 5 }
+    let(:second_name) { 'Second' }
+    let(:second_time) { 10 }
+    let(:third_name) { 'Third' }
+    let(:third_time) { 7 }
+    let(:fourth_name) { 'Fourth' }
+    let(:fourth_time) { 3 }
+
+    before :each do
+      @initial_event = Shrewd::Event.new(first_name)
+      @simulation.send(:add_to_queue, { time: first_time, event: @initial_event })
+      @queue = @simulation.instance_variable_get(:@queue)
+    end
+
+    it "adds an event to the queue" do
+      expect(@queue).to be_an_instance_of Array
+      expect(@queue).to_not be_empty
+      expect(@queue.first[:event].name).to eql first_name
+      expect(@queue.first[:time]).to eql first_time
+    end
+
+    # Test base binary search
+    context "multiples events" do
+      before :each do
+        @second_event = Shrewd::Event.new(second_name)
+        @simulation.send(:add_to_queue, { time: second_time,
+                                          event: @second_event })
+      end
+
+      it "adds second event to the queue" do
+        expect(@queue.size).to eql 2
+        expect(@queue[1][:event].name).to eql second_name
+        expect(@queue[1][:time]).to eql second_time
+      end
+
+      context "with third and fourth event" do
+        before :each do
+          @third_event = Shrewd::Event.new(third_name)
+          @fourth_event = Shrewd::Event.new(fourth_name)
+
+          @simulation.send(:add_to_queue, { time: third_time,
+                                            event: @third_event })
+          @simulation.send(:add_to_queue, { time: fourth_time,
+                                            event: @fourth_event })
+        end
+
+        it "adds third and fourth events to the queue" do
+          expect(@queue.size).to eql 4
+        end
+
+        it "places events in order" do
+          time = 0
+          @queue.each do |item|
+            expect(item[:time]).to be > time
+            time = item[:time]
+          end
+        end
+      end
+    end
+  end
+
+  describe "#reset" do
+    before :each do
+      @simulation.start(1000)
+      @simulation.reset
+    end
+
+    it "resets system state" do
+      log        = @simulation.print_log
+      queue      = @simulation.instance_variable_get(:@queue)
+      clock      = @simulation.instance_variable_get(:@clock)
+      variables  = @simulation.instance_variable_get(:@variables)
+      initial    = @simulation.instance_variable_get(:@initial_state)
+
+      expect(log).to be_empty
+      expect(queue).to be_empty
+      expect(clock).to eql 0
+      expect(variables).to eql initial
+    end
+
+  end
+end

data/spec/models/variable_spec.rb

@@ -0,0 +1,195 @@
+# VariableSpec
+#
+# Tests for the Shrewd::Variable class
+
+require 'shrewd/entities/variable'
+
+describe Shrewd::Variable do
+
+  # Shared variables
+  let(:name) {  'Queue' }
+  let(:description) { 'Number of people in line.' }
+  let(:initial_value) { 5 }
+
+  describe "initialization" do
+
+    # Common examples for validating a variable
+    shared_examples "valid variable" do
+
+      it "should be a variable" do
+        expect(@variable).to be_an_instance_of Shrewd::Variable
+      end
+
+      it "should have the correct properties" do
+        expect(@variable.name).to eql name
+        expect(@variable.description).to eql description
+      end
+
+    end
+
+    context "when default value provided" do
+
+      before :each do
+        @variable = Shrewd::Variable.new(name, description, initial_value)
+      end
+
+      include_examples "valid variable"
+
+      it "should have the provided default value" do
+        expect(@variable.value).to eql initial_value
+      end
+
+    end
+
+    context "when no default value provided" do
+
+      before :each do
+        @variable = Shrewd::Variable.new(name, description)
+      end
+
+      include_examples "valid variable"
+
+      it "should have a default of 0" do
+        expect(@variable.value).to eql 0
+      end
+
+    end
+
+  end
+
+  describe "increment" do
+
+    let(:positive_amount) { 4 }
+    let(:negative_amount) { -2 }
+
+    before :each do
+      @variable = Shrewd::Variable.new(name, description, initial_value)
+    end
+
+    context "by default amount" do
+
+      before :each do
+        @variable.increment
+      end
+
+      it "should add one to initial value" do
+        expected_value = initial_value + 1
+        expect(@variable.value).to eql expected_value
+      end
+    end
+
+    context "by positive amount" do
+
+      before :each do
+        @variable.increment positive_amount
+      end
+
+      it "should add positive amount to initial value" do
+        expected_value = initial_value + positive_amount
+        expect(@variable.value).to eql expected_value
+      end
+
+    end
+
+    context "by negative amount" do
+
+      before :each do
+        @variable.increment negative_amount
+      end
+
+      it "should subtract negative amount from initial value" do
+        expected_value = initial_value + negative_amount
+        expect(@variable.value).to eql expected_value
+      end
+
+    end
+  end
+
+  describe "decrement" do
+
+    let(:positive_amount) { 2 }
+    let(:negative_amount) { -2 }
+
+    before :each do
+      @variable = Shrewd::Variable.new(name, description, initial_value)
+    end
+
+    context "by default amount" do
+
+      before :each do
+        @variable.decrement
+      end
+
+      it "should subtract one from initial value" do
+        expected_value = initial_value - 1
+        expect(@variable.value).to eql expected_value
+      end
+    end
+
+    context "by provided positive amount" do
+
+      before :each do
+        @variable.decrement positive_amount
+      end
+
+      it "should subtract positive amount from initial value" do
+        expected_value = initial_value - positive_amount
+        expect(@variable.value).to eql expected_value
+      end
+
+    end
+
+    context "by provided negative amount" do
+
+      before :each do
+        @variable.decrement negative_amount
+      end
+
+      it "should add negative amount to initial value" do
+        expected_value = initial_value - negative_amount
+        expect(@variable.value).to eql expected_value
+      end
+
+    end
+  end
+
+  describe "compare" do
+
+    context "with self" do
+      before :each do
+        @variable1 = Shrewd::Variable.new(name, description, initial_value)
+        @variable2 = @variable1
+      end
+
+      it "should be equal" do
+        expect(@variable1 == @variable2.value).to be true
+      end
+    end
+
+    context "with variable with same value" do
+      before :each do
+        @variable1 = Shrewd::Variable.new(name, description, initial_value)
+        @variable2 = Shrewd::Variable.new(name, description, initial_value)
+      end
+
+      it "should be equal" do
+        expect(@variable1 == @variable2.value).to be true
+      end
+    end
+
+    context "with a variable with different value" do
+      let(:different_value) { initial_value + 3 }
+
+      before :each do
+        @variable1 = Shrewd::Variable.new(name, description, initial_value)
+        @variable2 = Shrewd::Variable.new(name, description, different_value)
+      end
+
+      it "should not be equal" do
+        expect(@variable1 == @variable2.value).to be false
+      end
+
+    end
+
+  end
+end