roku_builder 3.13.0 → 4.0.0

data/test/roku_builder/test_error_handler.rb

@@ -1,90 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-require_relative "test_helper.rb"
-module RokuBuilder
-  class ErrorHandler
-    class << self
-      def abort
-        #do nothing
-      end
-    end
-  end
-
-  class ErrorHandlerTest < Minitest::Test
-    def test_handle_error_codes
-      error_groups = {
-        fatal: {
-        options_code: [
-          EXTRA_COMMANDS,
-          NO_COMMANDS,
-          EXTRA_SOURCES,
-          NO_SOURCE,
-          BAD_CURRENT,
-          BAD_IN_FILE
-      ],
-        configure_code:[
-          CONFIG_OVERWRITE,
-      ],
-      device_code: [
-        BAD_DEVICE,
-        NO_DEVICES,
-      ],
-      load_code: [
-        MISSING_CONFIG,
-        INVALID_CONFIG,
-        MISSING_MANIFEST,
-        UNKNOWN_DEVICE,
-        UNKNOWN_PROJECT,
-        UNKNOWN_STAGE,
-        BAD_PROJECT_DIR,
-        BAD_KEY_FILE
-      ],
-        command_code: [
-          FAILED_SIDELOAD,
-          FAILED_SIGNING,
-          FAILED_DEEPLINKING,
-          FAILED_NAVIGATING,
-          FAILED_SCREENCAPTURE,
-          MISSING_MANIFEST,
-          BAD_PRINT_ATTRIBUTE
-      ],
-        configs_code: [
-          MISSING_OUT_FOLDER
-      ]
-      },
-        info: {
-        device_code: [
-          CHANGED_DEVICE
-      ],
-        configure_code:[
-          SUCCESS
-      ]
-      },
-        warn: {
-        load_code: [
-          DEPRICATED_CONFIG
-      ]
-      },
-        debug: {
-        configs_code: [
-          VALID
-      ]
-      }
-      }
-      error_groups.each_pair do |type,errors|
-        errors.each_pair do |key,value|
-          value.each do |code|
-            logger = Minitest::Mock.new
-            options = {logger: logger}
-            options[:options] = {deeplink_depricated: true} if key == :load_code or key == :options_code
-            options[key] = code
-            logger.expect(type, nil)  {|string| string.class == String}
-            method = "handle_#{key}s"
-            ErrorHandler.send(method.to_sym, **options)
-            logger.verify
-          end
-        end
-      end
-    end
-  end
-end

data/test/roku_builder/test_inspector.rb

@@ -1,298 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-require_relative "test_helper.rb"
-module RokuBuilder
-  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"
-      }
-      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(: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])
-      response.expect(:body, body)
-      response.expect(:body, body)
-      response.expect(:body, body)
-      response.expect(:body, body)
-      response.expect(:body, body)
-
-
-      package_info = {}
-      inspector = 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"
-      }
-      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(: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])
-      response.expect(:body, body)
-      response.expect(:body, body)
-      response.expect(:body, body)
-      response.expect(:body, body)
-
-
-      package_info = {}
-      inspector = 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"
-      }
-      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(: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])
-      response.expect(:body, body)
-      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 = 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
-    def test_screencapture_png
-      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"
-      }
-      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.png?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(: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])
-      response.expect(:body, body)
-      response.expect(:body, body)
-      response.expect(:body, body)
-
-
-      path2 = "pkgs/dev.png?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 = 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
-end

data/test/roku_builder/test_keyer.rb

@@ -1,176 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-require_relative "test_helper.rb"
-
-module RokuBuilder
-  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"
-      }
-      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)
-
-
-      dev_id = nil
-      keyer = 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"
-      }
-      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)
-
-
-      dev_id = nil
-      keyer = 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"
-      }
-      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(: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])
-
-      # This test fails with the following seeds due to the random number
-      # generator spitting out the same number twice
-      # SEED=21894
-      # SEED=31813
-      dev_id = Proc.new {"#{Random.rand(100)}"}
-      keyer = 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
-
-    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"
-      }
-      keyer = 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"
-      }
-
-      keyer = Keyer.new(**device_config)
-
-      Loader.stub(:new, loader) do
-        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
-end