cosmos 4.5.0 → 5.0.2.pre.beta2

data/spec/script/commands_spec.rb

@@ -1,283 +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/script'
-require 'tempfile'
-
-module Cosmos
-  describe Script do
-    before(:each) do
-      allow_any_instance_of(Interface).to receive(:connected?).and_return(true)
-      allow_any_instance_of(Interface).to receive(:disconnect)
-      allow_any_instance_of(Interface).to receive(:write)
-      allow_any_instance_of(Interface).to receive(:read)
-
-      @server = CmdTlmServer.new
-      shutdown_cmd_tlm()
-      initialize_script_module()
-      sleep 0.1
-    end
-
-    after(:each) do
-      @server.stop
-      shutdown_cmd_tlm()
-      sleep(0.1)
-    end
-
-    describe "require cosmos/script.rb" do
-      it "should raise when inside CmdTlmServer" do
-        save = $0
-        $0 = "CmdTlmServer"
-        expect { load 'cosmos/script.rb' }.to raise_error(/must not be required/)
-        $0 = save
-      end
-
-      it "should raise when inside Replay" do
-        save = $0
-        $0 = "Replay"
-        expect { load 'cosmos/script.rb' }.to raise_error(/must not be required/)
-        $0 = save
-      end
-    end
-
-    describe "cmd" do
-      it "sends a command" do
-        capture_io do |stdout|
-          cmd("INST ABORT")
-          expect(stdout.string).to match(/cmd\(\"INST ABORT\"\)/) #"
-          stdout.rewind
-          cmd("INST", "ABORT")
-          expect(stdout.string).to match(/cmd\(\"INST ABORT\"\)/) #"
-        end
-      end
-
-      it "checks parameter ranges" do
-        expect { cmd("INST COLLECT with TYPE NORMAL, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd("INST COLLECT with TYPE SPECIAL")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) #"
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd("INST COLLECT with TYPE SPECIAL")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_no_range_check" do
-      it "sends an out of range command" do
-        expect { cmd_no_range_check("INST COLLECT with TYPE NORMAL, DURATION 20") }.to_not raise_error
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd_no_range_check("INST COLLECT with TYPE SPECIAL")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) #"
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd_no_range_check("INST COLLECT with TYPE SPECIAL")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_no_hazardous_check" do
-      it "checks parameter ranges" do
-        expect { cmd_no_hazardous_check("INST COLLECT with TYPE SPECIAL, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
-      end
-
-      it "sends a hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_no_hazardous_check("INST COLLECT with TYPE SPECIAL")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) #"
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "cmd_no_checks" do
-      it "sends an out of range hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_no_checks("INST COLLECT with TYPE SPECIAL, DURATION 20")
-
-          expect(stdout.string).to match(/cmd\(\"INST COLLECT/) #"
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "cmd_raw" do
-      it "sends a command" do
-        capture_io do |stdout|
-          cmd_raw("INST ABORT")
-          expect(stdout.string).to match(/cmd_raw\(\"INST ABORT\"\)/) #"
-        end
-      end
-
-      it "checks parameter ranges" do
-        expect { cmd_raw("INST COLLECT with TYPE 0, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd_raw("INST COLLECT with TYPE 1")
-
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) #"
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd_raw("INST COLLECT with TYPE 1")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_raw_no_range_check" do
-      it "sends an out of range command" do
-        expect { cmd_raw_no_range_check("INST COLLECT with TYPE 0, DURATION 20") }.to_not raise_error
-      end
-
-      it "prompts for a hazardous command" do
-        capture_io do |stdout|
-          expect(self).to receive(:gets) { 'y' } # Send hazardous command
-          cmd_raw_no_range_check("INST COLLECT with TYPE 1")
-
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) #"
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring hazardous warnings")
-          stdout.rewind
-
-          expect(self).to receive(:gets) { 'n' } # Don't send hazardous
-          expect(self).to receive(:gets) { 'y' } # Stop running script
-          cmd_raw_no_range_check("INST COLLECT with TYPE 1")
-          expect(stdout.string).to match("Warning: Command INST COLLECT is Hazardous")
-        end
-      end
-    end
-
-    describe "cmd_raw_no_hazardous_check" do
-      it "checks parameter ranges" do
-        expect { cmd_raw_no_hazardous_check("INST COLLECT with TYPE 1, DURATION 20") }.to raise_error(/Command parameter 'INST COLLECT DURATION' = 20 not in valid range/)
-      end
-
-      it "sends a hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_raw_no_hazardous_check("INST COLLECT with TYPE 1")
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) #"
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to_not match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "cmd_raw_no_checks" do
-      it "sends an out of range hazardous command without prompting" do
-        capture_io do |stdout|
-          cmd_raw_no_checks("INST COLLECT with TYPE 1, DURATION 20")
-          expect(stdout.string).to match(/cmd_raw\(\"INST COLLECT/) #"
-          expect(stdout.string).to_not match("Warning: Command INST COLLECT is Hazardous")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring range checks")
-          expect(stdout.string).to match("Command INST COLLECT being sent ignoring hazardous warnings")
-        end
-      end
-    end
-
-    describe "send_raw" do
-      it "sends data to the write_raw interface method" do
-        expect_any_instance_of(Interface).to receive(:write_raw).with('\x00')
-        send_raw('INST_INT', '\x00')
-      end
-    end
-
-    describe "send_raw_file" do
-      it "sends file data to the write_raw interface method" do
-        file = File.open('raw_test_file.bin','wb')
-        file.write '\x00\x01\x02\x03'
-        file.close
-
-        expect_any_instance_of(Interface).to receive(:write_raw).with('\x00\x01\x02\x03')
-
-        send_raw_file('INST_INT', 'raw_test_file.bin')
-
-        File.delete('raw_test_file.bin')
-      end
-    end
-
-    describe "get_cmd_list" do
-      it "returns all the target commands" do
-        list = get_cmd_list("INST")
-        # Only check for the collect command to make this test list dependent
-        # on the demo INST command definition file
-        expect(list).to include(["COLLECT", "Starts a collect on the instrument"])
-      end
-    end
-
-    describe "get_cmd_param_list" do
-      it "returns all the parameters for a command" do
-        list = get_cmd_param_list("INST", "COLLECT")
-        expect(list).to include(["TYPE", 0, {"NORMAL"=>0, "SPECIAL"=>1}, "Collect type", nil, nil, true, "UINT"])
-      end
-    end
-
-    describe "get_cmd_hazardous" do
-      it "returns whether a command is hazardous" do
-        expect(get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"NORMAL"})).to be false
-        expect(get_cmd_hazardous("INST", "COLLECT", {"TYPE"=>"SPECIAL"})).to be true
-      end
-    end
-
-    describe "get_cmd_value, get_cmd_time, get_cmd_buffer" do
-      it "passes through to the cmd_tlm_server" do
-        expect {
-          get_cmd_value("INST", "COLLECT", "TYPE")
-          get_cmd_value("INST", "COLLECT", "RECEIVED_TIMEFORMATTED")
-          get_cmd_value("INST", "COLLECT", "RECEIVED_TIMESECONDS")
-          get_cmd_value("INST", "COLLECT", "RECEIVED_COUNT")
-          get_cmd_time("INST", "COLLECT")
-          get_cmd_time("INST")
-          get_cmd_time()
-          get_cmd_buffer("INST", "COLLECT")
-        }.to_not raise_error
-      end
-    end
-
-  end
-end

data/spec/script/extract_spec.rb

@@ -1,166 +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/script'
-require 'tempfile'
-
-module Cosmos
-
-  describe Extract do
-
-    describe "add_cmd_parameter" do
-      it "should remove quotes and preserve quoted strings" do
-        cmd_params = {}
-        add_cmd_parameter('TEST', '"3"', nil, cmd_params)
-        expect(cmd_params['TEST']).to eql('3')
-      end
-
-      it "should convert unquoted strings to the correct value type" do
-        cmd_params = {}
-        add_cmd_parameter('TEST', '3', nil, cmd_params)
-        expect(cmd_params['TEST']).to eql(3)
-        add_cmd_parameter('TEST2', '3.0', nil, cmd_params)
-        expect(cmd_params['TEST2']).to eql(3.0)
-        add_cmd_parameter('TEST3', '0xA', nil, cmd_params)
-        expect(cmd_params['TEST3']).to eql(0xA)
-        add_cmd_parameter('TEST4', '3e3', nil, cmd_params)
-        expect(cmd_params['TEST4']).to eql(3e3)
-        add_cmd_parameter('TEST5', 'Ryan', nil, cmd_params)
-        expect(cmd_params['TEST5']).to eql('Ryan')
-        add_cmd_parameter('TEST6', '3 4', nil, cmd_params)
-        expect(cmd_params['TEST6']).to eql('3 4')
-      end
-
-      it "should convert unquoted hex values into binary for blocks and strings" do
-        cmd_params = {}
-        packet = System.commands.packet("INST", "ASCIICMD").clone
-        add_cmd_parameter('STRING', '0xAABBCCDD', packet, cmd_params)
-        expect(cmd_params['STRING']).to eql("\xAA\xBB\xCC\xDD")
-      end
-
-      it "should preserve quoted hex values for blocks and strings" do
-        cmd_params = {}
-        packet = System.commands.packet("INST", "ASCIICMD").clone
-        add_cmd_parameter('STRING', "'0xAABBCCDD'", packet, cmd_params)
-        expect(cmd_params['STRING']).to eql("0xAABBCCDD")
-      end
-    end
-
-    describe "extract_fields_from_cmd_text" do
-      it "should complain about empty strings" do
-        expect { extract_fields_from_cmd_text("") }.to raise_error(/text must not be empty/)
-      end
-
-      it "should complain about strings that end in with but have no other text" do
-        expect { extract_fields_from_cmd_text("TEST COMMAND with") }.to raise_error(/must be followed by parameters/)
-        expect { extract_fields_from_cmd_text("TEST COMMAND with            ") }.to raise_error(/must be followed by parameters/)
-      end
-
-      it "should complain if target name or packet name are missing" do
-        expect { extract_fields_from_cmd_text("TEST") }.to raise_error(/Both Target Name and Command Name must be given/)
-      end
-
-      it "should complain if there are too many words before with" do
-        expect { extract_fields_from_cmd_text("TEST TEST TEST") }.to raise_error(/Only Target Name and Command Name must be given/)
-      end
-
-      it "should complain if any key value pairs are misformed" do
-        expect { extract_fields_from_cmd_text("TEST TEST with KEY VALUE, KEY VALUE, VALUE") }.to raise_error(/Missing value for last command parameter/)
-        expect { extract_fields_from_cmd_text("TEST TEST with KEY VALUE KEY VALUE") }.to raise_error(/Missing comma in command parameters/)
-        expect { extract_fields_from_cmd_text("TEST TEST with KEY VALUE KEY, KEY VALUE") }.to raise_error(/Missing comma in command parameters/)
-        expect { extract_fields_from_cmd_text("TEST TEST with KEY VALUE, KEY") }.to raise_error(/Missing value for last command parameter/)
-      end
-
-      it "should parse commands correctly" do
-        expect(extract_fields_from_cmd_text("TARGET PACKET with KEY1 VALUE1, KEY2 2, KEY3 '3', KEY4 4.0")).to eql(
-          ['TARGET', 'PACKET', {'KEY1' => 'VALUE1', 'KEY2' => 2, 'KEY3' => '3', 'KEY4' => 4.0}])
-      end
-
-      it "should handle multiple array parameters" do
-        expect(extract_fields_from_cmd_text("TARGET PACKET with KEY1 [1,2,3,4], KEY2 2, KEY3 '3', KEY4 [5, 6, 7, 8]")).to eql(
-          ['TARGET', 'PACKET', {'KEY1' => [1,2,3,4], 'KEY2' => 2, 'KEY3' => '3', 'KEY4' => [5,6,7,8]}])
-        expect(extract_fields_from_cmd_text("TARGET PACKET with KEY1 [1,2,3,4], KEY2 2, KEY3 '3', KEY4 ['1', '2', '3', '4']")).to eql(
-          ['TARGET', 'PACKET', {'KEY1' => [1,2,3,4], 'KEY2' => 2, 'KEY3' => '3', 'KEY4' => ['1', '2', '3', '4']}])
-      end
-    end
-
-    describe "extract_fields_from_tlm_text" do
-      it "should require exactly TARGET_NAME PACKET_NAME ITEM_NAME" do
-        expect { extract_fields_from_tlm_text("") }.to raise_error(/Telemetry Item must be specified as/)
-        expect { extract_fields_from_tlm_text("TARGET") }.to raise_error(/Telemetry Item must be specified as/)
-        expect { extract_fields_from_tlm_text("TARGET PACKET") }.to raise_error(/Telemetry Item must be specified as/)
-        expect { extract_fields_from_tlm_text("TARGET PACKET         ") }.to raise_error(/Telemetry Item must be specified as/)
-        expect { extract_fields_from_tlm_text("TARGET PACKET ITEM OTHER") }.to raise_error(/Telemetry Item must be specified as/)
-      end
-
-      it "should parse telemetry names correctly" do
-        expect(extract_fields_from_tlm_text("TARGET PACKET ITEM")).to eql(['TARGET', 'PACKET', 'ITEM'])
-        expect(extract_fields_from_tlm_text("        TARGET         PACKET       ITEM        ")).to eql(['TARGET', 'PACKET', 'ITEM'])
-      end
-    end
-
-    describe "extract_fields_from_set_tlm_text" do
-      it "should complain if formatted incorrectly" do
-        expect { extract_fields_from_set_tlm_text("") }.to raise_error(/Set Telemetry Item must be specified as/)
-        expect { extract_fields_from_set_tlm_text("TARGET") }.to raise_error(/Set Telemetry Item must be specified as/)
-        expect { extract_fields_from_set_tlm_text("TARGET PACKET") }.to raise_error(/Set Telemetry Item must be specified as/)
-        expect { extract_fields_from_set_tlm_text("TARGET PACKET ITEM") }.to raise_error(/Set Telemetry Item must be specified as/)
-        expect { extract_fields_from_set_tlm_text("TARGET PACKET ITEM=") }.to raise_error(/Set Telemetry Item must be specified as/)
-        expect { extract_fields_from_set_tlm_text("TARGET PACKET ITEM=      ") }.to raise_error(/Set Telemetry Item must be specified as/)
-        expect { extract_fields_from_set_tlm_text("TARGET PACKET ITEM =") }.to raise_error(/Set Telemetry Item must be specified as/)
-        expect { extract_fields_from_set_tlm_text("TARGET PACKET ITEM =     ") }.to raise_error(/Set Telemetry Item must be specified as/)
-      end
-
-      it "should parse set_tlm text correctly" do
-        expect(extract_fields_from_set_tlm_text("TARGET PACKET ITEM= 5")).to eql(['TARGET', 'PACKET', 'ITEM', 5])
-        expect(extract_fields_from_set_tlm_text("TARGET PACKET ITEM = 5")).to eql(['TARGET', 'PACKET', 'ITEM', 5])
-        expect(extract_fields_from_set_tlm_text("TARGET PACKET ITEM =5")).to eql(['TARGET', 'PACKET', 'ITEM', 5])
-        expect(extract_fields_from_set_tlm_text("TARGET PACKET ITEM=5")).to eql(['TARGET', 'PACKET', 'ITEM', 5])
-        expect(extract_fields_from_set_tlm_text("TARGET PACKET ITEM = 5.0")).to eql(['TARGET', 'PACKET', 'ITEM', 5.0])
-        expect(extract_fields_from_set_tlm_text("TARGET PACKET ITEM = Ryan")).to eql(['TARGET', 'PACKET', 'ITEM', 'Ryan'])
-        expect(extract_fields_from_set_tlm_text("TARGET PACKET ITEM = [1,2,3]")).to eql(['TARGET', 'PACKET', 'ITEM', [1,2,3]])
-      end
-    end
-
-    describe "extract_fields_from_check_text" do
-      it "should complain if formatted incorrectly" do
-        expect { extract_fields_from_check_text("") }.to raise_error(/Check improperly specified/)
-        expect { extract_fields_from_check_text("TARGET") }.to raise_error(/Check improperly specified/)
-        expect { extract_fields_from_check_text("TARGET PACKET") }.to raise_error(/Check improperly specified/)
-      end
-
-      it "should support no comparison" do
-        expect(extract_fields_from_check_text("TARGET PACKET ITEM")).to eql(['TARGET', 'PACKET', 'ITEM', nil])
-        expect(extract_fields_from_check_text("TARGET PACKET ITEM             ")).to eql(['TARGET', 'PACKET', 'ITEM', nil])
-      end
-
-      it "should support comparisons" do
-        expect(extract_fields_from_check_text("TARGET PACKET ITEM == 5")).to eql(['TARGET', 'PACKET', 'ITEM', '== 5'])
-        expect(extract_fields_from_check_text("TARGET PACKET ITEM > 5")).to eql(['TARGET', 'PACKET', 'ITEM', '> 5'])
-        expect(extract_fields_from_check_text("TARGET PACKET ITEM < 5")).to eql(['TARGET', 'PACKET', 'ITEM', '< 5'])
-      end
-
-      it "should support target packet items named the same" do
-        expect(extract_fields_from_check_text("TEST TEST TEST == 5")).to eql(['TEST', 'TEST', 'TEST', '== 5'])
-      end
-
-      it "should complain about trying to do an = comparison" do
-        expect { extract_fields_from_check_text("TARGET PACKET ITEM = 5") }.to raise_error(/ERROR: Use/)
-      end
-
-      it "should handle spaces throughout correctly" do
-        expect(extract_fields_from_check_text("TARGET PACKET ITEM == \"This   is  a test\"")).to eql(['TARGET', 'PACKET', 'ITEM', "== \"This   is  a test\""])
-        expect(extract_fields_from_check_text("TARGET   PACKET  ITEM   ==    'This is  a test   '")).to eql(['TARGET', 'PACKET', 'ITEM', "  ==    'This is  a test   '"])
-      end
-    end
-
-  end
-end

data/spec/script/limits_spec.rb

@@ -1,133 +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/script'
-require 'tempfile'
-
-module Cosmos
-  describe Script do
-    before(:each) do
-      allow_any_instance_of(Interface).to receive(:connected?).and_return(true)
-      allow_any_instance_of(Interface).to receive(:disconnect)
-      allow_any_instance_of(Interface).to receive(:write)
-      allow_any_instance_of(Interface).to receive(:read)
-
-      @server = CmdTlmServer.new
-      shutdown_cmd_tlm()
-      initialize_script_module()
-      sleep 0.1
-    end
-
-    after(:each) do
-      @server.stop
-      shutdown_cmd_tlm()
-      sleep(0.1)
-    end
-
-    describe "get_out_of_limits" do
-      it "gets all out of limits items" do
-        set_tlm_raw("INST HEALTH_STATUS TEMP1 = 0")
-        expect(get_out_of_limits).to include(["INST","HEALTH_STATUS","TEMP1",:RED_LOW])
-      end
-    end
-
-    describe "get_overall_limits_state" do
-      it "gets the overall limits state of the system" do
-        set_tlm_raw("INST HEALTH_STATUS TEMP1 = 0")
-        expect(get_overall_limits_state).to eql :RED
-      end
-
-      it "ignores specified items" do
-        ignore = []
-        ignore << %w(INST HEALTH_STATUS TEMP1)
-        ignore << %w(INST HEALTH_STATUS TEMP2)
-        ignore << %w(INST HEALTH_STATUS TEMP3)
-        ignore << %w(INST HEALTH_STATUS TEMP4)
-        ignore << %w(INST HEALTH_STATUS GROUND1STATUS)
-        ignore << %w(INST HEALTH_STATUS GROUND2STATUS)
-        expect(get_overall_limits_state(ignore)).to eql :STALE
-      end
-    end
-
-    describe "limits_enabled?, disable_limits, enable_limits" do
-      it "enables, disable, and check limits for an item" do
-        expect(limits_enabled?("INST HEALTH_STATUS TEMP1")).to be true
-        disable_limits("INST HEALTH_STATUS TEMP1")
-        expect(limits_enabled?("INST HEALTH_STATUS TEMP1")).to be false
-        enable_limits("INST HEALTH_STATUS TEMP1")
-        expect(limits_enabled?("INST HEALTH_STATUS TEMP1")).to be true
-      end
-    end
-
-    describe "get_limits, set_limits" do
-      it "gets and set limits for an item" do
-        expect(get_limits("INST", "HEALTH_STATUS", "TEMP1")).to eql [:DEFAULT, 1, true, -80.0, -70.0, 60.0, 80.0, -20.0, 20.0]
-        expect(set_limits("INST", "HEALTH_STATUS", "TEMP1", 1, 2, 5, 6, 3, 4)).to eql [:CUSTOM, 1, true, 1.0, 2.0, 5.0, 6.0, 3.0, 4.0]
-      end
-    end
-
-    describe "get_limits_groups, enable_limits_group, disable_limits_group" do
-      it "enables, disable, and get groups" do
-        expect(get_limits_groups).to include("FIRST")
-        enable_limits_group("FIRST")
-        disable_limits_group("FIRST")
-      end
-    end
-
-    describe "get_limits_sets, enable_limits_set, disable_limits_set" do
-      it "enables, disable, and get sets CTS-16" do
-        if get_limits_sets.include?(:CUSTOM)
-          expect(get_limits_sets).to eql [:DEFAULT,:TVAC,:CUSTOM]
-        else
-          expect(get_limits_sets).to eql [:DEFAULT,:TVAC]
-        end
-        set_limits_set(:TVAC)
-        expect(get_limits_set).to eql :TVAC
-        set_limits_set(:DEFAULT)
-        expect(get_limits_set).to eql :DEFAULT
-      end
-    end
-
-    describe "subscribe_limits_events, get_limits_event, unsubscribe_limits_events" do
-      it "raises an error if non_block and the queue is empty" do
-        id = subscribe_limits_events
-        expect { get_limits_event(id, true) }.to raise_error(ThreadError, "queue empty")
-        unsubscribe_limits_events(id)
-      end
-
-      it "subscribes and get limits change events" do
-        id = subscribe_limits_events
-        CmdTlmServer.instance.post_limits_event(:LIMITS_CHANGE, ['TGT','PKT','ITEM',:YELLOW,:RED])
-        result = get_limits_event(id, true)
-        expect(result[0]).to eql :LIMITS_CHANGE
-        unsubscribe_limits_events(id)
-      end
-
-      it "subscribes and get limits settings events" do
-        id = subscribe_limits_events
-        CmdTlmServer.instance.post_limits_event(:LIMITS_SETTINGS, ['TGT','PKT','ITEM',:DEFAULT])
-        result = get_limits_event(id, true)
-        expect(result[0]).to eql :LIMITS_SETTINGS
-        unsubscribe_limits_events(id)
-      end
-
-      it "handles unknown limits events" do
-        id = subscribe_limits_events
-        CmdTlmServer.instance.post_limits_event(:UNKNOWN, "This is a test")
-        result = get_limits_event(id, true)
-        expect(result[0]).to eql :UNKNOWN
-        unsubscribe_limits_events(id)
-      end
-    end
-
-  end
-end

data/spec/script/script_spec.rb

@@ -1,80 +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/script'
-require 'tempfile'
-
-module Cosmos
-  describe Script do
-    describe "require cosmos/script.rb" do
-      it "should require cosmos/script/script" do
-        save = $0
-        $0 = "Test"
-        expect { load 'cosmos/script.rb' }.to_not raise_error()
-        $0 = save
-      end
-
-      it "should raise when inside CmdTlmServer" do
-        save = $0
-        $0 = "CmdTlmServer"
-        expect { load 'cosmos/script.rb' }.to raise_error(/must not be required/)
-        $0 = save
-      end
-
-      it "should raise when inside Replay" do
-        save = $0
-        $0 = "Replay"
-        expect { load 'cosmos/script.rb' }.to raise_error(/must not be required/)
-        $0 = save
-      end
-    end
-
-    describe "set_disconnected_targets, get_disconnected_targets, clear_disconnected_targets" do
-      it "should set, get, and clear disconnected targets" do
-        set_disconnected_targets(['INST'])
-        expect($disconnected_targets).to include('INST')
-        expect(get_disconnected_targets()).to eq ['INST']
-        clear_disconnected_targets()
-        expect(get_disconnected_targets()).to be_nil
-        shutdown_cmd_tlm()
-      end
-
-      it "should handle any type of request when disconnected" do
-        initialize_script_module()
-        set_disconnected_targets(['INST'])
-        # Try some simple cmd, tlm requests which route to the disconnected
-        disconnected = $cmd_tlm_server.instance_variable_get(:@disconnected)
-        expect(disconnected).to receive(:cmd).and_call_original
-        cmd("INST ABORT")
-        expect(disconnected).to receive(:tlm).and_call_original
-        tlm("INST HEALTH_STATUS TEMP1")
-        # SYSTEM isn't disconnected so these should not go to disconnected
-        expect(disconnected).not_to receive(:cmd)
-        expect { cmd("SYSTEM STARTLOGGING with LABEL 'TEST'") }.to raise_error(DRb::DRbConnError)
-        expect(disconnected).not_to receive(:tlm)
-        expect { tlm("SYSTEM META COSMOS_VERSION") }.to raise_error(DRb::DRbConnError)
-
-        # The rest should pass through to the JsonDRbObject
-        cosmos_script_sleep(0.1)
-        expect { get_limits_groups() }.to raise_error(DRb::DRbConnError)
-        expect { set_limits_set("DEFAULT") }.to raise_error(DRb::DRbConnError)
-        ignore = []
-        ignore << %w(SYSTEM META COMPUTER)
-        ignore << %w(SYSTEM META VERSION)
-        expect { get_overall_limits_state(ignore) }.to raise_error(DRb::DRbConnError)
-
-        clear_disconnected_targets()
-        shutdown_cmd_tlm()
-      end
-    end
-
-  end
-end