roku_builder 3.11.1 → 3.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 24f62ca635f6a690606f53980f4b2de0d3206525
-  data.tar.gz: 1d061880ae44bd0764ed4ec22583f2402749a917
+  metadata.gz: 93b0a591ad7b3ea224df548135d5630d63042720
+  data.tar.gz: b5af0760e8b9a2c914ec483fe28c0be45bee1b6b
 SHA512:
-  metadata.gz: 8583f7c075a0fce0cc992d0f215b27e0145b147a88da14b4785887a84e70e60f85ecb0b91d5548081850c4347b2457c3bab4f1644fde1abbdbeb21832fb23960
-  data.tar.gz: afe84a4778c8ac21c3c97cf450e73ec5215d80f67d9dfba5a2dbc034f4637c7b9e7479b0d362ae775a21b5008be08dd21b58d6104fd7ed8a14efbde9ddcf3327
+  metadata.gz: b553af68d7eae9b5e2b3c40b7eef3b7852ab01b86704b1aa7548c37ee57914bc502cee6c820f32c48c5f562e46750241571ccecd83dc76784fcf329bb98b0d30
+  data.tar.gz: 0b51fbe386fe0944f114c26057dc0f2267bd88fc5f238a4007f1b6d8f9a3a9435f6e3f47c5819599afa13c82c960ae61788f83e720d67fd2566a55729b3674ac

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    roku_builder (3.11.1)
+    roku_builder (3.12.0)
       faraday (~> 0.11)
       faraday-digestauth (~> 0.2)
       git (~> 1.3)
@@ -22,10 +22,6 @@ GEM
       thor (~> 0.19.1)
       tins (~> 1.6)
     docile (1.1.5)
-    em-websocket (0.5.1)
-      eventmachine (>= 0.12.9)
-      http_parser.rb (~> 0.6.0)
-    eventmachine (1.2.1)
     faraday (0.11.0)
       multipart-post (>= 1.2, < 3)
     faraday-digestauth (0.2.1)
@@ -44,12 +40,9 @@ GEM
       shellany (~> 0.0)
       thor (>= 0.18.1)
     guard-compat (1.2.1)
-    guard-livereload (2.5.2)
-      em-websocket (~> 0.5)
-      guard (~> 2.8)
-      guard-compat (~> 1.0)
-      multi_json (~> 1.8)
-    http_parser.rb (0.6.0)
+    guard-minitest (2.4.6)
+      guard-compat (~> 1.2)
+      minitest (>= 3.0)
     json (2.0.3)
     listen (3.1.5)
       rb-fsevent (~> 0.9, >= 0.9.4)
@@ -63,7 +56,6 @@ GEM
       minitest-server (~> 1.0)
     minitest-server (1.0.4)
       minitest (~> 5.0)
-    multi_json (1.12.1)
     multipart-post (2.0.0)
     nenv (0.3.0)
     net-http-digest_auth (1.4)
@@ -104,7 +96,8 @@ DEPENDENCIES
   bundler (~> 1.7)
   byebug (~> 9.0)
   coveralls (~> 0.8)
-  guard-livereload (~> 2.5)
+  guard (~> 2.14)
+  guard-minitest (~> 2.4)
   minitest (~> 5.10)
   minitest-autotest (~> 1.0)
   minitest-server (~> 1.0)

data/Guardfile

@@ -17,7 +17,10 @@
 #
 # and, you'll have to watch "config/Guardfile" instead of "Guardfile"
 
-guard 'livereload' do
-  watch(%r{lib/roku_builder/.+\.rb})
-  watch(%r{lib/roku_builder.rb})
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/roku_builder/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/roku_builder/(.*/)?([^/]+)\.rb$})     { |m| "test/roku_builder/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/roku_builder/test_helper\.rb$})      { 'test/roku_builder' }
 end

data/README.md

@@ -55,91 +55,176 @@ This will create the file '~/.roku_config.json' with a default configuration.
 Edit this file to add appropriate values. The following are default
 configuration options:
 
+##### Top Level Configuration
+
  * devices: information for accessing devices
- * devices -> default: id of the default device
  * projects: this is a hash of project objects
- * projects -> default: the key for the default project
+ * keys: contains keys that will be used for signing packages
+ * input_mapping: allows you to change key mappings for the intractive navigator
+
+##### Device Configuration
+
+ * devices.default: id of the default device
+ * devices.<device_id>.ip: ip address of the device
+ * devices.<device_id>.user: dev username for the roku device
+ * devices.<device_id>.password: dev password for the roku device
+
+##### Project Configuration
+
+ * projects.default: the key for the default project
+ * projects.parent_dir: optional directory path that all projects are relative
+    to
+ * projects.<project_id>.parent: optional id of parent project to copy configs
+    from
+ * projects.<project_id>.directory: full path of the git repository the houses
+    the roku app
+ * projects.<project_id>.app_name: Name used when packaging the app
+ * projects.<project_id>.stage_method: Which method to use for switching app
+    stages (git or script)
+ * projects.<project_id>.stages: a hash of stage objects
+ * projects.<project_id>.stages.<stage_id>.branch: name of the branch for the
+    given stage (if stage_method = git). If using stage_method = stage then
+    this can be removed.
+ * projects.<project_id>.stages.<stage_id>.script: scripts to use to stage the
+    app (if stage_method = script). If using stage_method = git this can be
+    removed.
+ * projects.<project_id>.stages.<stage_id>.script.stage: script run form the
+    app root directory to stage app
+ * projects.<project_id>.stages.<stage_id>.script -> unstage: script run form
+    the app root directory to unstage app
+ * projects.<project_id>.stages.<stage_id>.key: this can be a string referencing
+    a key in the keys section or a hash of options
+ * projects.<project_id>.stages.<stage_id>.key.keyed_pkg: path to a pkg file
+    that has been signed
+ * projects.<project_id>.stages.<stage_id>.key.password: password for the signed pkg
+
+##### Key Configuration
+
+ * keys.key_dir: optional directory that all keys are relative to
+ * keys.<key_id>.keyed_pkg: path to a pkg file that has been signed
+ * keys.<key_id>.password: password for the signed pkg
+
+The "input_mappings" section is optional but will allow you to override
+the default input mappings. In the section each key is a key press code. The
+value is a array with the desired command to run and a human readable key name.
+To see the key press code for a specific key the --navigate command can be run
+with the --debug option on to see a print out of all the keys pressed.
 
- Each Device has the following options:
+#### Basic steps for creating a Roku channel/application package
 
- * ip: ip address of the device
- * user: dev username for the roku device
- * password: dev password for the roku device
+Official docs for packaging an application can be found [in the sdk](https://sdkdocs.roku.com/display/sdkdoc/Packaging+Your+Application), however the basic steps are:
 
- Each project has the following options:
+1.  Side-load your application onto a Roku device for testing.
+1.  Run the genkey utility to generate a key.  This key will sign packages. This step only needs to be done once.
+1.  Run the package utility to generate the package.
+1.  Download the package from the Roku device to your computer.
 
- * directory: full path of the git repository the houses the roku app
- * app_name: Name used when packaging the app
- * stage_method: Which method to use for switching app stages (git or script)
- * stages: a hash of stage objects
+RokuBuilder makes running each of these steps easy, without needing to use the Roku device web interface or telnet.
 
- Each stage has the following options:
+#### Projects and Stages
 
- * branch: name of the branch for the given stage (if stage_method = git). If
-    using stage_method = stage then this can be removed.
- * script: scripts to use to stage the app (if stage_method = script). If using
-    stage_method = git this can be removed.
- * script -> stage: script run form the app root directory to stage app
- * script -> unstage: script run form the app root directory to unstage app
- * key: has of key options for signing a package
- * key -> keyed_pkg: path to a pkg file that has been signed
- * key -> password: password for the signed pkg
+The configuration for this gem allows you to define any number of project and
+any number of stages for each project. It is intended that each app be defined
+as a project and then the stages for that project would allow you to define
+production/staging/etc. stages.
 
-There is an optional "input_mappings" section that will allow you to override
-the default input mappings. In the section each key is a key press code. The
-value is a array with the desired command to run and a human readable key name.
-To see the key press code for a specific key the --navigate command can be run
-with the --debug option on to see a print out of all the keys pressed.
+There are two different ways that stages can be defined. You can use a script
+to define your stage. This gives you the greatest amount of freedom allowing
+you to setup your stage anyway you want. The other option is to use git
+staging. To do this you must have one branch for eash stage.
 
+The project used in the examples below is a smart default. If you are in a
+project directory then it will use that project. If you are not then it will
+use the defualt that you have defined in your config. You can define what
+project you want the command to be run on using the --project option:
 
-#### Sideloading
+    $ roku -lw --project project1
 
-There are several ways to side load an app. You can sideload based on a stage,
-an arbitrary git referance or the working directory.
+or:
 
-To sideload a stage you can run the following command:
+    $ roku -lw -P project1
 
-    $ roku --sideload --stage production
+#### Commands and Sources
+
+There are several commands that require a source option to run properly. These
+include:
+
+ * Sideload
+ * Build
+ * Package
+ * Test
+ * Key
+
+There are several source options that can be supplied to these commands. Which
+options you use will depend on the type of staging you are using and the app
+you are trying to run the command. The options are as follows:
+
+ * --ref or -r
+   * This option only works with git type staging. It will allow you to run a
+      command on a specific git branch, tag, or referance.
+ * --stage or -s
+   * This option will work with either git or script staging. It allows you to
+      sideload a specific stage. If using script staging then it will run the
+      configured stage script before sideloading and then run the unstage
+      script after. If using git staging it will stach any local changes,
+      switch to the configured branch, sideload, switch back to the previous
+      branch, and unstach changes. This is the only source option that you can
+      use when packaging.
+ * --working or -w
+   * This option will work with git or script staging. It will use the project
+      configs to determine the directory to use but will not run any staging
+      method.
+ * --current or -c
+   * This option will ignore any project configurattion and just us the entire
+      current directory.
+ * --in or -I
+   * This option allows you to pass in a zip file of an already built app.
 
-This will sideload the production stage. By default the production stage is
-used. So the above is equivalent to the following:
 
-    $ roku --sideload
+#### Sideloading
 
-and:
+You can sideload an app directly to the device using this gem. The gem will
+zip all of the configured files and upload it to the device and the remove the
+zip. You can do so with the following commands:
 
-    $ roku -l
+    $ roku --sideload --stage production
 
-To sideload via a git referance you can run the following command
+or:
 
-    $ roku --sideload --ref master
+    $ roku -ls production
 
-This will sideload the master branch. The following is equivalent:
+When sideoading you can use any of the source options approiate to your staging
+method.
 
-    $ roku -lr master
+#### Building
 
-To sideload the current working directory you can run the following:
+You can build an app to be sideloaded later or by someone else by using the
+following command:
 
-    $ roku --sideload --working
+    $ roku --build --working
 
 or:
 
-    $ roku -lw
+    $ roku -bw
 
-If you choose to sideload via stage or git referance then the roku tool with
-stash any changes in the working directory and then apply the stash after. From
-time to time there may be an issue with this and you will have to clear the
-stash manually.
+When bulding you can use any of the source options approiate to your staging
+method except the --in option.
 
-You can also sideload the current directory even if it is not setup as a
-project. If the directory has a manifest file then you can run the following
-command:
+#### Generating a key
 
-    $ roku --sideload --current
+Before you can package a channel, you must [generate a key](https://sdkdocs.roku.com/display/sdkdoc/Packaging+Your+Application#PackagingYourApplication-RunthegenkeyUtility)
+that is used to sign the package. This key is used to sign a new package and is
+also needed to sign a package when updating a channel.
 
-or:
+You can create a key by running the genkey command:
 
-    $ roku -lc
+    $ roku --genkey --debug
+
+This will output the following data, all of which need to put in the `keys` section of `~/.roku_config.json`:
+
+*  `Keyed PKG`: This is the signing key, used to sign new and updated packages
+*  `Password`: Key's password
+*  `DevID`: The developer ID associated with the key.  Don't need to save this, but it is best practice to include this string in the signing keys filename
 
 #### Packaging
 
@@ -153,17 +238,8 @@ or:
 
     $ roku -ps production
 
-#### Building
-
-You can build an app to be sideloaded later or by someone else by using the
-following command:
-
-    $ roku --build --stage production
-
-or:
-
-    $ roku -bw
-
+The package command will automatically [Rekey](https://github.com/rokudev/docs/blob/master/develop/guides/packaging.md#rekeying)
+your roku device before packaging the channel
 
 #### Monitoring Logs
 
@@ -177,20 +253,40 @@ brightscript log:
 or:
     $ roku -m main
 
+or
+
+    $ roku --monitor
+
 The following are the options to be passed in as type:
 
  * main
- * sg
- * task1
- * task2
- * task3
- * taskX
+ * sg (depricated)
+ * task1 (depricated)
+ * task2 (depricated)
+ * task3 (depricated)
+ * taskX (depricated)
  * profile
 
+If no option is passed in then main log is monitored.
+
 The tool connects to the roku via telnet and prints everything that it
 recieves. It will continue indefinatly unless it is stopped via Ctrl-c or
 entering "q".
 
+The monitor tool also includes command history and some tab completeion.
+
+#### Interactive Navigation
+
+The gem has the ability to capture keyboard input and send it to the roku as
+remote inputs. This can be done by running the following command:
+
+    $ roku --navigate
+
+Running in verbose mode will print out all of the key mappings avaiable. If you
+want to change these mappings you can do so via the input_mapping config values
+. To determine the codes needed to enter in the input_mapping config you can
+run the navigator in debug mode.
+
 #### Profiling Scene Graph
 
 The tool will help a little with profiling scenegraph applications. Running the
@@ -222,7 +318,7 @@ are run otherwise it will just grab the test run from last time.
 Another tool for testing is the navigate command. You can use this to script
 navigation on the roku console. The command is used as follows:
 
-    $ roku --navigate <command>
+    $ roku --nav <command>
 
 The possible commands are as follows:
 
@@ -267,46 +363,13 @@ You can use a differnt configuration file useing the following option:
 
 This path will be expanded so you do not have to use the full path
 
-You can use your keyboard to control the roku by running the following command:
-
-    $ roku --navigate
-
-To see the key mapings you can run the following command:
-
-    $ roku --navigate -V
-
-## Projects
-
-The project used in the above examples is a smart default. If you are in a
-project directory then it will use that project. If you are not then it will
-use the defualt that you have defined in your config. You can define what
-project you want the command to be run on using the --project option:
-
-    $ roku -lw --project project1
-
-or:
-
-    $ roku -lw -P project1
-
-## Stages
-
-Each project can have any number of stages. stages can be defined in a number
-of ways. The default is to use git branches to define stages. You can setup a
-branch for each stage and the gem will automatically switch between them as
-needed. If using git stages then the gem will ensure to stash any change you
-currently have before checking out the required branch. When done it will
-switch back and unstash the changes. You can use the -w or --working options
-to avoid this.
-
-The other method of staging is script staging. This will run a script you
-define before and after performing any actions. This will let you stage your
-app anyway you like as long as it can be done via script.
-
 ## Devices
 
-In the examples above the default device is used. If you have multiple devices
-defined in your config then you can select a different one using the following
-option:
+In the examples above the device used is a smart default. It will use the
+default device defined in the configuration file. If that device is not online
+it will look start at the top and try each device until it findes an avaiable
+device. If you have multiple devices defined in your config then you can select
+a different one using the following option:
 
     $ roku -lw --device device2
 
@@ -325,10 +388,6 @@ directory:
 
 ## Improvements
 
- * Increase testing
-   * Config Unit Tests
-   * Intergration Tests
- * Move RokuBuilder::Controller to RokuBuilder?
  * Allow start and end delimiter for tests to be configured
  * Fix file naming when building from a referance
  * Extend profiling

data/bin/roku

@@ -104,8 +104,8 @@ parser = OptionParser.new do |opts|
     options[:screens] = true
   end
 
-  opts.on("-m", "--monitor TYPE", "Command: run telnet to monitor roku log") do |m|
-    options[:monitor] = m
+  opts.on("-m", "--monitor [TYPE]", "Command: run telnet to monitor roku log") do |m|
+    options[:monitor] = m || "main"
   end
 
   opts.on("-u", "--update-manifest", "Command: update the manifest file") do

data/config.json.example

@@ -9,6 +9,7 @@
   },
   "projects": {
     "default": "<project id>",
+    "project_dir": "<optional parent directory for all projects>",
     "<project id>": {
       "directory": "<path/to/repo>",
       "folders": ["resources","source"],
@@ -26,6 +27,7 @@
     }
   },
   "keys": {
+    "key_dir": "<optional parent directory for all keys>",
     "key1": {
       "keyed_pkg": "<path/to/signed/package>",
       "password": "<password>"

data/lib/roku_builder/config_manager.rb

@@ -46,17 +46,29 @@ module RokuBuilder
     # @return [Hash] roku config object
     def self.get_config(config:, logger:)
       begin
-        config = JSON.parse(File.open(config).read, {symbolize_names: true})
+        config = {parent_config: config}
+        depth = 1
+        while config[:parent_config]
+          config_parent = JSON.parse(File.open(config[:parent_config]).read, {symbolize_names: true})
+          config.delete(:parent_config)
+          config.merge!(config_parent) {|key, v1, v2| v1}
+          depth += 1
+          if depth > 10
+            logger.fatal "Parent configs too deep."
+            return nil
+          end
+        end
         config[:devices][:default] = config[:devices][:default].to_sym
         config[:projects][:default] = config[:projects][:default].to_sym
         config[:projects].each_pair do |key,value|
           next if key == :default
+          next if key == :project_dir
           if value[:stage_method]
             value[:stage_method] = value[:stage_method].to_sym
           end
         end
         config[:projects].each_pair do |key, value|
-          unless key == :default
+          unless key == :default or key == :project_dir
             if value[:parent] and config[:projects][value[:parent].to_sym]
               new_value = config[:projects][value[:parent].to_sym]
               new_value = new_value.deep_merge value

data/lib/roku_builder/config_parser.rb

@@ -107,6 +107,9 @@ module RokuBuilder
       else
         project_config = config[:projects][options[:project].to_sym]
         return UNKNOWN_PROJECT unless project_config
+        if config[:projects][:project_dir]
+          project_config[:directory] = File.join(config[:projects][:project_dir], project_config[:directory])
+        end
         project_config[:stage_method] = :working if options[:working]
       end
       project_config
@@ -188,6 +191,9 @@ module RokuBuilder
         configs[:key] = configs[:project_config][:stages][stage][:key]
         if configs[:key].class == String
           configs[:key] = config[:keys][configs[:key].to_sym]
+          if config[:keys][:key_dir]
+            configs[:key][:keyed_pkg] = File.join(config[:keys][:key_dir], configs[:key][:keyed_pkg])
+          end
         end
       end
       if options[:package]

data/lib/roku_builder/config_validator.rb

@@ -44,7 +44,7 @@ module RokuBuilder
       end
       if config[:projects]
         config[:projects].each {|project,project_config|
-          next if project == :default
+          next if project == :default or project == :project_dir
           validate_project(codes: codes, project: project_config)
           if project_config[:stages]
             project_config[:stages].each {|_stage, stage_config|
@@ -54,7 +54,10 @@ module RokuBuilder
         }
       end
       if config[:keys]
-        config[:keys].each {|_key,key_config| validate_key(codes: codes, key: key_config) }
+        config[:keys].each {|key,key_config|
+          next if key == :key_dir
+          validate_key(codes: codes, key: key_config)
+        }
       end
       if config[:input_mapping]
         config[:input_mapping].each_value {|info| validate_mapping(codes: codes, mapping: info) }

data/lib/roku_builder/version.rb

@@ -2,5 +2,5 @@
 
 module RokuBuilder
   # Version of the RokuBuilder Gem
-  VERSION = "3.11.1"
+  VERSION = "3.12.0"
 end

data/rakefile

@@ -4,7 +4,7 @@ require 'rake'
 require 'rake/testtask'
 
 Rake::TestTask.new do |t|
-    t.test_files = Dir.glob('tests/roku_builder/*_test.rb')
+    t.test_files = Dir.glob('test/roku_builder/test_*.rb')
 end
 
 task(default: :test)

data/roku_builder.gemspec

@@ -37,5 +37,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "simplecov",         "~> 0.12"
   spec.add_development_dependency "coveralls",         "~> 0.8"
   spec.add_development_dependency "yard",              "~> 0.9"
-  spec.add_development_dependency "guard-livereload",  "~> 2.5"
+  spec.add_development_dependency "guard",             "~> 2.14"
+  spec.add_development_dependency "guard-minitest",    "~> 2.4"
 end

data/{tests/roku_builder/config_manager_test.rb → test/roku_builder/test_config_manager.rb}

@@ -18,6 +18,44 @@ class ConfigManagerTest < Minitest::Test
     assert_equal :project1, config[:projects][:default], :project1
   end
 
+  def test_config_manager_read_config_parent
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    io = Minitest::Mock.new
+    parent_config = good_config
+    parent_config[:projects].delete(:project1)
+    parent_config[:projects].delete(:project2)
+    child_config = good_config
+    child_config.delete(:devices)
+    child_config.delete(:keys)
+    child_config.delete(:input_mapping)
+    child_config[:parent_config] = "config/file/path"
+    io.expect(:read, child_config.to_json)
+    io.expect(:read, parent_config.to_json)
+    config = nil
+    File.stub(:open, io) do
+      config = RokuBuilder::ConfigManager.get_config(config: config_path, logger: logger)
+    end
+    io.verify
+    assert_equal "user",  config[:devices][:roku][:user]
+    assert_equal "<app name>", config[:projects][:project1][:app_name]
+  end
+
+  def test_config_manager_read_config_parent_too_deep
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    io = Minitest::Mock.new
+    parent_config = good_config
+    parent_config[:parent_config] = "config/file/path"
+    10.times {|_i| io.expect(:read, parent_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_manger_load_config
     logger = Logger.new("/dev/null")
     target_config = File.join(File.dirname(__FILE__), "test_files", "controller_test", "configure_test.json")

data/{tests/roku_builder/config_parser_test.rb → test/roku_builder/test_config_parser.rb}

@@ -76,6 +76,42 @@ class ConfigParserTest < Minitest::Test
     assert_equal "/dev/nuller", configs[:project_config][:directory]
   end
 
+  def test_manifest_config_project_directory
+    logger = Logger.new("/dev/null")
+    options = {}
+    config = good_config
+    config[:projects][:project_dir] = "/tmp"
+    config[:projects][:project1][:directory] = "project1"
+
+
+    code = nil
+    configs = nil
+
+    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+
+    assert_equal RokuBuilder::SUCCESS, code
+    assert_equal Hash, config.class
+    assert_equal "/tmp/project1", configs[:project_config][:directory]
+  end
+
+  def test_manifest_config_key_directory
+    logger = Logger.new("/dev/null")
+    options = {key: true, project: :project2}
+    config = good_config
+    config[:keys][:key_dir] = "/tmp"
+    config[:keys][:a][:keyed_pkg] = "a"
+
+
+    code = nil
+    configs = nil
+
+    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+
+    assert_equal RokuBuilder::SUCCESS, code
+    assert_equal Hash, config.class
+    assert_equal "/tmp/a", configs[:key][:keyed_pkg]
+  end
+
   def test_setup_sideload_config
     args = {
       configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},

data/{tests/roku_builder/controller_test.rb → test/roku_builder/test_controller.rb}

@@ -171,5 +171,19 @@ class ControllerTest < Minitest::Test
       logger.verify
     end
   end
+
+  def test_controller_validate_configs
+    configs = {out: {folder: "/out/folder"}}
+    exist = lambda {|args| assert_equal "/out/folder", args; true}
+    Dir.stub(:exist?, exist) do
+      assert_equal RokuBuilder::VALID, RokuBuilder::Controller.send(:validate_configs, configs: configs)
+    end
+
+    configs = {out: {folder: "/out/folder"}}
+    exist = lambda {|args| assert_equal "/out/folder", args; false}
+    Dir.stub(:exist?, exist) do
+      assert_equal RokuBuilder::MISSING_OUT_FOLDER, RokuBuilder::Controller.send(:validate_configs, configs: configs)
+    end
+  end
 end
 

data/{tests/roku_builder/controller_commands_test.rb → test/roku_builder/test_controller_commands.rb}

@@ -403,7 +403,6 @@ class ControllerCommandsTest < Minitest::Test
     stager = Minitest::Mock.new
 
     options = {print: 'title', config: "~/.roku_config.json"}
-    config = good_config
     configs = {stage_config: {}}
     code = nil
     scripter_config = {attribute: :title, configs: configs}
@@ -419,4 +418,35 @@ class ControllerCommandsTest < Minitest::Test
     assert_equal RokuBuilder::SUCCESS, code
     stager.verify
   end
+  def test_controller_commands_dostage
+    logger = Logger.new("/dev/null")
+    stager = Minitest::Mock.new
+
+    options = {dostage: true, config: "~/.roku_config.json"}
+    configs = {stage_config: {}}
+    code = nil
+    stager.expect(:stage, true)
+
+    RokuBuilder::Stager.stub(:new, stager) do
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
+    end
+    assert_equal true, code
+    stager.verify
+  end
+
+  def test_controller_commands_dounstage
+    logger = Logger.new("/dev/null")
+    stager = Minitest::Mock.new
+
+    options = {dounstage: true, config: "~/.roku_config.json"}
+    configs = {stage_config: {}}
+    code = nil
+    stager.expect(:unstage, true)
+
+    RokuBuilder::Stager.stub(:new, stager) do
+      code = RokuBuilder::Controller.send(:execute_commands, {options: options, configs: configs, logger: logger})
+    end
+    assert_equal true, code
+    stager.verify
+  end
 end

data/{tests/roku_builder/navigator_test.rb → test/roku_builder/test_navigator.rb}

@@ -156,7 +156,6 @@ class NavigatorTest < Minitest::Test
       init_params: {mappings: {}}
     }
 
-    input = nil
     navigator = RokuBuilder::Navigator.new(**device_config)
     STDIN.stub(:echo=, nil) do
       STDIN.stub(:raw!, nil) do
@@ -187,7 +186,6 @@ class NavigatorTest < Minitest::Test
       init_params: {mappings: {}}
     }
 
-    input = nil
     navigator = RokuBuilder::Navigator.new(**device_config)
     STDIN.stub(:echo=, nil) do
       STDIN.stub(:raw!, nil) do

data/test/roku_builder/test_ruby_git.rb

@@ -0,0 +1,82 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+require_relative "test_helper.rb"
+
+class GitTest < Minitest::Test
+
+  def test_stashes_pop
+    base = Minitest::Mock.new
+    lib = Minitest::Mock.new
+
+    index = 1
+    base.expect(:lib, lib)
+    lib.expect(:stash_pop, nil, [index])
+
+    Dir.mktmpdir do |dir|
+      git = Git.init(File.join(dir, "git"))
+      stashes = git.branch.stashes
+      stashes.instance_variable_set(:@base, base)
+      stashes.pop(index)
+    end
+
+    base.verify
+    lib.verify
+  end
+
+  def test_stashes_drop
+    base = Minitest::Mock.new
+    lib = Minitest::Mock.new
+
+    index = 1
+    base.expect(:lib, lib)
+    lib.expect(:stash_drop, nil, [index])
+
+    Dir.mktmpdir do |dir|
+      git = Git.init(File.join(dir, "git"))
+      stashes = git.branch.stashes
+      stashes.instance_variable_set(:@base, base)
+      stashes.drop(index)
+    end
+
+    base.verify
+    lib.verify
+  end
+
+  def test_lib_pop
+    lib = Git::Lib.new
+    command = lambda{|command_sent|
+      assert_equal "stash pop", command_sent
+    }
+    lib.stub(:command, command) do
+      lib.stash_pop
+    end
+
+    lib = Git::Lib.new
+    command = lambda{|command_sent, args|
+      assert_equal "stash pop", command_sent
+      assert_equal [1], args
+    }
+    lib.stub(:command, command) do
+      lib.stash_pop(1)
+    end
+  end
+
+  def test_lib_drop
+    lib = Git::Lib.new
+    command = lambda{|command_sent|
+      assert_equal "stash drop", command_sent
+    }
+    lib.stub(:command, command) do
+      lib.stash_drop
+    end
+
+    lib = Git::Lib.new
+    command = lambda{|command_sent, args|
+      assert_equal "stash drop", command_sent
+      assert_equal [1], args
+    }
+    lib.stub(:command, command) do
+      lib.stash_drop(1)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 3.11.1
+  version: 3.12.0
 platform: ruby
 authors:
 - greeneca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-27 00:00:00.000000000 Z
+date: 2017-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -235,19 +235,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: guard-livereload
+  name: guard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 description: Allows the user to easily sideload, package, deeplink, test, roku apps.
 email:
 - charles.greene@redspace.com
@@ -289,43 +303,44 @@ files:
 - lib/roku_builder/version.rb
 - rakefile
 - roku_builder.gemspec
-- tests/roku_builder/config_manager_test.rb
-- tests/roku_builder/config_parser_test.rb
-- tests/roku_builder/config_validator_test.rb
-- tests/roku_builder/controller_commands_test.rb
-- tests/roku_builder/controller_test.rb
-- tests/roku_builder/error_handler_test.rb
-- tests/roku_builder/inspector_test.rb
-- tests/roku_builder/keyer_test.rb
-- tests/roku_builder/linker_test.rb
-- tests/roku_builder/loader_test.rb
-- tests/roku_builder/manifest_manager_test.rb
-- tests/roku_builder/monitor_test.rb
-- tests/roku_builder/navigator_test.rb
-- tests/roku_builder/packager_test.rb
-- tests/roku_builder/profiler_test.rb
-- tests/roku_builder/scripter_test.rb
-- tests/roku_builder/stager_test.rb
-- tests/roku_builder/test_files/controller_config_test/valid_config.json
-- tests/roku_builder/test_files/controller_test/load_config_test.json
-- tests/roku_builder/test_files/controller_test/parent_config.json
-- tests/roku_builder/test_files/controller_test/valid_config.json
-- tests/roku_builder/test_files/loader_test/a
-- tests/roku_builder/test_files/loader_test/manifest
-- tests/roku_builder/test_files/loader_test/source/b
-- tests/roku_builder/test_files/loader_test/source/c/d
-- tests/roku_builder/test_files/manifest_manager_test/manifest_comments
-- 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
-- tests/roku_builder/test_files/stager_test/source/b
-- tests/roku_builder/test_files/stager_test/source/c/d
-- tests/roku_builder/test_helper.rb
-- tests/roku_builder/tester_test.rb
-- tests/roku_builder/util_test.rb
+- test/roku_builder/test_config_manager.rb
+- test/roku_builder/test_config_parser.rb
+- test/roku_builder/test_config_validator.rb
+- test/roku_builder/test_controller.rb
+- test/roku_builder/test_controller_commands.rb
+- test/roku_builder/test_error_handler.rb
+- test/roku_builder/test_files/controller_config_test/valid_config.json
+- test/roku_builder/test_files/controller_test/load_config_test.json
+- test/roku_builder/test_files/controller_test/parent_config.json
+- test/roku_builder/test_files/controller_test/valid_config.json
+- test/roku_builder/test_files/loader_test/a
+- test/roku_builder/test_files/loader_test/manifest
+- test/roku_builder/test_files/loader_test/source/b
+- test/roku_builder/test_files/loader_test/source/c/d
+- test/roku_builder/test_files/manifest_manager_test/manifest_comments
+- test/roku_builder/test_files/manifest_manager_test/manifest_template
+- test/roku_builder/test_files/manifest_manager_test/manifest_template_2
+- test/roku_builder/test_files/manifest_manager_test/test.zip
+- test/roku_builder/test_files/manifest_manager_test/updated_title_manifest
+- test/roku_builder/test_files/stager_test/a
+- test/roku_builder/test_files/stager_test/manifest
+- test/roku_builder/test_files/stager_test/source/b
+- test/roku_builder/test_files/stager_test/source/c/d
+- test/roku_builder/test_helper.rb
+- test/roku_builder/test_inspector.rb
+- test/roku_builder/test_keyer.rb
+- test/roku_builder/test_linker.rb
+- test/roku_builder/test_loader.rb
+- test/roku_builder/test_manifest_manager.rb
+- test/roku_builder/test_monitor.rb
+- test/roku_builder/test_navigator.rb
+- test/roku_builder/test_packager.rb
+- test/roku_builder/test_profiler.rb
+- test/roku_builder/test_ruby_git.rb
+- test/roku_builder/test_scripter.rb
+- test/roku_builder/test_stager.rb
+- test/roku_builder/test_tester.rb
+- test/roku_builder/test_util.rb
 homepage: ''
 licenses:
 - MIT
@@ -350,4 +365,42 @@ rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Build Tool for Roku Apps
-test_files: []
+test_files:
+- test/roku_builder/test_config_manager.rb
+- test/roku_builder/test_config_parser.rb
+- test/roku_builder/test_config_validator.rb
+- test/roku_builder/test_controller.rb
+- test/roku_builder/test_controller_commands.rb
+- test/roku_builder/test_error_handler.rb
+- test/roku_builder/test_files/controller_config_test/valid_config.json
+- test/roku_builder/test_files/controller_test/load_config_test.json
+- test/roku_builder/test_files/controller_test/parent_config.json
+- test/roku_builder/test_files/controller_test/valid_config.json
+- test/roku_builder/test_files/loader_test/a
+- test/roku_builder/test_files/loader_test/manifest
+- test/roku_builder/test_files/loader_test/source/b
+- test/roku_builder/test_files/loader_test/source/c/d
+- test/roku_builder/test_files/manifest_manager_test/manifest_comments
+- test/roku_builder/test_files/manifest_manager_test/manifest_template
+- test/roku_builder/test_files/manifest_manager_test/manifest_template_2
+- test/roku_builder/test_files/manifest_manager_test/test.zip
+- test/roku_builder/test_files/manifest_manager_test/updated_title_manifest
+- test/roku_builder/test_files/stager_test/a
+- test/roku_builder/test_files/stager_test/manifest
+- test/roku_builder/test_files/stager_test/source/b
+- test/roku_builder/test_files/stager_test/source/c/d
+- test/roku_builder/test_helper.rb
+- test/roku_builder/test_inspector.rb
+- test/roku_builder/test_keyer.rb
+- test/roku_builder/test_linker.rb
+- test/roku_builder/test_loader.rb
+- test/roku_builder/test_manifest_manager.rb
+- test/roku_builder/test_monitor.rb
+- test/roku_builder/test_navigator.rb
+- test/roku_builder/test_packager.rb
+- test/roku_builder/test_profiler.rb
+- test/roku_builder/test_ruby_git.rb
+- test/roku_builder/test_scripter.rb
+- test/roku_builder/test_stager.rb
+- test/roku_builder/test_tester.rb
+- test/roku_builder/test_util.rb