trema 0.4.6 → 0.4.7

data/spec/support/action.rb

@@ -15,33 +15,30 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 
+require 'rspec'
 
-require "rubygems"
-require "rspec"
-
-
-shared_examples_for "option is within range" do | option, range |
+shared_examples_for 'option is within range' do | option, range |
   context "with #{ option } (#{ range })" do
-    let( option ) { range.first }
-    it { expect { subject }.not_to raise_error( ArgumentError ) }
+    let(option) { range.first }
+    it { expect { subject }.not_to raise_error(ArgumentError) }
   end
 
 
   context "with #{ option } (< #{ range.first })" do
-    let( option ) { range.first - 1 }
-    it { expect { subject }.to raise_error( ArgumentError ) }
+    let(option) { range.first - 1 }
+    it { expect { subject }.to raise_error(ArgumentError) }
   end
 
 
   context "with #{ option } (> #{ range.last })" do
-    let( option ) { range.last + 1 }
-    it { expect { subject }.to raise_error( ArgumentError ) }
+    let(option) { range.last + 1 }
+    it { expect { subject }.to raise_error(ArgumentError) }
   end
 end
 
 
 RSpec.configure do | config |
-  config.alias_it_should_behave_like_to :it_validates, "it validates"
+  config.alias_it_should_behave_like_to :it_validates, 'it validates'
 end
 
 

data/spec/support/mandatory-option.rb

@@ -15,35 +15,32 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 
+require 'rspec'
 
-require "rubygems"
-require "rspec"
-
-
-shared_examples_for "any Openflow message with mandatory options" do | options |
+shared_examples_for 'any Openflow message with mandatory options' do | options |
   subject do
     opt_hash = {}
-    options[ :options ].each do | each |
-      opt_hash[ each[ :name ] ] = __send__( each[ :name ] )
+    options[ :options].each do | each |
+      opt_hash[ each[ :name]] = __send__(each[ :name])
     end
-    options[ :klass ].new( opt_hash )
+    options[ :klass].new(opt_hash)
   end
 
-  options[ :options ].each do | each |
-    let( each[ :name ] ) { each[ :sample_value ] }
+  options[ :options].each do | each |
+    let(each[ :name]) { each[ :sample_value] }
   end
 
 
-  options[ :options ].each do | each |
-    context "with :#{ each[ :name ] } (#{ each[ :sample_value ] })" do
-      let( each[ :name ] ) { each[ :sample_value ] }
-      its( each[ :name ] ) { should == each[ :sample_value ] }
-      its( each[ :alias ] ) { should == each[ :sample_value ] } if each[ :alias ]
+  options[ :options].each do | each |
+    context "with :#{ each[ :name] } (#{ each[ :sample_value] })" do
+      let(each[ :name]) { each[ :sample_value] }
+      its(each[ :name]) { should == each[ :sample_value] }
+      its(each[ :alias]) { should == each[ :sample_value] } if each[ :alias]
     end
 
-    context "without :#{ each[ :name ] }" do
-      let( each[ :name ] ) { nil }
-      it { expect { subject }.to raise_error( ArgumentError, ":#{ each[ :name ] } is a mandatory option" ) }
+    context "without :#{ each[ :name] }" do
+      let(each[ :name]) { nil }
+      it { expect { subject }.to raise_error(ArgumentError, ":#{ each[ :name] } is a mandatory option") }
     end
   end
 end

data/spec/support/matchers/constant.rb

@@ -1,19 +1,19 @@
 RSpec::Matchers.define :have_constant do | const, klass |
   match do | owner |
-    const_defined = owner.const_defined?( const )
-    klass_match = owner.const_get( const ).class == klass unless klass.nil?
-    klass.nil? ? const_defined : ( const_defined && klass_match )
+    const_defined = owner.const_defined?(const)
+    klass_match = owner.const_get(const).class == klass unless klass.nil?
+    klass.nil? ? const_defined : ( const_defined && klass_match)
   end
 
   failure_message_for_should do | actual |
-    msg = "constant #{ expected[ 0 ] } not defined in #{ actual }"
-    msg += " as a #{ expected[ 1 ] }" unless expected[ 1 ].nil?
+    msg = "constant #{ expected[ 0] } not defined in #{ actual }"
+    msg += " as a #{ expected[ 1] }" unless expected[ 1].nil?
     msg
   end
 
   failure_message_for_should_not do | actual |
-    msg = "constant #{ expected[ 0 ] } is defined in #{ actual }"
-    msg += " as a #{ expected[ 1 ] }" unless expected[ 1 ].nil?
+    msg = "constant #{ expected[ 0] } is defined in #{ actual }"
+    msg += " as a #{ expected[ 1] }" unless expected[ 1].nil?
     msg
   end
 

data/spec/support/openflow-message.rb

@@ -15,157 +15,154 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 
+require 'rspec'
 
-require "rubygems"
-require "rspec"
-
-
-shared_examples_for "any Openflow message with default transaction ID" do
-  its( :transaction_id ) { should be_unsigned_32bit }
-  its( :xid ) { should be_unsigned_32bit }
+shared_examples_for 'any Openflow message with default transaction ID' do
+  its(:transaction_id) { should be_unsigned_32bit }
+  its(:xid) { should be_unsigned_32bit }
 end
 
 
-shared_examples_for "any Openflow message with transaction ID" do
-  context "transaction_id: -123", :nosudo => true do
-    let( :transaction_id ) { -123 }
-    it { expect { subject }.to raise_error( ArgumentError, "Transaction ID must be an unsigned 32-bit integer" ) }
+shared_examples_for 'any Openflow message with transaction ID' do
+  context 'transaction_id: -123', :nosudo => true do
+    let(:transaction_id) { -123 }
+    it { expect { subject }.to raise_error(ArgumentError, 'Transaction ID must be an unsigned 32-bit integer') }
   end
 
-  context "transaction_id: 0", :nosudo => true do
-    let( :transaction_id ) { 0 }
-    its( :transaction_id ) { should == 0 }
-    its( :xid ) { should == 0 }
+  context 'transaction_id: 0', :nosudo => true do
+    let(:transaction_id) { 0 }
+    its(:transaction_id) { should == 0 }
+    its(:xid) { should == 0 }
   end
 
-  context "transaction_id: 123", :nosudo => true do
-    let( :transaction_id ) { 123 }
-    its( :transaction_id ) { should == 123 }
-    its( :xid ) { should == 123 }
+  context 'transaction_id: 123', :nosudo => true do
+    let(:transaction_id) { 123 }
+    its(:transaction_id) { should == 123 }
+    its(:xid) { should == 123 }
   end
 
-  context "transaction_id: UINT32_MAX", :nosudo => true do
-    let( :transaction_id ) { 2 ** 32 - 1 }
-    its( :transaction_id ) { should == 2 ** 32 - 1 }
-    its( :xid ) { should == 2 ** 32 - 1 }
+  context 'transaction_id: UINT32_MAX', :nosudo => true do
+    let(:transaction_id) { 2**32 - 1 }
+    its(:transaction_id) { should == 2**32 - 1 }
+    its(:xid) { should == 2**32 - 1 }
   end
 
-  context "transaction_id: UINT32_MAX + 1", :nosudo => true do
-    let( :transaction_id ) { 2 ** 32 }
-    it { expect { subject }.to raise_error( ArgumentError, "Transaction ID must be an unsigned 32-bit integer" ) }
+  context 'transaction_id: UINT32_MAX + 1', :nosudo => true do
+    let(:transaction_id) { 2**32 }
+    it { expect { subject }.to raise_error(ArgumentError, 'Transaction ID must be an unsigned 32-bit integer') }
   end
 end
 
 
-shared_examples_for "any Openflow message with xid" do
-  context "xid: -123", :nosudo => true do
-    let( :xid ) { -123 }
-    it { expect { subject }.to raise_error( ArgumentError, "Transaction ID must be an unsigned 32-bit integer" ) }
+shared_examples_for 'any Openflow message with xid' do
+  context 'xid: -123', :nosudo => true do
+    let(:xid) { -123 }
+    it { expect { subject }.to raise_error(ArgumentError, 'Transaction ID must be an unsigned 32-bit integer') }
   end
 
-  context "xid: 0", :nosudo => true do
-    let( :xid ) { 0 }
-    its( :xid ) { should == 0 }
-    its( :transaction_id ) { should == 0 }
+  context 'xid: 0', :nosudo => true do
+    let(:xid) { 0 }
+    its(:xid) { should == 0 }
+    its(:transaction_id) { should == 0 }
   end
 
-  context "xid: 123", :nosudo => true do
-    let( :xid ) { 123 }
-    its( :xid ) { should == 123 }
-    its( :transaction_id ) { should == 123 }
+  context 'xid: 123', :nosudo => true do
+    let(:xid) { 123 }
+    its(:xid) { should == 123 }
+    its(:transaction_id) { should == 123 }
   end
 
-  context "xid: UINT32_MAX", :nosudo => true do
-    let( :xid ) { 2 ** 32 - 1 }
-    its( :xid ) { should == 2 ** 32 - 1 }
-    its( :transaction_id ) { should == 2 ** 32 - 1 }
+  context 'xid: UINT32_MAX', :nosudo => true do
+    let(:xid) { 2**32 - 1 }
+    its(:xid) { should == 2**32 - 1 }
+    its(:transaction_id) { should == 2**32 - 1 }
   end
 
-  context "xid: UINT32_MAX + 1", :nosudo => true do
-    let( :xid ) { 2 ** 32 }
-    it { expect { subject }.to raise_error( ArgumentError, "Transaction ID must be an unsigned 32-bit integer" ) }
+  context 'xid: UINT32_MAX + 1', :nosudo => true do
+    let(:xid) { 2**32 }
+    it { expect { subject }.to raise_error(ArgumentError, 'Transaction ID must be an unsigned 32-bit integer') }
   end
 end
 
 
-shared_examples_for "any Openflow message with user_data" do
-  context "user_data: nil", :nosudo => true do
-    let( :user_data ) { nil }
-    its( :user_data ) { should be_nil }
-    it_should_behave_like "any Openflow message with default transaction ID"
+shared_examples_for 'any Openflow message with user_data' do
+  context 'user_data: nil', :nosudo => true do
+    let(:user_data) { nil }
+    its(:user_data) { should be_nil }
+    it_should_behave_like 'any Openflow message with default transaction ID'
   end
 
 
   context 'user_data: "USER DATA"', :nosudo => true do
-    let( :user_data ) { "USER DATA" }
-    its( :user_data ) { should == "USER DATA" }
-    it_should_behave_like "any Openflow message with default transaction ID"
+    let(:user_data) { 'USER DATA' }
+    its(:user_data) { should == 'USER DATA' }
+    it_should_behave_like 'any Openflow message with default transaction ID'
   end
 
 
-  context "user_data: :INVALID_DATA", :nosudo => true do
-    let( :user_data ) { :INVALID_DATA }
-    it { expect { subject }.to raise_error( TypeError ) }
+  context 'user_data: :INVALID_DATA', :nosudo => true do
+    let(:user_data) { :INVALID_DATA }
+    it { expect { subject }.to raise_error(TypeError) }
   end
 end
 
 
-shared_examples_for "any OpenFlow message" do | options |
-  option = options[ :option ]
-  name = options[ :name ]
-  size = options[ :size ]
+shared_examples_for 'any OpenFlow message' do | options |
+  option = options[ :option]
+  name = options[ :name]
+  size = options[ :size]
   case size
     when 8
-      let( :uint_max ) { 2 ** 8 - 1 }
+      let(:uint_max) { 2**8 - 1 }
     when 16
-      let( :uint_max ) { 2 ** 16 - 1 }
+      let(:uint_max) { 2**16 - 1 }
     when 32
-      let( :uint_max ) { 2 ** 32 - 1 }
+      let(:uint_max) { 2**32 - 1 }
   end
 
 
   context "when its #{ name } is a negative value" do
-    let( option ) { -1234 }
-    it "should raise ArgumentError" do
-      expect { subject }.to raise_error( "#{ name } must be an unsigned #{ size }-bit integer" )
+    let(option) { -1234 }
+    it 'should raise ArgumentError' do
+      expect { subject }.to raise_error("#{ name } must be an unsigned #{ size }-bit integer")
     end
   end
 
 
   context "when its #{ name } is zero" do
-    let( option ) { 0 }
-    its( option ) { should == 0 }
+    let(option) { 0 }
+    its(option) { should == 0 }
   end
 
 
   context "when its #{ name } is 123" do
-    let( option ) { 123 }
-    its( option ) { should == 123 }
+    let(option) { 123 }
+    its(option) { should == 123 }
   end
 
 
   context "when its #{ name } is UINT#{ size }MAX" do
-    let( option ) { uint_max }
-    its( option ) { should == uint_max }
+    let(option) { uint_max }
+    its(option) { should == uint_max }
   end
 
 
   context "when its #{ name } is UINT#{ size }_MAX + 1" do
-    let( option ) { uint_max + 1 }
-    it "should raise ArgumentError" do
-      expect { subject }.to raise_error( "#{ name } must be an unsigned #{ size }-bit integer" )
+    let(option) { uint_max + 1 }
+    it 'should raise ArgumentError' do
+      expect { subject }.to raise_error("#{ name } must be an unsigned #{ size }-bit integer")
     end
   end
 end
 
 
-shared_examples_for "any OpenFlow message with port option" do
-  it_should_behave_like "any OpenFlow message", :option => :port, :name => "Port", :size => 16
+shared_examples_for 'any OpenFlow message with port option' do
+  it_should_behave_like 'any OpenFlow message', :option => :port, :name => 'Port', :size => 16
 end
 
 
-shared_examples_for "any OpenFlow message with transaction_id option" do
-  it_should_behave_like "any OpenFlow message", :option => :transaction_id, :name => "Transaction ID", :size => 32
+shared_examples_for 'any OpenFlow message with transaction_id option' do
+  it_should_behave_like 'any OpenFlow message', :option => :transaction_id, :name => 'Transaction ID', :size => 32
 end
 
 

data/spec/support/port-status.rb

@@ -15,18 +15,15 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 
+require 'rspec'
 
-require "rubygems"
-require "rspec"
-
-
-shared_examples_for "port status message" do | options |
+shared_examples_for 'port status message' do | options |
   it_should_behave_like(
-    "any Openflow message with mandatory options",
-    :klass => options[ :klass ],
-    :options => [ { :name => :datapath_id, :alias => :dpid, :sample_value => 0xabc },
-                  { :name => :transaction_id, :alias => :xid, :sample_value => 123 },
-                  { :name => :phy_port, :sample_value => "PHY_PORT" } ]
+    'any Openflow message with mandatory options',
+    :klass => options[ :klass],
+    :options => [{ :name => :datapath_id, :alias => :dpid, :sample_value => 0xabc },
+                 { :name => :transaction_id, :alias => :xid, :sample_value => 123 },
+                 { :name => :phy_port, :sample_value => 'PHY_PORT' }]
   )
 end
 

data/spec/trema/app_spec.rb

@@ -16,65 +16,65 @@
 #
 
 
-require File.join( File.dirname( __FILE__ ), "..", "spec_helper" )
-require "trema/app"
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+require 'trema/app'
 
 
 module Trema
   describe App do
-    context "when running an app" do
-      it "should run without options" do
-        stanza = { :path => "/usr/bin/tetris", :name => "NAME" }
-        app = App.new( stanza )
+    context 'when running an app' do
+      it 'should run without options' do
+        stanza = { :path => '/usr/bin/tetris', :name => 'NAME' }
+        app = App.new(stanza)
 
-        app.should_receive( :sh ).with( "/usr/bin/tetris --name NAME" )
+        app.should_receive(:sh).with('/usr/bin/tetris --name NAME')
 
         app.run!
       end
 
 
-      it "should run with options" do
-        stanza = { :path => "/usr/bin/tetris", :name => "NAME", :options => [ "OPTION0", "OPTION1" ] }
-        app = App.new( stanza )
+      it 'should run with options' do
+        stanza = { :path => '/usr/bin/tetris', :name => 'NAME', :options => ['OPTION0', 'OPTION1'] }
+        app = App.new(stanza)
 
-        app.should_receive( :sh ).with( "/usr/bin/tetris --name NAME OPTION0 OPTION1" )
+        app.should_receive(:sh).with('/usr/bin/tetris --name NAME OPTION0 OPTION1')
 
         app.run!
       end
     end
 
 
-    context "when daemonizing an app" do
-      it "should daemonize without options" do
-        stanza = { :path => "/usr/bin/tetris", :name => "NAME" }
-        app = App.new( stanza )
+    context 'when daemonizing an app' do
+      it 'should daemonize without options' do
+        stanza = { :path => '/usr/bin/tetris', :name => 'NAME' }
+        app = App.new(stanza)
 
-        app.should_receive( :sh ).with( "/usr/bin/tetris --name NAME -d" )
+        app.should_receive(:sh).with('/usr/bin/tetris --name NAME -d')
 
         app.daemonize!
       end
 
 
-      it "should daemonize with options" do
-        stanza = { :path => "/usr/bin/tetris", :name => "NAME", :options => [ "OPTION0", "OPTION1" ] }
-        app = App.new( stanza )
+      it 'should daemonize with options' do
+        stanza = { :path => '/usr/bin/tetris', :name => 'NAME', :options => ['OPTION0', 'OPTION1'] }
+        app = App.new(stanza)
 
-        app.should_receive( :sh ).with( "/usr/bin/tetris --name NAME -d OPTION0 OPTION1" )
+        app.should_receive(:sh).with('/usr/bin/tetris --name NAME -d OPTION0 OPTION1')
 
         app.daemonize!
       end
     end
 
 
-    context "when shutting an app down" do
-      it "should send a signal to kill" do
-        process = mock( "process" )
-        Trema::Process.stub!( :read ).and_return( process )
+    context 'when shutting an app down' do
+      it 'should send a signal to kill' do
+        process = mock('process')
+        Trema::Process.stub!(:read).and_return(process)
 
-        process.should_receive( :kill! )
+        process.should_receive(:kill!)
 
-        stanza = { :path => "/usr/bin/tetris", :name => "NAME" }
-        App.new( stanza ).shutdown!
+        stanza = { :path => '/usr/bin/tetris', :name => 'NAME' }
+        App.new(stanza).shutdown!
       end
     end
   end