roku_builder 3.12.8 → 3.13.0

data/lib/roku_builder/stager.rb

@@ -5,11 +5,11 @@ module RokuBuilder
   # Change stage of roku application
   class Stager
 
-    def initialize(key: nil, method:, root_dir: nil, logger:)
+    def initialize(key: nil, method:, root_dir: nil)
       @method = method
       @key = key
       @root_dir = root_dir
-      @logger = logger
+      @logger = Logger.instance
       @stage_success = true
       @stash_key = "roku-builder-temp-stash"
     end

data/lib/roku_builder/tester.rb

@@ -8,9 +8,16 @@ module RokuBuilder
   class Tester < Util
 
     # Initialize starting and ending regular expressions
-    def init()
-      @end_reg = /\*\*\*\*\* ENDING TESTS \*\*\*\*\*/
-      @start_reg = /\*\*\*\*\* STARTING TESTS \*\*\*\*\*/
+    def init(root_dir:)
+      @root_dir = root_dir
+      @end_reg = /\*+\s*End testing\s*\*+/
+      @start_reg = /\*+\s*Start testing\s*\*+/
+      @test_logger = ::Logger.new(STDOUT)
+      @test_logger.formatter = proc {|_severity, _datetime, _progname, msg|
+        "%s\n\r" % [msg]
+      }
+      @in_tests = false
+      @logs = []
     end
 
     # Run tests and report results
@@ -21,15 +28,21 @@ module RokuBuilder
         'Port' => 8085
       }
 
+      @device_config[:init_params] = {
+        root_dir: @root_dir
+      }
       loader = Loader.new(**@device_config)
       connection = Net::Telnet.new(telnet_config)
       code, _build_version = loader.sideload(**sideload_config)
-
       if code == SUCCESS
-        in_tests = false
+        @device_config[:init_params] = nil
+        linker = Linker.new(**@device_config)
+        linker.launch(options: "RunTests:true")
+
         connection.waitfor(@end_reg) do |txt|
-          in_tests = handle_text(txt: txt, in_tests: in_tests)
+          handle_text(txt: txt)
         end
+        print_logs
         connection.puts("cont\n")
       end
     end
@@ -40,13 +53,46 @@ module RokuBuilder
     # @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:)
+    def handle_text(txt:)
+      check_for_used_connection(txt: 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 =~ @start_reg
+        check_for_end(line: line)
+        @logs.push line if @in_tests
+        check_for_start(line: line)
+      end
+    end
+
+    def check_for_used_connection(txt:)
+      if txt =~ /connection already in use/
+        raise IOError, "Telnet Connection Already in Use"
+      end
+    end
+
+    def check_for_end(line:)
+      if line =~ @end_reg
+        @in_tests = false
+        breakline = line.gsub(/./, '*')
+        @logs.push line
+        @logs.push breakline
+        @logs.push breakline
+      end
+    end
+
+    def check_for_start(line:)
+      if line =~ @start_reg
+        @logs = []
+        @in_tests = true
+        breakline = line.gsub(/./, '*')
+        @logs.push breakline
+        @logs.push breakline
+        @logs.push line
+      end
+    end
+
+    def print_logs
+      @logs.each do |log|
+        @test_logger.unknown log
       end
-      in_tests
     end
   end
 end

data/lib/roku_builder/util.rb

@@ -11,18 +11,17 @@ module RokuBuilder
     # @param ip [String] IP address of roku device
     # @param user [String] Username for roku device
     # @param password [String] Password for roku device
-    def initialize(ip:, user:, password:, logger:, init_params: nil)
+    def initialize(ip:, user:, password:, init_params: nil)
+      @logger = Logger.instance
       @device_config = {
         ip: ip,
         user: user,
-        password: password,
-        logger: logger
+        password: password
       }
       @roku_ip_address = ip
       @dev_username = user
       @dev_password = password
       @url = "http://#{@roku_ip_address}"
-      @logger = logger
       if init_params
         init(**init_params)
       else

data/lib/roku_builder/version.rb

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

data/roku_builder.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Build Tool for Roku Apps}
   spec.description   = %q{Allows the user to easily sideload, package, deeplink, test, roku apps.}
   spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.license       = "Apache-2.0"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "net-ping",            "~> 2.0"
   spec.add_dependency "net-telnet",          "~> 0.1"
   spec.add_dependency "nokogiri",            "~> 1.7"
+  spec.add_dependency "win32-security",      "~> 0.5" # For windows compatibility
 
   spec.add_development_dependency "bundler",           "~> 1.7"
   spec.add_development_dependency "rake",              "~> 12.0"

data/test/roku_builder/test_config.rb

@@ -0,0 +1,168 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+require_relative "test_helper.rb"
+
+module RokuBuilder
+  class ConfigTest < Minitest::Test
+
+    def test_config_init
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+    end
+
+    def test_config_expand_path
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      options[:config].sub!(/#{File.expand_path("~")}/, "~")
+        config = Config.new(options: options)
+      config.load
+    end
+
+    def test_missing_config
+      options = build_options({config: File.join(test_files_path(ConfigTest), "missing.json"), validate: true})
+      assert_raises ArgumentError do
+        config = Config.new(options: options)
+        config.load
+      end
+    end
+
+    def test_invalid_config
+      options = build_options({config: File.join(test_files_path(ConfigTest), "bad.json"), validate: true})
+      assert_raises InvalidConfig do
+        config = Config.new(options: options)
+        config.load
+        config.validate
+      end
+    end
+
+    def test_non_json_config
+      options = build_options({config: File.join(test_files_path(ConfigTest), "non_json.json"), validate: true})
+      assert_raises InvalidConfig do
+        config = Config.new(options: options)
+        config.load
+      end
+    end
+
+    def test_config_parse
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      assert_equal Hash, config.parsed.class
+    end
+
+    def test_config_read
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      assert_equal :roku, config.raw[:devices][:default]
+      assert_equal :p1, config.raw[:projects][:default]
+    end
+
+    def test_config_read_parent
+      options = build_options({config: File.join(test_files_path(ConfigTest), "child.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      assert_equal :roku, config.raw[:devices][:default]
+      assert_equal :p1, config.raw[:projects][:default]
+    end
+
+    def test_config_read_parent
+      options = build_options({config: File.join(test_files_path(ConfigTest), "parent_projects.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      assert_equal "app", config.raw[:projects][:p1][:app_name]
+    end
+
+    def test_config_edit
+      orginal = File.join(test_files_path(ConfigTest), "config.json")
+      tmp = File.join(test_files_path(ConfigTest), "tmpconfig.json")
+      FileUtils.cp(orginal, tmp)
+      options = build_options({config: tmp, edit_params: "ip:123.456.789", validate: true})
+      config = Config.new(options: options)
+      config.load
+      config.edit
+      options = build_options({config: tmp, validate: true})
+      config = Config.new(options: options)
+      config.load
+      assert_equal "123.456.789", config.raw[:devices][:roku][:ip]
+      FileUtils.rm(tmp)
+    end
+
+    def test_config_update_package
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), package: true, stage: :production, set_stage: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      options[:build_version] = "BUILDVERSION"
+      config.update
+      assert_equal "app - production - BUILDVERSION", config.parsed[:package_config][:app_name_version]
+      assert_equal "/tmp/app_production_BUILDVERSION", config.parsed[:package_config][:out_file]
+      assert_equal "/tmp/app_production_BUILDVERSION", config.parsed[:inspect_config][:pkg]
+    end
+
+    def test_config_update_build
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), build: true, stage: :production, set_stage: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      options[:build_version] = "BUILDVERSION"
+      config.update
+      assert_equal "/tmp/app_production_BUILDVERSION", config.parsed[:build_config][:out_file]
+    end
+
+    def test_config_update_sideload
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), sideload: true, stage: :production, set_stage: true, out: "/tmp2"})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      options[:build_version] = "BUILDVERSION"
+      config.update
+      assert_equal "/tmp2/app_production_BUILDVERSION", config.parsed[:sideload_config][:out_file]
+    end
+
+    def test_config_configure_creation
+      target_config = File.join(test_files_path(ConfigTest), "configure_test.json")
+      options = build_options({config: target_config, configure: true})
+      File.delete(target_config) if File.exist?(target_config)
+      refute File.exist?(target_config)
+      config = Config.new(options: options)
+      config.configure
+      assert File.exist?(target_config)
+      File.delete(target_config) if File.exist?(target_config)
+    end
+
+    def test_config_configure_edit_params
+      target_config = File.join(test_files_path(ConfigTest), "configure_test.json")
+      options = build_options({
+        config: target_config,
+        configure: true,
+        edit_params: "ip:111.222.333.444"
+      })
+      File.delete(target_config) if File.exist?(target_config)
+      refute File.exist?(target_config)
+      config = Config.new(options: options)
+      config.configure
+      assert File.exist?(target_config)
+      assert_equal "111.222.333.444", config.raw[:devices][config.raw[:devices][:default]][:ip]
+      File.delete(target_config) if File.exist?(target_config)
+    end
+
+    def test_config_configure_edit_params
+      target_config = File.join(test_files_path(ConfigTest), "configure_test.json")
+      options = build_options({
+        config: target_config,
+        configure: true
+      })
+      File.delete(target_config) if File.exist?(target_config)
+      refute File.exist?(target_config)
+      config = Config.new(options: options)
+      config.configure
+      assert File.exist?(target_config)
+      assert_raises InvalidOptions do
+        config.configure
+      end
+      File.delete(target_config) if File.exist?(target_config)
+    end
+  end
+end

data/test/roku_builder/test_config_parser.rb

@@ -2,438 +2,391 @@
 
 require_relative "test_helper.rb"
 
-class ConfigParserTest < 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,
-      sideload: true
-    }
-    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 "/tmp", configs[:manifest_config][:root_dir]
-  end
-
-  def test_manifest_config_in
-    logger = Logger.new("/dev/null")
-    options = {
-      config: File.expand_path(File.join(File.dirname(__FILE__), "test_files", "controller_config_test", "valid_config.json")),
-      in: "/dev/null/infile",
-      update_manifest: false,
-      fetch: false,
-      sideload: true
-    }
-    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/infile", configs[:manifest_config][:root_dir]
-    assert_equal :in, configs[:stage_config][:method]
-  end
-
-  def test_manifest_config_in_expand
-    logger = Logger.new("/dev/null")
-    options = {
-      config: File.expand_path(File.join(File.dirname(__FILE__), "test_files", "controller_config_test", "valid_config.json")),
-      in: "./infile",
-      update_manifest: false,
-      fetch: false,
-      sideload: true
-    }
-    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 File.join(Dir.pwd, "infile"), configs[:manifest_config][:root_dir]
-    assert_equal :in, configs[:stage_config][:method]
-  end
-
-  def test_manifest_config_current
-    logger = Logger.new("/dev/null")
-    options = {
-      config: File.expand_path(File.join(File.dirname(__FILE__), "test_files", "controller_config_test", "valid_config.json")),
-      current: true,
-      update_manifest: false,
-      fetch: false,
-      sideload: true
-    }
-    code, configs = nil
-    config = good_config
-    Pathname.stub(:pwd, "/dev/null/infile") do
-      File.stub(:exist?, true) do
-        code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
-      end
+module RokuBuilder
+  class ConfigParserTest < Minitest::Test
+    def test_manifest_config
+      options = build_options({
+        sideload: true,
+        working: true
+      })
+      config = good_config
+      configs = ConfigParser.parse(options: options, config: config)
+
+      assert_equal Hash, config.class
+      assert_equal "/tmp", configs[:manifest_config][:root_dir]
     end
 
-    assert_equal RokuBuilder::SUCCESS, code
-    assert_equal Hash, config.class
-    assert_equal "/dev/null/infile", configs[:manifest_config][:root_dir]
-    assert_equal :current, configs[:stage_config][:method]
-  end
-
-  def test_setup_project_config_current
-    args = {
-      config: {},
-      options: {current: true }
-    }
-    project = {}
-    File.stub(:exist?, true) do
-      project = RokuBuilder::ConfigParser.send(:setup_project_config, **args)
-    end
-    assert_equal Pathname.pwd.to_s, project[:directory]
-    assert_equal :current, project[:stage_method]
-    assert_nil project[:folders]
-    assert_nil project[:files]
-  end
-
-  def test_setup_project_config_good_project_dir
-    config = good_config
-    args = {
-      config: config,
-      options: {sideload: true, project: :project1}
-    }
-    project = {}
-    File.stub(:exist?, true) do
-      project = RokuBuilder::ConfigParser.send(:setup_project_config, **args)
-    end
-    refute_equal RokuBuilder::BAD_PROJECT_DIR, project
-  end
+    def test_manifest_config_in
+      options = build_options({
+        in: "/dev/null/infile",
+        sideload: true
+      })
+      config = good_config
+      configs = ConfigParser.parse(options: options, config: config)
+
+      assert_equal Hash, config.class
+      assert_equal "/dev/null/infile", configs[:manifest_config][:root_dir]
+      assert_equal :in, configs[:stage_config][:method]
+    end
 
-  def test_setup_project_config_bad_project_dir
-    config = good_config
-    config[:projects][:project1][:directory] = "/dev/null"
-    args = {
-      config: config,
-      options: {sideload: true, project: :project1}
-    }
-    project = {}
-    File.stub(:exist?, true) do
-      project = RokuBuilder::ConfigParser.send(:setup_project_config, **args)
-    end
-    assert_equal RokuBuilder::BAD_PROJECT_DIR, project
-  end
+    def test_manifest_config_in_expand
+      options = build_options({
+        in: "./infile",
+        sideload: true
+      })
+      config = good_config
+      configs = ConfigParser.parse(options: options, config: config)
+
+      assert_equal Hash, config.class
+      assert_equal File.join(Dir.pwd, "infile"), configs[:manifest_config][:root_dir]
+      assert_equal :in, configs[:stage_config][:method]
+    end
 
-  def test_setup_project_config_bad_child_project_dir
-    config = good_config
-    config[:projects][:project_dir] = "/tmp"
-    config[:projects][:project1][:directory] = "bad"
-    args = {
-      config: config,
-      options: {sideload: true, project: :project1}
-    }
-    project = {}
-    File.stub(:exist?, true) do
-      project = RokuBuilder::ConfigParser.send(:setup_project_config, **args)
-    end
-    assert_equal RokuBuilder::BAD_PROJECT_DIR, project
-  end
+    def test_manifest_config_current
+      options = build_options({
+        current: true,
+        sideload: true
+      })
+      configs = nil
+      config = good_config
+      Pathname.stub(:pwd, "/dev/null/infile") do
+        File.stub(:exist?, true) do
+          configs = ConfigParser.parse(options: options, config: config)
+        end
+      end
 
-  def test_setup_project_config_bad_parent_project_dir
-    config = good_config
-    config[:projects][:project_dir] = "/bad"
-    config[:projects][:project1][:directory] = "good"
-    args = {
-      config: config,
-      options: {sideload: true, project: :project1}
-    }
-    project = {}
-    File.stub(:exist?, true) do
-      project = RokuBuilder::ConfigParser.send(:setup_project_config, **args)
-    end
-    assert_equal RokuBuilder::BAD_PROJECT_DIR, project
-  end
+      assert_equal Hash, config.class
+      assert_equal "/dev/null/infile", configs[:manifest_config][:root_dir]
+      assert_equal :current, configs[:stage_config][:method]
+    end
 
-  def test_setup_stage_config_script
-    args = {
-      configs: {project_config: {directory: "/tmp", stage_method: :script, stages: {production: {script: "script"}}}},
-      options: {stage: "production", sideload: true},
-      logger: Logger.new("/dev/null")
-    }
-    config = RokuBuilder::ConfigParser.send(:setup_stage_config, **args)[0]
-    assert_equal args[:configs][:project_config][:stages][:production][:script], config[:key]
-  end
+    def test_setup_project_config_bad_project
+      config = good_config
+      options = build_options({sideload: true, project: :project3, set_stage: true})
+      assert_raises ParseError do
+        File.stub(:exist?, true) do
+          ConfigParser.parse(options: options, config: config)
+        end
+      end
+    end
 
-  def test_setup_stage_config_git_ref
-    args = {
-      configs: {project_config: {directory: "/tmp", stage_method: :git, }},
-      options: {stage: "production", ref: "git-ref", sideload: true},
-      logger: Logger.new("/dev/null")
-    }
-    config = RokuBuilder::ConfigParser.send(:setup_stage_config, **args)[0]
-    assert_equal args[:options][:ref], config[:key]
-  end
+    def test_setup_project_config_current
+      options = build_options({ sideload: true, current: true })
+      config = good_config
+      configs = nil
+      File.stub(:exist?, true) do
+        configs = ConfigParser.parse(options: options, config: config)
+      end
+      project = configs[:project_config]
+      assert_equal Pathname.pwd.to_s, project[:directory]
+      assert_equal :current, project[:stage_method]
+      assert_nil project[:folders]
+      assert_nil project[:files]
+    end
 
-  def test_manifest_config_project_select
-    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,
-      sideload: true
-    }
-    config = good_config
+    def test_setup_project_config_good_project_dir
+      config = good_config
+      options = build_options({sideload: true, project: :project1, set_stage: true})
+      File.stub(:exist?, true) do
+        ConfigParser.parse(options: options, config: config)
+      end
+    end
 
-    code = nil
-    configs = nil
+    def test_setup_project_config_bad_project_dir
+      config = good_config
+      config[:projects][:project1][:directory] = "/dev/null"
+      options = build_options({sideload: true, project: :project1, working: true})
+      assert_raises ParseError do
+        File.stub(:exist?, true) do
+          ConfigParser.parse(options: options, config: config)
+        end
+      end
+    end
 
-    Pathname.stub(:pwd, Pathname.new("/dev/nuller")) do
-      code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+    def test_setup_project_config_bad_child_project_dir
+      config = good_config
+      config[:projects][:project_dir] = "/tmp"
+      config[:projects][:project1][:directory] = "bad"
+      options = build_options({sideload: true, project: :project1, working: true})
+      assert_raises ParseError do
+        File.stub(:exist?, true) do
+          ConfigParser.parse(options: options, config: config)
+        end
+      end
     end
 
-    assert_equal RokuBuilder::SUCCESS, code
-    assert_equal Hash, config.class
-    assert_equal "/tmp", configs[:project_config][:directory]
-  end
+    def test_setup_project_config_bad_parent_project_dir
+      config = good_config
+      config[:projects][:project_dir] = "/bad"
+      config[:projects][:project1][:directory] = "good"
+      options = build_options({sideload: true, project: :project1, set_stage: true})
+      assert_raises ParseError do
+        File.stub(:exist?, true) do
+          ConfigParser.parse(options: options, config: config)
+        end
+      end
+    end
 
-  def test_manifest_config_project_directory
-    logger = Logger.new("/dev/null")
-    options = {
-      sideload: true
-    }
-    config = good_config
-    config[:projects][:project_dir] = "/tmp"
-    config[:projects][:project1][:directory] = "project1"
-    config[:projects][:project2][:directory] = "project2"
+    def test_setup_stage_config_bad_stage
+      config = good_config
+      options = build_options({sideload: true, project: :project1, stage: :bad, set_stage: true})
+      assert_raises ParseError do
+        File.stub(:exist?, true) do
+          ConfigParser.parse(options: options, config: config)
+        end
+      end
+    end
 
+    def test_setup_stage_config_bad_method
+      config = good_config
+      config[:projects][:project1][:stage_method] = :bad
+      options = build_options({sideload: true, project: :project1, set_stage: true})
+      assert_raises ParseError do
+        File.stub(:exist?, true) do
+          ConfigParser.parse(options: options, config: config)
+        end
+      end
+    end
 
-    code = nil
-    configs = nil
+    def test_setup_stage_config_missing_method
+      config = good_config
+      config[:projects][:project1][:stage_method] = nil
+      options = build_options({sideload: true, project: :project1, set_stage: true})
+      assert_raises ParseError do
+        File.stub(:exist?, true) do
+          ConfigParser.parse(options: options, config: config)
+        end
+      end
+    end
 
-    Dir.stub(:exist?, true) do
-      code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+    def test_setup_stage_config_script
+      config = good_config
+      config[:projects][:project1][:stage_method] = :script
+      config[:projects][:project1][:stages][:production][:script] = {stage: "script", unstage: "script"}
+      options = build_options({stage: "production", sideload: true, set_stage: true})
+      parsed = ConfigParser.parse(options: options, config: config)
+      assert_equal parsed[:project_config][:stages][:production][:script], config[:projects][:project1][:stages][:production][:script]
     end
 
-    assert_equal RokuBuilder::SUCCESS, code
-    assert_equal Hash, config.class
-    assert_equal "/tmp/project1", configs[:project_config][:directory]
-  end
+    def test_setup_stage_config_git_ref
+      config = good_config
+      options = build_options({stage: "production", ref: "git-ref", sideload: true})
+      parsed = ConfigParser.parse(options: options, config: config)
+      assert_equal options[:ref], parsed[:stage_config][:key]
+    end
 
-  def test_manifest_config_project_directory_select
-    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,
-      sideload: true
-    }
-    config = good_config
-    config[:projects][:project_dir] = "/tmp"
-    config[:projects][:project1][:directory] = "project1"
-    config[:projects][:project2][:directory] = "project2"
-
-    code = nil
-    configs = nil
-
-    Pathname.stub(:pwd, Pathname.new("/tmp/project2")) do
-      Dir.stub(:exist?, true) do
-        code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+    def test_manifest_config_project_select
+      options = build_options({ sideload: true, working: true })
+      config = good_config
+      configs = nil
+      Pathname.stub(:pwd, Pathname.new("/dev/nuller")) do
+        configs = ConfigParser.parse(options: options, config: config)
       end
+      assert_equal Hash, config.class
+      assert_equal "/tmp", configs[:project_config][:directory]
     end
 
-    assert_equal RokuBuilder::SUCCESS, code
-    assert_equal Hash, config.class
-    assert_equal "/tmp/project2", configs[:project_config][:directory]
-  end
+    def test_manifest_config_project_directory
+      options = build_options({
+        sideload: true,
+        working: true
+      })
+      config = good_config
+      config[:projects][:project_dir] = "/tmp"
+      config[:projects][:project1][:directory] = "project1"
+      config[:projects][:project2][:directory] = "project2"
 
-  def test_manifest_config_key_directory
-    tmp_file = Tempfile.new("pkg")
-    logger = Logger.new("/dev/null")
-    options = {key: true, project: :project2}
-    config = good_config
-    config[:keys][:key_dir] = File.dirname(tmp_file.path)
-    config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)
+      configs = nil
 
+      Dir.stub(:exist?, true) do
+        configs = ConfigParser.parse(options: options, config: config)
+      end
 
-    code = nil
-    configs = nil
+      assert_equal Hash, config.class
+      assert_equal "/tmp/project1", configs[:project_config][:directory]
+    end
 
-    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+    def test_manifest_config_project_directory_select
+      options = build_options({sideload: true, working: true})
+      config = good_config
+      config[:projects][:project_dir] = "/tmp"
+      config[:projects][:project1][:directory] = "project1"
+      config[:projects][:project2][:directory] = "project2"
+
+      configs = nil
+      Pathname.stub(:pwd, Pathname.new("/tmp/project2")) do
+        Dir.stub(:exist?, true) do
+          configs = ConfigParser.parse(options: options, config: config)
+        end
+      end
 
-    assert_equal RokuBuilder::SUCCESS, code
-    assert_equal Hash, config.class
-    assert_equal tmp_file.path, configs[:key][:keyed_pkg]
-    tmp_file.close
-  end
+      assert_equal Hash, config.class
+      assert_equal "/tmp/project2", configs[:project_config][:directory]
+    end
 
-  def test_manifest_config_key_directory_bad
-    tmp_file = Tempfile.new("pkg")
-    logger = Logger.new("/dev/null")
-    options = {key: true, project: :project2}
-    config = good_config
-    config[:keys][:key_dir] = "/bad"
-    config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)
+    def test_key_config_key_directory
+      tmp_file = Tempfile.new("pkg")
+      options = build_options({key: true, project: :project2, set_stage: true})
+      config = good_config
+      config[:keys][:key_dir] = File.dirname(tmp_file.path)
+      config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)
 
-    code = nil
-    configs = nil
+      configs = ConfigParser.parse(options: options, config: config)
 
-    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+      assert_equal Hash, config.class
+      assert_equal tmp_file.path, configs[:key][:keyed_pkg]
+      tmp_file.close
+    end
 
-    assert_equal RokuBuilder::BAD_KEY_FILE, code
-  end
+    def test_key_config_key_directory_bad
+      tmp_file = Tempfile.new("pkg")
+      options = build_options({key: true, project: :project2, set_stage: true})
+      config = good_config
+      config[:keys][:key_dir] = "/bad"
+      config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)
+
+      assert_raises ParseError do
+        ConfigParser.parse(options: options, config: config)
+      end
+    end
 
-  def test_manifest_config_key_path_bad
-    tmp_file = Tempfile.new("pkg")
-    logger = Logger.new("/dev/null")
-    options = {key: true, project: :project2}
-    config = good_config
-    config[:keys][:key_dir] = File.dirname(tmp_file.path)
-    config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)+".bad"
+    def test_key_config_key_path_bad
+      tmp_file = Tempfile.new("pkg")
+      options = build_options({key: true, project: :project2, set_stage: true})
+      config = good_config
+      config[:keys][:key_dir] = File.dirname(tmp_file.path)
+      config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)+".bad"
 
-    code = nil
-    configs = nil
+      assert_raises ParseError do
+        ConfigParser.parse(options: options, config: config)
+      end
+    end
 
-    code, configs = RokuBuilder::ConfigParser.parse_config(options: options, config: config, logger: logger)
+    def test_key_config_bad_key
+      options = build_options({key: true, project: :project1, set_stage: true})
+      config = good_config
+      config[:projects][:project1][:stages][:production][:key] = "bad"
 
-    assert_equal RokuBuilder::BAD_KEY_FILE, code
-  end
+      assert_raises ParseError do
+        ConfigParser.parse(options: options, config: config)
+      end
+    end
 
-  def test_setup_sideload_config
-    args = {
-      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
-      options: {sideload: true}
-    }
-    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
-
-    refute_nil args[:configs][:sideload_config]
-    refute_nil args[:configs][:sideload_config][:content]
-    refute_nil args[:configs][:build_config]
-    refute_nil args[:configs][:build_config][:content]
-    refute_nil args[:configs][:init_params][:loader]
-    refute_nil args[:configs][:init_params][:loader][:root_dir]
-
-    assert_nil args[:configs][:sideload_config][:content][:excludes]
-    assert_nil args[:configs][:sideload_config][:update_manifest]
-    assert_nil args[:configs][:sideload_config][:infile]
-  end
-  def test_setup_sideload_config_exclude
-    args = {
-      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
-      options: {sideload: true}
-    }
-    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
-    assert_nil args[:configs][:sideload_config][:content][:excludes]
-
-    args = {
-      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
-      options: {build: true}
-    }
-    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
-    refute_nil args[:configs][:sideload_config][:content][:excludes]
-
-    args = {
-      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
-      options: {package: true}
-    }
-    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
-    refute_nil args[:configs][:sideload_config][:content][:excludes]
-
-    args = {
-      configs: {project_config: {directory: "/tmp", folders: ["a", "b"], files: ["c", "d"], excludes: []}, init_params: {}},
-      options: {sideload: true, exclude: true}
-    }
-    RokuBuilder::ConfigParser.send(:setup_sideload_config, **args)
-    refute_nil args[:configs][:sideload_config][:content][:excludes]
-  end
+    def test_setup_sideload_config
+      config = good_config
+      options = build_options({sideload: true, working: true})
+      parsed = ConfigParser.parse(options: options, config: config)
+
+      refute_nil parsed[:sideload_config]
+      refute_nil parsed[:sideload_config][:content]
+      refute_nil parsed[:build_config]
+      refute_nil parsed[:build_config][:content]
+      refute_nil parsed[:init_params][:loader]
+      refute_nil parsed[:init_params][:loader][:root_dir]
+
+      assert_nil parsed[:sideload_config][:content][:excludes]
+      assert_nil parsed[:sideload_config][:update_manifest]
+      assert_nil parsed[:sideload_config][:infile]
+    end
+    def test_setup_sideload_config_exclude
+      config = good_config
+      config[:projects][:project1][:excludes] = []
+      options = build_options({sideload: true, working: true})
+      parsed = ConfigParser.parse(options: options, config: config)
+      assert_nil parsed[:sideload_config][:content][:excludes]
+
+      options = build_options({build: true, working: true})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:sideload_config][:content][:excludes]
+
+      options = build_options({package: true, set_stage: true})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:sideload_config][:content][:excludes]
+
+      options = build_options({sideload: true, working: true, exclude: true})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:sideload_config][:content][:excludes]
+    end
 
-  def test_deeplink_app_config
-    args = {
-      config: {},
-      configs: {project_config: {directory: "dir"}, init_params: {}, out: {}},
-      options: {deeplink: "a:b", app_id: "xxxxxx"},
-    }
-    RokuBuilder::ConfigParser.send(:setup_simple_configs, **args)
-  end
+    def test_deeplink_app_config
+      config = good_config
+      options = build_options({deeplink: "a:b", app_id: "xxxxxx"})
+      parsed = ConfigParser.parse(options: options, config: config)
 
-  def test_monitor_config
-    args = {
-      config: {},
-      configs: {project_config: {directory: "dir"}, init_params: {}, out: {}},
-      options: {monitor: "main", regexp: "^A$"},
-    }
-    RokuBuilder::ConfigParser.send(:setup_active_configs, **args)
-    refute_nil args[:configs][:monitor_config][:regexp]
-    assert args[:configs][:monitor_config][:regexp].match("A")
-  end
+      assert_equal parsed[:deeplink_config][:options], options[:deeplink]
+      assert_equal parsed[:deeplink_config][:app_id], options[:app_id]
+    end
 
-  def test_outfile_config
-    configs = {}
-    args = {
-     options: {out: nil},
-     configs: configs
-    }
-    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
-    refute_nil configs[:out]
-    refute_nil configs[:out][:folder]
-    assert_nil configs[:out][:file]
-    assert_equal "/tmp", configs[:out][:folder]
-
-    configs = {}
-    args = {
-     options: {out: "/home/user"},
-     configs: configs
-    }
-    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
-    refute_nil configs[:out]
-    refute_nil configs[:out][:folder]
-    assert_nil configs[:out][:file]
-    assert_equal "/home/user", configs[:out][:folder]
-
-    configs = {}
-    args = {
-     options: {out: "/home/user/file.pkg"},
-     configs: configs
-    }
-    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
-    refute_nil configs[:out]
-    refute_nil configs[:out][:folder]
-    refute_nil configs[:out][:file]
-    assert_equal "/home/user", configs[:out][:folder]
-    assert_equal "file.pkg", configs[:out][:file]
-
-    configs = {}
-    args = {
-     options: {out: "/home/user/file.zip"},
-     configs: configs
-    }
-    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
-    refute_nil configs[:out]
-    refute_nil configs[:out][:folder]
-    refute_nil configs[:out][:file]
-    assert_equal "/home/user", configs[:out][:folder]
-    assert_equal "file.zip", configs[:out][:file]
-
-    configs = {}
-    args = {
-     options: {out: "/home/user/file.jpg"},
-     configs: configs
-    }
-    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
-    refute_nil configs[:out]
-    refute_nil configs[:out][:folder]
-    refute_nil configs[:out][:file]
-    assert_equal "/home/user", configs[:out][:folder]
-    assert_equal "file.jpg", configs[:out][:file]
-
-    configs = {}
-    args = {
-     options: {out: "file.jpg"},
-     configs: configs
-    }
-    RokuBuilder::ConfigParser.send(:setup_outfile, **args)
-    refute_nil configs[:out]
-    refute_nil configs[:out][:folder]
-    refute_nil configs[:out][:file]
-    assert_equal "/tmp", configs[:out][:folder]
-    assert_equal "file.jpg", configs[:out][:file]
+    def test_monitor_config
+      config = good_config
+      options = build_options({monitor: "main", regexp: "^A$"})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:monitor_config][:regexp]
+      assert parsed[:monitor_config][:regexp].match("A")
+    end
+    def test_outfile_config_default
+      config = good_config
+      options = build_options({build: true, working: true, out: nil})
+      parsed = ConfigParser.parse(options: options, config: config)
+
+      refute_nil parsed[:out]
+      refute_nil parsed[:out][:folder]
+      assert_nil parsed[:out][:file]
+      assert_equal "/tmp", parsed[:out][:folder]
+    end
+    def test_outfile_config_folder
+      config = good_config
+
+      options = build_options({build: true, working: true, out: "/home/user"})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:out]
+      refute_nil parsed[:out][:folder]
+      assert_nil parsed[:out][:file]
+      assert_equal "/home/user", parsed[:out][:folder]
+    end
+    def test_outfile_config_pkg
+      config = good_config
+
+      options = build_options({build: true, working: true, out: "/home/user/file.pkg"})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:out]
+      refute_nil parsed[:out][:folder]
+      refute_nil parsed[:out][:file]
+      assert_equal "/home/user", parsed[:out][:folder]
+      assert_equal "file.pkg", parsed[:out][:file]
+    end
+    def test_outfile_config_zip
+      config = good_config
+
+      options = build_options({build: true, working: true, out: "/home/user/file.zip"})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:out]
+      refute_nil parsed[:out][:folder]
+      refute_nil parsed[:out][:file]
+      assert_equal "/home/user", parsed[:out][:folder]
+      assert_equal "file.zip", parsed[:out][:file]
+    end
+    def test_outfile_config_jpg
+      config = good_config
+
+      options = build_options({build: true, working: true, out: "/home/user/file.jpg"})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:out]
+      refute_nil parsed[:out][:folder]
+      refute_nil parsed[:out][:file]
+      assert_equal "/home/user", parsed[:out][:folder]
+      assert_equal "file.jpg", parsed[:out][:file]
+    end
+    def test_outfile_config_default_jpg
+      config = good_config
+
+      options = build_options({build: true, working: true, out: "file.jpg"})
+      parsed = ConfigParser.parse(options: options, config: config)
+      refute_nil parsed[:out]
+      refute_nil parsed[:out][:folder]
+      refute_nil parsed[:out][:file]
+      assert_equal "/tmp", parsed[:out][:folder]
+      assert_equal "file.jpg", parsed[:out][:file]
+    end
   end
 end