cosmos 3.9.2 → 4.0.0

data/spec/interfaces/linc_interface_spec.rb

@@ -12,8 +12,13 @@ require 'spec_helper'
 require 'cosmos/interfaces/linc_interface'
 
 module Cosmos
-
   describe LincInterface do
+    class TcpipClientStream < TcpipSocketStream
+      # Allow the connect_nonblock method to simply return
+      def connect_nonblock(socket, addr); end
+      def write(data); end
+    end
+
     before(:all) do
       clean_config()
       System.class_eval('@@instance = nil')
@@ -21,11 +26,6 @@ module Cosmos
 
     describe "connect" do
       it "passes a new TcpipClientStream to the stream protocol" do
-        stream = double("stream")
-        allow(stream).to receive(:connect)
-        expect(TcpipClientStream).to receive(:new) { stream }
-        expect(stream).to receive(:connected?) { true }
-        expect(stream).to receive(:raw_logger_pair=) { nil }
         i = LincInterface.new('localhost','8888')
         i.target_names << "INST"
         expect(i.connected?).to be false
@@ -36,17 +36,9 @@ module Cosmos
 
     describe "write" do
       before(:each) do
-        @stream = double("stream")
-        allow(@stream).to receive(:connect)
-        expect(TcpipClientStream).to receive(:new) { @stream }
-        allow(@stream).to receive(:connected?) { true }
-        allow(@stream).to receive(:write)
-        expect(@stream).to receive(:raw_logger_pair=) { nil }
         @i = LincInterface.new('localhost','8888','true','2','nil','5','0','16','4','GSE_HDR_GUID','BIG_ENDIAN','GSE_HDR_LEN')
         @i.target_names << "INST"
-        expect(@i.connected?).to be false
         @i.connect
-        expect(@i.connected?).to be true
       end
 
       it "returns an exception if its not connected" do
@@ -122,13 +114,14 @@ module Cosmos
           @buffer << [3].pack("N")
           @buffer << "BAD"
           @handshake.write("DATA", @buffer)
-
-          allow_any_instance_of(LengthStreamProtocol).to receive(:read).and_return(@handshake)
+          # LincInterface has a length offset of 4
+          @handshake.write("GSE_HDR_LEN", @handshake.buffer(false).length-4)
         end
 
         it "does not timeout if the handshake is received" do
+          allow_any_instance_of(TcpipClientStream).to receive(:read).and_return @handshake.buffer(false)
           t = Thread.new do
-            sleep 1
+            sleep 0.1
             @i.read
           end
           @i.write(@cmd)
@@ -151,33 +144,30 @@ module Cosmos
           buffer << [3].pack("N")
           buffer << "BAD"
           handshake2.write("DATA", buffer)
+          handshake2.write("GSE_HDR_LEN", handshake2.buffer(false).length-4)
 
           read_cnt = 0
           write_cnt = 0
-          allow_any_instance_of(LengthStreamProtocol).to receive(:read) do
+          allow_any_instance_of(TcpipClientStream).to receive(:read) do
             read_cnt += 1
             result = nil
-            result = handshake2 if read_cnt == 1
-            result = @handshake if read_cnt == 2
+            result = handshake2.buffer(false) if read_cnt == 1
+            result = @handshake.buffer(false) if read_cnt == 2
             result
           end
 
           # Create new thread for each write
           t1 = Thread.new do
-            expect(@stream).to receive(:write) do
-              write_cnt += 1
-            end
+            write_cnt += 1
             @i.write(cmd2)
           end
           # Create new thread for each write
           t2 = Thread.new do
-            expect(@stream).to receive(:write) do
-              write_cnt += 1
-            end
+            write_cnt += 1
             @i.write(@cmd)
           end
 
-          sleep 0.5
+          sleep 0.2
           # Expect both write threads have written
           expect(write_cnt).to eql 2
           # But no handshakes have been received
@@ -192,11 +182,12 @@ module Cosmos
         end
 
         it "warns if an error code is set" do
+          allow_any_instance_of(TcpipClientStream).to receive(:read).and_return @handshake.buffer(false)
           expect(Logger).to receive(:warn) do |msg|
             expect(msg).to eql "Warning sending command (12345): BAD"
           end
           t = Thread.new do
-            sleep 1
+            sleep 0.1
             @i.read
           end
           @i.write(@cmd)
@@ -204,9 +195,10 @@ module Cosmos
         end
 
         it "raises an exception if the status is 'ERROR'" do
+          allow_any_instance_of(TcpipClientStream).to receive(:read).and_return @handshake.buffer(false)
           @handshake.write("STATUS", "ERROR")
           t = Thread.new do
-            sleep 1
+            sleep 0.1
             @i.read
           end
           expect { @i.write(@cmd) }.to raise_error("Error sending command (12345): BAD")
@@ -217,12 +209,6 @@ module Cosmos
 
     describe "read" do
       before(:each) do
-        stream = double("stream")
-        allow(stream).to receive(:connect)
-        expect(TcpipClientStream).to receive(:new) { stream }
-        allow(stream).to receive(:connected?) { true }
-        allow(stream).to receive(:write)
-        expect(stream).to receive(:raw_logger_pair=) { nil }
         @i = LincInterface.new('localhost','8888','true','2','nil','5','0','16','4','GSE_HDR_GUID','BIG_ENDIAN','GSE_HDR_LEN')
         @i.target_names << "INST"
         expect(@i.connected?).to be false
@@ -233,9 +219,23 @@ module Cosmos
       it "handles local commands" do
         @handshake = System.telemetry.packet("INST","HANDSHAKE")
         @handshake.write("GSE_HDR_ID", 1001)
+        @handshake.write("STATUS","OK")
+        @handshake.write("CODE", 12345)
         @handshake.write("ORIGIN", 1)
-
-        allow_any_instance_of(LengthStreamProtocol).to receive(:read).and_return(@handshake)
+        buffer = ''
+        buffer << ["INST".length].pack("C")
+        buffer << "INST"
+        buffer << ["LINC_COMMAND".length].pack("C")
+        buffer << "LINC_COMMAND"
+        buffer << [@handshake.buffer.length].pack("N")
+        buffer << @handshake.buffer
+        buffer << [3].pack("N")
+        buffer << "BAD"
+        @handshake.write("DATA", buffer)
+        # LincInterface has a length offset of 4
+        @handshake.write("GSE_HDR_LEN", @handshake.buffer(false).length-4)
+
+        allow_any_instance_of(TcpipClientStream).to receive(:read).and_return @handshake.buffer(false)
 
         expect(Logger).to receive(:info) do |msg|
           expect(msg).to match(/External Command/)
@@ -244,7 +244,5 @@ module Cosmos
         @i.read
       end
     end
-
   end
 end
-

data/spec/interfaces/protocols/burst_protocol_spec.rb

@@ -0,0 +1,300 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'spec_helper'
+require 'cosmos/interfaces/protocols/burst_protocol'
+require 'cosmos/interfaces/interface'
+require 'cosmos/streams/stream'
+
+module Cosmos
+  describe BurstProtocol do
+    before(:each) do
+      @interface = StreamInterface.new
+      allow(@interface).to receive(:connected?) { true }
+    end
+
+    describe "configure_protocol" do
+      it "initializes attributes" do
+        @interface.add_protocol(BurstProtocol, [1, '0xDEADBEEF', true], :READ_WRITE)
+        expect(@interface.read_protocols[0].instance_variable_get(:@data)).to eq ''
+        expect(@interface.read_protocols[0].instance_variable_get(:@discard_leading_bytes)).to eq 1
+        expect(@interface.read_protocols[0].instance_variable_get(:@sync_pattern)).to eq "\xDE\xAD\xBE\xEF"
+        expect(@interface.read_protocols[0].instance_variable_get(:@fill_fields)).to be true
+      end
+    end
+
+    describe "connect" do
+      it "clears the data" do
+        @interface.add_protocol(BurstProtocol, [1, '0xDEADBEEF', true], :READ_WRITE)
+        @interface.read_protocols[0].instance_variable_set(:@data, '\x00\x01\x02\x03')
+        @interface.connect
+        expect(@interface.read_protocols[0].instance_variable_get(:@data)).to eql ''
+      end
+    end
+
+    describe "disconnect" do
+      it "clears the data" do
+        @interface.add_protocol(BurstProtocol, [1, '0xDEADBEEF', true], :READ_WRITE)
+        @interface.read_protocols[0].instance_variable_set(:@data, '\x00\x01\x02\x03')
+        @interface.connect
+        expect(@interface.read_protocols[0].instance_variable_get(:@data)).to eql ''
+      end
+    end
+
+    describe "read_data" do
+      it "reads data from the stream" do
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read; "\x01\x02\x03\x04"; end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [], :READ_WRITE)
+        pkt = @interface.read
+        expect(pkt.length).to eql 4
+      end
+
+      it "handles timeouts from the stream" do
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read; raise Timeout::Error; end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [], :READ_WRITE)
+        expect(@interface.read).to be_nil
+      end
+
+      it "discards leading bytes from the stream" do
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read
+            "\x01\x02\x03\x04"
+          end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [2], :READ_WRITE)
+        pkt = @interface.read
+        expect(pkt.length).to eql 2
+        expect(pkt.buffer.formatted).to match(/03 04/)
+      end
+
+      # The sync pattern is NOT part of the data
+      it "discards the entire sync pattern" do
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read
+            "\x12\x34\x56\x78\x9A\xBC"
+          end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [2, '0x1234'], :READ_WRITE)
+        pkt = @interface.read
+        expect(pkt.length).to eql 4
+        expect(pkt.buffer.formatted).to match(/56 78 9A BC/)
+      end
+
+      # The sync pattern is partially part of the data
+      it "discards part of the sync pattern" do
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read
+            "\x12\x34\x56\x78\x9A\xBC"
+          end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [1, '0x123456'], :READ_WRITE)
+        pkt = @interface.read
+        expect(pkt.length).to eql 5
+        expect(pkt.buffer.formatted).to match(/34 56 78 9A BC/)
+      end
+
+      # The sync pattern is completely part of the data
+      it "handles a sync pattern" do
+        $read_cnt = 0
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read
+            $read_cnt += 1
+            case $read_cnt
+            when 1
+              "\x00\x00\x00\x00\x00\x00"
+            when 2
+              "\x00\x12\x34\x10\x20"
+            when 3
+              ""
+            end
+          end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [0, '0x1234'], :READ_WRITE)
+        pkt = @interface.read
+        expect(pkt.length).to eql 4 # sync plus two bytes
+        expect(pkt.buffer.formatted).to match(/12 34 10 20/)
+      end
+
+      it "handles a sync pattern split across reads" do
+        $read_cnt = 0
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read
+            $read_cnt += 1
+            case $read_cnt
+            when 1
+              "\x00\x00\x00\x00\x00\x00\x00\x12"
+            when 2
+              "\x34\x20"
+            when 3
+              ""
+            end
+          end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [0, '0x1234'], :READ_WRITE)
+        pkt = @interface.read
+        expect(pkt.length).to eql 3 # sync plus one byte
+      end
+
+      it "handles a false positive sync pattern" do
+        $read_cnt = 0
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def read
+            $read_cnt += 1
+            case $read_cnt
+            when 1
+              "\x00\x00\x12\x00\x00\x12"
+            when 2
+              "\x34\x20"
+            when 3
+              ""
+            end
+          end
+        end
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [0, '0x1234'], :READ_WRITE)
+        pkt = @interface.read
+        expect(pkt.length).to eql 3 # sync plus one byte
+      end
+    end
+
+    describe "write" do
+      it "doesn't change the data if fill_fields is false" do
+        $buffer = ''
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def write(buffer) $buffer = buffer; end
+        end
+        data = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x00\x01\x02\x03")
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [0, '0x1234'], :READ_WRITE)
+        data = @interface.write(data)
+        expect($buffer).to eql "\x00\x01\x02\x03"
+      end
+
+      it "complains if the data isn't big enough to hold the sync pattern" do
+        $buffer = ''
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def write(buffer) $buffer = buffer; end
+          def disconnect; end
+        end
+        data = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x00\x00")
+        # Don't discard bytes, include and fill the sync pattern
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [0, '0x12345678', true], :READ_WRITE)
+        # 2 bytes are not enough to hold the 4 byte sync
+        expect { @interface.write(data) }.to raise_error(ArgumentError, /buffer insufficient/)
+      end
+
+      it "fills the sync pattern in the data" do
+        $buffer = ''
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def write(buffer) $buffer = buffer; end
+        end
+        data = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x00\x01\x02\x03")
+        # Don't discard bytes, include and fill the sync pattern
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [0, '0x1234', true], :READ_WRITE)
+        @interface.write(data)
+        expect($buffer).to eql "\x12\x34\x02\x03"
+      end
+
+      it "adds the sync pattern to the data stream" do
+        $buffer = ''
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def write(buffer) $buffer = buffer; end
+        end
+        data = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x00\x01\x02\x03")
+        # Discard first 2 bytes (the sync pattern), include and fill the sync pattern
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [2, '0x12345678', true], :READ_WRITE)
+        @interface.write(data)
+        expect($buffer).to eql "\x12\x34\x56\x78\x02\x03"
+      end
+
+      it "adds part of the sync pattern to the data stream" do
+        $buffer = ''
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def write(buffer) $buffer = buffer; end
+        end
+        data = Packet.new(nil, nil, :BIG_ENDIAN, nil, "\x00\x00\x02\x03")
+        # Discard first byte (part of the sync pattern), include and fill the sync pattern
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [1, '0x123456', true], :READ_WRITE)
+        @interface.write(data)
+        expect($buffer).to eql "\x12\x34\x56\x02\x03"
+      end
+    end
+
+    describe "write_raw" do
+      it "doesnt change the data" do
+        $buffer = ''
+        class MyStream < Stream
+          def connect; end
+          def connected?; true; end
+          def disconnect; end
+          def write(buffer) $buffer = buffer; end
+        end
+        # Discard first 2 bytes (the sync pattern), include and fill the sync pattern
+        @interface.instance_variable_set(:@stream, MyStream.new)
+        @interface.add_protocol(BurstProtocol, [2, '0x1234', true], :READ_WRITE)
+        @interface.write_raw("\x00\x01\x02\x03")
+        expect($buffer).to eql "\x00\x01\x02\x03"
+      end
+    end
+  end
+end