symian 0.1.0

data/test/symian/configuration_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+require 'symian/reference_configuration'
+
+
+describe Symian::Configuration do
+
+  context 'simulation-related parameters' do
+
+    it 'should correctly load simulation start' do
+      with_reference_config do |conf|
+        conf.start_time.must_equal START_TIME
+      end
+    end
+
+    it 'should correctly load simulation duration' do
+      with_reference_config do |conf|
+        conf.duration.must_equal DURATION
+      end
+    end
+
+    it 'should correctly load simulation end time' do
+      with_reference_config do |conf|
+        conf.end_time.must_equal START_TIME + DURATION
+      end
+    end
+
+    it 'should correctly load warmup phase duration' do
+      with_reference_config do |conf|
+        conf.warmup_duration.must_equal WARMUP_DURATION
+      end
+    end
+
+    it 'should initialize incident generation' do
+      with_reference_config do |conf|
+        conf.incident_generation.must_equal INCIDENT_GENERATION
+      end
+    end
+
+    it 'should initialize support groups' do
+      with_reference_config do |conf|
+        conf.support_groups.must_equal SUPPORT_GROUPS
+      end
+    end
+
+    it 'should initialize transition matrix' do
+      with_reference_config do |conf|
+        conf.transition_matrix.must_equal TRANSITION_MATRIX
+      end
+    end
+
+  end
+
+  context 'cloning mechanism' do
+    it 'should correctly clone w/ other ops' do
+      with_reference_config do |conf|
+        new_ops = (1..conf.support_groups.size).to_a
+        new_conf = conf.reallocate_ops_and_clone(new_ops)
+        new_conf.support_groups.zip(new_ops) do |(k,v),num_ops|
+          v[:operators][:number].must_equal num_ops
+        end
+      end
+    end
+  end
+
+end

data/test/symian/cost_analyzer_test.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+
+require 'symian/reference_configuration'
+require 'symian/cost_analyzer'
+
+
+describe Symian::CostAnalyzer do
+
+  context 'operations' do
+    it 'should correctly calculate daily operations' do
+      EXAMPLE_KPIS = { :mttr => 9000, :micd => 450 }
+
+      with_reference_config do |conf|
+        ca = Symian::CostAnalyzer.new(conf)
+        res = ca.evaluate(EXAMPLE_KPIS)
+        res[:operations].must_equal((25_000 + 30_000 + 40_000) / 365.0)
+      end
+    end
+  end
+
+  context 'contracting' do
+    it 'should work if no contracting function is provided' do
+      cost_analysis_wo_contracting = COST_ANALYSIS.reject {|x| x == :contracting }
+      with_reference_config(cost_analysis: cost_analysis_wo_contracting) do |conf|
+        Symian::CostAnalyzer.new(conf)
+      end
+    end
+  end
+
+  context 'drift' do
+    it 'should work if no drift function is provided' do
+      cost_analysis_wo_drift = COST_ANALYSIS.reject {|x| x == :drift }
+      with_reference_config(cost_analysis: cost_analysis_wo_drift) do |conf|
+        Symian::CostAnalyzer.new(conf)
+      end
+    end
+  end
+
+    # it 'should work if penalty function returns something' do
+    #   evaluator = with_reference_config do |conf|
+    #     SISFC::Evaluator.new(conf)
+    #   end
+    #   evaluator.evaluate_business_impact({ mttr: 0.075 }, nil, EXAMPLE_ALLOCATION)
+    # end
+
+    # it 'should work if penalty function returns nil' do
+    #   evaluator = with_reference_config do |conf|
+    #     SISFC::Evaluator.new(conf)
+    #   end
+    #   evaluator.evaluate_business_impact({ mttr: 0.025 }, nil, EXAMPLE_ALLOCATION)
+    # end
+end

data/test/symian/generator_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+require 'symian/generator'
+require 'symian/event'
+
+
+describe Symian::IncidentGenerator do
+
+  let(:simulation) { MiniTest::Mock.new }
+
+
+  it 'should generate incidents with random arrival times' do
+    gen = Symian::IncidentGenerator.new(simulation,
+                                        :type => :sequential_random_variable,
+                                        :source => { :first_value => Time.now,
+                                                     :seed => (Process.pid / rand).to_i,
+                                                     :distribution => :discrete_uniform,
+                                                     :max_value => 100 })
+    simulation.expect(:new_event, nil, [ Symian::Event::ET_INCIDENT_ARRIVAL, Symian::Incident, Time, nil ])
+    gen.generate
+  end
+
+
+  it 'should generate incidents with arrival times from traces'
+
+
+end

data/test/symian/incident_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+require 'symian/incident'
+
+describe Symian::Incident do
+
+  it 'should ignore invalid parameters passed to the constructor' do
+    Symian::Incident.new(1, Time.now, :some_invalid_param => "dummy")
+  end
+
+  it 'should not be closed unless closure time is provided' do
+    inc = Symian::Incident.new(1, Time.now)
+    inc.closed?.must_equal false
+  end
+
+  it 'should be closed if closure time is provided' do
+    inc = Symian::Incident.new(1, Time.now)
+    inc.closure_time = Time.now
+    inc.closed?.must_equal true
+  end
+
+  it 'should have a nil TTR if still open' do
+    inc = Symian::Incident.new(1, Time.now)
+    inc.ttr.must_be_nil
+  end
+
+  it 'should have a valid TTR if closed' do
+    arrival_time = Time.now
+    closure_time = Time.now + 1.hour
+    inc = Symian::Incident.new(1, arrival_time,
+                               :closure_time => closure_time)
+    inc.ttr.must_equal 1.hour
+  end
+
+  it 'should correctly manage tracking information' do
+    inc = Symian::Incident.new(1, Time.now)
+    tis = [ { :type     => :queue,
+              :at       => Time.now,
+              :duration => 50.seconds,
+              :sg       => 'SG1' },
+            { :type     => :work,
+              :at       => Time.now + 1.hour,
+              :duration => 2.hours,
+              :sg       => 'SG2' },
+            { :type     => :suspend,
+              :at       => Time.now + 20.minutes,
+              :duration => 30.minutes,
+              :sg       => 'SG3' } ]
+    tis.each do |ti|
+      inc.add_tracking_information(ti)
+    end
+    i = 0
+    inc.with_tracking_information do |ti|
+      ti.must_equal tis[i]
+      i += 1
+    end
+  end
+
+  it 'should correctly calculate time spent at last support group' do
+    inc = Symian::Incident.new(1, Time.now)
+    now = Time.now
+
+    tis = [ { :type     => :queue,
+              :at       => now,
+              :duration => 1.hour,
+              :sg       => 'SG1' },
+            { :type     => :work,
+              :at       => now + 1.hour,
+              :duration => 2.hours,
+              :sg       => 'SG1' },
+            { :type     => :queue,
+              :at       => now + 3.hours,
+              :duration => 1.hour,
+              :sg       => 'SG2' },
+            { :type     => :work,
+              :at       => now + 4.hours,
+              :duration => 2.hours,
+              :sg       => 'SG2' },
+            { :type     => :queue,
+              :at       => now + 6.hours,
+              :duration => 1.hour,
+              :sg       => 'SG3' },
+            { :type     => :work,
+              :at       => now + 7.hours,
+              :duration => 2.hours,
+              :sg       => 'SG3' },
+            { :type     => :suspend,
+              :at       => now + 9.hours,
+              :duration => 30.minutes,
+              :sg       => 'SG3' },
+            { :type     => :work,
+              :at       => now + 9.hours + 30.minutes,
+              :duration => 30.minutes,
+              :sg       => 'SG3' } ]
+
+    tis.each do |ti|
+      inc.add_tracking_information(ti)
+    end
+
+    inc.total_time_at_last_sg.must_equal 4.hours
+    inc.queue_time_at_last_sg.must_equal 1.hour
+  end
+
+end

data/test/symian/operator_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+require 'symian/incident'
+require 'symian/operator'
+
+
+describe Symian::Operator do
+
+  it 'should support :workshift => :all_day_long shortcut' do
+    o = Symian::Operator.new(1, 1, :workshift => :all_day_long)
+    o.workshift.must_equal Symian::WorkShift::WORKSHIFT_24x7
+  end
+
+
+  it 'should work on minor incidents until escalation' do
+    assignment_time          = Time.now                  # incident is assigned now
+    needed_work_time         = 1.hour                    # incident requires 1 hour of work
+    arrival_time             = assignment_time - 1.hour  # incident arrived one hour ago
+    expected_escalation_time = assignment_time + 1.hour  # incident should be closed in one hour
+
+    o = Symian::Operator.new(1, 1)
+    i = Symian::Incident.new(1, arrival_time)
+
+    o.assign(i, { :needed_work_time => needed_work_time }, assignment_time).must_equal [ :incident_escalation, expected_escalation_time ]
+  end
+
+
+  it 'should work on major incidents until time of shift' do
+    assignment_time  = Time.now                   # incident is assigned now
+    needed_work_time = 2.hours                    # incident requires 2 hours of work
+    arrival_time     = assignment_time - 1.hour   # incident arrived one hour ago
+    workshift_start  = assignment_time - 7.hours  # operator workshift started 7 hours ago
+    workshift_end    = assignment_time + 1.hour   # operator workshift ends in 1 hour
+
+    o = Symian::Operator.new(1, 1,
+                             :workshift => Symian::WorkShift.new(:custom,
+                                                                 :start_time => workshift_start,
+                                                                 :end_time   => workshift_end))
+    i = Symian::Incident.new(1, arrival_time)
+
+    o.assign(i, { :needed_work_time => needed_work_time }, assignment_time).must_equal [ :operator_off_duty, workshift_end ]
+  end
+
+
+  it 'should have specialization factors skewing its productivity' do
+    assignment_time          = Time.now                  # incident is assigned now
+    needed_work_time         = 2.hours                   # incident requires 2 hours of work
+    arrival_time             = assignment_time - 1.hour  # incident arrived one hour ago
+    expected_escalation_time = assignment_time + 1.hour  # incident should be closed in one hour
+
+    o = Symian::Operator.new(1, 1,
+                             :specialization => { :web => 2.0 })      # 2x specialization on 'web' incidents
+
+    i = Symian::Incident.new(1, arrival_time, :category => :web)
+
+    o.assign(i, { :needed_work_time => needed_work_time }, assignment_time).must_equal [ :incident_escalation, expected_escalation_time ]
+  end
+
+end
+

data/test/symian/reference_configuration.rb

@@ -0,0 +1,107 @@
+require 'symian/configuration'
+
+START_TIME      = Time.utc(1978, 'Aug', 12, 14, 30, 0)
+DURATION        = 1.minute
+WARMUP_DURATION = 10.seconds
+SIMULATION_CHARACTERIZATION = <<END
+  start_time Time.utc(1978, 'Aug', 12, 14, 30, 0)
+  duration 1.minute
+  warmup_duration 10.seconds
+END
+
+INCIDENT_GENERATION_CHARACTERIZATION = <<END
+incident_generation \
+  :type   => :sequential_random_variable,
+  :source => {
+    :first_value => Time.utc(1978, 'Aug', 12, 14, 31, 0),
+    :distribution => :exponential,
+    :mean => 1/0.0015
+  }
+END
+
+SUPPORT_GROUPS_CHARACTERIZATION = <<END
+support_groups \
+  'SG1' => { :work_time => { :distribution => :exponential, :mean => 227370 },
+             :operators => { :number => 1, :workshift => :all_day_long } },
+  'SG2' => { :work_time => { :distribution => :exponential, :mean => 1980 },
+             :operators => { :number => 1, :workshift => :all_day_long } },
+  'SG3' => { :work_time => { :distribution => :exponential, :mean => 360 },
+             :operators => { :number => 1, :workshift => :all_day_long } }
+END
+
+TRANSITION_MATRIX_CHARACTERIZATION = <<END
+transition_matrix %q{
+  From/To,SG1,SG2,SG3,Out
+  In,25,50,25,0
+  SG1,0,10,70,20
+  SG2,5,0,45,45
+  SG3,10,20,0,70
+}
+END
+
+COST_ANALYSIS_CHARACTERIZATION = <<END
+cost_analysis \
+  :operations => [
+    { :sg_name => 'SG1', :operator_salary => 30_000 },
+    { :sg_name => 'SG2', :operator_salary => 40_000 },
+    { :sg_name => 'SG3', :operator_salary => 25_000 },
+  ],
+  :contracting => lambda { |kpis|
+    kpis[:mttr] > 9000 ? 1500 : 0.0
+  },
+  :drift => lambda { |kpis|
+    target = 500
+    delta = target - kpis[:micd]
+    if delta > 0.0
+      1500.0 * (2.0 / Math::PI) * Math::atan(10.0 * delta / target)
+    else
+      0.0
+    end
+  }
+END
+
+
+# this is the whole reference configuration
+# (useful for spec'ing configuration.rb)
+REFERENCE_CONFIGURATION =
+  SIMULATION_CHARACTERIZATION +
+  INCIDENT_GENERATION_CHARACTERIZATION +
+  SUPPORT_GROUPS_CHARACTERIZATION +
+  TRANSITION_MATRIX_CHARACTERIZATION +
+  COST_ANALYSIS_CHARACTERIZATION
+
+evaluator = Object.new
+evaluator.extend Symian::Configurable
+evaluator.instance_eval(REFERENCE_CONFIGURATION)
+
+# these are preprocessed portions of the reference configuration
+# (useful for spec'ing everything else)
+INCIDENT_GENERATION = evaluator.incident_generation
+SUPPORT_GROUPS      = evaluator.support_groups
+TRANSITION_MATRIX   = evaluator.transition_matrix
+COST_ANALYSIS       = evaluator.cost_analysis
+
+
+def with_reference_config(opts={})
+  # create temporary file with reference configuration
+  tf = Tempfile.open('REFERENCE_CONFIGURATION')
+  begin
+    tf.write(REFERENCE_CONFIGURATION)
+    tf.close
+
+    # create a configuration object from the reference configuration file
+    conf = Symian::Configuration.load_from_file(tf.path)
+
+    # apply any change from the opts parameter and validate the modified configuration
+    opts.each do |k,v|
+      conf.send(k, v)
+    end
+    conf.validate
+
+    # pass the configuration object to the block
+    yield conf
+  ensure
+    # delete temporary file
+    tf.delete
+  end
+end

data/test/symian/support_group_test.rb

@@ -0,0 +1,111 @@
+require 'test_helper'
+
+require 'symian/incident'
+require 'symian/support_group'
+require 'symian/work_shift'
+
+
+describe Symian::SupportGroup do
+
+  before :each do
+    @simulation = MiniTest::Mock.new
+  end
+
+
+  it 'should be creatable with one operator group' do
+    sg = Symian::SupportGroup.new('SG',
+                                  @simulation,
+                                  { :distribution => :exponential, :mean => 5 },
+                                  { :number => 3, :workshift => Symian::WorkShift.new(:all_day_long) })
+    start_time = Time.now
+    sg.initialize_at(start_time)
+    sg.operators.size.must_equal 3
+  end
+
+
+  it 'should be creatable with several operator groups' do
+    sg = Symian::SupportGroup.new('SG',
+                                  @simulation,
+                                  { :distribution => :exponential, :mean => 5 },
+                                  [ { :number => 3, :workshift => Symian::WorkShift.new(:all_day_long) },
+                                    { :number => 4, :workshift => Symian::WorkShift.new(:all_day_long) },
+                                    { :number => 3, :workshift => Symian::WorkShift.new(:all_day_long) } ])
+    start_time = Time.now
+    sg.initialize_at(start_time)
+    sg.operators.size.must_equal 10
+  end
+
+
+  it 'should allow incident reassignments' do
+    ws = Symian::WorkShift.new(:custom,
+                               :start_time => Time.utc(2009, 'Jan', 1,  8, 0, 0),
+                               :end_time   => Time.utc(2009, 'Jan', 1, 16, 0, 0))
+    sg = Symian::SupportGroup.new('SG',
+                                  @simulation,
+                                  { :distribution => :constant, :value => 10.hours },
+                                  [ { :number => 1, :workshift => ws } ])
+    start_time = Time.utc(2009, 'Jan', 1, 8, 0, 0)
+    incident_arrival = start_time + 2.hours
+
+    @simulation.expect(:new_event,
+                       nil,
+                       [ Symian::Event::ET_OPERATOR_LEAVING, String, incident_arrival + 6.hours, 'SG'])
+
+    sg.initialize_at(start_time)
+    i = Symian::Incident.new(0, incident_arrival,
+                             :category     => 'normal',
+                             :priority     => 0) # not supported at the moment
+
+    # first increase queue size,...
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_SUPPORT_GROUP_QUEUE_SIZE_CHANGE, 1, incident_arrival, 'SG'])
+    # ...then decrease it, ...
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_SUPPORT_GROUP_QUEUE_SIZE_CHANGE, 0, incident_arrival, 'SG'])
+    # ...assign it to an operator, ...
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_INCIDENT_ASSIGNMENT, Array, incident_arrival, 'SG'])
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_OPERATOR_ACTIVITY_STARTS, Array, incident_arrival, 'SG'])
+    # ...and finally escalate the incident.
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_OPERATOR_ACTIVITY_FINISHES, Array, incident_arrival + 6.hours, 'SG'])
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_INCIDENT_RESCHEDULING, Array, incident_arrival + 6.hours, 'SG'])
+
+    sg.new_incident(i, incident_arrival)
+
+    i.visited_support_groups.must_equal 1
+  end
+
+
+  it 'should accept new incidents' do
+    sg = Symian::SupportGroup.new('SG',
+                                  @simulation,
+                                  { :distribution => :constant, :value => 500 },
+                                  [ { :number => 3, :workshift => Symian::WorkShift.new(:all_day_long) } ])
+    start_time = Time.now
+    sg.initialize_at(start_time)
+    incident_arrival = start_time + 3600  # after 1 hour
+    i = Symian::Incident.new(0, incident_arrival,
+                             :category     => 'normal',
+                             :priority     => 0) # not supported at the moment
+
+    # first increase queue size,...
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_SUPPORT_GROUP_QUEUE_SIZE_CHANGE, 1, incident_arrival, 'SG'])
+    # ...then decrease it, ...
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_SUPPORT_GROUP_QUEUE_SIZE_CHANGE, 0, incident_arrival, 'SG'])
+    # ...assign it to an operator, ...
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_INCIDENT_ASSIGNMENT, Array, incident_arrival, 'SG'])
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_OPERATOR_ACTIVITY_STARTS, Array, incident_arrival, 'SG'])
+    # ...and finally escalate the incident.
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_OPERATOR_ACTIVITY_FINISHES, Array, incident_arrival + 500, 'SG'])
+    @simulation.expect(:new_event, nil, [Symian::Event::ET_INCIDENT_ESCALATION, Symian::Incident, incident_arrival + 500, 'SG'])
+
+    sg.new_incident(i, incident_arrival)
+
+    i.visited_support_groups.must_equal 1
+  end
+
+  # it 'should handle operators going home'
+
+  # it 'should handle operators coming back'
+
+  # it 'should handle operators finishing their work'
+
+end
+