roku_builder 4.1.0 → 4.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 573c78252bcce4dea40430de90789acd0d4f3a05
-  data.tar.gz: 8c96b5bfa0b1f2dcab2c8b19f47fe477f972e604
+  metadata.gz: 76ae977634fda5e0bf54a43c8ad3f4ed9f25ecbd
+  data.tar.gz: 5bc65db62d56b8a93a2abb6f1448b3972aa9f8a5
 SHA512:
-  metadata.gz: 4e144ca75cb797bbe36846cdcfc17512ac6c13333712d7e3862e4d90e0d0d455d28f1c83c308fc2a91bdc66efaed910024199db0158e691c1a579d23a0f75597
-  data.tar.gz: d41bb3e7113cd436cc2418e9c2f7c9a1288565bf140e373ccaf89c9da76c5a4464c1d34532d2be2de592804bcd18519e96a19df77808768da3b34a1afe45ea06
+  metadata.gz: 8599f80443262180266504b745ed95d3cd4751e2404b8da870b2690c9913e58ade819f7faea4bf2be45ee7ebb39081ae0991ca6b277b16fff0ddef0da4e2b016
+  data.tar.gz: b0e5b307b438d757dc08e636fb3e18bea910009eac62e0752ddab0bcef63006bf69f0b090dc3fcd664fa3a86641b3638141774ca7644c135f9750749c42e41f5

data/CHANGELOG

@@ -1,3 +1,13 @@
+ = 4.2.0 =
+
+ - Added `--sgperf` command to do performance reports
+ - Added `--devlog` command to turn on enhanced logging
+ - Added memmory profiler option to monitor image memmory usage
+ - Add 'roots' profiler option
+ - Add node id option to profiler
+ - images profiler option now sorts images by file size
+ - Improve formatting of verbose output of navigator
+
  = 4.1.0 =
 
  - Remove unnecessary default manifest values

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roku_builder (4.1.0)
+    roku_builder (4.2.0)
       faraday (~> 0.12)
       faraday-digestauth (~> 0.2)
       git (~> 1.3)

data/intergration/roku_builder/test_profiler.rb

@@ -32,6 +32,18 @@ module RokuBuilder
       output = `#{roku} --profile all`
       assert_match(/RectangleExample/, output)
     end
+    def test_profile_roots
+      `#{roku} --sideload --working`
+      assert_log @uuid
+      output = `#{roku} --profile roots`
+      assert_match(/Default/, output)
+    end
+    def test_profile_node
+      `#{roku} --sideload --working`
+      assert_log @uuid
+      output = `#{roku} --profile exampleRectangle`
+      assert_match(/name="exampleRectangle"/, output)
+    end
     def test_profile_images
       `#{roku} --sideload --working`
       assert_log @uuid

data/lib/roku_builder/plugins/monitor.rb

@@ -66,9 +66,10 @@ module RokuBuilder
       end
 
       commands = [
-        "bsc", "bscs", "brkd", "bt", "classes", "cont", "cont", "down", "d",
-        "exit", "gc", "help", "last", "list", "next", "print", "p", "?", "step",
-        "s", "t", "over", "out", "up", "u", "var", "q"
+        "bsc", "bscs", "brkd", "bt", "c", "classes", "cont", "cont", "down", "d",
+        "exit", "gc", "help", "l", "last", "list", "n", "next", "o", "print",
+        "p", "?", "s", "stats", "step", "t", "th", "thread", "threads", "ths",
+        "over", "out", "up", "u", "q", "v", "var"
       ].sort
       commands.collect { |i| i + ' '  } if libedit
 

data/lib/roku_builder/plugins/navigator.rb

@@ -102,9 +102,9 @@ module RokuBuilder
       running = true
       @logger.info("Key Mappings:")
       @mappings.each_value {|key|
-        @logger.info("#{key[1]} -> #{@commands[key[0].to_sym]}")
+        @logger.info(sprintf("%13s -> %s", key[1], @commands[key[0].to_sym]))
       }
-      @logger.info("Control-C -> Exit")
+      @logger.info(sprintf("%13s -> %s", "Ctrl + c", "Exit"))
       while running
         char = read_char
         @logger.debug("Char: #{char.inspect}")

data/lib/roku_builder/plugins/profiler.rb

@@ -7,7 +7,11 @@ module RokuBuilder
     extend Plugin
 
     def self.commands
-      {profile: {device: true}}
+      {
+        profile: {device: true},
+        sgperf: {device: true},
+        devlog: {device: true}
+      }
     end
 
     def self.parse_options(parser:, options:)
@@ -15,21 +19,80 @@ module RokuBuilder
       parser.on("--profile COMMAND", "Run various profiler options") do |c|
         options[:profile] = c
       end
+      parser.on("--sgperf", "Run scenegraph profiler") do
+        options[:sgperf] = true
+      end
+      parser.on("--devlog FUNCTION [TYPE]", "Run scenegraph profiler") do |f, t|
+        options[:devlog] = t || "rendezvous"
+        options[:devlog_function] = f
+      end
     end
 
     # Run the profiler commands
     # @param command [Symbol] The profiler command to run
     def profile(options:)
+      @connection = nil
       case options[:profile].to_sym
       when :stats
         print_stats
       when :all
         print_all_nodes
+      when :roots
+        print_root_nodes
       when :images
         print_image_information
+      when :memmory
+        print_memmory_usage
       when :textures
         print_texture_information
+      else
+        print_nodes_by_id(options[:profile])
       end
+      @connection.close if @connection
+    end
+
+    def sgperf(options:)
+      telnet_config ={
+        'Host' => @roku_ip_address,
+        'Port' => 8080
+      }
+      @connection = Net::Telnet.new(telnet_config)
+      @connection.puts("sgperf clear\n")
+      @connection.puts("sgperf start\n")
+      start_reg = /thread/
+      end_reg = /#{SecureRandom.uuid}/
+      prev_lines = 0
+      begin
+      while true
+        lines = get_command_response(command: "sgperf report", start_reg: start_reg,
+          end_reg: end_reg, ignore_warnings: true)
+        results = []
+        lines.each do |line|
+          match = /thread node calls: create\s*(\d*) \+ op\s*(\d*)\s*@\s*(\d*\.\d*)% rendezvous/.match(line)
+          results.push([match[1].to_i, match[2].to_i, match[3].to_f])
+        end
+        print "\r" + ("\e[A\e[K"*prev_lines)
+        prev_lines = 0
+        results.each_index do |i|
+          line = results[i]
+          if line[0] > 0 or line[1] > 0 or options[:verbose]
+            prev_lines += 1
+            puts "Thread #{i}: c:#{line[0]} u:#{line[1]} r:#{line[2]}%"
+          end
+        end
+      end
+      rescue SystemExit, Interrupt
+        @connection.close if @connection
+      end
+    end
+
+    def devlog(options:)
+      telnet_config ={
+        'Host' => @roku_ip_address,
+        'Port' => 8080
+      }
+      connection = Net::Telnet.new(telnet_config)
+      connection.puts("enhanced_dev_log #{options[:devlog]} #{options[:devlog_function]}\n")
     end
 
     private
@@ -67,12 +130,39 @@ module RokuBuilder
       lines = get_command_response(command: "sgnodes all", start_reg: start_reg, end_reg: end_reg)
       lines.each {|line| print line}
     end
+    def print_root_nodes
+      start_reg = /<Root_Nodes>/
+      end_reg = /<\/Root_Nodes>/
+      lines = get_command_response(command: "sgnodes roots", start_reg: start_reg, end_reg: end_reg)
+      lines.each {|line| print line}
+    end
+    def print_nodes_by_id(id)
+      start_reg = /<#{id}>/
+      end_reg = /<\/#{id}>/
+      lines = get_command_response(command: "sgnodes #{id}", start_reg: start_reg, end_reg: end_reg)
+      lines.each {|line| print line}
+    end
     def print_image_information
       start_reg = /RoGraphics instance/
       end_reg = /Available memory/
       lines = get_command_response(command: "r2d2_bitmaps", start_reg: start_reg, end_reg: end_reg)
+      lines = sort_image_lines(lines)
       lines.each {|line| print line}
     end
+    def print_memmory_usage
+      start_reg = /RoGraphics instance/
+      end_reg = /Available memory/
+      begin
+      while true
+        lines = get_command_response(command: "r2d2_bitmaps", start_reg: start_reg, end_reg: end_reg, ignore_warnings: true)
+        memmory_data = get_memmory_data(lines)
+        print_memmory_data(memmory_data)
+        sleep 1
+      end
+      rescue SystemExit, Interrupt
+        #Exit
+      end
+    end
     def print_texture_information
       start_reg = /\*+/
       end_reg = /#{SecureRandom.uuid}/
@@ -82,30 +172,31 @@ module RokuBuilder
 
     # Retrive list of all nodes
     # @return [Array<String>] Array of lines
-    def get_command_response(command:, start_reg:, end_reg:, unique: false)
+    def get_command_response(command:, start_reg:, end_reg:, unique: false, ignore_warnings: false)
       waitfor_config = {
         'Match' => /.+/,
-        'Timeout' => 5
+        'Timeout' => 1
       }
-      telnet_config ={
-        'Host' => @roku_ip_address,
-        'Port' => 8080
-      }
-
-      connection = Net::Telnet.new(telnet_config)
+      unless @connection
+        telnet_config ={
+          'Host' => @roku_ip_address,
+          'Port' => 8080
+        }
+        @connection = Net::Telnet.new(telnet_config)
+      end
 
       @lines = []
       @all_txt = ""
       @begun = false
       @done = false
-      connection.puts("#{command}\n")
+      @connection.puts("#{command}\n")
       while not @done
         begin
-          connection.waitfor(waitfor_config) do |txt|
+          @connection.waitfor(waitfor_config) do |txt|
             handle_text(txt: txt, start_reg: start_reg, end_reg: end_reg, unique: unique)
           end
         rescue Net::ReadTimeout
-          @logger.warn "Timed out reading profiler information"
+          @logger.warn "Timed out reading profiler information" unless ignore_warnings
           @done = true
         end
       end
@@ -122,6 +213,7 @@ module RokuBuilder
       while line = @all_txt.slice!(/^.*\n/) do
         if line =~ start_reg
           @begun = true
+          @done = false
           @lines = [] if unique
         end
         @lines.push(line) if @begun
@@ -131,6 +223,53 @@ module RokuBuilder
         end
       end
     end
+
+    def sort_image_lines(lines)
+      new_lines = []
+      line = lines.shift
+      while line != nil
+        reg = /0x[^\s]+\s+\d+\s+\d+\s+\d+\s+\d+/
+        line_data = []
+        while line =~ reg
+          line_data.push({line: line, size: line.split[4].to_i})
+          line = lines.shift
+        end
+        line_data.sort! {|a, b| b[:size] <=> a[:size]}
+        line_data.each {|data| new_lines.push(data[:line])}
+        new_lines.push(line)
+        line = lines.shift
+      end
+      return new_lines
+    end
+
+    def get_memmory_data(lines)
+      data = {}
+      line = lines.shift
+      while line != nil
+        first_match = /RoGraphics instance (0x.*)/.match(line)
+        if first_match
+          while line != nil
+            usage_match = /Available memory (\d*) used (\d*) max (\d*)/.match(line)
+              if usage_match
+                data[first_match[1]] = [usage_match[1].to_i, usage_match[2].to_i, usage_match[3].to_i]
+                break
+              end
+            line = lines.shift
+          end
+        end
+        line = lines.shift
+      end
+      return data
+    end
+
+    def print_memmory_data(data)
+      @prev_lines ||= 0
+      print "\r" + ("\e[A\e[K"*@prev_lines)
+      data.each_key do |key|
+        print "#{key}: #{(data[key][1]*100)/data[key][2]}%\n"
+      end
+      @prev_lines = data.count
+    end
   end
   RokuBuilder.register_plugin(Profiler)
 end

data/lib/roku_builder/version.rb

@@ -2,5 +2,5 @@
 
 module RokuBuilder
   # Version of the RokuBuilder Gem
-  VERSION = "4.1.0"
+  VERSION = "4.2.0"
 end

data/test/roku_builder/plugins/test_profiler.rb

@@ -15,17 +15,16 @@ module RokuBuilder
       parser = OptionParser.new
       options = {}
       Profiler.parse_options(parser: parser, options: options)
-      argv = ["roku", "--profile", "command"]
+      argv = ["roku", "--profile", "command", "--sgperf", "--devlog", "on"]
       parser.parse! argv
       assert_equal "command", options[:profile]
     end
     def test_profiler_stats
-      Logger.set_testing
       options = {profile: "stats"}
       config, options = build_config_options_objects(ProfilerTest, options, false)
       waitfor = Proc.new do |telnet_config, &blk|
         assert_equal(/.+/, telnet_config["Match"])
-        assert_equal(5, telnet_config["Timeout"])
+        assert_equal(1, telnet_config["Timeout"])
         txt = "<All_Nodes><NodeA /><NodeB /><NodeC><NodeD /></NodeC></All_Nodes>\n"
         blk.call(txt)
         true
@@ -35,6 +34,7 @@ module RokuBuilder
 
       connection.expect(:puts, nil, ["sgnodes all\n"])
       connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:close, nil)
 
       Net::Telnet.stub(:new, connection) do
         profiler.stub(:printf, nil) do
@@ -45,12 +45,11 @@ module RokuBuilder
       connection.verify
     end
     def test_profiler_all
-      Logger.set_testing
       options = {profile: "all"}
       config, options = build_config_options_objects(ProfilerTest, options, false)
       waitfor = Proc.new do |telnet_config, &blk|
         assert_equal(/.+/, telnet_config["Match"])
-        assert_equal(5, telnet_config["Timeout"])
+        assert_equal(1, telnet_config["Timeout"])
         txt = "<All_Nodes><NodeA /><NodeB /><NodeC><NodeD /></NodeC></All_Nodes>\n"
         blk.call(txt)
         true
@@ -60,6 +59,7 @@ module RokuBuilder
 
       connection.expect(:puts, nil, ["sgnodes all\n"])
       connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:close, nil)
 
       Net::Telnet.stub(:new, connection) do
         profiler.stub(:print, nil) do
@@ -69,14 +69,61 @@ module RokuBuilder
 
       connection.verify
     end
+    def test_profiler_roots
+      options = {profile: "roots"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      waitfor = Proc.new do |telnet_config, &blk|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(1, telnet_config["Timeout"])
+        txt = "<Root_Nodes><NodeA /><NodeB /><NodeC><NodeD /></NodeC></Root_Nodes>\n"
+        blk.call(txt)
+        true
+      end
+      connection = Minitest::Mock.new
+      profiler = Profiler.new(config: config)
+
+      connection.expect(:puts, nil, ["sgnodes roots\n"])
+      connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:close, nil)
+
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:print, nil) do
+          profiler.profile(options: options)
+        end
+      end
+      connection.verify
+    end
+    def test_profiler_node
+      options = {profile: "nodeId"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      waitfor = Proc.new do |telnet_config, &blk|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(1, telnet_config["Timeout"])
+        txt = "<nodeId><NodeA /><NodeB /><NodeC><NodeD /></NodeC></nodeId>\n"
+        blk.call(txt)
+        true
+      end
+      connection = Minitest::Mock.new
+      profiler = Profiler.new(config: config)
+
+      connection.expect(:puts, nil, ["sgnodes nodeId\n"])
+      connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:close, nil)
+
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:print, nil) do
+          profiler.profile(options: options)
+        end
+      end
+      connection.verify
+    end
     def test_profiler_images
-      Logger.set_testing
       options = {profile: "images"}
       config, options = build_config_options_objects(ProfilerTest, options, false)
       waitfor = Proc.new do |telnet_config, &blk|
         assert_equal(/.+/, telnet_config["Match"])
-        assert_equal(5, telnet_config["Timeout"])
-        txt = " RoGraphics instance\nAvailable memory\n"
+        assert_equal(1, telnet_config["Timeout"])
+        txt = " RoGraphics instance\n0x234 1 2 3 4\nAvailable memory\n"
         blk.call(txt)
         true
       end
@@ -85,6 +132,7 @@ module RokuBuilder
 
       connection.expect(:puts, nil, ["r2d2_bitmaps\n"])
       connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:close, nil)
 
       Net::Telnet.stub(:new, connection) do
         profiler.stub(:print, nil) do
@@ -94,13 +142,61 @@ module RokuBuilder
 
       connection.verify
     end
+
+    def test_profiler_memmory
+      options = {profile: "memmory"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      waitfor = Proc.new do |telnet_config, &blk|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(1, telnet_config["Timeout"])
+        txt = " RoGraphics instance 0x123\nAvailable memory 123 used 456 max 579\n"
+        blk.call(txt)
+        true
+      end
+      print_count = 0
+      print_stub = Proc.new do |message|
+        case print_count
+        when 0
+          assert_equal "\r", message
+        when 1
+          assert_equal "0x123: 78%\n", message
+        end
+        print_count +=1
+        true
+      end
+      first = true
+      puts_stub = Proc.new do |message|
+        if first
+          assert_equal "r2d2_bitmaps\n", message
+          first  = false
+        else
+          raise SystemExit
+        end
+        true
+      end
+      connection = Minitest::Mock.new
+      profiler = Profiler.new(config: config)
+
+      connection.expect(:puts, nil, &puts_stub)
+      connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:puts, nil, &puts_stub)
+      connection.expect(:close, nil)
+
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:print, print_stub) do
+          profiler.profile(options: options)
+        end
+      end
+
+      assert print_count > 1
+      connection.verify
+    end
     def test_profiler_textures
-      Logger.set_testing
       options = {profile: "textures"}
       config, options = build_config_options_objects(ProfilerTest, options, false)
       waitfor = Proc.new do |telnet_config, &blk|
         assert_equal(/.+/, telnet_config["Match"])
-        assert_equal(5, telnet_config["Timeout"])
+        assert_equal(1, telnet_config["Timeout"])
         txt = "*******\ntexture\n"
         blk.call(txt)
         true
@@ -114,6 +210,7 @@ module RokuBuilder
       connection.expect(:puts, nil, ["loaded_textures\n"])
       connection.expect(:waitfor, nil, &waitfor)
       connection.expect(:waitfor, nil, &timeout)
+      connection.expect(:close, nil)
 
       Net::Telnet.stub(:new, connection) do
         profiler.stub(:print, nil) do
@@ -123,5 +220,123 @@ module RokuBuilder
 
       connection.verify
     end
+    def test_profiler_devlog
+      options = {devlog: "rendezvous", devlog_function: "on"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+
+      connection = Minitest::Mock.new
+      connection.expect(:puts, nil, ["enhanced_dev_log rendezvous on\n"])
+
+      profiler = Profiler.new(config: config)
+      Net::Telnet.stub(:new, connection) do
+        profiler.devlog(options: options)
+      end
+      connection.verify
+    end
+    def test_profiler_sgperf
+      options = {sgperf: true}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      profiler = Profiler.new(config: config)
+
+      connection = Object.new
+      connection.define_singleton_method(:puts){}
+      connection.define_singleton_method(:waitfor){}
+      connection.define_singleton_method(:close){}
+
+      message_count = {}
+      puts_stub = Proc.new { |message|
+        message_count[message] ||= 0
+        message_count[message] += 1
+        case message
+        when "sgperf clear\n"
+          assert_equal 1, message_count[message]
+        when "sgperf start\n"
+          assert_equal 1, message_count[message]
+        when "sgperf report\n"
+          if message_count[message] > 1
+            raise SystemExit
+          end
+        end
+      }
+      waitfor = Proc.new {|telnet_config|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(1, telnet_config["Timeout"])
+        raise Net::ReadTimeout
+      }
+
+      Net::Telnet.stub(:new, connection) do
+        connection.stub(:puts, puts_stub) do
+          txt = ">>thread node calls: create     0 + op    24  @ 100.0% rendezvous"
+          connection.stub(:waitfor, waitfor, txt) do
+            profiler.sgperf(options: options)
+          end
+        end
+      end
+
+      assert(0 < message_count["sgperf clear\n"])
+      assert(0 < message_count["sgperf start\n"])
+      assert(0 < message_count["sgperf report\n"])
+
+    end
+    def test_profiler_sgperf_multi_lines
+      options = {sgperf: true}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      profiler = Profiler.new(config: config)
+
+      connection = Object.new
+      connection.define_singleton_method(:puts){}
+      connection.define_singleton_method(:waitfor){}
+      connection.define_singleton_method(:close){}
+
+      message_count = {}
+      connection_puts = Proc.new { |message|
+        message_count[message] ||= 0
+        message_count[message] += 1
+        case message
+        when "sgperf clear\n"
+          assert_equal 1, message_count[message]
+        when "sgperf start\n"
+          assert_equal 1, message_count[message]
+        end
+      }
+      first = true
+      command_response = Proc.new { 
+        if first
+          first = false
+          [">>thread node calls: create     0 + op    24  @ 0.0% rendezvous",
+            "thread node calls: create     1 + op    0  @ 100.0% rendezvous",
+            "thread node calls: create     0 + op    1  @ 100.0% rendezvous"]
+        else
+          raise SystemExit
+        end
+      }
+      call_count = 0
+      profiler_puts = Proc.new { |message|
+        case call_count
+        when 0
+          assert_equal("Thread 0: c:0 u:24 r:0.0%", message)
+        when 1
+          assert_equal("Thread 1: c:1 u:0 r:100.0%", message)
+        when 2
+          assert_equal("Thread 2: c:0 u:1 r:100.0%", message)
+        end
+        call_count += 1
+      }
+
+      Net::Telnet.stub(:new, connection) do
+        connection.stub(:puts, connection_puts) do
+          profiler.stub(:get_command_response, command_response) do
+            profiler.stub(:puts, profiler_puts) do
+              profiler.sgperf(options: options)
+            end
+          end
+        end
+      end
+
+      assert(2 < call_count)
+      assert(0 < message_count["sgperf clear\n"])
+      assert(0 < message_count["sgperf start\n"])
+
+    end
   end
 end

data/test/roku_builder/test_config.rb

@@ -119,6 +119,38 @@ module RokuBuilder
       File.delete(target_config) if File.exist?(target_config)
     end
 
+    def test_config_configure_edit_params_project
+      target_config = File.join(test_files_path(ConfigTest), "configure_test.json")
+      options = build_options({
+        config: target_config,
+        configure: true,
+        edit_params: "directory:/test/dir"
+      })
+      File.delete(target_config) if File.exist?(target_config)
+      refute File.exist?(target_config)
+      config = Config.new(options: options)
+      config.configure
+      assert File.exist?(target_config)
+      assert_equal "/test/dir", config.raw[:projects][config.raw[:projects][:default]][:directory]
+      File.delete(target_config) if File.exist?(target_config)
+    end
+
+    def test_config_configure_edit_params_stage
+      target_config = File.join(test_files_path(ConfigTest), "configure_test.json")
+      options = build_options({
+        config: target_config,
+        configure: true,
+        edit_params: "branch:test"
+      })
+      File.delete(target_config) if File.exist?(target_config)
+      refute File.exist?(target_config)
+      config = Config.new(options: options)
+      config.configure
+      assert File.exist?(target_config)
+      assert_equal "test", config.raw[:projects][config.raw[:projects][:default]][:stages][:production][:branch]
+      File.delete(target_config) if File.exist?(target_config)
+    end
+
     def test_config_configure_edit_params_default
       target_config = File.join(test_files_path(ConfigTest), "configure_test.json")
       options = build_options({

data/test/roku_builder/test_options.rb

@@ -5,7 +5,8 @@ require_relative "test_helper.rb"
 module RokuBuilder
   class OptionsTest < Minitest::Test
     def setup
-      RokuBuilder.class_variable_set(:@@plugins, [])
+      RokuBuilder.setup_plugins
+      register_plugins(Core)
       Logger.set_testing
     end
     def teardown
@@ -36,8 +37,10 @@ module RokuBuilder
       parser.expect(:banner=, nil, [String])
       parser.expect(:parse!, nil)
       OptionParser.stub(:new, parser) do
-        options.stub(:validate_parser, nil) do
-          options_hash = options.send(:parse)
+        options.stub(:add_plugin_options, nil) do
+          options.stub(:validate_parser, nil) do
+            options_hash = options.send(:parse)
+          end
         end
       end
       parser.verify
@@ -50,12 +53,14 @@ module RokuBuilder
       parser.expect(:banner=, nil, [String])
       parser.expect(:parse!, nil)
       OptionParser.stub(:new, parser) do
-        options.send(:parse)
+        options.stub(:add_plugin_options, nil) do
+          options.send(:parse)
+        end
       end
       parser.verify
       Array.class_eval { remove_method :each_option  }
     end
-    def test_options_parse_validate_options_bad
+    def test_options_parse_validate_options_bad_short
       Array.class_eval { alias_method :each_option, :each  }
       parser = Minitest::Mock.new()
       options = Options.allocate
@@ -64,13 +69,32 @@ module RokuBuilder
 
       OptionParser.stub(:new, parser) do
         assert_raises(ImplementationError) do
-          options.send(:parse)
+          options.stub(:add_plugin_options, nil) do
+            options.send(:parse)
+          end
         end
       end
       parser.verify
       Array.class_eval { remove_method :each_option  }
     end
-    def build_stack(good = true)
+    def test_options_parse_validate_options_bad_long
+      Array.class_eval { alias_method :each_option, :each  }
+      parser = Minitest::Mock.new()
+      options = Options.allocate
+      parser.expect(:banner=, nil, [String])
+      parser.expect(:instance_variable_get, build_stack(true, false), [:@stack])
+
+      OptionParser.stub(:new, parser) do
+        options.stub(:add_plugin_options, nil) do
+          assert_raises(ImplementationError) do
+            options.send(:parse)
+          end
+        end
+      end
+      parser.verify
+      Array.class_eval { remove_method :each_option  }
+    end
+    def build_stack(shortgood = true, longgood = true)
       optionsA = Minitest::Mock.new()
       optionsB = Minitest::Mock.new()
       list = [optionsA, optionsB]
@@ -78,11 +102,14 @@ module RokuBuilder
       3.times do
         optionsA.expect(:short, [ "a" ])
         optionsA.expect(:long, [ "aOption" ])
-        if good
+        if shortgood
           optionsB.expect(:short, [ "b" ])
-          optionsB.expect(:long, ["bOption" ])
         else
           optionsB.expect(:short, [ "a" ])
+        end
+        if longgood
+          optionsB.expect(:long, ["bOption" ])
+        else
           optionsB.expect(:long, [ "aOption" ])
         end
       end
@@ -103,6 +130,15 @@ module RokuBuilder
         build_options(options)
       end
     end
+    def test_options_validate_source
+      options = Options.allocate
+      options.stub(:source_command?, true) do
+        assert_raises InvalidOptions do
+          options.send(:initialize, {options: {validate: true}})
+          options.validate
+        end
+      end
+    end
     def test_options_validate_extra_sources_sideload
       options = {
         validate: true,
@@ -123,6 +159,17 @@ module RokuBuilder
         build_options(options)
       end
     end
+    def test_options_validate_depricated
+      options = Options.allocate
+      logger = Minitest::Mock.new()
+      logger.expect(:warn, nil, ["Depricated"])
+      Logger.class_variable_set(:@@instance, logger)
+      options.stub(:depricated_options, {validate: "Depricated"}) do
+        options.send(:initialize, {options: {validate: true}})
+        options.validate
+      end
+      logger.verify
+    end
     def test_options_exclude_command
       options = build_options({
         validate:true,

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 4.2.0
 platform: ruby
 authors:
 - greeneca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-28 00:00:00.000000000 Z
+date: 2017-07-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip