roku_builder 3.13.0 → 4.0.0

data/test/roku_builder/test_config.rb

@@ -4,6 +4,9 @@ require_relative "test_helper.rb"
 
 module RokuBuilder
   class ConfigTest < Minitest::Test
+    def setup
+      Logger.set_testing
+    end
 
     def test_config_init
       options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
@@ -59,7 +62,7 @@ module RokuBuilder
       assert_equal :p1, config.raw[:projects][:default]
     end
 
-    def test_config_read_parent
+    def test_config_read_parent_child_part
       options = build_options({config: File.join(test_files_path(ConfigTest), "child.json"), validate: true})
       config = Config.new(options: options)
       config.load
@@ -67,7 +70,7 @@ module RokuBuilder
       assert_equal :p1, config.raw[:projects][:default]
     end
 
-    def test_config_read_parent
+    def test_config_read_parent_parent_part
       options = build_options({config: File.join(test_files_path(ConfigTest), "parent_projects.json"), validate: true})
       config = Config.new(options: options)
       config.load
@@ -89,38 +92,6 @@ module RokuBuilder
       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})
@@ -148,7 +119,7 @@ module RokuBuilder
       File.delete(target_config) if File.exist?(target_config)
     end
 
-    def test_config_configure_edit_params
+    def test_config_configure_edit_params_default
       target_config = File.join(test_files_path(ConfigTest), "configure_test.json")
       options = build_options({
         config: target_config,
@@ -164,5 +135,50 @@ module RokuBuilder
       end
       File.delete(target_config) if File.exist?(target_config)
     end
+
+    def test_config_set_root_dir
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      config.root_dir = "new/dir"
+      assert_equal "new/dir", config.root_dir
+    end
+
+    def test_config_set_in
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      config.in = "new/dir"
+      assert_equal "new/dir", config.in
+    end
+
+    def test_config_set_out
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      config.out = "new/dir"
+      assert_equal "new/dir", config.out
+    end
+
+    def test_config_dont_set_params
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      assert_raises StandardError do
+        config.param = "value"
+      end
+    end
+    def test_config_input_mappings
+      options = build_options({config: File.join(test_files_path(ConfigTest), "config.json"), validate: true})
+      config = Config.new(options: options)
+      config.load
+      config.parse
+      refute_nil config.input_mappings
+      assert_equal ["home", "Home"], config.input_mappings[:a]
+    end
   end
 end

data/test/roku_builder/test_config_parser.rb

@@ -4,51 +4,54 @@ require_relative "test_helper.rb"
 
 module RokuBuilder
   class ConfigParserTest < Minitest::Test
+    def setup
+      Logger.set_testing
+    end
     def test_manifest_config
       options = build_options({
-        sideload: true,
+        validate: true,
         working: true
       })
-      config = good_config
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       configs = ConfigParser.parse(options: options, config: config)
 
       assert_equal Hash, config.class
-      assert_equal "/tmp", configs[:manifest_config][:root_dir]
+      assert_equal test_files_path(ConfigParserTest), configs[:root_dir]
     end
 
     def test_manifest_config_in
       options = build_options({
         in: "/dev/null/infile",
-        sideload: true
+        validate: true
       })
-      config = good_config
+      config = good_config(ConfigParserTest)
       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]
+      assert_equal "/dev/null/infile", configs[:root_dir]
     end
 
     def test_manifest_config_in_expand
       options = build_options({
         in: "./infile",
-        sideload: true
+        validate: true
       })
-      config = good_config
+      config = good_config(ConfigParserTest)
       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]
+      assert_equal File.join(Dir.pwd, "infile"), configs[:root_dir]
     end
 
     def test_manifest_config_current
       options = build_options({
         current: true,
-        sideload: true
+        validate: true
       })
+      options.define_singleton_method(:source_commands){[:validate]}
       configs = nil
-      config = good_config
+      config = good_config(ConfigParserTest)
       Pathname.stub(:pwd, "/dev/null/infile") do
         File.stub(:exist?, true) do
           configs = ConfigParser.parse(options: options, config: config)
@@ -56,13 +59,13 @@ module RokuBuilder
       end
 
       assert_equal Hash, config.class
-      assert_equal "/dev/null/infile", configs[:manifest_config][:root_dir]
-      assert_equal :current, configs[:stage_config][:method]
+      assert_equal "/dev/null/infile", configs[:root_dir]
     end
 
     def test_setup_project_config_bad_project
-      config = good_config
-      options = build_options({sideload: true, project: :project3, set_stage: true})
+      config = good_config(ConfigParserTest)
+      options = build_options({validate: true, project: :project3, stage: "production"})
+      options.define_singleton_method(:source_commands) {[:validate]}
       assert_raises ParseError do
         File.stub(:exist?, true) do
           ConfigParser.parse(options: options, config: config)
@@ -71,13 +74,13 @@ module RokuBuilder
     end
 
     def test_setup_project_config_current
-      options = build_options({ sideload: true, current: true })
-      config = good_config
+      options = build_options({ validate: true, current: true })
+      config = good_config(ConfigParserTest)
       configs = nil
       File.stub(:exist?, true) do
         configs = ConfigParser.parse(options: options, config: config)
       end
-      project = configs[:project_config]
+      project = configs[:project]
       assert_equal Pathname.pwd.to_s, project[:directory]
       assert_equal :current, project[:stage_method]
       assert_nil project[:folders]
@@ -85,17 +88,19 @@ module RokuBuilder
     end
 
     def test_setup_project_config_good_project_dir
-      config = good_config
-      options = build_options({sideload: true, project: :project1, set_stage: true})
+      config = good_config(ConfigParserTest)
+      options = build_options({validate: true, project: :project1, stage: 'production'})
+      options.define_singleton_method(:source_commands) {[:validate]}
       File.stub(:exist?, true) do
         ConfigParser.parse(options: options, config: config)
       end
     end
 
     def test_setup_project_config_bad_project_dir
-      config = good_config
+      config = good_config(ConfigParserTest)
       config[:projects][:project1][:directory] = "/dev/null"
-      options = build_options({sideload: true, project: :project1, working: true})
+      options = build_options({validate: true, project: :project1, working: true})
+      options.define_singleton_method(:source_commands){[:validate]}
       assert_raises ParseError do
         File.stub(:exist?, true) do
           ConfigParser.parse(options: options, config: config)
@@ -104,10 +109,11 @@ module RokuBuilder
     end
 
     def test_setup_project_config_bad_child_project_dir
-      config = good_config
+      config = good_config(ConfigParserTest)
       config[:projects][:project_dir] = "/tmp"
       config[:projects][:project1][:directory] = "bad"
-      options = build_options({sideload: true, project: :project1, working: true})
+      options = build_options({validate: true, project: :project1, working: true})
+      options.define_singleton_method(:source_commands){[:validate]}
       assert_raises ParseError do
         File.stub(:exist?, true) do
           ConfigParser.parse(options: options, config: config)
@@ -116,42 +122,11 @@ module RokuBuilder
     end
 
     def test_setup_project_config_bad_parent_project_dir
-      config = good_config
+      config = good_config(ConfigParserTest)
       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_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
-
-    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})
+      options = build_options({validate: true, project: :project1, stage: 'production'})
+      options.define_singleton_method(:source_commands){[:validate]}
       assert_raises ParseError do
         File.stub(:exist?, true) do
           ConfigParser.parse(options: options, config: config)
@@ -160,38 +135,34 @@ module RokuBuilder
     end
 
     def test_setup_stage_config_script
-      config = good_config
+      config = good_config(ConfigParserTest)
       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})
+      options = build_options({stage: "production", validate: true})
+      options.define_singleton_method(:source_commands){[:validate]}
       parsed = ConfigParser.parse(options: options, config: config)
-      assert_equal parsed[:project_config][:stages][:production][:script], config[:projects][:project1][:stages][:production][:script]
-    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]
+      assert_equal parsed[:project][:stages][:production][:script], config[:projects][:project1][:stages][:production][:script]
     end
 
     def test_manifest_config_project_select
-      options = build_options({ sideload: true, working: true })
-      config = good_config
+      options = build_options({ validate: true, working: true })
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       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]
+      assert_equal test_files_path(ConfigParserTest), configs[:project][:directory]
     end
 
     def test_manifest_config_project_directory
       options = build_options({
-        sideload: true,
+        validate: true,
         working: true
       })
-      config = good_config
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       config[:projects][:project_dir] = "/tmp"
       config[:projects][:project1][:directory] = "project1"
       config[:projects][:project2][:directory] = "project2"
@@ -203,12 +174,13 @@ module RokuBuilder
       end
 
       assert_equal Hash, config.class
-      assert_equal "/tmp/project1", configs[:project_config][:directory]
+      assert_equal "/tmp/project1", configs[:project][:directory]
     end
 
     def test_manifest_config_project_directory_select
-      options = build_options({sideload: true, working: true})
-      config = good_config
+      options = build_options({validate: true, working: true})
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       config[:projects][:project_dir] = "/tmp"
       config[:projects][:project1][:directory] = "project1"
       config[:projects][:project2][:directory] = "project2"
@@ -221,13 +193,14 @@ module RokuBuilder
       end
 
       assert_equal Hash, config.class
-      assert_equal "/tmp/project2", configs[:project_config][:directory]
+      assert_equal "/tmp/project2", configs[:project][:directory]
     end
 
     def test_key_config_key_directory
       tmp_file = Tempfile.new("pkg")
-      options = build_options({key: true, project: :project2, set_stage: true})
-      config = good_config
+      options = build_options({validate: true, project: :project2, stage: 'production'})
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       config[:keys][:key_dir] = File.dirname(tmp_file.path)
       config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)
 
@@ -240,8 +213,9 @@ module RokuBuilder
 
     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
+      options = build_options({validate: true, project: :project2, stage: 'production'})
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       config[:keys][:key_dir] = "/bad"
       config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)
 
@@ -252,8 +226,9 @@ module RokuBuilder
 
     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
+      options = build_options({validate: true, project: :project2, stage: 'production'})
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       config[:keys][:key_dir] = File.dirname(tmp_file.path)
       config[:keys][:a][:keyed_pkg] = File.basename(tmp_file.path)+".bad"
 
@@ -261,72 +236,19 @@ module RokuBuilder
         ConfigParser.parse(options: options, config: config)
       end
     end
-
     def test_key_config_bad_key
-      options = build_options({key: true, project: :project1, set_stage: true})
-      config = good_config
+      options = build_options({validate: true, project: :project1, stage: 'production', })
+      options.define_singleton_method(:source_commands){[:validate]}
+      config = good_config(ConfigParserTest)
       config[:projects][:project1][:stages][:production][:key] = "bad"
 
       assert_raises ParseError do
         ConfigParser.parse(options: options, config: config)
       end
     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
-      config = good_config
-      options = build_options({deeplink: "a:b", app_id: "xxxxxx"})
-      parsed = ConfigParser.parse(options: options, config: config)
-
-      assert_equal parsed[:deeplink_config][:options], options[:deeplink]
-      assert_equal parsed[:deeplink_config][:app_id], options[:app_id]
-    end
-
-    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})
+      config = good_config(ConfigParserTest)
+      options = build_options({validate: true, working: true, out: nil})
       parsed = ConfigParser.parse(options: options, config: config)
 
       refute_nil parsed[:out]
@@ -335,9 +257,9 @@ module RokuBuilder
       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"})
+      config = good_config(ConfigParserTest)
+      options = build_options({validate: true, working: true, out: "/home/user"})
+      options.define_singleton_method(:source_commands){[:validate]}
       parsed = ConfigParser.parse(options: options, config: config)
       refute_nil parsed[:out]
       refute_nil parsed[:out][:folder]
@@ -345,9 +267,9 @@ module RokuBuilder
       assert_equal "/home/user", parsed[:out][:folder]
     end
     def test_outfile_config_pkg
-      config = good_config
+      config = good_config(ConfigParserTest)
 
-      options = build_options({build: true, working: true, out: "/home/user/file.pkg"})
+      options = build_options({validate: true, working: true, out: "/home/user/file.pkg"})
       parsed = ConfigParser.parse(options: options, config: config)
       refute_nil parsed[:out]
       refute_nil parsed[:out][:folder]
@@ -356,9 +278,9 @@ module RokuBuilder
       assert_equal "file.pkg", parsed[:out][:file]
     end
     def test_outfile_config_zip
-      config = good_config
+      config = good_config(ConfigParserTest)
 
-      options = build_options({build: true, working: true, out: "/home/user/file.zip"})
+      options = build_options({validate: true, working: true, out: "/home/user/file.zip"})
       parsed = ConfigParser.parse(options: options, config: config)
       refute_nil parsed[:out]
       refute_nil parsed[:out][:folder]
@@ -367,9 +289,9 @@ module RokuBuilder
       assert_equal "file.zip", parsed[:out][:file]
     end
     def test_outfile_config_jpg
-      config = good_config
+      config = good_config(ConfigParserTest)
 
-      options = build_options({build: true, working: true, out: "/home/user/file.jpg"})
+      options = build_options({validate: true, working: true, out: "/home/user/file.jpg"})
       parsed = ConfigParser.parse(options: options, config: config)
       refute_nil parsed[:out]
       refute_nil parsed[:out][:folder]
@@ -378,9 +300,9 @@ module RokuBuilder
       assert_equal "file.jpg", parsed[:out][:file]
     end
     def test_outfile_config_default_jpg
-      config = good_config
+      config = good_config(ConfigParserTest)
 
-      options = build_options({build: true, working: true, out: "file.jpg"})
+      options = build_options({validate: true, working: true, out: "file.jpg"})
       parsed = ConfigParser.parse(options: options, config: config)
       refute_nil parsed[:out]
       refute_nil parsed[:out][:folder]