roku_builder 3.3.2

data/lib/roku_builder/monitor.rb

@@ -0,0 +1,62 @@
+module RokuBuilder
+
+  # Monitor development Logs
+  class Monitor < Util
+
+    # Initialize port config
+    def init()
+      @ports = {
+        main: 8085,
+        sg: 8089,
+        task1: 8090,
+        task2: 8091,
+        task3: 8092,
+        taskX: 8093,
+      }
+    end
+
+    # Monitor a development log on the Roku device
+    # @param type [Symbol] The log type to monitor
+    # @param verbose [Boolean] Print status messages.
+    def monitor(type:)
+      telnet_config = {
+        'Host' => @roku_ip_address,
+        'Port' => @ports[type]
+      }
+      waitfor_config = {
+        'Match' => /./,
+        'Timeout' => false
+      }
+
+      thread = Thread.new(telnet_config, waitfor_config) {|telnet_config,waitfor_config|
+        @logger.info "Monitoring #{type} console(#{telnet_config['Port']}) on #{telnet_config['Host'] }"
+        connection = Net::Telnet.new(telnet_config)
+        Thread.current[:connection] = connection
+        all_text = ""
+        while true
+          connection.waitfor(waitfor_config) do |txt|
+            all_text += txt
+            while line = all_text.slice!(/^.*\n/) do
+              puts line
+            end
+            if all_text == "BrightScript Debugger> "
+              print all_text
+              all_text = ""
+            end
+          end
+        end
+      }
+      running = true
+      while running
+        @logger.info "Q to exit"
+        command = gets.chomp
+        if command == "q"
+          thread.exit
+          running = false
+        else
+          thread[:connection].puts(command)
+        end
+      end
+    end
+  end
+end

data/lib/roku_builder/navigator.rb

@@ -0,0 +1,107 @@
+module RokuBuilder
+
+  # Navigation methods
+  class Navigator < Util
+
+    # Setup navigation commands
+    def init
+      @commands = {
+        up: "Up",
+        down: "Down",
+        right: "Right",
+        left: "Left",
+        select: "Select",
+        back: "Back",
+        home: "Home",
+        rew: "Rev",
+        ff: "Fwd",
+        play: "Play",
+        replay: "InstantReplay"
+      }
+
+      @screens = {
+        platform: [:home, :home, :home, :home, :home, :ff, :play, :rew, :play, :ff],
+        secret: [:home, :home, :home, :home, :home, :ff, :ff, :ff, :rew, :rew],
+        secret2: [:home, :home, :home, :home, :home, :up, :right, :down, :left, :up],
+        channels: [:home, :home, :home, :up, :up, :left, :right, :left, :right, :left],
+        developer: [:home, :home, :home, :up, :up, :right, :left, :right, :left, :right],
+        wifi: [:home, :home, :home, :home, :home, :up, :down, :up, :down, :up],
+        antenna: [:home, :home, :home, :home, :home, :ff, :down, :rew, :down, :ff],
+        bitrate: [:home, :home, :home, :home, :home, :rew, :rew, :rew, :ff, :ff],
+        network: [:home, :home, :home, :home, :home, :right, :left, :right, :left, :right],
+        reboot: [:home, :home, :home, :home, :home, :up, :rew, :rew, :ff, :ff]
+      }
+    end
+
+    # Send a navigation command to the roku device
+    # @param command [Symbol] The smbol of the command to send
+    # @return [Boolean] Success
+    def nav(command:)
+      if @commands.has_key?(command)
+        conn = Faraday.new(url: "#{@url}:8060") do |f|
+          f.request :multipart
+          f.request :url_encoded
+          f.adapter Faraday.default_adapter
+        end
+
+        path = "/keypress/#{@commands[command]}"
+        response = conn.post path
+        return response.success?
+      else
+        return false
+      end
+    end
+
+    # Type text on the roku device
+    # @param text [String] The text to type on the device
+    # @return [Boolean] Success
+    def type(text:)
+      conn = Faraday.new(url: "#{@url}:8060") do |f|
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+      text.split(//).each do |c|
+        path = "/keypress/LIT_#{CGI::escape(c)}"
+        response = conn.post path
+        return false unless response.success?
+      end
+      return true
+    end
+
+    # Show the commands for one of the roku secret screens
+    # @param type [Symbol] The type of screen to show
+    # @return [Boolean] Screen found
+    def screen(type:)
+      if @screens.has_key?(type)
+        display = []
+        count = []
+        @screens[type].each do |command|
+          if display.count > 0 and  display[-1] == command
+            count[-1] = count[-1] + 1
+          else
+            display.push(command)
+            count.push(1)
+          end
+        end
+        string = ""
+        display.each_index do |i|
+          if count[i] > 1
+            string = string + @commands[display[i]]+" x "+count[i].to_s+", "
+          else
+            string = string + @commands[display[i]]+", "
+          end
+        end
+        @logger.unknown(string.strip)
+      else
+        return false
+      end
+      true
+    end
+
+    # Show avaiable roku secret screens
+    def screens
+      @screens.keys.each {|screen| @logger.unknown(screen)}
+    end
+  end
+end

data/lib/roku_builder/packager.rb

@@ -0,0 +1,47 @@
+module RokuBuilder
+
+  # Method of packaging app for submission
+  class Packager < Util
+
+    # Sign and download the currently sideloaded app
+    # @param app_name_version [String] The name and version of the package
+    # @param out_file [String] Location to download signed package to
+    # @param password [String] Password for the devices current key
+    # @return [Boolean] True on package success and download, false otherwise
+    def package(app_name_version:, out_file:, password:)
+      # Sign package
+      path = "/plugin_package"
+      conn = Faraday.new(url: @url) do |f|
+        f.headers['Content-Type'] = Faraday::Request::Multipart.mime_type
+        f.request :digest, @dev_username, @dev_password
+        f.request :multipart
+        f.request :url_encoded
+        f.adapter Faraday.default_adapter
+      end
+      payload =  {
+        mysubmit: "Package",
+        app_name: app_name_version,
+        passwd: password,
+        pkg_time: Time.now.to_i
+      }
+      response = conn.post path, payload
+
+      # Check for error
+      failed = /(Failed: [^\.]*\.)/.match(response.body)
+      return failed[1] if failed
+
+      # Download signed package
+      pkg = /<a href="pkgs[^>]*>([^<]*)</.match(response.body)[1]
+      path = "/pkgs/#{pkg}"
+      conn = Faraday.new(url: @url) do |f|
+        f.request :digest, @dev_username, @dev_password
+        f.adapter Faraday.default_adapter
+      end
+      response = conn.get path
+      return false if response.status != 200
+
+      File.open(out_file, 'w+') {|fp| fp.write(response.body)}
+      true
+    end
+  end
+end

data/lib/roku_builder/tester.rb

@@ -0,0 +1,32 @@
+module RokuBuilder
+
+  # Method for running unit tests
+  # This is intended to be used with the brstest librbary but should work
+  # with other testing libraries
+  class Tester < Util
+
+    # Run tests and report results
+    # @param sideload_config [Hash] The config for sideloading the app
+    def run_tests(sideload_config:)
+      telnet_config ={
+        'Host' => @roku_ip_address,
+        'Port' => 8085
+      }
+
+      loader = Loader.new(**@device_config)
+      connection = Net::Telnet.new(telnet_config)
+      loader.sideload(**sideload_config)
+
+      in_tests = false
+      end_reg = /\*\*\*\*\* ENDING TESTS \*\*\*\*\*/
+      connection.waitfor(end_reg) do |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 =~ /\*\*\*\*\* STARTING TESTS \*\*\*\*\*/
+        end
+      end
+      connection.puts("cont\n")
+    end
+  end
+end

data/lib/roku_builder/util.rb

@@ -0,0 +1,31 @@
+module RokuBuilder
+
+  # Super class for device utilities
+  # This class defines a common initializer and allows subclasses
+  # to define their own secondary initializer
+  class Util
+
+    # Common initializer of device utils
+    # @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:)
+      @device_config = {
+        ip: ip,
+        user: user,
+        password: password
+      }
+      @roku_ip_address = ip
+      @dev_username = user
+      @dev_password = password
+      @url = "http://#{@roku_ip_address}"
+      @logger = logger
+      init()
+    end
+
+    # Second initializer to be overwriten
+    def init
+      #Override in subclass
+    end
+  end
+end

data/lib/roku_builder/version.rb

@@ -0,0 +1,4 @@
+module RokuBuilder
+  # Version of the RokuBuilder Gem
+  VERSION = "3.3.2"
+end

data/rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.test_files = Dir.glob('tests/roku_builder/*_test.rb')
+end
+
+task(default: :test)

data/roku_builder.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'roku_builder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "roku_builder"
+  spec.version       = RokuBuilder::VERSION
+  spec.authors       = ["greeneca"]
+  spec.email         = ["charles.greene@redspace.com"]
+  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.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rubyzip",             "~> 1.1"
+  spec.add_dependency "faraday",             "~> 0.9"
+  spec.add_dependency "faraday-digestauth",  "~> 0.2"
+  spec.add_dependency "git",                 "~> 1.2.9"
+  spec.add_dependency "net-ping",            "~> 1.7"
+
+  spec.add_development_dependency "bundler",           "~> 1.7"
+  spec.add_development_dependency "rake",              "~> 10.0"
+  spec.add_development_dependency "byebug",            "~> 3.5"
+  spec.add_development_dependency "minitest",          "~> 5.8"
+  spec.add_development_dependency "minitest-autotest", "~> 1.0"
+  spec.add_development_dependency "minitest-server",   "~> 1.0"
+  spec.add_development_dependency "simplecov",         "~> 0.11"
+  spec.add_development_dependency "yard",              "~> 0.8.7"
+  spec.add_development_dependency "guard-livereload",  "~> 2.5"
+end

data/tests/roku_builder/config_manager_test.rb

@@ -0,0 +1,400 @@
+require_relative "test_helper.rb"
+
+class ConfigManagerTest < Minitest::Test
+
+  def test_config_manager_read_config
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    config = nil
+    File.stub(:open, io) do
+      config = RokuBuilder::ConfigManager.get_config(config: config_path, logger: logger)
+    end
+    io.verify
+    assert_equal :roku,  config[:devices][:default], :roku
+    assert_equal :project1, config[:projects][:default], :project1
+  end
+
+  def test_config_manager_validate_devices
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [1], codes
+  end
+
+  def test_config_manager_validate_devices_default
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:default] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [2], codes
+  end
+
+  def test_config_manager_validate_devices_default_is_symbol
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:default] = "bad"
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [3], codes
+  end
+
+  def test_config_manager_validate_device_ip
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:ip] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [7], codes
+  end
+
+  def test_config_manager_validate_device_ip_empty
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:ip] = ""
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [7], codes
+  end
+
+  def test_config_manager_validate_device_ip_default_value
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:ip] = "xxx.xxx.xxx.xxx"
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [7], codes
+  end
+
+  def test_config_manager_validate_device_user
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:user] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [8], codes
+  end
+
+  def test_config_manager_validate_device_user_empty
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:user] = ""
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [8], codes
+  end
+
+  def test_config_manager_validate_device_user_default_value
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:user] = "<username>"
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [8], codes
+  end
+
+  def test_config_manager_validate_device_password
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:password] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [9], codes
+  end
+
+  def test_config_manager_validate_device_password_empty
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:password] = ""
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [9], codes
+  end
+
+  def test_config_manager_validate_device_password_default_value
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:devices][:roku][:password] = "<password>"
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [9], codes
+  end
+
+  def test_config_manager_validate_projects
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [4], codes
+  end
+
+  def test_config_manager_validate_projects_default
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:default] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [5], codes
+  end
+
+  def test_config_manager_validate_projects_default_default_value
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:default] = "<project id>".to_sym
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [5], codes
+  end
+
+  def test_config_manager_validate_projects_default_is_symbol
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:default] = "project_id"
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [6], codes
+  end
+
+  def test_config_manager_validate_project_app_name
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:project1][:app_name] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [10], codes
+  end
+
+  def test_config_manager_validate_project_directory
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:project1][:directory] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [11], codes
+  end
+
+  def test_config_manager_validate_project_folders
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:project1][:folders] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [12], codes
+  end
+
+  def test_config_manager_validate_project_folders_is_array
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:project1][:folders] = "Folders"
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [13], codes
+  end
+
+  def test_config_manager_validate_project_files
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:project1][:files] = nil
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [14], codes
+  end
+
+  def test_config_manager_validate_project_filess_is_array
+    logger = Logger.new("/dev/null")
+    config = good_config
+    config[:projects][:project1][:files] = "Files"
+    codes = RokuBuilder::ConfigManager.validate_config(config: config, logger: logger)
+    assert_equal [15], codes
+  end
+
+  def test_config_manager_edit_ip
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    args = {
+      config: config_path,
+      options: "ip:192.168.0.200",
+      device: :roku,
+      project: nil,
+      stage: nil,
+      logger: logger
+    }
+    new_config = good_config
+    new_config[:devices][:roku][:ip] = "192.168.0.200"
+
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    io.expect(:write, nil, [JSON.pretty_generate(new_config)])
+    io.expect(:close, nil)
+    config = nil
+    File.stub(:open, io) do
+      RokuBuilder::ConfigManager.edit_config(**args)
+    end
+    io.verify
+  end
+
+  def test_config_manager_edit_user
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    args = {
+      config: config_path,
+      options: "user:new_user",
+      device: "roku",
+      project: nil,
+      stage: nil,
+      logger: logger
+    }
+    new_config = good_config
+    new_config[:devices][:roku][:user] = "new_user"
+
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    io.expect(:write, nil, [JSON.pretty_generate(new_config)])
+    io.expect(:close, nil)
+    config = nil
+    File.stub(:open, io) do
+      RokuBuilder::ConfigManager.edit_config(**args)
+    end
+    io.verify
+  end
+
+  def test_config_manager_edit_password
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    args = {
+      config: config_path,
+      options: "password:new_password",
+      device: nil,
+      project: nil,
+      stage: nil,
+      logger: logger
+    }
+    new_config = good_config
+    new_config[:devices][:roku][:password] = "new_password"
+
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    io.expect(:write, nil, [JSON.pretty_generate(new_config)])
+    io.expect(:close, nil)
+    config = nil
+    File.stub(:open, io) do
+      RokuBuilder::ConfigManager.edit_config(**args)
+    end
+    io.verify
+  end
+
+  def test_config_manager_edit_app_name
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    args = {
+      config: config_path,
+      options: "app_name:new name",
+      device: nil,
+      project: :project1,
+      stage: nil,
+      logger: logger
+    }
+    new_config = good_config
+    new_config[:projects][:project1][:app_name] = "new name"
+
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    io.expect(:write, nil, [JSON.pretty_generate(new_config)])
+    io.expect(:close, nil)
+    config = nil
+    File.stub(:open, io) do
+      RokuBuilder::ConfigManager.edit_config(**args)
+    end
+    io.verify
+  end
+
+  def test_config_manager_edit_directory
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    args = {
+      config: config_path,
+      options: "directory:new/directory/path",
+      device: nil,
+      project: "project1",
+      stage: nil,
+      logger: logger
+    }
+    new_config = good_config
+    new_config[:projects][:project1][:directory] = "new/directory/path"
+
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    io.expect(:write, nil, [JSON.pretty_generate(new_config)])
+    io.expect(:close, nil)
+    config = nil
+    File.stub(:open, io) do
+      RokuBuilder::ConfigManager.edit_config(**args)
+    end
+    io.verify
+  end
+
+  def test_config_manager_edit_branch
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    args = {
+      config: config_path,
+      options: "branch:new-branch",
+      device: nil,
+      project: nil,
+      stage: :production,
+      logger: logger
+    }
+    new_config = good_config
+    new_config[:projects][:project1][:stages][:production][:branch] = "new-branch"
+
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    io.expect(:write, nil, [JSON.pretty_generate(new_config)])
+    io.expect(:close, nil)
+    config = nil
+    File.stub(:open, io) do
+      RokuBuilder::ConfigManager.edit_config(**args)
+    end
+    io.verify
+  end
+
+  def test_config_manager_edit_default_stage
+    logger = Logger.new("/dev/null")
+    config_path = "config/file/path"
+    args = {
+      config: config_path,
+      options: "branch:new-branch",
+      device: nil,
+      project: nil,
+      stage: nil,
+      logger: logger
+    }
+    new_config = good_config
+    new_config[:projects][:project1][:stages][:production][:branch] = "new-branch"
+
+    io = Minitest::Mock.new
+    io.expect(:read, good_config.to_json)
+    io.expect(:write, nil, [JSON.pretty_generate(new_config)])
+    io.expect(:close, nil)
+    config = nil
+    File.stub(:open, io) do
+      RokuBuilder::ConfigManager.edit_config(**args)
+    end
+    io.verify
+  end
+
+  def good_config
+    {
+      devices: {
+        default: :roku,
+        roku: {
+          ip: "192.168.0.100",
+          user: "user",
+          password: "password"
+        }
+      },
+      projects: {
+        default: :project1,
+        project1: {
+          directory: "<path/to/repo>",
+          folders: ["resources","source"],
+          files: ["manifest"],
+          app_name: "<app name>",
+          stages:{
+            production: {
+              branch: "production",
+              key: {
+                keyed_pkg: "<path/to/signed/pkg>",
+                password: "<password for pkg>"
+              }
+            }
+          }
+        }
+      }
+    }
+  end
+end