roku_builder 3.3.2

data/tests/roku_builder/controller_test.rb

@@ -0,0 +1,250 @@
+require_relative "test_helper.rb"
+
+class ControllerTest < Minitest::Test
+  def test_controller_validate_options
+    logger = Logger.new("/dev/null")
+    options = {
+      sideload: true,
+      package: true
+    }
+    assert_equal 1, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {}
+    assert_equal 2,  RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      sideload: true,
+      working: true,
+      current: true
+    }
+    assert_equal 3, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      sideload: true,
+      working: true
+    }
+    assert_equal 0, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      package: true
+    }
+    assert_equal 4, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      package: true,
+      current: true
+    }
+    assert_equal 5, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      deeplink: true
+    }
+    assert_equal 6, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      deeplink: true,
+      deeplink_options: ""
+    }
+    assert_equal 6, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+  end
+  def test_controller_configure
+    logger = Logger.new("/dev/null")
+    target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")
+    File.delete(target_config) if File.exists?(target_config)
+    assert !File.exists?(target_config)
+
+    options = {
+      configure: true,
+      config: target_config,
+    }
+
+    RokuBuilder::Controller.handle_options(options: options, logger: logger)
+
+    assert File.exists?(target_config)
+
+    options = {
+      configure: true,
+      config: target_config,
+      edit_params: "ip:111.222.333.444"
+    }
+
+    RokuBuilder::Controller.handle_options(options: options, logger: logger)
+
+    assert File.exists?(target_config)
+    config = RokuBuilder::ConfigManager.get_config(config: target_config, logger: logger)
+    assert_equal "111.222.333.444", config[:devices][:roku][:ip]
+    File.delete(target_config) if File.exists?(target_config)
+  end
+
+  def test_controller_validate
+    logger = Logger.new("/dev/null")
+    target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")
+    File.delete(target_config) if File.exists?(target_config)
+
+    # Test Missing Config
+    options = {validate: true, config: target_config}
+    code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::MISSING_CONFIG, code
+
+    FileUtils.cp(File.join(File.dirname(target_config), "valid_config.json"), target_config)
+
+    # Test Invalid config json
+    options = {validate: true, config: target_config}
+    RokuBuilder::ConfigManager.stub(:get_config, nil) do
+      code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+    end
+    assert_equal RokuBuilder::Controller::INVALID_CONFIG, code
+
+    # Test Invalid config
+    options = {validate: true, config: target_config}
+    RokuBuilder::ConfigManager.stub(:validate_config, [1]) do
+      code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+    end
+    assert_equal RokuBuilder::Controller::INVALID_CONFIG, code
+
+    # Test Depricated Config
+    options = {validate: true, stage: 'production', config: target_config}
+    RokuBuilder::ConfigManager.stub(:validate_config, [-1]) do
+      code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+    end
+    assert_equal RokuBuilder::Controller::DEPRICATED_CONFIG, code
+
+    # Test valid Config
+    options = {validate: true, stage: 'production', config: target_config}
+    RokuBuilder::ConfigManager.stub(:validate_config, [0]) do
+      RokuBuilder::Controller.stub(:check_devices, [0, nil]) do
+        code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+
+    # Test valid config in pwd
+    options = {validate: true, stage: 'production', config: target_config}
+    RokuBuilder::ConfigManager.stub(:validate_config, [0]) do
+      RokuBuilder::Controller.stub(:system, "/dev/null/test") do
+        RokuBuilder::Controller.stub(:check_devices, [0, nil]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+
+    File.delete(target_config) if File.exists?(target_config)
+  end
+
+  def test_controller_sideload
+    logger = Logger.new("/dev/null")
+    target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")
+    File.delete(target_config) if File.exists?(target_config)
+    FileUtils.cp(File.join(File.dirname(target_config), "valid_config.json"), target_config)
+    loader = Minitest::Mock.new
+
+    code = nil
+    options = {sideload: true, stage: 'production', config: target_config}
+    sideload_config = {
+      root_dir: "/dev/null",
+      branch: "master",
+      update_manifest: nil,
+      fetch: nil,
+      folders: ["resources", "source"],
+      files: ["manifest"]
+    }
+    # Test Success
+    loader.expect(:sideload, true, [sideload_config])
+    RokuBuilder::Loader.stub(:new, loader) do
+      RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, sideload_config: sideload_config}]) do
+        code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+
+    # Test Failure
+    loader.expect(:sideload, false, [sideload_config])
+    RokuBuilder::Loader.stub(:new, loader) do
+      RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, sideload_config: sideload_config}]) do
+        code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+      end
+    end
+    assert_equal RokuBuilder::Controller::FAILED_SIDELOAD, code
+
+    loader.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+
+  def test_controller_package
+    logger = Logger.new("/dev/null")
+    target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")
+    File.delete(target_config) if File.exists?(target_config)
+    FileUtils.cp(File.join(File.dirname(target_config), "valid_config.json"), target_config)
+    loader = Minitest::Mock.new
+    #TODO
+  end
+
+  def test_controller_build
+    logger = Logger.new("/dev/null")
+    target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")
+    File.delete(target_config) if File.exists?(target_config)
+    FileUtils.cp(File.join(File.dirname(target_config), "valid_config.json"), target_config)
+    loader = Minitest::Mock.new
+
+    code = nil
+    options = {build: true, stage: 'production', out_folder: "/tmp", config: target_config}
+    build_config = {
+      root_dir: "/dev/null",
+      branch: "master",
+      outfile: "/tmp/app_production_1.zip",
+      fetch: nil,
+      folders: ["resources", "source"],
+      files: ["manifest"]
+    }
+    loader.expect(:build, "/tmp/build", [build_config])
+    RokuBuilder::Loader.stub(:new, loader) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, manifest_config: {}, project_config: {}, build_config: build_config}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+  end
+  def test_controller_update
+    logger = Logger.new("/dev/null")
+    target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")
+    File.delete(target_config) if File.exists?(target_config)
+    FileUtils.cp(File.join(File.dirname(target_config), "valid_config.json"), target_config)
+    mock = Minitest::Mock.new
+
+    code = nil
+    options = {update: true, stage: 'production', out_folder: "/tmp", config: target_config}
+    manifest_config = {
+     root_dir: "/dev/null"
+    }
+    mock.expect(:call, "1", [manifest_config])
+    mock.expect(:call, "2", [manifest_config])
+    RokuBuilder::ManifestManager.stub(:build_version, mock) do
+      RokuBuilder::ManifestManager.stub(:update_build, mock) do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, manifest_config: manifest_config}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    mock.verify
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+  end
+
+  def test_controller_deeplink
+    logger = Logger.new("/dev/null")
+    target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")
+    File.delete(target_config) if File.exists?(target_config)
+    FileUtils.cp(File.join(File.dirname(target_config), "valid_config.json"), target_config)
+    mock = Minitest::Mock.new
+
+    code = nil
+    options = {deeplink: true, stage: 'production', deeplink_options: "a:b", config: target_config}
+    deeplink_config = {
+     root_dir: "/dev/null"
+    }
+    mock.expect(:link, "true", [deeplink_config])
+    RokuBuilder::Linker.stub(:new, mock) do
+      RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, deeplink_config: deeplink_config}]) do
+        code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+      end
+    end
+    mock.verify
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+  end
+end
+

data/tests/roku_builder/inspector_test.rb

@@ -0,0 +1,153 @@
+require_relative "test_helper.rb"
+
+class InspectorTest < Minitest::Test
+  def test_inspector_inspect
+    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 = "r1.insertCell(0).innerHTML = 'App Name: ';"+
+      "      r1.insertCell(1).innerHTML = '<div class=\"roku-color-c3\">app_name</div>';"+
+      ""+
+      "      var r2 = table.insertRow(1);"+
+      "      r2.insertCell(0).innerHTML = 'Dev ID: ';"+
+      "      r2.insertCell(1).innerHTML = '<div class=\"roku-color-c3\"><font face=\"Courier\">dev_id</font></div>';"+
+      "      "+
+      "      var dd = new Date(628232400);"+
+      "      var ddStr = \"\";"+
+      "      ddStr += (dd.getMonth()+1);"+
+      "      ddStr += \"/\";"+
+      "      ddStr += dd.getDate();"+
+      "      ddStr += \"/\";"+
+      "      ddStr += dd.getFullYear();"+
+      "      ddStr += \" \";"+
+      "      ddStr += dd.getHours();"+
+      "      ddStr += \":\";"+
+      "      ddStr += dd.getMinutes();"+
+      "      ddStr += \":\";"+
+      "      ddStr += dd.getSeconds(); "+
+      "      "+
+      "      var r3 = table.insertRow(2);"+
+      "      r3.insertCell(0).innerHTML = 'Creation Date: ';"+
+      "      r3.insertCell(1).innerHTML = '<div class=\"roku-color-c3\">'+ddStr+'</div>';"+
+      "      "+
+      "      var r4 = table.insertRow(3);"+
+      "      r4.insertCell(0).innerHTML = 'dev.zip: ';"+
+      "      r4.insertCell(1).innerHTML = '<div class=\"roku-color-c3\"><font face=\"Courier\">dev_zip</font></div>';"
+
+    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)
+    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_screencapture
+    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")
+    }
+    screencapture_config = {
+      out_folder: "out/folder/path",
+      out_file: nil
+    }
+    path = "/plugin_inspect"
+    password = "password"
+    payload ={
+      mysubmit: "Screenshot",
+      password: password,
+      archive: io
+    }
+    body = "<hr /><img src=\"pkgs/dev.jpg?time=1455629573\">"
+    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)
+
+
+    path2 = "pkgs/dev.jpg?time=1455629573"
+    body2 = "<screencapture>"
+    connection.expect(:get, response, [path2])
+    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+    faraday.expect(:adapter, nil, [Faraday.default_adapter])
+    response.expect(:body, body2)
+    response.expect(:success?, true)
+    io.expect("write", nil, [body2])
+
+
+    success = false
+    inspector = RokuBuilder::Inspector.new(**device_config)
+    Faraday.stub(:new, connection, faraday) do
+      Faraday::UploadIO.stub(:new, io) do
+        File.stub(:open, nil, io) do
+          success = inspector.screencapture(**screencapture_config)
+        end
+      end
+    end
+
+    assert success
+
+    connection.verify
+    faraday.verify
+    io.verify
+    response.verify
+  end
+end

data/tests/roku_builder/keyer_test.rb

@@ -0,0 +1,88 @@
+require_relative "test_helper.rb"
+
+class KeyerTest < Minitest::Test
+  def test_keyer_dev_id
+    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 = "v class=\"roku-font-5\"><label>Your Dev ID: &nbsp;</label> dev_id<hr></div>"
+
+    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)
+    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_rekey_changed
+    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: "Rekey",
+      password: password,
+      archive: io
+    }
+
+    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])
+
+    dev_id = Proc.new { Random.rand(100) }
+    keyer = RokuBuilder::Keyer.new(**device_config)
+    key_changed = nil
+    Faraday.stub(:new, connection, faraday) do
+      Faraday::UploadIO.stub(:new, io) do
+        keyer.stub(:dev_id, dev_id) do
+          key_changed = keyer.rekey(keyed_pkg: "pkg/path", password: password)
+        end
+      end
+    end
+
+    assert key_changed
+
+    connection.verify
+    faraday.verify
+    io.verify
+    response.verify
+  end
+end