roku_builder 3.3.3 → 3.3.4

data/lib/roku_builder/tester.rb

@@ -5,6 +5,7 @@ module RokuBuilder
   # with other testing libraries
   class Tester < Util
 
+    # Initialize starting and ending regular expressions
     def init()
       @end_reg = /\*\*\*\*\* ENDING TESTS \*\*\*\*\*/
       @start_reg = /\*\*\*\*\* STARTING TESTS \*\*\*\*\*/

data/lib/roku_builder/util.rb

@@ -27,5 +27,44 @@ module RokuBuilder
     def init
       #Override in subclass
     end
+
+    # Generates a simpe Faraday connection with digest credentials
+    # @return [Faraday] The faraday connection
+    def simple_connection
+      Faraday.new(url: @url) do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    # Generates a multipart Faraday connection with digest credentials
+    # @param port [Integer] optional port to connect to
+    # @return [Faraday] The faraday connection
+    def multipart_connection(port: nil)
+      url = @url
+      url = "#{url}:#{port}" if port
+      Faraday.new(url: url) do |f|
+        f.headers['Content-Type'] = Faraday::Request::Multipart.mime_type
+        f.request :digest, @dev_username, @dev_password
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    # Parses a string into and options hash
+    # @param options [String] string of options in the format "a:b, c:d"
+    # @return [Hash] Options hash generated
+    def self.options_parse(options:)
+      parsed = {}
+      opts = options.split(/,\s*/)
+      opts.each do |opt|
+        opt = opt.split(":")
+        key = opt.shift.to_sym
+        value = opt.join(":")
+        parsed[key] = value
+      end
+      parsed
+    end
   end
 end

data/lib/roku_builder/version.rb

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

data/lib/roku_builder.rb

@@ -13,6 +13,7 @@ require "git"
 require 'json'
 
 require "roku_builder/controller"
+require "roku_builder/controller_commands"
 require "roku_builder/util"
 require "roku_builder/keyer"
 require "roku_builder/inspector"
@@ -22,11 +23,105 @@ require "roku_builder/linker"
 require "roku_builder/tester"
 require "roku_builder/manifest_manager"
 require "roku_builder/config_manager"
+require "roku_builder/config_validator"
+require "roku_builder/config_parser"
+require "roku_builder/error_handler"
 require "roku_builder/navigator"
 require "roku_builder/monitor"
 require "roku_builder/version"
 
 # Wrapping module for the Roku Builder Gem
 module RokuBuilder
-  # For documentation
+
+  ### Global Codes ###
+
+  # Success
+  SUCCESS         = 0
+
+  ### Validation Codes ###
+
+  # Valid Options
+  VALID           = 0
+
+  # Too many commands given
+  EXTRA_COMMANDS  = 1
+
+  # No commands given
+  NO_COMMANDS     = 2
+
+  # Too many source options given
+  EXTRA_SOURCES   = 3
+
+  # No source options given
+  NO_SOURCE       = 4
+
+  # Incorrect use of current option
+  BAD_CURRENT     = 5
+
+  # No deeplink options supplied for deeplink
+  BAD_DEEPLINK    = 6
+
+  # Incorrect use of the in option
+  BAD_IN_FILE     = 7
+
+
+
+  ### Device Codes ###
+
+  # The default device is offline switched to a secondary device
+  CHANGED_DEVICE = -1
+
+  # Device is online
+  GOOD_DEVICE = 0
+
+  # User defined device was not online
+  BAD_DEVICE = 1
+
+  # No configured devices were online
+  NO_DEVICES = 2
+
+
+  ### Execute Codes ###
+
+  # Config has deplicated options
+  DEPRICATED_CONFIG  = -1
+
+  # Tring to overwrite existing config file
+  CONFIG_OVERWRITE   = 1
+
+  # Missing config file
+  MISSING_CONFIG     = 2
+
+  # Invalid config file
+  INVALID_CONFIG     = 3
+
+  # Missing manifest file
+  MISSING_MANIFEST   = 4
+
+  # Unknow device given
+  UNKNOWN_DEVICE     = 5
+
+  # Unknown project given
+  UNKNOWN_PROJECT    = 6
+
+  # Unknown stage given
+  UNKNOWN_STAGE      = 7
+
+
+  ### Execute Codes ###
+
+  # Failed to sideload app
+  FAILED_SIDELOAD    = 8
+
+  # Failed to sign app
+  FAILED_SIGNING     = 9
+
+  # Failed to deeplink to app
+  FAILED_DEEPLINKING = 10
+
+  # Failed to send navigation command
+  FAILED_NAVIGATING  = 11
+
+  # Failed to capture screen
+  FAILED_SCREENCAPTURE = 12
 end

data/roku_builder.gemspec

@@ -20,19 +20,20 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = "~> 2.2"
 
-  spec.add_dependency "rubyzip",             "~> 1.1"
+  spec.add_dependency "rubyzip",             "~> 1.2"
   spec.add_dependency "faraday",             "~> 0.9"
   spec.add_dependency "faraday-digestauth",  "~> 0.2"
-  spec.add_dependency "git",                 "~> 1.2.9"
+  spec.add_dependency "git",                 "~> 1.3"
   spec.add_dependency "net-ping",            "~> 1.7"
 
   spec.add_development_dependency "bundler",           "~> 1.7"
-  spec.add_development_dependency "rake",              "~> 10.0"
-  spec.add_development_dependency "byebug",            "~> 3.5"
+  spec.add_development_dependency "rake",              "~> 11.1"
+  spec.add_development_dependency "byebug",            "~> 8.2"
   spec.add_development_dependency "minitest",          "~> 5.8"
   spec.add_development_dependency "minitest-autotest", "~> 1.0"
   spec.add_development_dependency "minitest-server",   "~> 1.0"
   spec.add_development_dependency "simplecov",         "~> 0.11"
+  spec.add_development_dependency "coveralls",         "~> 0.8"
   spec.add_development_dependency "yard",              "~> 0.8.7"
   spec.add_development_dependency "guard-livereload",  "~> 2.5"
 end

data/tests/roku_builder/config_manager_test.rb

@@ -16,6 +16,71 @@ class ConfigManagerTest < Minitest::Test
     assert_equal :project1, config[:projects][:default], :project1
   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")
+    File.delete(target_config) if File.exist?(target_config)
+
+    code = nil
+    config = nil
+    configs = nil
+    # Test Missing Config
+    options = {validate: true, config: target_config}
+    code = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+    assert_equal RokuBuilder::MISSING_CONFIG, code
+
+    FileUtils.cp(File.join(File.dirname(target_config), "valid_config.json"), target_config)
+
+    # Test Invalid config json
+    options = {validate: true, config: target_config}
+    RokuBuilder::ConfigManager.stub(:get_config, nil) do
+      code = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+    end
+    assert_equal RokuBuilder::INVALID_CONFIG, code
+    assert_nil config
+    assert_nil configs
+
+    # Test Invalid config
+    options = {validate: true, config: target_config}
+    RokuBuilder::ConfigValidator.stub(:validate_config, [1]) do
+      code, config, configs = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+    end
+    assert_equal RokuBuilder::INVALID_CONFIG, 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
+      code, config, configs = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+    end
+    assert_equal RokuBuilder::DEPRICATED_CONFIG, code
+    assert_equal Hash, config.class
+    assert_equal Hash, configs.class
+
+    # Test valid Config
+    options = {validate: true, stage: 'production', config: target_config}
+    RokuBuilder::ConfigValidator.stub(:validate_config, [0]) do
+      code, config, configs = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+    end
+    assert_equal RokuBuilder::SUCCESS, code
+    assert_equal Hash, config.class
+    assert_equal Hash, configs.class
+
+    # Test valid config in pwd
+    options = {validate: true, stage: 'production', config: target_config}
+    RokuBuilder::ConfigValidator.stub(:validate_config, [0]) do
+      RokuBuilder::Controller.stub(:system, "/dev/null/test") do
+        code, config, configs = RokuBuilder::ConfigManager.load_config(options: options, logger: logger)
+      end
+    end
+    assert_equal RokuBuilder::SUCCESS, code
+    assert_equal Hash, config.class
+    assert_equal Hash, configs.class
+
+    File.delete(target_config) if File.exist?(target_config)
+  end
+
   def test_config_manager_read_invalid_config
     logger = Logger.new("/dev/null")
     config_path = "config/file/path"
@@ -29,191 +94,14 @@ class ConfigManagerTest < Minitest::Test
     assert_nil config
   end
 
-  def test_config_manager_validate_devices
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [1], codes
-  end
-
-  def test_config_manager_validate_devices_default
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:default] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [2], codes
-  end
-
-  def test_config_manager_validate_devices_default_is_symbol
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:default] = "bad"
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [3], codes
-  end
-
-  def test_config_manager_validate_device_ip
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:ip] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [7], codes
-  end
-
-  def test_config_manager_validate_device_ip_empty
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:ip] = ""
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [7], codes
-  end
-
-  def test_config_manager_validate_device_ip_default_value
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:ip] = "xxx.xxx.xxx.xxx"
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [7], codes
-  end
-
-  def test_config_manager_validate_device_user
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:user] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [8], codes
-  end
-
-  def test_config_manager_validate_device_user_empty
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:user] = ""
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [8], codes
-  end
-
-  def test_config_manager_validate_device_user_default_value
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:user] = "<username>"
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [8], codes
-  end
-
-  def test_config_manager_validate_device_password
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:password] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [9], codes
-  end
-
-  def test_config_manager_validate_device_password_empty
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:password] = ""
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [9], codes
-  end
-
-  def test_config_manager_validate_device_password_default_value
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:devices][:roku][:password] = "<password>"
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [9], codes
-  end
-
-  def test_config_manager_validate_projects
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [4], codes
-  end
-
-  def test_config_manager_validate_projects_default
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:default] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [5], codes
-  end
-
-  def test_config_manager_validate_projects_default_default_value
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:default] = "<project id>".to_sym
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [5], codes
-  end
-
-  def test_config_manager_validate_projects_default_is_symbol
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:default] = "project_id"
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [6], codes
-  end
-
-  def test_config_manager_validate_project_app_name
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:project1][:app_name] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [10], codes
-  end
-
-  def test_config_manager_validate_project_directory
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:project1][:directory] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [11], codes
-  end
-
-  def test_config_manager_validate_project_folders
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:project1][:folders] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [12], codes
-  end
-
-  def test_config_manager_validate_project_folders_is_array
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:project1][:folders] = "Folders"
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [13], codes
-  end
-
-  def test_config_manager_validate_project_files
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:project1][:files] = nil
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [14], codes
-  end
-
-  def test_config_manager_validate_project_filess_is_array
-    logger = Logger.new("/dev/null")
-    config = good_config
-    config[:projects][:project1][:files] = "Files"
-    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
-    assert_equal [15], codes
-  end
-
   def test_config_manager_edit_ip
     logger = Logger.new("/dev/null")
     config_path = "config/file/path"
     args = {
       config: config_path,
-      options: "ip:192.168.0.200",
-      device: :roku,
-      project: nil,
-      stage: nil,
+      options: {edit_params: "ip:192.168.0.200",
+        device: :roku,
+      },
       logger: logger
     }
     new_config = good_config
@@ -223,7 +111,6 @@ class ConfigManagerTest < Minitest::Test
     io.expect(:read, good_config.to_json)
     io.expect(:write, nil, [JSON.pretty_generate(new_config)])
     io.expect(:close, nil)
-    config = nil
     File.stub(:open, io) do
       RokuBuilder::ConfigManager.edit_config(**args)
     end
@@ -235,10 +122,7 @@ class ConfigManagerTest < Minitest::Test
     config_path = "config/file/path"
     args = {
       config: config_path,
-      options: "user:new_user",
-      device: "roku",
-      project: nil,
-      stage: nil,
+      options: {edit_params: "user:new_user"},
       logger: logger
     }
     new_config = good_config
@@ -248,7 +132,6 @@ class ConfigManagerTest < Minitest::Test
     io.expect(:read, good_config.to_json)
     io.expect(:write, nil, [JSON.pretty_generate(new_config)])
     io.expect(:close, nil)
-    config = nil
     File.stub(:open, io) do
       RokuBuilder::ConfigManager.edit_config(**args)
     end
@@ -260,10 +143,7 @@ class ConfigManagerTest < Minitest::Test
     config_path = "config/file/path"
     args = {
       config: config_path,
-      options: "password:new_password",
-      device: nil,
-      project: nil,
-      stage: nil,
+      options: {edit_params: "password:new_password"},
       logger: logger
     }
     new_config = good_config
@@ -273,7 +153,6 @@ class ConfigManagerTest < Minitest::Test
     io.expect(:read, good_config.to_json)
     io.expect(:write, nil, [JSON.pretty_generate(new_config)])
     io.expect(:close, nil)
-    config = nil
     File.stub(:open, io) do
       RokuBuilder::ConfigManager.edit_config(**args)
     end
@@ -285,10 +164,9 @@ class ConfigManagerTest < Minitest::Test
     config_path = "config/file/path"
     args = {
       config: config_path,
-      options: "app_name:new name",
-      device: nil,
-      project: :project1,
-      stage: nil,
+      options: {edit_params: "app_name:new name",
+        project: :project1
+      },
       logger: logger
     }
     new_config = good_config
@@ -298,7 +176,6 @@ class ConfigManagerTest < Minitest::Test
     io.expect(:read, good_config.to_json)
     io.expect(:write, nil, [JSON.pretty_generate(new_config)])
     io.expect(:close, nil)
-    config = nil
     File.stub(:open, io) do
       RokuBuilder::ConfigManager.edit_config(**args)
     end
@@ -310,10 +187,9 @@ class ConfigManagerTest < Minitest::Test
     config_path = "config/file/path"
     args = {
       config: config_path,
-      options: "directory:new/directory/path",
-      device: nil,
-      project: "project1",
-      stage: nil,
+      options: {edit_params: "directory:new/directory/path",
+        project: :project1
+      },
       logger: logger
     }
     new_config = good_config
@@ -323,7 +199,6 @@ class ConfigManagerTest < Minitest::Test
     io.expect(:read, good_config.to_json)
     io.expect(:write, nil, [JSON.pretty_generate(new_config)])
     io.expect(:close, nil)
-    config = nil
     File.stub(:open, io) do
       RokuBuilder::ConfigManager.edit_config(**args)
     end
@@ -335,10 +210,9 @@ class ConfigManagerTest < Minitest::Test
     config_path = "config/file/path"
     args = {
       config: config_path,
-      options: "branch:new-branch",
-      device: nil,
-      project: nil,
-      stage: :production,
+      options: {edit_params: "branch:new-branch",
+        stage: :production
+      },
       logger: logger
     }
     new_config = good_config
@@ -348,7 +222,6 @@ class ConfigManagerTest < Minitest::Test
     io.expect(:read, good_config.to_json)
     io.expect(:write, nil, [JSON.pretty_generate(new_config)])
     io.expect(:close, nil)
-    config = nil
     File.stub(:open, io) do
       RokuBuilder::ConfigManager.edit_config(**args)
     end
@@ -360,10 +233,7 @@ class ConfigManagerTest < Minitest::Test
     config_path = "config/file/path"
     args = {
       config: config_path,
-      options: "branch:new-branch",
-      device: nil,
-      project: nil,
-      stage: nil,
+      options: {edit_params: "branch:new-branch"},
       logger: logger
     }
     new_config = good_config
@@ -373,41 +243,10 @@ class ConfigManagerTest < Minitest::Test
     io.expect(:read, good_config.to_json)
     io.expect(:write, nil, [JSON.pretty_generate(new_config)])
     io.expect(:close, nil)
-    config = nil
     File.stub(:open, io) do
       RokuBuilder::ConfigManager.edit_config(**args)
     end
     io.verify
   end
 
-  def good_config
-    {
-      devices: {
-        default: :roku,
-        roku: {
-          ip: "192.168.0.100",
-          user: "user",
-          password: "password"
-        }
-      },
-      projects: {
-        default: :project1,
-        project1: {
-          directory: "<path/to/repo>",
-          folders: ["resources","source"],
-          files: ["manifest"],
-          app_name: "<app name>",
-          stages:{
-            production: {
-              branch: "production",
-              key: {
-                keyed_pkg: "<path/to/signed/pkg>",
-                password: "<password for pkg>"
-              }
-            }
-          }
-        }
-      }
-    }
-  end
 end

data/tests/roku_builder/{controller_config_test.rb → config_parser_test.rb}

@@ -1,6 +1,6 @@
 require_relative "test_helper.rb"
 
-class ControllerConfigTest < Minitest::Test
+class ConfigParserTest < Minitest::Test
   def test_manifest_config
     logger = Logger.new("/dev/null")
     options = {
@@ -9,11 +9,11 @@ class ControllerConfigTest < Minitest::Test
       update_manifest: false,
       fetch: false,
     }
-    code, config, configs = RokuBuilder::Controller.load_config(options: options, logger: logger)
+    config = good_config
+    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
 
+    assert_equal RokuBuilder::SUCCESS, code
+    assert_equal Hash, config.class
     assert_equal "/dev/null", configs[:manifest_config][:root_dir]
-    assert_equal logger, configs[:manifest_config][:logger]
-
-
   end
 end