segregate 0.4.0 → 0.5.0

data/spec/segregate_spec.rb

@@ -6,26 +6,8 @@ describe Segregate do
   end
 
   describe '::new' do
-  	it 'returns an instance of Segregate' do
-  		expect(Segregate.new).to be_an_instance_of Segregate
-  	end
-
-    it 'has the inital values' do
-      @parser = Segregate.new
-      expect(@parser.request?).to be_false
-      expect(@parser.response?).to be_false
-      expect(@parser.uri).to be_nil
-      expect(@parser.request_line).to be_nil
-      expect(@parser.request_method).to be_nil
-      expect(@parser.request_url).to be_nil
-      expect(@parser.status_line).to be_nil
-      expect(@parser.status_code).to be_nil
-      expect(@parser.status_phrase).to be_nil
-      expect(@parser.http_version).to eq [nil, nil]
-      expect(@parser.major_http_version).to be_nil
-      expect(@parser.minor_http_version).to be_nil
-      expect(@parser.headers).to be_empty
-      expect(@parser.body).to be_empty
+    it "creates a new parser" do
+      expect(Segregate.new).to be_an_instance_of Segregate
     end
   end
 
@@ -34,130 +16,214 @@ describe Segregate do
       @parser = Segregate.new
     end
 
-    describe '#parse' do
-      it 'accepts one argument' do
-        expect(@parser).to respond_to(:parse).with(1).argument
+    describe '#method_missing' do
+      it 'raises an error if URI does not respond' do
+        expect{ @parser.not_uri }.to raise_error
+      end
+    end
+
+    describe '#parse_data' do
+      it 'raises an error if an incorret fist line is passed' do
+        expect{ @parser.parse_data("NOT A HTTP LINE\r\n") }.to raise_error RuntimeError, 'ERROR: Unknown first line: NOT A HTTP LINE'
+      end
+
+      it 'raises an error if an incorret request method is passed' do
+        expect{ @parser.parse_data("FAIL /endpoint HTTP/1.1\r\n") }.to raise_error RuntimeError, 'ERROR: Unknown http method: FAIL'
+      end
+
+      it 'can accept partial first lines' do
+        @parser.parse_data "GET /endpoint"
+        @parser.parse_data " HTTP/1.1\r\n"
+        expect(@parser.request_line).to eq "GET /endpoint HTTP/1.1"
+      end
+
+      it 'can accept partial headers' do
+        @parser.parse_data "GET /endpoint HTTP/1.1\r\n"
+        @parser.parse_data "host: www.goo"
+        @parser.parse_data "gle.com\r\n"
+        expect(@parser.headers.host).to eq 'www.google.com'
       end
 
-      it 'errors if an incorrect first line is received' do
-        expect{ @parser.parse "fail\r\n" }.to raise_error RuntimeError, 'ERROR: Unknown first line: fail'
+      it 'can accept partial body' do
+        @parser.parse_data "GET /endpoint HTTP/1.1\r\n"
+        @parser.parse_data "transfer-encoding: chunked\r\n\r\n"
+        @parser.parse_data "9\r\n"
+        @parser.parse_data "12345\r\n"
+        @parser.parse_data "6789\r\n"
+        expect(@parser.body).to eq "123456789"
       end
 
-      it 'errors if an incorrect http method is received' do
-        expect{ @parser.parse "FAIL /endpoint HTTP/1.1\r\n" }.to raise_error RuntimeError, 'ERROR: Unknown http method: FAIL'
+      it 'can accept partial body' do
+        @parser.parse_data "GET /endpoint HTTP/1.1\r\n"
+        @parser.parse_data "content-length: 9\r\n\r\n"
+        @parser.parse_data "12345\r\n"
+        @parser.parse_data "6789\r\n"
+        expect(@parser.body).to eq "123456789"
       end
     end
 
-    context 'a request line has been parsed' do
-      before(:each) do
-        @parser.parse "GET /endpoint HTTP/1.1\r\n"
+    describe '#uri' do
+      it 'returns nil' do
+        expect(@parser.uri).to be_nil
       end
+    end
 
-      describe '#request_line' do
-        it 'returns a string' do
-          expect(@parser.request_line).to be_an_instance_of String
-        end
+    describe '#type' do
+      it 'is an instance of juncture' do
+        expect(@parser.type).to be_an_instance_of Juncture
+      end
 
-        it 'returns a request line' do
-          expect(@parser.request_line).to match Segregate::REQUEST_LINE
-        end
+      it 'is in a nil state' do
+        expect(@parser.type.state).to be_nil
+      end
+    end
 
-        it 'returns a modified method request line' do
-          @parser.request_method = 'POST'
-          expect(@parser.request_line).to match Segregate::REQUEST_LINE
-          expect(@parser.request_line).to eq "POST /endpoint HTTP/1.1"
-        end
+    describe '#state' do
+      it 'is an instance of juncture' do
+        expect(@parser.state).to be_an_instance_of Juncture
+      end
 
-        it 'returns a modified path request line' do
-          @parser.path = "/new/endpoint"
-          expect(@parser.request_line).to match Segregate::REQUEST_LINE
-          expect(@parser.request_line).to eq "GET /new/endpoint HTTP/1.1"
-        end
+      it 'is in a waiting state' do
+        expect(@parser.state.state).to eq :waiting
+      end
+    end
 
-        it 'returns a modified http version request line' do
-          @parser.http_version = [2,3]
-          expect(@parser.request_line).to match Segregate::REQUEST_LINE
-          expect(@parser.request_line).to eq "GET /endpoint HTTP/2.3"
-        end
+    describe '#http_version' do
+      it 'returns [nil, nil]' do
+        expect(@parser.http_version).to eq [nil, nil]
+      end
+    end
 
-        it 'returns a modified major http version request line' do
-          @parser.major_http_version = 2
-          expect(@parser.request_line).to match Segregate::REQUEST_LINE
-          expect(@parser.request_line).to eq "GET /endpoint HTTP/2.1"
-        end
+    describe '#request_method' do
+      it 'returns nil' do
+        expect(@parser.request_method).to be_nil
+      end
+    end
 
-        it 'returns a modified minor http version request line' do
-          @parser.minor_http_version = 2
-          expect(@parser.request_line).to match Segregate::REQUEST_LINE
-          expect(@parser.request_line).to eq "GET /endpoint HTTP/1.2"
-        end
+    describe '#status_code' do
+      it 'returns nil' do
+        expect(@parser.status_code).to be_nil
       end
+    end
 
-      describe '#status_line' do
-        it 'returns nil' do
-          expect(@parser.status_line).to be_nil
-        end
+    describe '#status_phrase' do
+      it 'returns nil' do
+        expect(@parser.status_phrase).to be_nil
       end
+    end
 
-      describe '#request?' do
-        it 'returns true' do
-          expect(@parser.request?).to be_an_instance_of TrueClass
-        end
+    describe '#headers' do
+      it 'is an instance of hashie mash' do
+        expect(@parser.headers).to be_an_instance_of Hashie::Mash
       end
 
-      describe '#response?' do
-        it 'returns false' do
-          expect(@parser.response?).to be_an_instance_of FalseClass
-        end
+      it 'is empty' do
+        expect(@parser.headers).to be_empty
       end
+    end
 
-      describe '#http_version' do
-        it 'returns an array' do
-          expect(@parser.http_version).to be_an_instance_of Array
-        end
+    describe '#body' do
+      it 'is empty' do
+        expect(@parser.body).to be_empty
+      end
+    end
 
-        it 'returns [1, 1]' do
-          expect(@parser.http_version).to eql [1,1]
-        end
+    describe '#request?' do
+      it 'returns false' do
+        expect(@parser.request?).to be_false
       end
+    end
 
-      describe '#major_http_version' do
-        it 'returns an integer' do
-          expect(@parser.major_http_version).to be_an_instance_of Fixnum
-        end
+    describe '#response?' do
+      it 'returns false' do
+        expect(@parser.response?).to be_false
+      end
+    end
 
-        it 'returns 1' do
-          expect(@parser.major_http_version).to eql 1
+    describe '#headers_complete?' do
+      it 'returns false' do
+        expect(@parser.headers_complete?).to be_false
+      end
+    end
+
+    describe '#done?' do
+      it 'returns false' do
+        expect(@parser.done?).to be_false
+      end
+    end
+
+    describe '#request_line' do
+      it 'returns nil' do
+        expect(@parser.request_line).to be_nil
+      end
+    end
+
+    describe '#status_line' do
+      it 'returns nil' do
+        expect(@parser.status_line).to be_nil
+      end
+    end
+
+    describe '#request_url' do
+      it 'returns nil' do
+        expect(@parser.request_url).to be_nil
+      end
+    end
+
+    describe '#major_http_version' do
+      it 'returns nil' do
+        expect(@parser.major_http_version).to be_nil
+      end
+    end
+
+    describe '#minor_http_version' do
+      it 'returns nil' do
+        expect(@parser.minor_http_version).to be_nil
+      end
+    end
+
+    context 'a request line has been parsed' do
+      before(:each) do
+        @parser.parse_data "GET /endpoint HTTP/1.1\r\n"
+      end
+
+      describe '#uri' do
+        it 'is an instance of URI' do
+          expect(@parser.uri).to be_an_instance_of URI::Generic
         end
       end
 
-      describe '#minor_http_version' do
-        it 'returns an integer' do
-          expect(@parser.minor_http_version).to be_an_instance_of Fixnum
+      describe '#respond_to?' do
+        it 'responds to segregate methods' do
+          expect(@parser.respond_to?(:request_line)).to be_true
         end
 
-        it 'returns 1' do
-          expect(@parser.minor_http_version).to eql 1
+        it 'responds to uri methods' do
+          expect(@parser.respond_to?(:hostname)).to be_true
         end
       end
 
-      describe '#request_method' do
-        it 'returns an string' do
-          expect(@parser.request_method).to be_an_instance_of String
+      describe '#type' do
+        it 'is in a request state' do
+          expect(@parser.type.state).to eq :request
         end
+      end
 
-        it 'returns GET' do
-          expect(@parser.request_method).to eq 'GET'
+      describe '#state' do
+        it 'is in a headers state' do
+          expect(@parser.state.state).to eq :headers
         end
       end
 
-      describe '#request_url' do
-        it 'returns an string' do
-          expect(@parser.request_url).to be_an_instance_of String
+      describe '#http_version' do
+        it 'returns [1, 1]' do
+          expect(@parser.http_version).to eq [1, 1]
         end
+      end
 
-        it 'returns /endpoint' do
-          expect(@parser.request_url).to eq '/endpoint'
+      describe '#request_method' do
+        it 'returns GET' do
+          expect(@parser.request_method).to eq 'GET'
         end
       end
 
@@ -173,362 +239,472 @@ describe Segregate do
         end
       end
 
-      describe '#uri' do
-        it 'returns a URI' do
-          expect(@parser.uri).to be_an_instance_of URI::Generic
+      describe '#headers' do
+        it 'is empty' do
+          expect(@parser.headers).to be_empty
         end
       end
 
-      describe '#method_missing' do
-        it 'returns the uri methods' do
-          expect(@parser.path).to eq '/endpoint'
-        end
-
-        it 'raises an error if uri does not respond to the method' do
-          expect{ @parser.not_present }.to raise_error NoMethodError, /undefined method `not_present'/
+      describe '#body' do
+        it 'is empty' do
+          expect(@parser.body).to be_empty
         end
       end
 
-      describe '#respond_to?' do
-        it 'responds to the uri path' do
-          expect(@parser.respond_to? :uri).to be_true
-          expect(@parser.respond_to? :path).to be_true
+      describe '#request?' do
+        it 'returns false' do
+          expect(@parser.request?).to be_true
         end
       end
-    end
-
-    context 'a response line has been parsed' do
-      before(:each) do
-        @parser.parse "HTTP/1.1 200 OK\r\n"
-      end
 
-      describe '#request_line' do
-        it 'returns nil' do
-          expect(@parser.request_line).to be_nil
+      describe '#response?' do
+        it 'returns false' do
+          expect(@parser.response?).to be_false
         end
       end
 
-      describe '#status_line' do
-        it 'returns a string' do
-          expect(@parser.status_line).to be_an_instance_of String
+      describe '#headers_complete?' do
+        it 'returns false' do
+          expect(@parser.headers_complete?).to be_false
         end
+      end
 
-        it 'returns a status line' do
-          expect(@parser.status_line).to match Segregate::STATUS_LINE
+      describe '#done?' do
+        it 'returns false' do
+          expect(@parser.done?).to be_false
         end
+      end
 
-        it 'returns a modified http version status line' do
-          @parser.http_version = [2,3]
-          expect(@parser.status_line).to match Segregate::STATUS_LINE
-          expect(@parser.status_line).to eq "HTTP/2.3 200 OK"
+      describe '#request_line' do
+        it 'returns a valid request line' do
+          expect(@parser.request_line).to match Segregate::REQUEST_LINE
         end
+      end
 
-        it 'returns a modified status code status line' do
-          @parser.status_code = 404
-          expect(@parser.status_line).to match Segregate::STATUS_LINE
-          expect(@parser.status_line).to eq "HTTP/1.1 404 OK"
+      describe '#status_line' do
+        it 'returns nil' do
+          expect(@parser.status_line).to be_nil
         end
+      end
 
-        it 'returns a modified status phrase status line' do
-          @parser.status_phrase = 'NOT_OK'
-          expect(@parser.status_line).to match Segregate::STATUS_LINE
-          expect(@parser.status_line).to eq "HTTP/1.1 200 NOT_OK"
+      describe '#request_url' do
+        it 'returns /endpoint' do
+          expect(@parser.request_url).to eq '/endpoint'
         end
       end
 
-      describe '#request?' do
-        it 'returns false' do
-          expect(@parser.request?).to be_an_instance_of FalseClass
+      describe '#major_http_version' do
+        it 'returns 1' do
+          expect(@parser.major_http_version).to eq 1
         end
       end
 
-      describe '#response?' do
-        it 'returns true' do
-          expect(@parser.response?).to be_an_instance_of TrueClass
+      describe '#minor_http_version' do
+        it 'returns 1' do
+          expect(@parser.minor_http_version).to eq 1
         end
       end
 
-      describe '#http_version' do
-        it 'returns an array' do
-          expect(@parser.http_version).to be_an_instance_of Array
+      context 'headers have been parsed' do
+        before(:each) do
+          @parser.parse_data "host: www.google.com\r\ncontent-length: 10\r\n\r\n"
         end
 
-        it 'returns [1, 1]' do
-          expect(@parser.http_version).to eql [1,1]
+        describe '#state' do
+          it 'is in a body state' do
+            expect(@parser.state.state).to eq :body
+          end
         end
-      end
 
-      describe '#major_http_version' do
-        it 'returns an integer' do
-          expect(@parser.major_http_version).to be_an_instance_of Fixnum
+        describe '#headers' do
+          it 'has the correct keys' do
+            expect(@parser.headers.keys).to eq ['host', 'content-length']
+          end
+
+          it 'has the correct values' do
+            expect(@parser.headers.values).to eq ['www.google.com', '10']
+          end
         end
 
-        it 'returns 1' do
-          expect(@parser.major_http_version).to eql 1
+        describe '#body' do
+          it 'is empty' do
+            expect(@parser.body).to be_empty
+          end
         end
-      end
 
-      describe '#minor_http_version' do
-        it 'returns an integer' do
-          expect(@parser.minor_http_version).to be_an_instance_of Fixnum
+        describe '#headers_complete?' do
+          it 'returns true' do
+            expect(@parser.headers_complete?).to be_true
+          end
         end
 
-        it 'returns 1' do
-          expect(@parser.minor_http_version).to eql 1
+        describe '#done?' do
+          it 'returns false' do
+            expect(@parser.done?).to be_false
+          end
         end
-      end
 
-      describe '#request_method' do
-        it 'returns nil' do
-          expect(@parser.request_method).to be_nil
+        context 'a body has been parsed' do
+          before(:each) do
+            @parser.parse_data "1234567890\r\n"
+          end
+          describe '#state' do
+            it 'is in a done state' do
+              expect(@parser.state.state).to eq :done
+            end
+          end
+
+          describe '#body' do
+            it 'has the correct data' do
+              expect(@parser.body).to eq '1234567890'
+            end
+          end
+
+          describe '#done?' do
+            it 'returns true' do
+              expect(@parser.done?).to be_true
+            end
+          end
+
+          describe '#raw_data' do
+            it 'returns the message in string form' do
+              expect(@parser.raw_data).to eq "GET /endpoint HTTP/1.1\r\nhost: www.google.com\r\ncontent-length: 10\r\n\r\n1234567890\r\n\r\n"
+            end
+          end
+
+          describe '#major_http_version=' do
+            it 'updates the major http version' do
+              @parser.major_http_version = 2
+              expect(@parser.request_line).to eq 'GET /endpoint HTTP/2.1'
+            end
+          end
+
+          describe '#minor_http_version=' do
+            it 'updates the minor http version' do
+              @parser.minor_http_version = 2
+              expect(@parser.request_line).to eq 'GET /endpoint HTTP/1.2'
+            end
+          end
+
+          describe '#request_method=' do
+            it 'updates the request method' do
+              @parser.request_method = 'POST'
+              expect(@parser.request_line).to eq 'POST /endpoint HTTP/1.1'
+            end
+          end
+
+          describe '#path=' do
+            it 'updates the request url' do
+              @parser.path = '/new/endpoint'
+              expect(@parser.request_line).to eq 'GET /new/endpoint HTTP/1.1'
+            end
+          end
+
+          describe '#body=' do
+            it 'updates the body' do
+              @parser.body = 'this is the body'
+              expect(@parser.raw_data).to eq "GET /endpoint HTTP/1.1\r\nhost: www.google.com\r\ncontent-length: 16\r\n\r\nthis is the body\r\n\r\n"
+            end
+          end
         end
       end
 
-      describe '#request_url' do
-        it 'returns nil' do
-          expect(@parser.request_url).to be_nil
+      context 'non body headers have been parsed' do
+        before(:each) do
+          @parser.parse_data "host: www.google.com\r\naccept: *\r\n\r\n"
         end
-      end
 
-      describe '#status_code' do
-        it 'returns an integer' do
-          expect(@parser.status_code).to be_an_instance_of Fixnum
+        describe '#state' do
+          it 'is in a done state' do
+            expect(@parser.state.state).to eq :done
+          end
         end
 
-        it 'returns 200' do
-          expect(@parser.status_code).to eql 200
+        describe '#headers' do
+          it 'has the correct keys' do
+            expect(@parser.headers.keys).to eq ['host', 'accept']
+          end
+
+          it 'has the correct values' do
+            expect(@parser.headers.values).to eq ['www.google.com', '*']
+          end
         end
-      end
 
-      describe '#status_phrase' do
-        it 'returns an string' do
-          expect(@parser.status_phrase).to be_an_instance_of String
+        describe '#body' do
+          it 'is empty' do
+            expect(@parser.body).to be_empty
+          end
         end
 
-        it 'returns OK' do
-          expect(@parser.status_phrase).to eq 'OK'
+        describe '#headers_complete?' do
+          it 'returns true' do
+            expect(@parser.headers_complete?).to be_true
+          end
         end
-      end
 
-      describe '#uri' do
-        it 'returns nil' do
-          expect(@parser.uri).to be_nil
+        describe '#done?' do
+          it 'returns true' do
+            expect(@parser.done?).to be_true
+          end
         end
       end
     end
 
-    context 'a header has been parsed' do
+    context 'a status line has been parsed' do
       before(:each) do
-        @parser.parse "GET /endpoint HTTP/1.1\r\nAccept: application/json\r\n"
+        @parser.parse_data "HTTP/1.1 200 OK\r\n"
       end
 
-      describe '#headers' do
-        it 'returns an instans of a hashie mash' do
-          expect(@parser.headers).to be_an_instance_of Hashie::Mash
+      describe '#uri' do
+        it 'returns nil' do
+          expect(@parser.uri).to be_nil
         end
+      end
 
-        it 'contains the parsed header' do
-          expect(@parser.headers).to respond_to(:accept)
-          expect(@parser.headers.accept).to eq 'application/json'
+      describe '#type' do
+        it 'is in a request state' do
+          expect(@parser.type.state).to eq :response
         end
       end
 
-      describe '#headers_complete?' do
-        it 'returns false' do
-          expect(@parser.headers_complete?).to be_an_instance_of FalseClass
+      describe '#state' do
+        it 'is in a headers state' do
+          expect(@parser.state.state).to eq :headers
         end
       end
-    end
 
-    context 'all headers have been parsed' do
-      before(:each) do
-        @parser.parse "GET /endpoint HTTP/1.1\r\nAccept: application/json\r\nHost: www.google.com\r\n\r\n"
+      describe '#http_version' do
+        it 'returns [1, 1]' do
+          expect(@parser.http_version).to eq [1, 1]
+        end
       end
 
-      describe '#headers' do
-        it 'returns an instans of a hashie mash' do
-          expect(@parser.headers).to be_an_instance_of Hashie::Mash
+      describe '#request_method' do
+        it 'returns nil' do
+          expect(@parser.request_method).to be_nil
         end
+      end
 
-        it 'contains all the parsed headers' do
-          expect(@parser.headers).to respond_to(:accept)
-          expect(@parser.headers).to respond_to(:host)
-          expect(@parser.headers.accept).to eq 'application/json'
-          expect(@parser.headers.host).to eq 'www.google.com'
+      describe '#status_code' do
+        it 'returns 200' do
+          expect(@parser.status_code).to eq 200
         end
+      end
 
-        it 'contains modified headers' do
-          @parser.headers.host = 'www.yahoo.com'
-          expect(@parser.headers).to respond_to(:host)
-          expect(@parser.headers.host).to eq 'www.yahoo.com'
+      describe '#status_phrase' do
+        it 'returns OK' do
+          expect(@parser.status_phrase).to eq 'OK'
         end
       end
 
-      describe '#headers_complete?' do
-        it 'returns true' do
-          expect(@parser.headers_complete?).to be_an_instance_of TrueClass
+      describe '#headers' do
+        it 'is empty' do
+          expect(@parser.headers).to be_empty
         end
       end
-    end
 
-    context 'a body has been parsed' do
-      before(:each) do
-        @parser.parse "GET /endpoint HTTP/1.1\r\nHost: www.google.com\r\nContent-Length: 20\r\n\r\n"
-        @parser.parse "This is the content!\r\n\r\n"
+      describe '#body' do
+        it 'is empty' do
+          expect(@parser.body).to be_empty
+        end
       end
 
-      describe '#body' do
-        it 'returns a string' do
-          expect(@parser.body).to be_an_instance_of String
+      describe '#request?' do
+        it 'returns false' do
+          expect(@parser.request?).to be_false
         end
+      end
 
-        it 'contains the body text' do
-          expect(@parser.body).to eq 'This is the content!'
+      describe '#response?' do
+        it 'returns false' do
+          expect(@parser.response?).to be_true
         end
       end
 
-      describe '#body_complete?' do
-        it 'returns true' do
-          expect(@parser.body_complete?).to be_an_instance_of TrueClass
+      describe '#headers_complete?' do
+        it 'returns false' do
+          expect(@parser.headers_complete?).to be_false
         end
       end
 
-      describe '#update_content_length' do
-        it 'updates the content lenght header' do
-          expect(@parser.headers['content-length']).to eq '20'
-          @parser.body = 'new content'
-          @parser.update_content_length
-          expect(@parser.headers['content-length']).to eq '11'
+      describe '#done?' do
+        it 'returns false' do
+          expect(@parser.done?).to be_false
         end
       end
 
-      describe '#raw_data' do
-        it 'returns the raw message' do
-          expect(@parser.raw_data).to eq "GET /endpoint HTTP/1.1\r\nhost: www.google.com\r\ncontent-length: 20\r\n\r\nThis is the content!\r\n\r\n"
+      describe '#request_line' do
+        it 'returns nil' do
+          expect(@parser.request_line).to be_nil
         end
       end
-    end
 
-    context 'a partial chunked body has been parsed' do
-      before(:each) do
-        @parser.parse "GET /endpoint HTTP/1.1\r\nHost: www.google.com\r\nTransfer-Encoding: chunked\r\n\r\n"
-        @parser.parse "1a\r\nThis is the first content!\r\n"
+      describe '#status_line' do
+        it 'returns a valid status line' do
+          expect(@parser.status_line).to match Segregate::STATUS_LINE
+        end
       end
 
-      describe '#body' do
-        it 'returns a string' do
-          expect(@parser.body).to be_an_instance_of String
+      describe '#request_url' do
+        it 'returns nil' do
+          expect(@parser.request_url).to be_nil
         end
+      end
 
-        it 'contains the body text' do
-          expect(@parser.body).to eq 'This is the first content!'
+      describe '#major_http_version' do
+        it 'returns 1' do
+          expect(@parser.major_http_version).to eq 1
         end
       end
 
-      describe '#body_complete?' do
-        it 'returns false' do
-          expect(@parser.body_complete?).to be_an_instance_of FalseClass
+      describe '#minor_http_version' do
+        it 'returns 1' do
+          expect(@parser.minor_http_version).to eq 1
         end
       end
 
-      context 'the body parsing is completed' do
+      context 'headers have been parsed' do
         before(:each) do
-          @parser.parse "1b\r\nThis is the second content!\r\n0\r\n\r\n"
+          @parser.parse_data "host: www.google.com\r\ntransfer-encoding: chunked\r\n\r\n"
         end
 
-        describe '#body' do
-          it 'returns a string' do
-            expect(@parser.body).to be_an_instance_of String
+        describe '#state' do
+          it 'is in a body state' do
+            expect(@parser.state.state).to eq :body
           end
+        end
 
-          it 'contains the body text' do
-            expect(@parser.body).to eq 'This is the first content!This is the second content!'
+        describe '#headers' do
+          it 'has the correct keys' do
+            expect(@parser.headers.keys).to eq ['host', 'transfer-encoding']
           end
 
-          it 'contains the modified body' do
-            @parser.body.sub!('first', 'third')
-            expect(@parser.body).to eq 'This is the third content!This is the second content!'
+          it 'has the correct values' do
+            expect(@parser.headers.values).to eq ['www.google.com', 'chunked']
           end
         end
 
-        describe '#body_complete?' do
-          it 'returns true' do
-            expect(@parser.body_complete?).to be_an_instance_of TrueClass
+        describe '#body' do
+          it 'is empty' do
+            expect(@parser.body).to be_empty
           end
         end
 
-        describe '#update_content_length' do
-          it 'updates the content lenght header' do
-            expect(@parser.headers['content-length']).to be_nil
-            expect(@parser.headers['transfer-encoding']).to eq 'chunked'
-            @parser.body = 'new content'
-            @parser.update_content_length
-            expect(@parser.headers['content-length']).to eq '11'
-            expect(@parser.headers['transfer-encoding']).to be_nil
+        describe '#headers_complete?' do
+          it 'returns true' do
+            expect(@parser.headers_complete?).to be_true
           end
         end
 
-        describe '#raw_data' do
-          it 'returns the raw message' do
-            expect(@parser.raw_data).to eq "GET /endpoint HTTP/1.1\r\nhost: www.google.com\r\ncontent-length: 53\r\n\r\nThis is the first content!This is the second content!\r\n\r\n"
+        describe '#done?' do
+          it 'returns false' do
+            expect(@parser.done?).to be_false
           end
         end
-      end
-    end
-  end
 
-  context 'a new parser has been created with a callback object' do
-    before(:each) do
-      @callback_object = double
-      @parser = Segregate.new @callback_object
-    end
+        context 'a body has been parsed' do
+          before(:each) do
+            @parser.parse_data "9\r\n123456789\r\n0\r\n\r\n"
+          end
+          describe '#state' do
+            it 'is in a done state' do
+              expect(@parser.state.state).to eq :done
+            end
+          end
 
-    describe 'on_message_begin' do
-      it 'calls the callback object' do
-        @callback_object.should_receive(:on_message_begin).with(@parser)
-        @parser.parse "GET /endpoint HTTP/1.1\r\n"
-      end
-    end
+          describe '#body' do
+            it 'has the correct data' do
+              expect(@parser.body).to eq '123456789'
+            end
+          end
 
-    describe 'on_request' do
-      it 'calls the callback object' do
-        @callback_object.should_receive(:on_request_line).with(@parser)
-        @parser.parse "GET /endpoint HTTP/1.1\r\n"
-      end
-    end
+          describe '#done?' do
+            it 'returns true' do
+              expect(@parser.done?).to be_true
+            end
+          end
 
-    describe 'on_response' do
-      it 'calls the callback object' do
-        @callback_object.should_receive(:on_status_line).with(@parser)
-        @parser.parse "HTTP/1.1 200 OK\r\n"
-      end
-    end
+          describe '#raw_data' do
+            it 'returns the message in string form' do
+              expect(@parser.raw_data).to eq "HTTP/1.1 200 OK\r\nhost: www.google.com\r\ncontent-length: 9\r\n\r\n123456789\r\n\r\n"
+            end
+          end
 
-    describe 'on_headers_complete' do
-      it 'calls the callback object' do
-        @callback_object.should_receive(:on_headers_complete).with(@parser)
-        @parser.parse "GET /endpoint HTTP/1.1\r\nHost: www.google.com\r\n\r\n"
-      end
-    end
+          describe '#major_http_version=' do
+            it 'updates the major http version' do
+              @parser.major_http_version = 2
+              expect(@parser.status_line).to eq 'HTTP/2.1 200 OK'
+            end
+          end
 
-    describe 'on_body' do
-      it 'calls the callback object' do
-        @callback_object.should_receive(:on_body).with("TestData")
-        @parser.parse "GET /endpoint HTTP/1.1\r\nContent-Length: 8\r\n\r\n"
-        @parser.parse "TestData\r\n\r\n"
-      end
-    end
+          describe '#minor_http_version=' do
+            it 'updates the minor http version' do
+              @parser.minor_http_version = 2
+              expect(@parser.status_line).to eq 'HTTP/1.2 200 OK'
+            end
+          end
+
+          describe '#status_code=' do
+            it 'updates the status code' do
+              @parser.status_code = 404
+              expect(@parser.status_line).to eq 'HTTP/1.1 404 OK'
+            end
+          end
+
+          describe '#status_phrase=' do
+            it 'updates the status phrase' do
+              @parser.status_phrase = 'not found'
+              expect(@parser.status_line).to eq 'HTTP/1.1 200 not found'
+            end
+          end
 
-    describe 'on_message_complete' do
-      it 'calls the callback object with a body' do
-        @callback_object.should_receive(:on_message_complete).with(@parser)
-        @parser.parse "GET /endpoint HTTP/1.1\r\nContent-Length: 8\r\n\r\n"
-        @parser.parse "TestData\r\n\r\n"
+          describe '#body=' do
+            it 'updates the body' do
+              @parser.body = 'this is the body'
+              expect(@parser.raw_data).to eq "HTTP/1.1 200 OK\r\nhost: www.google.com\r\ncontent-length: 16\r\n\r\nthis is the body\r\n\r\n"
+            end
+          end
+        end
       end
 
-      it 'calls the callback object without a body' do
-        @callback_object.should_receive(:on_message_complete).with(@parser)
-        @parser.parse "GET /endpoint HTTP/1.1\r\nhost: www.google.com\r\n\r\n"
+      context 'non body headers have been parsed' do
+        before(:each) do
+          @parser.parse_data "host: www.google.com\r\naccept: *\r\n\r\n"
+        end
+
+        describe '#state' do
+          it 'is in a done state' do
+            expect(@parser.state.state).to eq :done
+          end
+        end
+
+        describe '#headers' do
+          it 'has the correct keys' do
+            expect(@parser.headers.keys).to eq ['host', 'accept']
+          end
+
+          it 'has the correct values' do
+            expect(@parser.headers.values).to eq ['www.google.com', '*']
+          end
+        end
+
+        describe '#body' do
+          it 'is empty' do
+            expect(@parser.body).to be_empty
+          end
+        end
+
+        describe '#headers_complete?' do
+          it 'returns true' do
+            expect(@parser.headers_complete?).to be_true
+          end
+        end
+
+        describe '#done?' do
+          it 'returns true' do
+            expect(@parser.done?).to be_true
+          end
+        end
       end
     end
   end