call-rota 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3cde12e911d3263bf5173b3682108d4275a65baf
+  data.tar.gz: 75026298ff90a1eb6b8edfd16672143c46ac5181
+SHA512:
+  metadata.gz: ebc7f858f79ab4ab805dd25735c5c1bede161aae185cf8d0b7110bd039c96d16aac957c98bba5f8a2c87882d913d83813fee471cde1257169c169fb934653db4
+  data.tar.gz: 4d31b2ff54b713fd0cf5a7eb2e7e1d25145178d800917450e66392683b869b33c64b7b00a7a55e13809540b9c40de8b36d933f2cf7187916221c78025842f43c

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 GOV.UK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,3 @@
+# Call rota
+
+Gem that provides a script to generate on-call rotas

data/lib/call_rota/version.rb

@@ -0,0 +1,3 @@
+module CallRota
+  VERSION = "0.0.1"
+end

data/lib/people_collection_factory.rb

@@ -0,0 +1,32 @@
+require "ostruct"
+
+class PeopleCollectionFactory
+  def initialize(people_inputs, deploy_access_inputs)
+    @people_inputs = people_inputs
+    @people_with_deploy_access = production_access_use_names(deploy_access_inputs)
+  end
+
+  def call
+    @people_inputs.map do |person_hash|
+      build_person(
+        person_hash,
+        deploy_access?(person_hash[:use_name]),
+      )
+    end
+  end
+
+private
+  def build_person(person_hash, has_production_access)
+    OpenStruct.new(
+      person_hash.merge(production_access: has_production_access)
+    )
+  end
+
+  def production_access_use_names(raw_deploy_access_inputs)
+    raw_deploy_access_inputs.map { |p| p[:use_name] }
+  end
+
+  def deploy_access?(person_use_name)
+    @people_with_deploy_access.include? person_use_name
+  end
+end

data/lib/rota_week_builder.rb

@@ -0,0 +1,69 @@
+class RotaWeekBuilder
+  def initialize(people)
+    @people = people
+  end
+
+  def call
+    RotaWeek.new(
+      :web_ops => pick_person("webops"),
+      :dev => pick_person("developer", true),
+      :supplemental_dev => pick_person("developer"),
+    )
+  end
+
+private
+
+  def pick_person(role, production_access=false)
+    eligible_people = available_people(role, production_access)
+    if eligible_people.empty?
+      raise "No more people to pick for role #{role}
+            #{production_access ? "with production access" : ""}!"
+    end
+    eligible_people.sample.tap do |chosen_person|
+      make_ineligible(team_members(chosen_person.team))
+    end
+  end
+
+  def team_members(team_name)
+    @people.select { |p| p.team == team_name }
+  end
+
+  def available_people(role, production_access)
+    people_with_role_and_access(role, production_access) - ineligible_people
+  end
+
+  def ineligible_people
+    @ineligible_people ||= []
+  end
+
+  def make_ineligible(people)
+    @ineligible_people = ineligible_people + people
+  end
+
+  def people_with_role_and_access(role, production_access)
+    result = @people.dup
+    if production_access
+      result = result.select { |p| p.production_access == true }
+    end
+    result.select { |p| p.rota_skill_group == role }
+  end
+
+end
+
+class RotaWeek
+  include Enumerable
+
+  attr_reader :web_ops, :dev, :supplemental_dev
+
+  def initialize(web_ops:, dev:, supplemental_dev:)
+    @web_ops = web_ops
+    @dev = dev
+    @supplemental_dev = supplemental_dev
+  end
+
+  def each
+    yield web_ops
+    yield dev
+    yield supplemental_dev
+  end
+end

data/spec/helpers/test_penguin_factories.rb

@@ -0,0 +1,73 @@
+module TestPenguinFactories
+  class ColonyFactory
+    include RSpec::Mocks
+
+    def initialize(generator)
+      @generator = generator
+    end
+
+    def call(teams:, test_penguin_team_factory:)
+      result = []
+
+      teams.times do |i|
+        result += test_penguin_team_factory.call("team_#{i}")
+      end
+
+      result
+    end
+  end
+
+  class TeamFactory
+    include RSpec::Mocks
+
+    def initialize(generator, webops:, developers_with_prod:, developers_without_prod:)
+      @generator = generator
+      @webops = webops
+      @developers_with_prod = developers_with_prod
+      @developers_without_prod = developers_without_prod
+    end
+
+    def call(team_name = "team_name")
+      result = []
+
+      @webops.times do
+        result << webops_penguin_factory.call(team_name)
+      end
+
+      @developers_with_prod.times do
+        result << developers_penguin_factory.call(team_name, true)
+      end
+
+      @developers_without_prod.times do
+        result << developers_penguin_factory.call(team_name, false)
+      end
+
+      result
+    end
+
+  private
+    def webops_penguin_factory
+      ->(team_name) {
+        double(:webops_penguin,
+          team: team_name,
+          rota_skill_group: "webops",
+          production_access: true,
+        )
+      }
+    end
+
+    def developers_penguin_factory
+      ->(team_name, production_access) {
+        double(:developer_penguin,
+          team: team_name,
+          rota_skill_group: "developer",
+          production_access: production_access,
+        )
+      }
+    end
+
+    def double(symbol, *args)
+      @generator.call(symbol, *args)
+    end
+  end
+end

data/spec/people_collection_factory_spec.rb

@@ -0,0 +1,61 @@
+require 'people_collection_factory'
+
+describe PeopleCollectionFactory do
+  let(:names) { ["Blue Penguin", "Red Penguin"] }
+  let(:use_names) { ["B Penguin", "R Penguin"] }
+  let(:blue_penguin_hash) {
+    {
+      :full_name        => names.first,
+      :use_name         => use_names.first,
+      :rota_skill_group => "developer",
+      :team             => "User Formats",
+    }
+  }
+  let(:red_penguin_hash) {
+    {
+      :full_name        => names[1],
+      :use_name         => use_names[1],
+      :rota_skill_group => "webops",
+      :team             => "Product Gaps",
+    }
+  }
+
+  #When this data is available, this will contain
+  #information about whether person is tech lead or not
+  let(:people_input_data) {
+    [
+      blue_penguin_hash,
+      red_penguin_hash,
+    ]
+  }
+
+  let(:deploy_access_input_data) {
+    [
+      red_penguin_hash,
+    ]
+  }
+
+  subject(:factory) {
+    described_class.new(
+      people_input_data,
+      deploy_access_input_data
+    )
+  }
+
+  it "returns a collection of objects representing the input data" do
+    result = factory.call
+    first_result = result[0]
+
+    expect(result).to respond_to :[]
+    expect(result.size).to eq(2)
+    expect(names).to include(first_result.full_name)
+  end
+
+  it "correctly determines production access" do
+    result = factory.call
+    with_production_access = result.select { |p| p.production_access == true }
+
+    expect(with_production_access.size).to eq(1)
+    expect(with_production_access.first.use_name).to eq("R Penguin")
+  end
+end

data/spec/rota_week_builder_spec.rb

@@ -0,0 +1,64 @@
+require "rota_week_builder"
+require "helpers/test_penguin_factories"
+
+describe RotaWeekBuilder do
+  let(:penguins) {
+    test_penguin_team_factory = TestPenguinFactories::TeamFactory.new(
+      method(:double),
+      webops: 2,
+      developers_with_prod: 2,
+      developers_without_prod: 10,
+    )
+    TestPenguinFactories::ColonyFactory.new(method(:double)).call(
+      teams: 3,
+      test_penguin_team_factory: test_penguin_team_factory,
+    )
+  }
+
+  subject(:builder) { RotaWeekBuilder.new(penguins) }
+
+  let(:result) { subject.call }
+
+  it "returns a collection for the next week" do
+    expect(result.web_ops).not_to be(nil)
+    expect(result.dev).not_to be(nil)
+    expect(result.supplemental_dev).not_to be(nil)
+    expect(result.count).to eq(3)
+  end
+
+  it "returns three different people" do
+    people = result.map.to_a
+    expect(people.uniq.size).to eq(3)
+  end
+
+  it "returns people of the right role for their allocated job" do
+    expect(result.web_ops.rota_skill_group).to eq("webops")
+    expect(result.dev.rota_skill_group).to eq("developer")
+    expect(result.supplemental_dev.rota_skill_group).to eq("developer")
+  end
+
+  it "returns a primary dev with production access" do
+    expect(result.dev.production_access).to be true
+  end
+
+  it "returns people from different teams" do
+    people = [result.dev, result.supplemental_dev, result.web_ops]
+
+    expect(people.map(&:team).uniq.size).to eq 3
+  end
+
+  context "with two people" do
+    let(:penguins) {
+      TestPenguinFactories::TeamFactory.new(
+        method(:double),
+        webops: 1,
+        developers_with_prod: 0,
+        developers_without_prod: 1,
+      ).call
+    }
+
+    it "raises if not provided with enough people" do
+      expect { subject.call }.to raise_error
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: call-rota
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tom Russell
+- Camille Baldock
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: gem_publisher
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: bradley.wright@digital.cabinet-office.gov.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/call_rota/version.rb
+- lib/people_collection_factory.rb
+- lib/rota_week_builder.rb
+- spec/helpers/test_penguin_factories.rb
+- spec/people_collection_factory_spec.rb
+- spec/rota_week_builder_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alphagov/call-rota
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Gem that provides a script to generate on-call rotas
+test_files:
+- spec/helpers/test_penguin_factories.rb
+- spec/people_collection_factory_spec.rb
+- spec/spec_helper.rb
+- spec/rota_week_builder_spec.rb