roku_builder 3.11.0 → 3.11.1

data/tests/roku_builder/config_parser_test.rb

@@ -127,10 +127,81 @@ class ConfigParserTest < Minitest::Test
   def test_deeplink_app_config
     args = {
       config: {},
-      configs: {project_config: {directory: "dir"}, init_params: {}},
+      configs: {project_config: {directory: "dir"}, init_params: {}, out: {}},
       options: {deeplink: "a:b", app_id: "xxxxxx"},
-      logger: Logger.new("/dev/null")
     }
     RokuBuilder::ConfigParser.send(:setup_simple_configs, **args)
   end
+
+  def test_outfile_config
+    configs = {}
+    args = {
+     options: {out: nil},
+     configs: configs
+    }
+    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
+    refute_nil configs[:out]
+    refute_nil configs[:out][:folder]
+    assert_nil configs[:out][:file]
+    assert_equal "/tmp", configs[:out][:folder]
+
+    configs = {}
+    args = {
+     options: {out: "/home/user"},
+     configs: configs
+    }
+    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
+    refute_nil configs[:out]
+    refute_nil configs[:out][:folder]
+    assert_nil configs[:out][:file]
+    assert_equal "/home/user", configs[:out][:folder]
+
+    configs = {}
+    args = {
+     options: {out: "/home/user/file.pkg"},
+     configs: configs
+    }
+    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
+    refute_nil configs[:out]
+    refute_nil configs[:out][:folder]
+    refute_nil configs[:out][:file]
+    assert_equal "/home/user", configs[:out][:folder]
+    assert_equal "file.pkg", configs[:out][:file]
+
+    configs = {}
+    args = {
+     options: {out: "/home/user/file.zip"},
+     configs: configs
+    }
+    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
+    refute_nil configs[:out]
+    refute_nil configs[:out][:folder]
+    refute_nil configs[:out][:file]
+    assert_equal "/home/user", configs[:out][:folder]
+    assert_equal "file.zip", configs[:out][:file]
+
+    configs = {}
+    args = {
+     options: {out: "/home/user/file.jpg"},
+     configs: configs
+    }
+    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
+    refute_nil configs[:out]
+    refute_nil configs[:out][:folder]
+    refute_nil configs[:out][:file]
+    assert_equal "/home/user", configs[:out][:folder]
+    assert_equal "file.jpg", configs[:out][:file]
+
+    configs = {}
+    args = {
+     options: {out: "file.jpg"},
+     configs: configs
+    }
+    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
+    refute_nil configs[:out]
+    refute_nil configs[:out][:folder]
+    refute_nil configs[:out][:file]
+    assert_equal "/tmp", configs[:out][:folder]
+    assert_equal "file.jpg", configs[:out][:file]
+  end
 end

data/tests/roku_builder/config_validator_test.rb

@@ -157,4 +157,40 @@ class ConfigValidatorTest < Minitest::Test
     codes = RokuBuilder::ConfigValidator.validate_config(config: config)
     assert_equal [15], codes
   end
+
+  def test_config_manager_validate_project_key
+    config = good_config
+    config[:projects][:project2][:stages][:production][:key] = "b"
+    codes = RokuBuilder::ConfigValidator.validate_config(config: config)
+    assert_equal [22], codes
+  end
+
+  def test_config_manager_validate_keys_pkg
+    config = good_config
+    config[:keys][:a][:keyed_pkg] = nil
+    codes = RokuBuilder::ConfigValidator.validate_config(config: config)
+    assert_equal [19], codes
+    config = good_config
+    config[:keys][:a][:keyed_pkg] = "<path/to/signed/package>"
+    codes = RokuBuilder::ConfigValidator.validate_config(config: config)
+    assert_equal [19], codes
+  end
+
+  def test_config_manager_validate_keys_password
+    config = good_config
+    config[:keys][:a][:password] = nil
+    codes = RokuBuilder::ConfigValidator.validate_config(config: config)
+    assert_equal [20], codes
+    config = good_config
+    config[:keys][:a][:password] = "<password>"
+    codes = RokuBuilder::ConfigValidator.validate_config(config: config)
+    assert_equal [20], codes
+  end
+
+  def test_config_manager_validate_input_mappings
+    config = good_config
+    config[:input_mapping]["a"] = ["home"]
+    codes = RokuBuilder::ConfigValidator.validate_config(config: config)
+    assert_equal [21], codes
+  end
 end

data/tests/roku_builder/controller_commands_test.rb

@@ -27,7 +27,7 @@ class ControllerCommandsTest < Minitest::Test
 
     RokuBuilder::Loader.stub(:new, loader) do
       RokuBuilder::Stager.stub(:new, stager) do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
       end
     end
     assert_equal RokuBuilder::SUCCESS, code
@@ -39,7 +39,7 @@ class ControllerCommandsTest < Minitest::Test
     loader.expect(:sideload, [RokuBuilder::FAILED_SIDELOAD, "build_version"], [configs[:sideload_config]])
     RokuBuilder::Loader.stub(:new, loader) do
       RokuBuilder::Stager.stub(:new, stager) do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
       end
     end
     assert_equal RokuBuilder::FAILED_SIDELOAD, code
@@ -76,7 +76,7 @@ class ControllerCommandsTest < Minitest::Test
           RokuBuilder::Inspector.stub(:new, inspector) do
             RokuBuilder::Stager.stub(:new, stager) do
               Logger.stub(:new, logger) do
-                code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+                code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
               end
             end
           end
@@ -120,7 +120,7 @@ class ControllerCommandsTest < Minitest::Test
           RokuBuilder::Inspector.stub(:new, inspector) do
             RokuBuilder::Stager.stub(:new, stager) do
               Logger.stub(:new, logger) do
-                code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+                code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
               end
             end
           end
@@ -153,7 +153,7 @@ class ControllerCommandsTest < Minitest::Test
     RokuBuilder::Loader.stub(:new, loader) do
       RokuBuilder::ManifestManager.stub(:build_version, "1") do
         RokuBuilder::Stager.stub(:new, stager) do
-          code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+          code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
         end
       end
     end
@@ -178,7 +178,7 @@ class ControllerCommandsTest < Minitest::Test
     RokuBuilder::ManifestManager.stub(:build_version, mock) do
       RokuBuilder::ManifestManager.stub(:update_build, mock) do
         RokuBuilder::Stager.stub(:new, stager) do
-          code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+          code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
         end
       end
     end
@@ -197,7 +197,7 @@ class ControllerCommandsTest < Minitest::Test
     code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
     mock.expect(:launch, "true", [configs[:deeplink_config]])
     RokuBuilder::Linker.stub(:new, mock) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     mock.verify
     assert_equal RokuBuilder::SUCCESS, code
@@ -217,7 +217,7 @@ class ControllerCommandsTest < Minitest::Test
     mock.expect(:launch, "true", [configs[:deeplink_config]])
     RokuBuilder::Linker.stub(:new, mock) do
       RokuBuilder::ControllerCommands.stub(:sideload, sideload) do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
       end
     end
     mock.verify
@@ -238,7 +238,7 @@ class ControllerCommandsTest < Minitest::Test
     stager.expect(:unstage, true)
     RokuBuilder::Linker.stub(:new, mock) do
       RokuBuilder::Stager.stub(:new, stager) do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
       end
     end
     mock.verify
@@ -255,7 +255,7 @@ class ControllerCommandsTest < Minitest::Test
     code = nil
     RokuBuilder::Loader.stub(:new, loader) do
       RokuBuilder::ManifestManager.stub(:build_version, "1") do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
       end
     end
     assert_equal RokuBuilder::SUCCESS, code
@@ -272,7 +272,7 @@ class ControllerCommandsTest < Minitest::Test
     code = nil
     RokuBuilder::Monitor.stub(:new, monitor) do
       RokuBuilder::ManifestManager.stub(:build_version, "1") do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
       end
     end
     assert_equal RokuBuilder::SUCCESS, code
@@ -288,7 +288,7 @@ class ControllerCommandsTest < Minitest::Test
     navigator.expect(:nav, true, [configs[:navigate_config]])
     code = nil
     RokuBuilder::Navigator.stub(:new, navigator) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::SUCCESS, code
     navigator.verify
@@ -303,7 +303,7 @@ class ControllerCommandsTest < Minitest::Test
     navigator.expect(:nav, nil, [configs[:navigate_config]])
     code = nil
     RokuBuilder::Navigator.stub(:new, navigator) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::FAILED_NAVIGATING, code
     navigator.verify
@@ -318,7 +318,7 @@ class ControllerCommandsTest < Minitest::Test
     navigator.expect(:screen, true, [configs[:screen_config]])
     code = nil
     RokuBuilder::Navigator.stub(:new, navigator) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::SUCCESS, code
     navigator.verify
@@ -333,7 +333,7 @@ class ControllerCommandsTest < Minitest::Test
     navigator.expect(:screens, true)
     code = nil
     RokuBuilder::Navigator.stub(:new, navigator) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::SUCCESS, code
     navigator.verify
@@ -348,7 +348,7 @@ class ControllerCommandsTest < Minitest::Test
     navigator.expect(:type, true, [configs[:text_config]])
     code = nil
     RokuBuilder::Navigator.stub(:new, navigator) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::SUCCESS, code
     navigator.verify
@@ -363,7 +363,7 @@ class ControllerCommandsTest < Minitest::Test
     tester.expect(:run_tests, true, [configs[:test_config]])
     code = nil
     RokuBuilder::Tester.stub(:new, tester) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::SUCCESS, code
     tester.verify
@@ -378,7 +378,7 @@ class ControllerCommandsTest < Minitest::Test
     inspector.expect(:screencapture, true, [configs[:screencapture_config]])
     code = nil
     RokuBuilder::Inspector.stub(:new, inspector) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::SUCCESS, code
     inspector.verify
@@ -393,7 +393,7 @@ class ControllerCommandsTest < Minitest::Test
     inspector.expect(:screencapture, false, [configs[:screencapture_config]])
     code = nil
     RokuBuilder::Inspector.stub(:new, inspector) do
-      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
     end
     assert_equal RokuBuilder::FAILED_SCREENCAPTURE, code
     inspector.verify
@@ -413,7 +413,7 @@ class ControllerCommandsTest < Minitest::Test
 
     RokuBuilder::Stager.stub(:new, stager) do
       RokuBuilder::Scripter.stub(:print, print_check) do
-        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
       end
     end
     assert_equal RokuBuilder::SUCCESS, code

data/tests/roku_builder/controller_test.rb

@@ -149,11 +149,15 @@ class ControllerTest < Minitest::Test
             RokuBuilder::ErrorHandler.stub(:handle_configure_codes, nil) do
               RokuBuilder::ConfigManager.stub(:load_config, nil) do
                 RokuBuilder::ErrorHandler.stub(:handle_load_codes, nil) do
-                  RokuBuilder::Controller.stub(:check_devices, nil) do
-                    RokuBuilder::ErrorHandler.stub(:handle_device_codes, nil) do
-                      RokuBuilder::Controller.stub(:execute_commands, nil) do
-                        RokuBuilder::ErrorHandler.stub(:handle_command_codes, nil) do
-                          RokuBuilder::Controller.run(options: test[:options], logger: logger)
+                  RokuBuilder::Controller.stub(:validate_configs, nil) do
+                    RokuBuilder::ErrorHandler.stub(:handle_configs_codes, nil) do
+                      RokuBuilder::Controller.stub(:check_devices, nil) do
+                        RokuBuilder::ErrorHandler.stub(:handle_device_codes, nil) do
+                          RokuBuilder::Controller.stub(:execute_commands, nil) do
+                            RokuBuilder::ErrorHandler.stub(:handle_command_codes, nil) do
+                              RokuBuilder::Controller.run(options: test[:options], logger: logger)
+                            end
+                          end
                         end
                       end
                     end

data/tests/roku_builder/error_handler_test.rb

@@ -43,7 +43,11 @@ class ErrorHandlerTest < Minitest::Test
           RokuBuilder::FAILED_DEEPLINKING,
           RokuBuilder::FAILED_NAVIGATING,
           RokuBuilder::FAILED_SCREENCAPTURE,
+          RokuBuilder::MISSING_MANIFEST,
           RokuBuilder::BAD_PRINT_ATTRIBUTE
+        ],
+        configs_code: [
+          RokuBuilder::MISSING_OUT_FOLDER
         ]
       },
       info: {
@@ -61,6 +65,11 @@ class ErrorHandlerTest < Minitest::Test
         options_code: [
           RokuBuilder::DEPRICATED
         ]
+      },
+      debug: {
+        configs_code: [
+          RokuBuilder::VALID
+        ]
       }
     }
     error_groups.each_pair do |type,errors|

data/tests/roku_builder/keyer_test.rb

@@ -123,4 +123,57 @@ class KeyerTest < Minitest::Test
     io.verify
     response.verify
   end
+
+  def test_keyer_generate_new_key
+    connection = Minitest::Mock.new
+
+    connection.expect(:puts, nil, ["genkey"])
+    connection.expect(:waitfor, nil) do |config, &blk|
+      assert_equal(/./, config['Match'])
+      assert_equal(false, config['Timeout'])
+      txt = "Password: password\nDevID: devid\n"
+      blk.call(txt)
+      true
+    end
+    connection.expect(:close, nil, [])
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    keyer = RokuBuilder::Keyer.new(**device_config)
+    Net::Telnet.stub(:new, connection) do
+      keyer.send(:generate_new_key)
+    end
+  end
+
+  def test_keyer_genkey
+    loader = Minitest::Mock.new
+    packager = Minitest::Mock.new
+
+    loader.expect(:sideload, nil)
+    packager.expect(:package, nil, [app_name_version: "key_dev_id", out_file: "/tmp/key_dev_id.pkg", password: "password"])
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+
+    keyer = RokuBuilder::Keyer.new(**device_config)
+
+    RokuBuilder::Loader.stub(:new, loader) do
+      RokuBuilder::Packager.stub(:new, packager) do
+        keyer.stub(:generate_new_key, ["password", "dev_id"]) do
+          keyer.genkey
+        end
+      end
+    end
+
+    loader.verify
+    packager.verify
+  end
 end

data/tests/roku_builder/monitor_test.rb

@@ -124,12 +124,8 @@ class MonitorTest < Minitest::Test
     def monitor.puts(input)
       @mock.puts(input)
     end
-    def monitor.print(input)
-      @mock.print(input)
-    end
 
     mock.expect(:puts, nil, ["midline split\n"])
-    mock.expect(:print, nil, ["BrightScript Debugger> "])
 
     all_text = "midline "
     txt = "split\nBrightScript Debugger> "
@@ -138,5 +134,7 @@ class MonitorTest < Minitest::Test
 
     assert_equal "", result
 
+    mock.verify
+
   end
 end

data/tests/roku_builder/navigator_test.rb

@@ -140,4 +140,148 @@ class NavigatorTest < Minitest::Test
 
     logger.verify
   end
+
+  def test_navigator_read_char
+    getc = Minitest::Mock.new
+    chr = Minitest::Mock.new
+
+    getc.expect(:call, chr)
+    chr.expect(:chr, "a")
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null"),
+      init_params: {mappings: {}}
+    }
+
+    input = nil
+    navigator = RokuBuilder::Navigator.new(**device_config)
+    STDIN.stub(:echo=, nil) do
+      STDIN.stub(:raw!, nil) do
+        STDIN.stub(:getc, getc) do
+          assert_equal "a", navigator.read_char
+        end
+      end
+    end
+    getc.verify
+    chr.verify
+  end
+
+  def test_navigator_read_char_multichar
+    getc = Minitest::Mock.new
+    chr = Minitest::Mock.new
+    read_nonblock = Minitest::Mock.new
+
+    getc.expect(:call, chr)
+    chr.expect(:chr, "\e")
+    read_nonblock.expect(:call, "a", [3])
+    read_nonblock.expect(:call, "b", [2])
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null"),
+      init_params: {mappings: {}}
+    }
+
+    input = nil
+    navigator = RokuBuilder::Navigator.new(**device_config)
+    STDIN.stub(:echo=, nil) do
+      STDIN.stub(:raw!, nil) do
+        STDIN.stub(:getc, getc) do
+          STDIN.stub(:read_nonblock, read_nonblock) do
+            assert_equal "\eab", navigator.read_char
+          end
+        end
+      end
+    end
+    getc.verify
+    chr.verify
+  end
+
+  def test_navigator_interactive
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null"),
+      init_params: {mappings: {}}
+    }
+    navigator = RokuBuilder::Navigator.new(**device_config)
+    navigator.stub(:read_char, "\u0003") do
+      navigator.interactive
+    end
+  end
+
+  def test_navigator_interactive_nav
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null"),
+      init_params: {mappings: {}}
+    }
+
+    read_char = lambda {
+      @i ||= 0
+      char = nil
+      case(@i)
+      when 0
+        char = "<"
+      when 1
+        char = "\u0003"
+      end
+      @i += 1
+      char
+    }
+
+    nav = lambda { |args|
+      assert_equal :rev, args[:commands][0]
+    }
+
+    navigator = RokuBuilder::Navigator.new(**device_config)
+    navigator.stub(:read_char, read_char) do
+      navigator.stub(:nav, nav) do
+        navigator.interactive
+      end
+    end
+  end
+  def test_navigator_interactive_text
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null"),
+      init_params: {mappings: {}}
+    }
+
+    read_char = lambda {
+      @i ||= 0
+      char = nil
+      case(@i)
+      when 0
+        char = "a"
+      when 1
+        char = "\u0003"
+      end
+      @i += 1
+      char
+    }
+
+    type = lambda { |args|
+      assert_equal "a", args[:text]
+    }
+
+    navigator = RokuBuilder::Navigator.new(**device_config)
+    navigator.stub(:read_char, read_char) do
+      navigator.stub(:type, type) do
+        navigator.interactive
+      end
+    end
+  end
 end