openflow-protocol 0.1.7 → 0.1.8

data/spec/messages/echo_reply_spec.rb

@@ -1,47 +1,45 @@
-require 'spec_helper'
-
-describe OFEchoReply do
+describe OpenFlow::Protocol::EchoReply do
   let(:data) { [1, 3, 0, 8, 0, 0, 0, 1].pack('C*') }
 
   it 'should read binary' do
-    msg = OFEchoReply.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoReply.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_reply)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(1)
     expect(msg.data).to be_empty
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFEchoReply)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::EchoReply)
   end
   it 'should read binary with data' do
-    msg = OFEchoReply.read [1, 3, 0, 10, 0, 0, 0, 1, 10, 20].pack('C*')
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoReply.read [1, 3, 0, 10, 0, 0, 0, 1, 10, 20].pack('C*')
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_reply)
     expect(msg.len).to eq(10)
     expect(msg.xid).to eq(1)
     expect(msg.data.length).to eq(2)
   end
   it 'should initialize with default values' do
-    msg = OFEchoReply.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoReply.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_reply)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(0)
     expect(msg.data).to be_empty
   end
   it 'should initialize with some values' do
-    msg = OFEchoReply.new(xid: 1)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoReply.new(xid: 1)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_reply)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(1)
     expect(msg.data).to be_empty
   end
   it 'should initialize with data' do
-    msg = OFEchoReply.new(data: [10, 20].pack('C*'))
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoReply.new(data: [10, 20].pack('C*'))
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_reply)
     expect(msg.len).to eq(10)
     expect(msg.xid).to eq(0)

data/spec/messages/echo_request_spec.rb

@@ -1,56 +1,54 @@
-require 'spec_helper'
-
-describe OFEchoRequest do
+describe OpenFlow::Protocol::EchoRequest do
   let(:data) { [1, 2, 0, 8, 0, 0, 0, 1].pack('C*') }
 
   it 'should read binary' do
-    msg = OFEchoRequest.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoRequest.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_request)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(1)
     expect(msg.data).to be_empty
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFEchoRequest)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::EchoRequest)
   end
   it 'should read binary with data' do
-    msg = OFEchoRequest.read [1, 2, 0, 10, 0, 0, 0, 1, 10, 20].pack('C*')
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoRequest.read [1, 2, 0, 10, 0, 0, 0, 1, 10, 20].pack('C*')
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_request)
     expect(msg.len).to eq(10)
     expect(msg.xid).to eq(1)
     expect(msg.data.length).to eq(2)
   end
   it 'should initialize with default values' do
-    msg = OFEchoRequest.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoRequest.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_request)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(0)
     expect(msg.data).to be_empty
   end
   it 'should initialize with some values' do
-    msg = OFEchoRequest.new(xid: 1)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoRequest.new(xid: 1)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_request)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(1)
     expect(msg.data).to be_empty
   end
   it 'should initialize with data' do
-    msg = OFEchoRequest.new(data: [10, 20].pack('C*'))
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::EchoRequest.new(data: [10, 20].pack('C*'))
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:echo_request)
     expect(msg.len).to eq(10)
     expect(msg.xid).to eq(0)
     expect(msg.data.length).to eq(2)
   end
-  it 'should convert to OFEchoReply' do
-    msg = OFEchoRequest.new(xid: 1, data: [10, 20].pack('C*'))
+  it 'should convert to OpenFlow::Protocol::EchoReply' do
+    msg = OpenFlow::Protocol::EchoRequest.new(xid: 1, data: [10, 20].pack('C*'))
     msg_reply = msg.to_reply
-    expect(msg_reply.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg_reply.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg_reply.type).to eq(:echo_reply)
     expect(msg.len).to eq(msg_reply.len)
     expect(msg.xid).to eq(msg_reply.xid)

data/spec/messages/error_spec.rb

@@ -1,36 +1,39 @@
-require 'spec_helper'
-
-describe OFError do
+describe OpenFlow::Protocol::Error do
+  let(:hello_msg) {
+    [1, 0, 0, 8, 0, 0, 0, 1].pack('C*')
+  }
   let(:data) {
     [
-      1, 1, 0, 16, 0, 0, 0, 1, # header
+      1, 1, 0, 20, 0, 0, 0, 1, # header
       0, 0,                    # type
-      0, 0,                    # code
-      1, 2, 3, 4               # data
-    ].pack('C*')
+      0, 0                     # code
+    ].pack('C*') + hello_msg
   }
 
   it 'should read binary' do
-    msg = OFError.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::Error.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:error)
-    expect(msg.len).to eq(16)
+    expect(msg.len).to eq(20)
     expect(msg.xid).to eq(1)
     expect(msg.error_type).to eq(:hello_failed)
     expect(msg.error_code).to eq(:incompatible)
-    expect(msg.data).to eq([1, 2, 3, 4].pack('C*'))
+    expect(msg.data).to eq(hello_msg)
+    hello = msg.parsed_data
+    expect(hello.type).to eq(:hello)
+    expect(hello.xid).to eq(1)
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFError)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::Error)
   end
-  it 'should read binary' do
-    msg = OFError.read [
+  it 'should read another binary' do
+    msg = OpenFlow::Protocol::Error.read [
       1, 1, 0, 12, 0, 0, 0, 1, # header
       0, 2,                    # type
       0, 4                     # code
     ].pack('C*')
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:error)
     expect(msg.len).to eq(12)
     expect(msg.xid).to eq(1)
@@ -39,8 +42,8 @@ describe OFError do
     expect(msg.data).to be_empty
   end
   it 'should initialize with default values' do
-    msg = OFError.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::Error.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:error)
     expect(msg.len).to eq(12)
     expect(msg.xid).to eq(0)
@@ -49,12 +52,12 @@ describe OFError do
     expect(msg.data).to be_empty
   end
   it 'should initialize with some values' do
-    msg = OFError.new(
+    msg = OpenFlow::Protocol::Error.new(
       xid: 1,
       error_type: :port_mod_failed,
       error_code: :bad_port
     )
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:error)
     expect(msg.len).to eq(12)
     expect(msg.xid).to eq(1)

data/spec/messages/features_reply_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe OFFeaturesReply do
+describe OpenFlow::Protocol::FeaturesReply do
   let(:data) {
     [
       1, 6, 0, 128, 0, 0, 0, 1, # header
@@ -90,8 +88,8 @@ describe OFFeaturesReply do
   }
 
   it 'should read binary' do
-    msg = OFFeaturesReply.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FeaturesReply.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:features_reply)
     expect(msg.len).to eq(128)
     expect(msg.xid).to eq(1)
@@ -127,16 +125,16 @@ describe OFFeaturesReply do
     expect(msg.ports[1].port_number).to eq(2)
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFFeaturesReply)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::FeaturesReply)
   end
   it 'should read a real binary message' do
-    msg = OFFeaturesReply.read(real_data)
+    msg = OpenFlow::Protocol::FeaturesReply.read(real_data)
     expect(msg.ports.length).to eq(3)
   end
   it 'should initialize with default values' do
-    msg = OFFeaturesReply.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FeaturesReply.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:features_reply)
     expect(msg.len).to eq(32)
     expect(msg.xid).to eq(0)
@@ -148,7 +146,7 @@ describe OFFeaturesReply do
     expect(msg.ports).to be_empty
   end
   it 'should initialize with some values' do
-    msg = OFFeaturesReply.new(
+    msg = OpenFlow::Protocol::FeaturesReply.new(
       xid: 1,
       datapath_id: 42,
       n_buffers: 10,
@@ -177,9 +175,9 @@ describe OFFeaturesReply do
         :set_tp_dst,
         :enqueue
       ],
-      ports: [OFPhysicalPort.new]
+      ports: [OpenFlow::Protocol::PhysicalPort.new]
     )
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:features_reply)
     expect(msg.len).to eq(80)
     expect(msg.xid).to eq(1)

data/spec/messages/features_request_spec.rb

@@ -1,29 +1,27 @@
-require 'spec_helper'
-
-describe OFFeaturesRequest do
+describe OpenFlow::Protocol::FeaturesRequest do
   let(:data) { [1, 5, 0, 8, 0, 0, 0, 1].pack('C*') }
 
   it 'should read binary' do
-    msg = OFFeaturesRequest.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FeaturesRequest.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:features_request)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(1)
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFFeaturesRequest)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::FeaturesRequest)
   end
   it 'should initialize with default values' do
-    msg = OFFeaturesRequest.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FeaturesRequest.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:features_request)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(0)
   end
   it 'should initialize with some values' do
-    msg = OFFeaturesRequest.new(xid: 1)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FeaturesRequest.new(xid: 1)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:features_request)
     expect(msg.len).to eq(8)
     expect(msg.xid).to eq(1)

data/spec/messages/flow_mod_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe OFFlowMod do
+describe OpenFlow::Protocol::FlowMod do
   let(:data) {
     [
       1, 14, 0, 80, 0, 0, 0, 1, # header
@@ -40,8 +38,8 @@ describe OFFlowMod do
   }
 
   it 'should read binary' do
-    msg = OFFlowMod.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FlowMod.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:flow_mod)
     expect(msg.len).to eq(80)
     expect(msg.xid).to eq(1)
@@ -58,12 +56,12 @@ describe OFFlowMod do
     expect(msg.actions.first.type).to eq(:output)
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFFlowMod)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::FlowMod)
   end
   it 'should initialize with default values' do
-    msg = OFFlowMod.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FlowMod.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:flow_mod)
     expect(msg.len).to eq(72)
     expect(msg.xid).to eq(0)
@@ -79,7 +77,7 @@ describe OFFlowMod do
     expect(msg.actions).to be_empty
   end
   it 'should initialize with some values' do
-    msg = OFFlowMod.new(
+    msg = OpenFlow::Protocol::FlowMod.new(
       xid: 1,
       match: {
         wildcards: {
@@ -105,9 +103,9 @@ describe OFFlowMod do
       priority: 3000,
       buffer_id: 1,
       flags: [:send_flow_removed],
-      actions: [OFActionOutput.new(port: 1)]
+      actions: [OpenFlow::Protocol::ActionOutput.new(port: 1)]
     )
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:flow_mod)
     expect(msg.len).to eq(80)
     expect(msg.xid).to eq(1)
@@ -124,12 +122,12 @@ describe OFFlowMod do
     expect(msg.actions.first.type).to eq(:output)
   end
   it 'should initialize with some other values' do
-    msg = OFFlowMod.new(
+    msg = OpenFlow::Protocol::FlowMod.new(
       xid: 1,
       cookie: 2,
       command: :delete
     )
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:flow_mod)
     expect(msg.len).to eq(72)
     expect(msg.xid).to eq(1)

data/spec/messages/flow_removed_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe OFFlowRemoved do
+describe OpenFlow::Protocol::FlowRemoved do
   let(:data) {
     [
       1, 11, 0, 88, 0, 0, 0, 1, # header
@@ -36,8 +34,8 @@ describe OFFlowRemoved do
   }
 
   it 'should read binary' do
-    msg = OFFlowRemoved.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FlowRemoved.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:flow_removed)
     expect(msg.len).to eq(88)
     expect(msg.xid).to eq(1)
@@ -52,12 +50,12 @@ describe OFFlowRemoved do
     expect(msg.byte_count).to eq(80)
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFFlowRemoved)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::FlowRemoved)
   end
   it 'should initialize with default values' do
-    msg = OFFlowRemoved.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::FlowRemoved.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:flow_removed)
     expect(msg.len).to eq(88)
     expect(msg.xid).to eq(0)
@@ -72,7 +70,7 @@ describe OFFlowRemoved do
     expect(msg.byte_count).to eq(0)
   end
   it 'should initialize with some values' do
-    msg = OFFlowRemoved.new(
+    msg = OpenFlow::Protocol::FlowRemoved.new(
       xid: 1,
       match: {
         wildcards: {
@@ -100,7 +98,7 @@ describe OFFlowRemoved do
       packet_count: 10,
       byte_count: 80
     )
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:flow_removed)
     expect(msg.len).to eq(88)
     expect(msg.xid).to eq(1)

data/spec/messages/get_config_reply_spec.rb

@@ -1,6 +1,4 @@
-require 'spec_helper'
-
-describe OFGetConfigReply do
+describe OpenFlow::Protocol::GetConfigReply do
   let(:data) {
     [
       1, 8, 0, 12, 0, 0, 0, 1, # header
@@ -10,8 +8,8 @@ describe OFGetConfigReply do
   }
 
   it 'should read binary' do
-    msg = OFGetConfigReply.read(data)
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::GetConfigReply.read(data)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:get_config_reply)
     expect(msg.len).to eq(12)
     expect(msg.xid).to eq(1)
@@ -19,12 +17,12 @@ describe OFGetConfigReply do
     expect(msg.miss_send_length).to eq(0xff)
   end
   it 'should be parsable' do
-    msg = OFParser.read(data)
-    expect(msg.class).to eq(OFGetConfigReply)
+    msg = OpenFlow::Protocol::Parser.read(data)
+    expect(msg.class).to eq(OpenFlow::Protocol::GetConfigReply)
   end
   it 'should initialize with default values' do
-    msg = OFGetConfigReply.new
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    msg = OpenFlow::Protocol::GetConfigReply.new
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:get_config_reply)
     expect(msg.len).to eq(12)
     expect(msg.xid).to eq(0)
@@ -32,12 +30,12 @@ describe OFGetConfigReply do
     expect(msg.miss_send_length).to eq(0)
   end
   it 'should initialize with some values' do
-    msg = OFGetConfigReply.new(
+    msg = OpenFlow::Protocol::GetConfigReply.new(
       xid: 1,
       flags: :fragments_normal,
       miss_send_length: 0xff
     )
-    expect(msg.version).to eq(OFMessage::OFP_VERSION)
+    expect(msg.version).to eq(OpenFlow::Protocol::Message::OFP_VERSION)
     expect(msg.type).to eq(:get_config_reply)
     expect(msg.len).to eq(12)
     expect(msg.xid).to eq(1)