stream_spec.rb in http-2-0.6.3

- old
+ new

@@ -1,22 +1,21 @@
 require "helper"
 
 describe HTTP2::Stream do
   before(:each) do
-    @conn = Connection.new
-    @stream = @conn.new_stream
+    @client = Client.new
+    @stream = @client.new_stream
   end
 
   context "stream states" do
     it "should initiliaze all streams to IDLE" do
       @stream.state.should eq :idle
     end
 
-    it "should set stream priority and flow window" do
-      stream = @conn.new_stream(priority: 3, window: 1024)
+    it "should set custom stream priority" do
+      stream = @client.new_stream(priority: 3)
       stream.priority.should eq 3
-      stream.window.should eq 1024
     end
 
     context "reserved (local)" do
       before(:each) { @stream.send PUSH_PROMISE }
 
@@ -135,20 +134,20 @@
           s.state.should eq :half_closed_remote
         end
       end
 
       it "should transition to half closed if remote opened with END_STREAM" do
-        s = @conn.new_stream
+        s = @client.new_stream
         hclose = HEADERS.dup
         hclose[:flags] = [:end_stream]
 
         s.receive hclose
         s.state.should eq :half_closed_remote
       end
 
       it "should transition to half closed if local opened with END_STREAM" do
-        s = @conn.new_stream
+        s = @client.new_stream
         hclose = HEADERS.dup
         hclose[:flags] = [:end_stream]
 
         s.send hclose
         s.state.should eq :half_closed_local
@@ -164,12 +163,12 @@
         @stream.state.should eq :closed
       end
 
       it "should emit :active on open transition" do
         openp, openr = false, false
-        sp = @conn.new_stream
-        sr = @conn.new_stream
+        sp = @client.new_stream
+        sr = @client.new_stream
         sp.on(:active) { openp = true }
         sr.on(:active) { openr = true }
 
         sp.receive HEADERS
         sr.send HEADERS
@@ -177,11 +176,11 @@
         openp.should be_true
         openr.should be_true
       end
 
       it "should not emit :active on transition from open" do
-        order, stream = [], @conn.new_stream
+        order, stream = [], @client.new_stream
 
         stream.on(:active) { order << :active }
         stream.on(:half_close) { order << :half_close }
         stream.on(:close)  { order << :close }
 
@@ -206,11 +205,11 @@
         closep.should be_true
         closer.should be_true
       end
 
       it "should emit :close after frame is processed" do
-        order, stream = [], @conn.new_stream
+        order, stream = [], @client.new_stream
 
         stream.on(:active) { order << :active }
         stream.on(:data)   { order << :data }
         stream.on(:half_close) { order << :half_close }
         stream.on(:close)  { order << :close }
@@ -268,11 +267,11 @@
         @stream.state.should eq :half_closed_local
       end
 
       it "should emit :half_close event on transition" do
         order = []
-        stream = @conn.new_stream
+        stream = @client.new_stream
         stream.on(:active) { order << :active }
         stream.on(:half_close) { order << :half_close }
 
         req = HEADERS.dup
         req[:flags] = [:end_stream, :end_headers]
@@ -328,11 +327,11 @@
         @stream.state.should eq :half_closed_remote
       end
 
       it "should emit :half_close event on transition" do
         order = []
-        stream = @conn.new_stream
+        stream = @client.new_stream
         stream.on(:active) { order << :active }
         stream.on(:half_close) { order << :half_close }
 
         req = HEADERS.dup
         req[:flags] = [:end_stream, :end_headers]
@@ -458,22 +457,22 @@
       settings, data = SETTINGS.dup, DATA.dup
       settings[:payload] = { settings_initial_window_size: 1000 }
       settings[:stream] = 0
 
       framer = Framer.new
-      @conn << framer.generate(settings)
+      @client << framer.generate(settings)
 
-      s1 = @conn.new_stream
+      s1 = @client.new_stream
       s1.send HEADERS
       s1.send data.merge({payload: "x" * 900, flags: []})
       s1.window.should eq 100
 
       s1.send data.merge({payload: "x" * 200})
       s1.window.should eq 0
       s1.buffered_amount.should eq 100
 
-      @conn << framer.generate(WINDOW_UPDATE.merge({
+      @client << framer.generate(WINDOW_UPDATE.merge({
         stream: s1.id, increment: 1000
       }))
       s1.buffered_amount.should eq 0
       s1.window.should eq 900
     end
@@ -488,12 +487,12 @@
 
       @stream.reprioritize 30
     end
 
     it ".reprioritize should raise error if invoked by server" do
-      conn = Connection.new(:server)
-      stream = conn.new_stream
+      srv = Server.new
+      stream = srv.new_stream
 
       expect { stream.reprioritize(10) }.to raise_error(StreamError)
     end
 
     it ".headers should emit HEADERS frames" do
@@ -555,15 +554,15 @@
     end
   end
 
   context "server API" do
     before(:each) do
-      @srv = Connection.new(:server)
+      @srv = Server.new
       @frm = Framer.new
 
-      @conn.on(:frame) {|bytes| @srv << bytes }
-      @client_stream = @conn.new_stream
+      @client.on(:frame) {|bytes| @srv << bytes }
+      @client_stream = @client.new_stream
     end
 
     it "should emit received headers via on(:headers)" do
       headers, recv = {"header" => "value"}, nil
       @srv.on(:stream) do |stream|
@@ -598,25 +597,19 @@
       @client_stream.reprioritize(new_priority)
     end
 
     context "push" do
       before(:each) do
-        @srv.on(:frame)  {|bytes| @conn << bytes }
+        @srv.on(:frame)  {|bytes| @client << bytes }
         @srv.on(:stream) do |stream|
           @server_stream = stream
         end
 
-        @srv << @frm.generate(SETTINGS)
+        # @srv << @frm.generate(SETTINGS)
         @client_stream.headers({"key" => "value"})
       end
 
-      it ".promise should raise error on client push" do
-        expect do
-          @client_stream.promise({}) {}
-        end.to raise_error(ProtocolError)
-      end
-
       it ".promise should emit server initiated stream" do
         push = nil
         @server_stream.promise({"key" => "val"}) { |pstream| push = pstream }
         push.id.should eq 2
       end
@@ -649,10 +642,10 @@
           order.should eq [:reserved, :active, :half_close, :close]
         end
 
         it "client: headers > active > headers > .. > data > close" do
           order, headers = [], {}
-          @conn.on(:promise) do |push|
+          @client.on(:promise) do |push|
             order << :reserved
 
             push.on(:active)    { order << :active }
             push.on(:data)      { order << :data }
             push.on(:half_close){ order << :half_close }