cosmos 4.0.3 → 4.1.0

data/spec/tools/cmd_tlm_server/cmd_tlm_server_spec.rb

@@ -83,20 +83,12 @@ module Cosmos
           expect(CmdTlmServer.json_drb.method_whitelist).to include('stop_logging')
           expect(CmdTlmServer.json_drb.method_whitelist).to include('stop_cmd_log')
           expect(CmdTlmServer.json_drb.method_whitelist).to include('stop_tlm_log')
-          threads = Thread.list.length
-          cts.start # Call start again ... it should do nothing
-          expect(CmdTlmServer.json_drb.method_whitelist).to include('start_logging')
-          expect(CmdTlmServer.json_drb.method_whitelist).to include('stop_logging')
-          expect(CmdTlmServer.json_drb.method_whitelist).to include('stop_cmd_log')
-          expect(CmdTlmServer.json_drb.method_whitelist).to include('stop_tlm_log')
         ensure
           cts.stop
           sleep 0.2
         end
 
-        expect_any_instance_of(PacketLogging).to receive(:start)
-        # Now start the server in production mode
-        cts.start(true)
+        cts = CmdTlmServer.new(CmdTlmServer::DEFAULT_CONFIG_FILE, true)
         begin
           # Verify we disabled the ability to stop logging
           expect(CmdTlmServer.json_drb.method_whitelist).to include('start_logging')
@@ -201,6 +193,11 @@ module Cosmos
     end
 
     describe "self.subscribe_limits_events" do
+      it "rejects bad queue sizes" do
+        expect{ CmdTlmServer.subscribe_limits_events(0) }.to raise_error(ArgumentError)
+        expect{ CmdTlmServer.subscribe_limits_events(true) }.to raise_error(ArgumentError)
+      end
+
       it "subscribes to limits events" do
         allow(System).to receive_message_chain(:telemetry,:stale).and_return([])
         allow(System).to receive_message_chain(:telemetry,:limits_change_callback=)
@@ -306,9 +303,14 @@ module Cosmos
 
     describe "self.subscribe_packet_data" do
       it "rejects bad queue sizes" do
+        expect{ CmdTlmServer.subscribe_packet_data([["SYSTEM","LIMITS_CHANGE"]], 0) }.to raise_error(ArgumentError)
         expect{ CmdTlmServer.subscribe_packet_data([["SYSTEM","LIMITS_CHANGE"]], true) }.to raise_error(ArgumentError)
       end
 
+      it "rejects bad packet lists" do
+        expect{ CmdTlmServer.subscribe_packet_data(["SYSTEM","LIMITS_CHANGE"]) }.to raise_error(ArgumentError, /packets must be nested array/)
+      end
+
       it "subscribes to packets" do
         cts = CmdTlmServer.new
         id = CmdTlmServer.subscribe_packet_data([["SYSTEM","LIMITS_CHANGE"]])
@@ -400,6 +402,80 @@ module Cosmos
       end
     end
 
+    describe "self.get_packet_data" do
+      it "raises an error if the queue is empty and non_block" do
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_packet_data([["SYSTEM","LIMITS_CHANGE"]])
+
+        expect { CmdTlmServer.get_packet_data(id, true) }.to raise_error(ThreadError)
+        cts.stop
+        sleep 0.2
+      end
+
+      it "works in disconnect mode" do
+        cts = CmdTlmServer.new(CmdTlmServer::DEFAULT_CONFIG_FILE, false, true)
+        id = CmdTlmServer.subscribe_packet_data([["SYSTEM","LIMITS_CHANGE"]])
+        buffer,tgt,pkt,tv_sec,tv_usec,cnt = CmdTlmServer.get_packet_data(id, true)
+        expect(buffer).not_to be_nil
+        expect(tgt).to eql "SYSTEM"
+        expect(pkt).to eql "LIMITS_CHANGE"
+      end
+    end
+
+    describe "self.subscribe_server_messages" do
+      it "rejects bad queue sizes" do
+        expect{ CmdTlmServer.subscribe_server_messages(0) }.to raise_error(ArgumentError)
+        expect{ CmdTlmServer.subscribe_server_messages(true) }.to raise_error(ArgumentError)
+      end
+
+      it "subscribes to server messages" do
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_server_messages()
+        cts.post_server_message("This is a test")
+        cts.post_server_message("Another test")
+        message = CmdTlmServer.get_server_message(id, true)
+        expect(message).to eql "This is a test"
+        message = CmdTlmServer.get_server_message(id, true)
+        expect(message).to eql "Another test"
+
+        cts.stop
+        sleep 0.2
+      end
+
+      it "deletes queues after the max packets is reached" do
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_server_messages(2)
+        cts.post_server_message("One message")
+        message = CmdTlmServer.get_server_message(id, true)
+        expect(message).to eql "One message"
+
+        # Fill the queue
+        1001.times { cts.post_server_message("Message") }
+
+        # Try to get another message
+        expect { CmdTlmServer.get_server_message(id) }.to raise_error("Server message queue with id #{id} not found")
+
+        cts.stop
+        sleep 0.2
+      end
+    end
+
+    describe "self.subscribe_server_messages" do
+      it "unsubscribes to messages" do
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_server_messages(2)
+        cts.post_server_message("One message")
+        message = CmdTlmServer.get_server_message(id, true)
+        expect(message).to eql "One message"
+
+        CmdTlmServer.unsubscribe_server_messages(id)
+        cts.post_server_message("Two message")
+        expect { CmdTlmServer.get_server_message(id) }.to raise_error("Server message queue with id #{id} not found")
+        cts.stop
+        sleep 0.2
+      end
+    end
+
     describe "self.get_packet_data" do
       it "raises an error if the queue is empty and non_block" do
         cts = CmdTlmServer.new

data/spec/tools/cmd_tlm_server/interface_thread_spec.rb

@@ -59,18 +59,10 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
 
           expect(stdout.string).to match "Connection Failed: RuntimeError : ConnectError"
         end
@@ -80,10 +72,9 @@ module Cosmos
         capture_io do |stdout|
           allow(@interface).to receive(:connected?).and_return(false)
           allow(@interface).to receive(:connect) { raise "ConnectError" }
-          # 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
-          # see the error twice.
-          @interface.reconnect_delay = 0.15
+          # 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|
@@ -91,19 +82,11 @@ module Cosmos
             error_count += 1
           end
           thread.start
-          sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          sleep 0.3
+          expect(running_threads.length).to eql(2)
           thread.stop
-          sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          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"
@@ -115,18 +98,10 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
 
           expect(stdout.string).to match "Connection Success"
         end
@@ -141,18 +116,10 @@ module Cosmos
           end
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(callback_called).to be true
 
           expect(stdout.string).not_to match "Connection Success"
@@ -169,18 +136,10 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
 
           expect(stdout.string).to match "Connection Lost"
         end
@@ -199,18 +158,10 @@ module Cosmos
           sleep 1
           # Since we set auto_reconnect to false we shouldn't see the interface
           # thread because it will be killed
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(callback_called).to be true
 
           expect(stdout.string).not_to match "Connection Lost"
@@ -223,18 +174,10 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(stdout.string).to match "ReadError"
         end
       end
@@ -249,18 +192,10 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
 
           expect(stdout.string).to match "ECONNRESET"
         end
@@ -304,18 +239,10 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
 
           expect(stdout.string).to match "Unknown 2 byte packet"
         end
@@ -330,18 +257,10 @@ module Cosmos
           thread.start
           sleep 0.1
 
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(stdout.string).to match "Received unknown identified telemetry: BOB SMITH"
         end
       end
@@ -357,18 +276,10 @@ module Cosmos
           thread = InterfaceThread.new(@interface)
           thread.start
           sleep 0.1
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
 
           expect(stdout.string).to match "Problem writing to router"
         end
@@ -379,21 +290,12 @@ module Cosmos
         allow(writer).to receive_message_chain(:tlm_log_writer,:write)
         @interface.packet_log_writer_pairs = [writer]
         thread = InterfaceThread.new(@interface)
-        threads = Thread.list.length
         thread.start
         sleep 0.1
-        if RUBY_ENGINE == 'ruby'
-          expect(Thread.list.length).to eql(2)
-        else
-          expect(Thread.list.length).to eql(3)
-        end
+        expect(running_threads.length).to eql(2)
         thread.stop
         sleep 0.2
-        if RUBY_ENGINE == 'ruby'
-          expect(Thread.list.length).to eql(1)
-        else
-          expect(Thread.list.length).to eql(2)
-        end
+        expect(running_threads.length).to eql(1)
       end
 
     end

data/spec/tools/cmd_tlm_server/router_thread_spec.rb

@@ -39,18 +39,10 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.5
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(stdout.string).to match "disconnected interface"
         end
       end
@@ -65,18 +57,10 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.5
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(stdout.string).to match "Error routing command"
         end
       end
@@ -97,18 +81,10 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.5
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(stdout.string).to match "Received unknown identified command: BOB SMITH"
         end
       end
@@ -133,18 +109,10 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.5
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(stdout.string).to match "Received unknown identified command: BOB SMITH"
         end
         expect(target).to have_received(:interface).at_least(2).times #and_return(@interface)
@@ -170,18 +138,10 @@ module Cosmos
         capture_io do |stdout|
           thread.start
           sleep 0.2
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(2)
-          else
-            expect(Thread.list.length).to eql(3)
-          end
+          expect(running_threads.length).to eql(2)
           thread.stop
           sleep 0.5
-          if RUBY_ENGINE == 'ruby'
-            expect(Thread.list.length).to eql(1)
-          else
-            expect(Thread.list.length).to eql(2)
-          end
+          expect(running_threads.length).to eql(1)
           expect(stdout.string).to match "target with no interface"
         end
       end