cosmos 4.5.2 → 5.0.2.pre.beta2

data/spec/tools/cmd_tlm_server/connections_spec.rb

@@ -1,231 +0,0 @@
-# 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'
-require 'cosmos/tools/cmd_tlm_server/connections'
-require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server_config'
-require 'tempfile'
-
-module Cosmos
-
-  describe Connections do
-    describe "initialize" do
-      it "only allows :ROUTERS or :INTERFACES" do
-        tf = Tempfile.new('unittest')
-        tf.close
-        expect { Connections.new(:BLAH, CmdTlmServerConfig.new(tf.path)) }.to raise_error("Unknown type: BLAH. Must be :INTERFACES or :ROUTERS.")
-        tf.unlink
-      end
-    end
-
-    describe "start" do
-      it "calls connect for each connection" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'ROUTER MY_ROUTER interface.rb'
-        tf.close
-        routers = Connections.new(:ROUTERS, CmdTlmServerConfig.new(tf.path))
-        expect { routers.start }.to raise_error("Connections start_thread method not implemented")
-        tf.unlink
-      end
-    end
-
-    describe "stop" do
-      it "calls disconnect for each connection" do
-        allow_any_instance_of(Interface).to receive(:disconnect)
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE MY_INT interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect { interfaces.stop }.to raise_error("Connections stop_thread method not implemented")
-        tf.unlink
-      end
-    end
-
-    describe "connect" do
-      it "calls start_thread with no parameters" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE MY_INT interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces).to receive(:start_thread)
-        interfaces.connect("MY_INT")
-        tf.unlink
-      end
-
-      it "calls disconnect, recreate and start_thread with parameters" do
-        allow_any_instance_of(Interface).to receive(:disconnect)
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE MY_INT interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces).to receive(:stop_thread)
-        expect(interfaces).to receive(:start_thread)
-        expect(interfaces).to receive(:recreate)
-        interfaces.connect("MY_INT", "param")
-        tf.unlink
-      end
-    end
-
-    describe "recreate" do
-      it "raises an error" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE MY_INT interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect { interfaces.recreate("MY_INT") }.to raise_error("Connections recreate method not implemented")
-        tf.unlink
-      end
-    end
-
-    describe "state" do
-      it "relays the state of the connection" do
-        allow_any_instance_of(Interface).to receive(:connected?).and_return(false, true, false)
-        allow_any_instance_of(Interface).to receive(:thread).and_return(true, nil)
-
-        tf = Tempfile.new('unittest')
-        tf.puts 'ROUTER MY_ROUTER interface.rb'
-        tf.close
-        routers = Connections.new(:ROUTERS, CmdTlmServerConfig.new(tf.path))
-        expect(routers.state("MY_ROUTER")).to eql "ATTEMPTING"
-        expect(routers.state("MY_ROUTER")).to eql "CONNECTED"
-        expect(routers.state("MY_ROUTER")).to eql "DISCONNECTED"
-        tf.unlink
-      end
-    end
-
-    describe "names" do
-      it "lists all the names" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'ROUTER ROUTER1 interface.rb'
-        tf.puts 'ROUTER ROUTER2 interface.rb'
-        tf.puts 'ROUTER ROUTER3 interface.rb'
-        tf.close
-        routers = Connections.new(:ROUTERS, CmdTlmServerConfig.new(tf.path))
-        expect(routers.names).to eql %w(ROUTER1 ROUTER2 ROUTER3)
-        tf.unlink
-      end
-    end
-
-    describe "clear_counters" do
-      it "clears all counters" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE INTERFACE1 interface.rb'
-        tf.puts 'INTERFACE INTERFACE2 interface.rb'
-        tf.puts 'INTERFACE INTERFACE3 interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        interfaces.all.each do |name, interface|
-          interface.bytes_written = 100
-          interface.bytes_read = 200
-          interface.write_count = 10
-          interface.read_count = 20
-        end
-        interfaces.clear_counters
-        interfaces.all.each do |name, interface|
-          expect(interface.bytes_written).to eql 0
-          expect(interface.bytes_read).to eql 0
-          expect(interface.write_count).to eql 0
-          expect(interface.read_count).to eql 0
-        end
-        tf.unlink
-      end
-    end
-
-    describe "start_raw_logging" do
-      it "starts raw logging on all connections by default" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE INTERFACE1 interface.rb'
-        tf.puts 'INTERFACE INTERFACE2 interface.rb'
-        tf.puts 'INTERFACE INTERFACE3 interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces.all['INTERFACE1']).to receive(:start_raw_logging)
-        expect(interfaces.all['INTERFACE2']).to receive(:start_raw_logging)
-        expect(interfaces.all['INTERFACE3']).to receive(:start_raw_logging)
-        interfaces.start_raw_logging
-        tf.unlink
-      end
-
-      it "starts raw logging on a specified connections by name" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE INTERFACE1 interface.rb'
-        tf.puts 'INTERFACE INTERFACE2 interface.rb'
-        tf.puts 'INTERFACE INTERFACE3 interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces.all['INTERFACE1']).to_not receive(:start_raw_logging)
-        expect(interfaces.all['INTERFACE2']).to receive(:start_raw_logging)
-        expect(interfaces.all['INTERFACE3']).to_not receive(:start_raw_logging)
-        interfaces.start_raw_logging('INTERFACE2')
-        tf.unlink
-      end
-
-      it "raises on an unknown connection" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE INTERFACE1 interface.rb'
-        tf.puts 'INTERFACE INTERFACE2 interface.rb'
-        tf.puts 'INTERFACE INTERFACE3 interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces.all['INTERFACE1']).to_not receive(:start_raw_logging)
-        expect(interfaces.all['INTERFACE2']).to_not receive(:start_raw_logging)
-        expect(interfaces.all['INTERFACE3']).to_not receive(:start_raw_logging)
-        expect { interfaces.start_raw_logging('BLAH') }.to raise_error(/Unknown/)
-        tf.unlink
-      end
-    end
-
-    describe "stop_raw_logging" do
-      it "stops raw logging on all connections by default" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE INTERFACE1 interface.rb'
-        tf.puts 'INTERFACE INTERFACE2 interface.rb'
-        tf.puts 'INTERFACE INTERFACE3 interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces.all['INTERFACE1']).to receive(:stop_raw_logging)
-        expect(interfaces.all['INTERFACE2']).to receive(:stop_raw_logging)
-        expect(interfaces.all['INTERFACE3']).to receive(:stop_raw_logging)
-        interfaces.stop_raw_logging
-        tf.unlink
-      end
-
-      it "stops raw logging on a specified connections by name" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE INTERFACE1 interface.rb'
-        tf.puts 'INTERFACE INTERFACE2 interface.rb'
-        tf.puts 'INTERFACE INTERFACE3 interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces.all['INTERFACE1']).to_not receive(:stop_raw_logging)
-        expect(interfaces.all['INTERFACE2']).to receive(:stop_raw_logging)
-        expect(interfaces.all['INTERFACE3']).to_not receive(:stop_raw_logging)
-        interfaces.stop_raw_logging('INTERFACE2')
-        tf.unlink
-      end
-
-      it "raises on an unknown connection" do
-        tf = Tempfile.new('unittest')
-        tf.puts 'INTERFACE INTERFACE1 interface.rb'
-        tf.puts 'INTERFACE INTERFACE2 interface.rb'
-        tf.puts 'INTERFACE INTERFACE3 interface.rb'
-        tf.close
-        interfaces = Connections.new(:INTERFACES, CmdTlmServerConfig.new(tf.path))
-        expect(interfaces.all['INTERFACE1']).to_not receive(:stop_raw_logging)
-        expect(interfaces.all['INTERFACE2']).to_not receive(:stop_raw_logging)
-        expect(interfaces.all['INTERFACE3']).to_not receive(:stop_raw_logging)
-        expect { interfaces.stop_raw_logging('BLAH') }.to raise_error(/Unknown/)
-        tf.unlink
-      end
-    end
-  end
-end
-

data/spec/tools/cmd_tlm_server/interface_thread_spec.rb

@@ -1,319 +0,0 @@
-# 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'
-require 'cosmos/tools/cmd_tlm_server/interface_thread'
-require 'cosmos/interfaces/interface'
-
-module Cosmos
-
-  describe InterfaceThread do
-
-    before(:each) do
-      @packet = Packet.new('TGT','PKT')
-      @packet.buffer = "\x01\x02"
-
-      @interface = Interface.new
-      @connected_count = 0
-      allow(@interface).to receive(:connected?) do
-        if @connected_count == 0
-          @connected_count += 1
-          false
-        else
-          @connected_count += 1
-          true
-        end
-      end
-      allow(@interface).to receive(:connect)
-      allow(@interface).to receive(:disconnect)
-      allow(@interface).to receive(:read) do
-        sleep 0.01
-        @packet
-      end
-
-      allow(System).to receive_message_chain(:telemetry,:packet).and_return(@packet)
-      allow(System).to receive_message_chain(:telemetry,:identify).and_return(nil)
-      allow(System).to receive_message_chain(:telemetry,:identify_and_define_packet).and_return(@packet)
-      targets = {'TGT'=>Target.new('TGT')}
-      allow(System).to receive(:targets).and_return(targets)
-    end
-
-    after(:all) do
-      Dir[File.join(Cosmos::USERPATH,"*_exception.txt")].each do |file|
-        File.delete file
-      end
-    end
-
-    describe "start" do
-      it "logs connection errors" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:connected?).and_return(false)
-          allow(@interface).to receive(:connect) { raise "ConnectError" }
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-
-          expect(stdout.string).to match("Connection Failed: RuntimeError : ConnectError")
-        end
-      end
-
-      it "does not log connection errors when there is a callback" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:connected?).and_return(false)
-          allow(@interface).to receive(:connect) { raise "ConnectError" }
-          # Make the reconnect_delay be 0.2 so we see the initial error and a
-          # reconnect error during the 0.3 sleep after starting the thread
-          @interface.reconnect_delay = 0.2
-          thread = InterfaceThread.new(@interface)
-          error_count = 0
-          thread.connection_failed_callback = Proc.new do |error|
-            expect(error.message).to eql "ConnectError"
-            error_count += 1
-          end
-          thread.start
-          sleep 0.3
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.1
-          expect(running_threads.length).to eql(1)
-          expect(error_count).to eql 2
-
-          expect(stdout.string).not_to match("Connection Failed: ConnectError")
-        end
-      end
-
-      it "logs the connection" do
-        capture_io do |stdout|
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-
-          expect(stdout.string).to match("Connection Success")
-        end
-      end
-
-      it "does not log the connection when there is a callback" do
-        capture_io do |stdout|
-          thread = InterfaceThread.new(@interface)
-          callback_called = false
-          thread.connection_success_callback = Proc.new do
-            callback_called = true
-          end
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-          expect(callback_called).to be true
-
-          expect(stdout.string).not_to match("Connection Success")
-        end
-      end
-
-      it "logs the connection being lost" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:read).and_return(nil)
-          # Make the reconnect_delay be slightly longer than half of 0.1 which is
-          # how long the test is waiting after calling start. This allows us to
-          # create see the error twice.
-          @interface.reconnect_delay = 0.06
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-
-          expect(stdout.string).to match("Connection Lost")
-        end
-      end
-
-      it "does not log the connection being lost when there is a callback" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:read).and_return(nil)
-          @interface.auto_reconnect = false
-          thread = InterfaceThread.new(@interface)
-          callback_called = false
-          thread.connection_lost_callback = Proc.new do
-            callback_called = true
-          end
-          thread.start
-          sleep 1
-          # Since we set auto_reconnect to false we shouldn't see the interface
-          # thread because it will be killed
-          expect(running_threads.length).to eql(1)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-          expect(callback_called).to be true
-
-          expect(stdout.string).not_to match("Connection Lost")
-        end
-      end
-
-      it "handles a read exception" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:read) { raise "ReadError" }
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-          expect(stdout.string).to match("ReadError")
-        end
-      end
-
-      it "handles a read connection reset" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:read) { raise Errno::ECONNRESET }
-          # Make the reconnect_delay be slightly longer than half of 0.1 which is
-          # how long the test is waiting after calling start. This allows us to
-          # create see the error twice.
-          @interface.reconnect_delay = 0.06
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-
-          expect(stdout.string).to match("ECONNRESET")
-        end
-      end
-
-      it "logs any thread exceptions" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:connected?) { raise "ConnectedError" }
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          thread.stop
-          sleep 0.2
-
-          expect(stdout.string).to match("Packet reading thread unexpectedly died")
-        end
-      end
-
-      it "does not thread exceptions when there is a callback" do
-        capture_io do |stdout|
-          allow(@interface).to receive(:connected?) { raise "ConnectedError" }
-          thread = InterfaceThread.new(@interface)
-          callback_called = false
-          thread.fatal_exception_callback = Proc.new do |error|
-            expect(error.message).to eql "ConnectedError"
-            callback_called = true
-          end
-          thread.start
-          sleep 0.1
-          thread.stop
-          sleep 0.2
-          expect(callback_called).to be true
-
-          expect(stdout.string).not_to match("Packet reading thread unexpectedly died")
-        end
-      end
-
-      it "handles unidentified packets" do
-        capture_io do |stdout|
-          @packet = Packet.new(nil,nil)
-          @packet.buffer = "\x01\x02"
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-
-          expect(stdout.string).to match("Unknown 2 byte packet")
-        end
-      end
-
-      it "handles identified yet unknown telemetry" do
-        capture_io do |stdout|
-          @packet.target_name = 'BOB'
-          @packet.packet_name = 'SMITH'
-          allow(System).to receive_message_chain(:telemetry,:packet).and_raise(RuntimeError)
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-          expect(stdout.string).to match("Received unknown identified telemetry: BOB SMITH")
-        end
-      end
-
-      it "writes to all defined routers" do
-        capture_io do |stdout|
-          router = double("Router")
-          allow(router).to receive(:write_allowed?).and_return(true)
-          allow(router).to receive(:connected?).and_return(true)
-          allow(router).to receive(:name).and_return("ROUTER")
-          allow(router).to receive(:write) { raise "RouterWriteError" }
-          @interface.routers = [router]
-          thread = InterfaceThread.new(@interface)
-          thread.start
-          sleep 0.1
-          expect(running_threads.length).to eql(2)
-          thread.stop
-          sleep 0.2
-          expect(running_threads.length).to eql(1)
-
-          expect(stdout.string).to match("Problem writing to router")
-        end
-      end
-
-      it "writes to all defined packet log writers" do
-        writer = double("LogWriter")
-        allow(writer).to receive_message_chain(:tlm_log_writer,:write)
-        @interface.packet_log_writer_pairs = [writer]
-        thread = InterfaceThread.new(@interface)
-        thread.start
-        sleep 0.1
-        expect(running_threads.length).to eql(2)
-        thread.stop
-        sleep 0.2
-        expect(running_threads.length).to eql(1)
-      end
-
-      it "handles stored packet log writers" do
-        writer = double("LogWriter")
-        allow(writer).to receive_message_chain(:tlm_log_writer,:write)
-        @interface.stored_packet_log_writer_pairs = [writer]
-        @packet.stored = true
-        thread = InterfaceThread.new(@interface)
-        thread.start
-        sleep 0.1
-        expect(running_threads.length).to eql(2)
-        thread.stop
-        sleep 0.2
-        expect(running_threads.length).to eql(1)
-      end
-
-    end
-  end
-end