Replace #status_code with #status

spec/std/http/client/response_spec.cr

@@ -169,14 +169,14 @@ class HTTP::Client
     end
 
     it "doesn't sets content length for 1xx, 204 or 304" do
-      [100, 101, 204, 304].each do |status|
+      [HTTP::Status::CONTINUE, HTTP::Status::SWITCHING_PROTOCOLS, HTTP::Status::NO_CONTENT, HTTP::Status::NOT_MODIFIED].each do |status|
         response = Response.new(status)
         response.headers.size.should eq(0)
       end
     end
 
     it "raises when creating 1xx, 204 or 304 with body" do
-      [100, 101, 204, 304].each do |status|
+      [HTTP::Status::CONTINUE, HTTP::Status::SWITCHING_PROTOCOLS, HTTP::Status::NO_CONTENT, HTTP::Status::NOT_MODIFIED].each do |status|
         expect_raises ArgumentError do
           Response.new(status, "hello")
         end
@@ -188,7 +188,7 @@ class HTTP::Client
       headers["Content-Type"] = "text/plain"
       headers["Content-Length"] = "5"
 
-      response = Response.new(200, "hello", headers)
+      response = Response.new(:ok, "hello", headers)
       io = IO::Memory.new
       response.to_io(io)
       io.to_s.should eq("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nhello")
@@ -200,7 +200,7 @@ class HTTP::Client
       headers["Content-Length"] = "5"
       headers["Set-Cookie"] = "foo=bar; path=/"
 
-      response = Response.new(200, "hello", headers)
+      response = Response.new(:ok, "hello", headers)
 
       io = IO::Memory.new
       response.to_io(io)
@@ -221,69 +221,74 @@ class HTTP::Client
     end
 
     it "sets content length from body" do
-      response = Response.new(200, "hello")
+      response = Response.new(:ok, "hello")
       io = IO::Memory.new
       response.to_io(io)
       io.to_s.should eq("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\nhello")
     end
 
     it "sets content length even without body" do
-      response = Response.new(200)
+      response = Response.new(:ok)
       io = IO::Memory.new
       response.to_io(io)
       io.to_s.should eq("HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n")
     end
 
     it "serialize as chunked with body_io" do
-      response = Response.new(200, body_io: IO::Memory.new("hello"))
+      response = Response.new(:ok, body_io: IO::Memory.new("hello"))
       io = IO::Memory.new
       response.to_io(io)
       io.to_s.should eq("HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nhello\r\n0\r\n\r\n")
     end
 
     it "serialize as not chunked with body_io if HTTP/1.0" do
-      response = Response.new(200, version: "HTTP/1.0", body_io: IO::Memory.new("hello"))
+      response = Response.new(:ok, version: "HTTP/1.0", body_io: IO::Memory.new("hello"))
       io = IO::Memory.new
       response.to_io(io)
       io.to_s.should eq("HTTP/1.0 200 OK\r\nContent-Length: 5\r\n\r\nhello")
     end
 
     it "returns no content_type when header is missing" do
-      response = Response.new(200, "")
+      response = Response.new(:ok, "")
       response.content_type.should be_nil
       response.charset.should be_nil
     end
 
     it "returns content type and no charset" do
-      response = Response.new(200, "", headers: HTTP::Headers{"Content-Type" => "application/octet-stream"})
+      response = Response.new(:ok, "", headers: HTTP::Headers{"Content-Type" => "application/octet-stream"})
       response.content_type.should eq("application/octet-stream")
       response.charset.should be_nil
     end
 
     it "returns content type and charset, removes semicolon" do
-      response = Response.new(200, "", headers: HTTP::Headers{"Content-Type" => "text/plain ; charset=UTF-8"})
+      response = Response.new(:ok, "", headers: HTTP::Headers{"Content-Type" => "text/plain ; charset=UTF-8"})
       response.content_type.should eq("text/plain")
       response.charset.should eq("UTF-8")
     end
 
     it "returns content type and charset, removes quotes" do
-      response = Response.new(200, "", headers: HTTP::Headers{"Content-Type" => %(text/plain ; charset="UTF-8")})
+      response = Response.new(:ok, "", headers: HTTP::Headers{"Content-Type" => %(text/plain ; charset="UTF-8")})
       response.content_type.should eq("text/plain")
       response.charset.should eq("UTF-8")
     end
 
     it "returns content type and no charset, other parameter (#2520)" do
-      response = Response.new(200, "", headers: HTTP::Headers{"Content-Type" => "application/octet-stream ; colenc=U"})
+      response = Response.new(:ok, "", headers: HTTP::Headers{"Content-Type" => "application/octet-stream ; colenc=U"})
       response.content_type.should eq("application/octet-stream")
       response.charset.should be_nil
     end
 
     it "returns content type and charset, removes semicolon, with multiple parameters (#2520)" do
-      response = Response.new(200, "", headers: HTTP::Headers{"Content-Type" => "text/plain ; colenc=U ; charset=UTF-8"})
+      response = Response.new(:ok, "", headers: HTTP::Headers{"Content-Type" => "text/plain ; colenc=U ; charset=UTF-8"})
       response.content_type.should eq("text/plain")
       response.charset.should eq("UTF-8")
     end
 
+    it "returns status_code" do
+      response = Response.new(:created)
+      response.status_code.should eq 201
+    end
+
     it "creates Response with status code 204, no body and Content-Length == 0 (#2512)" do
       response = Response.new(204, version: "HTTP/1.0", body: "", headers: HTTP::Headers{"Content-Length" => "0"})
       response.status_code.should eq(204)
@@ -292,7 +297,7 @@ class HTTP::Client
 
     describe "success?" do
       it "returns true for the 2xx" do
-        response = Response.new(200)
+        response = Response.new(:ok)
 
         response.success?.should eq(true)
       end

spec/std/http/http_spec.cr

@@ -77,14 +77,4 @@ describe HTTP do
       end
     end
   end
-
-  describe ".default_status_message_for" do
-    it "returns a default message for status 200" do
-      HTTP.default_status_message_for(200).should eq("OK")
-    end
-
-    it "returns an empty string on non-existent status" do
-      HTTP.default_status_message_for(0).should eq("")
-    end
-  end
 end

spec/std/http/server/server_spec.cr

@@ -155,10 +155,24 @@ module HTTP
         io.to_s.should eq("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 5\r\n\r\nHello")
       end
 
+      it "sets status code" do
+        io = IO::Memory.new
+        response = Response.new(io)
+        response.status_code = 201
+        response.status.should eq HTTP::Status::CREATED
+      end
+
+      it "retrieves status code" do
+        io = IO::Memory.new
+        response = Response.new(io)
+        response.status = :created
+        response.status_code.should eq 201
+      end
+
       it "changes status and others" do
         io = IO::Memory.new
         response = Response.new(io)
-        response.status_code = 404
+        response.status = :not_found
         response.version = "HTTP/1.0"
         response.close
         io.to_s.should eq("HTTP/1.0 404 Not Found\r\nContent-Length: 0\r\n\r\n")

spec/std/http/status_spec.cr

@@ -0,0 +1,86 @@
+require "spec"
+require "http"
+
+describe HTTP::Status do
+  describe ".new" do
+    it "raises when given invalid status code" do
+      expect_raises(ArgumentError, "Invalid HTTP status code: 1000") do
+        HTTP::Status.new(1000)
+      end
+    end
+
+    it "returns an instance when given defined status code" do
+      HTTP::Status.new(201).should eq HTTP::Status::CREATED
+    end
+
+    it "returns an instance when given undefined status code" do
+      HTTP::Status.new(418).should eq HTTP::Status.new(418)
+    end
+  end
+
+  describe "#code" do
+    it "returns the status code" do
+      HTTP::Status::INTERNAL_SERVER_ERROR.code.should eq 500
+    end
+  end
+
+  describe "#informational?" do
+    it "returns true when given 1xx status code" do
+      HTTP::Status.new(100).informational?.should be_true
+    end
+
+    it "returns false unless given 1xx status code" do
+      HTTP::Status.new(999).informational?.should be_false
+    end
+  end
+
+  describe "#success?" do
+    it "returns true when given 2xx status code" do
+      HTTP::Status.new(200).success?.should be_true
+    end
+
+    it "returns false unless given 2xx status code" do
+      HTTP::Status.new(999).success?.should be_false
+    end
+  end
+
+  describe "#redirection?" do
+    it "returns true when given 3xx status code" do
+      HTTP::Status.new(300).redirection?.should be_true
+    end
+
+    it "returns false unless given 3xx status code" do
+      HTTP::Status.new(999).redirection?.should be_false
+    end
+  end
+
+  describe "#client_error?" do
+    it "returns true when given 4xx status code" do
+      HTTP::Status.new(400).client_error?.should be_true
+    end
+
+    it "returns false unless given 4xx status code" do
+      HTTP::Status.new(999).client_error?.should be_false
+    end
+  end
+
+  describe "#server_error?" do
+    it "returns true when given 5xx status code" do
+      HTTP::Status.new(500).server_error?.should be_true
+    end
+
+    it "returns false unless given 5xx status code" do
+      HTTP::Status.new(999).server_error?.should be_false
+    end
+  end
+
+  describe "#description" do
+    it "returns default description for status 200" do
+      HTTP::Status.new(200).description.should eq("OK")
+    end
+
+    it "returns nil on non-existent status" do
+      HTTP::Status.new(999).description.should eq(nil)
+    end
+  end
+end

src/http/client/response.cr

@@ -4,24 +4,28 @@ require "mime/media_type"
 
 class HTTP::Client::Response
   getter version : String
-  getter status_code : Int32
-  getter status_message : String
+  getter status : HTTP::Status
+  getter status_message : String?
   getter headers : Headers
   getter! body_io : IO
   @cookies : Cookies?
 
-  def initialize(@status_code, @body : String? = nil, @headers : Headers = Headers.new, status_message = nil, @version = "HTTP/1.1", @body_io = nil)
-    @status_message = status_message || HTTP.default_status_message_for(@status_code)
+  def initialize(@status : HTTP::Status, @body : String? = nil, @headers : Headers = Headers.new, status_message = nil, @version = "HTTP/1.1", @body_io = nil)
+    @status_message = status_message || @status.description
 
-    if Response.mandatory_body?(@status_code)
+    if Response.mandatory_body?(@status)
       @body = "" unless @body || @body_io
     else
       if (@body || @body_io) && (headers["Content-Length"]? != "0")
-        raise ArgumentError.new("Status #{status_code} should not have a body")
+        raise ArgumentError.new("Status #{status.code} should not have a body")
       end
     end
   end
 
+  def self.new(status_code : Int32, body : String? = nil, headers : Headers = Headers.new, status_message = nil, version = "HTTP/1.1", body_io = nil)
+    new(HTTP::Status.new(status_code), body, headers, status_message, version, body_io)
+  end
+
   def body
     @body || ""
   end
@@ -32,7 +36,7 @@ class HTTP::Client::Response
 
   # Returns `true` if the response status code is between 200 and 299.
   def success?
-    (200..299).includes?(status_code)
+    @status.success?
   end
 
   # Returns a convenience wrapper around querying and setting cookie related
@@ -49,6 +53,11 @@ class HTTP::Client::Response
     mime_type.try &.media_type
   end
 
+  # Convenience method to retrieve the HTTP status code.
+  def status_code
+    status.code
+  end
+
   def charset : String?
     mime_type.try &.["charset"]?
   end
@@ -60,7 +69,7 @@ class HTTP::Client::Response
   end
 
   def to_io(io)
-    io << @version << ' ' << @status_code << ' ' << @status_message << "\r\n"
+    io << @version << ' ' << @status.code << ' ' << @status_message << "\r\n"
     cookies = @cookies
     headers = cookies ? cookies.add_response_headers(@headers) : @headers
     HTTP.serialize_headers_and_body(io, headers, @body, @body_io, @version)
@@ -74,8 +83,8 @@ class HTTP::Client::Response
     end
   end
 
-  def self.mandatory_body?(status_code) : Bool
-    !(status_code / 100 == 1 || status_code == 204 || status_code == 304)
+  def self.mandatory_body?(status : HTTP::Status) : Bool
+    !(status.informational? || status.no_content? || status.not_modified?)
   end
 
   def self.supports_chunked?(version) : Bool
@@ -130,14 +139,15 @@ class HTTP::Client::Response
       raise "Invalid HTTP status code: #{pieces[1]}"
     end
 
+    status = HTTP::Status.new(status_code)
     status_message = pieces[2]? ? pieces[2].chomp : ""
 
     body_type = HTTP::BodyType::OnDemand
-    body_type = HTTP::BodyType::Mandatory if mandatory_body?(status_code)
+    body_type = HTTP::BodyType::Mandatory if mandatory_body?(status)
     body_type = HTTP::BodyType::Prohibited if ignore_body
 
     HTTP.parse_headers_and_body(io, body_type: body_type, decompress: decompress) do |headers, body|
-      return yield new status_code, nil, headers, status_message, http_version, body
+      return yield new status, nil, headers, status_message, http_version, body
     end
   end
 end