roku_builder 3.3.2

data/tests/roku_builder/linker_test.rb

@@ -0,0 +1,37 @@
+require_relative "test_helper.rb"
+
+class LinkerTest < Minitest::Test
+  def test_linker_link
+    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 = "/launch/dev?a=A&b=B:C&d=a%5Cb"
+    options = 'a:A, b:B:C, d:a\b'
+
+    connection.expect(:post, response, [path])
+    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(:success?, true)
+
+    linker = RokuBuilder::Linker.new(**device_config)
+    success = nil
+    Faraday.stub(:new, connection, faraday) do
+      success = linker.link(options: options)
+    end
+
+    assert success
+
+    connection.verify
+    faraday.verify
+    response.verify
+  end
+end

data/tests/roku_builder/loader_test.rb

@@ -0,0 +1,153 @@
+require_relative "test_helper.rb"
+
+class LoaderTest < Minitest::Test
+  def test_loader_sideload
+    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,
+      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(:build_version, "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")
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    build_config = {
+      root_dir: root_dir,
+      folders: ["source"],
+      files: ["manifest"]
+    }
+    loader = RokuBuilder::Loader.new(**device_config)
+    outfile = nil
+    RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
+      outfile = loader.build(**build_config)
+    end
+    Zip::File.open(outfile) do |file|
+      assert file.find_entry("manifest") != nil
+      assert file.find_entry("source/a") != nil
+      assert file.find_entry("source/b") != nil
+      assert_nil file.find_entry("c")
+    end
+  end
+  def test_loader_build_all_contents
+    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")
+    }
+    build_config = {
+      root_dir: root_dir,
+    }
+    loader = RokuBuilder::Loader.new(**device_config)
+    outfile = nil
+    RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
+      outfile = loader.build(**build_config)
+    end
+    Zip::File.open(outfile) do |file|
+      assert file.find_entry("manifest") != nil
+      assert file.find_entry("source/a") != nil
+      assert file.find_entry("source/b") != nil
+      assert file.find_entry("c") != nil
+    end
+  end
+
+  def test_loader_unload
+    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 Success")
+
+    loader = RokuBuilder::Loader.new(**device_config)
+    result = nil
+    Faraday.stub(:new, connection, faraday) do
+      result = loader.unload
+    end
+
+    assert_equal true, result
+
+    connection.verify
+    faraday.verify
+    response.verify
+  end
+end

data/tests/roku_builder/manifest_manager_test.rb

@@ -0,0 +1,25 @@
+require_relative "test_helper.rb"
+
+class ManifestManagerTest < Minitest::Test
+  def test_manifest_manager_update
+    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"), 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.2", 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")
+    FileUtils.cp(File.join(root_dir, "manifest_template"), File.join(root_dir, "manifest"))
+    build_version = nil
+    build_version = RokuBuilder::ManifestManager.build_version(root_dir: root_dir, logger: logger)
+    assert_equal "010101.1", build_version
+    FileUtils.rm(File.join(root_dir, "manifest"))
+  end
+end

data/tests/roku_builder/monitor_test.rb

@@ -0,0 +1,34 @@
+require_relative "test_helper.rb"
+
+class MonitorTest < Minitest::Test
+  def test_monitor_monit
+    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
+
+    def monitor.gets
+      sleep(0.1)
+      "q"
+    end
+
+    Net::Telnet.stub(:new, connection) do
+      monitor.monitor(type: :main)
+    end
+
+    connection.verify
+  end
+end

data/tests/roku_builder/navigator_test.rb

@@ -0,0 +1,72 @@
+require_relative "test_helper.rb"
+
+class NavigatorTest < Minitest::Test
+  def test_navigator_nav
+    commands = {
+      up: "Up",
+      down: "Down",
+      right: "Right",
+      left: "Left",
+      select: "Select",
+      back: "Back",
+      home: "Home",
+      rew: "Rev",
+      ff: "Fwd",
+      play: "Play",
+      replay: "InstantReplay"
+    }
+    commands.each {|k,v|
+      path = "/keypress/#{v}"
+      navigator_test(path: path, input: k, type: :nav)
+    }
+  end
+
+  def test_navigator_type
+    path = "keypress/LIT_"
+    navigator_test(path: path, input: "Type", type: :text)
+  end
+
+  def navigator_test(path:, input:, type:)
+    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")
+    }
+    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
+    faraday.expect(:request, nil, [:multipart])
+    faraday.expect(:request, nil, [:url_encoded])
+    faraday.expect(:adapter, nil, [Faraday.default_adapter])
+
+    navigator = RokuBuilder::Navigator.new(**device_config)
+    success = nil
+    Faraday.stub(:new, connection, faraday) do
+      if type == :nav
+        success = navigator.nav(command: input)
+      elsif type == :text
+        success = navigator.type(text: input)
+      end
+    end
+
+    assert success
+
+    connection.verify
+    faraday.verify
+    io.verify
+    response.verify
+  end
+end

data/tests/roku_builder/packager_test.rb

@@ -0,0 +1,125 @@
+require_relative "test_helper.rb"
+
+class PackagerTest < Minitest::Test
+  def test_packager_package_failed
+    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: "Package",
+      app_name: "app_name",
+      passwd: "password",
+      pkg_time: 0
+    }
+    package_config ={
+      app_name_version: "app_name",
+      out_file: "out_file",
+      password: "password"
+    }
+    path = "/plugin_package"
+
+    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_equal payload[:app_name], arg2[:app_name]
+      assert_equal payload[:passwd], arg2[:passwd]
+      assert_equal payload[:pkg_time], arg2[:pkg_time]
+    end
+    response.expect(:body, "Failed: Error.")
+
+    packager = RokuBuilder::Packager.new(**device_config)
+    result = nil
+    Faraday.stub(:new, connection, faraday) do
+      Time.stub(:now, Time.at(0)) do
+        result = packager.package(**package_config)
+      end
+    end
+
+    assert_equal "Failed: Error.", result
+
+    connection.verify
+    faraday.verify
+    response.verify
+  end
+
+  def test_packager_package
+    connection = Minitest::Mock.new
+    faraday = Minitest::Mock.new
+    response = Minitest::Mock.new
+    io = Minitest::Mock.new
+
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    payload = {
+      mysubmit: "Package",
+      app_name: "app_name",
+      passwd: "password",
+      pkg_time: 0
+    }
+    package_config ={
+      app_name_version: "app_name",
+      out_file: "out_file",
+      password: "password"
+    }
+    path = "/plugin_package"
+
+    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])
+
+    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+    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_equal payload[:app_name], arg2[:app_name]
+      assert_equal payload[:passwd], arg2[:passwd]
+      assert_equal payload[:pkg_time], arg2[:pkg_time]
+    end
+    connection.expect(:get, response, ["/pkgs/pkg_url"])
+
+    response.expect(:body, "<a href=\"pkgs\">pkg_url</a>")
+    response.expect(:body, "<a href=\"pkgs\">pkg_url</a>")
+
+    response.expect(:status, 200)
+    response.expect(:body, "package_body")
+
+    io.expect(:write, nil, ["package_body"])
+
+    packager = RokuBuilder::Packager.new(**device_config)
+    result = nil
+    Faraday.stub(:new, connection, faraday) do
+      Time.stub(:now, Time.at(0)) do
+        File.stub(:open, nil, io) do
+          result = packager.package(**package_config)
+        end
+      end
+    end
+
+    assert_equal true, result
+
+    connection.verify
+    faraday.verify
+    response.verify
+    io.verify
+  end
+end