cosmos 4.4.2 → 4.5.0

data/lib/cosmos/tools/tlm_extractor/tlm_extractor_processor.rb

@@ -72,13 +72,13 @@ module Cosmos
         items = []
         configs.each { |config| config.mode = :dart; items.concat(config.normal_items); config.open_output_file }
         items.uniq!
- 
+
         time_start = Time.utc(1970, 1, 1) unless time_start
         time_end = Time.now unless time_end
 
         results = {}
         begin
-          server = JsonDRbObject.new(System.connect_hosts['DART_DECOM'], System.ports['DART_DECOM'])
+          server = JsonDRbObject.new(System.connect_hosts['DART_DECOM'], System.ports['DART_DECOM'], 1.0, Cosmos::System.x_csrf_token)
 
           index = 0
           items.each do |item_type, target_name, packet_name, item_name, value_type, dart_reduction, dart_reduced_type|
@@ -116,7 +116,7 @@ module Cosmos
             rescue Exception => error
               yield(index.to_f / items.length, "Error querying #{query_string} : #{error.class}:#{error.message}\n#{error.backtrace.join("\n")}\n") if block_given?
               return # Bail out because something bad happened
-            end          
+            end
           end
 
           configs.each { |config| config.process_dart(results) }

data/lib/cosmos/tools/tlm_grapher/tabbed_plots_tool/tabbed_plots_dart_thread.rb

@@ -45,7 +45,7 @@ module Cosmos
 
           # Execute each query
           results = {}
-          server = JsonDRbObject.new(System.connect_hosts['DART_DECOM'], System.ports['DART_DECOM'])
+          server = JsonDRbObject.new(System.connect_hosts['DART_DECOM'], System.ports['DART_DECOM'], 1.0, Cosmos::System.x_csrf_token)
           time_start = Time.utc(1970, 1, 1) unless time_start
           time_end = Time.now unless time_end
           progress_dialog.set_step_progress(0) if progress_dialog

data/lib/cosmos/tools/tlm_viewer/tlm_viewer.rb

@@ -146,7 +146,7 @@ module Cosmos
             'clear_all']
           @json_drb.method_whitelist = whitelist
           begin
-            @json_drb.start_service System.listen_hosts['TLMVIEWER_API'], port, self
+            @json_drb.start_service System.listen_hosts['TLMVIEWER_API'], port, self, 1000, System
           rescue Exception
             raise FatalError.new("Error starting JsonDRb on port #{port}.\nPerhaps a Telemetry Viewer is already running?")
           end
@@ -171,7 +171,7 @@ module Cosmos
 
         ConfigParser.splash = nil
       end
-      
+
       hide() unless options.show_main
     end
 

data/lib/cosmos/version.rb

@@ -1,12 +1,12 @@
 # encoding: ascii-8bit
 
-COSMOS_VERSION = '4.4.2'
+COSMOS_VERSION = '4.5.0'
 module Cosmos
   module Version
     MAJOR = '4'
-    MINOR = '4'
-    PATCH = '2'
-    BUILD = '41a1376a7b11d7bb3498dd6fd0a13c1a9b383946'
+    MINOR = '5'
+    PATCH = '0'
+    BUILD = '627198e20200543f157cc4c2ffde5d7df5180ae2'
   end
-  VERSION = '4.4.2'
+  VERSION = '4.5.0'
 end

data/spec/core_ext/time_spec.rb

@@ -183,6 +183,10 @@ describe Time do
       expect(parts[1]).to eql ccsds_ms
       expect(parts[2]).to be_within(50).of(ccsds_us)
     end
+
+    it "maintains precision" do
+      expect(Time.ccsds2sec(22766, 65115943, 552).round(6)).to eql(1967047515.943552)
+    end
   end
 
   describe "Time.yds2mdy" do

data/spec/io/json_drb_rack_spec.rb

@@ -0,0 +1,166 @@
+  # 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/io/json_drb_rack'
+
+  module Cosmos
+
+    describe JsonDrbRack do
+      before(:each) do
+        @env = {
+          "GATEWAY_INTERFACE" => "CGI/1.1",
+          "PATH_INFO" => "/index.html",
+          "QUERY_STRING" => "",
+          "REMOTE_ADDR" => "::1",
+          "REMOTE_HOST" => "localhost",
+          "REQUEST_METHOD" => "POST",
+          "REQUEST_URI" => "http://localhost:3000/index.html",
+          "SCRIPT_NAME" => "",
+          "SERVER_NAME" => "localhost",
+          "SERVER_PORT" => "3000",
+          "SERVER_PROTOCOL" => "HTTP/1.1",
+          "SERVER_SOFTWARE" => "WEBrick/1.3.1 (Ruby/2.0.0/2013-11-22)",
+          "HTTP_HOST" => "127.0.0.1:7777",
+          "HTTP_USER_AGENT" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:26.0) Gecko/20100101 Firefox/26.0",
+          "HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+          "HTTP_ACCEPT_LANGUAGE" => "zh-tw,zh;q=0.8,en-us;q=0.5,en;q=0.3",
+          "HTTP_ACCEPT_ENCODING" => "gzip, deflate",
+          "HTTP_COOKIE" => "jsonrpc.session=3iqp3ydRwFyqjcfO0GT2bzUh.bacc2786c7a81df0d0e950bec8fa1a9b1ba0bb61",
+          "HTTP_CONNECTION" => "keep-alive",
+          "HTTP_CACHE_CONTROL" => "max-age=0",
+          "rack.version" => [1, 2],
+          "rack.input" => StringIO.new(""),
+          "rack.errors" => nil,
+          "rack.multithread" => true,
+          "rack.multiprocess" => false,
+          "rack.run_once" => false,
+          "rack.url_scheme" => "http",
+          "HTTP_VERSION" => "HTTP/1.1",
+          "REQUEST_PATH" => "/index.html"
+        }
+      end
+
+      class MockDRb
+        class MockDRbAcl
+          def initialize(val = true)
+            @val = val
+          end
+          def allow_addr?(val)
+            return @val
+          end
+        end
+
+        def initialize(val, response_data = "response", error_code = nil)
+          @acl = MockDRbAcl.new(val)
+          @response_data = response_data
+          @error_code = error_code
+        end
+
+        def acl
+          @acl
+        end
+
+        def process_request(request_data, start_time)
+          return @response_data, @error_code
+        end
+      end
+
+      class MockSystem
+        def initialize(token = 'SuperSecret', hosts = ['127.0.0.1:7777'], origins = [])
+          @token = token
+          @hosts = hosts
+          @origins = origins
+        end
+        def x_csrf_token
+          @token
+        end
+        def allowed_hosts
+          @hosts
+        end
+        def allowed_origins
+          @origins
+        end
+      end
+
+      describe "call" do
+        it "supports the drb acl" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(false), MockSystem.new)
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden"]
+        end
+
+        it "handles X-Csrf-Token" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'TryToGuess'
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: Bad X-Csrf-Token: #{@env['HTTP_X_CSRF_TOKEN']}"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Handles Allowed Hosts" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_HOST'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: #{@env['HTTP_HOST']} not in allowed hosts"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess', ['5.6.7.8:7777']))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_HOST'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Handles Allowed Origins" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_ORIGIN'] = "5.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 403
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Forbidden: #{@env['HTTP_ORIGIN']} not in allowed origins"]
+
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess', ['127.0.0.1:7777'], ['3.6.7.8:7777']))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env['HTTP_ORIGIN'] = "3.6.7.8:7777"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 200
+          expect(type).to eql({'Content-Type' => "application/json-rpc"})
+          expect(body_array).to eql ["response"]
+        end
+
+        it "Only accepts posts" do
+          json_drb_rack = JsonDrbRack.new(MockDRb.new(true), MockSystem.new('NeverGuess'))
+          @env['HTTP_X_CSRF_TOKEN'] = 'NeverGuess'
+          @env["REQUEST_METHOD"] = "GET"
+          status, type, body_array = json_drb_rack.call(@env)
+          expect(status).to eql 405
+          expect(type).to eql({'Content-Type' => "text/plain"})
+          expect(body_array).to eql ["Request not allowed"]
+        end
+
+      end
+    end
+  end

data/spec/io/json_rpc_spec.rb

@@ -238,25 +238,25 @@ module Cosmos
 
       it "reports an error if there is no 'result' or 'error' key" do
         json = JsonRpcResponse.new(10).as_json
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if the version isn't 2.0" do
         json = JsonRpcResponse.new(10).as_json
         json['jsonrpc'] = "1.1"
         json['result'] = "true"
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if there is both a 'result' and 'error' key" do
         json = JsonRpcResponse.new(10).as_json
         json['result'] = "true"
         json['error'] = {"code"=>-1, "message"=>"error"}
-        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(json.to_json) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if it is not json" do
-        expect { JsonRpcResponse.from_json(Object.new) }.to raise_error("Invalid JSON-RPC 2.0 Response")
+        expect { JsonRpcResponse.from_json(Object.new) }.to raise_error(/Invalid JSON-RPC 2.0 Response/)
       end
 
       it "reports an error if the error hash is bad" do
@@ -268,4 +268,3 @@ module Cosmos
 
   end
 end
-

data/spec/io/posix_serial_driver_spec.rb

@@ -0,0 +1,81 @@
+# 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
+
+if RbConfig::CONFIG['target_os'] !~ /mswin|mingw|cygwin/i and RUBY_ENGINE == 'ruby' and !ENV['TRAVIS']
+
+  require 'spec_helper'
+  require 'cosmos/io/posix_serial_driver'
+
+  module Cosmos
+
+    describe PosixSerialDriver do
+      describe "instance" do
+        it "enforces the baud rate to a known value" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',10,:NONE) }.to raise_error(ArgumentError, "Invalid baud rate: 10")
+        end
+
+        it "supports even, odd, or no parity" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:EVEN).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:ODD).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
+        end
+
+        it "supports 1 or 2 stop bits" do
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,2).close }.to_not raise_error
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
+        end
+
+        it "supports 5-8 data bits" do
+          (5..8).each do |data_bits|
+            driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,data_bits)
+            handle = driver.instance_variable_get(:@handle)
+            expect(handle.tcgetattr.cflag & Termios::CSIZE).to eq(Termios.const_get("CS#{data_bits}"))
+            driver.close
+          end
+          expect { PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,9) }.to raise_error(ArgumentError, "Invalid data bits: 9")
+        end
+
+        it "sets arbitrary Posix structure elements" do
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,8)
+          handle = driver.instance_variable_get(:@handle)
+          # Verify non of the things we're going to set are already set
+          expect(handle.tcgetattr.iflag & Termios::IGNBRK).to eq(0)
+          expect(handle.tcgetattr.oflag & Termios::OPOST).to eq(0)
+          expect(handle.tcgetattr.cflag & Termios::CLOCAL).to eq(Termios::CLOCAL) # We set this by default
+          expect(handle.tcgetattr.lflag & Termios::ECHO).to eq(0)
+          expect(handle.tcgetattr.cc[Termios::VMIN]).to eq(1)
+          driver.close
+          # When setting a field the "1" is optional. When clearing a field the "0" is required.
+          # Entries in the "cc" special characters field are automatically converted to integers if they are numbers
+          struct = [["iflag", "IGNBRK"], ["oflag", "OPOST", "1"], ["cflag", "CLOCAL", "0"], ["lflag", "ECHO"], ["cc", "VMIN", "2"]]
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600,:NONE,1,10,nil,:NONE,8,struct)
+          handle = driver.instance_variable_get(:@handle)
+          expect(handle.tcgetattr.iflag & Termios::IGNBRK).to eq(Termios::IGNBRK)
+          expect(handle.tcgetattr.oflag & Termios::OPOST).to eq(Termios::OPOST)
+          expect(handle.tcgetattr.cflag & Termios::CLOCAL).to eq(0)
+          expect(handle.tcgetattr.lflag & Termios::ECHO).to eq(Termios::ECHO)
+          expect(handle.tcgetattr.cc[Termios::VMIN]).to eq(2)
+          driver.close
+        end
+      end
+
+      describe "close, closed?" do
+        it "closes the handle" do
+          driver = PosixSerialDriver.new('/dev/ttyS0',9600)
+          expect(driver.closed?).to be false
+          driver.close
+          expect(driver.closed?).to be true
+        end
+      end
+    end
+  end
+end

data/spec/io/win32_serial_driver_spec.rb

@@ -19,7 +19,8 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
       before(:each) do
         allow(Win32).to receive(:create_file).and_return(Object.new)
         state = double("comm_state")
-        allow(state).to receive(:write)
+        @dcb_struct = {}
+        allow(state).to receive(:write) { |key, value| @dcb_struct[key] = value }
         allow(Win32).to receive(:get_comm_state).and_return(state)
         allow(Win32).to receive(:set_comm_state)
         allow(Win32).to receive(:set_comm_timeouts)
@@ -34,12 +35,14 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
           expect { Win32SerialDriver.new('COM1',9600,:EVEN) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:ODD) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE) }.to_not raise_error
+          expect(@dcb_struct["Parity"]).to_not be_nil # Simply check that Parity was set
           expect { Win32SerialDriver.new('COM1',9600,:BLAH) }.to raise_error(ArgumentError, "Invalid parity: BLAH")
         end
 
         it "supports 1 or 2 stop bits" do
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,2) }.to_not raise_error
+          expect(@dcb_struct["StopBits"]).to_not be_nil # Simply check that StopBits was set
           expect { Win32SerialDriver.new('COM1',9600,:NONE,3) }.to raise_error(ArgumentError, "Invalid stop bits: 3")
         end
 
@@ -49,6 +52,19 @@ if RUBY_ENGINE == 'ruby' or Gem.win_platform?
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,7) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8) }.to_not raise_error
           expect { Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,9) }.to raise_error(ArgumentError, "Invalid data bits: 9")
+          expect(@dcb_struct["ByteSize"]).to_not be_nil # Simply check that ByteSize was set
+        end
+
+        it "sets arbitrary Windows DCB structure elements" do
+          Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8)
+          expect(@dcb_struct["fOutxDsrFlow"]).to be_nil # This isn't set by default
+          expect(@dcb_struct["Parity"]).to eq(0)
+          # Set a new variable in the Windows DCB struct and override the :NONE parity
+          # We pass them in as strings because that's how they're parsed
+          struct = [["fOutxDsrFlow", "1"], ["Parity", "4"]]
+          Win32SerialDriver.new('COM1',9600,:NONE,1,10,nil,0.01,1000,:NONE,8,struct)
+          expect(@dcb_struct["fOutxDsrFlow"]).to eq(1)
+          expect(@dcb_struct["Parity"]).to eq(4)
         end
 
         it "calculates the correct timeouts" do

data/spec/system/system_spec.rb

@@ -703,6 +703,114 @@ module Cosmos
         end
       end
 
+      context "with ALLOW_ROUTER_COMMANDING" do
+        it "takes 0 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ROUTER_COMMANDING BLAH TRUE")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ALLOW_ROUTER_COMMANDING./)
+          tf.unlink
+        end
+
+        it "allows router commanding" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ROUTER_COMMANDING")
+          tf.close
+          expect(System.allow_router_commanding).to be false
+          System.instance.process_file(tf.path)
+          expect(System.allow_router_commanding).to be true
+          tf.unlink
+        end
+
+        it "it disallows router commanding if not present" do
+          tf = Tempfile.new('unittest')
+
+          tf.close
+          expect(System.allow_router_commanding).to be false
+          System.instance.process_file(tf.path)
+          expect(System.allow_router_commanding).to be false
+          tf.unlink
+        end
+      end
+
+      context "with X_CSRF_TOKEN" do
+        it "takes 1 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("X_CSRF_TOKEN")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for X_CSRF_TOKEN./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("X_CSRF_TOKEN localhost true")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for X_CSRF_TOKEN./)
+          tf.unlink
+        end
+
+        it "updates the CSRF token" do
+          tf = Tempfile.new('unittest')
+          tf.puts("X_CSRF_TOKEN ExtraSpecial")
+          tf.close
+          expect(System.x_csrf_token).to eql "SuperSecret"
+          System.instance.process_file(tf.path)
+          expect(System.x_csrf_token).to eql "ExtraSpecial"
+          tf.unlink
+        end
+      end
+
+      context "with ALLOW_HOST" do
+        it "takes 1 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_HOST")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for ALLOW_HOST./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_HOST localhost true")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ALLOW_HOST./)
+          tf.unlink
+        end
+
+        it "adds to allowed hosts" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_HOST 1.2.3.4:8888")
+          tf.close
+          expect(System.allowed_hosts).to_not include("1.2.3.4:8888")
+          System.instance.process_file(tf.path)
+          expect(System.allowed_hosts).to include("1.2.3.4:8888")
+          tf.unlink
+        end
+      end
+
+      context "with ALLOW_ORIGIN" do
+        it "takes 1 parameters" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ORIGIN")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Not enough parameters for ALLOW_ORIGIN./)
+          tf.unlink
+
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ORIGIN localhost true")
+          tf.close
+          expect { System.instance.process_file(tf.path) }.to raise_error(ConfigParser::Error, /Too many parameters for ALLOW_ORIGIN./)
+          tf.unlink
+        end
+
+        it "adds to allowed origins" do
+          tf = Tempfile.new('unittest')
+          tf.puts("ALLOW_ORIGIN 1.2.3.4:8888")
+          tf.close
+          expect(System.allowed_origins).to_not include("1.2.3.4:8888")
+          System.instance.process_file(tf.path)
+          expect(System.allowed_origins).to include("1.2.3.4:8888")
+          tf.unlink
+        end
+      end
+
       context "with ALLOW_ACCESS" do
         it "takes 1 parameters" do
           tf = Tempfile.new('unittest')