trema 0.3.3 → 0.3.4

data/spec/trema/packet-out_spec.rb

@@ -41,16 +41,14 @@ end
 describe "packet-out" do
   context "a controller instance" do
     it "should respond to #send_packet_out" do
-      PacketOutController.new.should respond_to(:send_packet_out)
+      expect( PacketOutController.new ).to respond_to(:send_packet_out)
     end
   end
 
 
   context "when invoked with no datapath_id" do
     it "should raise an error" do
-      lambda do
-        PacketOutController.new.send_packet_out
-      end.should raise_error("wrong number of arguments (0 for 1)")
+      expect { PacketOutController.new.send_packet_out }.to raise_error("wrong number of arguments (0 for 1)")
     end
   end
 
@@ -66,7 +64,7 @@ describe "packet-out" do
       }.run( PacketOutController ) {
         send_packets "host2", "host1"
         sleep 2
-        vhost( "host1" ).rx_stats.n_pkts.should == 1
+        expect( vhost( "host1" ).rx_stats.n_pkts ).to eq( 1 )
       }
     end
   end
@@ -114,7 +112,7 @@ describe "packet-out" do
           :actions => Trema::ActionOutput.new( :port => 1 )
         )
         sleep 2
-        vhost( "host2" ).rx_stats.n_pkts.should == 1
+        expect( vhost( "host2" ).rx_stats.n_pkts ).to eq( 1 )
       }
     end
   end

data/spec/trema/port-mod_spec.rb

@@ -33,7 +33,7 @@ describe PortMod, ".new( VALID OPTIONS )" do
     )
   }
   its( :port_no ) { should == 2 }
-  its( :hw_addr ) { subject.to_s.should eq "11:22:33:44:55:66" }
+  its( "hw_addr.to_s" ) { should eq "11:22:33:44:55:66" }
   its( :config ) { should == 1 }
   its( :mask ) { should == 1 }
   its( :advertise ) { should == 0 }
@@ -42,46 +42,45 @@ describe PortMod, ".new( VALID OPTIONS )" do
 
   describe "hw_addr" do
     it "should be a Trema::Mac object" do
-      PortMod.new(
-        :port_no => 2,
-        :hw_addr => Mac::new( "11:22:33:44:55:66" ),
-        :config => 1,
-        :mask => 1,
-        :advertise => 0
-      ).hw_addr.to_s.should eq( "11:22:33:44:55:66" )
+      expect( PortMod.new(
+               :port_no => 2,
+               :hw_addr => Mac::new( "11:22:33:44:55:66" ),
+               :config => 1,
+               :mask => 1,
+               :advertise => 0
+             ).hw_addr.to_s ).to eq( "11:22:33:44:55:66" )
     end
 
 
     it "should be a string('11:22:33:44:55')" do
-      PortMod.new(
-        :port_no => 2,
-        :hw_addr => "11:22:33:44:55:66",
-        :config => 1,
-        :mask => 1,
-        :advertise => 0 ).hw_addr.to_s.should eq( "11:22:33:44:55:66" )
+      expect( PortMod.new(
+               :port_no => 2,
+               :hw_addr => "11:22:33:44:55:66",
+               :config => 1,
+               :mask => 1,
+               :advertise => 0 ).hw_addr.to_s ).to eq( "11:22:33:44:55:66" )
     end
 
 
     it "should be a number(281474976710655)" do
-      PortMod.new(
-        :port_no => 2,
-        :hw_addr => 281474976710655,
-        :config => 1,
-        :mask => 1,
-        :advertise => 0 ).hw_addr.to_s.should eq( "ff:ff:ff:ff:ff:ff" )
+      expect( PortMod.new(
+               :port_no => 2,
+               :hw_addr => 281474976710655,
+               :config => 1,
+               :mask => 1,
+               :advertise => 0 ).hw_addr.to_s ).to eq( "ff:ff:ff:ff:ff:ff" )
     end
 
 
     it "should otherwise raise ArgumentError" do
-      lambda do
-        PortMod.new(
-          :port_no => 2,
-          :hw_addr => Array.new( 1234 ),
-          :config => 1,
-          :mask => 1,
-          :advertise => 0
-        )
-      end.should raise_error ArgumentError
+      expect { PortMod.new(
+                :port_no => 2,
+                :hw_addr => Array.new( 1234 ),
+                :config => 1,
+                :mask => 1,
+                :advertise => 0
+               )
+             }.to raise_error( ArgumentError )
     end
   end
 end

data/spec/trema/port-status-modify_spec.rb

@@ -51,8 +51,8 @@ module Trema
           link "host", "0xabc"
         }.run( PortStatusController ) {
           controller( "PortStatusController" ).should_receive( :port_status ).with do | dpid, message |
-            dpid.should == 0xabc
-            message.should be_an_instance_of( PortStatusModify )
+            expect( dpid ).to eq( 0xabc )
+            expect( message ).to be_an_instance_of( PortStatusModify )
           end
 
           controller( "PortStatusController" ).send_message 0xabc, FeaturesRequest.new

data/spec/trema/port_spec.rb

@@ -25,31 +25,31 @@ require "trema"
 describe Trema::Port do
   it "should have its port number" do
     port = Trema::Port.new( :number => 123 )
-    port.number.should == 123
+    expect( port.number ).to be( 123 )
   end
 
   it "should check the port up" do
     port = Trema::Port.new( :config => 0, :state => 0 )
-    port.up?.should == true
-    port.down?.should == false
+    expect( port.up? ).to be_true
+    expect( port.down? ).to be_false
   end
 
   it "should check the port down(config=0,state=1)" do
     port = Trema::Port.new( :config => 0, :state => 1 )
-    port.up?.should == false
-    port.down?.should == true
+    expect( port.up? ).to be_false
+    expect( port.down? ).to be_true
   end
 
   it "should check the port down(config=1,state=0)" do
     port = Trema::Port.new( :config => 1, :state => 0 )
-    port.up?.should == false
-    port.down?.should == true
+    expect( port.up? ).to be_false
+    expect( port.down? ).to be_true
   end
 
   it "should check the port down(config=1,state=1)" do
     port = Trema::Port.new( :config => 1, :state => 1 )
-    port.up?.should == false
-    port.down?.should == true
+    expect( port.up? ).to be_false
+    expect( port.down? ).to be_true
   end
 end
 

data/spec/trema/queue-get-config-reply_spec.rb

@@ -34,8 +34,8 @@ describe QueueGetConfigReply, ".new( VALID OPTIONS )" do
       :queues => Queue.queues
     )
   end
-  its( :queues ) { subject.length.should ==  2  }
-  its( :queues ) { subject[0].should be_an_instance_of PacketQueue }
+  its( "queues.length" ) { should ==  2  }
+  its( "queues.first" ) { should be_an_instance_of PacketQueue }
   its( :datapath_id ) { should == 0xabc }
   its( :transaction_id ) { should == 123 }
 end

data/spec/trema/send-out-port_spec.rb

@@ -21,63 +21,73 @@ require "trema"
 
 
 describe SendOutPort, :type => "actions" do
-  context "#new( 1 )" do
-    subject { SendOutPort.new( 1 ) }
+  describe "#new(port_number)" do
+    subject( :send_out_port ) { SendOutPort.new( port_number ) }
 
-    its( :port_number ) { should == 1 }
-    its( :max_len ) { should == 2 ** 16 - 1 }
-    its( :to_s ) { should == "SendOutPort: port=1, max_len=65535" }
-  end
 
-  context "#new( :port_number => number )" do
-    subject { SendOutPort.new( :port_number => number ) }
+    context "with port_number (1)" do
+      let( :port_number ) { 1 }
 
-    context "with port number (1)" do
-      let( :number ) { 1 }
-      its( :port_number ) { should == 1 }
-      its( :to_s ) { should == "SendOutPort: port=1, max_len=65535" }
+      its( :port_number ) { should eq( 1 ) }
+      its( :max_len ) { should eq( 2 ** 16 - 1 ) }
+      its( :to_s ) { should eq( "SendOutPort: port_number=1, max_len=65535" ) }
     end
 
-    it_validates "option range", :number, 0..( 2 ** 16 - 1 )
-  end
 
-  context "#new( :port_number => 1, :max_len => number )" do
-    subject { SendOutPort.new( :port_number => 1, :max_len => max_len ) }
+    context "with port_number (10)" do
+      let( :port_number ) { 10 }
 
-    context "with :max_len == 256" do
-      let( :max_len ) { 256 }
-      its( :max_len ) { should == 256 }
-      its( :to_s ) { should == "SendOutPort: port=1, max_len=256" }
+      context "when set as FlowMod's action", :sudo => true do
+        it "should insert a new flow entry with action (output:10)" do
+          class TestController < Controller; end
+          network {
+            vswitch { datapath_id 0xabc }
+          }.run( TestController ) {
+            controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => send_out_port )
+            sleep 2
+            expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+            expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "output:10" )
+          }
+        end
+      end
     end
 
-    it_validates "option range", :max_len, 0..( 2 ** 16 - 1 )
+
+    it_validates "option is within range", :port_number, 0..( 2 ** 16 - 1 )
   end
 
-  context "when sending a Flow Mod with SendOutPort action" do
-    it "should insert a new flow entry with action (output:1)" do
-      class TestController < Controller; end
-      network {
-        vswitch { datapath_id 0xabc }
-      }.run( TestController ) {
-        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => SendOutPort.new( 1 ) )
-        sleep 2
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[ 0 ].actions.should == "output:1"
-      }
+
+  describe "#new(:port_number => value)" do
+    subject { SendOutPort.new( :port_number => port_number ) }
+
+
+    context "with option (:port_number => 1)" do
+      let( :port_number ) { 1 }
+
+      its( :port_number ) { should eq( 1 ) }
+      its( :max_len ) { should eq( 2 ** 16 - 1 ) }
+      its( :to_s ) { should eq( "SendOutPort: port_number=1, max_len=65535" ) }
     end
   end
 
-  context "when sending a Flow Mod with multiple SendOutPort actions" do
-    it "should insert a new flow entry with actions (output:1\/output:2)" do
-      class TestController < Controller; end
-      network {
-        vswitch { datapath_id 0xabc }
-      }.run( TestController ) {
-        controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => [ SendOutPort.new( 1 ), SendOutPort.new( 2 ) ] )
-        sleep 2
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[ 0 ].actions.should match( /output:1\/output:2/ )
-      }
+
+  describe "#new(:port_number => value1, :max_len => value2)" do
+    subject { SendOutPort.new( options ) }
+
+
+    context "with options (:port_number => 1, :max_len => 256)" do
+      let( :options ) { { :port_number => 1, :max_len => 256 } }
+
+      its( :port_number ) { should eq( 1 ) }
+      its( :max_len ) { should eq( 256 ) }
+      its( :to_s ) { should eq( "SendOutPort: port_number=1, max_len=256" ) }
+    end
+
+
+    context "with options (:port_number => 1, :max_len => max_len)" do
+      let( :options ) { { :port_number => 1, :max_len => max_len } }
+
+      it_validates "option is within range", :max_len, 0..( 2 ** 16 - 1 )
     end
   end
 end

data/spec/trema/set-config_spec.rb

@@ -59,8 +59,8 @@ describe SetConfig, ".new( VALID OPTIONS )" do
         vswitch { datapath_id 0xabc }
       }.run( SetConfigController ) {
         controller( "SetConfigController" ).should_receive( :get_config_reply ) do | dpid, arg |
-          arg.flags.should == 0
-          arg.miss_send_len.should == 0
+          expect( arg.flags ).to eq( 0 )
+          expect( arg.miss_send_len ).to eq( 0 )
         end
         set_config = SetConfig.new( :flags => 0, :miss_send_len => 0, :transaction_id => 123 )
         controller( "SetConfigController" ).send_message( 0xabc, set_config )

data/spec/trema/set-eth-dst-addr_spec.rb

@@ -51,7 +51,7 @@ describe SetEthDstAddr, ".new( mac_address )", :type => "actions" do
     it { expect { subject }.to raise_error( TypeError ) }
   end
 
-  it_validates "option range", :mac_address, 0..0xffffffffffff
+  it_validates "option is within range", :mac_address, 0..0xffffffffffff
 
   context "when sending a Flow Mod with action set to SetEthDstAddr" do
     let( :mac_address ) { "52:54:00:a8:ad:8c" }
@@ -63,8 +63,8 @@ describe SetEthDstAddr, ".new( mac_address )", :type => "actions" do
       }.run( TestController ) {
         controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
         sleep 2
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[ 0 ].actions.should == "mod_dl_dst:52:54:00:a8:ad:8c"
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "mod_dl_dst:52:54:00:a8:ad:8c" )
       }
     end
   end

data/spec/trema/set-eth-src-addr_spec.rb

@@ -51,7 +51,7 @@ describe SetEthSrcAddr, ".new( mac_address )", :type => "actions" do
     it { expect { subject }.to raise_error( TypeError ) }
   end
 
-  it_validates "option range", :mac_address, 0..0xffffffffffff
+  it_validates "option is within range", :mac_address, 0..0xffffffffffff
 
   context "when sending a Flow Mod with action set to SetEthSrcAddr" do
     let( :mac_address ) { "52:54:00:a8:ad:8c" }
@@ -63,8 +63,8 @@ describe SetEthSrcAddr, ".new( mac_address )", :type => "actions" do
       }.run( TestController ) {
         controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
         sleep 2
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[ 0 ].actions.should == "mod_dl_src:52:54:00:a8:ad:8c"
+        expect( vswitch( "0xabc" ) ).to have( 1 ).flows
+        expect( vswitch( "0xabc" ).flows[ 0 ].actions ).to eq( "mod_dl_src:52:54:00:a8:ad:8c" )
       }
     end
   end

data/spec/trema/set-ip-dst-addr_spec.rb

@@ -20,32 +20,36 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe SetIpDstAddr, ".new(ip_address)" do
+describe SetIpDstAddr, ".new(ip_address)", :type => "actions" do
   subject { SetIpDstAddr.new( ip_address ) }
 
-  context %{when "192.168.1.1"} do
+  context %{with ip_address ("192.168.1.1")} do
     let( :ip_address ) { "192.168.1.1" }
-    its( :ip_address ) { should == IPAddr.new( "192.168.1.1" ) }
+    its( "ip_address.to_s" ) { should == "192.168.1.1" }
   end
-end
 
+  context %{with invalid ip_address ("192.168.1")} do
+    let( :ip_address ) { "192.168.1" }
+    it { expect { subject }.to raise_error( ArgumentError ) }
+  end
 
-describe ActionSetTpDst, ".new( array )" do
-  it { expect { ActionSetTpDst.new( [ 1, 2, 3 ] ) }.to raise_error( TypeError ) }
-end
+  context "with invalid ip_address ([1, 2, 3])" do
+    let( :ip_address ) { [ 1, 2, 3 ] }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
+  context "when sending a Flow Mod with SetIpDstAddr" do
+    let( :ip_address ) { "192.168.1.1" }
 
-describe SetIpDstAddr, ".new( VALID OPTION )" do
-  context "when sending #flow_mod(add) with action set to mod_nw_dst" do
-    it "should have a flow with action set to mod_nw_dst" do
-      class FlowModAddController < Controller; end
+    it "should insert a flow entry with action (mod_nw_dst:192.168.1.1)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => SetIpDstAddr.new( "192.168.1.1" ) )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /mod_nw_dst:192.168.1.1/ )
+      }.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_dst:192.168.1.1" )
       }
     end
   end

data/spec/trema/set-ip-src-addr_spec.rb

@@ -20,32 +20,36 @@ require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
 require "trema"
 
 
-describe SetIpSrcAddr, ".new(ip_address)" do
+describe SetIpSrcAddr, ".new(ip_address)", :type => "actions" do
   subject { SetIpSrcAddr.new( ip_address ) }
 
-  context %{when "192.168.1.1"} do
+  context %{with ip_address ("192.168.1.1")} do
     let( :ip_address ) { "192.168.1.1" }
-    its( :ip_address ) { should == IPAddr.new( "192.168.1.1" ) }
+    its( "ip_address.to_s" ) { should == "192.168.1.1" }
   end
-end
 
+  context %{with invalid ip_address ("192.168.1")} do
+    let( :ip_address ) { "192.168.1" }
+    it { expect { subject }.to raise_error( ArgumentError ) }
+  end
 
-describe ActionSetTpSrc, ".new( array )" do
-  it { expect { ActionSetTpSrc.new( [ 1, 2, 3 ] ) }.to raise_error( TypeError ) }
-end
+  context "with invalid ip_address ([1, 2, 3])" do
+    let( :ip_address ) { [ 1, 2, 3 ] }
+    it { expect { subject }.to raise_error( TypeError ) }
+  end
 
+  context "when sending a Flow Mod with SetIpSrcAddr" do
+    let( :ip_address ) { "192.168.1.1" }
 
-describe SetIpSrcAddr, ".new( VALID OPTION )" do
-  context "when sending #flow_mod(add) with action set to mod_nw_src" do
-    it "should have a flow with action set to mod_nw_src" do
-      class FlowModAddController < Controller; end
+    it "should insert a flow entry with action (mod_nw_src:192.168.1.1)" do
+      class TestController < Controller; end
       network {
         vswitch { datapath_id 0xabc }
-      }.run( FlowModAddController ) {
-        controller( "FlowModAddController" ).send_flow_mod_add( 0xabc, :actions => SetIpSrcAddr.new( "192.168.1.1" ) )
-        sleep 2 # FIXME: wait to send_flow_mod_add
-        vswitch( "0xabc" ).should have( 1 ).flows
-        vswitch( "0xabc" ).flows[0].actions.should match( /mod_nw_src:192.168.1.1/ )
+      }.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_src:192.168.1.1" )
       }
     end
   end