roku_builder 3.13.0 → 4.0.0

data/test/roku_builder/plugins/test_packager.rb

@@ -0,0 +1,202 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+require_relative "../test_helper.rb"
+
+module RokuBuilder
+  class PackagerTest < Minitest::Test
+    def setup
+      Logger.set_testing
+      RokuBuilder.setup_plugins
+      register_plugins(Packager)
+      @requests = []
+    end
+    def teardown
+      @requests.each {|req| remove_request_stub(req)}
+    end
+    def test_packager_parse_options_long
+      parser = OptionParser.new
+      options = {}
+      Packager.parse_options(parser: parser, options: options)
+      argv = ["roku", "--package", "--key", "--genkey", "--inspect-package"]
+      parser.parse! argv
+      assert options[:package]
+      assert options[:key]
+      assert options[:genkey]
+      assert options[:inspect_package]
+    end
+    def test_scripter_parse_options_short
+      parser = OptionParser.new
+      options = {}
+      Packager.parse_options(parser: parser, options: options)
+      argv = ["roku", "-p", "-k", "-i"]
+      parser.parse! argv
+      assert options[:package]
+      assert options[:key]
+      assert options[:inspect_package]
+    end
+    def test_packager_current
+      config, options = [nil, nil]
+      Pathname.stub(:pwd, test_files_path(PackagerTest)) do
+        config, options = build_config_options_objects(PackagerTest, {package: true, current: true}, false)
+      end
+      packager = Packager.new(config: config)
+      assert_raises InvalidOptions do
+        packager.package(options: options)
+      end
+    end
+    def test_packager_in
+      config, options = build_config_options_objects(PackagerTest, {package: true, in: "/tmp/test.pkg"}, false)
+      packager = Packager.new(config: config)
+      assert_raises InvalidOptions do
+        packager.package(options: options)
+      end
+    end
+    def test_packager_ref
+      config, options = build_config_options_objects(PackagerTest, {package: true, ref: "test_ref"}, false)
+      packager = Packager.new(config: config)
+      assert_raises InvalidOptions do
+        packager.package(options: options)
+      end
+    end
+    def test_packager_package_failed
+      config, options = build_config_options_objects(PackagerTest, {package: true, stage: "production"}, false)
+      @requests.push(stub_request(:post, "http://192.168.0.100:8060/keypress/Home").
+        to_return(status: 200, body: "", headers: {}))
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_install").
+        to_return(status: 200, body: "", headers: {}))
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_package").
+        to_return(status: 200, body: "Failed: Error.", headers: {}))
+      packager = Packager.new(config: config)
+      assert_raises ExecutionError do
+        packager.package(options: options)
+      end
+    end
+
+    def test_packager_package
+      loader = Minitest::Mock.new
+      inspector = Minitest::Mock.new
+      io = Minitest::Mock.new
+      config, options = build_config_options_objects(PackagerTest, {package: true, stage: "production", inspect_package: true}, false)
+
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_inspect").
+        to_return(status: 200, body: "", headers: {}).times(2))
+      body = "<a href=\"pkgs\">pkg_url</a>"
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_package").
+        to_return(status: 200, body: body, headers: {}).times(2))
+      body = "package_body"
+      @requests.push(stub_request(:get, "http://192.168.0.100/pkgs/pkg_url").
+        to_return(status: 200, body: body, headers: {}))
+
+      loader.expect(:sideload, nil, [Hash])
+      io.expect(:write, nil, ["package_body"])
+      inspector.expect(:inspect, nil, [Hash])
+
+      packager = Packager.new(config: config)
+      dev_id = Proc.new {"#{Random.rand(999999999999)}"}
+      Loader.stub(:new, loader) do
+        Time.stub(:now, Time.at(0)) do
+          File.stub(:open, nil, io) do
+            Inspector.stub(:new, inspector) do
+              packager.stub(:dev_id, dev_id) do
+                packager.package(options: options)
+              end
+            end
+          end
+        end
+      end
+      io.verify
+      loader.verify
+      inspector.verify
+    end
+    def test_packager_dev_id
+      body = "v class=\"roku-font-5\"><label>Your Dev ID: &nbsp;</label> dev_id<hr></div>"
+      @requests.push(stub_request(:get, "http://192.168.0.100/plugin_package").
+        to_return(status: 200, body: body, headers: {}))
+
+      config = build_config_options_objects(PackagerTest, {key: true, stage: "production"}, false)[0]
+      packager = Packager.new(config: config)
+      dev_id = packager.dev_id
+
+      assert_equal "dev_id", dev_id
+    end
+    def test_packager_dev_id_old_interface
+      body = "<p> Your Dev ID: <font face=\"Courier\">dev_id</font> </p>"
+      @requests.push(stub_request(:get, "http://192.168.0.100/plugin_package").
+        to_return(status: 200, body: body, headers: {}))
+
+      config = build_config_options_objects(PackagerTest, {key: true, stage: "production"}, false)[0]
+      packager = Packager.new(config: config)
+      dev_id = packager.dev_id
+
+      assert_equal "dev_id", dev_id
+    end
+
+    def test_packager_key_changed
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_inspect").
+        to_return(status: 200, body: "", headers: {}))
+      logger = Minitest::Mock.new
+      logger.expect(:debug, nil) {|s| s =~ /\d* -> \d*/}
+      dev_id = Proc.new {"#{Random.rand(999999999999)}"}
+      config, options = build_config_options_objects(PackagerTest, {key: true, stage: "production"}, false)
+      packager = Packager.new(config: config)
+      Logger.class_variable_set(:@@instance, logger)
+      packager.stub(:dev_id, dev_id) do
+        packager.key(options: options)
+      end
+    end
+
+    def test_packager_key_same
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_inspect").
+        to_return(status: 200, body: "", headers: {}))
+      logger = Minitest::Mock.new
+      logger.expect(:info, nil) {|s| s =~ /did not change/}
+      logger.expect(:debug, nil) {|s| s =~ /\d* -> \d*/}
+      dev_id = Proc.new {"#{Random.rand(999999999999)}"}
+      config, options = build_config_options_objects(PackagerTest, {key: true, stage: "production"}, false)
+      packager = Packager.new(config: config)
+      Logger.class_variable_set(:@@instance, logger)
+      packager.stub(:dev_id, dev_id) do
+        packager.key(options: options)
+      end
+    end
+
+    def test_packager_generate_new_key
+      connection = Minitest::Mock.new()
+      connection.expect(:puts, nil, ["genkey"])
+      connection.expect(:waitfor, nil) do |config, &blk|
+        assert_equal(/./, config['Match'])
+        assert_equal(false, config['Timeout'])
+        txt = "Password: password\nDevID: devid\n"
+        blk.call(txt)
+        true
+      end
+      connection.expect(:close, nil, [])
+
+      config = build_config_options_objects(PackagerTest, {genkey: true}, false)[0]
+      packager = Packager.new(config: config)
+      Net::Telnet.stub(:new, connection) do
+        packager.send(:generate_new_key)
+      end
+    end
+
+    def test_packager_genkey
+      loader = Minitest::Mock.new
+      loader.expect(:sideload, nil, [Hash])
+
+      body = "<a href=\"pkgs\">pkg_url</a>"
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_package").
+         to_return(status: 200, body: body, headers: {}))
+      @requests.push(stub_request(:get, "http://192.168.0.100/pkgs/pkg_url").
+        to_return(status: 200, body: "", headers: {}))
+      config, options = build_config_options_objects(PackagerTest, {genkey: true}, false)
+      packager = Packager.new(config: config)
+      Loader.stub(:new, loader) do
+        packager.stub(:generate_new_key, ["password", "dev_id"]) do
+          packager.genkey(options: options)
+        end
+      end
+
+      loader.verify
+    end
+  end
+end

data/test/roku_builder/plugins/test_profiler.rb

@@ -0,0 +1,127 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+require_relative "../test_helper.rb"
+
+module RokuBuilder
+  class ProfilerTest < Minitest::Test
+    def setup
+      Logger.set_testing
+      RokuBuilder.setup_plugins
+      unless RokuBuilder.plugins.include?(Profiler)
+        RokuBuilder.register_plugin(Profiler)
+      end
+    end
+    def test_profiler_parse_options_long
+      parser = OptionParser.new
+      options = {}
+      Profiler.parse_options(parser: parser, options: options)
+      argv = ["roku", "--profile", "command"]
+      parser.parse! argv
+      assert_equal "command", options[:profile]
+    end
+    def test_profiler_stats
+      Logger.set_testing
+      options = {profile: "stats"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      waitfor = Proc.new do |telnet_config, &blk|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(5, telnet_config["Timeout"])
+        txt = "<All_Nodes><NodeA /><NodeB /><NodeC><NodeD /></NodeC></All_Nodes>\n"
+        blk.call(txt)
+        true
+      end
+      connection = Minitest::Mock.new
+      profiler = Profiler.new(config: config)
+
+      connection.expect(:puts, nil, ["sgnodes all\n"])
+      connection.expect(:waitfor, nil, &waitfor)
+
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:printf, nil) do
+          profiler.profile(options: options)
+        end
+      end
+
+      connection.verify
+    end
+    def test_profiler_all
+      Logger.set_testing
+      options = {profile: "all"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      waitfor = Proc.new do |telnet_config, &blk|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(5, telnet_config["Timeout"])
+        txt = "<All_Nodes><NodeA /><NodeB /><NodeC><NodeD /></NodeC></All_Nodes>\n"
+        blk.call(txt)
+        true
+      end
+      connection = Minitest::Mock.new
+      profiler = Profiler.new(config: config)
+
+      connection.expect(:puts, nil, ["sgnodes all\n"])
+      connection.expect(:waitfor, nil, &waitfor)
+
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:print, nil) do
+          profiler.profile(options: options)
+        end
+      end
+
+      connection.verify
+    end
+    def test_profiler_images
+      Logger.set_testing
+      options = {profile: "images"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      waitfor = Proc.new do |telnet_config, &blk|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(5, telnet_config["Timeout"])
+        txt = " RoGraphics instance\nAvailable memory\n"
+        blk.call(txt)
+        true
+      end
+      connection = Minitest::Mock.new
+      profiler = Profiler.new(config: config)
+
+      connection.expect(:puts, nil, ["r2d2_bitmaps\n"])
+      connection.expect(:waitfor, nil, &waitfor)
+
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:print, nil) do
+          profiler.profile(options: options)
+        end
+      end
+
+      connection.verify
+    end
+    def test_profiler_textures
+      Logger.set_testing
+      options = {profile: "textures"}
+      config, options = build_config_options_objects(ProfilerTest, options, false)
+      waitfor = Proc.new do |telnet_config, &blk|
+        assert_equal(/.+/, telnet_config["Match"])
+        assert_equal(5, telnet_config["Timeout"])
+        txt = "*******\ntexture\n"
+        blk.call(txt)
+        true
+      end
+      timeout = Proc.new do |telnet_config, &blk|
+        raise ::Net::ReadTimeout
+      end
+      connection = Minitest::Mock.new
+      profiler = Profiler.new(config: config)
+
+      connection.expect(:puts, nil, ["loaded_textures\n"])
+      connection.expect(:waitfor, nil, &waitfor)
+      connection.expect(:waitfor, nil, &timeout)
+
+      Net::Telnet.stub(:new, connection) do
+        profiler.stub(:print, nil) do
+          profiler.profile(options: options)
+        end
+      end
+
+      connection.verify
+    end
+  end
+end

data/test/roku_builder/plugins/test_scripter.rb

@@ -0,0 +1,110 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+require_relative "../test_helper.rb"
+
+module RokuBuilder
+  class ScripterTest < Minitest::Test
+    def setup
+      options = {print: "field", working: true}
+      RokuBuilder.setup_plugins
+      unless RokuBuilder.plugins.include?(Scripter)
+        RokuBuilder.register_plugin(Scripter)
+      end
+      @config, @options = build_config_options_objects(ScripterTest, options, false)
+    end
+    def test_scripter_parse_options_long
+      parser = OptionParser.new
+      options = {}
+      Scripter.parse_options(parser: parser, options: options)
+      argv = ["roku", "--print", "print"]
+      parser.parse! argv
+      assert_equal :print, options[:print]
+    end
+    def test_scripter_print_bad_attr
+      scripter = Scripter.new(config: @config)
+      assert_raises ExecutionError do
+        scripter.print(options: @options)
+      end
+    end
+
+    def test_scripter_print_config_root_dir
+      options = {print: :root_dir, working: true}
+      @config, @options = build_config_options_objects(ScripterTest, options, false)
+      call_count = 0
+      fake_print = lambda { |message, path|
+        assert_equal "%s", message
+        assert_equal @config.parsed[:root_dir], path
+        call_count+=1
+      }
+      scripter = Scripter.new(config: @config)
+      scripter.stub(:printf, fake_print) do
+        scripter.print(options: @options)
+      end
+      assert_equal 1, call_count
+    end
+    def test_scripter_print_config_app_name
+      options = {print: :app_name, working: true}
+      @config, @options = build_config_options_objects(ScripterTest, options, false)
+      call_count = 0
+      fake_print = lambda { |message, value|
+        assert_equal "%s", message
+        assert_equal "<app name>", value
+        call_count+=1
+      }
+      scripter = Scripter.new(config: @config)
+      scripter.stub(:printf, fake_print) do
+        scripter.print(options: @options)
+      end
+      assert_equal 1, call_count
+    end
+
+    def test_scripter_print_manifest_title
+      options = {print: :title, working: true}
+      @config, @options = build_config_options_objects(ScripterTest, options, false)
+      call_count = 0
+      fake_print = lambda { |message, title|
+        assert_equal "%s", message
+        assert_equal "Test", title
+        call_count+=1
+      }
+      scripter = Scripter.new(config: @config)
+      scripter.stub(:printf, fake_print) do
+        scripter.print(options: @options)
+      end
+      assert_equal 1, call_count
+    end
+
+    def test_scripter_print_manifest_build_version
+      options = {print: :build_version, working: true}
+      @config, @options = build_config_options_objects(ScripterTest, options, false)
+      call_count = 0
+      fake_print = lambda { |message, build|
+        assert_equal "%s", message
+        assert_equal "010101.1", build
+        call_count+=1
+      }
+      scripter = Scripter.new(config: @config)
+      scripter.stub(:printf, fake_print) do
+        scripter.print(options: @options)
+      end
+      assert_equal 1, call_count
+    end
+
+    def test_scripter_print_manifest_app_version
+      options = {print: :app_version, working: true}
+      @config, @options = build_config_options_objects(ScripterTest, options, false)
+      call_count = 0
+      fake_print = lambda { |message, major, minor|
+        assert_equal "%s.%s", message
+        assert_equal "1", major
+        assert_equal "0", minor
+        call_count+=1
+      }
+      scripter = Scripter.new(config: @config)
+      scripter.stub(:printf, fake_print) do
+        scripter.print(options: @options)
+      end
+      assert_equal 1, call_count
+    end
+  end
+end

data/test/roku_builder/plugins/test_tester.rb

@@ -0,0 +1,109 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+require_relative "../test_helper.rb"
+
+module RokuBuilder
+  class TesterTest < Minitest::Test
+    def setup
+      Logger.set_testing
+      RokuBuilder.setup_plugins
+      register_plugins(Tester)
+      @connection = Minitest::Mock.new
+      @requests = []
+
+      @requests.push(stub_request(:post, "http://192.168.0.100:8060/keypress/Home").
+        to_return(status: 200, body: "", headers: {}))
+      @requests.push(stub_request(:post, "http://192.168.0.100/plugin_install").
+        to_return(status: 200, body: "Install Success", headers: {}))
+      @requests.push(stub_request(:post, "http://192.168.0.100:8060/launch/dev?RunTests=true").
+        to_return(status: 200, body: "", headers: {}))
+    end
+    def teardown
+      @connection.verify
+      @requests.each {|req| remove_request_stub(req)}
+    end
+    def test_scripter_parse_options_long
+      parser = OptionParser.new
+      options = {}
+      Tester.parse_options(parser: parser, options: options)
+      argv = ["roku", "--test"]
+      parser.parse! argv
+      assert options[:test]
+    end
+    def test_tester_runtests
+      config, options = build_config_options_objects(TesterTest, {test: true, working: true}, false)
+      tester = Tester.new(config: config)
+
+      @connection.expect(:waitfor, nil, [/\*+\s*End testing\s*\*+/])
+      @connection.expect(:puts, nil, ["cont\n"])
+
+      Net::Telnet.stub(:new, @connection) do
+        tester.test(options: options)
+      end
+    end
+
+    def test_tester_runtests_and_handle
+      config, options = build_config_options_objects(TesterTest, {test: true, working: true}, false)
+      tester = Tester.new(config: config)
+
+      waitfor = Proc.new do |end_reg, &blk|
+        assert_equal(/\*+\s*End testing\s*\*+/, end_reg)
+        txt = "Fake Text"
+        blk.call(txt) == false
+      end
+
+      @connection.expect(:waitfor, nil, &waitfor)
+      @connection.expect(:puts, nil, ["cont\n"])
+
+      Net::Telnet.stub(:new, @connection) do
+        tester.stub(:handle_text, false) do
+          tester.test(options: options)
+        end
+      end
+    end
+
+    def test_tester_handle_text_no_text
+      config = build_config_options_objects(TesterTest, {test: true, working: true}, false)[0]
+      tester = Tester.new(config: config)
+
+      text = "this\nis\na\ntest\nparagraph"
+      tester.send(:handle_text, {txt: text})
+
+      refute tester.instance_variable_get(:@in_tests)
+    end
+
+    def test_tester_handle_text_all_text
+      config = build_config_options_objects(TesterTest, {test: true, working: true}, false)[0]
+      tester = Tester.new(config: 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
+
+    def test_tester_handle_text_partial_text
+      config = build_config_options_objects(TesterTest, {test: true, working: true}, false)[0]
+      tester = Tester.new(config: 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
+
+    def test_tester_handle_text_used_connection
+      config = build_config_options_objects(TesterTest, {test: true, working: true}, false)[0]
+      tester = Tester.new(config: config)
+
+      text = ["connection already in use"]
+
+      assert_raises IOError do
+        tester.send(:handle_text, {txt: text.join("\n")})
+      end
+    end
+  end
+end