trema 0.4.6 → 0.4.7

data/spec/trema/link_spec.rb

@@ -16,37 +16,37 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema/link"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema/link'
 
 
 module Trema
   describe Link do
     before :each do
       Trema::Link.instances.clear
-      @stanza = mock( "link stanza", :peers => [ "Virtual Host", "Virtual Switch" ] )
+      @stanza = mock('link stanza', :peers => ['Virtual Host', 'Virtual Switch'])
     end
 
 
-    context "when creating/deleting a link" do
+    context 'when creating/deleting a link' do
       before :each do
-        @link = Link.new( @stanza )
+        @link = Link.new(@stanza)
       end
 
 
-      it "executes ip and ifconfig command" do
-        @link.should_receive( :sh ).once.ordered.with( "sudo ip link add name trema0-0 type veth peer name trema0-1" )
-        @link.should_receive( :sh ).once.ordered.with( "sudo /sbin/sysctl -w net.ipv6.conf.trema0-0.disable_ipv6=1 >/dev/null 2>&1" )
-        @link.should_receive( :sh ).once.ordered.with( "sudo /sbin/sysctl -w net.ipv6.conf.trema0-1.disable_ipv6=1 >/dev/null 2>&1" )
-        @link.should_receive( :sh ).once.ordered.with( "sudo /sbin/ifconfig trema0-0 up" )
-        @link.should_receive( :sh ).once.ordered.with( "sudo /sbin/ifconfig trema0-1 up" )
+      it 'executes ip and ifconfig command' do
+        @link.should_receive(:sh).once.ordered.with('sudo ip link add name trema0-0 type veth peer name trema0-1')
+        @link.should_receive(:sh).once.ordered.with('sudo /sbin/sysctl -w net.ipv6.conf.trema0-0.disable_ipv6=1 >/dev/null 2>&1')
+        @link.should_receive(:sh).once.ordered.with('sudo /sbin/sysctl -w net.ipv6.conf.trema0-1.disable_ipv6=1 >/dev/null 2>&1')
+        @link.should_receive(:sh).once.ordered.with('sudo /sbin/ifconfig trema0-0 up')
+        @link.should_receive(:sh).once.ordered.with('sudo /sbin/ifconfig trema0-1 up')
 
         @link.enable!
       end
 
 
-      it "executes ip and ifconfig command" do
-        @link.should_receive( :sh ).once.with( "sudo ip link delete trema0-0 2>/dev/null" )
+      it 'executes ip and ifconfig command' do
+        @link.should_receive(:sh).once.with('sudo ip link delete trema0-0 2>/dev/null')
 
         @link.delete!
       end

data/spec/trema/list-switches-reply_spec.rb

@@ -16,24 +16,24 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
 describe Controller do
-  context "when #list_switches_request is sent" do
-    it "should receive #list_switches_reply" do
+  context 'when #list_switches_request is sent' do
+    it 'should receive #list_switches_reply' do
       class ListSwitchesController < Controller; end
-      network {
+      network do
         vswitch { datapath_id 0x1 }
         vswitch { datapath_id 0x2 }
         vswitch { datapath_id 0x3 }
-      }.run( ListSwitchesController ) {
-        controller( "ListSwitchesController" ).should_receive( :list_switches_reply ) do | dpids |
-          expect( dpids ).to eq( [ 0x1, 0x2, 0x3 ] )
+      end.run(ListSwitchesController) do
+        controller('ListSwitchesController').should_receive(:list_switches_reply) do | dpids |
+          expect(dpids).to eq([0x1, 0x2, 0x3])
         end
-        controller( "ListSwitchesController" ).send_list_switches_request
-      }
+        controller('ListSwitchesController').send_list_switches_request
+      end
     end
   end
 end

data/spec/trema/match_spec.rb

@@ -16,90 +16,90 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-describe Match, ".new" do
-  subject {
+describe Match, '.new' do
+  subject do
     Match.new(
       :in_port => 1,
-      :dl_src => "00:00:00:00:00:01",
-      :dl_dst => "00:00:00:00:00:02",
+      :dl_src => '00:00:00:00:00:01',
+      :dl_dst => '00:00:00:00:00:02',
       :dl_vlan => 65535,
       :dl_vlan_pcp => 0,
       :dl_type => 0x800,
       :nw_tos => 0,
       :nw_proto => 17,
-      :nw_src => "192.168.0.1",
-      :nw_dst => "192.168.0.0/24",
+      :nw_src => '192.168.0.1',
+      :nw_dst => '192.168.0.0/24',
       :tp_src => 10,
       :tp_dst => 20
     )
-  }
-  its( :in_port ) { should == 1 }
-  its( "dl_src.to_s" ) { should == "00:00:00:00:00:01" }
-  its( "dl_dst.to_s" ) { should == "00:00:00:00:00:02" }
-  its( :dl_vlan ) { should == 65535 }
-  its( :dl_vlan_pcp ) { should == 0 }
-  its( :dl_type ) { should == 0x800 }
-  its( :nw_tos ) { should == 0 }
-  its( :nw_proto ) { should == 17 }
-  its( "nw_src.to_s" ) { should == "192.168.0.1" }
-  its( "nw_src.prefixlen" ) { should == 32 }
-  its( "nw_dst.to_s" ) { should == "192.168.0.0" }
-  its( "nw_dst.prefixlen" ) { should == 24 }
-  its( :tp_src ) { should == 10 }
-  its( :tp_dst ) { should == 20 }
-  its( :to_s ) { should == "wildcards = 0x20000(nw_dst(8)), in_port = 1, dl_src = 00:00:00:00:00:01, dl_dst = 00:00:00:00:00:02, dl_vlan = 0xffff, dl_vlan_pcp = 0, dl_type = 0x800, nw_tos = 0, nw_proto = 17, nw_src = 192.168.0.1/32, nw_dst = 192.168.0.0/24, tp_src = 10, tp_dst = 20" }
+  end
+  its(:in_port) { should == 1 }
+  its('dl_src.to_s') { should == '00:00:00:00:00:01' }
+  its('dl_dst.to_s') { should == '00:00:00:00:00:02' }
+  its(:dl_vlan) { should == 65535 }
+  its(:dl_vlan_pcp) { should == 0 }
+  its(:dl_type) { should == 0x800 }
+  its(:nw_tos) { should == 0 }
+  its(:nw_proto) { should == 17 }
+  its('nw_src.to_s') { should == '192.168.0.1' }
+  its('nw_src.prefixlen') { should == 32 }
+  its('nw_dst.to_s') { should == '192.168.0.0' }
+  its('nw_dst.prefixlen') { should == 24 }
+  its(:tp_src) { should == 10 }
+  its(:tp_dst) { should == 20 }
+  its(:to_s) { should == 'wildcards = 0x20000(nw_dst(8)), in_port = 1, dl_src = 00:00:00:00:00:01, dl_dst = 00:00:00:00:00:02, dl_vlan = 0xffff, dl_vlan_pcp = 0, dl_type = 0x800, nw_tos = 0, nw_proto = 17, nw_src = 192.168.0.1/32, nw_dst = 192.168.0.0/24, tp_src = 10, tp_dst = 20' }
 end
 
 
-describe Match, ".compare" do
-  it "Should match" do
+describe Match, '.compare' do
+  it 'Should match' do
     tester = Match.new(
       :in_port => 1,
-      :dl_src => "00:00:00:00:00:01",
-      :dl_dst => "00:00:00:00:00:02",
+      :dl_src => '00:00:00:00:00:01',
+      :dl_dst => '00:00:00:00:00:02',
       :dl_vlan => 65535,
       :dl_vlan_pcp => 0,
       :dl_type => 0x800,
       :nw_tos => 0,
       :nw_proto => 17,
-      :nw_src => "192.168.0.1",
-      :nw_dst => "192.168.0.2",
+      :nw_src => '192.168.0.1',
+      :nw_dst => '192.168.0.2',
       :tp_src => 10,
       :tp_dst => 20
     )
     pattern = Match.new(
       :in_port => 1,
-      :nw_src => "192.168.0.0/24",
-      :nw_dst => "192.168.0.0/24"
+      :nw_src => '192.168.0.0/24',
+      :nw_dst => '192.168.0.0/24'
     )
-    expect( pattern.compare( tester ) ).to be_true
+    expect(pattern.compare(tester)).to be_true
   end
 
-  it "Should not match" do
+  it 'Should not match' do
     tester = Match.new(
       :in_port => 1,
-      :dl_src => "00:00:00:00:00:01",
-      :dl_dst => "00:00:00:00:00:02",
+      :dl_src => '00:00:00:00:00:01',
+      :dl_dst => '00:00:00:00:00:02',
       :dl_vlan => 65535,
       :dl_vlan_pcp => 0,
       :dl_type => 0x800,
       :nw_tos => 0,
       :nw_proto => 17,
-      :nw_src => "192.168.0.1",
-      :nw_dst => "192.168.0.2",
+      :nw_src => '192.168.0.1',
+      :nw_dst => '192.168.0.2',
       :tp_src => 10,
       :tp_dst => 20
     )
     pattern = Match.new(
       :in_port => 1,
-      :nw_src => "10.0.0.0/8",
-      :nw_dst => "10.0.0.0/8"
+      :nw_src => '10.0.0.0/8',
+      :nw_dst => '10.0.0.0/8'
     )
-    expect( pattern.compare( tester ) ).to be_false
+    expect(pattern.compare(tester)).to be_false
   end
 end
 

data/spec/trema/open-vswitch_spec.rb

@@ -16,8 +16,8 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema/open-vswitch"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema/open-vswitch'
 
 
 module Trema
@@ -31,80 +31,80 @@ module Trema
       end
     end
 
-    it "should keep a list of vswitches" do
-      OpenVswitch.new mock( "stanza 0", :name => "vswitch 0", :validate => true )
-      OpenVswitch.new mock( "stanza 1", :name => "vswitch 1", :validate => true )
-      OpenVswitch.new mock( "stanza 2", :name => "vswitch 2", :validate => true )
+    it 'should keep a list of vswitches' do
+      OpenVswitch.new mock('stanza 0', :name => 'vswitch 0', :validate => true)
+      OpenVswitch.new mock('stanza 1', :name => 'vswitch 1', :validate => true)
+      OpenVswitch.new mock('stanza 2', :name => 'vswitch 2', :validate => true)
 
-      expect( OpenflowSwitch ).to have( 3 ).vswitches
-      expect( OpenflowSwitch[ "vswitch 0" ] ).not_to be_nil
-      expect( OpenflowSwitch[ "vswitch 1" ] ).not_to be_nil
-      expect( OpenflowSwitch[ "vswitch 2" ] ).not_to be_nil
+      expect(OpenflowSwitch).to have(3).vswitches
+      expect(OpenflowSwitch[ 'vswitch 0']).not_to be_nil
+      expect(OpenflowSwitch[ 'vswitch 1']).not_to be_nil
+      expect(OpenflowSwitch[ 'vswitch 2']).not_to be_nil
     end
   end
 
 
-  describe OpenVswitch, %[dpid = "0xabc"] do
-    subject {
-      stanza = { :dpid_short => "0xabc", :dpid_long => "0000000000000abc", :ip => "127.0.0.1" }
-      stanza.stub!( :validate )
-      stanza.stub!( :name ).and_return( name )
+  describe OpenVswitch, 'dpid = 0xabc' do
+    subject do
+      stanza = { :dpid_short => '0xabc', :dpid_long => '0000000000000abc', :ip => '127.0.0.1' }
+      stanza.stub!(:validate)
+      stanza.stub!(:name).and_return(name)
       OpenVswitch.new stanza
-    }
+    end
 
 
-    context "when its name is not set" do
-      let( :name ) { "0xabc" }
+    context 'when its name is not set' do
+      let(:name) { '0xabc' }
 
-      its( :name ) { should == "0xabc" }
-      its( :dpid_short ) { should == "0xabc" }
-      its( :dpid_long ) { should == "0000000000000abc" }
-      its( :network_device ) { should == "vsw_0xabc" }
+      its(:name) { should == '0xabc' }
+      its(:dpid_short) { should == '0xabc' }
+      its(:dpid_long) { should == '0000000000000abc' }
+      its(:network_device) { should == 'vsw_0xabc' }
     end
 
 
-    context "when its name is set" do
-      let( :name ) { "Otosan Switch" }
+    context 'when its name is set' do
+      let(:name) { 'Otosan Switch' }
 
-      its( :name ) { should == "Otosan Switch" }
-      its( :dpid_short ) { should == "0xabc" }
-      its( :dpid_long ) { should == "0000000000000abc" }
-      its( :network_device ) { should == "vsw_0xabc" }
+      its(:name) { should == 'Otosan Switch' }
+      its(:dpid_short) { should == '0xabc' }
+      its(:dpid_long) { should == '0000000000000abc' }
+      its(:network_device) { should == 'vsw_0xabc' }
     end
 
 
-    context "when getting its flows" do
-      let( :name ) { "0xabc" }
+    context 'when getting its flows' do
+      let(:name) { '0xabc' }
 
-      it "should execute ofctl to get the flows" do
-        ofctl = mock( "ofctl" )
-        Ofctl.stub!( :new ).and_return( ofctl )
+      it 'should execute ofctl to get the flows' do
+        ofctl = mock('ofctl')
+        Ofctl.stub!(:new).and_return(ofctl)
 
-        ofctl.should_receive( :users_flows ).with( subject ).once
+        ofctl.should_receive(:users_flows).with(subject).once
 
         subject.flows
       end
     end
 
 
-    context "when running it" do
-      let( :name ) { "0xabc" }
+    context 'when running it' do
+      let(:name) { '0xabc' }
 
-      it "should execute ovs openflowd" do
-        subject.should_receive( :sh ).with do | command |
-          expect( command ).to include( Executables.ovs_openflowd )
+      it 'should execute ovs openflowd' do
+        subject.should_receive(:sh).with do | command |
+          expect(command).to include(Executables.ovs_openflowd)
         end
 
         subject.run!
       end
 
-      it "should be connected to virtual ports" do
-        subject << "VirtualInterface0"
-        subject << "VirtualInterface1"
-        subject << "VirtualInterface2"
+      it 'should be connected to virtual ports' do
+        subject << 'VirtualInterface0'
+        subject << 'VirtualInterface1'
+        subject << 'VirtualInterface2'
 
-        subject.should_receive( :sh ).with do | command |
-          expect( command ).to include( "--ports=VirtualInterface0,VirtualInterface1,VirtualInterface2" )
+        subject.should_receive(:sh).with do | command |
+          expect(command).to include('--ports=VirtualInterface0,VirtualInterface1,VirtualInterface2')
         end
 
         subject.run!

data/spec/trema/openflow-error_spec.rb

@@ -16,117 +16,119 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-describe Trema::OpenflowError, "new" do
-  context "when #port_mod with an invalid(port_no) is sent" do
-    it "should receive #error(type=Error::OFPET_PORT_MOD_FAILED,code=Error::OFPPMFC_BAD_PORT)" do
+describe Trema::OpenflowError, 'new' do
+  context 'when #port_mod with an invalid(port_no) is sent' do
+    it 'should receive #error(type=Error::OFPET_PORT_MOD_FAILED,code=Error::OFPPMFC_BAD_PORT)' do
       class OpenflowErrorController < Controller; end
-      network {
-        vswitch( "error-port") { datapath_id 0xabc }
-      }.run( OpenflowErrorController ) {
-        port_mod = Trema::PortMod.new( :port_no => 2,
-          :hw_addr => Trema::Mac.new( "11:22:33:44:55:66" ),
+      network do
+        vswitch('error-port') { datapath_id 0xabc }
+      end.run(OpenflowErrorController) do
+        port_mod = Trema::PortMod.new(
+          :port_no => 2,
+          :hw_addr => Trema::Mac.new('11:22:33:44:55:66'),
           :config => 1,
           :mask => 1,
           :advertise => 0
         )
-        controller( "OpenflowErrorController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          expect( datapath_id ).to eq( 0xabc )
-          expect( message.type ).to eq( Error::OFPET_PORT_MOD_FAILED )
-          expect( message.code ).to eq( Error::OFPPMFC_BAD_PORT )
+        controller('OpenflowErrorController').should_receive(:openflow_error) do | datapath_id, message |
+          expect(datapath_id).to eq(0xabc)
+          expect(message.type).to eq(Error::OFPET_PORT_MOD_FAILED)
+          expect(message.code).to eq(Error::OFPPMFC_BAD_PORT)
         end
-        controller( "OpenflowErrorController" ).send_message( 0xabc, port_mod )
+        controller('OpenflowErrorController').send_message(0xabc, port_mod)
         sleep 2 # FIXME: wait to send_message
-      }
+      end
     end
   end
 
 
-  context "when #port_mod with an invalid(hw_addr) is sent" do
-    it "should receive #error(type=Error::OFPET_PORT_MOD_FAILED,code=Error::OFPPMFC_BAD_HW_ADDR)" do
+  context 'when #port_mod with an invalid(hw_addr) is sent' do
+    it 'should receive #error(type=Error::OFPET_PORT_MOD_FAILED,code=Error::OFPPMFC_BAD_HW_ADDR)' do
       class OpenflowErrorController < Controller; end
-      network {
-        vswitch( "error-hw-addr") { datapath_id 0xabc }
-        vhost "host1"
-        vhost "host2"
-        link "host1", "error-hw-addr"
-        link "host2", "error-hw-addr"
-      }.run( OpenflowErrorController ) {
-        port_mod = Trema::PortMod.new( :port_no => 1,
-          :hw_addr => Trema::Mac.new( "11:22:33:44:55:66" ),
+      network do
+        vswitch('error-hw-addr') { datapath_id 0xabc }
+        vhost 'host1'
+        vhost 'host2'
+        link 'host1', 'error-hw-addr'
+        link 'host2', 'error-hw-addr'
+      end.run(OpenflowErrorController) do
+        port_mod = Trema::PortMod.new(
+          :port_no => 1,
+          :hw_addr => Trema::Mac.new('11:22:33:44:55:66'),
           :config => 1,
           :mask => 1,
           :advertise => 0
         )
-        controller( "OpenflowErrorController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          expect( datapath_id ).to eq( 0xabc )
-          expect( message.type ).to eq( Error::OFPET_PORT_MOD_FAILED )
-          expect( message.code ).to eq( Error::OFPPMFC_BAD_HW_ADDR )
+        controller('OpenflowErrorController').should_receive(:openflow_error) do | datapath_id, message |
+          expect(datapath_id).to eq(0xabc)
+          expect(message.type).to eq(Error::OFPET_PORT_MOD_FAILED)
+          expect(message.code).to eq(Error::OFPPMFC_BAD_HW_ADDR)
         end
-        controller( "OpenflowErrorController" ).send_message( 0xabc, port_mod )
+        controller('OpenflowErrorController').send_message(0xabc, port_mod)
         sleep 2 # FIXME: wait to send_message
-      }
+      end
     end
   end
 
 
-  context "when #flow_mod(add) message with an invalid(action_port) is sent" do
-    it "should receive #error(type=Error::OFPET_BAD_ACTION,code=Error::OFPBAC_BAD_OUT_PORT)" do
+  context 'when #flow_mod(add) message with an invalid(action_port) is sent' do
+    it 'should receive #error(type=Error::OFPET_BAD_ACTION,code=Error::OFPBAC_BAD_OUT_PORT)' do
       class OpenflowErrorController < Controller; end
-      network {
-        vswitch( "error-out-port") { datapath_id 0xabc }
-        vhost "host1"
-        vhost "host2"
-        link "host1", "error-port"
-        link "host2", "error-port"
-      }.run( OpenflowErrorController ) {
-        controller( "OpenflowErrorController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          expect( datapath_id ).to eq( 0xabc )
-          expect( message.type ).to eq( Error::OFPET_BAD_ACTION )
-          expect( message.code ).to eq( Error::OFPBAC_BAD_OUT_PORT )
+      network do
+        vswitch('error-out-port') { datapath_id 0xabc }
+        vhost 'host1'
+        vhost 'host2'
+        link 'host1', 'error-port'
+        link 'host2', 'error-port'
+      end.run(OpenflowErrorController) do
+        controller('OpenflowErrorController').should_receive(:openflow_error) do | datapath_id, message |
+          expect(datapath_id).to eq(0xabc)
+          expect(message.type).to eq(Error::OFPET_BAD_ACTION)
+          expect(message.code).to eq(Error::OFPBAC_BAD_OUT_PORT)
         end
-        controller( "OpenflowErrorController" ).send_flow_mod_add( 0xabc, :actions => ActionOutput.new( :port => 0x5555 ) )
+        controller('OpenflowErrorController').send_flow_mod_add(0xabc, :actions => ActionOutput.new(:port => 0x5555))
         sleep 2 # FIXME: wait to send_flow_mod_add
-      }
+      end
     end
   end
 
 
-  context "when an unsupported message is sent" do
-    it "should receive an openflow error with valid attributes" do
+  context 'when an unsupported message is sent' do
+    it 'should receive an openflow error with valid attributes' do
       class OpenflowController < Controller; end
-      network {
-        vswitch( "error-request") { datapath_id 0xabc }
-      }.run( OpenflowController ) {
-        queue_get_config_request = Trema::QueueGetConfigRequest.new( :port => 1 )
-        controller( "OpenflowController" ).should_receive( :openflow_error ) do | datapath_id, message |
-          expect( message.datapath_id ).to eq( 0xabc )
-          expect( message.type ).to satisfy { | n |
+      network do
+        vswitch('error-request') { datapath_id 0xabc }
+      end.run(OpenflowController) do
+        queue_get_config_request = Trema::QueueGetConfigRequest.new(:port => 1)
+        controller('OpenflowController').should_receive(:openflow_error) do | datapath_id, message |
+          expect(message.datapath_id).to eq(0xabc)
+          expect(message.type).to satisfy { | n |
             n >= 0 && n <= 5
           }
           case message.type
-          when 0,4
-            expect( message.code ).to include( 0,1 )
-          when 1,2
-            expect( message.code ).to satisfy { | n |
+          when 0, 4
+            expect(message.code).to include(0, 1)
+          when 1, 2
+            expect(message.code).to satisfy { | n |
               n >= 0 && n <= 8
             }
           when 3
-            expect( message.code ).to satisfy { | n |
+            expect(message.code).to satisfy { | n |
               n >= 0 && n <= 5
             }
           when 5
-            expect( message.code ).to satisfy { |n|
+            expect(message.code).to satisfy { |n|
               n >= 0 && n <= 3
             }
           end
         end
-        controller( "OpenflowController" ).send_message( 0xabc, queue_get_config_request )
+        controller('OpenflowController').send_message(0xabc, queue_get_config_request)
         sleep 2 # FIXME: wait to send_message
-      }
+      end
     end
   end
 end