roku_builder 3.6.0 → 3.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 878733ac2055fcbfa7fb162abf1f36a3d8e200c7
-  data.tar.gz: ee4a6a97eb48e0befd1e9dd5ec8e542396411f9b
+  metadata.gz: 5fd419ef8714c1ee725684939cff69165e1daac9
+  data.tar.gz: 6fc59c0b8453ee8ea26f765b493892044faacf68
 SHA512:
-  metadata.gz: bb15a8cdf99cdf04716c9ca95c8b531a492f1eff3632f7a663d0e061f34dcc5e5951b10d182bca3fe0cec130201010f0dc32f7a8fbbbb13890666ba9c3918fbb
-  data.tar.gz: 5894aeed3e103c46480cce8061b3b2fbd1a469c3f2391d6e72420a6d4f8531485d4ef15692b158959a30fd3529ecf8479129e558d4a0f03700e09ae26feb0d17
+  metadata.gz: 601f919047c348e2511456e37c5a5810df71f273fbc9005671cd1af815e251546ff4939334473e7a1010c84e2d23fce68ad4f0c7c5936584d15a95816e37772a
+  data.tar.gz: a015de3a94792cfa7d8051f305834cb3c99f1139f2be004ce519cdd6213e870cf51525233a99005cca4a1edf8026fb8bcb712cb1f47bb827a75ccb5d7c40eaff

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.6.0)
+    roku_builder (3.6.1)
       faraday (~> 0.9)
       faraday-digestauth (~> 0.2)
       git (~> 1.3)

data/bin/roku

@@ -133,6 +133,10 @@ OptionParser.new do |opts|
     options[:in] = i
   end
 
+  opts.on("-x", "--exclude", "Apply exclude config to sideload") do
+    options[:exclude] = true
+  end
+
   opts.on("-V", "--verbose", "Print Info message") do
     options[:verbose] = true
   end

data/lib/roku_builder/config_parser.rb

@@ -145,7 +145,7 @@ module RokuBuilder
         files: configs[:project_config][:files],
       }
       all_commands = options.keys & Controller.commands
-      if Controller.exclude_commands.include?(all_commands.first)
+      if options[:exclude] or Controller.exclude_commands.include?(all_commands.first)
         content[:excludes] = configs[:project_config][:excludes]
       end
 

data/lib/roku_builder/controller.rb

@@ -122,8 +122,6 @@ module RokuBuilder
           case key
           when :options
             args[:options] = options
-          when :config
-            args[:config] = config
           when :configs
             args[:configs] = configs
           when :logger

data/lib/roku_builder/version.rb

@@ -1,4 +1,4 @@
 module RokuBuilder
   # Version of the RokuBuilder Gem
-  VERSION = "3.6.0"
+  VERSION = "3.6.1"
 end

data/tests/roku_builder/config_manager_test.rb

@@ -49,6 +49,20 @@ class ConfigManagerTest < Minitest::Test
     assert_nil config
     assert_nil configs
 
+    # Test Unknown Device
+    options = {validate: true, device: :bad, config: target_config}
+    code, config, configs = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+    assert_equal RokuBuilder::UNKNOWN_DEVICE, code
+    assert_nil config
+    assert_nil configs
+
+    # Test Unknown Project
+    options = {validate: true, project: :bad, config: target_config}
+    code, config, configs = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+    assert_equal RokuBuilder::UNKNOWN_PROJECT, code
+    assert_nil config
+    assert_nil configs
+
     # Test Depricated Config
     options = {validate: true, stage: 'production', config: target_config}
     RokuBuilder::ConfigValidator.stub(:validate_config, [-1]) do
@@ -78,6 +92,8 @@ class ConfigManagerTest < Minitest::Test
     assert_equal Hash, config.class
     assert_equal Hash, configs.class
 
+
+
     File.delete(target_config) if File.exist?(target_config)
   end
 

data/tests/roku_builder/config_parser_test.rb

@@ -17,6 +17,41 @@ class ConfigParserTest < Minitest::Test
     assert_equal "/dev/null", configs[:manifest_config][:root_dir]
   end
 
+  def test_setup_project_config_current
+    args = {
+      config: {},
+      options: {current: true }
+    }
+    project = {}
+    File.stub(:exist?, true) do
+      project = RokuBuilder::ConfigParser.send(:setup_project_config, **args)
+    end
+    assert_equal Pathname.pwd.to_s, project[:directory]
+    assert_equal :current, project[:stage_method]
+    assert_nil project[:folders]
+    assert_nil project[:files]
+  end
+
+  def test_setup_stage_config_script
+    args = {
+      configs: {project_config: {directory: "/tmp", stage_method: :script, stages: {production: {script: "script"}}}},
+      options: {stage: "production"},
+      logger: Logger.new("/dev/null")
+    }
+    config, stage = RokuBuilder::ConfigParser.send(:setup_stage_config, **args)
+    assert_equal args[:configs][:project_config][:stages][:production][:script], config[:key]
+  end
+
+  def test_setup_stage_config_git_ref
+    args = {
+      configs: {project_config: {directory: "/tmp", stage_method: :git, }},
+      options: {stage: "production", ref: "git-ref"},
+      logger: Logger.new("/dev/null")
+    }
+    config, stage = RokuBuilder::ConfigParser.send(:setup_stage_config, **args)
+    assert_equal args[:options][:ref], config[:key]
+  end
+
   def test_manifest_config_project_select
     logger = Logger.new("/dev/null")
     options = {
@@ -38,4 +73,52 @@ class ConfigParserTest < Minitest::Test
     assert_equal Hash, config.class
     assert_equal "/dev/nuller", configs[:project_config][:directory]
   end
+
+  def test_setup_sideload_config
+    args = {
+      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
+      options: {sideload: true}
+    }
+    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
+
+    refute_nil args[:configs][:sideload_config]
+    refute_nil args[:configs][:sideload_config][:content]
+    refute_nil args[:configs][:build_config]
+    refute_nil args[:configs][:build_config][:content]
+    refute_nil args[:configs][:init_params][:loader]
+    refute_nil args[:configs][:init_params][:loader][:root_dir]
+
+    assert_nil args[:configs][:sideload_config][:content][:excludes]
+    assert_nil args[:configs][:sideload_config][:update_manifest]
+    assert_nil args[:configs][:sideload_config][:infile]
+  end
+  def test_setup_sideload_config_exclude
+    args = {
+      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
+      options: {sideload: true}
+    }
+    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
+    assert_nil args[:configs][:sideload_config][:content][:excludes]
+
+    args = {
+      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
+      options: {build: true}
+    }
+    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
+    refute_nil args[:configs][:sideload_config][:content][:excludes]
+
+    args = {
+      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
+      options: {package: true}
+    }
+    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
+    refute_nil args[:configs][:sideload_config][:content][:excludes]
+
+    args = {
+      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
+      options: {sideload: true, exclude: true}
+    }
+    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
+    refute_nil args[:configs][:sideload_config][:content][:excludes]
+  end
 end

data/tests/roku_builder/controller_commands_test.rb

@@ -2,6 +2,13 @@ require_relative "test_helper.rb"
 
 class ControllerCommandsTest < Minitest::Test
 
+  def test_controller_commands_validate
+    logger = Minitest::Mock.new
+    logger.expect(:info, nil, ["Config validated"])
+    code = RokuBuilder::ControllerCommands.validate(logger: logger)
+    assert_equal RokuBuilder::SUCCESS, code
+    logger.verify
+  end
   def test_controller_commands_sideload
     logger = Logger.new("/dev/null")
     loader = Minitest::Mock.new
@@ -189,6 +196,43 @@ class ControllerCommandsTest < Minitest::Test
     mock.verify
     assert_equal RokuBuilder::SUCCESS, code
   end
+  def test_controller_commands_deeplink_sideload
+    logger = Logger.new("/dev/null")
+    mock = Minitest::Mock.new
+
+    ran_sideload = false
+
+    sideload =  Proc.new {|a, b, c| ran_sideload = true}
+
+    code = nil
+    options = {deeplink: true, set_stage: true, stage: 'production', deeplink_options: "a:b", config: "~/.roku_config.json"}
+    config = good_config
+    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+    mock.expect(:link, "true", [configs[:deeplink_config]])
+    RokuBuilder::Linker.stub(:new, mock) do
+      RokuBuilder::ControllerCommands.stub(:sideload, sideload) do
+        code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+      end
+    end
+    mock.verify
+    assert_equal RokuBuilder::SUCCESS, code
+    assert ran_sideload
+  end
+  def test_controller_commands_deeplink_fail
+    logger = Logger.new("/dev/null")
+    mock = Minitest::Mock.new
+
+    code = nil
+    options = {deeplink: true, stage: 'production', deeplink_options: "a:b", config: "~/.roku_config.json"}
+    config = good_config
+    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+    mock.expect(:link, false, [configs[:deeplink_config]])
+    RokuBuilder::Linker.stub(:new, mock) do
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, config: config, configs: configs, logger: logger})
+    end
+    mock.verify
+    assert_equal RokuBuilder::FAILED_DEEPLINKING, code
+  end
   def test_controller_commands_delete
     logger = Logger.new("/dev/null")
     loader = Minitest::Mock.new

data/tests/roku_builder/controller_test.rb

@@ -29,6 +29,11 @@ class ControllerTest < Minitest::Test
       current: true
     }
     assert_equal RokuBuilder::BAD_CURRENT, RokuBuilder::Controller.send(:validate_options, {options: options})
+    options = {
+      package: true,
+      in: true
+    }
+    assert_equal RokuBuilder::BAD_IN_FILE, RokuBuilder::Controller.send(:validate_options, {options: options})
     options = {
       deeplink: "a:b c:d",
       deeplink_depricated: true

data/tests/roku_builder/loader_test.rb

@@ -66,6 +66,65 @@ class LoaderTest < Minitest::Test
     io.verify
     response.verify
   end
+  def test_loader_sideload_infile
+    connection = Minitest::Mock.new
+    faraday = Minitest::Mock.new
+    io = Minitest::Mock.new
+    response = Minitest::Mock.new
+
+    infile = File.join(File.dirname(__FILE__), "test_files", "loader_test", "infile_test.zip")
+    logger = Logger.new("/dev/null")
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: logger,
+    }
+    loader_config = {
+      infile: infile
+    }
+    payload = {
+      mysubmit: "Replace",
+      archive: io,
+    }
+    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")
+    response.expect(:status, 200)
+    response.expect(:body, "Install Success")
+
+    loader = RokuBuilder::Loader.new(**device_config)
+    result = nil
+    build_version = nil
+    RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
+      Faraday.stub(:new, connection, faraday) do
+        Faraday::UploadIO.stub(:new, io) do
+          File.stub(:delete, nil) do
+            result, build_version = loader.sideload(**loader_config)
+          end
+        end
+      end
+    end
+
+    assert_equal "build_version", build_version
+    assert_equal RokuBuilder::SUCCESS, result
+
+    connection.verify
+    faraday.verify
+    io.verify
+    response.verify
+  end
   def test_loader_sideload_update
     connection = Minitest::Mock.new
     faraday = Minitest::Mock.new

data/tests/roku_builder/manifest_manager_test.rb

@@ -32,6 +32,13 @@ class ManifestManagerTest < Minitest::Test
     FileUtils.rm(File.join(root_dir, "manifest"))
   end
 
+  def test_manifest_manager_build_version_zip
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "manifest_manager_test", "test.zip")
+    build_version = nil
+    build_version = RokuBuilder::ManifestManager.build_version(root_dir: root_dir)
+    assert_equal "010101.1", build_version
+  end
+
   def test_manifest_manager_update_manifest
     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"))
@@ -62,4 +69,22 @@ class ManifestManagerTest < Minitest::Test
     assert FileUtils.compare_file(File.join(root_dir, "manifest"), File.join(root_dir, "updated_title_manifest"))
     FileUtils.rm(File.join(root_dir, "manifest"))
   end
+  def test_manifest_manager_update_manifest_partial
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "manifest_manager_test")
+    attrs = {
+      title: "New Title",
+      major_version: 2,
+      minor_version: 2,
+      build_version: "020202.0002",
+      mm_icon_focus_hd: "pkg:/images/focus1.png",
+      mm_icon_focus_sd: "pkg:/images/focus2.png"
+    }
+    RokuBuilder::ManifestManager.update_manifest(root_dir: root_dir, attributes: attrs)
+    attrs = {
+      title: "New Title",
+    }
+    RokuBuilder::ManifestManager.update_manifest(root_dir: root_dir, attributes: attrs)
+    assert FileUtils.compare_file(File.join(root_dir, "manifest"), File.join(root_dir, "updated_title_manifest"))
+    FileUtils.rm(File.join(root_dir, "manifest"))
+  end
 end

data/tests/roku_builder/monitor_test.rb

@@ -28,6 +28,37 @@ class MonitorTest < Minitest::Test
     connection.verify
   end
 
+  def test_monitor_monit_and_manage
+    connection = Minitest::Mock.new
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    monitor = RokuBuilder::Monitor.new(**device_config)
+
+    connection.expect(:waitfor, nil) do |config, &blk|
+      assert_equal(/./, config['Match'])
+      assert_equal(false, config['Timeout'])
+      txt = "Fake Text"
+      blk.call(txt) == ""
+    end
+
+    def monitor.gets
+      sleep(0.1)
+      "q"
+    end
+
+    Net::Telnet.stub(:new, connection) do
+      monitor.stub(:manage_text, "") do
+        monitor.monitor(type: :main)
+      end
+    end
+
+    connection.verify
+  end
+
   def test_monitor_monit_input
     connection = Minitest::Mock.new
     device_config = {

data/tests/roku_builder/stager_test.rb

@@ -1,6 +1,18 @@
 require_relative "test_helper.rb"
 
 class StagerTest < Minitest::Test
+
+  def test_stager_method
+    root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
+    stager_config = {
+      method: :working,
+      root_dir: root_dir,
+      logger: nil
+    }
+    stager = RokuBuilder::Stager.new(**stager_config)
+    assert_equal stager_config[:method], stager.method
+  end
+
   def test_stager_stage_working
     root_dir = File.join(File.dirname(__FILE__), "test_files", "stager_test")
     stager_config = {

data/tests/roku_builder/tester_test.rb

@@ -31,6 +31,43 @@ class TesterTest < Minitest::Test
     connection.verify
   end
 
+  def test_tester_runtests_and_handle
+    waitfor = Proc.new do |end_reg, &blk|
+      assert_equal /\*\*\*\*\* ENDING TESTS \*\*\*\*\*/, end_reg
+      txt = "Fake Text"
+      blk.call(txt) == false
+    end
+    connection = Minitest::Mock.new
+    loader = Minitest::Mock.new
+    device_config = {
+      ip: "111.222.333",
+      user: "user",
+      password: "password",
+      logger: Logger.new("/dev/null")
+    }
+    loader_config = {
+      root_dir: "root/dir/path",
+      branch: "branch",
+      folders: ["source"],
+      files: ["manifest"]
+    }
+    tester = RokuBuilder::Tester.new(**device_config)
+
+    loader.expect(:sideload, nil, [loader_config])
+    connection.expect(:waitfor, nil, &waitfor)
+    connection.expect(:puts, nil, ["cont\n"])
+
+    RokuBuilder::Loader.stub(:new, loader) do
+      Net::Telnet.stub(:new, connection) do
+        tester.stub(:handle_text, false) do
+          tester.run_tests(sideload_config: loader_config)
+        end
+      end
+    end
+
+    connection.verify
+  end
+
   def test_tester_handle_text_no_text
     logger = Minitest::Mock.new
     device_config = {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.6.1
 platform: ruby
 authors:
 - greeneca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-20 00:00:00.000000000 Z
+date: 2016-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -297,6 +297,7 @@ files:
 - tests/roku_builder/test_files/loader_test/source/c/d
 - tests/roku_builder/test_files/manifest_manager_test/manifest_template
 - tests/roku_builder/test_files/manifest_manager_test/manifest_template_2
+- tests/roku_builder/test_files/manifest_manager_test/test.zip
 - tests/roku_builder/test_files/manifest_manager_test/updated_title_manifest
 - tests/roku_builder/test_files/stager_test/a
 - tests/roku_builder/test_files/stager_test/manifest