respect-rails 0.1.0

data/test/unit/request_helper_test.rb

@@ -0,0 +1,67 @@
+require "test_helper"
+
+class RequestHelperTest < Test::Unit::TestCase
+  def test_successful_request_validation
+    request = Object.new
+    request.extend(Respect::Rails::RequestHelper)
+    schema = mock()
+    schema.stubs(:validate?).with(request).returns(true).once
+    request.stubs(:request_schema).with().returns(schema)
+    Benchmark.stubs(:realtime).with().yields().returns(1.2345) # 1234.5 seconds.
+    ::Rails.logger.stubs(:info).with("  Request validation: success (1234.5ms)").once
+    assert_nothing_raised do
+      request.validate_schema
+    end
+  end
+
+  def test_failed_request_validation
+    request = Object.new
+    request.extend(Respect::Rails::RequestHelper)
+    schema = mock()
+    schema.stubs(:validate?).with(request).returns(false).once
+    error = RuntimeError.new("test error")
+    error.stubs(:context).with().returns(["foo", "bar"])
+    schema.stubs(:last_error).with().returns(error)
+    request.stubs(:request_schema).with().returns(schema)
+    Benchmark.stubs(:realtime).with().yields().returns(1.2345) # 1234.5 seconds.
+    ::Rails.logger.stubs(:info).with("  Request validation: failure (1234.5ms)").once
+    ::Rails.logger.stubs(:info).with("    foo").once
+    ::Rails.logger.stubs(:info).with("    bar").once
+    begin
+      request.validate_schema
+      assert false, "nothing raised"
+    rescue RuntimeError => e
+      assert_equal error, e
+    end
+  end
+
+  def test_none_request_validation
+    request = Object.new
+    request.extend(Respect::Rails::RequestHelper)
+    request.stubs(:params).with().never
+    schema = mock()
+    schema.stubs(:validate!).never
+    request.stubs(:request_schema).with().returns(nil)
+    Benchmark.stubs(:realtime).with().yields().returns(1.2345) # 1234.5 seconds.
+    ::Rails.logger.stubs(:info).with("  Request validation: none (1234.5ms)").once
+    assert_nothing_raised do
+      request.validate_schema
+    end
+  end
+
+  def test_request_validation_schema_query_on_success
+    request = Object.new
+    request.extend(Respect::Rails::RequestHelper)
+    request.stubs(:validate_schema).returns(true)
+    assert_equal(true, request.validate_schema?)
+  end
+
+  def test_request_validation_schema_query_on_failure
+    error = mock()
+    error.stubs(:context).returns([])
+    request = Object.new
+    request.extend(Respect::Rails::RequestHelper)
+    request.stubs(:validate_schema).raises(Respect::Rails::RequestValidationError.new(error, :path, {}))
+    assert_equal(false, request.validate_schema?)
+  end
+end

data/test/unit/request_schema_test.rb

@@ -0,0 +1,164 @@
+require "test_helper"
+
+class RequestSchemaTest < Test::Unit::TestCase
+  def setup
+    @rs = Respect::Rails::RequestSchema.new("ctrl", "action")
+  end
+
+  def test_default_path_parameters
+    assert_equal "ctrl", @rs.default_path_parameters["controller"].options[:equal_to]
+    assert_equal false, @rs.default_path_parameters["controller"].doc
+    assert_equal "action", @rs.default_path_parameters["action"].options[:equal_to]
+    assert_equal false, @rs.default_path_parameters["action"].doc
+  end
+
+  def test_path_parameters_are_merged_with_default
+    params = Respect::HashSchema.new
+    result = Respect::HashSchema.new
+    @rs.default_path_parameters.stubs(:merge).with(params).returns(result).once
+    assert_not_equal result.object_id, @rs.path_parameters.object_id
+    assert_equal result.object_id, @rs.public_send(:path_parameters=, params).object_id
+    assert_equal result.object_id, @rs.path_parameters.object_id
+  end
+
+  def test_validate_all_parameters
+    Respect::Rails::Engine.stubs(:disable_request_headers_validation).returns(false)
+    request = mock()
+    headers = {}
+    request.stubs(:headers).with().returns(headers).at_least_once
+    @rs.headers.stubs(:validate).with(headers).once
+    params = {}
+    request.stubs(:params).with().returns(params).at_least_once
+    @rs.path_parameters.stubs(:validate).with(params).once
+    @rs.path_parameters.stubs(:sanitized_object).returns(params).once
+    @rs.query_parameters.stubs(:validate).with(params).once
+    @rs.query_parameters.stubs(:sanitized_object).returns(params).once
+    @rs.body_parameters.stubs(:validate).with(params).once
+    @rs.body_parameters.stubs(:sanitized_object).returns(params).once
+    assert_equal true, @rs.validate(request)
+  end
+
+  def test_validate_raise_request_validation_error_on_path_params_validation_error
+    Respect::Rails::Engine.stubs(:disable_request_headers_validation).returns(false)
+    request = mock()
+    headers = {}
+    request.stubs(:headers).with().returns(headers).at_least_once
+    params = {}
+    request.stubs(:params).with().returns(params).at_least_once
+    @rs.path_parameters.stubs(:validate).with(params).raises(Respect::ValidationError.new("error message")).once
+    @rs.query_parameters.stubs(:validate).with(params)
+    @rs.body_parameters.stubs(:validate).with(params)
+    begin
+      @rs.validate(request)
+      assert false, "nothing raised"
+    rescue Respect::Rails::RequestValidationError => e
+      assert e.error.is_a?(Respect::ValidationError)
+      assert_equal "error message; in path", e.message
+      assert e.part.path?
+      assert_equal params, e.object
+    end
+  end
+
+  def test_validate_raise_request_validation_error_on_query_params_validation_error
+    Respect::Rails::Engine.stubs(:disable_request_headers_validation).returns(false)
+    request = mock()
+    headers = {}
+    request.stubs(:headers).with().returns(headers).at_least_once
+    params = {}
+    request.stubs(:params).with().returns(params).at_least_once
+    @rs.path_parameters.stubs(:validate).with(params)
+    @rs.query_parameters.stubs(:validate).with(params).raises(Respect::ValidationError.new("error message")).once
+    @rs.body_parameters.stubs(:validate).with(params)
+    begin
+      @rs.validate(request)
+      assert false, "nothing raised"
+    rescue Respect::Rails::RequestValidationError => e
+      assert e.error.is_a?(Respect::ValidationError)
+      assert_equal "error message; in query", e.message
+      assert e.part.query?
+      assert_equal params, e.object
+    end
+  end
+
+  def test_validate_raise_request_validation_error_on_body_params_validation_error
+    Respect::Rails::Engine.stubs(:disable_request_headers_validation).returns(false)
+    request = mock()
+    headers = {}
+    request.stubs(:headers).with().returns(headers).at_least_once
+    params = {}
+    request.stubs(:params).with().returns(params).at_least_once
+    @rs.path_parameters.stubs(:validate).with(params)
+    @rs.query_parameters.stubs(:validate).with(params)
+    @rs.body_parameters.stubs(:validate).with(params).raises(Respect::ValidationError.new("error message")).once
+    begin
+      @rs.validate(request)
+      assert false, "nothing raised"
+    rescue Respect::Rails::RequestValidationError => e
+      assert e.error.is_a?(Respect::ValidationError)
+      assert_equal "error message; in body", e.message
+      assert e.part.body?
+      assert_equal params, e.object
+    end
+  end
+
+  def test_validate_raise_request_validation_error_on_headers_validation_error
+    Respect::Rails::Engine.stubs(:disable_request_headers_validation).returns(false)
+    request = mock()
+    headers = {}
+    request.stubs(:headers).with().returns(headers).at_least_once
+    @rs.headers.stubs(:validate).with(headers).raises(Respect::ValidationError.new("error message")).once
+    simplified_headers = {}
+    @rs.stubs(:simplify_headers).with(headers).returns(simplified_headers).once
+    params = {}
+    request.stubs(:params).with().returns(params)
+    @rs.path_parameters.stubs(:validate).with(params)
+    @rs.query_parameters.stubs(:validate).with(params)
+    @rs.body_parameters.stubs(:validate).with(params)
+    begin
+      @rs.validate(request)
+      assert false, "nothing raised"
+    rescue Respect::Rails::RequestValidationError => e
+      assert e.error.is_a?(Respect::ValidationError)
+      assert_equal "error message; in headers", e.message
+      assert e.part.headers?
+      assert_equal simplified_headers.object_id, e.object.object_id
+    end
+  end
+
+  def test_validate_query_returns_true_when_no_error
+    request = mock()
+    @rs.stubs(:validate).with(request).returns(nil)
+    assert_equal true, @rs.validate?(request)
+  end
+
+  def test_validate_query_returns_false_on_error_and_store_last_error
+    doc = {}
+    error = Respect::Rails::RequestValidationError.new(Respect::ValidationError.new("message"), :path, {})
+    @rs.stubs(:validate).with(doc).raises(error).once
+    assert_equal false, @rs.validate?(doc)
+    assert_equal error, @rs.last_error
+  end
+
+  def test_validate_shebang_returns_true_on_success_and_sanitize
+    request = mock()
+    @rs.stubs(:validate?).with(request).returns(true).once
+    @rs.stubs(:sanitize!).with(request).once
+    assert_equal true, @rs.validate!(request)
+  end
+
+  def test_validate_shebang_returns_false_on_failure
+    request = mock()
+    @rs.stubs(:validate?).with(request).returns(false).once
+    assert_equal false, @rs.validate!(request)
+  end
+
+  def test_sanitize_all_params
+    request = mock()
+    params = mock()
+    request.stubs(:params).with().returns(params).at_least_once
+    @rs.path_parameters.stubs(:sanitize_object!).with(params).once
+    @rs.query_parameters.stubs(:sanitize_object!).with(params).once
+    @rs.body_parameters.stubs(:sanitize_object!).with(params).once
+    @rs.sanitize!(request)
+  end
+end

data/test/unit/response_def_test.rb

@@ -0,0 +1,9 @@
+require "test_helper"
+
+class ResponseDefTest < ActiveSupport::TestCase
+  test "can use kernel method" do
+    Respect::Rails::ResponseDef.eval do
+      p
+    end
+  end
+end

data/test/unit/response_helper_test.rb

@@ -0,0 +1,73 @@
+require "test_helper"
+
+class ResponseHelperTest < Test::Unit::TestCase
+  def test_successful_response_validation
+    response = Object.new
+    response.extend(Respect::Rails::ResponseHelper)
+    body = ""
+    schema = mock()
+    response.stubs(:schema).with().returns(schema)
+    response.stubs(:content_type).with().returns(Mime::JSON)
+    schema.stubs(:validate?).with(response).returns(true).once
+    Benchmark.stubs(:realtime).with().yields().returns(1.2345) # 1234.5 seconds.
+    Rails.logger.stubs(:info).with("  Response validation: success (1234.5ms)").once
+    assert_nothing_raised do
+      response.validate_schema
+    end
+  end
+
+  def test_failed_response_validation
+    response = Object.new
+    response.extend(Respect::Rails::ResponseHelper)
+    body = ""
+    schema = mock()
+    response.stubs(:schema).with().returns(schema)
+    response.stubs(:content_type).with().returns(Mime::JSON)
+    schema.stubs(:validate?).with(response).returns(false).once
+    error = RuntimeError.new("test error")
+    error.stubs(:context).with().returns(["foo", "bar"])
+    schema.stubs(:last_error).with().returns(error)
+    Benchmark.stubs(:realtime).with().yields().returns(1.2345) # 1234.5 seconds.
+    Rails.logger.stubs(:info).with("  Response validation: failure (1234.5ms)").once
+    Rails.logger.stubs(:info).with("    foo").once
+    Rails.logger.stubs(:info).with("    bar").once
+    begin
+      response.validate_schema
+      assert false, "nothing raised"
+    rescue RuntimeError => e
+      assert_equal error, e
+    end
+  end
+
+  def test_none_response_validation
+    response = Object.new
+    response.extend(Respect::Rails::ResponseHelper)
+    body = ""
+    schema = mock()
+    response.stubs(:schema).with().returns(nil)
+    response.stubs(:body).with().never
+    response.stubs(:content_type).with().never
+    schema.stubs(:validate?).never
+    Benchmark.stubs(:realtime).with().yields().returns(1.2345) # 1234.5 seconds.
+    ::Rails.logger.stubs(:info).with("  Response validation: none (1234.5ms)").once
+    assert_nothing_raised do
+      response.validate_schema
+    end
+  end
+
+  def test_response_validation_schema_query_on_success
+    response = Object.new
+    response.extend(Respect::Rails::ResponseHelper)
+    response.stubs(:validate_schema).returns(true)
+    assert_equal(true, response.validate_schema?)
+  end
+
+  def test_response_validation_schema_query_on_failure
+    error = mock()
+    error.stubs(:context).returns([])
+    response = Object.new
+    response.extend(Respect::Rails::ResponseHelper)
+    response.stubs(:validate_schema).raises(Respect::Rails::ResponseValidationError.new(error, :body, {}))
+    assert_equal(false, response.validate_schema?)
+  end
+end

data/test/unit/response_schema_set_test.rb

@@ -0,0 +1,18 @@
+require "test_helper"
+
+class ResponseSchemaSetTest < Test::Unit::TestCase
+  def test_respond_to_object_method
+    assert_respond_to Respect::Rails::ResponseSchemaSet.new("automatic_validation", "response_schema_from_file"), :class
+  end
+
+  def test_normalize_status
+    assert_equal :ok, Respect::Rails::ResponseSchemaSet.symbolize_status(:ok)
+    assert_equal :ok, Respect::Rails::ResponseSchemaSet.symbolize_status("ok")
+    assert_equal :ok, Respect::Rails::ResponseSchemaSet.symbolize_status(200)
+    assert_equal :ok, Respect::Rails::ResponseSchemaSet.symbolize_status("200")
+    assert_equal :ok, Respect::Rails::ResponseSchemaSet.symbolize_status(200.5)
+    assert_raises(ArgumentError) do
+      Respect::Rails::ResponseSchemaSet.symbolize_status(Object.new)
+    end
+  end
+end

data/test/unit/response_schema_test.rb

@@ -0,0 +1,147 @@
+require "test_helper"
+
+class ResponseSchemaTest < Test::Unit::TestCase
+  def setup
+    @rs = Respect::Rails::ResponseSchema.new
+  end
+
+  def test_define_with_block
+    s = Respect::HashSchema.define do |s|
+      s.integer "result"
+    end
+    block_def = Proc.new do |r|
+      r.body do |s|
+        s.integer "result"
+      end
+    end
+    rs = Respect::Rails::ResponseSchema.define(:ok, &block_def)
+    assert_equal :ok, rs.status
+    assert_equal s, rs.body
+
+    rs = Respect::Rails::ResponseSchema.define(&block_def)
+    assert_equal :ok, rs.status
+    assert_equal s, rs.body
+  end
+
+  def test_duplicata_are_equal
+    s = Respect::Rails::ResponseSchema.new(:ok)
+    assert_equal s, s.dup
+  end
+
+  def test_differs_from_status
+    s1 = Respect::Rails::ResponseSchema.new(:ok)
+    s2 = Respect::Rails::ResponseSchema.new(:created)
+    assert(s1 != s2)
+  end
+
+  def test_differs_from_body
+    s1 = Respect::Rails::ResponseSchema.new
+    s1.body = Respect::IntegerSchema.new
+    s2 = Respect::Rails::ResponseSchema.new
+    s2.body = Respect::StringSchema.new
+    assert(s1 != s2)
+  end
+
+  def test_define_from_file
+    # Prepare mock file name and contents
+    filename = "/path/to/definition_file.rb"
+    file_content = <<-EOS.strip_heredoc
+      body do |s|
+        s.integer "result"
+      end
+      EOS
+    File.stubs(:read).with(filename).returns(file_content)
+    # Compute the expected response schema.
+    expected_response_schema = Respect::Rails::ResponseSchema.new
+    expected_response_schema.body = Respect::HashSchema.define do |s|
+      s.integer "result"
+    end
+    # Do the test.
+    rs = Respect::Rails::ResponseSchema.from_file(:ok, filename)
+    assert_equal expected_response_schema, rs
+  end
+
+  def test_validate_raise_response_validation_error_on_validation_error
+    response = mock()
+    headers = mock()
+    response.stubs(:headers).returns(headers)
+    headers_schema = Respect::HashSchema.new
+    @rs.stubs(:headers).returns(headers_schema)
+    headers_schema.stubs(:validate).with(headers).once
+
+    body = mock()
+    response.stubs(:body).returns(body)
+    body_schema = Respect::HashSchema.new
+    @rs.stubs(:body).returns(body_schema)
+    decoded_body = mock()
+    ActiveSupport::JSON.stubs(:decode).with(body).returns(decoded_body).once
+    body_schema.stubs(:validate).with(decoded_body).raises(Respect::ValidationError.new("message"))
+    assert_raises(Respect::Rails::ResponseValidationError) do
+      @rs.validate(response)
+    end
+  end
+
+  def test_validate_returns_true_on_success
+    response = mock()
+    headers = mock()
+    response.stubs(:headers).returns(headers)
+    headers_schema = Respect::HashSchema.new
+    @rs.stubs(:headers).returns(headers_schema)
+    headers_schema.stubs(:validate).with(headers).once
+    body = mock()
+    response.stubs(:body).returns(body)
+    body_schema = Respect::HashSchema.new
+    @rs.stubs(:body).returns(body_schema)
+    decoded_body = mock()
+    ActiveSupport::JSON.stubs(:decode).with(body).returns(decoded_body).once
+    body_schema.stubs(:validate).with(decoded_body).once
+    assert_equal true, @rs.validate(response)
+  end
+
+  def test_validate_query_returns_true_when_no_error
+    doc = {}
+    @rs.stubs(:validate).with(doc).returns(nil)
+    assert_equal true, @rs.validate?(doc)
+  end
+
+  def test_validate_query_returns_false_on_error_and_store_last_error
+    doc = {}
+    error = Respect::Rails::ResponseValidationError.new(Respect::ValidationError.new("message"), :body, {})
+    @rs.stubs(:validate).with(doc).raises(error).once
+    assert_equal false, @rs.validate?(doc)
+    assert_equal error, @rs.last_error
+  end
+
+  def test_symbolize_http_status
+    assert_equal :ok, Respect::Rails::ResponseSchema.symbolize_http_status(200)
+    assert_equal :internal_server_error, Respect::Rails::ResponseSchema.symbolize_http_status(0)
+    assert_equal :gateway_timeout, Respect::Rails::ResponseSchema.symbolize_http_status(504)
+    assert_equal :http_version_not_supported, Respect::Rails::ResponseSchema.symbolize_http_status(505)
+  end
+
+  def test_validate_raise_response_validation_error_for_headers_error
+    response = mock()
+    headers = mock()
+    response.stubs(:headers).returns(headers)
+    headers_schema = Respect::HashSchema.new
+    @rs.stubs(:headers).returns(headers_schema)
+    headers_schema.stubs(:validate).with(headers).raises(Respect::ValidationError.new("message")).once
+    simplified_headers = {}
+    @rs.stubs(:simplify_headers).with(headers).returns(simplified_headers).once
+
+    body = mock()
+    response.stubs(:body).returns(body)
+    body_schema = Respect::HashSchema.new
+    @rs.stubs(:body).returns(body_schema)
+    decoded_body = mock()
+    ActiveSupport::JSON.stubs(:decode).with(body).returns(decoded_body)
+    body_schema.stubs(:validate).with(decoded_body)
+    begin
+      @rs.validate(response)
+      assert false
+    rescue Respect::Rails::ResponseValidationError => e
+      assert_equal "headers", e.part
+      assert_equal simplified_headers.object_id, e.object.object_id
+    end
+  end
+end