revised_holidays 9.0.0

data/definitions/sk.yaml

@@ -0,0 +1,154 @@
+# Slovak holiday definitions for the Ruby Holiday gem.
+#
+# Updated: 2013-12-26.
+# Sources:
+# - http://sk.wikipedia.org/wiki/Slovensk%C3%A9_%C5%A1t%C3%A1tne_sviatky
+---
+months:
+  0:
+  - name: Veľkonočný pondelok
+    regions: [sk]
+    function: easter(year)
+    function_modifier: 1
+  - name: Veľký piatok
+    regions: [sk]
+    function: easter(year)
+    function_modifier: -2
+  1:
+  - name: Nový rok
+    regions: [sk]
+    mday: 1
+  - name: Zjavenie Pána (Traja králi)
+    regions: [sk]
+    mday: 6
+  5:
+  - name: Sviatok práce
+    regions: [sk]
+    mday: 1
+  - name: Deň víťazstva nad fašizmom
+    regions: [sk]
+    mday: 8
+  7:
+  - name: Sviatok svätého Cyrila a svätého Metoda
+    regions: [sk]
+    mday: 5
+  8:
+  - name: Výročie Slovenského národného povstania
+    regions: [sk]
+    mday: 29
+  9:
+  - name: Deň Ústavy Slovenskej republiky
+    regions: [sk]
+    mday: 1
+  - name: Sedembolestná Panna Mária
+    regions: [sk]
+    mday: 15
+  11:
+  - name: Sviatok všetkých svätých
+    regions: [sk]
+    mday: 1
+  - name: Deň boja za slobodu a demokraciu
+    regions: [sk]
+    mday: 17
+  12:
+  - name: Štedrý deň
+    regions: [sk]
+    mday: 24
+  - name: 1. sviatok vianočný
+    regions: [sk]
+    mday: 25
+  - name: 2. sviatok vianočný
+    regions: [sk]
+    mday: 26
+
+tests:
+  - given:
+      date: '2013-01-01'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Nový rok"
+  - given:
+      date: '2013-01-06'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Zjavenie Pána (Traja králi)"
+  - given:
+      date: '2013-03-29'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Veľký piatok"
+  - given:
+      date: '2013-04-01'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Veľkonočný pondelok"
+  - given:
+      date: '2013-05-01'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Sviatok práce"
+  - given:
+      date: '2013-05-08'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Deň víťazstva nad fašizmom"
+  - given:
+      date: '2013-07-05'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Sviatok svätého Cyrila a svätého Metoda"
+  - given:
+      date: '2013-08-29'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Výročie Slovenského národného povstania"
+  - given:
+      date: '2013-09-01'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Deň Ústavy Slovenskej republiky"
+  - given:
+      date: '2013-09-15'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Sedembolestná Panna Mária"
+  - given:
+      date: '2013-11-01'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Sviatok všetkých svätých"
+  - given:
+      date: '2013-11-17'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Deň boja za slobodu a demokraciu"
+  - given:
+      date: '2013-12-24'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "Štedrý deň"
+  - given:
+      date: '2013-12-25'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "1. sviatok vianočný"
+  - given:
+      date: '2013-12-26'
+      regions: ["sk"]
+      options: ["informal"]
+    expect:
+      name: "2. sviatok vianočný"

data/definitions/spec/coverage_report.rb

@@ -0,0 +1,7 @@
+require 'simplecov'
+SimpleCov.minimum_coverage 100
+SimpleCov.coverage_dir 'reports/coverage'
+SimpleCov.start do
+  add_filter "/spec/"
+  add_filter "/.bundle/"
+end

data/definitions/spec/data/invalid/months/malformed/bad.yaml

@@ -0,0 +1,15 @@
+---
+months:
+  1:
+  - name: Test Holiday
+    regions: [test]
+    mday: 1
+
+methods:
+  test:
+    arguments: year
+    source: |
+      true
+
+tests: |
+  test

data/definitions/spec/data/invalid/months/missing/no_months.yaml

@@ -0,0 +1,9 @@
+---
+methods:
+  test:
+    arguments: year
+    source: |
+      true
+
+tests: |
+  test

data/definitions/spec/data/valid/simple.yaml

@@ -0,0 +1,15 @@
+---
+months:
+  1:
+  - name: Test Holiday
+    regions: [test]
+    mday: 1
+
+methods:
+  test:
+    arguments: year
+    source: |
+      true
+
+tests: |
+  test

data/definitions/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$: << '../lib'
+
+require 'coverage_report'
+
+RSpec.configure do |c|
+  c.order = :random
+end

data/definitions/spec/validation/custom_method_validator_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'validation/custom_method_validator'
+
+describe Definitions::Validation::CustomMethod do
+  let(:methods) {
+    {
+      'test' => {
+        'arguments' => "date,year,month,day",
+        'ruby' => "some source",
+      }
+    }
+  }
+
+  subject { described_class.new }
+
+  context 'success' do
+    it 'returns true' do
+      expect(subject.call(methods)).to be true
+    end
+  end
+
+  context 'failure' do
+    context 'name' do
+      it 'returns false if empty' do
+        methods = {}
+        methods[""]  = {}
+        expect { subject.call(methods) }.to raise_error(Definitions::Errors::InvalidCustomMethod)
+      end
+    end
+
+    context 'arguments' do
+      it 'returns false if nil' do
+        methods['test']['arguments'] = nil
+        expect { subject.call(methods) }.to raise_error(Definitions::Errors::InvalidCustomMethod)
+      end
+
+      it 'returns false if empty' do
+        methods['test']['arguments'] = ""
+        expect { subject.call(methods) }.to raise_error(Definitions::Errors::InvalidCustomMethod)
+      end
+
+      it 'returns false if contains unknown variable' do
+        methods['test']['arguments'] = "unknown"
+        expect { subject.call(methods) }.to raise_error(Definitions::Errors::InvalidCustomMethod)
+      end
+    end
+
+    context 'source' do
+      it 'returns false if nil' do
+        methods['test']['ruby'] = nil
+        expect { subject.call(methods) }.to raise_error(Definitions::Errors::InvalidCustomMethod)
+      end
+
+      it 'returns false if empty' do
+        methods['test']['ruby'] = ""
+        expect { subject.call(methods) }.to raise_error(Definitions::Errors::InvalidCustomMethod)
+      end
+    end
+  end
+end

data/definitions/spec/validation/definition_validator_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'validation/definition_validator'
+
+describe Definitions::Validation::Definition do
+  let(:custom_method_validator) { double(:custom_method_validator, :call => true) }
+  let(:months_validator) { double(:months_validator, :call => nil) }
+  let(:test_validator) { double(:test_validator, :call => true) }
+
+  let(:definition) { {
+    "months" => { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1}] },
+    "methods" =>{ "test" => {"arguments"=>"year", "source"=>"true"} },
+    "tests" => "test"
+  } }
+
+  subject { described_class.new(custom_method_validator, months_validator, test_validator) }
+
+  context 'definition is valid' do
+    it 'reports success' do
+      expect(subject.call(definition)).to be true
+    end
+  end
+
+  context 'invalid months' do
+    it 'raises error if months validator raises error' do
+      expect(months_validator).to receive(:call).with(definition['months']).and_raise(StandardError)
+      expect { subject.call(definition) }.to raise_error(StandardError)
+    end
+  end
+
+  context 'no methods' do
+    it 'returns success' do
+      definition["methods"] = nil
+      expect(subject.call(definition)).to be true
+    end
+  end
+
+  context 'no tests' do
+    it 'raises error' do
+      expect(test_validator).to receive(:call).with(definition['tests']).and_raise(StandardError)
+      expect { subject.call(definition) }.to raise_error(StandardError)
+    end
+  end
+end

data/definitions/spec/validation/month_validator_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+require 'validation/month_validator'
+
+describe Definitions::Validation::Month do
+  subject { described_class.new }
+
+  context 'months are valid' do
+    it 'reports success' do
+      months =  { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1}] }
+      expect(subject.call(months)).to be true
+    end
+  end
+
+  context 'invalid months' do
+    it 'returns error if missing' do
+      expect { subject.call(nil) }.to raise_error(Definitions::Errors::NoMonths)
+    end
+
+    it 'returns error if empty' do
+      expect { subject.call({}) }.to raise_error(Definitions::Errors::NoMonths)
+      expect { subject.call([]) }.to raise_error(Definitions::Errors::NoMonths)
+    end
+
+    it 'returns error if month not an integer' do
+      months = { 'january' => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1}] }
+      expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+        expect(e.message).to eq("All months must be an integer, received: #{months}")
+      }
+    end
+
+    it 'returns error if months not 0 through 12' do
+      months = { -1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1}] }
+      expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+        expect(e.message).to eq("All months must be between 0 and 12, received: #{months}")
+      }
+
+      months = { 13 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1}] }
+      expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+        expect(e.message).to eq("All months must be between 0 and 12, received: #{months}")
+      }
+    end
+
+    it 'returns error if month has no name' do
+      months = { 1 => [{""=>"Test Holiday", "regions"=>["test"], "mday"=>1}] }
+      expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+        expect(e.message).to eq("All months must have a name, received: #{months}")
+      }
+    end
+
+    it 'returns error if month has no regions' do
+      months = { 1 => [{"name"=>"Test Holiday", "mday"=>1}] }
+      expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidRegions) { |e|
+        expect(e.message).to eq("A month must contain at least one region, received: #{months}")
+      }
+    end
+
+    it 'returns error if month has empty regions' do
+      months = { 1 => [{"name"=>"Test Holiday", "regions" => [], "mday"=>1}] }
+      expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidRegions) { |e|
+        expect(e.message).to eq("A month must contain at least one region, received: #{months}")
+      }
+    end
+
+    it 'returns error if month has empty regions' do
+      months = { 1 => [{"name"=>"Test Holiday", "regions"=>[""], "mday"=>1}] }
+      expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidRegions) { |e|
+        expect(e.message).to eq("A month must contain at least one region, received: #{months}")
+      }
+    end
+
+    context 'year_ranges' do
+      it 'returns error if year_ranges contains unknown subkey' do
+        months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"blah" => [2018]} }] }
+        expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+          expect(e.message).to eq("The :year_ranges value only accepts the following: :until, :from, :limited, :between, received: #{months}")
+        }
+      end
+
+      it 'returns error if :until value is not a single integer' do
+        months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"until" => [2018]} }] }
+        expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+          expect(e.message).to eq("The year_ranges.until value must contain a single 'year' integer, ex. 2018, received: #{months}")
+        }
+      end
+
+      it 'returns error if :from value is not a single integer' do
+        months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"from" => [2018]} }] }
+        expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+          expect(e.message).to eq("The year_ranges.from value must contain a single 'year' integer, ex. 2018, received: #{months}")
+        }
+      end
+
+      it 'returns error if :limited value is not an array' do
+        months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"limited" => 2018} }] }
+        expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+          expect(e.message).to eq("The year_ranges.limited value must contain an array of 'year' integers, ex. [2018], received: #{months}")
+        }
+      end
+
+      it 'returns error if :limited value is not an array of integers' do
+        months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"limited" => ["blah"]} }] }
+        expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+          expect(e.message).to eq("The year_ranges.limited value must contain an array of 'year' integers, ex. [2018], received: #{months}")
+        }
+      end
+
+      context 'between' do
+        it 'returns error if not a hash' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"between" => "2008..2012" } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("year_ranges.between must contain both a 'start' and 'end' key, received: #{months}")
+          }
+        end
+
+        it 'returns error if start is missing' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"between" => {"end" => 2018} } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("year_ranges.between must contain both a 'start' and 'end' key, received: #{months}")
+          }
+        end
+
+        it 'returns error if end is missing' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"between" => {"start" => 2016} } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("year_ranges.between must contain both a 'start' and 'end' key, received: #{months}")
+          }
+        end
+
+        it 'returns an error if start value is not an integer' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"between" => {"start" => "2016", "end" => 2018} } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("The year_ranges.between.start value must contain a single 'year' integer, ex. 2018, received: #{months}")
+          }
+        end
+
+        it 'returns an error if end value is not an integer' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"between" => {"start" => 2016, "end" => "2018"} } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("The year_ranges.between.end value must contain a single 'year' integer, ex. 2018, received: #{months}")
+          }
+        end
+
+        it 'returns an error if end value is before start' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"between" => {"start" => 2016, "end" => 2015} } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("The year_ranges.between.end value cannot be before the start value, received: #{months}")
+          }
+        end
+
+        it 'returns an error if the start and end values are the same' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"between" => {"start" => 2016, "end" => 2016} } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("The year_ranges.between start and end values cannot be the same, received: #{months}")
+          }
+        end
+      end
+
+      context 'with multiple selectors' do
+        it 'returns an error if provided an array' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => [{"from" => 2019}, {"between" => {"start" => 2014, "end" => 2016} }] }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("year_ranges only supports a single selector at this time, received: #{months}")
+          }
+        end
+
+        it 'returns an error if there is more than 1 sub key' do
+          months = { 1 => [{"name"=>"Test Holiday", "regions"=>["test"], "mday"=>1, "year_ranges" => {"from" => 2019, "between" => {"start" => 2014, "end" => 2016} } }] }
+          expect { subject.call(months) }.to raise_error(Definitions::Errors::InvalidMonth) { |e|
+            expect(e.message).to eq("year_ranges only supports a single selector at this time, received: #{months}")
+          }
+        end
+      end
+    end
+  end
+end

data/definitions/spec/validation/test_validator_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+require 'validation/test_validator'
+
+describe Definitions::Validation::Test do
+  subject { described_class.new }
+
+  context 'success' do
+    it 'returns true if single valid test' do
+      tests = [{ "given" => { "date" => "2016-01-01", "regions" => ['us'] }, "expect" => { "name" => "Test Holiday" } } ]
+      expect(subject.call(tests)).to be true
+    end
+
+    it 'returns true if multiple valid tests' do
+      tests = [
+        { "given" => { "date" => "2016-01-01", "regions" => ['us'] }, "expect" => { "name" => "Test Holiday" } },
+        { "given" => { "date" => "2016-02-02", "regions" => ['us'] }, "expect" => { "name" => "Test 2" } }
+      ]
+
+      expect(subject.call(tests)).to be true
+    end
+
+    it 'returns true if single test has informal option' do
+      tests = [{ "given" => { "date" => "2016-01-01", "regions" => ['us'], "options" => "informal" }, "expect" => { "name" => "Test Holiday" } } ]
+      expect(subject.call(tests)).to be true
+    end
+
+    it 'returns true if single test has single valid option' do
+      tests = [{ "given" => { "date" => "2016-01-01", "regions" => ['us'], "options" => "observed" }, "expect" => { "name" => "Test Holiday" } } ]
+      expect(subject.call(tests)).to be true
+    end
+
+    it 'returns true if single test has multiple valid options' do
+      tests = [{ "given" => { "date" => "2016-01-01", "regions" => ['us'], "options" => ["informal", "observed"] }, "expect" => { "name" => "Test Holiday" } } ]
+      expect(subject.call(tests)).to be true
+    end
+
+    it 'returns true if regions is an array' do
+      tests = [{ "given" => { "date" => "2016-01-01", "regions" => ['us', 'us_dc']}, "expect" => { "name" => "Test Holiday" } } ]
+      expect(subject.call(tests)).to be true
+    end
+
+    it 'returns true if dates are an array and all are valid dates' do
+      tests = [{ "given" => { "date" => ["2016-01-01", "2016-01-02", "2017-01-02"], "regions" => ['us', 'us_dc']}, "expect" => { "name" => "Test Holiday" } } ]
+      expect(subject.call(tests)).to be true
+    end
+  end
+
+  context 'failure' do
+    it 'raises error if tests are nil' do
+      expect { subject.call(nil) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+        expect(e.message).to eq "Tests cannot be nil"
+      }
+    end
+
+    it 'raises error if tests are empty array' do
+      expect { subject.call([]) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+        expect(e.message).to eq "Tests cannot be empty. They are too important to leave out!"
+      }
+    end
+
+    it 'raises error if tests are not an array' do
+      expect { subject.call("blah") }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+        expect(e.message).to eq "Tests must be an array"
+      }
+    end
+
+    context 'single test' do
+      let(:tests)  {
+        [
+          {
+            "given" => {
+              "date" => "2016-01-01",
+              "regions" => ['us', 'us_dc']
+            },
+            "expect" => { "name" => "Test Holiday" }
+          }
+        ]
+      }
+
+      context 'given' do
+        it 'raises error if no given value' do
+          tests.first.delete("given")
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test must contain given key"
+          }
+        end
+
+        it 'raises error if nil regions' do
+          tests.first["given"]["regions"] = nil
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test contains invalid regions (must be an array of strings)"
+          }
+        end
+
+        it 'raises error if empty regions' do
+          tests.first["given"]["regions"] = []
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test must contain at least one region"
+          }
+        end
+
+        it 'raises error if regions not an array' do
+          tests.first["given"]["regions"] = "invalid"
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test contains invalid regions (must be an array of strings)"
+          }
+        end
+
+        it 'raises error if regions is array of empty strings' do
+          tests.first["given"]["regions"] = [""]
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test cannot contain empty regions"
+          }
+        end
+
+        it 'raises error if single invalid option' do
+          tests.first["given"]["options"] = "blah"
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test contains invalid option(s)"
+          }
+        end
+
+        it 'raises error if array of options with single invalid' do
+          tests.first["given"]["options"] = ["informal", "blah"]
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test contains invalid option(s)"
+          }
+        end
+
+        it 'raises error if no date or year range keys' do
+          tests.first["given"].delete("date")
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test must contain some date"
+          }
+        end
+
+        it 'raises error if nil date' do
+          tests.first["given"]["date"] = nil
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test must contain valid date"
+          }
+        end
+
+        it 'raises error if invalid date' do
+          tests.first["given"]["date"] = "blah"
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test must contain valid date"
+          }
+        end
+      end
+
+      context 'expect' do
+        it 'raises error if expect key is not present' do
+          tests.first.delete("expect")
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include "Test must contain expect key"
+          }
+        end
+
+        it 'raises error if holiday flag value not valid' do
+          tests.first["expect"]["holiday"] = "blah"
+          expect { subject.call(tests) }.to raise_error(Definitions::Errors::InvalidTest) { |e|
+            expect(e.message).to include"Test contains invalid holiday value (must be true/false)"
+          }
+        end
+      end
+    end
+  end
+end