sensu-settings 0.0.7 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 690063711717849124c05c9309e8de85ff2acb18
-  data.tar.gz: d428097e014e10a55908740b4e674845ca3f629c
+  metadata.gz: ef6d260f3a69448e3a303ce08ce763250d7b7d19
+  data.tar.gz: 014d25fbb63da7810ca2ad80172d9712e6912906
 SHA512:
-  metadata.gz: bd127578469e2dfd40ba961e7a5424ac4d226fab9de7fe5648675070817a4929f400ff3edf9735543827ae665732e18c350c09cd6fe8a40ea2331618213090a9
-  data.tar.gz: eb0d64cedec2802613cc59b9f7d00146f83b0904c03b830c51c230e385974baa157118a8c069328bf7554fddbe73ccef9407b9a36f9abd015e3fa3b4d25d6b6c
+  metadata.gz: 500751d2e63b018ae29ac8d93fc1dfe2452df2175271a48e50a98c65eb2d236fe1a0946aa79520f17b1780bd18e6da3eb664e8a894562c5928ec68a986026961
+  data.tar.gz: 57bc19aa368477c6dd317538fdefb12ad67ab4818bb7cd7832e838c46e2f0f35356e8b913474b8b83ac9edb5211b3f3eaf1608bb68ea5f38b309b6dc34325b8d

data/lib/sensu/settings/rules.rb

@@ -89,7 +89,7 @@ module Sensu
       # @param value [Object] to check if matches pattern.
       # @return [TrueClass, FalseClass]
       def must_match_regex(regex, value)
-        value =~ regex
+        (value =~ regex) == 0
       end
 
       # Check if a value is boolean, if set (no nil).

data/sensu-settings.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name          = "sensu-settings"
-  spec.version       = "0.0.7"
+  spec.version       = "1.0.0"
   spec.authors       = ["Sean Porter"]
   spec.email         = ["portertech@gmail.com"]
   spec.summary       = "The Sensu settings library, loader and validator"

data/spec/loader_spec.rb

@@ -12,37 +12,37 @@ describe "Sensu::Settings::Loader" do
   end
 
   it "can provide a loader API" do
-    @loader.should respond_to(:load_env, :load_file, :load_directory, :set_env!, :validate)
+    expect(@loader).to respond_to(:load_env, :load_file, :load_directory, :set_env!, :validate)
   end
 
   it "can provide indifferent access to settings" do
-    @loader[:checks].should be_kind_of(Hash)
-    @loader["checks"].should be_kind_of(Hash)
+    expect(@loader[:checks]).to be_kind_of(Hash)
+    expect(@loader["checks"]).to be_kind_of(Hash)
   end
 
   it "can validate loaded settings" do
     failures = @loader.validate
-    failures.size.should eq(0)
+    expect(failures.size).to eq(0)
   end
 
   it "can load RabbitMQ settings from the environment" do
     ENV["RABBITMQ_URL"] = "amqp://guest:guest@localhost:5672/"
     @loader.load_env
-    @loader.warnings.size.should eq(1)
+    expect(@loader.warnings.size).to eq(1)
     ENV["RABBITMQ_URL"] = nil
   end
 
   it "can load Redis settings from the environment" do
     ENV["REDIS_URL"] = "redis://username:password@localhost:6789"
     @loader.load_env
-    @loader.warnings.size.should eq(1)
+    expect(@loader.warnings.size).to eq(1)
     ENV["REDIS_URL"] = nil
   end
 
   it "can load Sensu API settings from the environment" do
     ENV["API_PORT"] = "4567"
     @loader.load_env
-    @loader.warnings.size.should eq(1)
+    expect(@loader.warnings.size).to eq(1)
     ENV["API_PORT"] = nil
   end
 
@@ -50,19 +50,19 @@ describe "Sensu::Settings::Loader" do
     ENV["REDISTOGO_URL"] = "redis://username:password@localhost:6789"
     ENV["PORT"] = "4567"
     @loader.load_env
-    @loader.warnings.size.should eq(2)
+    expect(@loader.warnings.size).to eq(2)
     ENV["REDISTOGO_URL"] = nil
     ENV["PORT"] = nil
   end
 
   it "can load settings from a file" do
     @loader.load_file(@config_file)
-    @loader.warnings.size.should eq(1)
+    expect(@loader.warnings.size).to eq(1)
     warning = @loader.warnings.first
-    warning[:file].should eq(File.expand_path(@config_file))
-    warning[:message].should eq("loading config file")
-    @loader[:api][:port].should eq(4567)
-    @loader["api"]["port"].should eq(4567)
+    expect(warning[:file]).to eq(File.expand_path(@config_file))
+    expect(warning[:message]).to eq("loading config file")
+    expect(@loader[:api][:port]).to eq(4567)
+    expect(@loader["api"]["port"]).to eq(4567)
   end
 
   it "can load settings from a file and validate them" do
@@ -71,99 +71,99 @@ describe "Sensu::Settings::Loader" do
     reasons = failures.map do |failure|
       failure[:message]
     end
-    reasons.should include("check interval must be an integer")
+    expect(reasons).to include("check interval must be an integer")
   end
 
   it "can attempt to load settings from a nonexistent file" do
     @loader.load_file("/tmp/bananaphone")
     warnings = @loader.warnings
-    warnings.size.should eq(2)
+    expect(warnings.size).to eq(2)
     messages = warnings.map do |warning|
       warning[:message]
     end
-    messages.should include("config file does not exist or is not readable")
-    messages.should include("ignoring config file")
+    expect(messages).to include("config file does not exist or is not readable")
+    expect(messages).to include("ignoring config file")
   end
 
   it "can attempt to load settings from a file with invalid JSON" do
     @loader.load_file(File.join(@assets_dir, "invalid.json"))
     warnings = @loader.warnings
-    warnings.size.should eq(3)
+    expect(warnings.size).to eq(3)
     messages = warnings.map do |warning|
       warning[:message]
     end
-    messages.should include("loading config file")
-    messages.should include("config file must be valid json")
-    messages.should include("ignoring config file")
+    expect(messages).to include("loading config file")
+    expect(messages).to include("config file must be valid json")
+    expect(messages).to include("ignoring config file")
   end
 
   it "can load settings from files in a directory" do
     @loader.load_directory(@config_dir)
     warnings = @loader.warnings
-    warnings.size.should eq(4)
+    expect(warnings.size).to eq(4)
     messages = warnings.map do |warning|
       warning[:message]
     end
-    messages.should include("loading config files from directory")
-    messages.should include("loading config file")
-    messages.should include("config file applied changes")
-    @loader[:checks][:nested][:command].should eq("true")
+    expect(messages).to include("loading config files from directory")
+    expect(messages).to include("loading config file")
+    expect(messages).to include("config file applied changes")
+    expect(@loader[:checks][:nested][:command]).to eq("true")
   end
 
   it "can attempt to load settings from files in a nonexistent directory" do
     @loader.load_directory("/tmp/rottentomatos")
-    @loader.warnings.size.should eq(1)
+    expect(@loader.warnings.size).to eq(1)
     warning = @loader.warnings.first
-    warning[:message].should eq("loading config files from directory")
+    expect(warning[:message]).to eq("loading config files from directory")
   end
 
   it "can set environment variables for child processes" do
     @loader.load_file(@config_file)
     @loader.load_directory(@config_dir)
-    @loader.loaded_files.size.should eq(3)
+    expect(@loader.loaded_files.size).to eq(3)
     @loader.set_env!
-    ENV["SENSU_CONFIG_FILES"].split(":").should eq(@loader.loaded_files)
+    expect(ENV["SENSU_CONFIG_FILES"].split(":")).to eq(@loader.loaded_files)
   end
 
   it "can load settings and determine if certain definitions exist" do
     @loader.load_file(@config_file)
     @loader.load_directory(@config_dir)
-    @loader.check_exists?("nonexistent").should be_false
-    @loader.check_exists?("tokens").should be_true
-    @loader.filter_exists?("nonexistent").should be_false
-    @loader.filter_exists?("development").should be_true
-    @loader.mutator_exists?("nonexistent").should be_false
-    @loader.mutator_exists?("noop").should be_true
-    @loader.handler_exists?("nonexistent").should be_false
-    @loader.handler_exists?("default").should be_true
+    expect(@loader.check_exists?("nonexistent")).to be(false)
+    expect(@loader.check_exists?("tokens")).to be(true)
+    expect(@loader.filter_exists?("nonexistent")).to be(false)
+    expect(@loader.filter_exists?("development")).to be(true)
+    expect(@loader.mutator_exists?("nonexistent")).to be(false)
+    expect(@loader.mutator_exists?("noop")).to be(true)
+    expect(@loader.handler_exists?("nonexistent")).to be(false)
+    expect(@loader.handler_exists?("default")).to be(true)
   end
 
   it "can load settings and provide setting category accessors" do
     @loader.load_file(@config_file)
     @loader.load_directory(@config_dir)
-    @loader.checks.should be_kind_of(Array)
-    @loader.checks.should_not be_empty
+    expect(@loader.checks).to be_kind_of(Array)
+    expect(@loader.checks).to_not be_empty
     check = @loader.checks.detect do |check|
       check[:name] == "tokens"
     end
-    check[:interval].should eq(1)
-    @loader.filters.should be_kind_of(Array)
-    @loader.filters.should_not be_empty
+    expect(check[:interval]).to eq(1)
+    expect(@loader.filters).to be_kind_of(Array)
+    expect(@loader.filters).to_not be_empty
     filter = @loader.filters.detect do |filter|
       filter[:name] == "development"
     end
-    filter[:negate].should be_true
-    @loader.mutators.should be_kind_of(Array)
-    @loader.mutators.should_not be_empty
+    expect(filter[:negate]).to be(true)
+    expect(@loader.mutators).to be_kind_of(Array)
+    expect(@loader.mutators).to_not be_empty
     mutator = @loader.mutators.detect do |mutator|
       mutator[:name] == "noop"
     end
-    mutator[:command].should eq("cat")
-    @loader.handlers.should be_kind_of(Array)
-    @loader.handlers.should_not be_empty
+    expect(mutator[:command]).to eq("cat")
+    expect(@loader.handlers).to be_kind_of(Array)
+    expect(@loader.handlers).to_not be_empty
     handler = @loader.handlers.detect do |handler|
       handler[:name] == "default"
     end
-    handler[:type].should eq("set")
+    expect(handler[:type]).to eq("set")
   end
 end

data/spec/rules_spec.rb

@@ -6,60 +6,61 @@ describe "Sensu::Settings::Rules" do
   include Sensu::Settings::Rules
 
   it "can provide validation rules" do
-    must_be_a_hash({}).should be_true
-    must_be_a_hash("").should be_false
-    must_be_a_hash_if_set({}).should be_true
-    must_be_a_hash_if_set(nil).should be_true
-    must_be_a_hash_if_set("").should be_false
-    must_be_an_array([]).should be_true
-    must_be_an_array("").should be_false
-    must_be_an_array_if_set([]).should be_true
-    must_be_an_array_if_set(nil).should be_true
-    must_be_an_array_if_set("").should be_false
-    must_be_a_string("").should be_true
-    must_be_a_string(1).should be_false
-    must_be_a_string_if_set("").should be_true
-    must_be_a_string_if_set(nil).should be_true
-    must_be_a_string_if_set(1).should be_false
-    must_be_an_integer(1).should be_true
-    must_be_an_integer("").should be_false
-    must_be_a_numeric(1.5).should be_true
-    must_be_a_numeric("").should be_false
-    must_match_regex(/^foo$/, "foo").should be_true
-    must_match_regex(/^foo$/, "bar").should be_false
-    must_be_boolean_if_set(true).should be_true
-    must_be_boolean_if_set(false).should be_true
-    must_be_boolean_if_set(nil).should be_true
-    must_be_boolean_if_set("").should be_false
-    items_must_be_strings([]).should be_true
-    items_must_be_strings(["test"]).should be_true
-    items_must_be_strings([1]).should be_false
-    items_must_be_strings([""]).should be_false
-    either_are_set?(1).should be_true
-    either_are_set?(1, nil).should be_true
-    either_are_set?(nil, nil, 1).should be_true
-    either_are_set?(1, 1).should be_true
-    either_are_set?.should be_false
-    either_are_set?(nil).should be_false
-    either_are_set?(nil, nil).should be_false
-    must_be_time("16:30").should be_true
-    must_be_time("16:30", "21:00").should be_true
-    must_be_time(false).should be_false
-    must_be_time(false, "21:00").should be_false
+    expect(must_be_a_hash({})).to be(true)
+    expect(must_be_a_hash("")).to be(false)
+    expect(must_be_a_hash_if_set({})).to be(true)
+    expect(must_be_a_hash_if_set(nil)).to be(true)
+    expect(must_be_a_hash_if_set("")).to be(false)
+    expect(must_be_an_array([])).to be(true)
+    expect(must_be_an_array("")).to be(false)
+    expect(must_be_an_array_if_set([])).to be(true)
+    expect(must_be_an_array_if_set(nil)).to be(true)
+    expect(must_be_an_array_if_set("")).to be(false)
+    expect(must_be_a_string("")).to be(true)
+    expect(must_be_a_string(1)).to be(false)
+    expect(must_be_a_string_if_set("")).to be(true)
+    expect(must_be_a_string_if_set(nil)).to be(true)
+    expect(must_be_a_string_if_set(1)).to be(false)
+    expect(must_be_an_integer(1)).to be(true)
+    expect(must_be_an_integer("")).to be(false)
+    expect(must_be_a_numeric(1.5)).to be(true)
+    expect(must_be_a_numeric("")).to be(false)
+    expect(must_match_regex(/^foo$/, "foo")).to be(true)
+    expect(must_match_regex(/^foo$/, "bar")).to be(false)
+    expect(must_match_regex(/^\w+$/, "baz$")).to be(false)
+    expect(must_be_boolean_if_set(true)).to be(true)
+    expect(must_be_boolean_if_set(false)).to be(true)
+    expect(must_be_boolean_if_set(nil)).to be(true)
+    expect(must_be_boolean_if_set("")).to be(false)
+    expect(items_must_be_strings([])).to be(true)
+    expect(items_must_be_strings(["test"])).to be(true)
+    expect(items_must_be_strings([1])).to be(false)
+    expect(items_must_be_strings([""])).to be(false)
+    expect(either_are_set?(1)).to be(true)
+    expect(either_are_set?(1, nil)).to be(true)
+    expect(either_are_set?(nil, nil, 1)).to be(true)
+    expect(either_are_set?(1, 1)).to be(true)
+    expect(either_are_set?).to be(false)
+    expect(either_are_set?(nil)).to be(false)
+    expect(either_are_set?(nil, nil)).to be(false)
+    expect(must_be_time("16:30")).to be(true)
+    expect(must_be_time("16:30", "21:00")).to be(true)
+    expect(must_be_time(false)).to be(false)
+    expect(must_be_time(false, "21:00")).to be(false)
     unless RUBY_VERSION < "1.9"
-      must_be_time("false").should be_false
-      must_be_time("false", "21:00").should be_false
+      expect(must_be_time("false")).to be(false)
+      expect(must_be_time("false", "21:00")).to be(false)
     end
-    must_be_time(1).should be_false
-    must_be_either(%w[foo bar], "foo").should be_true
-    must_be_either(%w[foo bar], "bar").should be_true
-    must_be_either(%w[foo bar], ["foo", "bar"]).should be_true
-    must_be_either(%w[foo bar], "baz").should be_false
-    must_be_either(%w[foo bar], 1).should be_false
-    must_be_either(%w[foo bar], nil).should be_false
-    must_be_either(%w[foo bar], ["foo", nil]).should be_false
-    must_be_either_if_set(%w[foo bar], "foo").should be_true
-    must_be_either_if_set(%w[foo bar], nil).should be_true
-    must_be_either_if_set(%w[foo bar], "baz").should be_false
+    expect(must_be_time(1)).to be(false)
+    expect(must_be_either(%w[foo bar], "foo")).to be(true)
+    expect(must_be_either(%w[foo bar], "bar")).to be(true)
+    expect(must_be_either(%w[foo bar], ["foo", "bar"])).to be(true)
+    expect(must_be_either(%w[foo bar], "baz")).to be(false)
+    expect(must_be_either(%w[foo bar], 1)).to be(false)
+    expect(must_be_either(%w[foo bar], nil)).to be(false)
+    expect(must_be_either(%w[foo bar], ["foo", nil])).to be(false)
+    expect(must_be_either_if_set(%w[foo bar], "foo")).to be(true)
+    expect(must_be_either_if_set(%w[foo bar], nil)).to be(true)
+    expect(must_be_either_if_set(%w[foo bar], "baz")).to be(false)
   end
 end

data/spec/settings_spec.rb

@@ -12,39 +12,39 @@ describe "Sensu::Settings" do
   end
 
   it "can provide a loader" do
-    Sensu::Settings.should respond_to(:load)
-    Sensu::Settings.load.should be_an_instance_of(Sensu::Settings::Loader)
+    expect(Sensu::Settings).to respond_to(:load)
+    expect(Sensu::Settings.load).to be_an_instance_of(Sensu::Settings::Loader)
     settings = Sensu::Settings.load
-    settings.should respond_to(:validate)
+    expect(settings).to respond_to(:validate)
   end
 
   it "can retrive the current loaded loader" do
     settings = Sensu::Settings.load
-    Sensu::Settings.get.should eq(settings)
-    Sensu::Settings.get.should eq(settings)
+    expect(Sensu::Settings.get).to eq(settings)
+    expect(Sensu::Settings.get).to eq(settings)
   end
 
   it "can load up a loader if one doesn't exist" do
     settings = Sensu::Settings.get
-    settings.should be_an_instance_of(Sensu::Settings::Loader)
-    Sensu::Settings.get.should eq(settings)
+    expect(settings).to be_an_instance_of(Sensu::Settings::Loader)
+    expect(Sensu::Settings.get).to eq(settings)
   end
 
   it "can load settings from the environment, a file, and a directory" do
     ENV["RABBITMQ_URL"] = "amqp://guest:guest@localhost:5672/"
     settings = Sensu::Settings.load(:config_file => @config_file, :config_dir => @config_dir)
-    settings[:rabbitmq].should eq(ENV["RABBITMQ_URL"])
-    settings[:api][:port].should eq(4567)
-    settings[:checks][:merger][:command].should eq("echo -n merger")
-    settings[:checks][:merger][:subscribers].should eq(["foo", "bar"])
-    settings[:checks][:nested][:command].should eq("true")
-    ENV["SENSU_CONFIG_FILES"].split(":").should eq(settings.loaded_files)
+    expect(settings[:rabbitmq]).to eq(ENV["RABBITMQ_URL"])
+    expect(settings[:api][:port]).to eq(4567)
+    expect(settings[:checks][:merger][:command]).to eq("echo -n merger")
+    expect(settings[:checks][:merger][:subscribers]).to eq(["foo", "bar"])
+    expect(settings[:checks][:nested][:command]).to eq("true")
+    expect(ENV["SENSU_CONFIG_FILES"].split(":")).to eq(settings.loaded_files)
     ENV["RABBITMQ_URL"] = nil
   end
 
   it "can load settings from files in multiple directories" do
     settings = Sensu::Settings.load(:config_dirs => [@config_dir, @app_dir])
-    settings[:checks][:merger][:command].should eq("echo -n merger")
-    settings[:checks][:app_http_endpoint][:command].should eq("check-http.rb -u https://localhost/ping -q pong")
+    expect(settings[:checks][:merger][:command]).to eq("echo -n merger")
+    expect(settings[:checks][:app_http_endpoint][:command]).to eq("check-http.rb -u https://localhost/ping -q pong")
   end
 end

data/spec/validator_spec.rb

@@ -10,33 +10,33 @@ describe "Sensu::Settings::Validator" do
 
   it "can run, validating setting categories" do
     failures = @validator.run({})
-    failures.should be_kind_of(Array)
+    expect(failures).to be_kind_of(Array)
     failures.each do |failure|
-      failure[:object].should be_nil
+      expect(failure[:object]).to be(nil)
     end
     reasons = failures.map do |failure|
       failure[:message]
     end
-    reasons.should include("checks must be a hash")
-    reasons.should include("filters must be a hash")
-    reasons.should include("mutators must be a hash")
-    reasons.should include("handlers must be a hash")
-    reasons.size.should eq(5)
+    expect(reasons).to include("checks must be a hash")
+    expect(reasons).to include("filters must be a hash")
+    expect(reasons).to include("mutators must be a hash")
+    expect(reasons).to include("handlers must be a hash")
+    expect(reasons.size).to eq(5)
   end
 
   it "can validate a transport definition" do
     transport = nil
     @validator.validate_transport(transport)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     transport = {}
     @validator.validate_transport(transport)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     transport[:name] = 1
     @validator.validate_transport(transport)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     transport[:name] = "rabbitmq"
     @validator.validate_transport(transport)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can run, validating transport" do
@@ -46,10 +46,10 @@ describe "Sensu::Settings::Validator" do
       }
     }
     @validator.run(settings)
-    @validator.reset.should eq(5)
+    expect(@validator.reset).to eq(5)
     settings[:transport][:name] = "rabbitmq"
     @validator.run(settings)
-    @validator.reset.should eq(4)
+    expect(@validator.reset).to eq(4)
   end
 
   it "can validate an empty check definition" do
@@ -57,90 +57,90 @@ describe "Sensu::Settings::Validator" do
     reasons = @validator.failures.map do |failure|
       failure[:message]
     end
-    reasons.should include("check name must be a string")
-    reasons.should include("check name cannot contain spaces or special characters")
-    reasons.should include("check command must be a string")
-    reasons.should include("check interval must be an integer")
-    reasons.should include("check subscribers must be an array")
-    reasons.size.should eq(5)
+    expect(reasons).to include("check name must be a string")
+    expect(reasons).to include("check name cannot contain spaces or special characters")
+    expect(reasons).to include("check command must be a string")
+    expect(reasons).to include("check interval must be an integer")
+    expect(reasons).to include("check subscribers must be an array")
+    expect(reasons.size).to eq(5)
   end
 
   it "can validate a check definition" do
     check = {:name => "foo bar"}
     @validator.validate_check(check)
-    @validator.reset.should eq(4)
+    expect(@validator.reset).to eq(4)
     check[:name] = "foo"
     @validator.validate_check(check)
-    @validator.reset.should eq(3)
+    expect(@validator.reset).to eq(3)
     check[:command] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(3)
+    expect(@validator.reset).to eq(3)
     check[:command] = "true"
     @validator.validate_check(check)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     check[:timeout] = "foo"
     @validator.validate_check(check)
-    @validator.reset.should eq(3)
+    expect(@validator.reset).to eq(3)
     check[:timeout] = 1.5
     @validator.validate_check(check)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     check[:timeout] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     check[:publish] = "false"
     @validator.validate_check(check)
-    @validator.reset.should eq(3)
+    expect(@validator.reset).to eq(3)
     check[:publish] = false
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:publish] = true
     @validator.validate_check(check)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     check[:interval] = "1"
     @validator.validate_check(check)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     check[:interval] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subscribers] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subscribers] = [1]
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subscribers] = []
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:standalone] = "true"
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:standalone] = true
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:handler] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:handler] = "cat"
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:handlers] = "cat"
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:handlers] = ["cat"]
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:low_flap_threshold] = "25"
     @validator.validate_check(check)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     check[:low_flap_threshold] = 25
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:high_flap_threshold] = "55"
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:high_flap_threshold] = 55
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate check subdue" do
@@ -151,63 +151,63 @@ describe "Sensu::Settings::Validator" do
       :standalone => true
     }
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:subdue] = true
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue] = {
       :at => "unknown"
     }
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:at] = "publisher"
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:subdue][:at] = "handler"
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:subdue][:begin] = "14:30"
     check[:subdue][:end] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:begin] = 1
     check[:subdue][:end] = "14:30"
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:begin] = "14:30"
     check[:subdue][:end] = "16:30"
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:subdue][:days] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:days] = ["unknown"]
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:days] = [true]
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:days] = ["monday"]
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:subdue][:exceptions] = 1
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:exceptions] = []
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:subdue][:exceptions] = [1]
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:exceptions] = [{}]
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     check[:subdue][:exceptions] = [{:begin => "15:00"}]
     @validator.validate_check(check)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     check[:subdue][:exceptions] = [{:begin => "15:00", :end => "15:30"}]
     @validator.validate_check(check)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can run, validating checks" do
@@ -220,118 +220,118 @@ describe "Sensu::Settings::Validator" do
       }
     }
     @validator.run(settings)
-    @validator.reset.should eq(5)
+    expect(@validator.reset).to eq(5)
     settings[:checks][:foo][:interval] = 1
     @validator.run(settings)
-    @validator.reset.should eq(4)
+    expect(@validator.reset).to eq(4)
   end
 
   it "can validate a filter definition" do
     filter = {}
     @validator.validate_filter(filter)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     filter[:attributes] = 1
     @validator.validate_filter(filter)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     filter[:attributes] = {}
     @validator.validate_filter(filter)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     filter[:negate] = "true"
     @validator.validate_filter(filter)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     filter[:negate] = true
     @validator.validate_filter(filter)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate a mutator definition" do
     mutator = {}
     @validator.validate_mutator(mutator)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     mutator[:command] = "cat"
     @validator.validate_mutator(mutator)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     mutator[:timeout] = "foo"
     @validator.validate_mutator(mutator)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     mutator[:timeout] = 1.5
     @validator.validate_mutator(mutator)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     mutator[:timeout] = 1
     @validator.validate_mutator(mutator)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate a handler definition" do
     handler = {}
     @validator.validate_handler(handler)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     handler[:type] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     handler[:type] = "unknown"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:type] = "pipe"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:command] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:command] = "cat"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:timeout] = "foo"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:timeout] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:mutator] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:mutator] = "foo"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:handle_flapping] = "true"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:handle_flapping] = true
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:handle_flapping] = false
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:filter] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:filter] = "foo"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:filters] = "foo"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:filters] = []
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:filters] = [1]
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:filters] = ["foo"]
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:severities] = "foo"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:severities] = []
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:severities] = ["foo"]
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:severities] = ["warning", "unknown"]
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate a tcp/udp handler definition" do
@@ -339,22 +339,22 @@ describe "Sensu::Settings::Validator" do
       :type => "tcp"
     }
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:socket] = {}
     @validator.validate_handler(handler)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     handler[:socket][:host] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     handler[:socket][:host] = "127.0.0.1"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:socket][:port] = "foo"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:socket][:port] = 2003
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate a transport handler definition" do
@@ -362,34 +362,34 @@ describe "Sensu::Settings::Validator" do
       :type => "transport"
     }
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:pipe] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:pipe] = {}
     @validator.validate_handler(handler)
-    @validator.reset.should eq(3)
+    expect(@validator.reset).to eq(3)
     handler[:pipe][:type] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(3)
+    expect(@validator.reset).to eq(3)
     handler[:pipe][:type] = "unknown"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     handler[:pipe][:type] = "direct"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:pipe][:name] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:pipe][:name] = "foo"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:pipe][:options] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:pipe][:options] = {}
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate a handler set definition" do
@@ -397,19 +397,19 @@ describe "Sensu::Settings::Validator" do
       :type => "set"
     }
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:handlers] = 1
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:handlers] = "default"
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:handlers] = [1]
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:handlers] = ["default"]
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate handler subdue" do
@@ -419,71 +419,71 @@ describe "Sensu::Settings::Validator" do
       :command => "cat"
     }
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     handler[:subdue] = true
     @validator.validate_handler(handler)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     handler[:subdue] = {
       :at => "handler",
       :begin => "14:30",
       :end => "15:45"
     }
     @validator.validate_handler(handler)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate a client definition" do
     client = true
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client = {}
     @validator.validate_client(client)
-    @validator.reset.should eq(4)
+    expect(@validator.reset).to eq(4)
     client[:name] = 1
     @validator.validate_client(client)
-    @validator.reset.should eq(4)
+    expect(@validator.reset).to eq(4)
     client[:name] = "foo bar"
     @validator.validate_client(client)
-    @validator.reset.should eq(3)
+    expect(@validator.reset).to eq(3)
     client[:name] = "foo"
     @validator.validate_client(client)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     client[:address] = 1
     @validator.validate_client(client)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     client[:address] = "127.0.0.1"
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:subscriptions] = true
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:subscriptions] = []
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:subscriptions] = [1]
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:subscriptions] = ["bar"]
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:redact] = true
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:redact] = []
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:redact] = [1]
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:redact] = ["secret"]
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:safe_mode] = 1
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:safe_mode] = false
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate client socket" do
@@ -493,25 +493,25 @@ describe "Sensu::Settings::Validator" do
       :subscriptions => ["bar"]
     }
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:socket] = true
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:socket] = {}
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:socket][:bind] = true
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:socket][:bind] = "127.0.0.1"
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:socket][:port] = "2012"
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:socket][:port] = 2012
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can validate client keepalive" do
@@ -521,46 +521,46 @@ describe "Sensu::Settings::Validator" do
       :subscriptions => ["bar"]
     }
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:keepalive] = true
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:keepalive] = {}
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:keepalive][:handler] = 1
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:keepalive][:handler] = "foo"
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:keepalive][:handlers] = 1
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:keepalive][:handlers] = [1]
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:keepalive][:handlers] = ["foo"]
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:keepalive][:thresholds] = true
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:keepalive][:thresholds] = {}
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:keepalive][:thresholds][:warning] = "60"
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:keepalive][:thresholds][:warning] = 60
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     client[:keepalive][:thresholds][:critical] = "90"
     @validator.validate_client(client)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     client[:keepalive][:thresholds][:critical] = 90
     @validator.validate_client(client)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can run, validating client" do
@@ -571,43 +571,43 @@ describe "Sensu::Settings::Validator" do
       }
     }
     @validator.run(settings, "client")
-    @validator.reset.should eq(6)
+    expect(@validator.reset).to eq(6)
     settings[:client][:subscriptions] = ["bar"]
     @validator.run(settings, "client")
-    @validator.reset.should eq(5)
+    expect(@validator.reset).to eq(5)
   end
 
   it "can validate an api definition" do
     api = true
     @validator.validate_api(api)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     api = {}
     @validator.validate_api(api)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     api[:port] = true
     @validator.validate_api(api)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     api[:port] = 4567
     @validator.validate_api(api)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     api[:bind] = true
     @validator.validate_api(api)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     api[:bind] = "127.0.0.1"
     @validator.validate_api(api)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
     api[:user] = 1
     @validator.validate_api(api)
-    @validator.reset.should eq(2)
+    expect(@validator.reset).to eq(2)
     api[:user] = "foo"
     @validator.validate_api(api)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     api[:password] = 1
     @validator.validate_api(api)
-    @validator.reset.should eq(1)
+    expect(@validator.reset).to eq(1)
     api[:password] = "bar"
     @validator.validate_api(api)
-    @validator.reset.should eq(0)
+    expect(@validator.reset).to eq(0)
   end
 
   it "can run, validating api" do
@@ -617,9 +617,9 @@ describe "Sensu::Settings::Validator" do
       }
     }
     @validator.run(settings, "api")
-    @validator.reset.should eq(6)
+    expect(@validator.reset).to eq(6)
     settings[:api][:port] = 4567
     @validator.run(settings, "api")
-    @validator.reset.should eq(5)
+    expect(@validator.reset).to eq(5)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sensu-settings
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 1.0.0
 platform: ruby
 authors:
 - Sean Porter
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-28 00:00:00.000000000 Z
+date: 2014-06-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json