class Longleaf::ServiceMappingValidator

Validates application configuration of service to location mappings

Public Class Methods

new(config) click to toggle source

@param config [Hash] hash containing the application configuration

Calls superclass method Longleaf::ConfigurationValidator::new
# File lib/longleaf/services/service_mapping_validator.rb, line 13
def initialize(config)
  super(config)
end

Protected Instance Methods

validate() click to toggle source

Validates service mapping configuration to ensure that it is syntactically and referentially correct. @param config [Hash] hash containing the application configuration

# File lib/longleaf/services/service_mapping_validator.rb, line 20
def validate
  assert("Configuration must be a hash, but a #{@config.class} was provided", @config.class == Hash)
  assert("Configuration must contain a root '#{AF::SERVICE_MAPPINGS}' key", @config.key?(AF::SERVICE_MAPPINGS))
  mappings = @config[AF::SERVICE_MAPPINGS]
  return if mappings.nil? || mappings.empty?
  assert("'#{AF::SERVICE_MAPPINGS}' must be an array of mappings", mappings.is_a?(Array))

  service_names = @config[AF::SERVICES].keys
  location_names = @config[AF::LOCATIONS].keys

  mappings.each do |mapping|
    register_on_failure do
      assert("Mapping must be a hash, but received #{mapping.inspect} instead", mapping.is_a?(Hash))

      register_on_failure { validate_mapping_field(AF::LOCATIONS, mapping, location_names) }
      register_on_failure { validate_mapping_field(AF::SERVICES, mapping, service_names) }
    end
  end

  @result
end

Private Instance Methods

validate_mapping_field(field, mapping, valid_values) click to toggle source
# File lib/longleaf/services/service_mapping_validator.rb, line 43
def validate_mapping_field(field, mapping, valid_values)
  assert("Mapping must contain a '#{field}' field", mapping.key?(field))
  field_values = mapping[field]
  assert("Mapping '#{field}' field must be either a string or an array, but received '#{field_values.class}' instead",
      field_values.is_a?(Array) || field_values.is_a?(String))
  assert("Mapping must specify one or more value in the '#{field}' field", !field_values.empty?)

  check_values = field_values.is_a?(String) ? [field_values] : field_values
  check_values.each do |value|
    register_on_failure do
      assert("Mapping specifies value '#{value}', but no #{field} with that name exist",
          valid_values.include?(value))
    end
  end
end