cosmos 3.0.0

data/spec/tools/cmd_tlm_server/cmd_tlm_server_spec.rb

@@ -0,0 +1,418 @@
+# 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/cmd_tlm_server'
+
+module Cosmos
+
+  describe CmdTlmServer do
+    before(:all) do
+      cts = File.join(Cosmos::USERPATH,'config','tools','cmd_tlm_server','cmd_tlm_server.txt')
+      FileUtils.mkdir_p(File.dirname(cts))
+      File.open(cts,'w') do |file|
+        file.puts 'INTERFACE INT interface.rb'
+      end
+
+      @start_threads = Thread.list.length
+    end
+
+    after(:all) do
+      clean_config()
+      Thread.list.length.should eql @start_threads
+    end
+
+    before(:each) do
+      allow_any_instance_of(Interface).to receive(:connect).and_return(true)
+      allow_any_instance_of(Interface).to receive(:connected?).and_return(true)
+      allow_any_instance_of(Interface).to receive(:read).and_return(nil)
+      allow_any_instance_of(Interface).to receive(:disconnect).and_return(nil)
+    end
+
+    describe "initialize, self.instance" do
+      it "should create the single instance of the CTS" do
+        cts = CmdTlmServer.new
+        CmdTlmServer.instance.should eql cts
+        CmdTlmServer.background_tasks.should be_a BackgroundTasks
+        CmdTlmServer.commanding.should be_a Commanding
+        CmdTlmServer.interfaces.should be_a Interfaces
+        CmdTlmServer.packet_logging.should be_a PacketLogging
+        CmdTlmServer.routers.should be_a Routers
+        CmdTlmServer.message_log.should be_a MessageLog
+        CmdTlmServer.json_drb.should be_a JsonDRb
+
+        # Verify we can't start another CTS
+        expect { CmdTlmServer.new }.to raise_error(FatalError, /Error starting JsonDRb on port 7777/)
+        cts.stop
+        sleep 0.1
+      end
+
+      it "should create the CTS in production mode" do
+        # Production mode means we start logging
+        expect_any_instance_of(PacketLogging).to receive(:start)
+        cts = CmdTlmServer.new('cmd_tlm_server.txt', true)
+        # Verify we disabled the ability to stop logging
+        CmdTlmServer.json_drb.method_whitelist.should include('start_logging')
+        CmdTlmServer.json_drb.method_whitelist.should_not include('stop_logging')
+        CmdTlmServer.json_drb.method_whitelist.should_not include('stop_cmd_log')
+        CmdTlmServer.json_drb.method_whitelist.should_not include('stop_tlm_log')
+        cts.stop
+        sleep 0.1
+      end
+   end
+
+    describe "start" do
+      it "should create the CTS in production mode" do
+        # Production mode means we start logging
+        cts = CmdTlmServer.new
+        CmdTlmServer.json_drb.method_whitelist.should include('start_logging')
+        CmdTlmServer.json_drb.method_whitelist.should include('stop_logging')
+        CmdTlmServer.json_drb.method_whitelist.should include('stop_cmd_log')
+        CmdTlmServer.json_drb.method_whitelist.should include('stop_tlm_log')
+        threads = Thread.list.length
+        cts.start # Call start again ... it should do nothing
+        Thread.list.length.should eql threads
+        cts.stop
+        sleep 0.1
+
+        expect_any_instance_of(PacketLogging).to receive(:start)
+        # Now start the server in production mode
+        cts.start(true)
+        # Verify we disabled the ability to stop logging
+        CmdTlmServer.json_drb.method_whitelist.should include('start_logging')
+        CmdTlmServer.json_drb.method_whitelist.should_not include('stop_logging')
+        CmdTlmServer.json_drb.method_whitelist.should_not include('stop_cmd_log')
+        CmdTlmServer.json_drb.method_whitelist.should_not include('stop_tlm_log')
+        cts.stop
+        sleep 0.1
+      end
+
+      it "should monitor the staleness thread" do
+        capture_io do |stdout|
+          # Production mode means we start logging
+          allow(System).to receive_message_chain(:telemetry,:limits_change_callback=)
+          allow(System).to receive_message_chain(:telemetry,:check_stale) { raise "Stale Error" }
+          sleep 0.1
+          cts = CmdTlmServer.new
+          sleep 0.1
+          cts.stop
+          sleep 0.1
+
+          stdout.string.should match "Staleness Monitor thread unexpectedly died"
+        end
+      end
+    end
+
+    describe "limits_change_callback" do
+      it "should log the change according to the state" do
+        capture_io do |stdout|
+          cts = CmdTlmServer.new
+          pkt = Packet.new("TGT","PKT")
+          pi = PacketItem.new("TEST", 0, 32, :UINT, :BIG_ENDIAN, nil)
+          cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+          stdout.string.should match "TGT PKT TEST = 100 is UNKNOWN"
+
+          pi.limits.state = :BLUE
+          cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+          stdout.string.should match "<B>TGT PKT TEST = 100 is BLUE"
+
+          pi.limits.state = :GREEN
+          cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+          stdout.string.should match "<G>TGT PKT TEST = 100 is GREEN"
+
+          pi.limits.state = :YELLOW
+          cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+          stdout.string.should match "<Y>TGT PKT TEST = 100 is YELLOW"
+
+          pi.limits.state = :RED
+          cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+          stdout.string.should match "<R>TGT PKT TEST = 100 is RED"
+
+          cts.stop
+          sleep 0.1
+        end
+      end
+
+      it "should call the limits response" do
+        cts = CmdTlmServer.new
+        pkt = Packet.new("TGT","PKT")
+        pi = PacketItem.new("TEST", 0, 32, :UINT, :BIG_ENDIAN, nil)
+        lr = LimitsResponse.new
+        pi.limits.response = lr
+        expect(pi.limits.response).to receive(:call) do |tgt, pkt, item, old_state, state|
+          tgt.should eql "TGT"
+          pkt.should eql "PKT"
+          item.name.should eql "TEST"
+          old_state.should eql :YELLOW
+          state.should eql :GREEN
+        end
+        pi.limits.state = :GREEN
+
+        cts.limits_change_callback(pkt, pi, :YELLOW, 100, true)
+        sleep 0.1
+        cts.stop
+        sleep 0.1
+      end
+
+      it "should log limits response errors" do
+        capture_io do |stdout|
+          cts = CmdTlmServer.new
+          pkt = Packet.new("TGT","PKT")
+          pi = PacketItem.new("TEST", 0, 32, :UINT, :BIG_ENDIAN, nil)
+          lr = LimitsResponse.new
+          pi.limits.response = lr
+          expect(pi.limits.response).to receive(:call) { raise "ResponseError" }
+          pi.limits.state = :GREEN
+
+          cts.limits_change_callback(pkt, pi, :YELLOW, 100, true)
+          sleep 0.1
+
+          stdout.string.should match "TGT PKT TEST Limits Response Exception!"
+          cts.stop
+          sleep 0.1
+        end
+      end
+    end
+
+    describe "self.subscribe_limits_events" do
+      it "should subscribe to limits events" do
+        cts = CmdTlmServer.new
+        pkt = Packet.new("TGT","PKT")
+        pi = PacketItem.new("TEST", 0, 32, :UINT, :BIG_ENDIAN, nil)
+        id = CmdTlmServer.subscribe_limits_events()
+
+        # Create two limits change events
+        pi.limits.state = :GREEN
+        cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+        pi.limits.state = :YELLOW
+        cts.limits_change_callback(pkt, pi, :GREEN, 100, true)
+
+        # Get and check the first one
+        type,data = CmdTlmServer.get_limits_event(id)
+        tgt,pkt,item,old_state,state = data # split the data array
+        type.should eql :LIMITS_CHANGE
+        tgt.should eql "TGT"
+        pkt.should eql "PKT"
+        item.should eql "TEST"
+        old_state.should eql :STALE
+        state.should eql :GREEN
+
+        # Get and check the second one
+        type,data = CmdTlmServer.get_limits_event(id)
+        tgt,pkt,item,old_state,state = data # split the data array
+        type.should eql :LIMITS_CHANGE
+        tgt.should eql "TGT"
+        pkt.should eql "PKT"
+        item.should eql "TEST"
+        old_state.should eql :GREEN
+        state.should eql :YELLOW
+
+        cts.stop
+        sleep 0.1
+      end
+
+      it "should delete queues after the max events is reached" do
+        cts = CmdTlmServer.new
+        pkt = Packet.new("TGT","PKT")
+        pi = PacketItem.new("TEST", 0, 32, :UINT, :BIG_ENDIAN, nil)
+        id = CmdTlmServer.subscribe_limits_events(2) # Max of 2 events
+
+        # Create two limits change events
+        pi.limits.state = :GREEN
+        cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+        pi.limits.state = :YELLOW
+        cts.limits_change_callback(pkt, pi, :GREEN, 100, true)
+
+        # Pull off one
+        type,data = CmdTlmServer.get_limits_event(id)
+
+        # Add two more to put us over the limit
+        cts.limits_change_callback(pkt, pi, :GREEN, 100, true)
+        cts.limits_change_callback(pkt, pi, :GREEN, 100, true)
+
+        # Try to pull off one
+        expect { CmdTlmServer.get_limits_event(id) }.to raise_error("Limits event queue with id #{id} not found")
+
+        cts.stop
+        sleep 0.1
+      end
+    end
+
+    describe "self.unsubscribe_limits_events" do
+      it "should unsubscribe to limits events" do
+        cts = CmdTlmServer.new
+        pkt = Packet.new("TGT","PKT")
+        pi = PacketItem.new("TEST", 0, 32, :UINT, :BIG_ENDIAN, nil)
+        id = CmdTlmServer.subscribe_limits_events()
+
+        # Create two limits change events
+        pi.limits.state = :GREEN
+        cts.limits_change_callback(pkt, pi, :STALE, 100, true)
+        pi.limits.state = :YELLOW
+        cts.limits_change_callback(pkt, pi, :GREEN, 100, true)
+
+        # Get one
+        type,data = CmdTlmServer.get_limits_event(id)
+
+        # Unsubscribe and try to get the other one
+        CmdTlmServer.unsubscribe_limits_events(id)
+        expect { CmdTlmServer.get_limits_event(id) }.to raise_error("Limits event queue with id #{id} not found")
+
+        cts.stop
+        sleep 0.1
+      end
+    end
+
+    describe "self.subscribe_packet_data" do
+      it "should subscribe to packets" do
+        version = System.telemetry.packet("COSMOS","VERSION")
+        allow_any_instance_of(Interface).to receive(:read) do
+          sleep 0.05
+          version
+        end
+
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_packet_data([["COSMOS","VERSION"]])
+
+        # Get and check the packet
+        begin
+          buffer,tgt,pkt,tv_sec,tv_usec,cnt = CmdTlmServer.get_packet_data(id, true)
+          buffer.should_not be_nil
+          tgt.should eql "COSMOS"
+          pkt.should eql "VERSION"
+          tv_sec.should > 0
+          tv_usec.should > 0
+          cnt.should eql 1
+        rescue => err
+          sleep 0.1
+          retry
+        end
+
+        sleep 0.1
+
+        # Get and check the second one
+        begin
+          buffer,tgt,pkt,tv_sec,tv_usec,cnt = CmdTlmServer.get_packet_data(id, true)
+          buffer.should_not be_nil
+          tgt.should eql "COSMOS"
+          pkt.should eql "VERSION"
+          tv_sec.should > 0
+          tv_usec.should > 0
+          cnt.should eql 2
+        rescue
+          sleep 0.1
+          retry
+        end
+
+        cts.stop
+        sleep 0.1
+      end
+
+      it "should delete queues after the max packets is reached" do
+        version = System.telemetry.packet("COSMOS","VERSION")
+        allow_any_instance_of(Interface).to receive(:read) do
+          sleep 0.1
+          version
+        end
+
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_packet_data([["COSMOS","VERSION"]], 2)
+
+        # Get and check the packet
+        begin
+          buffer,tgt,pkt,tv_sec,tv_usec,cnt = CmdTlmServer.get_packet_data(id, true)
+          buffer.should_not be_nil
+          tgt.should eql "COSMOS"
+          pkt.should eql "VERSION"
+          tv_sec.should > 0
+
+          tv_usec.should > 0
+          cnt.should > 0
+        rescue
+          sleep 0.1
+          retry
+        end
+
+        # Allow the interface read to fill the queue
+        sleep 0.4
+
+        # Try to get another packet
+        expect { CmdTlmServer.get_packet_data(id) }.to raise_error("Packet data queue with id #{id} not found")
+
+        cts.stop
+        sleep 0.1
+      end
+    end
+
+    describe "self.unsubscribe_packet_data" do
+      it "should unsubscribe to packets" do
+        version = System.telemetry.packet("COSMOS","VERSION")
+        allow_any_instance_of(Interface).to receive(:read) do
+          sleep 0.05
+          version
+        end
+
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_packet_data([["COSMOS","VERSION"]], 2)
+
+        # Get and check the packet
+        begin
+          buffer,tgt,pkt,tv_sec,tv_usec,cnt = CmdTlmServer.get_packet_data(id, true)
+          buffer.should_not be_nil
+          tgt.should eql "COSMOS"
+          pkt.should eql "VERSION"
+          tv_sec.should > 0
+          tv_usec.should > 0
+          cnt.should > 0
+        rescue => err
+          sleep 0.1
+          retry
+        end
+
+        # Unsubscribe and try to get another packet
+        CmdTlmServer.unsubscribe_packet_data(id)
+        expect { CmdTlmServer.get_packet_data(id) }.to raise_error("Packet data queue with id #{id} not found")
+
+        cts.stop
+        sleep 0.1
+      end
+    end
+
+    describe "self.get_packet_data" do
+      it "should raise an error if the queue is empty and non_block" do
+        cts = CmdTlmServer.new
+        id = CmdTlmServer.subscribe_packet_data([["COSMOS","VERSION"]])
+
+        expect { CmdTlmServer.get_packet_data(id, true) }.to raise_error(ThreadError)
+        cts.stop
+        sleep 0.1
+      end
+    end
+
+    describe "self.clear_counters" do
+      it "should clear all counters" do
+        cts = CmdTlmServer.new
+        expect(System).to receive(:clear_counters)
+        expect(CmdTlmServer.interfaces).to receive(:clear_counters)
+        expect(CmdTlmServer.routers).to receive(:clear_counters)
+        CmdTlmServer.json_drb.request_count = 100
+
+        CmdTlmServer.clear_counters
+
+        CmdTlmServer.json_drb.request_count.should eql 0
+        cts.stop
+        sleep 0.1
+      end
+    end
+
+  end
+end
+

data/spec/tools/cmd_tlm_server/commanding_spec.rb

@@ -0,0 +1,123 @@
+# 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 'tempfile'
+require 'cosmos'
+require 'cosmos/tools/cmd_tlm_server/commanding'
+require 'cosmos/tools/cmd_tlm_server/cmd_tlm_server_config'
+
+module Cosmos
+
+  describe Commanding do
+    after(:all) do
+      clean_config()
+    end
+
+    describe "send_command_to_target" do
+      it "should complain about unknown targets" do
+        tf = Tempfile.new('unittest')
+        tf.close
+        cmd = Commanding.new(CmdTlmServerConfig.new(tf.path))
+        expect { cmd.send_command_to_target('BLAH', Packet.new('TGT','PKT')) }.to raise_error("Unknown target: BLAH")
+        tf.unlink
+      end
+
+      it "should identify and command to the interface" do
+        tf = Tempfile.new('unittest')
+        tf.puts 'INTERFACE MY_INT interface.rb'
+        tf.close
+        config = CmdTlmServerConfig.new(tf.path)
+        cmd = Commanding.new(config)
+        interfaces = Interfaces.new(config)
+        interfaces.map_target("COSMOS","MY_INT")
+        expect(interfaces.all["MY_INT"]).to receive(:write)
+        expect(interfaces.all["MY_INT"].packet_log_writer_pairs[0].cmd_log_writer).to receive(:write)
+
+        # Grab an existing packet
+        pkt = System.commands.packet('COSMOS','STARTLOGGING')
+        # Restore defaults so it can be identified
+        pkt.restore_defaults
+        # Set the target_name to nil to make it "unidentified"
+        pkt.target_name = nil
+
+        cmd.send_command_to_target('COSMOS', pkt)
+        # Verify the COSMOS STARTLOGGING packet has been updated
+        System.commands.packet("COSMOS","STARTLOGGING").buffer.should eql pkt.buffer
+        tf.unlink
+      end
+
+      it "should log unknown commands" do
+        Logger.level = Logger::DEBUG
+        stdout = StringIO.new('', 'r+')
+        $stdout = stdout
+
+        tf = Tempfile.new('unittest')
+        tf.puts 'INTERFACE MY_INT interface.rb'
+        tf.close
+        config = CmdTlmServerConfig.new(tf.path)
+        cmd = Commanding.new(config)
+        interfaces = Interfaces.new(config)
+        interfaces.map_target("COSMOS","MY_INT")
+        expect(interfaces.all["MY_INT"]).to receive(:write)
+        expect(interfaces.all["MY_INT"].packet_log_writer_pairs[0].cmd_log_writer).to receive(:write)
+
+        # Grab an existing packet
+        pkt = System.commands.packet('COSMOS','STARTLOGGING')
+        # Mess up the opcode so it won't be identifyable
+        pkt.write('OPCODE',100)
+        # Set the target_name to nil to make it "unidentified"
+        pkt.target_name = nil
+
+        cmd.send_command_to_target('COSMOS', pkt)
+        # Verify the unknown packet has been updated
+        System.commands.packet("UNKNOWN","UNKNOWN").buffer.should eql pkt.buffer
+        tf.unlink
+
+        stdout.string.should match "Unidentified packet"
+        Logger.level = Logger::FATAL
+        $stdout = STDOUT
+      end
+    end
+
+    describe "send_raw" do
+      it "should complain about unknown interfaces" do
+        tf = Tempfile.new('unittest')
+        tf.close
+        cmd = Commanding.new(CmdTlmServerConfig.new(tf.path))
+        expect { cmd.send_raw('BLAH', Packet.new('TGT','PKT')) }.to raise_error("Unknown interface: BLAH")
+        tf.unlink
+      end
+
+      it "should log writes" do
+        Logger.level = Logger::DEBUG
+        stdout = StringIO.new('', 'r+')
+        $stdout = stdout
+
+        tf = Tempfile.new('unittest')
+        tf.puts 'INTERFACE MY_INT interface.rb'
+        tf.close
+        config = CmdTlmServerConfig.new(tf.path)
+        cmd = Commanding.new(config)
+        interfaces = Interfaces.new(config)
+        expect(interfaces.all["MY_INT"]).to receive(:write_raw)
+
+        cmd.send_raw('MY_INT', "\x00\x01")
+        tf.unlink
+
+        stdout.string.should match "Unlogged raw data of 2 bytes being sent to interface MY_INT"
+        Logger.level = Logger::FATAL
+        $stdout = STDOUT
+      end
+    end
+
+  end
+end
+

data/spec/tools/cmd_tlm_server/connections_spec.rb

@@ -0,0 +1,147 @@
+# 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
+    after(:all) do
+      clean_config()
+    end
+
+    describe "initialize" do
+      it "should only allow :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 "should call 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 "should call 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 "should call 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 "should call 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 "should raise 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 "should relay 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))
+        routers.state("MY_ROUTER").should eql "ATTEMPTING"
+        routers.state("MY_ROUTER").should eql "CONNECTED"
+        routers.state("MY_ROUTER").should eql "DISCONNECTED"
+        tf.unlink
+      end
+    end
+
+    describe "names" do
+      it "should list 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))
+        routers.names.should eql %w(ROUTER1 ROUTER2 ROUTER3)
+        tf.unlink
+      end
+    end
+
+    describe "clear_counters" do
+      it "should clear 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|
+          interface.bytes_written.should eql 0
+          interface.bytes_read.should eql 0
+          interface.write_count.should eql 0
+          interface.read_count.should eql 0
+        end
+        tf.unlink
+      end
+    end
+  end
+end
+