trema 0.3.3 → 0.3.4

data/spec/trema/set-ip-tos_spec.rb

@@ -20,39 +20,38 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe SetIpTos, ".new( number )" do
+describe SetIpTos, ".new( type_of_service )", :type => "actions" do
   subject { SetIpTos.new( type_of_service ) }
 
-  context "when type_of_service == 32" do
+  context "with type_of_service (32)" do
     let( :type_of_service ) { 32 }
     its( :type_of_service ) { should == 32 }
   end
 
-  it_validates "option range", :type_of_service, 0..( 2 ** 8 - 1 )
-end
-
-
-describe SetIpTos, %{.new( "32" )} do
-  it { expect { SetIpTos.new( "32" ) }.to raise_error( TypeError ) }
-end
+  it_validates "option is within range", :type_of_service, 0..( 2 ** 8 - 1 )
 
+  context %{with type_of_service ("32")} do
+    let( :type_of_service ) { "32" }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
-describe SetIpTos, ".new( [ 32 ] )" do
-  it { expect { SetIpTos.new( [ 32 ] ) }.to raise_error( TypeError ) }
-end
+  context %{with type_of_service ([32])} do
+    let( :type_of_service ) { [ 32 ] }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
+  context "when sending a Flow Mod with SetIpTos" do
+    let( :type_of_service ) { 4 }
 
-describe SetIpTos, ".new( VALID OPTION )" do
-  context "when sending #flow_mod(add) with action set to mod_nw_tos" do
-    it "should have a flow with action set to mod_nw_tos" do
-      class FlowModAddController < Controller; end
+    it "should insert a new flow entry with action (mod_nw_tos:4)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => SetIpTos.new( 4 ) )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /mod_nw_tos:4/ )
+      }.run( TestController ) {
+        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+        sleep 2
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "mod_nw_tos:4" )
       }
     end
   end

data/spec/trema/set-transport-dst-port_spec.rb

@@ -20,39 +20,38 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe SetTransportDstPort, "new( number )" do
-  subject { SetTransportDstPort.new number }
+describe SetTransportDstPort, "new( port_number )", :type => "actions" do
+  subject { SetTransportDstPort.new port_number }
 
-  context "when number == 5555" do
-    let( :number ) { 5555 }
+  context "with port_number (5555)" do
+    let( :port_number ) { 5555 }
     its( :port_number ) { should == 5555 }
   end
 
-  it_validates "option range", :number, 0..( 2 ** 16 - 1 )
-end
-
-
-describe SetTransportDstPort, ".new( string )" do
-  it { expect { SetTransportDstPort.new( "5555" ) }.to raise_error( TypeError ) }
-end
+  it_validates "option is within range", :port_number, 0..( 2 ** 16 - 1 )
 
+  context %{with invalid port_number ("5555")} do
+    let( :port_number ) { "5555" }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
-describe SetTransportDstPort, ".new( array )" do
-  it { expect { SetTransportDstPort.new( [ 1, 2, 3 ] ) }.to raise_error( TypeError ) }
-end
+  context %{with invalid port_number ([1, 2, 3])} do
+    let( :port_number ) { [ 1, 2, 3 ] }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
+  context "when sending a Flow Mod with SetTransportDstPort" do
+    let( :port_number ) { 5555 }
 
-describe SetTransportDstPort, ".new( VALID OPTION )" do
-  context "when sending #flow_mod(add) with action set to mod_tp_dst" do
-    it "should have a flow with action set to mod_tp_dst" do
-      class FlowModAddController < Controller; end
+    it "should insert a new flow entry with action (mod_tp_dst:5555)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => SetTransportDstPort.new( 5555 ) )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /mod_tp_dst:5555/ )
+      }.run( TestController ) {
+        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+        sleep 2
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "mod_tp_dst:5555" )
       }
     end
   end

data/spec/trema/set-transport-src-port_spec.rb

@@ -20,39 +20,38 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe SetTransportSrcPort, "new( number )" do
-  subject { SetTransportSrcPort.new number }
+describe SetTransportSrcPort, "new( port_number )", :type => "actions" do
+  subject { SetTransportSrcPort.new port_number }
 
-  context "when number == 5555" do
-    let( :number ) { 5555 }
+  context "with port_number (5555)" do
+    let( :port_number ) { 5555 }
     its( :port_number ) { should == 5555 }
   end
 
-  it_validates "option range", :number, 0..( 2 ** 16 - 1 )
-end
-
-
-describe SetTransportSrcPort, ".new( string )" do
-  it { expect { SetTransportSrcPort.new( "5555" ) }.to raise_error( TypeError ) }
-end
+  it_validates "option is within range", :port_number, 0..( 2 ** 16 - 1 )
 
+  context %{with invalid port_number ("5555")} do
+    let( :port_number ) { "5555" }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
-describe SetTransportSrcPort, ".new( array )" do
-  it { expect { SetTransportSrcPort.new( [ 1, 2, 3 ] ) }.to raise_error( TypeError ) }
-end
+  context %{with invalid port_number ([1, 2, 3])} do
+    let( :port_number ) { [ 1, 2, 3 ] }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
+  context "when sending a Flow Mod with SetTransportSrcPort" do
+    let( :port_number ) { 5555 }
 
-describe SetTransportSrcPort, ".new( VALID OPTION )" do
-  context "when sending #flow_mod(add) with action set to mod_tp_src" do
-    it "should have a flow with action set to mod_tp_src" do
-      class FlowModAddController < Controller; end
+    it "should insert a new flow entry with action (mod_tp_src:5555)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => SetTransportSrcPort.new( 5555 ) )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /mod_tp_src:5555/ )
+      }.run( TestController ) {
+        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+        sleep 2
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "mod_tp_src:5555" )
       }
     end
   end

data/spec/trema/set-vlan-priority_spec.rb

@@ -20,39 +20,38 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe SetVlanPriority, ".new( number )" do
+describe SetVlanPriority, ".new(vlan_priority)", :type => "actions" do
   subject { SetVlanPriority.new( vlan_priority ) }
 
-  context "when vlan_priority == 4" do
+  context "with vlan_priority (4)" do
     let( :vlan_priority ) { 4 }
     its( :vlan_priority ) { should == 4 }
   end
 
-  it_validates "option range", :vlan_priority, 0..7
-end
-
-
-describe SetVlanPriority, %{.new( "4" )} do
-  it { expect { SetVlanPriority.new( "4" ) }.to raise_error( TypeError ) }
-end
+  it_validates "option is within range", :vlan_priority, 0..7
 
+  context %{with vlan_priority ("4")} do
+    let( :vlan_priority ) { "4" }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
-describe SetVlanPriority, ".new( [ 4 ] )" do
-  it { expect { SetVlanPriority.new( [ 4 ] ) }.to raise_error( TypeError ) }
-end
+  context "with vlan_priority ([4])" do
+    let( :vlan_priority ) { [ 4 ] }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
+  context "when sending a Flow Mod with SetVlanVid" do
+    let( :vlan_priority ) { 7 }
 
-describe SetVlanPriority, ".new( VALID OPTION )" do
-  context "when sending #flow_mod(add) with action set to mod_vlan_pcp" do
-    it "should have a flow with action set to mod_vlan_pcp" do
-      class FlowModAddController < Controller; end
+    it "should insert a new flow with action (mod_vlan_pcp:7)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => SetVlanPriority.new( 7 ) )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /mod_vlan_pcp:7/ )
+      }.run( TestController ) {
+        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+        sleep 2
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "mod_vlan_pcp:7" )
       }
     end
   end

data/spec/trema/set-vlan-vid_spec.rb

@@ -20,39 +20,38 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe SetVlanVid, ".new( number )" do
+describe SetVlanVid, ".new(vlan_id)", :type => "actions" do
   subject { SetVlanVid.new( vlan_id ) }
 
-  context "when vlan_id == 1024" do
+  context "with vlan_id (1024)" do
     let( :vlan_id ) { 1024 }
     its( :vlan_id ) { should == 1024 }
   end
 
-  it_validates "option range", :vlan_id, 1..4095
-end
-
-
-describe SetVlanVid, %{.new( "1024" )} do
-  it { expect { SetVlanVid.new( "1024" ) }.to raise_error( TypeError ) }
-end
+  it_validates "option is within range", :vlan_id, 1..4095
 
+  context %{with vlan_id ("1024")} do
+    let( :vlan_id ) { "1024" }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
-describe SetVlanVid, ".new( [ 1024 ] )" do
-  it { expect { SetVlanVid.new( [ 1024 ] ) }.to raise_error( TypeError ) }
-end
+  context "with vlan_id ([1024])" do
+    let( :vlan_id ) { [ 1024 ] }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
+  context "when sending a Flow Mod with SetVlanVid" do
+    let( :vlan_id ) { 1024 }
 
-describe SetVlanVid, ".new( VALID OPTION )" do
-  context "when sending #flow_mod(add) with action set to mod_vlan_vid" do
-    it "should have a flow with action set to mod_vlan_vid" do
-      class FlowModAddController < Controller; end
+    it "should insert a new flow entry with action (mod_vlan_vid:1024)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => SetVlanVid.new( 1024 ) )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /mod_vlan_vid:1024/ )
+      }.run( TestController ) {
+        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+        sleep 2
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "mod_vlan_vid:1024" )
       }
     end
   end

data/spec/trema/shell/vhost_spec.rb

@@ -31,8 +31,8 @@ describe Trema::Shell, ".vhost" do
   it "should create a new vhost if name given" do
     Trema::Shell.vhost( "host1" )
 
-    Trema::Host.should have( 1 ).host
-    Trema::Host[ "host1" ].name.should == "host1"
+    expect( Trema::Host ).to have( 1 ).host
+    expect( Trema::Host[ "host1" ].name ).to eq( "host1" )
   end
 
 
@@ -44,11 +44,11 @@ describe Trema::Shell, ".vhost" do
       mac "00:00:00:1:1:1"
     }
 
-    Trema::Host.should have( 1 ).host
-    Trema::Host[ "host1" ].name.should == "host1"
-    Trema::Host[ "host1" ].ip.should == "192.168.100.1"
-    Trema::Host[ "host1" ].promisc.should be_true
-    Trema::Host[ "host1" ].mac.should == "00:00:00:1:1:1"
+    expect( Trema::Host ).to have( 1 ).host
+    expect( Trema::Host[ "host1" ].name ).to eq( "host1" )
+    expect( Trema::Host[ "host1" ].ip ).to eq( "192.168.100.1" )
+    expect( Trema::Host[ "host1" ].promisc ).to be_true
+    expect( Trema::Host[ "host1" ].mac ).to eq( "00:00:00:1:1:1" )
   end
 end
 

data/spec/trema/shell/vswitch_spec.rb

@@ -51,20 +51,20 @@ describe Trema::Shell, ".vswitch" do
 
     it "should create a new vswitch if name given" do
       Trema::Shell.vswitch { dpid "0xabc" }
-      Trema::OpenflowSwitch.should have( 1 ).switch
-      Trema::OpenflowSwitch[ "0xabc" ].name.should == "0xabc"
-      Trema::OpenflowSwitch[ "0xabc" ].dpid_short.should == "0xabc"
-      Trema::OpenflowSwitch[ "0xabc" ].dpid_long.should == "0000000000000abc"
+      expect( Trema::OpenflowSwitch ).to have( 1 ).switch
+      expect( Trema::OpenflowSwitch[ "0xabc" ].name ).to eq( "0xabc" )
+      expect( Trema::OpenflowSwitch[ "0xabc" ].dpid_short ).to eq( "0xabc" )
+      expect( Trema::OpenflowSwitch[ "0xabc" ].dpid_long ).to eq( "0000000000000abc" )
     end
 
 
     it "should create a new vswitch if dpid given" do
       Trema::Shell.vswitch "0xabc"
 
-      Trema::OpenflowSwitch.should have( 1 ).switch
-      Trema::OpenflowSwitch[ "0xabc" ].name.should == "0xabc"
-      Trema::OpenflowSwitch[ "0xabc" ].dpid_short.should == "0xabc"
-      Trema::OpenflowSwitch[ "0xabc" ].dpid_long.should == "0000000000000abc"
+      expect( Trema::OpenflowSwitch ).to have( 1 ).switch
+      expect( Trema::OpenflowSwitch[ "0xabc" ].name ).to eq( "0xabc" )
+      expect( Trema::OpenflowSwitch[ "0xabc" ].dpid_short ).to eq( "0xabc" )
+      expect( Trema::OpenflowSwitch[ "0xabc" ].dpid_long ).to eq( "0000000000000abc" )
     end
 
 

data/spec/trema/stats-reply_spec.rb

@@ -190,11 +190,11 @@ describe StatsReply, ".new( VALID OPTIONS )" do
         vswitch( "desc-stats" ) { datapath_id 0xabc }
       }.run( DescStatsController ) {
         controller( "DescStatsController" ).should_receive( :stats_reply ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == 0
-          message.stats[ 0 ].mfr_desc.should eq( "Nicira Networks, Inc." )
-          message.stats[ 0 ].hw_desc.should eq( "Open vSwitch" )
-          message.stats[ 0 ].should respond_to :to_s
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( 0 )
+          expect( message.stats[ 0 ].mfr_desc ).to eq( "Nicira Networks, Inc." )
+          expect( message.stats[ 0 ].hw_desc ).to eq( "Open vSwitch" )
+          expect( message.stats[ 0 ] ).to respond_to :to_s
         end
 
         controller( "DescStatsController" ).send_message( 0xabc,
@@ -228,10 +228,10 @@ describe StatsReply, ".new( VALID OPTIONS )" do
         sleep 2 # FIXME: wait to send_packets
 
         controller( "FlowStatsController" ).should_receive( :stats_reply ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == 1
-          message.stats[ 0 ].packet_count.should == 2
-          message.stats[ 0 ].should respond_to :to_s
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( 1 )
+          expect( message.stats[ 0 ].packet_count ).to eq( 2 )
+          expect( message.stats[ 0 ] ).to respond_to :to_s
         end
         match = Match.new( :dl_type =>0x800, :nw_proto => 17 )
         controller( "FlowStatsController" ).send_message( 0xabc,
@@ -265,11 +265,11 @@ describe StatsReply, ".new( VALID OPTIONS )" do
         sleep 2 # FIXME: wait to send_packets
 
         controller( "AggregateStatsController" ).should_receive( :stats_reply ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == 2
-          message.stats[ 0 ].packet_count.should == 10
-          message.stats[ 0 ].flow_count.should == 1
-          message.stats[ 0 ].should respond_to :to_s
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( 2 )
+          expect( message.stats[ 0 ].packet_count ).to eq( 10 )
+          expect( message.stats[ 0 ].flow_count ).to eq( 1 )
+          expect( message.stats[ 0 ] ).to respond_to :to_s
         end
         match = Match.new( :dl_type =>0x800, :nw_proto => 17 )
         controller( "AggregateStatsController" ).send_message( 0xabc,
@@ -300,10 +300,10 @@ describe StatsReply, ".new( VALID OPTIONS )" do
         sleep 2 # FIXME: wait to send_packets
 
         controller( "PortStatsController" ).should_receive( :stats_reply ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == 4
-          message.stats[ 0 ].should be_an_instance_of( Trema::PortStatsReply )
-          message.stats[ 0 ].should respond_to :to_s
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( 4 )
+          expect( message.stats[ 0 ] ).to be_an_instance_of( Trema::PortStatsReply )
+          expect( message.stats[ 0 ] ).to respond_to :to_s
         end
         controller( "PortStatsController" ).send_message( 0xabc,
           PortStatsRequest.new( :port_no => 1 ) )
@@ -332,11 +332,11 @@ describe StatsReply, ".new( VALID OPTIONS )" do
         sleep 2 # FIXME: wait to send_packets
 
         controller( "TableStatsController" ).should_receive( :stats_reply ) do | datapath_id, message |
-          datapath_id.should == 0xabc
-          message.type.should == 3
-          message.transaction_id.should == 123
-          message.stats[ 0 ].should be_an_instance_of(Trema::TableStatsReply)
-          message.stats[ 0 ].should respond_to :to_s
+          expect( datapath_id ).to eq( 0xabc )
+          expect( message.type ).to eq( 3 )
+          expect( message.transaction_id ).to eq( 123 )
+          expect( message.stats[ 0 ] ).to be_an_instance_of(Trema::TableStatsReply)
+          expect( message.stats[ 0 ] ).to respond_to :to_s
         end
         controller( "TableStatsController" ).send_message( 0xabc,
           TableStatsRequest.new( :transaction_id => 123 ) )

data/spec/trema/strip-vlan-header_spec.rb

@@ -20,17 +20,17 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe StripVlanHeader, ".new" do
-  context "when sending #flow_mod(add) with action set to strip_vlan" do
-    it "should have a flow with action set to strip_vlan" do
-      class FlowModAddController < Controller; end
+describe StripVlanHeader, :type => "actions" do
+  context "when sending a Flow Mod with StripVlanHeader" do
+    it "should insert a new flow entry with action (strip_vlan)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => StripVlanHeader.new )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[ 0 ].actions.should match( /strip_vlan/ )
+      }.run( TestController ) {
+        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+        sleep 2
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "strip_vlan" )
       }
     end
   end