roku_builder 3.3.2 → 3.3.3

data/tests/roku_builder/inspector_test.rb

@@ -66,6 +66,81 @@ class InspectorTest < Minitest::Test
     response.expect(:body, body)
 
 
+    package_info = {}
+    inspector = RokuBuilder::Inspector.new(**device_config)
+    Faraday.stub(:new, connection, faraday) do
+      Faraday::UploadIO.stub(:new, io) do
+        package_info = inspector.inspect(pkg: "pkg/path", password: password)
+      end
+    end
+
+    assert_equal "app_name", package_info[:app_name]
+    assert_equal "dev_id", package_info[:dev_id]
+    assert_equal Time.at(628232400).to_s, package_info[:creation_date]
+    assert_equal "dev_zip", package_info[:dev_zip]
+
+    connection.verify
+    faraday.verify
+    io.verify
+    response.verify
+  end
+  def test_inspector_inspect_old_interface
+    connection = Minitest::Mock.new
+    faraday = Minitest::Mock.new
+    io = Minitest::Mock.new
+    response = Minitest::Mock.new
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    path = "/plugin_inspect"
+    password = "password"
+    payload ={
+      mysubmit: "Inspect",
+      password: password,
+      archive: io
+    }
+    body = " <table cellpadding=\"2\">"+
+      " <tbody><tr><td> App Name: </td><td> <font color=\"blue\">app_name</font> </td></tr>"+
+      " <tr><td> Dev ID: </td><td> <font face=\"Courier\" color=\"blue\">dev_id</font> </td></tr>"+
+      " <tr><td> Creation Date: </td><td> <font color=\"blue\">"+
+      " <script type=\"text/javascript\">"+
+      " var d = new Date(628232400)"+
+      " document.write(d.getMonth()+1)"+
+      " document.write(\"/\")"+
+      " document.write(d.getDate())"+
+      " document.write(\"/\");"+
+      " document.write(d.getFullYear())"+
+      " document.write(\" \")"+
+      " document.write(d.getHours())"+
+      " document.write(\":\")"+
+      " document.write(d.getMinutes())"+
+      " document.write(\":\")"+
+      " document.write(d.getSeconds())"+
+      " </script>1/17/1970 16:42:28"+
+      " </font> </td></tr>"+
+      " <tr><td> dev.zip: </td><td> <font face=\"Courier\" color=\"blue\">dev_zip</font> </td></tr>"+
+      " </tbody></table>"
+
+    connection.expect(:post, response) do |arg1, arg2|
+      assert_equal path, arg1
+      assert_equal payload[:mysubmit], arg2[:mysubmit]
+      assert_equal payload[:password], arg2[:passwd]
+      assert payload[:archive] === arg2[:archive]
+    end
+    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+    faraday.expect(:request, nil, [:multipart])
+    faraday.expect(:request, nil, [:url_encoded])
+    faraday.expect(:adapter, nil, [Faraday.default_adapter])
+    response.expect(:body, body)
+    response.expect(:body, body)
+    response.expect(:body, body)
+    response.expect(:body, body)
+
+
     package_info = {}
     inspector = RokuBuilder::Inspector.new(**device_config)
     Faraday.stub(:new, connection, faraday) do

data/tests/roku_builder/keyer_test.rb

@@ -22,6 +22,39 @@ class KeyerTest < Minitest::Test
     response.expect(:body, body)
 
 
+    package_info = {}
+    dev_id = nil
+    keyer = RokuBuilder::Keyer.new(**device_config)
+    Faraday.stub(:new, connection, faraday) do
+      dev_id = keyer.dev_id
+    end
+
+    assert_equal "dev_id", dev_id
+
+    connection.verify
+    faraday.verify
+    response.verify
+  end
+  def test_keyer_dev_id_old_interface
+    connection = Minitest::Mock.new
+    faraday = Minitest::Mock.new
+    response = Minitest::Mock.new
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    path = "/plugin_package"
+    body = "<p> Your Dev ID: <font face=\"Courier\">dev_id</font> </p>"
+
+    connection.expect(:get, response, [path])
+    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+    faraday.expect(:adapter, nil, [Faraday.default_adapter])
+    response.expect(:body, body)
+
+
     package_info = {}
     dev_id = nil
     keyer = RokuBuilder::Keyer.new(**device_config)

data/tests/roku_builder/linker_test.rb

@@ -34,4 +34,19 @@ class LinkerTest < Minitest::Test
     faraday.verify
     response.verify
   end
+  def test_linker_link_nothing
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    options = ''
+    linker = RokuBuilder::Linker.new(**device_config)
+    success = nil
+    success = linker.link(options: options)
+
+    assert !success
+
+  end
 end

data/tests/roku_builder/loader_test.rb

@@ -58,6 +58,64 @@ class LoaderTest < Minitest::Test
     io.verify
     response.verify
   end
+  def test_loader_sideload_update
+    connection = Minitest::Mock.new
+    faraday = Minitest::Mock.new
+    io = Minitest::Mock.new
+    response = Minitest::Mock.new
+
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    loader_config = {
+      root_dir: root_dir,
+      update_manifest: true,
+      folders: ["source"],
+      files: ["manifest"]
+    }
+    payload = {
+      mysubmit: "Replace",
+      archive: io,
+    }
+    path = "/plugin_install"
+
+    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+    faraday.expect(:request, nil, [:multipart])
+    faraday.expect(:request, nil, [:url_encoded])
+    faraday.expect(:adapter, nil, [Faraday.default_adapter])
+    connection.expect(:post, response) do |arg1, arg2|
+      assert_equal path, arg1
+      assert_equal payload[:mysubmit], arg2[:mysubmit]
+      assert payload[:archive] === arg2[:archive]
+    end
+    response.expect(:status, 200)
+    response.expect(:body, "Install Success")
+
+    loader = RokuBuilder::Loader.new(**device_config)
+    result = nil
+    RokuBuilder::ManifestManager.stub(:update_build, "build_version") do
+      loader.stub(:build, "zip_file") do
+        Faraday.stub(:new, connection, faraday) do
+          Faraday::UploadIO.stub(:new, io) do
+            File.stub(:delete, nil) do
+              result = loader.sideload(**loader_config)
+            end
+          end
+        end
+      end
+    end
+
+    assert_equal "build_version", result
+
+    connection.verify
+    faraday.verify
+    io.verify
+    response.verify
+  end
 
   def test_loader_build_defining_folder_and_files
     root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
@@ -79,9 +137,9 @@ class LoaderTest < Minitest::Test
     end
     Zip::File.open(outfile) do |file|
       assert file.find_entry("manifest") != nil
-      assert file.find_entry("source/a") != nil
+      assert_nil file.find_entry("a")
       assert file.find_entry("source/b") != nil
-      assert_nil file.find_entry("c")
+      assert file.find_entry("source/c/d") != nil
     end
   end
   def test_loader_build_all_contents
@@ -102,9 +160,9 @@ class LoaderTest < Minitest::Test
     end
     Zip::File.open(outfile) do |file|
       assert file.find_entry("manifest") != nil
-      assert file.find_entry("source/a") != nil
+      assert file.find_entry("a") != nil
       assert file.find_entry("source/b") != nil
-      assert file.find_entry("c") != nil
+      assert file.find_entry("source/c/d") != nil
     end
   end
 
@@ -144,7 +202,49 @@ class LoaderTest < Minitest::Test
       result = loader.unload
     end
 
-    assert_equal true, result
+    assert result
+
+    connection.verify
+    faraday.verify
+    response.verify
+  end
+  def test_loader_unload_fail
+    connection = Minitest::Mock.new
+    faraday = Minitest::Mock.new
+    response = Minitest::Mock.new
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    payload = {
+      mysubmit: "Delete",
+      archive: "",
+    }
+    path = "/plugin_install"
+
+    faraday.expect(:headers, {})
+    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+    faraday.expect(:request, nil, [:multipart])
+    faraday.expect(:request, nil, [:url_encoded])
+    faraday.expect(:adapter, nil, [Faraday.default_adapter])
+    connection.expect(:post, response) do |arg1, arg2|
+      assert_equal path, arg1
+      assert_equal payload[:mysubmit], arg2[:mysubmit]
+      assert payload[:archive] === arg2[:archive]
+    end
+    response.expect(:status, 200)
+    response.expect(:body, "Install Filed")
+
+    loader = RokuBuilder::Loader.new(**device_config)
+    result = nil
+    Faraday.stub(:new, connection, faraday) do
+      result = loader.unload
+    end
+
+    assert !result
 
     connection.verify
     faraday.verify

data/tests/roku_builder/manifest_manager_test.rb

@@ -13,6 +13,18 @@ class ManifestManagerTest < Minitest::Test
     FileUtils.rm(File.join(root_dir, "manifest"))
   end
 
+  def test_manifest_manager_update_missing_build_number
+    logger = Logger.new('/dev/null')
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "manifest_manager_test")
+    FileUtils.cp(File.join(root_dir, "manifest_template_2"), File.join(root_dir, "manifest"))
+    build_version = nil
+    Time.stub(:now, Time.new(2001, 02, 01)) do
+      build_version = RokuBuilder::ManifestManager.update_build(root_dir: root_dir, logger: logger)
+    end
+    assert_equal "020101.1", build_version
+    FileUtils.rm(File.join(root_dir, "manifest"))
+  end
+
   def test_manifest_manager_build_version
     logger = Logger.new('/dev/null')
     root_dir = File.join(File.dirname(__FILE__), "test_files", "manifest_manager_test")

data/tests/roku_builder/monitor_test.rb

@@ -31,4 +31,73 @@ class MonitorTest < Minitest::Test
 
     connection.verify
   end
+
+  def test_monitor_monit_input
+    connection = Minitest::Mock.new
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    monitor_config = {
+      'Host' => device_config[:ip],
+      'Post' => 8085
+    }
+    monitor = RokuBuilder::Monitor.new(**device_config)
+
+    connection.expect(:waitfor, nil) do |config|
+      assert_equal /./, config['Match']
+      assert_equal false, config['Timeout']
+    end
+    connection.expect(:puts, nil, ["text"])
+
+    def monitor.gets
+      @count = 0 unless @count
+      sleep(0.1)
+      case @count
+      when 0
+        @count += 1
+        "text"
+      else
+        "q"
+      end
+    end
+
+    Net::Telnet.stub(:new, connection) do
+      monitor.monitor(type: :main)
+    end
+
+    connection.verify
+  end
+
+  def test_monitor_manage_text
+    mock = Minitest::Mock.new
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    monitor = RokuBuilder::Monitor.new(**device_config)
+    monitor.instance_variable_set(:@mock, mock)
+
+    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> "
+
+    result = monitor.send(:manage_text, {all_text: all_text, txt: txt})
+
+    assert_equal "", result
+
+  end
 end

data/tests/roku_builder/navigator_test.rb

@@ -21,12 +21,17 @@ class NavigatorTest < Minitest::Test
     }
   end
 
+  def test_navigator_nav_fail
+    path = ""
+    navigator_test(path: path, input: :bad, type: :nav, success: false)
+  end
+
   def test_navigator_type
     path = "keypress/LIT_"
     navigator_test(path: path, input: "Type", type: :text)
   end
 
-  def navigator_test(path:, input:, type:)
+  def navigator_test(path:, input:, type:, success: true)
     connection = Minitest::Mock.new
     faraday = Minitest::Mock.new
     io = Minitest::Mock.new
@@ -38,35 +43,90 @@ class NavigatorTest < Minitest::Test
       password: "password",
       logger: Logger.new("/dev/null")
     }
-    if type == :nav
-      connection.expect(:post, response, [path])
-      response.expect(:success?, true)
-    elsif type == :text
-      input.split(//).each do |c|
-        path = "/keypress/LIT_#{CGI::escape(c)}"
+    if success
+      if type == :nav
         connection.expect(:post, response, [path])
         response.expect(:success?, true)
+      elsif type == :text
+        input.split(//).each do |c|
+          path = "/keypress/LIT_#{CGI::escape(c)}"
+          connection.expect(:post, response, [path])
+          response.expect(:success?, true)
+        end
       end
-    end
-    faraday.expect(:request, nil, [:multipart])
-    faraday.expect(:request, nil, [:url_encoded])
-    faraday.expect(:adapter, nil, [Faraday.default_adapter])
+      faraday.expect(:request, nil, [:multipart])
+      faraday.expect(:request, nil, [:url_encoded])
+      faraday.expect(:adapter, nil, [Faraday.default_adapter])
+    end if
 
     navigator = RokuBuilder::Navigator.new(**device_config)
-    success = nil
+    result = nil
     Faraday.stub(:new, connection, faraday) do
       if type == :nav
-        success = navigator.nav(command: input)
+        result = navigator.nav(command: input)
       elsif type == :text
-        success = navigator.type(text: input)
+         result = navigator.type(text: input)
       end
     end
 
-    assert success
+    assert_equal success, result
 
     connection.verify
     faraday.verify
     io.verify
     response.verify
   end
+
+  def test_navigator_screen
+    logger = Minitest::Mock.new
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: logger
+    }
+    navigator = RokuBuilder::Navigator.new(**device_config)
+
+    logger.expect(:unknown, nil, ["Home x 5, Fwd x 3, Rev x 2,"])
+    logger.expect(:unknown, nil, ["Home x 5, Up, Rev x 2, Fwd x 2,"])
+
+    navigator.screen(type: :secret)
+    navigator.screen(type: :reboot)
+
+    logger.verify
+  end
+
+  def test_navigator_screen_fail
+    logger = Minitest::Mock.new
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: logger
+    }
+    navigator = RokuBuilder::Navigator.new(**device_config)
+
+    assert !navigator.screen(type: :bad)
+
+    logger.verify
+  end
+
+  def test_navigator_screens
+    logger = Minitest::Mock.new
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: logger
+    }
+    navigator = RokuBuilder::Navigator.new(**device_config)
+
+    navigator.instance_variable_get("@screens").each_key do |key|
+      logger.expect(:unknown, nil, [key])
+    end
+
+    navigator.screens
+
+    logger.verify
+  end
 end