roku_builder 3.3.2 → 3.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4fb0f1a154541f38d45f4cec4a78800d5442c4de
-  data.tar.gz: 04f1448deacf24c15223993745750f9298b6107a
+  metadata.gz: 57d35cf7d34cc1a61441de8f49007204e480238b
+  data.tar.gz: 25124d6fee986c47d3a58cdf0b23c023482c99cb
 SHA512:
-  metadata.gz: 40eb84586c9745d4faac4eae184c02be437966d65f71e194d0befb18c78e98e4f73a3fce23ab755ea5721242c928dec6462dea5969c75bd890da8933be0f054d
-  data.tar.gz: 0370b82f8bf8d258f2c9ab04b88b4624e73129dd01db3e38cc97a1c15e123a7b2064a9e4820d63b3662fb8f2ca6bf24c1b6d2eb13745829cf7add45acec3ae77
+  metadata.gz: 4efb6c2af95286dbadf4ef3f769752908516bdc200785194dc59f35739a2f4bd6b5b70d6f50915ae343dc5ab971711c43ef344a1e910d529129f697ae7c4abda
+  data.tar.gz: 0a431ada9ec91e6bedcf12ceb14ccca7eb70bd841614741b5ce46e41bcc158b881ed3b221f502eebe841687bf71da6673d38cce507b8928f1750083cc5b93fa8

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.3.1)
+    roku_builder (3.3.3)
       faraday (~> 0.9)
       faraday-digestauth (~> 0.2)
       git (~> 1.2.9)

data/README.md

@@ -1,5 +1,7 @@
 # RokuBuilder
 
+[![Gem Version](https://badge.fury.io/rb/roku_builder.svg)](https://badge.fury.io/rb/roku_builder)
+
 A tool to help with Roku Development. Assists with the following roku
 development tasks:
 
@@ -267,8 +269,8 @@ directory:
 
 ## Improvements
 
+ * Account for missing folders or files
  * Increase testing
-   * More Unit Tests
    * Intergration Tests
  * Move RokuBuilder::Controller to RokuBuilder?
  * Allow start and end delimiter for tests to be configured

data/bin/roku

@@ -130,6 +130,10 @@ OptionParser.new do |opts|
     options[:out] = o
   end
 
+  opts.on("-I", "--in PATH", "Input file for sideloading") do |i|
+    options[:in] = i
+  end
+
   opts.on("-V", "--verbose", "Print Info message") do |v|
     options[:verbose] = v
   end

data/lib/roku_builder/controller.rb

@@ -28,6 +28,9 @@ module RokuBuilder
     # No deeplink options supplied for deeplink
     BAD_DEEPLINK    = 6
 
+    # Incorrect use of the in option
+    BAD_IN_FILE     = 7
+
 
 
     ### Device Codes ###
@@ -36,7 +39,7 @@ module RokuBuilder
     CHANGED_DEVICE = -1
 
     # Device is online
-    GOOD_DEVCICE = 0
+    GOOD_DEVICE = 0
 
     # User defined device was not online
     BAD_DEVICE = 1
@@ -108,11 +111,11 @@ module RokuBuilder
 
       options_code = self.validate_options(options: options, logger: logger)
 
-      self.handle_error_codes(options_code: options_code, logger: logger)
+      self.handle_error_codes(options: options, options_code: options_code, logger: logger)
 
       handle_code = self.handle_options(options: options, logger: logger)
 
-      self.handle_error_codes(handle_code: handle_code, logger: logger)
+      self.handle_error_codes(options: options, handle_code: handle_code, logger: logger)
     end
 
     protected
@@ -133,6 +136,9 @@ module RokuBuilder
       if sources.include?(:current)
         return BAD_CURRENT unless options[:build] or options[:sideload]
       end
+      if options[:in]
+        return BAD_IN_FILE unless options[:sideload]
+      end
       if options[:deeplink]
         return BAD_DEEPLINK if !options[:deeplink_options] or options[:deeplink_options].chomp == ""
       end
@@ -152,7 +158,7 @@ module RokuBuilder
 
       # Check devices
       device_code, configs = self.check_devices(options: options, config: config, configs: configs, logger: logger)
-      self.handle_error_codes(device_code: device_code, logger: logger)
+      self.handle_error_codes(options: options, device_code: device_code, logger: logger)
 
       command = (self.commands & options.keys).first
       case command
@@ -193,7 +199,7 @@ module RokuBuilder
       when :build
         ### Build ###
         loader = Loader.new(**configs[:device_config])
-        build_version = ManifestManager.build_version(**configs[:manifest_config], logger: logger)
+        build_version = ManifestManager.build_version(**configs[:manifest_config])
         options[:build_version] = build_version
         configs = self.update_configs(configs: configs, options: options)
         outfile = loader.build(**configs[:build_config])
@@ -245,7 +251,7 @@ module RokuBuilder
     def self.check_devices(options:, config:, configs:, logger:)
       ping = Net::Ping::External.new
       host = configs[:device_config][:ip]
-      return [GOOD_DEVCICE, configs] if ping.ping? host, 1, 0.2, 1
+      return [GOOD_DEVICE, configs] if ping.ping? host, 1, 0.2, 1
       return [BAD_DEVICE, nil] if options[:device_given]
       config[:devices].each_pair {|key, value|
         unless key == :default
@@ -284,7 +290,7 @@ module RokuBuilder
     # @param options_code [Integer] the error code returned by validate_options
     # @param handle_code [Integer] the error code returned by handle_options
     # @param logger [Logger] system logger
-    def self.handle_error_codes(options_code: nil, device_code: nil, handle_code: nil, logger:)
+    def self.handle_error_codes(options:, options_code: nil, device_code: nil, handle_code: nil, logger:)
       if options_code
         case options_code
         when EXTRA_COMMANDS
@@ -305,6 +311,9 @@ module RokuBuilder
         when BAD_DEEPLINK
           logger.fatal "Must supply deeplinking options when deeplinking"
           abort
+        when BAD_IN_FILE
+          logger.fatal "Can only supply in file for building"
+          abort
         end
       elsif device_code
         case device_code
@@ -497,7 +506,7 @@ module RokuBuilder
           password: configs[:key][:password],
           app_name_version: "#{project_config[:app_name]} - #{stage}"
         }
-        if options[:outfile]
+        if options[:out_file]
           configs[:package_config][:out_file] = File.join(options[:out_folder], options[:out_file])
         end
         # Create Inspector Config
@@ -516,7 +525,8 @@ module RokuBuilder
       }
       # Create Manifest Config
       configs[:manifest_config] = {
-        root_dir: project_config[:directory]
+        root_dir: project_config[:directory],
+        logger: logger
       }
       # Create Deeplink Config
       configs[:deeplink_config] ={

data/lib/roku_builder/inspector.rb

@@ -35,7 +35,7 @@ module RokuBuilder
       if app_name
         app_name = app_name[1]
         dev_id = /Dev ID:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)[1]
-        creation_date = /Creation Date:\s*<\/td>\s*<td>\s*<font[^>]*>\s*<script[^>]*>\s*var d = new Date\(([^\)]*)\)[^<]*<\/script><\/font>\s*<\/td>/.match(response.body.gsub("\n", ''))[1]
+        creation_date = /new Date\(([^)]*)\)/.match(response.body.gsub("\n", ''))[1]
         dev_zip = /dev.zip:\s*<\/td>\s*<td>\s*<font[^>]*>([^<]*)<\/font>\s*<\/td>/.match(response.body)[1]
       else
         app_name = /App Name:[^<]*<div[^>]*>([^<]*)<\/div>/.match(response.body)[1]

data/lib/roku_builder/loader.rb

@@ -10,8 +10,9 @@ module RokuBuilder
     # @param fetch [Boolean] Flag to fetch all remotes before sideloading. Default: false
     # @param folders [Array<String>] Array of folders to be sideloaded. Pass nil to send all folders. Default: nil
     # @param files [Array<String>] Array of files to be sideloaded. Pass nil to send all files. Default: nil
+    # @param infile [String] 
     # @return [String] Build version on success, nil otherwise
-    def sideload(root_dir:, branch: nil, update_manifest: false, fetch: false, folders: nil, files: nil)
+    def sideload(root_dir:, branch: nil, update_manifest: false, fetch: false, folders: nil, files: nil, infile: nil)
       @root_dir = root_dir
       result = nil
       stash = nil

data/lib/roku_builder/monitor.rb

@@ -35,14 +35,7 @@ module RokuBuilder
         all_text = ""
         while true
           connection.waitfor(waitfor_config) do |txt|
-            all_text += txt
-            while line = all_text.slice!(/^.*\n/) do
-              puts line
-            end
-            if all_text == "BrightScript Debugger> "
-              print all_text
-              all_text = ""
-            end
+            all_text = manage_text(all_text: all_text, txt: txt)
           end
         end
       }
@@ -58,5 +51,23 @@ module RokuBuilder
         end
       end
     end
+
+    private
+
+    # Handel text from telnet
+    #  @param all_text [String] remaining partial line text
+    #  @param txt [String] current string from telnet
+    #  @return [String] remaining partial line text
+    def manage_text(all_text:, txt:)
+      all_text += txt
+      while line = all_text.slice!(/^.*\n/) do
+        puts line
+      end
+      if all_text == "BrightScript Debugger> "
+        print all_text
+        all_text = ""
+      end
+      all_text
+    end
   end
 end

data/lib/roku_builder/tester.rb

@@ -5,6 +5,11 @@ module RokuBuilder
   # with other testing libraries
   class Tester < Util
 
+    def init()
+      @end_reg = /\*\*\*\*\* ENDING TESTS \*\*\*\*\*/
+      @start_reg = /\*\*\*\*\* STARTING TESTS \*\*\*\*\*/
+    end
+
     # Run tests and report results
     # @param sideload_config [Hash] The config for sideloading the app
     def run_tests(sideload_config:)
@@ -18,15 +23,25 @@ module RokuBuilder
       loader.sideload(**sideload_config)
 
       in_tests = false
-      end_reg = /\*\*\*\*\* ENDING TESTS \*\*\*\*\*/
-      connection.waitfor(end_reg) do |txt|
-        txt.split("\n").each do |line|
-          in_tests = false if line =~ end_reg
-          @logger.unknown line if in_tests
-          in_tests = true if line =~ /\*\*\*\*\* STARTING TESTS \*\*\*\*\*/
-        end
+      connection.waitfor(@end_reg) do |txt|
+        in_tests = handle_text(txt: txt, in_tests: in_tests)
       end
       connection.puts("cont\n")
     end
+
+    private
+
+    # Handel testing text
+    # @param txt [String] current text from telnet
+    # @param in_tests [Boolean] currently parsing test text
+    # @return [Boolean] currently parsing test text
+    def handle_text(txt:, in_tests:)
+      txt.split("\n").each do |line|
+        in_tests = false if line =~ @end_reg
+        @logger.unknown line if in_tests
+        in_tests = true if line =~ @start_reg
+      end
+      in_tests
+    end
   end
 end

data/lib/roku_builder/version.rb

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

data/roku_builder.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = "~> 2.2"
+
   spec.add_dependency "rubyzip",             "~> 1.1"
   spec.add_dependency "faraday",             "~> 0.9"
   spec.add_dependency "faraday-digestauth",  "~> 0.2"

data/tests/roku_builder/config_manager_test.rb

@@ -16,6 +16,19 @@ class ConfigManagerTest < Minitest::Test
     assert_equal :project1, config[:projects][:default], :project1
   end
 
+  def test_config_manager_read_invalid_config
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json+"}}}}}")
+    config = nil
+    File.stub(:open, io) do
+      config = RokuBuilder::ConfigManager.get_config(config: config_path, logger: logger)
+    end
+    io.verify
+    assert_nil config
+  end
+
   def test_config_manager_validate_devices
     logger = Logger.new("/dev/null")
     config = good_config

data/tests/roku_builder/controller_config_test.rb

@@ -0,0 +1,19 @@
+require_relative "test_helper.rb"
+
+class ControllerConfigTest < Minitest::Test
+  def test_manifest_config
+    logger = Logger.new("/dev/null")
+    options = {
+      config: File.expand_path(File.join(File.dirname(__FILE__), "test_files", "controller_config_test", "valid_config.json")),
+      stage: 'production',
+      update_manifest: false,
+      fetch: false,
+    }
+    code, config, configs = RokuBuilder::Controller.load_config(options: options, logger: logger)
+
+    assert_equal "/dev/null", configs[:manifest_config][:root_dir]
+    assert_equal logger, configs[:manifest_config][:logger]
+
+
+  end
+end

data/tests/roku_builder/controller_test.rb

@@ -1,5 +1,13 @@
 require_relative "test_helper.rb"
 
+class RokuBuilder::Controller
+  class << self
+    def abort
+      #do nothing
+    end
+  end
+end
+
 class ControllerTest < Minitest::Test
   def test_controller_validate_options
     logger = Logger.new("/dev/null")
@@ -7,38 +15,50 @@ class ControllerTest < Minitest::Test
       sideload: true,
       package: true
     }
-    assert_equal 1, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::EXTRA_COMMANDS, RokuBuilder::Controller.validate_options(options: options, logger: logger)
     options = {}
-    assert_equal 2,  RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::NO_COMMANDS,  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)
+    assert_equal RokuBuilder::Controller::EXTRA_SOURCES, RokuBuilder::Controller.validate_options(options: options, logger: logger)
     options = {
       sideload: true,
       working: true
     }
-    assert_equal 0, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::VALID, RokuBuilder::Controller.validate_options(options: options, logger: logger)
     options = {
       package: true
     }
-    assert_equal 4, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::NO_SOURCE, RokuBuilder::Controller.validate_options(options: options, logger: logger)
     options = {
       package: true,
       current: true
     }
-    assert_equal 5, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::BAD_CURRENT, RokuBuilder::Controller.validate_options(options: options, logger: logger)
     options = {
       deeplink: true
     }
-    assert_equal 6, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::BAD_DEEPLINK, RokuBuilder::Controller.validate_options(options: options, logger: logger)
     options = {
       deeplink: true,
       deeplink_options: ""
     }
-    assert_equal 6, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    assert_equal RokuBuilder::Controller::BAD_DEEPLINK, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      sideload: true,
+      in: "",
+      current: true
+    }
+    assert_equal RokuBuilder::Controller::VALID, RokuBuilder::Controller.validate_options(options: options, logger: logger)
+    options = {
+      package: true,
+      in: "",
+      set_stage: true
+    }
+    assert_equal RokuBuilder::Controller::BAD_IN_FILE, RokuBuilder::Controller.validate_options(options: options, logger: logger)
   end
   def test_controller_configure
     logger = Logger.new("/dev/null")
@@ -66,6 +86,16 @@ class ControllerTest < Minitest::Test
     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]
+
+    options = {
+      configure: true,
+      config: target_config
+    }
+
+    code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+
+    assert_equal RokuBuilder::Controller::CONFIG_OVERWRITE, code
+
     File.delete(target_config) if File.exists?(target_config)
   end
 
@@ -169,8 +199,99 @@ class ControllerTest < Minitest::Test
     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)
+    keyer = Minitest::Mock.new
     loader = Minitest::Mock.new
-    #TODO
+    packager = Minitest::Mock.new
+    inspector = Minitest::Mock.new
+
+    options = {package: true, inspect: true, stage: 'production', out_folder: "/tmp", config: target_config}
+    configs = {
+      device_config: {},
+      sideload_config: {},
+      key: {},
+      package_config: {
+        app_name_version: "app - production - build_version",
+        out_file: "/tmp/app_production_build_version.pkg"
+      },
+      project_config: {app_name: "app"},
+      inspect_config: {}
+    }
+    info = {app_name: "app", dev_id: "id", creation_date: "date", dev_zip: ""}
+
+    loader.expect(:sideload, "build_version", [configs[:sideload_config]])
+    keyer.expect(:rekey, true, [configs[:key]])
+    packager.expect(:package, true, [configs[:package_config]])
+    inspector.expect(:inspect, info, [configs[:inspect_config]])
+
+    code = nil
+    RokuBuilder::Keyer.stub(:new, keyer) do
+      RokuBuilder::Loader.stub(:new, loader) do
+        RokuBuilder::Packager.stub(:new, packager) do
+          RokuBuilder::Inspector.stub(:new, inspector) do
+            RokuBuilder::Controller.stub(:check_devices, [0, configs]) do
+              code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+            end
+          end
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+
+    keyer.verify
+    loader.verify
+    packager.verify
+    inspector.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+
+  def test_controller_package_outfile
+    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)
+    keyer = Minitest::Mock.new
+    loader = Minitest::Mock.new
+    packager = Minitest::Mock.new
+    inspector = Minitest::Mock.new
+
+    options = {package: true, inspect: true, stage: 'production', out: "/tmp/out.pkg", config: target_config}
+    configs = {
+      device_config: {},
+      sideload_config: {},
+      key: {},
+      package_config: {
+        app_name_version: "app - production - build_version",
+        out_file: "/tmp/out.pkg"
+      },
+      project_config: {app_name: "app"},
+      inspect_config: {}
+    }
+    info = {app_name: "app", dev_id: "id", creation_date: "date", dev_zip: ""}
+
+    loader.expect(:sideload, "build_version", [configs[:sideload_config]])
+    keyer.expect(:rekey, true, [configs[:key]])
+    packager.expect(:package, true, [configs[:package_config]])
+    inspector.expect(:inspect, info, [configs[:inspect_config]])
+
+    code = nil
+    RokuBuilder::Keyer.stub(:new, keyer) do
+      RokuBuilder::Loader.stub(:new, loader) do
+        RokuBuilder::Packager.stub(:new, packager) do
+          RokuBuilder::Inspector.stub(:new, inspector) do
+            RokuBuilder::Controller.stub(:check_devices, [0, configs]) do
+              code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+            end
+          end
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+
+    keyer.verify
+    loader.verify
+    packager.verify
+    inspector.verify
+    File.delete(target_config) if File.exists?(target_config)
   end
 
   def test_controller_build
@@ -199,6 +320,8 @@ class ControllerTest < Minitest::Test
       end
     end
     assert_equal RokuBuilder::Controller::SUCCESS, code
+    loader.verify
+    File.delete(target_config) if File.exists?(target_config)
   end
   def test_controller_update
     logger = Logger.new("/dev/null")
@@ -223,6 +346,7 @@ class ControllerTest < Minitest::Test
     end
     mock.verify
     assert_equal RokuBuilder::Controller::SUCCESS, code
+    File.delete(target_config) if File.exists?(target_config)
   end
 
   def test_controller_deeplink
@@ -245,6 +369,361 @@ class ControllerTest < Minitest::Test
     end
     mock.verify
     assert_equal RokuBuilder::Controller::SUCCESS, code
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_delete
+    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
+
+    options = {delete: true, stage: 'production', config: target_config}
+    loader.expect(:unload, nil)
+    code = nil
+    RokuBuilder::Loader.stub(:new, loader) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    loader.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_monitor
+    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)
+    monitor = Minitest::Mock.new
+
+    options = {monitor: "main", stage: 'production', config: target_config}
+    monitor.expect(:monitor, nil, [{}])
+    code = nil
+    RokuBuilder::Monitor.stub(:new, monitor) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, monitor_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    monitor.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_navigate
+    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)
+    navigator = Minitest::Mock.new
+
+    options = {navigate: "up", stage: 'production', config: target_config}
+    navigator.expect(:nav, true, [{}])
+    code = nil
+    RokuBuilder::Navigator.stub(:new, navigator) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, navigate_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    navigator.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_navigate_fail
+    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)
+    navigator = Minitest::Mock.new
+
+    options = {navigate: "up", stage: 'production', config: target_config}
+    navigator.expect(:nav, nil, [{}])
+    code = nil
+    RokuBuilder::Navigator.stub(:new, navigator) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, navigate_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::FAILED_NAVIGATING, code
+    navigator.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_screen
+    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)
+    navigator = Minitest::Mock.new
+
+    options = {screen: "secret", stage: 'production', config: target_config}
+    navigator.expect(:screen, true, [{}])
+    code = nil
+    RokuBuilder::Navigator.stub(:new, navigator) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, screen_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    navigator.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_screens
+    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)
+    navigator = Minitest::Mock.new
+
+    options = {screens: true, stage: 'production', config: target_config}
+    navigator.expect(:screens, true)
+    code = nil
+    RokuBuilder::Navigator.stub(:new, navigator) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    navigator.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_text
+    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)
+    navigator = Minitest::Mock.new
+
+    options = {text: "text string", stage: 'production', config: target_config}
+    navigator.expect(:type, true, [{}])
+    code = nil
+    RokuBuilder::Navigator.stub(:new, navigator) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, text_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    navigator.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_test
+    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)
+    tester = Minitest::Mock.new
+
+    options = {test: true, stage: 'production', config: target_config}
+    tester.expect(:run_tests, true, [{}])
+    code = nil
+    RokuBuilder::Tester.stub(:new, tester) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, test_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    tester.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_screencapture
+    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)
+    inspector = Minitest::Mock.new
+
+    options = {screencapture: true, stage: 'production', out: "/tmp/capture.jpg", config: target_config}
+    inspector.expect(:screencapture, true, [{}])
+    code = nil
+    RokuBuilder::Inspector.stub(:new, inspector) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, screencapture_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::SUCCESS, code
+    inspector.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+  def test_controller_screencapture_fail
+    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)
+    inspector = Minitest::Mock.new
+
+    options = {screencapture: true, stage: 'production', out: "/tmp", config: target_config}
+    inspector.expect(:screencapture, false, [{}])
+    code = nil
+    RokuBuilder::Inspector.stub(:new, inspector) do
+      RokuBuilder::ManifestManager.stub(:build_version, "1") do
+        RokuBuilder::Controller.stub(:check_devices, [0, {device_config: {}, screencapture_config: {}}]) do
+          code = RokuBuilder::Controller.handle_options(options: options, logger: logger)
+        end
+      end
+    end
+    assert_equal RokuBuilder::Controller::FAILED_SCREENCAPTURE, code
+    inspector.verify
+    File.delete(target_config) if File.exists?(target_config)
+  end
+
+  def test_controller_handel_error_codes
+    errors = {
+      fatal: {
+        options_code: [
+          RokuBuilder::Controller::EXTRA_COMMANDS,
+          RokuBuilder::Controller::NO_COMMANDS,
+          RokuBuilder::Controller::EXTRA_SOURCES,
+          RokuBuilder::Controller::NO_SOURCE,
+          RokuBuilder::Controller::BAD_CURRENT,
+          RokuBuilder::Controller::BAD_DEEPLINK,
+          RokuBuilder::Controller::BAD_IN_FILE
+        ],
+        device_code: [
+          RokuBuilder::Controller::BAD_DEVICE,
+          RokuBuilder::Controller::NO_DEVICES,
+        ],
+        handle_code: [
+          RokuBuilder::Controller::CONFIG_OVERWRITE,
+          RokuBuilder::Controller::MISSING_CONFIG,
+          RokuBuilder::Controller::INVALID_CONFIG,
+          RokuBuilder::Controller::MISSING_MANIFEST,
+          RokuBuilder::Controller::UNKNOWN_DEVICE,
+          RokuBuilder::Controller::UNKNOWN_PROJECT,
+          RokuBuilder::Controller::UNKNOWN_STAGE,
+          RokuBuilder::Controller::FAILED_SIDELOAD,
+          RokuBuilder::Controller::FAILED_SIGNING,
+          RokuBuilder::Controller::FAILED_DEEPLINKING,
+          RokuBuilder::Controller::FAILED_NAVIGATING,
+          RokuBuilder::Controller::FAILED_SCREENCAPTURE
+        ]
+      },
+      info: {
+        device_code: [
+          RokuBuilder::Controller::CHANGED_DEVICE
+        ]
+      },
+      warn: {
+        handle_code: [
+          RokuBuilder::Controller::DEPRICATED_CONFIG
+        ]
+      }
+    }
+
+    errors.each_pair do |type,errors|
+      errors.each_pair do |key,value|
+        value.each do |code|
+          logger = Minitest::Mock.new
+          options = {options: {}, logger: logger}
+          options[key] = code
+          logger.expect(type, nil)  {|string| string.class == String}
+          RokuBuilder::Controller.handle_error_codes(**options)
+          logger.verify
+        end
+      end
+    end
+  end
+
+  def test_controller_check_devices
+    logger = Logger.new("/dev/null")
+    ping = Minitest::Mock.new
+    options = {device_given: false}
+    config = {}
+    config[:devices] = {
+      a: {ip: "2.2.2.2"},
+      b: {ip: "3.3.3.3"}
+    }
+    configs = {
+      device_config: {ip: "1.1.1.1"}
+    }
+
+    Net::Ping::External.stub(:new, ping) do
+
+      ping.expect(:ping?, true, [configs[:device_config][:ip], 1, 0.2, 1])
+      code, ret = RokuBuilder::Controller.check_devices(options: options, config: config, configs: configs, logger: logger)
+      assert_equal RokuBuilder::Controller::GOOD_DEVICE, code
+
+      ping.expect(:ping?, false, [configs[:device_config][:ip], 1, 0.2, 1])
+      ping.expect(:ping?, false, [config[:devices][:a][:ip], 1, 0.2, 1])
+      ping.expect(:ping?, false, [config[:devices][:b][:ip], 1, 0.2, 1])
+      code, ret = RokuBuilder::Controller.check_devices(options: options, config: config, configs: configs, logger: logger)
+      assert_equal RokuBuilder::Controller::NO_DEVICES, code
+
+      ping.expect(:ping?, false, [configs[:device_config][:ip], 1, 0.2, 1])
+      ping.expect(:ping?, true, [config[:devices][:a][:ip], 1, 0.2, 1])
+      code, ret = RokuBuilder::Controller.check_devices(options: options, config: config, configs: configs, logger: logger)
+      assert_equal RokuBuilder::Controller::CHANGED_DEVICE, code
+      assert_equal config[:devices][:a][:ip], ret[:device_config][:ip]
+
+      options[:device_given] = true
+      ping.expect(:ping?, false, [configs[:device_config][:ip], 1, 0.2, 1])
+      code, ret = RokuBuilder::Controller.check_devices(options: options, config: config, configs: configs, logger: logger)
+      assert_equal RokuBuilder::Controller::BAD_DEVICE, code
+    end
+  end
+
+  def test_controller_run_debug
+    logger = Minitest::Mock.new
+    options = {debug: true}
+
+    logger.expect(:formater=, nil) do |proc_object|
+      proc_object.class == PROC and proc_object.arity == 4
+    end
+    logger.expect(:level=, nil, [Logger::DEBUG])
+    RokuBuilder::Controller.stub(:validate_options, nil) do
+      RokuBuilder::Controller.stub(:handle_options, nil) do
+        RokuBuilder::Controller.stub(:handle_error_codes, nil) do
+          RokuBuilder::Controller.run(options: options)
+        end
+      end
+    end
+  end
+  def test_controller_run_info
+    logger = Minitest::Mock.new
+    options = {verbose: true}
+
+    logger.expect(:formater=, nil) do |proc_object|
+      proc_object.class == PROC and proc_object.arity == 4
+    end
+    logger.expect(:level=, nil, [Logger::INFO])
+    RokuBuilder::Controller.stub(:validate_options, nil) do
+      RokuBuilder::Controller.stub(:handle_options, nil) do
+        RokuBuilder::Controller.stub(:handle_error_codes, nil) do
+          RokuBuilder::Controller.run(options: options)
+        end
+      end
+    end
+  end
+  def test_controller_run_warn
+    logger = Minitest::Mock.new
+    options = {}
+
+    logger.expect(:formater=, nil) do |proc_object|
+      proc_object.class == PROC and proc_object.arity == 4
+    end
+    logger.expect(:level=, nil, [Logger::WARN])
+    RokuBuilder::Controller.stub(:validate_options, nil) do
+      RokuBuilder::Controller.stub(:handle_options, nil) do
+        RokuBuilder::Controller.stub(:handle_error_codes, nil) do
+          RokuBuilder::Controller.run(options: options)
+        end
+      end
+    end
   end
 end