roku_builder 3.13.0 → 4.0.0

data/test/roku_builder/test_monitor.rb

@@ -1,137 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-require_relative "test_helper.rb"
-
-module RokuBuilder
-  class MonitorTest < Minitest::Test
-    def test_monitor_monit
-      connection = Minitest::Mock.new
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password"
-      }
-      monitor = Monitor.new(**device_config)
-
-      connection.expect(:waitfor, nil) do |config|
-        assert_equal(/./, config['Match'])
-        assert_equal(false, config['Timeout'])
-      end
-
-      readline = proc {
-        sleep(0.1)
-        "q"
-      }
-
-      Readline.stub(:readline, readline) do
-        Net::Telnet.stub(:new, connection) do
-          monitor.monitor(type: :main)
-        end
-      end
-
-      connection.verify
-    end
-
-    def test_monitor_monit_and_manage
-      connection = Minitest::Mock.new
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password"
-      }
-      monitor = Monitor.new(**device_config)
-      monitor.instance_variable_set(:@show_prompt, true)
-
-      connection.expect(:waitfor, nil) do |config, &blk|
-      assert_equal(/./, config['Match'])
-      assert_equal(false, config['Timeout'])
-      txt = "Fake Text"
-      blk.call(txt) == ""
-      end
-
-      readline = proc {
-        sleep(0.1)
-        "q"
-      }
-
-      Readline.stub(:readline, readline) do
-        Net::Telnet.stub(:new, connection) do
-          monitor.stub(:manage_text, "") do
-            monitor.monitor(type: :main)
-          end
-        end
-      end
-
-      connection.verify
-    end
-
-    def test_monitor_monit_input
-      connection = Minitest::Mock.new
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password"
-      }
-      monitor = Monitor.new(**device_config)
-      monitor.instance_variable_set(:@show_prompt, true)
-
-      connection.expect(:waitfor, nil) do |config|
-        assert_equal(/./, config['Match'])
-        assert_equal(false, config['Timeout'])
-      end
-      connection.expect(:puts, nil) do |text|
-        assert_equal("text", text)
-        monitor.instance_variable_set(:@show_prompt, true)
-      end
-
-
-      readline = proc {
-        @count ||= 0
-        sleep(0.1)
-        case @count
-        when 0
-          @count += 1
-          "text"
-        else
-          "q"
-        end
-      }
-
-      Readline.stub(:readline, readline) do
-        Net::Telnet.stub(:new, connection) do
-          monitor.monitor(type: :main)
-        end
-      end
-
-      connection.verify
-    end
-
-    def test_monitor_manage_text
-      mock = Minitest::Mock.new
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password"
-      }
-      monitor = Monitor.new(**device_config)
-      monitor.instance_variable_set(:@show_prompt, true)
-      monitor.instance_variable_set(:@mock, mock)
-
-      def monitor.puts(input)
-        @mock.puts(input)
-      end
-
-      mock.expect(:puts, nil, ["midline split\n"])
-
-      all_text = "midline "
-      txt = "split\nBrightScript Debugger> "
-
-      result = monitor.send(:manage_text, {all_text: all_text, txt: txt})
-
-      assert_equal "", result
-
-      mock.verify
-
-    end
-  end
-end

data/test/roku_builder/test_navigator.rb

@@ -1,280 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-require_relative "test_helper.rb"
-
-module RokuBuilder
-  class NavigatorTest < Minitest::Test
-    def test_navigator_nav
-      commands = {
-        up: "Up",
-        down: "Down",
-        right: "Right",
-        left: "Left",
-        select: "Select",
-        back: "Back",
-        home: "Home",
-        rew: "Rev",
-        ff: "Fwd",
-        play: "Play",
-        replay: "InstantReplay"
-      }
-      commands.each {|k,v|
-        path = "/keypress/#{v}"
-        navigator_test(path: path, input: k, type: :nav)
-      }
-    end
-
-    def test_navigator_nav_fail
-      path = ""
-      navigator_test(path: path, input: :bad, type: :nav, success: false)
-    end
-
-    def test_navigator_type
-      path = "keypress/LIT_"
-      navigator_test(path: path, input: "Type", type: :text)
-    end
-
-    def navigator_test(path:, input:, type:, success: true)
-      connection = Minitest::Mock.new
-      faraday = Minitest::Mock.new
-      io = Minitest::Mock.new
-      response = Minitest::Mock.new
-
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-      if success
-        if type == :nav
-          connection.expect(:post, response, [path])
-          response.expect(:success?, true)
-        elsif type == :text
-          input.split(//).each do |c|
-            path = "/keypress/LIT_#{CGI::escape(c)}"
-            connection.expect(:post, response, [path])
-            response.expect(:success?, true)
-          end
-        end
-        faraday.expect(:headers, {})
-        faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
-        faraday.expect(:request, nil, [:multipart])
-        faraday.expect(:request, nil, [:url_encoded])
-        faraday.expect(:adapter, nil, [Faraday.default_adapter])
-      end if
-
-      navigator = Navigator.new(**device_config)
-      result = nil
-      Faraday.stub(:new, connection, faraday) do
-        if type == :nav
-          result = navigator.nav(commands: [input])
-        elsif type == :text
-          result = navigator.type(text: input)
-        end
-      end
-
-      assert_equal success, result
-
-      connection.verify
-      faraday.verify
-      io.verify
-      response.verify
-    end
-
-    def test_navigator_screen
-      logger = Minitest::Mock.new
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-      Logger.class_variable_set(:@@instance, logger)
-      navigator = Navigator.new(**device_config)
-
-      logger.expect(:info, nil, ["Home x 5, Fwd x 3, Rev x 2,"])
-      logger.expect(:unknown, nil, ["Cannot run command automatically"])
-      logger.expect(:unknown, nil, ["Home x 5, Up, Rev x 2, Fwd x 2,"])
-
-      navigator.stub(:nav, nil) do
-        navigator.screen(type: :secret)
-        navigator.screen(type: :reboot)
-      end
-
-      logger.verify
-      Logger.set_testing
-    end
-
-    def test_navigator_screen_fail
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-      navigator = Navigator.new(**device_config)
-
-      assert !navigator.screen(type: :bad)
-
-    end
-
-    def test_navigator_screens
-      logger = Minitest::Mock.new
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-      Logger.class_variable_set(:@@instance, logger)
-      navigator = Navigator.new(**device_config)
-
-      navigator.instance_variable_get("@screens").each_key do |key|
-        logger.expect(:unknown, nil, [key])
-      end
-
-      navigator.screens
-
-      logger.verify
-      Logger.set_testing
-    end
-
-    def test_navigator_read_char
-      getc = Minitest::Mock.new
-      chr = Minitest::Mock.new
-
-      getc.expect(:call, chr)
-      chr.expect(:chr, "a")
-
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-
-      navigator = Navigator.new(**device_config)
-      STDIN.stub(:echo=, nil) do
-        STDIN.stub(:raw!, nil) do
-          STDIN.stub(:getc, getc) do
-            assert_equal "a", navigator.read_char
-          end
-        end
-      end
-      getc.verify
-      chr.verify
-    end
-
-    def test_navigator_read_char_multichar
-      getc = Minitest::Mock.new
-      chr = Minitest::Mock.new
-      read_nonblock = Minitest::Mock.new
-
-      getc.expect(:call, chr)
-      chr.expect(:chr, "\e")
-      read_nonblock.expect(:call, "a", [3])
-      read_nonblock.expect(:call, "b", [2])
-
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-
-      navigator = Navigator.new(**device_config)
-      STDIN.stub(:echo=, nil) do
-        STDIN.stub(:raw!, nil) do
-          STDIN.stub(:getc, getc) do
-            STDIN.stub(:read_nonblock, read_nonblock) do
-              assert_equal "\eab", navigator.read_char
-            end
-          end
-        end
-      end
-      getc.verify
-      chr.verify
-    end
-
-    def test_navigator_interactive
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-      navigator = Navigator.new(**device_config)
-      navigator.stub(:read_char, "\u0003") do
-        navigator.interactive
-      end
-    end
-
-    def test_navigator_interactive_nav
-
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-
-      read_char = lambda {
-        @i ||= 0
-        char = nil
-        case(@i)
-        when 0
-          char = "<"
-        when 1
-          char = "\u0003"
-        end
-        @i += 1
-        char
-      }
-
-      nav = lambda { |args|
-        assert_equal :rev, args[:commands][0]
-      }
-
-      navigator = Navigator.new(**device_config)
-      navigator.stub(:read_char, read_char) do
-        navigator.stub(:nav, nav) do
-          navigator.interactive
-        end
-      end
-    end
-    def test_navigator_interactive_text
-
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password",
-        init_params: {mappings: {}}
-      }
-
-      read_char = lambda {
-        @i ||= 0
-        char = nil
-        case(@i)
-        when 0
-          char = "a"
-        when 1
-          char = "\u0003"
-        end
-        @i += 1
-        char
-      }
-
-      type = lambda { |args|
-        assert_equal "a", args[:text]
-      }
-
-      navigator = Navigator.new(**device_config)
-      navigator.stub(:read_char, read_char) do
-        navigator.stub(:type, type) do
-          navigator.interactive
-        end
-      end
-    end
-  end
-end

data/test/roku_builder/test_packager.rb

@@ -1,127 +0,0 @@
-# ********** Copyright Viacom, Inc. Apache 2.0 **********
-
-require_relative "test_helper.rb"
-
-module RokuBuilder
-  class PackagerTest < Minitest::Test
-    def test_packager_package_failed
-      connection = Minitest::Mock.new
-      faraday = Minitest::Mock.new
-      response = Minitest::Mock.new
-
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password"
-      }
-      payload = {
-        mysubmit: "Package",
-        app_name: "app_name",
-        passwd: "password",
-        pkg_time: 0
-      }
-      package_config ={
-        app_name_version: "app_name",
-        out_file: "out_file",
-        password: "password"
-      }
-      path = "/plugin_package"
-
-      faraday.expect(:headers, {})
-      faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
-      faraday.expect(:request, nil, [:multipart])
-      faraday.expect(:request, nil, [:url_encoded])
-      faraday.expect(:adapter, nil, [Faraday.default_adapter])
-      connection.expect(:post, response) do |arg1, arg2|
-        assert_equal path, arg1
-        assert_equal payload[:mysubmit], arg2[:mysubmit]
-        assert_equal payload[:app_name], arg2[:app_name]
-        assert_equal payload[:passwd], arg2[:passwd]
-        assert_equal payload[:pkg_time], arg2[:pkg_time]
-      end
-      response.expect(:body, "Failed: Error.")
-
-      packager = Packager.new(**device_config)
-      result = nil
-      Faraday.stub(:new, connection, faraday) do
-        Time.stub(:now, Time.at(0)) do
-          result = packager.package(**package_config)
-        end
-      end
-
-      assert_equal "Failed: Error.", result
-
-      connection.verify
-      faraday.verify
-      response.verify
-    end
-
-    def test_packager_package
-      connection = Minitest::Mock.new
-      faraday = Minitest::Mock.new
-      response = Minitest::Mock.new
-      io = Minitest::Mock.new
-
-      device_config = {
-        ip: "111.222.333",
-        user: "user",
-        password: "password"
-      }
-      payload = {
-        mysubmit: "Package",
-        app_name: "app_name",
-        passwd: "password",
-        pkg_time: 0
-      }
-      package_config ={
-        app_name_version: "app_name",
-        out_file: "out_file",
-        password: "password"
-      }
-      path = "/plugin_package"
-
-      faraday.expect(:headers, {})
-      faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
-      faraday.expect(:request, nil, [:multipart])
-      faraday.expect(:request, nil, [:url_encoded])
-      faraday.expect(:adapter, nil, [Faraday.default_adapter])
-
-      faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
-      faraday.expect(:adapter, nil, [Faraday.default_adapter])
-
-      connection.expect(:post, response) do |arg1, arg2|
-        assert_equal path, arg1
-        assert_equal payload[:mysubmit], arg2[:mysubmit]
-        assert_equal payload[:app_name], arg2[:app_name]
-        assert_equal payload[:passwd], arg2[:passwd]
-        assert_equal payload[:pkg_time], arg2[:pkg_time]
-      end
-      connection.expect(:get, response, ["/pkgs/pkg_url"])
-
-      response.expect(:body, "<a href=\"pkgs\">pkg_url</a>")
-      response.expect(:body, "<a href=\"pkgs\">pkg_url</a>")
-
-      response.expect(:status, 200)
-      response.expect(:body, "package_body")
-
-      io.expect(:write, nil, ["package_body"])
-
-      packager = Packager.new(**device_config)
-      result = nil
-      Faraday.stub(:new, connection, faraday) do
-        Time.stub(:now, Time.at(0)) do
-          File.stub(:open, nil, io) do
-            result = packager.package(**package_config)
-          end
-        end
-      end
-
-      assert_equal true, result
-
-      connection.verify
-      faraday.verify
-      response.verify
-      io.verify
-    end
-  end
-end