trema 0.4.6 → 0.4.7

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

@@ -16,44 +16,45 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-describe QueueGetConfigReply, ".new( VALID OPTIONS )" do
+describe QueueGetConfigReply, '.new( VALID OPTIONS )' do
   subject do
     for i in 1..2 do
-      pq = PacketQueue.new( :queue_id => i, :len => i * 64 )
-      mr = MinRateQueue.new( i, i * 64, 1024 * i, pq)
+      pq = PacketQueue.new(:queue_id => i, :len => i * 64)
+      mr = MinRateQueue.new(i, i * 64, 1024 * i, pq)
     end
-    QueueGetConfigReply.new( :datapath_id => 0xabc,
+    QueueGetConfigReply.new(
+      :datapath_id => 0xabc,
       :transaction_id => 123,
       :port => 1,
       :queues => Trema::PacketQueues.queues
     )
   end
-  its( "queues.length" ) { should ==  2  }
-  its( "queues.first" ) { should be_an_instance_of PacketQueue }
-  its( :datapath_id ) { should == 0xabc }
-  its( :transaction_id ) { should == 123 }
+  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
 
 
-describe PacketQueue, ".new( VALID OPTIONS )" do
-  subject { PacketQueue.new( :queue_id => 123, :len => 64 ) }
-  its( :queue_id ) { should == 123 }
-  its( :len ) { should == 64 }
+describe PacketQueue, '.new( VALID OPTIONS )' do
+  subject { PacketQueue.new(:queue_id => 123, :len => 64) }
+  its(:queue_id) { should == 123 }
+  its(:len) { should == 64 }
 end
 
 
-describe MinRateQueue, ".new( VALID OPTIONS )" do
+describe MinRateQueue, '.new( VALID OPTIONS )' do
   subject do
-    pq = PacketQueue.new( :queue_id => 123, :len => 64 )
-    MinRateQueue.new( 1, 64, 1024, pq )
+    pq = PacketQueue.new(:queue_id => 123, :len => 64)
+    MinRateQueue.new(1, 64, 1024, pq)
   end
-  its( :property ) { should == 1 }
-  its( :len ) { should == 64 }
-  its( :rate ) { should == 1024 }
+  its(:property) { should == 1 }
+  its(:len) { should == 64 }
+  its(:rate) { should == 1024 }
 end
 
 

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

@@ -16,46 +16,46 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-describe QueueGetConfigRequest, ".new( OPTIONAL OPTION MISSING )" do
-  its( :port ) { should == 1 }
-  it_should_behave_like "any Openflow message with default transaction ID"
+describe QueueGetConfigRequest, '.new( OPTIONAL OPTION MISSING )' do
+  its(:port) { should == 1 }
+  it_should_behave_like 'any Openflow message with default transaction ID'
 end
 
 
-describe QueueGetConfigRequest, ".new( VALID OPTIONS )" do
-  subject { QueueGetConfigRequest.new( :transaction_id => transaction_id, :port => port ) }
-  let( :transaction_id ) { 123 }
-  let( :port ) { 2 }
-  it_should_behave_like "any OpenFlow message with transaction_id option"
-  it_should_behave_like "any OpenFlow message with port option"
+describe QueueGetConfigRequest, '.new( VALID OPTIONS )' do
+  subject { QueueGetConfigRequest.new(:transaction_id => transaction_id, :port => port) }
+  let(:transaction_id) { 123 }
+  let(:port) { 2 }
+  it_should_behave_like 'any OpenFlow message with transaction_id option'
+  it_should_behave_like 'any OpenFlow message with port option'
 
 
-  context "when #queue_get_config_request is sent" do
-    it "should #queue_get_config_reply" do
+  context 'when #queue_get_config_request is sent' do
+    it 'should #queue_get_config_reply' do
       pending "#queue_get_config_reply is not implemented in #{Trema.vendor_openvswitch}"
       class QueueGetConfigController < Controller; end
-      network {
+      network do
         vswitch { datapath_id 0xabc }
-      }.run( QueueGetConfigController ) {
-        controller( "QueueGetConfigController" ).should_receive( :queue_get_config_reply )
-        queue_get_config_request = QueueGetConfigRequest.new( :transaction_id => 123, :port => 1 )
-        controller( "QueueGetConfigController" ).send_message( 0xabc, queue_get_config_request )
+      end.run(QueueGetConfigController) do
+        controller('QueueGetConfigController').should_receive(:queue_get_config_reply)
+        queue_get_config_request = QueueGetConfigRequest.new(:transaction_id => 123, :port => 1)
+        controller('QueueGetConfigController').send_message(0xabc, queue_get_config_request)
         sleep 2 # FIXME: wait to send_message
-      }
+      end
     end
   end
 end
 
 
-describe QueueGetConfigRequest, ".new( INVALID OPTIONS )" do
-  it "should raise a TypeError" do
-    expect {
-     QueueGetConfigRequest.new "INVALID OPTIONS"
-    }.to raise_error( TypeError )
+describe QueueGetConfigRequest, '.new( INVALID OPTIONS )' do
+  it 'should raise a TypeError' do
+    expect do
+     QueueGetConfigRequest.new 'INVALID OPTIONS'
+    end.to raise_error(TypeError)
   end
 end
 

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

@@ -16,84 +16,84 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-describe SendOutPort, :type => "actions" do
-  describe "#new(port_number)" do
-    subject( :send_out_port ) { SendOutPort.new( port_number ) }
+describe SendOutPort, :type => 'actions' do
+  describe '#new(port_number)' do
+    subject(:send_out_port) { SendOutPort.new(port_number) }
 
 
-    context "with port_number (1)" do
-      let( :port_number ) { 1 }
+    context 'with 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( "Trema::SendOutPort: port_number=1, max_len=65535" ) }
+      its(:port_number) { should eq(1) }
+      its(:max_len) { should eq(2**16 - 1) }
+      its(:to_s) { should eq('Trema::SendOutPort: port_number=1, max_len=65535') }
     end
 
 
-    context "with port_number (10)" do
-      let( :port_number ) { 10 }
+    context 'with port_number (10)' do
+      let(:port_number) { 10 }
 
       context "when set as FlowMod's action", :sudo => true do
-        it "should insert a new flow entry with action (output:10)" do
+        it 'should insert a new flow entry with action (output:10)' do
           class TestController < Controller; end
-          network {
+          network do
             vswitch { datapath_id 0xabc }
-          }.run( TestController ) {
-            controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => send_out_port )
+          end.run(TestController) do
+            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" )
-            pending( "Test actions as an object using Trema::Switch" ) do
-              expect( vswitch( "0xabc" ) ).to have( 1 ).flows
-              expect( vswitch( "0xabc" ).flows[ 0 ] ).to have( 1 ).actions
-              expect( vswitch( "0xabc" ).flows[ 0 ].actions[ 0 ] ).to be_a( SendOutPort )
-              expect( vswitch( "0xabc" ).flows[ 0 ].actions[ 0 ].port_number ).to eq( 10 )
+            expect(vswitch('0xabc')).to have(1).flows
+            expect(vswitch('0xabc').flows[ 0].actions).to eq('output:10')
+            pending('Test actions as an object using Trema::Switch') do
+              expect(vswitch('0xabc')).to have(1).flows
+              expect(vswitch('0xabc').flows[ 0]).to have(1).actions
+              expect(vswitch('0xabc').flows[ 0].actions[ 0]).to be_a(SendOutPort)
+              expect(vswitch('0xabc').flows[ 0].actions[ 0].port_number).to eq(10)
             end
-          }
+          end
         end
       end
     end
 
 
-    it_validates "option is within range", :port_number, 0..( 2 ** 16 - 1 )
+    it_validates 'option is within range', :port_number, 0..( 2**16 - 1)
   end
 
 
-  describe "#new(:port_number => value)" do
-    subject { SendOutPort.new( :port_number => port_number ) }
+  describe '#new(:port_number => value)' do
+    subject { SendOutPort.new(:port_number => port_number) }
 
 
-    context "with option (:port_number => 1)" do
-      let( :port_number ) { 1 }
+    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( "Trema::SendOutPort: port_number=1, max_len=65535" ) }
+      its(:port_number) { should eq(1) }
+      its(:max_len) { should eq(2**16 - 1) }
+      its(:to_s) { should eq('Trema::SendOutPort: port_number=1, max_len=65535') }
     end
   end
 
 
-  describe "#new(:port_number => value1, :max_len => value2)" do
-    subject { SendOutPort.new( options ) }
+  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 } }
+    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( "Trema::SendOutPort: port_number=1, max_len=256" ) }
+      its(:port_number) { should eq(1) }
+      its(:max_len) { should eq(256) }
+      its(:to_s) { should eq('Trema::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 } }
+    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 )
+      it_validates 'option is within range', :max_len, 0..( 2**16 - 1)
     end
   end
 end

data/spec/trema/set-config_spec.rb

@@ -16,56 +16,56 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-describe SetConfig, "new( OPTIONAL OPTION MISSING )" do
-  its( :flags ) { should == 0 }
-  its( :miss_send_len ) { should == 128 }
-  it_should_behave_like "any Openflow message with default transaction ID"
+describe SetConfig, 'new( OPTIONAL OPTION MISSING )' do
+  its(:flags) { should == 0 }
+  its(:miss_send_len) { should == 128 }
+  it_should_behave_like 'any Openflow message with default transaction ID'
 end
 
 
-describe SetConfig, ".new( VALID OPTIONS )" do
-  subject { SetConfig.new( :flags => 1, :miss_send_len => 256, :transaction_id => transaction_id ) }
-  let( :transaction_id ) { 123 }
-  its( :flags ) { should  == 1 }
-  its( :miss_send_len ) { should == 256 }
-  it_should_behave_like "any OpenFlow message with transaction_id option"
+describe SetConfig, '.new( VALID OPTIONS )' do
+  subject { SetConfig.new(:flags => 1, :miss_send_len => 256, :transaction_id => transaction_id) }
+  let(:transaction_id) { 123 }
+  its(:flags) { should  == 1 }
+  its(:miss_send_len) { should == 256 }
+  it_should_behave_like 'any OpenFlow message with transaction_id option'
 
 
-  context "when #set_config is sent" do
-    it "should not #set_config_reply" do
+  context 'when #set_config is sent' do
+    it 'should not #set_config_reply' do
       class SetConfigController < Controller; end
-      network {
+      network do
         vswitch { datapath_id 0xabc }
-      }.run( SetConfigController ) {
-        set_config = SetConfig.new( :flags => 0, :miss_send_len => 128, :transaction_id => 123 )
-        controller( "SetConfigController" ).should_not_receive( :set_config_reply )
-        controller( "SetConfigController" ).send_message( 0xabc, set_config )
+      end.run(SetConfigController) do
+        set_config = SetConfig.new(:flags => 0, :miss_send_len => 128, :transaction_id => 123)
+        controller('SetConfigController').should_not_receive(:set_config_reply)
+        controller('SetConfigController').send_message(0xabc, set_config)
         sleep 2 # FIXME: wait to send_message
-      }
+      end
     end
   end
 
 
-  context "when #set_config is sent with flags, miss_send_len set to 0" do
-    it "should #get_config_reply with flags, miss_send_len set to 0" do
+  context 'when #set_config is sent with flags, miss_send_len set to 0' do
+    it 'should #get_config_reply with flags, miss_send_len set to 0' do
       class SetConfigController < Controller; end
-      network {
+      network do
         vswitch { datapath_id 0xabc }
-      }.run( SetConfigController ) {
-        controller( "SetConfigController" ).should_receive( :get_config_reply ) do | dpid, arg |
-          expect( arg.flags ).to eq( 0 )
-          expect( arg.miss_send_len ).to eq( 0 )
+      end.run(SetConfigController) do
+        controller('SetConfigController').should_receive(:get_config_reply) do | dpid, arg |
+          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 )
+        set_config = SetConfig.new(:flags => 0, :miss_send_len => 0, :transaction_id => 123)
+        controller('SetConfigController').send_message(0xabc, set_config)
         sleep 2 # FIXME: wait to send_message
-        controller( "SetConfigController" ).send_message( 0xabc, GetConfigRequest.new )
+        controller('SetConfigController').send_message(0xabc, GetConfigRequest.new)
         sleep 2 # FIXME: wait to send_message
-      }
+      end
     end
   end
 end

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

@@ -16,38 +16,38 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-[ SetEthSrcAddr, SetEthDstAddr ].each do | klass |
-  describe klass, ".new", :type => "actions" do
-    subject { klass.new( mac_address ) }
+[SetEthSrcAddr, SetEthDstAddr].each do | klass |
+  describe klass, '.new', :type => 'actions' do
+    subject { klass.new(mac_address) }
 
 
-    context %{with "11:22:33:44:55:66"} do
-      let( :mac_address ) { "11:22:33:44:55:66" }
+    context 'with "11:22:33:44:55:66"' do
+      let(:mac_address) { '11:22:33:44:55:66' }
 
-      its( :mac_address ) { should eq "11:22:33:44:55:66" }
-      its( :to_s ) { should eq "#{ klass.to_s }: mac_address=11:22:33:44:55:66" }
+      its(:mac_address) { should eq '11:22:33:44:55:66' }
+      its(:to_s) { should eq "#{ klass }: mac_address=11:22:33:44:55:66" }
 
       context "when set as FlowMod's action", :sudo => true do
-        it "should insert a new flow with action (mod_dl_{src,dst}:11:22:33:44:55:66)" do
+        it 'should insert a new flow with action (mod_dl_{src,dst}:11:22:33:44:55:66)' do
           class TestController < Controller; end
-          network {
+          network do
             vswitch { datapath_id 0xabc }
-          }.run( TestController ) {
-            controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+          end.run(TestController) do
+            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 match( /mod_dl_(src|dst):11:22:33:44:55:66/ )
-            pending( "Test actions as an object using Trema::Switch" ) do
-              expect( vswitch( "0xabc" ) ).to have( 1 ).flows
-              expect( vswitch( "0xabc" ).flows[ 0 ] ).to have( 1 ).actions
-              expect( vswitch( "0xabc" ).flows[ 0 ].actions[ 0 ] ).to be_a( klass )
-              expect( vswitch( "0xabc" ).flows[ 0 ].actions[ 0 ].mac_address.to_s ).to eq( "11:22:33:44:55:66" )
+            expect(vswitch('0xabc')).to have(1).flows
+            expect(vswitch('0xabc').flows[ 0].actions).to match(/mod_dl_(src|dst):11:22:33:44:55:66/)
+            pending('Test actions as an object using Trema::Switch') do
+              expect(vswitch('0xabc')).to have(1).flows
+              expect(vswitch('0xabc').flows[ 0]).to have(1).actions
+              expect(vswitch('0xabc').flows[ 0].actions[ 0]).to be_a(klass)
+              expect(vswitch('0xabc').flows[ 0].actions[ 0].mac_address.to_s).to eq('11:22:33:44:55:66')
             end
-          }
+          end
         end
       end
     end

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

@@ -16,59 +16,59 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema'
 
 
-[ SetIpSrcAddr, SetIpDstAddr ].each do | klass |
-  describe klass, "#new(ip_address)", :type => "actions" do
-    subject { klass.new( ip_address ) }
+[SetIpSrcAddr, SetIpDstAddr].each do | klass |
+  describe klass, '#new(ip_address)', :type => 'actions' do
+    subject { klass.new(ip_address) }
 
 
-    context %{with ip_address ("192.168.1.1")} do
-      let( :ip_address ) { "192.168.1.1" }
+    context 'with ip_address (192.168.1.1)' do
+      let(:ip_address) { '192.168.1.1' }
 
-      its( "ip_address.to_s" ) { should == "192.168.1.1" }
-      its( :to_s ) { should eq( "#{ klass.to_s }: ip_address=192.168.1.1" ) }
+      its('ip_address.to_s') { should == '192.168.1.1' }
+      its(:to_s) { should eq("#{ klass }: ip_address=192.168.1.1") }
     end
 
 
-    context %{with ip_address ("192.168.1.10")} do
-      let( :ip_address ) { "192.168.1.10" }
+    context 'with ip_address (192.168.1.10)' do
+      let(:ip_address) { '192.168.1.10' }
 
       context "when set as FlowMod's action", :sudo => true do
-        it "should insert a new flow entry with action (mod_nw_{src,dst}:192.168.1.10)" do
+        it 'should insert a new flow entry with action (mod_nw_{src,dst}:192.168.1.10)' do
           class TestController < Controller; end
-          network {
+          network do
             vswitch { datapath_id 0xabc }
-          }.run( TestController ) {
-            controller( "TestController" ).send_flow_mod_add( 0xabc, :actions => subject )
+          end.run(TestController) do
+            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 match( /mod_nw_(src|dst):192.168.1.10/ )
-            pending( "Test actions as an object using Trema::Switch" ) do
-              expect( vswitch( "0xabc" ) ).to have( 1 ).flows
-              expect( vswitch( "0xabc" ).flows[ 0 ] ).to have( 1 ).actions
-              expect( vswitch( "0xabc" ).flows[ 0 ].actions[ 0 ] ).to be_a( klass )
-              expect( vswitch( "0xabc" ).flows[ 0 ].actions[ 0 ].ip_address.to_s ).to eq( "192.168.1.10" )
+            expect(vswitch('0xabc')).to have(1).flows
+            expect(vswitch('0xabc').flows[ 0].actions).to match(/mod_nw_(src|dst):192.168.1.10/)
+            pending('Test actions as an object using Trema::Switch') do
+              expect(vswitch('0xabc')).to have(1).flows
+              expect(vswitch('0xabc').flows[ 0]).to have(1).actions
+              expect(vswitch('0xabc').flows[ 0].actions[ 0]).to be_a(klass)
+              expect(vswitch('0xabc').flows[ 0].actions[ 0].ip_address.to_s).to eq('192.168.1.10')
             end
-          }
+          end
         end
       end
     end
 
 
-    context %{with invalid ip_address ("1000.1000.1000.1000")} do
-      let( :ip_address ) { "1000.1000.1000.1000" }
+    context 'with invalid ip_address (1000.1000.1000.1000)' do
+      let(:ip_address) { '1000.1000.1000.1000' }
 
-      it { expect { subject }.to raise_error( ArgumentError ) }
+      it { expect { subject }.to raise_error(ArgumentError) }
     end
 
 
-    context "with invalid ip_address ([1, 2, 3])" do
-      let( :ip_address ) { [ 1, 2, 3 ] }
+    context 'with invalid ip_address ([1, 2, 3])' do
+      let(:ip_address) { [1, 2, 3] }
 
-      it { expect { subject }.to raise_error( TypeError ) }
+      it { expect { subject }.to raise_error(TypeError) }
     end
   end
 end