pio 0.3.0 → 0.4.0

data/spec/pio/arp/request/options_spec.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+require 'pio'
+
+describe Pio::Arp::Request::Options, '.new' do
+  Given(:mandatory_options) do
+    {
+      source_mac: 0x002682ebead1,
+      sender_protocol_address: 0xc0a85303,
+      target_protocol_address: 0xc0a853fe
+    }
+  end
+
+  context 'with all mandatory options' do
+    Given(:options) do
+      Pio::Arp::Request::Options.new(mandatory_options)
+    end
+
+    describe '#to_hash' do
+      When(:result) { options.to_hash }
+
+      Then { result[:source_mac] == Pio::Mac.new(0x002682ebead1) }
+      Then do
+        result[:sender_protocol_address] == Pio::IPv4Address.new(0xc0a85303)
+      end
+      Then do
+        result[:target_protocol_address] == Pio::IPv4Address.new(0xc0a853fe)
+      end
+    end
+  end
+
+  context 'when source_mac is not passed' do
+    Given(:user_options) do
+      mandatory_options.delete(:source_mac)
+      mandatory_options
+    end
+
+    When(:result) { Pio::Arp::Request::Options.new(user_options) }
+
+    Then do
+      result ==
+        Failure(ArgumentError, 'The source_mac option should be passed.')
+    end
+  end
+
+  context 'with source_mac = nil' do
+    Given(:user_options) do
+      mandatory_options.update(source_mac: nil)
+      mandatory_options
+    end
+
+    When(:result) { Pio::Arp::Request::Options.new(user_options) }
+
+    Then do
+      result ==
+        Failure(ArgumentError, "The source_mac option shouldn't be nil.")
+    end
+  end
+
+  context 'when sender_protocol_address is not passed' do
+    Given(:user_options) do
+      mandatory_options.delete(:sender_protocol_address)
+      mandatory_options
+    end
+
+    When(:result) { Pio::Arp::Request::Options.new(user_options) }
+
+    Then do
+      result == Failure(ArgumentError,
+                        'The sender_protocol_address option should be passed.')
+    end
+  end
+
+  context 'with sender_protocol_address = nil' do
+    Given(:user_options) do
+      mandatory_options.update(sender_protocol_address: nil)
+      mandatory_options
+    end
+
+    When(:result) { Pio::Arp::Request::Options.new(user_options) }
+
+    Then do
+      result == Failure(ArgumentError,
+                        "The sender_protocol_address option shouldn't be nil.")
+    end
+  end
+
+  context 'when target_protocol_address is not passed' do
+    Given(:user_options) do
+      mandatory_options.delete(:target_protocol_address)
+      mandatory_options
+    end
+
+    When(:result) { Pio::Arp::Request::Options.new(user_options) }
+
+    Then do
+      result == Failure(ArgumentError,
+                        'The target_protocol_address option should be passed.')
+    end
+  end
+
+  context 'with target_protocol_address = nil' do
+    Given(:user_options) do
+      mandatory_options.update(target_protocol_address: nil)
+      mandatory_options
+    end
+
+    When(:result) { Pio::Arp::Request::Options.new(user_options) }
+
+    Then do
+      result == Failure(ArgumentError,
+                        "The target_protocol_address option shouldn't be nil.")
+    end
+  end
+end

data/spec/pio/arp/request_spec.rb

@@ -1,119 +1,97 @@
-# -*- coding: utf-8 -*-
-require 'pio/arp/request'
+# encoding: utf-8
 
-describe Pio::Arp::Request do
-  context '.new' do
-    subject do
+require 'pio'
+
+describe Pio::ARP::Request do
+  Then { Pio::ARP::Request == Pio::Arp::Request }
+end
+
+describe Pio::Arp::Request, '.new' do
+  ARP_REQUEST_DUMP =
+    [
+      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, # destination mac address
+      0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # source mac address
+      0x08, 0x06,                         # ethernet type
+      0x00, 0x01,                         # arp hardware type
+      0x08, 0x00,                         # arp protocol type
+      0x06,                               # hardware address size
+      0x04,                               # protocol address size
+      0x00, 0x01,                         # operational code
+      0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # sender hardware address
+      0xc0, 0xa8, 0x53, 0x03,             # sender protocol address
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # target hardware address
+      0xc0, 0xa8, 0x53, 0xfe,             # target protocol address
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # padding
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00
+    ].pack('C*')
+
+  context 'with String MAC and IP address' do
+    Given(:arp_request) do
       Pio::Arp::Request.new(
-        :source_mac => source_mac,
-        :sender_protocol_address => sender_protocol_address,
-        :target_protocol_address => target_protocol_address
+        source_mac: '00:26:82:eb:ea:d1',
+        sender_protocol_address: '192.168.83.3',
+        target_protocol_address: '192.168.83.254'
       )
     end
 
-    let(:arp_request_dump) do
-      [
-       0xff, 0xff, 0xff, 0xff, 0xff, 0xff, # destination mac address
-       0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # source mac address
-       0x08, 0x06,                         # ethernet type
-       0x00, 0x01,                         # arp hardware type
-       0x08, 0x00,                         # arp protocol type
-       0x06,                               # hardware address size
-       0x04,                               # protocol address size
-       0x00, 0x01,                         # operational code
-       0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # sender hardware address
-       0xc0, 0xa8, 0x53, 0x03,             # sender protocol address
-       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # target hardware address
-       0xc0, 0xa8, 0x53, 0xfe,             # target protocol address
-       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # padding
-       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-       0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-       0x00, 0x00, 0x00, 0x00,
-      ].pack('C*')
-    end
-
-    context 'with Integer MAC and IP address' do
-      let(:source_mac) { 0x002682ebead1 }
-      let(:sender_protocol_address) { 0xc0a85303 }
-      let(:target_protocol_address) { 0xc0a853fe }
+    describe '#to_binary' do
+      When(:result) { arp_request.to_binary }
 
-      context '#to_binary' do
-        it 'returns an Arp Request binary String' do
-          expect(subject.to_binary).to eq arp_request_dump
-        end
-
-        it 'returns a valid ether frame with size = 64' do
-          expect(subject.to_binary.size).to eq 64
-        end
-      end
+      Then { result == ARP_REQUEST_DUMP }
+      And { result.size == 64 }
     end
+  end
 
-    context 'with String MAC and IP address' do
-      let(:source_mac) { '00:26:82:eb:ea:d1' }
-      let(:sender_protocol_address) { 0xc0a85303 }
-      let(:target_protocol_address) { 0xc0a853fe }
-
-      context '#to_binary' do
-        it 'returns an Arp Request binary String' do
-          expect(subject.to_binary).to eq arp_request_dump
-        end
-
-        it 'returns a valid ether frame with size = 64' do
-          expect(subject.to_binary.size).to eq 64
-        end
-      end
+  context 'with Integer MAC address and IP address' do
+    Given(:arp_request) do
+      Pio::Arp::Request.new(
+        source_mac: 0x002682ebead1,
+        sender_protocol_address: 0xc0a85303,
+        target_protocol_address: 0xc0a853fe
+      )
     end
 
-    context 'with Integer MAC and String IP address' do
-      let(:source_mac) { 0x002682ebead1 }
-      let(:sender_protocol_address) { '192.168.83.3' }
-      let(:target_protocol_address) { '192.168.83.254' }
+    describe '#to_binary' do
+      When(:result) { arp_request.to_binary }
 
-      context '#to_binary' do
-        it 'returns an Arp Request binary String' do
-          expect(subject.to_binary).to eq arp_request_dump
-        end
+      Then { result == ARP_REQUEST_DUMP }
+      And { result.size == 64 }
+    end
+  end
 
-        it 'returns a valid ether frame with size = 64' do
-          expect(subject.to_binary.size).to eq 64
-        end
-      end
+  context 'with String MAC and Integer IP address' do
+    Given(:arp_request) do
+      Pio::Arp::Request.new(
+        source_mac: '00:26:82:eb:ea:d1',
+        sender_protocol_address: 0xc0a85303,
+        target_protocol_address: 0xc0a853fe
+      )
     end
 
-    context 'when :source_mac is not set' do
-      let(:source_mac) { nil }
-      let(:sender_protocol_address) { '192.168.83.3' }
-      let(:target_protocol_address) { '192.168.83.254' }
+    describe '#to_binary' do
+      When(:result) { arp_request.to_binary }
 
-      it 'raises an invalid MAC address error' do
-        expect { subject }.to raise_error('Invalid MAC address: nil')
-      end
+      Then { result == ARP_REQUEST_DUMP }
+      And { result.size == 64 }
     end
+  end
 
-    context 'when :sender_protocol_address is not set' do
-      let(:source_mac) { 0x002682ebead1 }
-      let(:sender_protocol_address) { nil }
-      let(:target_protocol_address) { '192.168.83.254' }
-
-      it 'raises an invalid IPv4 address error' do
-        expect { subject }.to raise_error('Invalid IPv4 address: nil')
-      end
+  context 'with Integer MAC and String IP address' do
+    Given(:arp_request) do
+      Pio::Arp::Request.new(
+        source_mac: 0x002682ebead1,
+        sender_protocol_address: '192.168.83.3',
+        target_protocol_address: '192.168.83.254'
+      )
     end
 
-    context 'when :target_protocol_address is not set' do
-      let(:source_mac) { 0x002682ebead1 }
-      let(:sender_protocol_address) { '192.168.83.254' }
-      let(:target_protocol_address) { nil }
+    describe '#to_binary' do
+      When(:result) { arp_request.to_binary }
 
-      it 'raises an invalid IPv4 address error' do
-        expect { subject }.to raise_error('Invalid IPv4 address: nil')
-      end
+      Then { result == ARP_REQUEST_DUMP }
+      And { result.size == 64 }
     end
   end
 end
-
-### Local variables:
-### mode: Ruby
-### coding: utf-8-unix
-### indent-tabs-mode: nil
-### End:

data/spec/pio/arp_spec.rb

@@ -1,127 +1,93 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
+
 require 'pio'
 
-describe Pio::Arp do
-  context '.read' do
-    subject { Pio::Arp.read(data.pack('C*')) }
+describe Pio::ARP do
+  Then { Pio::ARP == Pio::Arp }
+end
 
-    context 'with an ARP Request packet' do
-      let(:data) do
+describe Pio::Arp do
+  describe '.read' do
+    context 'with an Arp Request packet' do
+      Given(:arp_request_dump) do
         [
-         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, # destination mac address
-         0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # source mac address
-         0x08, 0x06,                         # ethernet type
-         0x00, 0x01,                         # arp hardware type
-         0x08, 0x00,                         # arp protocol type
-         0x06,                               # hardware address size
-         0x04,                               # protocol address size
-         0x00, 0x01,                         # operational code
-         0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # sender hardware address
-         0xc0, 0xa8, 0x53, 0x03,             # sender protocol address
-         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # target hardware address
-         0xc0, 0xa8, 0x53, 0xfe,             # target protocol address
-        ]
+          0xff, 0xff, 0xff, 0xff, 0xff, 0xff, # destination mac address
+          0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # source mac address
+          0x08, 0x06,                         # ethernet type
+          0x00, 0x01,                         # arp hardware type
+          0x08, 0x00,                         # arp protocol type
+          0x06,                               # hardware address size
+          0x04,                               # protocol address size
+          0x00, 0x01,                         # operational code
+          0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # sender hardware address
+          0xc0, 0xa8, 0x53, 0x03,             # sender protocol address
+          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, # target hardware address
+          0xc0, 0xa8, 0x53, 0xfe,             # target protocol address
+        ].pack('C*')
       end
 
-      its(:class) { should be Pio::Arp::Request }
-      its('destination_mac.to_s') { should eq 'ff:ff:ff:ff:ff:ff' }
-      its('source_mac.to_s') { should eq '00:26:82:eb:ea:d1' }
-      its(:ether_type) { should eq 0x0806 }
-      its(:hardware_type) { should eq 1 }
-      its(:protocol_type) { should eq 0x800 }
-      its(:hardware_length) { should eq 6 }
-      its(:protocol_length) { should eq 4 }
-      its(:operation) { should eq 1 }
-      its('sender_hardware_address.to_s') { should eq '00:26:82:eb:ea:d1' }
-      its('sender_protocol_address.to_s') { should eq '192.168.83.3' }
-      its('target_hardware_address.to_s') { should eq '00:00:00:00:00:00' }
-      its('target_protocol_address.to_s') { should eq '192.168.83.254' }
-    end
-
-    context 'with an ARP Reply packet' do
-      let(:data) do
-        [
-         0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # destination mac address
-         0x00, 0x16, 0x9d, 0x1d, 0x9c, 0xc4, # source mac address
-         0x08, 0x06,                         # ethernet type
-         0x00, 0x01,                         # arp hardware type
-         0x08, 0x00,                         # arp protocol type
-         0x06,                               # hardware address size
-         0x04,                               # protocol address size
-         0x00, 0x02,                         # operational code
-         0x00, 0x16, 0x9d, 0x1d, 0x9c, 0xc4, # sender hardware address
-         0xc0, 0xa8, 0x53, 0xfe,             # sender protocol address
-         0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # target hardware address
-         0xc0, 0xa8, 0x53, 0x03,             # target protocol address
-        ]
+      When(:arp_request) do
+        Pio::Arp.read(arp_request_dump)
       end
 
-      its(:class) { should be Pio::Arp::Reply }
-      its('destination_mac.to_s') { should eq '00:26:82:eb:ea:d1' }
-      its('source_mac.to_s') { should eq '00:16:9d:1d:9c:c4' }
-      its(:ether_type) { should eq 0x0806 }
-      its(:hardware_type) { should eq 1 }
-      its(:protocol_type) { should eq 0x800 }
-      its(:hardware_length) { should eq 6 }
-      its(:protocol_length) { should eq 4 }
-      its(:operation) { should eq 2 }
-      its('sender_hardware_address.to_s') { should eq '00:16:9d:1d:9c:c4' }
-      its('sender_protocol_address.to_s') { should eq '192.168.83.254' }
-      its('target_hardware_address.to_s') { should eq '00:26:82:eb:ea:d1' }
-      its('target_protocol_address.to_s') { should eq '192.168.83.3' }
+      Then { arp_request.class == Pio::Arp::Request }
+      Then { arp_request.destination_mac.to_s == 'ff:ff:ff:ff:ff:ff' }
+      Then { arp_request.source_mac.to_s == '00:26:82:eb:ea:d1' }
+      Then { arp_request.ether_type == 0x0806 }
+      Then { arp_request.hardware_type == 1 }
+      Then { arp_request.protocol_type == 0x800 }
+      Then { arp_request.hardware_length == 6 }
+      Then { arp_request.protocol_length == 4 }
+      Then { arp_request.operation == 1 }
+      Then { arp_request.sender_hardware_address.to_s == '00:26:82:eb:ea:d1' }
+      Then { arp_request.sender_protocol_address.to_s == '192.168.83.3' }
+      Then { arp_request.target_hardware_address.to_s == '00:00:00:00:00:00' }
+      Then { arp_request.target_protocol_address.to_s == '192.168.83.254' }
     end
 
-    context 'with an ARP Request captured in real environment' do
-      let(:data) do
+    context 'with an Arp Reply packet' do
+      Given(:arp_reply_dump) do
         [
-         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x5c, 0x9a, 0xd8, 0xea,
-         0x37, 0x32, 0x08, 0x06, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04,
-         0x00, 0x01, 0x5c, 0x9a, 0xd8, 0xea, 0x37, 0x32, 0xc0, 0xa8,
-         0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8,
-         0x00, 0xfe
-        ]
+          0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # destination mac address
+          0x00, 0x16, 0x9d, 0x1d, 0x9c, 0xc4, # source mac address
+          0x08, 0x06,                         # ethernet type
+          0x00, 0x01,                         # arp hardware type
+          0x08, 0x00,                         # arp protocol type
+          0x06,                               # hardware address size
+          0x04,                               # protocol address size
+          0x00, 0x02,                         # operational code
+          0x00, 0x16, 0x9d, 0x1d, 0x9c, 0xc4, # sender hardware address
+          0xc0, 0xa8, 0x53, 0xfe,             # sender protocol address
+          0x00, 0x26, 0x82, 0xeb, 0xea, 0xd1, # target hardware address
+          0xc0, 0xa8, 0x53, 0x03,             # target protocol address
+        ].pack('C*')
       end
-      it { expect { subject }.not_to raise_error }
-    end
 
-    context 'with an ARP Request from a real OpenFlow switch' do
-      let(:data) do
-        [
-         0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x11, 0x22, 0x33, 0x44,
-         0x55, 0x66, 0x08, 0x06, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04,
-         0x00, 0x01, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xc0, 0xa8,
-         0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xa8,
-         0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-         0x00, 0x00, 0x00, 0x00
-        ]
+      When(:arp_reply) do
+        Pio::Arp.read(arp_reply_dump)
       end
-      it { expect { subject }.not_to raise_error }
-    end
 
-    context 'with an ARP Reply captured in real environment' do
-      let(:data) do
-        [
-         0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x5c, 0x9a, 0xd8, 0xea,
-         0x37, 0x32, 0x08, 0x06, 0x00, 0x01, 0x08, 0x00, 0x06, 0x04,
-         0x00, 0x02, 0x5c, 0x9a, 0xd8, 0xea, 0x37, 0x32, 0xc0, 0xa8,
-         0x00, 0x01, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0xc0, 0xa8,
-         0x00, 0xfe
-        ]
-      end
-      it { expect { subject }.not_to raise_error }
+      Then { arp_reply.class == Pio::Arp::Reply }
+      Then { arp_reply.destination_mac.to_s == '00:26:82:eb:ea:d1' }
+      Then { arp_reply.source_mac.to_s == '00:16:9d:1d:9c:c4' }
+      Then { arp_reply.ether_type == 0x0806 }
+      Then { arp_reply.hardware_type == 1 }
+      Then { arp_reply.protocol_type == 0x800 }
+      Then { arp_reply.hardware_length == 6 }
+      Then { arp_reply.protocol_length == 4 }
+      Then { arp_reply.operation == 2 }
+      Then { arp_reply.sender_hardware_address.to_s == '00:16:9d:1d:9c:c4' }
+      Then { arp_reply.sender_protocol_address.to_s == '192.168.83.254' }
+      Then { arp_reply.target_hardware_address.to_s == '00:26:82:eb:ea:d1' }
+      Then { arp_reply.target_protocol_address.to_s == '192.168.83.3' }
     end
 
     context 'with an invalid ARP packet' do
-      let(:data) { [] }
+      When(:result) do
+        Pio::Arp.read('')
+      end
 
-      it { expect { subject }.to raise_error(Pio::ParseError) }
+      Then { result == Failure(Pio::ParseError, 'End of file reached') }
     end
   end
 end
-
-### Local variables:
-### mode: Ruby
-### coding: utf-8-unix
-### indent-tabs-mode: nil
-### End: