roku_builder 3.12.8 → 3.13.0

data/test/roku_builder/test_tester.rb

@@ -1,133 +1,130 @@
 # ********** Copyright Viacom, Inc. Apache 2.0 **********
-
 require_relative "test_helper.rb"
 
-class TesterTest < Minitest::Test
-  def test_tester_runtests
-    connection = Minitest::Mock.new
-    loader = Minitest::Mock.new
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    loader_config = {
-      root_dir: "root/dir/path",
-      branch: "branch",
-      folders: ["source"],
-      files: ["manifest"]
-    }
-    tester = RokuBuilder::Tester.new(**device_config)
-
-    loader.expect(:sideload, [RokuBuilder::SUCCESS, ""], [loader_config])
-    connection.expect(:waitfor, nil, [/\*\*\*\*\* ENDING TESTS \*\*\*\*\*/])
-    connection.expect(:puts, nil, ["cont\n"])
-
-    RokuBuilder::Loader.stub(:new, loader) do
-      Net::Telnet.stub(:new, connection) do
-        tester.run_tests(sideload_config: loader_config)
+module RokuBuilder
+  class TesterTest < Minitest::Test
+    def test_tester_runtests
+      connection = Minitest::Mock.new
+      loader = Minitest::Mock.new
+      linker = Minitest::Mock.new
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password",
+        init_params: {root_dir: "root/dir/path"}
+      }
+      loader_config = {
+        root_dir: "root/dir/path",
+        branch: "branch",
+        folders: ["source"],
+        files: ["manifest"]
+      }
+      tester = Tester.new(**device_config)
+
+      loader.expect(:sideload, [SUCCESS, ""], [loader_config])
+      linker.expect(:launch, nil, [{options: "RunTests:true"}])
+      connection.expect(:waitfor, nil, [/\*+\s*End testing\s*\*+/])
+      connection.expect(:puts, nil, ["cont\n"])
+
+      Loader.stub(:new, loader) do
+        Linker.stub(:new, linker) do
+          Net::Telnet.stub(:new, connection) do
+            tester.run_tests(sideload_config: loader_config)
+          end
+        end
       end
-    end
 
-    connection.verify
-  end
+      connection.verify
+    end
 
-  def test_tester_runtests_and_handle
-    waitfor = Proc.new do |end_reg, &blk|
-      assert_equal(/\*\*\*\*\* ENDING TESTS \*\*\*\*\*/, end_reg)
+    def test_tester_runtests_and_handle
+      waitfor = Proc.new do |end_reg, &blk|
+      assert_equal(/\*+\s*End testing\s*\*+/, end_reg)
       txt = "Fake Text"
       blk.call(txt) == false
-    end
-    connection = Minitest::Mock.new
-    loader = Minitest::Mock.new
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    loader_config = {
-      root_dir: "root/dir/path",
-      branch: "branch",
-      folders: ["source"],
-      files: ["manifest"]
-    }
-    tester = RokuBuilder::Tester.new(**device_config)
-
-    loader.expect(:sideload, [RokuBuilder::SUCCESS, ""], [loader_config])
-    connection.expect(:waitfor, nil, &waitfor)
-    connection.expect(:puts, nil, ["cont\n"])
-
-    RokuBuilder::Loader.stub(:new, loader) do
-      Net::Telnet.stub(:new, connection) do
-        tester.stub(:handle_text, false) do
-          tester.run_tests(sideload_config: loader_config)
+      end
+      connection = Minitest::Mock.new
+      loader = Minitest::Mock.new
+      linker = Minitest::Mock.new
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password",
+        init_params: {root_dir: "root/dir/path"}
+      }
+      loader_config = {
+        root_dir: "root/dir/path",
+        branch: "branch",
+        folders: ["source"],
+        files: ["manifest"]
+      }
+      tester = Tester.new(**device_config)
+
+      loader.expect(:sideload, [SUCCESS, ""], [loader_config])
+      linker.expect(:launch, nil, [{options: "RunTests:true"}])
+      connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:puts, nil, ["cont\n"])
+
+      Loader.stub(:new, loader) do
+        Net::Telnet.stub(:new, connection) do
+          Linker.stub(:new, linker) do
+            tester.stub(:handle_text, false) do
+              tester.run_tests(sideload_config: loader_config)
+            end
+          end
         end
       end
-    end
-
-    connection.verify
-  end
-
-  def test_tester_handle_text_no_text
-    logger = Minitest::Mock.new
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: logger
-    }
-    tester = RokuBuilder::Tester.new(**device_config)
-
-    text = "this\nis\na\ntest\nparagraph"
 
-    assert !tester.send(:handle_text, {txt: text, in_tests: false})
-
-    logger.verify
-  end
-
-  def test_tester_handle_text_all_text
-    logger = Minitest::Mock.new
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: logger
-    }
-    tester = RokuBuilder::Tester.new(**device_config)
-
-    text = "this\nis\na\ntest\nparagraph"
-
-    logger.expect(:unknown, nil, ["this"])
-    logger.expect(:unknown, nil, ["is"])
-    logger.expect(:unknown, nil, ["a"])
-    logger.expect(:unknown, nil, ["test"])
-    logger.expect(:unknown, nil, ["paragraph"])
-
-    assert tester.send(:handle_text, {txt: text, in_tests: true})
-
-    logger.verify
-  end
+      connection.verify
+    end
 
-  def test_tester_handle_text_partial_text
-    logger = Minitest::Mock.new
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: logger
-    }
-    tester = RokuBuilder::Tester.new(**device_config)
+    def test_tester_handle_text_no_text
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password",
+        init_params: {root_dir: "root/dir/path"}
+      }
+      tester = Tester.new(**device_config)
 
-    text = "this\n***** STARTING TESTS *****\nis\na\ntest\n***** ENDING TESTS *****\nparagraph"
+      text = "this\nis\na\ntest\nparagraph"
+      tester.send(:handle_text, {txt: text})
 
-    logger.expect(:unknown, nil, ["is"])
-    logger.expect(:unknown, nil, ["a"])
-    logger.expect(:unknown, nil, ["test"])
+      refute tester.instance_variable_get(:@in_tests)
+    end
 
-    assert !tester.send(:handle_text, {txt: text, in_tests: false})
+    def test_tester_handle_text_all_text
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password",
+        init_params: {root_dir: "root/dir/path"}
+      }
+      tester = Tester.new(**device_config)
+      tester.instance_variable_set(:@in_tests, true)
+
+      text = ["this","is","a","test","paragraph"]
+
+      tester.send(:handle_text, {txt: text.join("\n")})
+      assert_equal text, tester.instance_variable_get(:@logs)
+      assert tester.instance_variable_get(:@in_tests)
+    end
 
-    logger.verify
+    def test_tester_handle_text_partial_text
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password",
+        init_params: {root_dir: "root/dir/path"}
+      }
+      tester = Tester.new(**device_config)
+
+      text = ["this","*Start testing*","is","a","test","*End testing*","paragraph"]
+      verify_text = ["***************","***************","*Start testing*","is","a","test","*End testing*","*************","*************"]
+
+      tester.send(:handle_text, {txt: text.join("\n")})
+      refute tester.instance_variable_get(:@in_tests)
+      assert_equal verify_text, tester.instance_variable_get(:@logs)
+    end
   end
 end

data/test/roku_builder/test_util.rb

@@ -2,24 +2,25 @@
 
 require_relative "test_helper.rb"
 
-class UtilTest < Minitest::Test
-  def test_util_init
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    test = TestClass.new(**device_config)
-    assert test.inited
+module RokuBuilder
+  class UtilTest < Minitest::Test
+    def test_util_init
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      test = TestClass.new(**device_config)
+      assert test.inited
+    end
   end
-end
 
-class TestClass < RokuBuilder::Util
-  def init
-    @inited = true
-  end
-  def inited
-    @inited || false
+  class TestClass < Util
+    def init
+      @inited = true
+    end
+    def inited
+      @inited || false
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 3.12.8
+  version: 3.13.0
 platform: ruby
 authors:
 - greeneca
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-06 00:00:00.000000000 Z
+date: 2017-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: win32-security
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -297,19 +311,22 @@ files:
 - config.json.example
 - config.json.min
 - lib/roku_builder.rb
-- lib/roku_builder/config_manager.rb
+- lib/roku_builder/config.rb
 - lib/roku_builder/config_parser.rb
 - lib/roku_builder/config_validator.rb
 - lib/roku_builder/controller.rb
 - lib/roku_builder/controller_commands.rb
 - lib/roku_builder/error_handler.rb
+- lib/roku_builder/errors.rb
 - lib/roku_builder/inspector.rb
 - lib/roku_builder/keyer.rb
 - lib/roku_builder/linker.rb
 - lib/roku_builder/loader.rb
+- lib/roku_builder/logger.rb
 - lib/roku_builder/manifest_manager.rb
 - lib/roku_builder/monitor.rb
 - lib/roku_builder/navigator.rb
+- lib/roku_builder/options.rb
 - lib/roku_builder/packager.rb
 - lib/roku_builder/profiler.rb
 - lib/roku_builder/scripter.rb
@@ -319,12 +336,18 @@ files:
 - lib/roku_builder/version.rb
 - rakefile
 - roku_builder.gemspec
-- test/roku_builder/test_config_manager.rb
+- test/roku_builder/test_config.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/config_test/bad.json
+- test/roku_builder/test_files/config_test/child.json
+- test/roku_builder/test_files/config_test/config.json
+- test/roku_builder/test_files/config_test/non_json.json
+- test/roku_builder/test_files/config_test/parent.json
+- test/roku_builder/test_files/config_test/parent_projects.json
 - 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
@@ -347,9 +370,11 @@ files:
 - test/roku_builder/test_keyer.rb
 - test/roku_builder/test_linker.rb
 - test/roku_builder/test_loader.rb
+- test/roku_builder/test_logger.rb
 - test/roku_builder/test_manifest_manager.rb
 - test/roku_builder/test_monitor.rb
 - test/roku_builder/test_navigator.rb
+- test/roku_builder/test_options.rb
 - test/roku_builder/test_packager.rb
 - test/roku_builder/test_profiler.rb
 - test/roku_builder/test_ruby_git.rb
@@ -359,7 +384,7 @@ files:
 - test/roku_builder/test_util.rb
 homepage: ''
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -382,12 +407,18 @@ signing_key:
 specification_version: 4
 summary: Build Tool for Roku Apps
 test_files:
-- test/roku_builder/test_config_manager.rb
+- test/roku_builder/test_config.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/config_test/bad.json
+- test/roku_builder/test_files/config_test/child.json
+- test/roku_builder/test_files/config_test/config.json
+- test/roku_builder/test_files/config_test/non_json.json
+- test/roku_builder/test_files/config_test/parent.json
+- test/roku_builder/test_files/config_test/parent_projects.json
 - 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
@@ -410,9 +441,11 @@ test_files:
 - test/roku_builder/test_keyer.rb
 - test/roku_builder/test_linker.rb
 - test/roku_builder/test_loader.rb
+- test/roku_builder/test_logger.rb
 - test/roku_builder/test_manifest_manager.rb
 - test/roku_builder/test_monitor.rb
 - test/roku_builder/test_navigator.rb
+- test/roku_builder/test_options.rb
 - test/roku_builder/test_packager.rb
 - test/roku_builder/test_profiler.rb
 - test/roku_builder/test_ruby_git.rb

data/lib/roku_builder/config_manager.rb

@@ -1,161 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-module RokuBuilder
-
-  # Load and validate config files.
-  class ConfigManager
-
-    # Load config file and generate intermeidate configs
-    # @param options [Hash] The options hash
-    # @param logger [Logger] system logger
-    # @return [Integer] Return code
-    # @return [Hash] Loaded config
-    # @return [Hash] Intermeidate configs
-    def self.load_config(options:, logger:)
-      config_file = File.expand_path(options[:config])
-      return MISSING_CONFIG unless File.exist?(config_file)
-      code = SUCCESS
-      config = ConfigManager.get_config(config: config_file, logger: logger)
-      return INVALID_CONFIG unless config
-      codes = ConfigValidator.validate_config(config: config)
-      fatal = false
-      warning = false
-      codes.each {|a_code|
-        if a_code > 0
-          logger.fatal "Invalid Config: "+ ConfigValidator.error_codes()[a_code]
-          fatal = true
-        elsif a_code < 0
-          logger.warn "Depricated Config: "+ ConfigValidator.error_codes()[a_code]
-          warning = true
-        elsif a_code == 0 and options[:validate]
-          logger.info "Config Valid"
-        end
-      }
-      return [INVALID_CONFIG, nil, nil] if fatal
-      code = DEPRICATED_CONFIG if warning
-
-      parse_code, configs = ConfigParser.parse_config(options: options, config: config, logger: logger)
-      unless parse_code == SUCCESS
-        return [parse_code, nil, nil]
-      end
-      [code, config, configs]
-    end
-
-    # Loads the roku config from file
-    # @param config [String] path for the roku config
-    # @return [Hash] roku config object
-    def self.get_config(config:, logger:)
-      begin
-        config = build_config(config: config, logger: logger)
-        return nil unless config
-        config[:devices][:default] = config[:devices][:default].to_sym
-        if config[:projects]
-          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 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
-                config[:projects][key] = new_value
-              end
-            end
-          end
-        end
-        config
-      rescue JSON::ParserError
-        logger.fatal "Config file is not valid JSON"
-        nil
-      end
-    end
-
-    def self.build_config(config:, logger:)
-      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
-    end
-
-
-    # Edit the roku config
-    # @param config [String] path for the roku config
-    # @param options [String] options to set in the config
-    # @param stage[String] which stage to use
-    # @return [Boolean] success
-    def self.edit_config(config:, options:, logger:)
-      config_object = get_config(config: config, logger: logger)
-      return false unless config_object
-      project = options[:project].to_sym if options[:project]
-      project = config_object[:projects][:default] unless options[:project]
-      device = options[:device].to_sym if options[:device]
-      device = config_object[:devices][:default] unless options[:device]
-      stage = options[:stage].to_sym if options[:stage]
-      stage ||= config_object[:projects][project][:stages].keys[0].to_sym
-      state = {
-        project: project,
-        device: device,
-        stage: stage
-      }
-      apply_options(config_object: config_object, options: options[:edit_params], state: state)
-      config_string = JSON.pretty_generate(config_object)
-      file = File.open(config, "w")
-      file.write(config_string)
-      file.close
-      return true
-    end
-
-    # Apply the changes in the options string to the config object
-    # @param config_object [Hash] The config loaded from file
-    # @param options [String] The string of options passed in by the user
-    # @param state [Hash] The state of the config the user is editing
-    def self.apply_options(config_object:, options:, state:)
-      changes = Util.options_parse(options: options)
-      changes.each {|key,value|
-        if [:ip, :user, :password].include?(key)
-          config_object[:devices][state[:device]][key] = value
-        elsif [:directory, :app_name].include?(key) #:folders, :files
-          config_object[:projects][state[:project]][key] = value
-        elsif [:branch].include?(key)
-          config_object[:projects][state[:project]][:stages][state[:stage]][key] = value
-        end
-      }
-    end
-    private_class_method :apply_options
-
-    # Update the intermeidate configs
-    # @param configs [Hash] Intermeidate configs hash
-    # @param options [Hash] Options hash
-    # @return [Hash] New intermeidate configs hash
-    def self.update_configs(configs:, options:)
-      if options[:build_version]
-        configs[:package_config][:app_name_version] = "#{configs[:project_config][:app_name]} - #{configs[:stage]} - #{options[:build_version]}" if configs[:package_config]
-        unless configs[:out][:file]
-          configs[:out][:file] = "#{configs[:project_config][:app_name]}_#{configs[:stage]}_#{options[:build_version]}"
-        end
-        pathname = File.join(configs[:out][:folder], configs[:out][:file])
-        configs[:package_config][:out_file] = pathname if configs[:package_config]
-        configs[:build_config][:out_file]   = pathname if configs[:build_config]
-        if configs[:sideload_config] and options[:out]
-          configs[:sideload_config][:out_file]   = pathname
-        end
-        configs[:inspect_config][:pkg] = configs[:package_config][:out_file] if configs[:inspect_config] and configs[:package_config]
-      end
-      return configs
-    end
-  end
-end