ffi-pcap 0.2.0 → 0.2.1

data/spec/live_spec.rb

@@ -26,10 +26,13 @@ describe Live do
 
   it "should provide statistics about packets received/dropped" do
     i = 0
+
     @pcap.loop {|this,pkt| @pcap.stop if (i += 1) == 10 }
+
     i.should_not == 0
+
     stats = @pcap.stats
-    Stat.should === stats
+    stats.should be_kind_of(Stat)
     stats.received.should > 0
     stats.received.should >= 10
   end
@@ -37,17 +40,20 @@ describe Live do
   it "should yield packets with a timestamp using loop()" do
     i = 0
     @pkt = nil
+
     @pcap.loop(:count => 2) do |this, pkt|
       this.should == @pcap
       pkt.should_not be_nil
-      Packet.should === pkt
+      pkt.should be_kind_of(Packet)
+
       (Time.now - pkt.time).should_not > 1000
-      i+=1
+
+      i += 1
     end
+
     i.should == 2
   end
 
-
   describe "live packets" do
     before(:all) do
       @pcap = Live.new(
@@ -64,7 +70,6 @@ describe Live do
     end
     
     it_should_behave_like "FFI::PCap::Packet populated"
-
   end
 
   describe "yielding to a block" do
@@ -78,7 +83,9 @@ describe Live do
       end
 
       start_traffic_generator()
+      
       it_should_behave_like "FFI::PCap::CaptureWrapper"
+
       stop_traffic_generator()
       @pcap.close
     end

data/spec/offline_spec.rb

@@ -2,19 +2,17 @@ require 'spec_helper'
 require 'wrapper_behaviors'
 
 describe Offline do
-  before(:each) do
-    @pcap = Offline.new(PCAP_TESTFILE)
-  end
+  before(:each) { @pcap = Offline.new(PCAP_TESTFILE) }
 
-  after(:each) do
-    @pcap.close
-  end
+  after(:each) { @pcap.close }
 
   it_should_behave_like "FFI::PCap::CaptureWrapper"
 
   it "should return a nil from next() at the end of the dump file" do
     i = 0
-    @pcap.loop {|this,pkt| i+=1 }
+
+    @pcap.loop {|this,pkt| i += 1 }
+
     i.should > 0
     @pcap.next.should be_nil
   end
@@ -22,11 +20,14 @@ describe Offline do
   it "should yield packets with a timestamp using loop()" do
     i = 0
     @pkt = nil
-    @pcap.loop(:count => 2) do |this, pkt|
+
+    @pcap.loop(:count => 2) do |this,pkt|
       this.should == @pcap
+
       pkt.should_not be_nil
-      Packet.should === pkt
+      pkt.should be_kind_of(Packet)
       pkt.time.to_i.should > 0
+
       i+=1
     end
     i.should == 2
@@ -41,7 +42,6 @@ describe Offline do
   end
 
   describe "yielding to a block" do
-
     # Note we also test all the behaviors here together instead of seperately.
     Offline.new(PCAP_TESTFILE) do |this|
       @pcap = this
@@ -55,7 +55,6 @@ describe Offline do
 
       @pcap.close
     end
-
   end
 end
 

data/spec/packet_behaviors.rb

@@ -1,32 +1,47 @@
+require 'spec_helper'
 
 shared_examples_for "FFI::PCap::Packet" do
   it "should supply a way to get a pointer for the body" do
     @pkt.body_ptr.should_not be_nil
-    ::FFI::Pointer.should === @pkt.body_ptr
+
+    @pkt.body_ptr.should be_kind_of(FFI::Pointer)
   end
 
   it "should supply a way to get a String for the body" do
     @pkt.body.should_not be_nil
-    String.should === @pkt.body
+
+    @pkt.body.should be_kind_of(String)
   end
 
   it "should supply a timestamp as a Time object" do
     @pkt.time.should_not be_nil
-    Time.should === @pkt.time
+
+    @pkt.time.should be_kind_of(Time)
   end
 
   it "should allow time timestamp to be changed" do
     t = Time.now
-    lambda {@pkt.time = t}.should_not raise_error(Exception)
-    @pkt.time.should == t
+
+    @pkt.time = t
+    @pkt.time.to_i.should == t.to_i
   end
 
   it "should return a deep copy of itself with copy()" do
     cp = @pkt.copy()
+
     cp.object_id.should_not == @pkt.object_id
     cp.body_ptr.object_id.should_not == @pkt.body_ptr.object_id
     cp.body.should == @pkt.body
   end
+
+  it "should marshal and umarshal" do
+    m = Marshal.dump(@pkt)
+    unm = Marshal.load(m)
+
+    unm.should be_kind_of(@pkt.class)
+    unm.time.to_i.should == @pkt.time.to_i
+    unm.body.should == @pkt.body
+  end
 end
 
 shared_examples_for "FFI::PCap::Packet populated" do
@@ -47,7 +62,6 @@ shared_examples_for "FFI::PCap::Packet populated" do
   it "should have a non-null body pointer" do
     @pkt.body_ptr.should_not be_null
   end
-
 end
 
 shared_examples_for "FFI::PCap::Packet composed" do

data/spec/packet_injection_spec.rb

@@ -3,15 +3,15 @@ require 'spec_helper'
 describe FFI::PCap::Live do
   describe "packet injection" do
     before(:all) do
-      @pcap = FFI::PCap.open_live :device => PCAP_DEV, 
-                             :promisc => false,
-                             :timeout => 100,
-                             :snaplen => 8192
+      @pcap = FFI::PCap.open_live(
+        :device  => PCAP_DEV,
+        :promisc => false,
+        :timeout => 100,
+        :snaplen => 8192
+      )
     end
 
-    after(:all) do
-      @pcap.close
-    end
+    after(:all) { @pcap.close }
 
     it "should detect when an invalid argument is supplied" do
       lambda { @pcap.inject(Object.new)}.should raise_error(ArgumentError)
@@ -26,13 +26,14 @@ describe FFI::PCap::Live do
 
     it "should allow injection of a String using inject()" do
       test_data = "A" * 1024
+
       @pcap.inject(test_data).should == test_data.size
     end
 
     it "should allow injection of a Packet using inject()" do
       test_data = "B" * 512
+
       @pcap.inject(Packet.from_string(test_data)).should == test_data.size
     end
-
   end
 end

data/spec/packet_spec.rb

@@ -5,45 +5,41 @@ describe Packet do
   describe 'created using new() with a body string and nil header' do
     before(:all) do
       @test_body = "\xde\xad\xbe\xef"
-      @pkt = Packet.new(nil, @test_body)
+      @pkt = described_class.new(nil, @test_body)
     end
 
     it_should_behave_like "FFI::PCap::Packet composed"
-
   end
 
   describe 'created using new() with a Header and pointer to body' do
     before(:all) do
       @test_body = "\xde\xad\xbe\xef\xba\xbe"
-      l = @test_body.size
-      body = FFI::MemoryPointer.from_string(@test_body)
-      @pkt = Packet.new(PacketHeader.new(:caplen => l, :len => l), body)
+
+      @pkt = described_class.new(
+        PacketHeader.new(:caplen => @test_body.size, :len => @test_body.size),
+        FFI::MemoryPointer.from_string(@test_body)
+      )
     end
 
     it_should_behave_like "FFI::PCap::Packet composed"
-
   end
 
   describe 'created with from_string()' do
     before(:all) do
       @test_body = "\xde\xad\xbe\xef"
-      @pkt = Packet.from_string("\xde\xad\xbe\xef")
+      @pkt = described_class.from_string("\xde\xad\xbe\xef")
     end
   
     it_should_behave_like "FFI::PCap::Packet composed"
-
   end
 
-
   describe 'provided by a libpcap savefile using next()' do
     before(:all) do
       @pcap = FFI::PCap.open_offline(PCAP_TESTFILE)
       @pkt = @pcap.next()
     end
 
-    after(:all) do
-      @pcap.close()
-    end
+    after(:all) { @pcap.close }
 
     it_should_behave_like "FFI::PCap::Packet populated"
   end
@@ -52,60 +48,60 @@ describe Packet do
     before(:all) do
       @pcap = FFI::PCap.open_offline(PCAP_TESTFILE)
       @pkt = nil
+
       # we use copy inside the loop because libpcap's loop() frees or reuses 
       # memory for packets after each call to the handler.
-      @pcap.loop(:count => 1) {|this,pkt| @pkt = pkt.copy }
+      @pcap.loop(:count => 1) { |this,pkt| @pkt = pkt.copy }
     end
 
-    after(:all) do
-      @pcap.close()
-    end
+    after(:all) { @pcap.close() }
 
     it_should_behave_like "FFI::PCap::Packet populated"
   end
 
-
   describe "error detection for new()" do
+    subject { described_class }
+
+    let(:buffer) { FFI::MemoryPointer.new(256) }
+
     it "should raise an error when two nil values are supplied" do
-      lambda { Packet.new(nil,nil)}.should raise_error(Exception)
+      lambda { subject.new(nil,nil)}.should raise_error(Exception)
     end
 
     it "should raise an error for an invalid header" do
       lambda { 
-        Packet.new(Object.new, FFI::MemoryPointer.new(256))
+        subject.new(Object.new, buffer)
       }.should raise_error(Exception)
     end
 
     it "should raise an error for a nil header without a string body" do
       lambda { 
-        Packet.new(nil, FFI::MemoryPointer.new(256))
+        subject.new(nil, buffer)
       }.should raise_error(Exception)
     end
 
     it "should raise an error for a valid header but an invalid body pointer" do
       lambda { 
-        Packet.new(PacketHeader.new, "hellotest")
+        subject.new(PacketHeader.new, "hellotest")
       }.should raise_error(Exception)
     end
 
     it "should not raise an error for a PacketHeader and a pointer" do
       lambda { 
-        Packet.new(PacketHeader.new, FFI::MemoryPointer.new(256))
+        subject.new(PacketHeader.new, buffer)
       }.should_not raise_error(Exception)
     end
 
     it "should not raise an error for a pointer and a pointer" do
       lambda { 
-        Packet.new(FFI::MemoryPointer.new(20), FFI::MemoryPointer.new(256))
+        subject.new(FFI::MemoryPointer.new(20), buffer)
       }.should_not raise_error(Exception)
     end
 
     it "should not raise an error for a nil and a string" do
       lambda { 
-        Packet.new(nil, "hellothere")
+        subject.new(nil, "hellothere")
       }.should_not raise_error(Exception)
-
     end
-
   end
 end

data/spec/pcap_spec.rb

@@ -1,32 +1,31 @@
 require 'spec_helper'
 
 describe FFI::PCap do
-  it "should define a VERSION constant" do
-    FFI::PCap.const_defined?('VERSION').should == true
-  end
+  subject { described_class }
 
   it ".lib_version() should expose the libpcap version banner" do
-    FFI::PCap.lib_version.should_not be_nil
-    FFI::PCap.lib_version.should_not be_empty
+    subject.lib_version.should_not be_nil
+    subject.lib_version.should_not be_empty
   end
 
   it ".lib_version_number() should expose the libpcap version number only" do
-    FFI::PCap.lib_version_number.should_not be_nil
-    FFI::PCap.lib_version_number.should_not be_empty
-    FFI::PCap.lib_version_number.should =~ /^\d+\.\d+\.\d+$/
+    subject.lib_version_number.should =~ /^\d+\.\d+\.\d+$/
   end
 
-  it ".lookupdev() should return a device deafult device" do
-    dev = FFI::PCap.lookupdev
+  it ".lookupdev() should return a device default device" do
+    dev = subject.lookupdev
+
     dev.should_not be_nil
     dev.should_not be_empty
   end
 
   it ".each_device() should enumerate over all usable interfaces" do
     i = 0
-    FFI::PCap.each_device do |dev|
+
+    subject.each_device do |dev|
       dev.should_not be_nil
-      Interface.should === dev
+      dev.should be_kind_of(Interface)
+
       [true,false].include?(dev.loopback?).should == true
       i+=1
     end
@@ -34,39 +33,44 @@ describe FFI::PCap do
   end
 
   it ".device_names() should return names for all network interfaces" do
-    devs = FFI::PCap.device_names
-    Array.should === devs
+    devs = subject.device_names
+    devs.should be_kind_of(Array)
+
     i = 0
+
     devs.each do |dev|
-      String.should === dev
-      dev.should_not be_nil
+      dev.should     be_kind_of(String)
       dev.should_not be_empty
-      i+=1
+
+      i += 1
     end
+
     i.should_not == 0
     devs.include?(PCAP_DEV).should == true
   end
 
   it ".dump_devices() should return name/network pairs for all interfaces" do
     i = 0
-    devs = FFI::PCap.dump_devices
-    Array.should === devs
-    devs.each do |y|
-      y.size.should == 2
-      dev, net = y
-      String.should === dev
-      dev.should_not be_nil
+
+    devs = subject.dump_devices
+    devs.should be_kind_of(Array)
+
+    devs.each do |(dev,net)|
+      dev.should be_kind_of(String)
       dev.should_not be_empty
-      i+=1
+
+      i += 1
     end
+
     i.should_not == 0
+
     devs.select{|dev,net| not net.nil? }.should_not be_empty
     devs.map{|dev,net| dev}.include?(PCAP_DEV).should == true
   end
 
   it ".open_live() should open a live pcap handler given a chosen device" do
     lambda {
-      pcap = FFI::PCap.open_live(:device => PCAP_DEV)
+      pcap = subject.open_live(:device => PCAP_DEV)
       pcap.device.should == PCAP_DEV
       pcap.close
     }.should_not raise_error(Exception)
@@ -77,7 +81,7 @@ describe FFI::PCap do
       # XXX Using Vista and wpcap.dll this breaks on me.
       #     The lookupdev for a default adapter result is '\', which is just
       #     wrong.
-      pcap = FFI::PCap.open_live()
+      pcap = subject.open_live()
       pcap.should be_ready
       pcap.close
     }.should_not raise_error(Exception)
@@ -85,7 +89,7 @@ describe FFI::PCap do
 
   it ".open_dead() should open a dead pcap handler" do
     lambda {
-      pcap = FFI::PCap.open_dead()
+      pcap = subject.open_dead()
       pcap.should be_ready
       pcap.close
     }.should_not raise_error(Exception)
@@ -93,7 +97,7 @@ describe FFI::PCap do
 
   it ".open_offline() should open a pcap dump file" do
     lambda {
-      pcap = FFI::PCap.open_offline(PCAP_TESTFILE)
+      pcap = subject.open_offline(PCAP_TESTFILE)
       pcap.should be_ready
       pcap.close
     }.should_not raise_error(Exception)
@@ -101,7 +105,7 @@ describe FFI::PCap do
 
   it ".open_file() should work the same as .open_offline()" do
     lambda {
-      pcap = FFI::PCap.open_offline(PCAP_TESTFILE)
+      pcap = subject.open_offline(PCAP_TESTFILE)
       pcap.should be_ready
       pcap.close
     }.should_not raise_error(Exception)
@@ -109,12 +113,15 @@ describe FFI::PCap do
 
   it ".open_live() should take a block and close the device after calling it" do
     pcap = nil
-    ret = FFI::PCap.open_live(:device => PCAP_DEV) {|this|
-      Live.should === this
+
+    ret = subject.open_live(:device => PCAP_DEV) do |this|
+      this.should be_kind_of(Live)
       this.should be_ready
       this.should_not be_closed
+
       pcap = this
-    }
+    end
+
     ret.should be_nil
     pcap.should_not be_ready
     pcap.should be_closed
@@ -122,12 +129,15 @@ describe FFI::PCap do
 
   it ".open_dead() should take a block and close the device after calling it" do
     pcap = nil
-    ret = FFI::PCap.open_dead() {|this|
-      Dead.should === this
+
+    ret = subject.open_dead() do |this|
+      this.should be_kind_of(Dead)
       this.should be_ready
       this.should_not be_closed
+
       pcap = this
-    }
+    end
+
     ret.should be_nil
     pcap.should_not be_ready
     ret.should be_nil
@@ -135,15 +145,17 @@ describe FFI::PCap do
 
   it ".open_file() should take a block and close the device after calling it" do
     pcap = nil
-    ret = FFI::PCap.open_file(PCAP_TESTFILE) {|this|
-      Offline.should === this
+
+    ret = subject.open_file(PCAP_TESTFILE) do |this|
+      this.should be_kind_of(Offline)
       this.should be_ready
       this.should_not be_closed
+
       pcap = this
-    }
+    end
+
     ret.should be_nil
     pcap.should_not be_ready
     ret.should be_nil
   end
-
 end