gertrude 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NmQ3MGEzYjg1ZTJmNjhiNWE2N2JjMjRiNmE5ODEwZTE3NDJjNTZiYw==
+  data.tar.gz: !binary |-
+    ZWNmMzc5Y2I3NDJhMWMyMmQ3MmFlMDI0YzljMzFiM2I0ZDAzMzY0ZQ==
+SHA512:
+  metadata.gz: !binary |-
+    NWYzYTEyZGM2YjYwYjk2MDdjMDI3MjlhNzU3MTU1MjNlZTk3M2U0YjZkNTY1
+    OTA2ZDMyZGIzMmY4ZDRjZThmMWU1OWNmNDgwYTM3M2E3YjRhNzAwMGYzMzJh
+    ZmQwYTUyZmZiYjgzNWMxYjJiMzkwMWVkNzk5Nzk5ZGVhZDk3ZDA=
+  data.tar.gz: !binary |-
+    ZmIwNWUxNzA3ZjZiZWM0ZWRiNDFmMzcwOWZiODIwNWFlNDU5ZTE3OTcxYWFi
+    YWMxNjljNDVlZGI2ZjUyNjZhYTBiNjIzNDI3MTI1NGRmY2Y2ZmZmNjhiNjZl
+    NTRjNzk3MzgwNDQ4OTkxMDdjZjg0ZWU4MDc0NDc5MzI3ZDZjZmI=

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store
+.idea/
+lib/gertrude/items/.DS_Store
+

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gertrude.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Wallace Harwood
+
+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,134 @@
+Gertrude
+========
+
+Gertrude is your librarian. It's a simple rest service that feeds you unique items, that you define, by type. Those items are reserved
+until you release them back to the service.
+
+As an example, this can be used to limit conflicts in users when testing. Testers (or automation) can request users
+from the service, and use them for testing. The service won't provide that specific user to another request, until the original
+requester releases it back to the service. Check your stuff back in to Gertrude. Dont be that guy.
+
+How do I use this?
+------------------
+
+ - Install the gem.
+ - Define your items in a yaml file, by type.
+ - Start the service, using your created yaml file.
+ - Request items from the service.
+ - Use the requested items to your hearts content.
+ - Release the item back to the service when you are done.
+ - ???
+ - PROFIT.
+
+Define items in a yaml file, by type
+------------------------------------
+
+Create a yaml file, using the following format:
+```ruby
+---
+item_type1:
+  type1_item1:
+    item1_property1: property1_value
+    items1_property2: property2_value
+  type1_item2:
+    item2_property1: property1_value
+    items2_property2: property2_value
+```
+
+Example (for an implementation to provide users):
+```ruby
+---
+admin:
+  admin1:
+    password: admin_password_1
+    other: admin_other
+  admin2:
+    password: admin_password_2
+    other: admin_other
+  admin3:
+    password: admin_password_3
+    other: admin_other
+basic:
+  basic1:
+  basic2:
+  basic3:
+custom_user:
+  john_smith:
+    password: jsmithpw
+    rep_id: 8675309
+    other_info:
+      - foo
+      - bar
+          - baz
+```
+
+Alternately, you can replace the "all_items.yml" file in the repo with your yaml file, and then start the service.
+
+Install the Gem
+--------------
+
+Install the gem
+```ruby
+$gem install gertrude
+```
+
+Start service, using created yaml file
+--------------------------------------
+
+Start the service. In this example, we use rack:
+```ruby
+$gertrude start -f path/to/yml
+```
+
+Request items from the service
+------------------------------
+
+Routes are as follows (please replace with your host address, item type, and port)
+
+See all available items, and their properties.
+```ruby
+  http://0.0.0.0:8080/
+```
+
+Get a list of all items available for reservation
+```ruby
+  http://0.0.0.0:8080/available
+```
+
+Reserve an item.
+```ruby
+  http:/0.0.0.0:8080/reserve/item?type=admin
+```
+
+Gertrude will return you the requested item as a hash.
+```ruby
+ {'admin1' => {'password' => 'admin_password_1', 'other' => 'admin_other'}
+```
+
+You can pass a timeout, in seconds (default is 30). Sometimes you have to wait for an item to become available.
+```ruby
+  http://0.0.0.0:8080/reserve/item?type=admin&timeout=120
+```
+
+Get a list of all items that are currently reserved.
+```ruby
+  http://0.0.0.0:8080/reserved
+```
+
+Use the requested items to your hearts content
+---------------------------------------------
+
+Enjoy your item, for however long you need to. Go ahead. Have a blast.
+
+Release the item back to the service when you are done
+------------------------------------------------------
+
+Release an item back to the service. You can't keep it forever.
+```ruby
+  http://0.0.0.0:8080/release/item?item=admin1
+```
+
+Release all currently reserved items.
+```ruby
+  http://0.0.0.0:8080/release
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+

data/bin/gertrude

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'optparse'
+require 'yaml'
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: example.rb [options]"
+
+  opts.on("-f", "--file [FILEPATH]", String, "Pass the yml file.") do |file|
+    options[:file] = file
+  end
+
+  opts.on("-p", "--port [PORT]", Integer, "Assign server port (Default is 4567)") do |p|
+    options[:port] = p
+  end
+
+  opts.on("-d", "--daemonize", "Run the server in the background") do |d|
+    options[:daemonize] = d
+  end
+
+  opts.on("-e", "--environment [ENV]", String, "Set Sinatra environment (Default is development)") do |env|
+    options[:environment] = env
+  end
+
+  opts.on("-o", "--host [HOST]", String, "Set the host address (Default is 0.0.0.0)") do |host|
+    options[:host] = host
+  end
+
+  opts.on("-h", "--help", "Display this help") do
+    puts opts
+    exit
+  end
+end.parse!
+
+options[:port] = 4567 if options[:port].nil?
+options[:environment] = 'development' if options[:environment].nil?
+options[:host] = '0.0.0.0' if options[:host].nil?
+
+require 'gertrude'
+require 'webrick'
+
+config_file = "#{Dir.pwd}/config.yml"
+
+case ARGV[0].downcase
+  when 'start'
+    fail "File is a required parameter" if options[:file].nil?
+    options[:file] = File.expand_path(options[:file])
+    if options[:daemonize]
+      File.write(config_file, options.to_yaml)
+      WEBrick::Daemon.start
+    end
+    ItemServer.run!(options)
+  when 'stop'
+    config = YAML.load_file(config_file)
+    port = config[:port]
+    fail "Port not found in config file.  You'll need to manually kill the server." if config[:port].nil?
+    `kill $(lsof -t -i :#{port})`
+    `rm #{config_file}` if File.exists?(config_file)
+  else
+    fail "Start and stop are the only two options."
+end
+
+
+

data/bin/setup

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+

data/gertrude.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gertrude/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gertrude"
+  spec.version       = Gertrude::VERSION
+  spec.authors       = ["Wallace Harwood", "Jarod Adair", "Umair Chagani"]
+  spec.email         = ["wallace.harwood@manheim.com", "jarod.adair@manheim.com", "umair.chagani@manheim.com"]
+
+  spec.summary       = %q{Librarian to manage your things for you.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rack-test'
+  spec.add_runtime_dependency 'bundler', "~> 1.11"
+  spec.add_runtime_dependency 'sinatra'
+  spec.add_runtime_dependency 'test-helpers'
+end
+

data/lib/gertrude.rb

@@ -0,0 +1,13 @@
+require 'bundler'
+require 'sinatra'
+require 'pry'
+require 'test-helpers/all'
+require 'yaml'
+require 'json'
+require 'gertrude/items/item_error'
+require 'gertrude/items/items_list'
+require 'gertrude/core_ext/hash'
+require 'gertrude/items/item_server'
+
+module Gertrude
+end

data/lib/gertrude/core_ext/hash.rb

@@ -0,0 +1,17 @@
+class Hash
+  def has_deep_key?(key)
+    self.has_key?(key) || any? { |k, v| v.has_deep_key?(key) if v.is_a? Hash }
+  end
+
+  def has_deep_value?(value)
+    self.has_value?(value) || any? { |k, v| v.has_deep_value?(value) if v.is_a? Hash }
+  end
+
+  def deep_find(key, hash = self)
+    return hash[key] if hash.respond_to?(:key?) && hash.key?(key)
+    return unless hash.is_a?(Enumerable)
+    found = nil
+    hash.find { |*x| found = deep_find(key, x.last) }
+    found
+  end
+end

data/lib/gertrude/items/item_error.rb

@@ -0,0 +1,16 @@
+class ItemError
+  class ItemTypeNotDefined < ArgumentError
+  end
+
+  class NoReservedItems < ArgumentError
+  end
+
+  class ItemsNotUnique < StandardError
+  end
+
+  class InvalidItem < ArgumentError
+  end
+
+  class NoAvailableItems < StandardError
+  end
+end

data/lib/gertrude/items/item_server.rb

@@ -0,0 +1,51 @@
+class ItemServer < Sinatra::Base
+
+  def initialize
+    super
+    @items_list = ItemsList.new.load_items!(settings.file)
+  end
+
+  error ::ItemError::ItemTypeNotDefined do |type|
+    error 422, "Item type not defined: #{type}"
+  end
+
+  error ::ItemError::NoReservedItems do
+    halt 422, 'No items currently reserved'
+  end
+
+  error ::ItemError::InvalidItem do |item|
+    halt 422, "Item does not exist in the service: #{item}"
+  end
+
+  error ::ItemError::NoAvailableItems do |type|
+    halt 422, "No #{type} items available to reserve"
+  end
+
+  get '/' do
+    @items_list.get_all_items.to_json
+  end
+
+  get '/reserve/item' do
+    @items_list.get_item(params[:type], params[:timeout] || 30).to_json
+  end
+
+  get '/release/item' do
+    (!@items_list.release_item(params[:item])).to_json
+  end
+
+  get '/reserved' do
+    @items_list.get_reserved_items.to_json
+  end
+
+  get '/release' do
+    status 204 if @items_list.release_all_items
+  end
+
+  get '/available' do
+    @items_list.get_available_items.to_json
+  end
+end
+
+
+
+

data/lib/gertrude/items/items_list.rb

@@ -0,0 +1,108 @@
+class ItemsList
+  include TestHelpers::Wait
+
+  attr_accessor :items
+  RESERVE_KEY = "reserved_#{SecureRandom.hex(4)}".to_sym
+
+  def load_items!(yml)
+    config = YAML.load_file(yml)
+    config.each_key do |type|
+      config[type].each_key do |item|
+        config[type][item] = {} if config[type][item].nil?
+        config[type][item][RESERVE_KEY] = false
+      end
+    end
+    raise ItemError::ItemsNotUnique.new unless unique_keys_across_items?(config)
+    @items = config
+    self
+  end
+
+  def unique_keys_across_items?(config)
+    item_keys = []
+    config.each_value { |v| item_keys.push(v.keys) }
+    item_keys.flatten!
+    item_keys.count == item_keys.uniq.count
+  end
+
+  def get_item(type, timeout)
+    raise ItemError::ItemTypeNotDefined.new(type) unless @items.has_key? type
+    loop_for_item(type, timeout)
+  end
+
+  def release_item(item)
+    raise ItemError::InvalidItem.new(item) unless @items.has_deep_key?(item)
+    @items.deep_find(item)[RESERVE_KEY] = false
+  end
+
+  def get_reserved_items
+    reserved_items.join(", ")
+  end
+
+  def get_available_items
+    available_items.join(",")
+  end
+
+  def get_all_items
+    list = Marshal.load(Marshal.dump(@items))
+    list.each_key do |type|
+      list[type].each do |item|
+        list[type][item[0]] = sanitize_response({item[0] => item[1]})
+      end
+    end
+    list
+  end
+
+  def release_all_items
+    raise ItemError::NoReservedItems if reserved_items.empty?
+    @items.each_key do |type|
+      @items[type].each_key do |item|
+        @items[type][item][RESERVE_KEY] = false if @items[type][item][RESERVE_KEY]
+      end
+    end
+    true
+  end
+
+  def available_items
+    available_items = []
+    @items.each_key do |type|
+      @items[type].each_key do |item|
+        available_items << item unless @items[type][item][RESERVE_KEY]
+      end
+    end
+    available_items
+  end
+
+  def reserved_items
+    taken_items = []
+    @items.each_key do |type|
+      @items[type].each_key do |item|
+        taken_items << item if @items[type][item][RESERVE_KEY]
+      end
+    end
+    taken_items
+  end
+
+  def loop_for_item(type, timeout)
+    item = wait_until(timeout: timeout) do
+      item = get_available_item(type)
+      raise ItemError::NoAvailableItems if item.empty?
+      item
+    end
+    reserve_item(type, item.keys.first)
+    sanitize_response(item)
+  end
+
+  def sanitize_response(item)
+    x = Marshal.load(Marshal.dump(item))
+    x.first.last.delete(RESERVE_KEY)
+    x
+  end
+
+  def reserve_item(type, item_key)
+    @items[type][item_key][RESERVE_KEY] = true
+  end
+
+  def get_available_item(type)
+    Hash[*@items[type].select { |item| !@items[type][item][RESERVE_KEY] }.first]
+  end
+end

data/lib/gertrude/version.rb

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

data/spec/gertrude_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe('item server') do
+  let (:item) { {'danny7' => {'user_name' => 'danny9', 'rep_id' => '100014624', 'profile_id' => '8192'}} }
+  let (:hash) { {type: {test: {hello: 'world', foo: 'bar'}, basic: {basic1: {}, basic2: {}}}} }
+
+  it('should reserve an item') do
+    allow_any_instance_of(ItemsList).to receive(:get_item).with('admin', 30).and_return(item)
+    get '/reserve/item?type=admin'
+    expect(last_response.body).to eql item.to_json
+  end
+
+  it('should release an item') do
+    allow_any_instance_of(ItemsList).to receive(:release).with('danny7').and_return(false)
+    get '/release/item?item=danny7'
+    expect(last_response.body).to eql 'true'
+  end
+
+  it('should release all items') do
+    allow_any_instance_of(ItemsList).to receive(:release_all_items).and_return(true)
+    get '/release'
+    expect(last_response.status).to eql 204
+  end
+
+  it('should return 500 error if release all items fails') do
+    allow_any_instance_of(ItemsList).to receive(:release_all_items).and_raise(ArgumentError)
+    get '/release'
+    expect(last_response.status).to eql 500
+  end
+
+  it('should return a list of reserved items') do
+    allow_any_instance_of(ItemsList).to receive(:get_reserved_items).and_return('danny7')
+    get '/reserved'
+    expect(last_response.body).to eql "\"danny7\""
+  end
+
+  it('should return a list of available items') do
+    allow_any_instance_of(ItemsList).to receive(:get_available_items).and_return('johnny5')
+    get '/available'
+    expect(last_response.body).to eql "\"johnny5\""
+  end
+
+  it('should return Item Type Not Defined error if item type does not exist') do
+    allow_any_instance_of(ItemsList).to receive(:get_item).with('foo', 30).and_raise(ItemError::ItemTypeNotDefined.new('foo'))
+    get '/reserve/item?type=foo'
+    expect(last_response.status).to eql 422
+    expect(last_response.body).to eql 'Item type not defined: foo'
+  end
+
+  it('should return No Available Items error if item type does not exist') do
+    allow_any_instance_of(ItemsList).to receive(:get_item).with('foo', 30).and_raise(ItemError::NoAvailableItems.new('foo'))
+    get '/reserve/item?type=foo'
+    expect(last_response.status).to eql 422
+    expect(last_response.body).to eql "No foo items available to reserve"
+  end
+
+  it('should return No Reserved Items error if no items in reserved list') do
+    allow_any_instance_of(ItemsList).to receive(:get_reserved_items).and_raise(ItemError::NoReservedItems)
+    get '/reserved'
+    expect(last_response.status).to eql 422
+    expect(last_response.body).to eql 'No items currently reserved'
+  end
+
+  it('should return Invalid Item error if item does not exist') do
+    allow_any_instance_of(ItemsList).to receive(:release).with('foo').and_raise(ItemError::InvalidItem.new('foo'))
+    get '/release/item?item=foo'
+    expect(last_response.status).to eql 422
+    expect(last_response.body).to eql 'Item does not exist in the service: foo'
+  end
+
+  it('should raise No Reserved Items error if no items reserved') do
+    allow_any_instance_of(ItemsList).to receive(:release_all_items).and_raise(ItemError::NoReservedItems)
+    get '/release'
+    expect(last_response.status).to eql 422
+    expect(last_response.body).to eql 'No items currently reserved'
+  end
+
+  it('should return all items') do
+    allow_any_instance_of(ItemsList).to receive(:get_all_items).and_return(hash)
+    get '/'
+    expect(last_response.body).to eql hash.to_json
+  end
+end

data/spec/hash_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe('Hash') do
+  before(:each) do
+    @some_hash = {foo: {bar: {bat: 'thing'}}}
+  end
+
+  describe('#has_deep_key') do
+    it('should return true if deep key exists') do
+      expect(@some_hash.has_deep_key?(:bar)).to be true
+    end
+
+    it('should return false if deep key does not exist') do
+      expect(@some_hash.has_deep_key?(:blah)).to be false
+    end
+  end
+
+  describe('#has_deep_value') do
+    it('should return true if deep value exists') do
+      expect(@some_hash.has_deep_value?('thing')).to be true
+    end
+
+    it('should return false if deep value does not exist') do
+      expect(@some_hash.has_deep_value?('not there')).to be false
+    end
+  end
+
+  describe('#deep_find') do
+    it('should return hash if key value is hash') do
+      expect(@some_hash.deep_find(:bar)).to eql({bat: 'thing'})
+    end
+
+    it('should return value if key is not a hash') do
+      expect(@some_hash.deep_find(:bat)).to eql 'thing'
+    end
+
+    it('should return first value for duplicate keys') do
+      @some_hash = {foo: {bar: {foo: 'thing'}}}
+      expect(@some_hash.deep_find(:foo)).to eql({bar: {foo: 'thing'}})
+    end
+  end
+end
+

data/spec/items_list_spec.rb

@@ -0,0 +1,186 @@
+require_relative 'spec_helper'
+
+describe 'items list' do
+  let(:item_list) { ItemsList.new }
+  let(:item) { {'danny7' => {'user_name' => 'danny9', 'rep_id' => '100014624', 'profile_id' => '8192'}} }
+
+  before(:each) do
+    item_list.items = {'admin' =>
+                           {'danny7' => {'user_name' => 'danny9', 'rep_id' => '100014620', 'profile_id' => '8190', ItemsList::RESERVE_KEY.to_sym => false},
+                            'johnny5' => {'user_name' => 'danny7', 'rep_id' => '100014624', 'profile_id' => '8192', ItemsList::RESERVE_KEY.to_sym => false}}}
+  end
+
+  describe '#unique_keys_across_items' do
+    it 'should raise Item Type Not Defined' do
+      expect { item_list.get_item(:blah, 1) }.to raise_error(ItemError::ItemTypeNotDefined)
+    end
+
+    it 'should return true if unique keys' do
+      expect(item_list.unique_keys_across_items?(item_list.items)).to be true
+    end
+
+    it 'should return false if duplicate keys' do
+      item_list.items.merge!({'basic' => {'danny7' => {'user_name' => 'danny7'}}})
+      expect(item_list.unique_keys_across_items?(item_list.items)).to be false
+    end
+  end
+
+  describe '#get_item' do
+    it 'should raise an error if type not defined' do
+      expect { item_list.get_item('foo', 0.01) }.to raise_error ItemError::ItemTypeNotDefined
+    end
+
+    it 'should return an item' do
+      allow(item_list).to receive(:loop_for_item).with('admin', 0.01).and_return(item)
+      expect(item_list.get_item('admin', 0.01)).to eql item
+    end
+  end
+
+  describe '#release_item' do
+    it 'should release an item' do
+      item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY] = true
+      expect(item_list.release_item('danny7')).to be false
+      expect(item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY]).to be false
+    end
+
+    it('should raise Invalid Item error when trying to release non reserved item') do
+      expect { item_list.release_item('foo') }.to raise_error(ItemError::InvalidItem)
+    end
+  end
+
+  describe '#get_reserved_items' do
+    it 'should return a string of reserved items' do
+      allow(item_list).to receive(:reserved_items).and_return(%w(danny7 johnny5))
+      expect(item_list.get_reserved_items).to eql 'danny7, johnny5'
+    end
+  end
+
+  describe '#get_available_items' do
+    it 'should return a string of reserved items' do
+      allow(item_list).to receive(:available_items).and_return(%w(danny7))
+      expect(item_list.get_available_items).to eql 'danny7'
+    end
+  end
+
+  describe '#get_all_items' do
+    it 'should return a string of reserved items' do
+      allow(item_list).to receive(:all_items).and_return(item_list.items)
+      response_hash = {"admin" => {"danny7" => {"danny7" => {"user_name" => "danny9", "rep_id" => "100014620", "profile_id" => "8190"}}, "johnny5" => {"johnny5" => {"user_name" => "danny7", "rep_id" => "100014624", "profile_id" => "8192"}}}}
+      expect(item_list.get_all_items).to eql response_hash
+    end
+  end
+
+  describe '#release_all_items' do
+    it 'should release all items' do
+      allow(item_list).to receive(:reserved_items).and_return(['danny7'])
+      item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY] = true
+      item_list.items['admin']['johnny5'][ItemsList::RESERVE_KEY] = true
+      item_list.release_all_items
+      expect(item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY]).to be false
+      expect(item_list.items['admin']['johnny5'][ItemsList::RESERVE_KEY]).to be false
+    end
+
+    it('should return true') do
+      allow(item_list).to receive(:reserved_items).and_return(['danny7'])
+      item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY] = true
+      item_list.items['admin']['johnny5'][ItemsList::RESERVE_KEY] = true
+      expect(item_list.release_all_items).to be true
+    end
+
+    it('should raise No Reserved Items if no items are reserved') do
+      expect { item_list.release_all_items }.to raise_error(ItemError::NoReservedItems)
+    end
+  end
+
+  describe '#reserved_items' do
+    it 'should return an array of reserved items' do
+      item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY] = true
+      expect(item_list.reserved_items).to eql ['danny7']
+    end
+  end
+
+  describe '#available_items' do
+    it 'should return an array of available items' do
+      item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY] = true
+      expect(item_list.available_items).to eql ['johnny5']
+    end
+  end
+
+  describe '#loop_for_item' do
+    it 'should reserve an item' do
+      allow(item_list).to receive(:get_available_item).with('admin').and_return(item)
+      allow(item_list).to receive(:reserve_item).with('admin', 'danny7').and_return(item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY] = true)
+      allow(item_list).to receive(:sanitize_response).with(item)
+      item_list.loop_for_item('admin', 0.01)
+      expect(item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY]).to be true
+    end
+
+    it 'should return a sanitized response' do
+      allow(item_list).to receive(:get_available_item).with('admin').and_return(item)
+      allow(item_list).to receive(:reserve_item).with('admin', 'danny7')
+      allow(item_list).to receive(:sanitize_response).with(item).and_return(item)
+      expect(item_list.loop_for_item('admin', 0.01)['danny7'].keys).to_not include ItemsList::RESERVE_KEY
+    end
+
+    it 'should return a hash' do
+      allow(item_list).to receive(:get_available_item).with('admin').and_return(item)
+      allow(item_list).to receive(:reserve_item).with('admin', 'danny7')
+      allow(item_list).to receive(:sanitize_response).with(item).and_return(item)
+      expect(item_list.loop_for_item('admin', 0.01)).to be_a_kind_of Hash
+    end
+
+    it 'should raise a timeout error if not items available' do
+      allow(item_list).to receive(:get_available_item).with('admin').and_return([])
+      expect { item_list.loop_for_item('admin', 0.01) }.to raise_error ItemError::NoAvailableItems
+    end
+  end
+
+  describe '#sanitize_response' do
+    it 'should not include reserve key' do
+      item = {'danny7' => {'user_name' => 'danny9', 'rep_id' => '100014624', 'profile_id' => '8192', ItemsList::RESERVE_KEY.to_sym => false}}
+      expect(item_list.sanitize_response(item)['danny7'].keys).to_not include ItemsList::RESERVE_KEY
+    end
+  end
+
+  describe '#reserve_item' do
+    it 'should reserve an item' do
+      expect(item_list.reserve_item('admin', 'danny7')).to be true
+      expect(item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY]).to be true
+    end
+  end
+
+  describe '#get_available_item' do
+    it 'should get next available item' do
+      item_list.items['admin']['danny7'][ItemsList::RESERVE_KEY] = true
+      expect(item_list.get_available_item('admin')).to eql({"johnny5" => {"user_name" => "danny7", "rep_id" => "100014624", "profile_id" => "8192", ItemsList::RESERVE_KEY.to_sym => false}})
+    end
+  end
+
+  describe '#load_items!' do
+    let(:hash) { {type: {test: {hello: 'world', foo: 'bar'}, basic: {basic1: {}, basic2: {}}}} }
+    let(:duplicate_hash) { {type: {test: {hello: 'world', foo: 'bar'}}, type2: {test: {hello: 'world'}}} }
+
+    it 'should add a unique key 2nd level to the given hash' do
+      allow(YAML).to receive(:load_file).with('').and_return(hash)
+      expect(ItemsList.new.load_items!('').items[:type][:test].keys).to include ItemsList::RESERVE_KEY
+    end
+
+    it 'should set @items to provided hash' do
+      allow(YAML).to receive(:load_file).with('').and_return(hash)
+      items = ItemsList.new
+      items.load_items!('')
+      expect(items.instance_variable_get('@items')).to eql hash
+    end
+
+    it 'should raise an error if duplicate keys' do
+      allow(YAML).to receive(:load_file).with('').and_return(duplicate_hash)
+      items = ItemsList.new
+      expect { items.load_items!('') }.to raise_error ItemError::ItemsNotUnique
+    end
+
+    it 'should raise an error on invalid config file' do
+      expect { ItemsList.new.load_items!('blah123') }.to raise_error(Errno::ENOENT)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+$project_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+#ARGV[1] = "#{$project_root}/spec/test_items_spec.yml"
+
+require 'sinatra'
+require 'pry'
+require 'test-helpers/all'
+require 'yaml'
+require 'json'
+require 'rspec'
+require 'rack/test'
+require_relative '../lib/gertrude/core_ext/hash'
+require_relative '../lib/gertrude/items/item_error'
+require_relative '../lib/gertrude/items/items_list'
+require_relative '../lib/gertrude/items/item_server'
+
+def app
+  ItemServer.tap do |svr|
+    svr.settings.set(:file,  "#{$project_root}/spec/test_items_spec.yml")
+    svr.set :environment, :production
+  end
+end
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+  config.formatter = :documentation
+  config.include Rack::Test::Methods
+end

data/spec/test_items_spec.yml

@@ -0,0 +1,19 @@
+---
+admin:
+  danny7:
+    user_name: 'danny7'
+    rep_id: '100014624'
+    profile_id: '8192'
+  man1:
+    user_name: 'man1'
+    rep_id: '100012345'
+    profile_id: '8100'
+rep:
+  hhummer:
+    user_name: 'hhummer'
+    rep_id: '100428682'
+    profile_id: '8064'
+  man3:
+    user_name: 'man3'
+    rep_id: '100976252'
+    profile_id: '8238'

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: gertrude
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Wallace Harwood
+- Jarod Adair
+- Umair Chagani
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.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'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-helpers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- wallace.harwood@manheim.com
+- jarod.adair@manheim.com
+- umair.chagani@manheim.com
+executables:
+- console
+- gertrude
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/gertrude
+- bin/setup
+- gertrude.gemspec
+- lib/gertrude.rb
+- lib/gertrude/core_ext/hash.rb
+- lib/gertrude/items/item_error.rb
+- lib/gertrude/items/item_server.rb
+- lib/gertrude/items/items_list.rb
+- lib/gertrude/version.rb
+- spec/gertrude_spec.rb
+- spec/hash_spec.rb
+- spec/items_list_spec.rb
+- spec/spec_helper.rb
+- spec/test_items_spec.yml
+homepage: ''
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Librarian to manage your things for you.
+test_files:
+- spec/gertrude_spec.rb
+- spec/hash_spec.rb
+- spec/items_list_spec.rb
+- spec/spec_helper.rb
+- spec/test_items_spec.yml