roku_builder 3.12.8 → 3.13.0

data/test/roku_builder/test_options.rb

@@ -0,0 +1,156 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+require_relative "test_helper.rb"
+
+module RokuBuilder
+  class OptionsTest < Minitest::Test
+    def test_options_validate_extra_commands
+      options = {
+        sideload: true,
+        package: true
+      }
+      assert_raises InvalidOptions do
+        build_options(options)
+      end
+    end
+    def test_options_validate_no_commands
+      options = {}
+      assert_raises InvalidOptions do
+        build_options(options)
+      end
+    end
+    def test_options_validate_extra_sources_sideload
+      options = {
+        sideload: true,
+        working: true,
+        current: true
+      }
+      assert_raises InvalidOptions do
+        build_options(options)
+      end
+    end
+    def test_options_validate_working
+      options = {
+        sideload: true,
+        working: true
+      }
+      build_options(options)
+    end
+    def test_options_validate_no_source
+      options = {
+        package: true
+      }
+      assert_raises InvalidOptions do
+        build_options(options)
+      end
+    end
+    def test_options_validate_bad_current
+      options = {
+        package: true,
+        current: true
+      }
+      assert_raises InvalidOptions do
+        build_options(options)
+      end
+    end
+    def test_options_validate_bad_in
+      options = {
+        package: true,
+        in: true
+      }
+      assert_raises InvalidOptions do
+        build_options(options)
+      end
+    end
+    def test_options_validate_depricated
+      options = {
+        deeplink: "a:b c:d",
+        deeplink_depricated: true
+      }
+      build_options(options)
+    end
+    def test_options_validate_current
+      options = {
+        sideload: true,
+        current: true
+      }
+      build_options(options)
+    end
+    def test_options_validate_extra_sources_package
+      options = {
+        package: true,
+        in: "",
+        set_stage: true
+      }
+      assert_raises InvalidOptions do
+        build_options(options)
+      end
+    end
+    def test_options_exclude_command_package
+      options = build_options({
+        package:true,
+        set_stage: true
+      })
+      assert options.exclude_command?
+    end
+    def test_options_exclude_command_build
+      options = build_options({
+        build:true,
+        set_stage: true
+      })
+      assert options.exclude_command?
+    end
+    def test_options_exclude_command_sideload
+      options = build_options({
+        sideload:true,
+        set_stage: true
+      })
+      refute options.exclude_command?
+    end
+    def test_options_source_command_sideload
+      options = build_options({
+        sideload:true,
+        working: true
+      })
+      assert options.source_command?
+    end
+    def test_options_source_command_deeplink
+      options = build_options({
+        deeplink: true,
+      })
+      refute options.source_command?
+    end
+    def test_options_command
+      options = build_options({
+        deeplink: true,
+      })
+      assert_equal :deeplink, options.command
+    end
+    def test_options_device_command_true
+      options = build_options({
+        deeplink: true,
+      })
+      assert options.device_command?
+    end
+    def test_options_device_command_false
+      options = build_options({
+        build: true,
+        working: true
+      })
+      refute options.device_command?
+    end
+    def test_options_has_source_false
+      options = build_options({
+        deeplink: true,
+      })
+      refute options.has_source?
+    end
+    def test_options_has_source_true
+      options = build_options({
+        deeplink: true,
+        working: true
+      })
+      assert options.has_source?
+    end
+  end
+end

data/test/roku_builder/test_packager.rb

@@ -2,126 +2,126 @@
 
 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)
+module RokuBuilder
+  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"
+      }
+      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
-    end
+      response.expect(:body, "Failed: Error.")
 
-    assert_equal "Failed: Error.", result
+      packager = 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
 
-    connection.verify
-    faraday.verify
-    response.verify
-  end
+      assert_equal "Failed: Error.", result
 
-  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]
+      connection.verify
+      faraday.verify
+      response.verify
     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>")
+    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"
+      }
+      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(:status, 200)
-    response.expect(:body, "package_body")
+      response.expect(:body, "<a href=\"pkgs\">pkg_url</a>")
+      response.expect(:body, "<a href=\"pkgs\">pkg_url</a>")
 
-    io.expect(:write, nil, ["package_body"])
+      response.expect(:status, 200)
+      response.expect(:body, "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)
+      io.expect(:write, nil, ["package_body"])
+
+      packager = 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
-    end
 
-    assert_equal true, result
+      assert_equal true, result
 
-    connection.verify
-    faraday.verify
-    response.verify
-    io.verify
+      connection.verify
+      faraday.verify
+      response.verify
+      io.verify
+    end
   end
 end

data/test/roku_builder/test_profiler.rb

@@ -2,33 +2,34 @@
 
 require_relative "test_helper.rb"
 
-class ProfilerTest < Minitest::Test
-  def test_profiler_stats
-    waitfor = Proc.new do |config, &blk|
+module RokuBuilder
+  class ProfilerTest < Minitest::Test
+    def test_profiler_stats
+      waitfor = Proc.new do |config, &blk|
       assert_equal(/.+/, config["Match"])
       assert_equal(5, config["Timeout"])
       txt = "<All_Nodes><NodeA /><NodeB /><NodeC><NodeD /></NodeC></All_Nodes>\n"
       blk.call(txt)
       true
-    end
-    connection = Minitest::Mock.new
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    profiler = RokuBuilder::Profiler.new(**device_config)
+      end
+      connection = Minitest::Mock.new
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      profiler = Profiler.new(**device_config)
 
-    connection.expect(:puts, nil, ["sgnodes all\n"])
-    connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:puts, nil, ["sgnodes all\n"])
+      connection.expect(:waitfor, nil, &waitfor)
 
-    Net::Telnet.stub(:new, connection) do
-      profiler.stub(:printf, nil) do
-        profiler.run(command: :stats)
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:printf, nil) do
+          profiler.run(command: :stats)
+        end
       end
-    end
 
-    connection.verify
+      connection.verify
+    end
   end
 end

data/test/roku_builder/test_scripter.rb

@@ -2,99 +2,101 @@
 
 require_relative "test_helper.rb"
 
-class Scriptertest < Minitest::Test
+module RokuBuilder
+  class Scriptertest < Minitest::Test
 
-  def test_scripter_print_bad_attr
-    code = RokuBuilder::Scripter.print(attribute: :bad, configs: {})
-    assert_equal RokuBuilder::BAD_PRINT_ATTRIBUTE, code
-  end
+    def test_scripter_print_bad_attr
+      code = Scripter.print(attribute: :bad, configs: {})
+      assert_equal BAD_PRINT_ATTRIBUTE, code
+    end
 
-  def test_scripter_print_config_root_dir
-    call_count = 0
-    code = nil
-    fake_print = lambda { |message, path|
-      assert_equal "%s", message
-      assert_equal "/dev/null", path
-      call_count+=1
-    }
-    configs = {project_config: {directory: "/dev/null"}}
-    RokuBuilder::Scripter.stub(:printf, fake_print) do
-      code = RokuBuilder::Scripter.print(attribute: :root_dir, configs: configs)
+    def test_scripter_print_config_root_dir
+      call_count = 0
+      code = nil
+      fake_print = lambda { |message, path|
+        assert_equal "%s", message
+        assert_equal "/dev/null", path
+        call_count+=1
+      }
+      configs = {project_config: {directory: "/dev/null"}}
+      Scripter.stub(:printf, fake_print) do
+        code = Scripter.print(attribute: :root_dir, configs: configs)
+      end
+      assert_equal 1, call_count
+      assert_equal SUCCESS, code
     end
-    assert_equal 1, call_count
-    assert_equal RokuBuilder::SUCCESS, code
-  end
-  def test_scripter_print_config_app_name
-    call_count = 0
-    code = nil
-    fake_print = lambda { |message, path|
-      assert_equal "%s", message
-      assert_equal "TestApp", path
-      call_count+=1
-    }
-    configs = {project_config: {app_name: "TestApp"}}
-    RokuBuilder::Scripter.stub(:printf, fake_print) do
-      code = RokuBuilder::Scripter.print(attribute: :app_name, configs: configs)
+    def test_scripter_print_config_app_name
+      call_count = 0
+      code = nil
+      fake_print = lambda { |message, path|
+        assert_equal "%s", message
+        assert_equal "TestApp", path
+        call_count+=1
+      }
+      configs = {project_config: {app_name: "TestApp"}}
+      Scripter.stub(:printf, fake_print) do
+        code = Scripter.print(attribute: :app_name, configs: configs)
+      end
+      assert_equal 1, call_count
+      assert_equal SUCCESS, code
     end
-    assert_equal 1, call_count
-    assert_equal RokuBuilder::SUCCESS, code
-  end
 
-  def test_scripter_print_manifest_title
-    call_count = 0
-    code = nil
-    fake_print = lambda { |message, title|
-      assert_equal "%s", message
-      assert_equal "title", title
-      call_count+=1
-    }
-    manifest = {title: "title"}
-    configs = {project_config: {directory: "/dev/null"}}
-    RokuBuilder::Scripter.stub(:printf, fake_print) do
-      RokuBuilder::ManifestManager.stub(:read_manifest, manifest) do
-        code = RokuBuilder::Scripter.print(attribute: :title, configs: configs)
+    def test_scripter_print_manifest_title
+      call_count = 0
+      code = nil
+      fake_print = lambda { |message, title|
+        assert_equal "%s", message
+        assert_equal "title", title
+        call_count+=1
+      }
+      manifest = {title: "title"}
+      configs = {project_config: {directory: "/dev/null"}}
+      Scripter.stub(:printf, fake_print) do
+        ManifestManager.stub(:read_manifest, manifest) do
+          code = Scripter.print(attribute: :title, configs: configs)
+        end
       end
+      assert_equal 1, call_count
+      assert_equal SUCCESS, code
     end
-    assert_equal 1, call_count
-    assert_equal RokuBuilder::SUCCESS, code
-  end
 
-  def test_scripter_print_manifest_build_version
-    call_count = 0
-    code = nil
-    fake_print = lambda { |message, build|
-      assert_equal "%s", message
-      assert_equal "010101.0001", build
-      call_count+=1
-    }
-    manifest = {build_version: "010101.0001"}
-    configs = {project_config: {directory: "/dev/null"}}
-    RokuBuilder::Scripter.stub(:printf, fake_print) do
-      RokuBuilder::ManifestManager.stub(:read_manifest, manifest) do
-        code = RokuBuilder::Scripter.print(attribute: :build_version, configs: configs)
+    def test_scripter_print_manifest_build_version
+      call_count = 0
+      code = nil
+      fake_print = lambda { |message, build|
+        assert_equal "%s", message
+        assert_equal "010101.0001", build
+        call_count+=1
+      }
+      manifest = {build_version: "010101.0001"}
+      configs = {project_config: {directory: "/dev/null"}}
+      Scripter.stub(:printf, fake_print) do
+        ManifestManager.stub(:read_manifest, manifest) do
+          code = Scripter.print(attribute: :build_version, configs: configs)
+        end
       end
+      assert_equal 1, call_count
+      assert_equal SUCCESS, code
     end
-    assert_equal 1, call_count
-    assert_equal RokuBuilder::SUCCESS, code
-  end
 
-  def test_scripter_print_manifest_app_version
-    call_count = 0
-    code = nil
-    fake_print = lambda { |message, major, minor|
-      assert_equal "%s.%s", message
-      assert_equal "1", major
-      assert_equal "0", minor
-      call_count+=1
-    }
-    manifest = {major_version: "1", minor_version: "0"}
-    configs = {project_config: {directory: "/dev/null"}}
-    RokuBuilder::Scripter.stub(:printf, fake_print) do
-      RokuBuilder::ManifestManager.stub(:read_manifest, manifest) do
-        code = RokuBuilder::Scripter.print(attribute: :app_version, configs: configs)
+    def test_scripter_print_manifest_app_version
+      call_count = 0
+      code = nil
+      fake_print = lambda { |message, major, minor|
+        assert_equal "%s.%s", message
+        assert_equal "1", major
+        assert_equal "0", minor
+        call_count+=1
+      }
+      manifest = {major_version: "1", minor_version: "0"}
+      configs = {project_config: {directory: "/dev/null"}}
+      Scripter.stub(:printf, fake_print) do
+        ManifestManager.stub(:read_manifest, manifest) do
+          code = Scripter.print(attribute: :app_version, configs: configs)
+        end
       end
+      assert_equal 1, call_count
+      assert_equal SUCCESS, code
     end
-    assert_equal 1, call_count
-    assert_equal RokuBuilder::SUCCESS, code
   end
 end