roku_builder 4.27.2 → 4.29.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efc602510a82d3cff193e13043545a4ce51ce65cc44efe011e95bfac75a6a820
-  data.tar.gz: b9d38640ea2be785eb4fc370216ab6f8cb82edf6e54027eed2a3abd2812a0c4a
+  metadata.gz: a74435c26dad5e136130516be10f397638bb374f4f105a8ca25c438193b39151
+  data.tar.gz: 1fa12ee0b271ae1506b5d3ffe028da016fbafa208eee996b6f9fbedd5dbb3a0e
 SHA512:
-  metadata.gz: ad5fa526a32f9fa53e12d78d6243eb2381c5b8c7c43877718c319c8eb70537eda7de8f649de242611155f1638f3730ea51cd5543d94d69b181d1c527d331b36a
-  data.tar.gz: e7bdab7f64cdbb74bc0bcae86b8c6d5b6b551ac4da95b0e547562470022bb32b25b3744a91e6f148a577eeb4ebd52093a86972e90e5ca07c517cb8abb88d08d8
+  metadata.gz: a7a74b63df763ff355473e8f1d5e90c80ea0805c8539edf43d189199876ebf7fd801322e45020ae9192c888c53e9de39f2e23d2ebe95ce581a4e0016fb2db493
+  data.tar.gz: 202e8b749f4b0aa46d6a0ebd18aabae4a3c486214d5945b823e1cc897b0a36a1ed3d351c07f0e49bf89e612df92bed68d860d3b1797ff89a92af63a9c3bd8313

data/lib/roku_builder/config.rb

@@ -23,7 +23,8 @@ module RokuBuilder
       load_config
     end
 
-    def parse(stage: nil)
+    def parse(stage: nil, options: nil)
+      @options = options if options
       @options[:stage] = stage if stage
       @parsed = ConfigParser.parse(options: @options, config: @config)
     end
@@ -126,7 +127,6 @@ module RokuBuilder
       if File.exist?(local_config_path) and !@loaded_configs.include?(File.expand_path(local_config_path))
         local_config_hash = read_config(File.open(local_config_path))
         add_missing_directories(local_config_hash)
-        local_sub_configs = "./.roku_config/*.json"
         @config = @config.deep_merge(local_config_hash)
         Dir.glob("./.roku_config/*.json").each do |sub_config_path|
           sub_config_hash = read_config(File.open(sub_config_path))

data/lib/roku_builder/config_parser.rb

@@ -22,6 +22,7 @@ module RokuBuilder
     def parse_config
       process_in_argument
       setup_devices
+      setup_api_keys
       setup_project
       setup_in_out_file
       setup_project_config
@@ -41,6 +42,10 @@ module RokuBuilder
       @parsed[:devices] = @config[:devices].select{|key, value| :default != key}
     end
 
+    def setup_api_keys
+      @parsed[:api_keys] = @config[:api_keys]
+    end
+
     def setup_project
       if project_required and not @options[:project]
         project = current_project

data/lib/roku_builder/config_validator.rb

@@ -26,7 +26,7 @@ module RokuBuilder
     KEY_MISSING_PATH          = 19
     KEY_MISSING_PASSWORD      = 20
     INVALID_MAPPING_INFO      = 21
-    #                         = 22
+    INVALID_API_KEY           = 22
     MISSING_STAGE_METHOD      = 23
 
     def initialize(config:)
@@ -63,7 +63,7 @@ module RokuBuilder
     def validate_config
       @codes = []
       validate_structure
-      [:projects, :devices, :keys, :input_mappings].each do |section|
+      [:projects, :devices, :keys, :input_mappings, :api_keys].each do |section|
         validate_section(section: section) if @config[section]
       end
       @codes.uniq!
@@ -174,6 +174,13 @@ module RokuBuilder
       process_errors(errors: errors)
     end
 
+    def validate_api_key(api_key:)
+      errors = [
+        [INVALID_API_KEY, (api_key.class != String)]
+      ]
+      process_errors(errors: errors)
+    end
+
     def process_errors(errors:)
       errors.each do |error|
         @codes.push(error[0]) if error[1]

data/lib/roku_builder/plugins/loader.rb

@@ -115,7 +115,7 @@ module RokuBuilder
       multipart_connection(device: device) do |conn|
         response = conn.post "/plugin_install", payload
       end
-      unless response.status == 200 and response.body =~ /squashfs file in internal memory/ or ignoreFailure
+      unless response.status == 200 and response.body =~ /Conversion succeeded/ or ignoreFailure
         raise ExecutionError, "Failed Converting to Squashfs"
       end
     end

data/lib/roku_builder/plugins/monitor.rb

@@ -135,7 +135,7 @@ module RokuBuilder
     #  @param txt [String] current string from telnet
     #  @param regexp [Regexp] regular expression to filter text on
     #  @return [String] remaining partial line text
-    def manage_text(all_text:, txt:, regexp: nil, logging: false, logfile:)
+    def manage_text(all_text:, txt:, regexp: nil, logging: false, logfile: nil)
       raise ExecutionError, "Connection Closed" unless txt
       if /connection is already in use/ =~ txt
         raise ExecutionError, "Connection is in use"

data/lib/roku_builder/plugins/packager.rb

@@ -82,7 +82,7 @@ module RokuBuilder
       get_device(device: device) do |device|
         oldId = dev_id(device: device)
 
-        raise ExecutionError, "Missing Key Config" unless @config.key
+        raise ExecutionError, "No Key Found For Stage #{options[:stage]}" unless @config.key
 
         # upload new key with password
         payload =  {

data/lib/roku_builder/plugins/rokuapi.rb

@@ -0,0 +1,184 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+module RokuBuilder
+
+  # Load/Unload/Build roku applications
+  class RokuAPI < Util
+    extend Plugin
+
+    HOST = "https://apipub.roku.com"
+
+    def init
+    end
+
+    def self.commands
+      {
+        submit: {source: false},
+        publish: {}
+      }
+    end
+
+    def self.parse_options(parser:, options:)
+      parser.separator "Commands:"
+      parser.on("--submit", 'Submit a package to the Roku Portal') do
+        options[:submit] = true
+      end
+      parser.on("--publish", 'Publish an app on the Roku Portal') do
+        options[:publish] = true
+      end
+      parser.separator "Options:"
+      parser.on("--channel-id ID", 'ID of the channel to submit to/publish') do |id|
+        options[:channel_id] = id
+      end
+      parser.on("--api-key KEY", 'The API key to use to submit/publish') do |key|
+        options[:api_key] = key
+      end
+      parser.on("--no-publish", 'Prevent the channel from being automatically published when submitted') do
+        options[:no_publish] = true
+      end 
+    end
+
+    def self.dependencies
+      []
+    end
+
+    def submit(options:)
+      raise RokuBuilder::InvalidOptions, "Missing channel id" unless options[:channel_id]
+      @logger.info "Submit to channel #{options[:channel_id]}"
+      @api_key = options[:api_key]
+      @no_publish = !!options[:no_publish]
+      response = get_channel_versions(options[:channel_id])
+      if response.first["channelState"] == "Unpublished"
+        response = update_channel_version(options[:channel_id], get_package(options), response.last["id"])
+      else
+        response = create_channel_version(options[:channel_id], get_package(options))
+      end
+      raise RokuBuilder::ExecutionError, "Request failed: #{response.reason_phrase}" unless response.success?
+      JSON.parse(response.body)
+    end
+
+    def publish(options:)
+      raise RokuBuilder::InvalidOptions, "Missing channel id" unless options[:channel_id]
+      @logger.info "Publish to channel #{options[:channel_id]}"
+      @api_key = options[:api_key]
+      response = get_channel_versions(options[:channel_id])
+      raise RokuBuilder::ExecutionError unless response.first["channelState"] == "Unpublished"
+      response = publish_channel_version(options[:channel_id], response.first["id"])
+      raise RokuBuilder::ExecutionError, "Request failed: #{response.reason_phrase}" unless response.success?
+      JSON.parse(response.body)
+    end
+
+    private
+
+    def get_package(options)
+      File.open(options[:in])
+    end
+
+    def api_path
+      "/developer/v1"
+    end
+
+    def get_channel_versions(channel)
+      path = "/external/channels/#{channel}/versions"
+      response = api_get(path)
+      sorted_versions(JSON.parse(response.body))
+    end
+
+    def sorted_versions(versions)
+      sorted = versions.sort do |a, b|
+        aa, ab = a["version"].split(".").map{|i| i.to_i}
+        ba, bb = b["version"].split(".").map{|i| i.to_i}
+        value = (aa == ba ? bb <=> ab : ba <=> aa)
+        value
+      end
+      sorted
+    end
+    
+    def create_channel_version(channel, package)
+      path = "/external/channels/#{channel}/versions"
+      params = nil
+      unless @no_publish
+        params = {"channelState" => "Published"}
+      end
+      api_post(path, path, package, params)
+    end
+
+    def update_channel_version(channel, package, version)
+      path = "/external/channel/#{channel}/#{version}"
+      token_path = "/external/channels/#{channel}/#{version}"
+      api_patch(path, token_path, package)
+    end
+
+    def publish_channel_version(channel, version)
+      path = "/external/channels/#{channel}/versions/#{version}"
+      token_path = "/external/channels/#{channel}/versions/#{version}/state"
+      api_post(path, token_path)
+    end
+
+    def api_get(path)
+      service_urn = "urn:roku:cloud-services:chanprovsvc"
+      connection('GET', path, nil).get(api_path+path)
+    end
+
+    def api_post(path, token_path, package=nil, params = nil)
+      body = {}.to_json
+      if package
+        body = {
+          "appFileBase64Encoded" => Base64.encode64(package.read)
+        }.to_json
+      end
+      connection('POST', token_path, body).post(api_path+path) do |request|
+        if params
+          request.params = params
+        end if
+        request.body = body
+      end
+    end
+
+    def api_patch(path, token_path, package)
+      body = {
+        "path" => "/appFileBase64Encoded",
+        "value" => Base64.encode64(package.read),
+        "op" => "replace"
+      }.to_json
+      response = connection('PATCH', token_path, body).patch(api_path+path) do |request|
+        request.body = body
+      end
+    end
+
+    def connection(method, path, body)
+      service_urn = "urn:roku:cloud-services:chanprovsvc"
+      connection = Faraday.new(url: HOST, headers: {
+        'Authorization' => "Bearer "+get_jwt_token(@api_key, service_urn, method, path, body),
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/json',
+      }) do |f|
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def get_jwt_token(api_key, service_urn, method, path, body = nil)
+      key_file = File.expand_path(@config.api_keys[api_key.to_sym])
+      raise InvalidOptions "Missing api key" unless key_file
+      jwk = JWT::JWK.new(JSON.parse(File.read(key_file)))
+      header = {
+        "typ" => "JWT",
+        "kid" => jwk.export[:kid]
+      }
+      payload = {
+        "exp" => (Time.now + (12*60*60)).to_i,
+        "x-roku-request-key" => SecureRandom.uuid,
+        "x-roku-request-spec" => {
+          "serviceUrn" => service_urn,
+          "httpMethod" => method,
+          "path" => path,
+        }
+      }
+      if body
+        payload["x-roku-request-spec"]["bodySha256Base64"] = Digest::SHA256.base64digest(body)
+      end
+      JWT.encode(payload, jwk.signing_key, 'RS256', header)
+    end
+  end
+  RokuBuilder.register_plugin(RokuAPI)
+end

data/lib/roku_builder/version.rb

@@ -2,5 +2,5 @@
 
 module RokuBuilder
   # Version of the RokuBuilder Gem
-  VERSION = "4.27.2"
+  VERSION = "4.29.1"
 end

data/lib/roku_builder.rb

@@ -27,6 +27,9 @@ require "tmpdir"
 require "zip"
 #analyzer
 require "image_size"
+#rokuapi
+require "jwt"
+require "base64"
 
 
 Dir.glob(File.join(File.dirname(__FILE__), "roku_builder", "*.rb")).each do |path|

data/roku_builder.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "nokogiri",            "~> 1.12"
   spec.add_dependency "win32-security",      "~> 0.5" # For windows compatibility
   spec.add_dependency "image_size",          "~> 2.0"
+  spec.add_dependency "jwt",                 "~> 2.7"
 
   spec.add_development_dependency "bundler",           "~> 2.0"
   spec.add_development_dependency "rake",              "~> 12.0"

data/test/roku_builder/plugins/test_analyzer.rb

@@ -153,11 +153,10 @@ module RokuBuilder
       logger.expect(severity, nil, [String])
 
       ::Logger.stub :new, logger do
-        warnings = test_file(text: text, quiet: false)
+        test_file(text: text, quiet: false)
       end
 
       logger.verify
-      warnings
     end
 
     def test(quiet=true)

data/test/roku_builder/plugins/test_core.rb

@@ -120,8 +120,6 @@ module RokuBuilder
       assert help_text
     end
     def test_core_get_plugin_by_name
-      parser = OptionParser.new
-      options = {}
       plugin_name = Core.get_plugin_by_name("core")
       refute_nil plugin_name
       assert_match "RokuBuilder::Core", plugin_name.to_s

data/test/roku_builder/plugins/test_loader.rb

@@ -136,7 +136,7 @@ module RokuBuilder
     end
     def test_loader_squash
       @request_stubs.push(stub_request(:post, "http://#{@device_config[:ip]}/plugin_install").
-        to_return(status: 200, body: "squashfs file in internal memory", headers: {}))
+        to_return(status: 200, body: "Conversion succeeded", headers: {}))
       @device_manager.expect(:reserve_device, @device, no_lock: false)
       @device_manager.expect(:release_device, nil, [@device])
 

data/test/roku_builder/plugins/test_rokuapi.rb

@@ -0,0 +1,557 @@
+# ********** Copyright Viacom, Inc. Apache 2.0 **********
+
+require_relative "../test_helper.rb"
+
+module RokuBuilder
+  class RokuAPITest < Minitest::Test
+    def setup
+      Logger.set_testing
+      RokuBuilder.class_variable_set(:@@dev, false)
+      RokuBuilder.setup_plugins
+      register_plugins(RokuAPI)
+      @config, @options = build_config_options_objects(RokuAPITest, {submit: true, channel_id: "1234", api_key: "key1"}, false)
+      @requests = []
+    end
+
+    def teardown
+      @requests.each {|req| remove_request_stub(req)}
+      WebMock.reset!
+    end
+
+    def test_commands
+      commands = RokuAPI.commands
+      refute_nil commands[:submit]
+      refute_nil commands[:publish]
+    end
+
+    def test_parse_options
+      parser = OptionParser.new
+      options = {}
+      RokuAPI.parse_options(parser: parser, options: options)
+      argv = ["roku", "--submit", "--publish", "--channel-id", "1234", "--api-key", "key1", "--no-publish"]
+      parser.parse! argv
+      assert options[:submit]
+      assert options[:publish]
+      assert_equal options[:channel_id], "1234"
+      assert_equal options[:api_key], "key1"
+      assert options[:no_publish]
+    end
+
+    def test_dependencies
+      assert_kind_of Array, RokuAPI.dependencies
+      assert_equal RokuAPI.dependencies.count, 0
+    end
+
+    def test_get_package
+      api = RokuAPI.new(config: @config)
+      options = {in: "in/path"}
+      called = false
+      open_proc = proc do |path|
+        called = true
+        assert_equal options[:in], path
+      end
+      File.stub(:open, open_proc) do
+        api.send(:get_package, options)
+      end
+      assert called
+    end
+
+    def test_api_path
+      api = RokuAPI.new(config: @config)
+      assert_equal "/developer/v1", api.send(:api_path)
+    end
+
+    def test_sorted_versions
+      api = RokuAPI.new(config: @config)
+      versions = [{"version" => "1.9"}, {"version" => "1.11"}, {"version" => "2.3"}, {"version" => "2.4"}]
+      sorted = api.send(:sorted_versions, versions)
+      assert_equal "2.4", sorted[0]["version"]
+      assert_equal "2.3", sorted[1]["version"]
+      assert_equal "1.11", sorted[2]["version"]
+      assert_equal "1.9", sorted[3]["version"]
+      versions = [{"version" => "1.4"}, {"version" => "1.3"}]
+      sorted = api.send(:sorted_versions, versions)
+      assert_equal "1.4", sorted[0]["version"]
+      assert_equal "1.3", sorted[1]["version"]
+    end
+
+    def test_get_jwt_token
+      api = RokuAPI.new(config: @config)
+      urn = "test:urn"
+      method = "GET"
+      path = "/test/path"
+      token = api.send(:get_jwt_token, @options[:api_key], urn, method, path)
+      jwk = JWT::JWK.new(JSON.parse(File.read(@config.api_keys[:key1])))
+      decoded = JWT.decode(token, jwk.public_key, true, {algorithm: 'RS256'})
+      assert_equal decoded[1]["typ"], "JWT"
+      assert_equal decoded[1]["alg"], "RS256"
+      assert_equal decoded[1]["kid"], jwk.export[:kid]
+
+      assert is_uuid?(decoded[0]["x-roku-request-key"])
+      spec = decoded[0]["x-roku-request-spec"]
+      refute_nil spec
+      assert_equal spec["serviceUrn"], urn
+      assert_equal spec["httpMethod"], method
+      assert_equal spec["path"], path
+    end
+
+    def test_get_jwt_token_with_body
+      api = RokuAPI.new(config: @config)
+      urn = "test:urn"
+      method = "GET"
+      path = "/test/path"
+      body = {
+        "appFileBase64Encoded" => Base64.encode64(File.open(File.join(test_files_path(RokuAPITest), "test.pkg")).read)
+      }
+      sha256 = Digest::SHA256.base64digest(body.to_json)
+      token = api.send(:get_jwt_token, @options[:api_key], urn, method, path, body.to_json)
+      jwk = JWT::JWK.new(JSON.parse(File.read(@config.api_keys[:key1])))
+      decoded = JWT.decode(token, jwk.public_key, true, {algorithm: 'RS256'})
+      assert_equal decoded[1]["typ"], "JWT"
+      assert_equal decoded[1]["alg"], "RS256"
+      assert_equal decoded[1]["kid"], jwk.export[:kid]
+
+      assert is_uuid?(decoded[0]["x-roku-request-key"])
+      spec = decoded[0]["x-roku-request-spec"]
+      refute_nil spec
+      assert_equal spec["serviceUrn"], urn
+      assert_equal spec["httpMethod"], method
+      assert_equal spec["path"], path
+      assert_equal spec["bodySha256Base64"], sha256
+    end
+
+    def test_api_get
+      api = RokuAPI.new(config: @config)
+      path = "/test/path"
+      api.instance_variable_set(:@api_key, "key1")
+      @requests.push(stub_request(:any, /apipub.roku.com.*/))
+      response = api.send(:api_get, path)
+      assert_requested(:get, "https://apipub.roku.com/developer/v1/test/path", headers: {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+        "Authorization" => /Bearer .*/
+      })
+    end
+
+    def test_api_post
+      api = RokuAPI.new(config: @config)
+      path = "/test/path"
+      token_path = "/other/path"
+      api.instance_variable_set(:@api_key, "key1")
+      package = File.open(File.join(test_files_path(RokuAPITest), "test.pkg"))
+      encoded = Base64.encode64(package.read)
+      @requests.push(stub_request(:any, /apipub.roku.com.*/))
+      called = false
+      jwt_proc = proc do |api_key, service_urn, method, path, body|
+        called = true
+        assert_equal path, token_path
+        "token"
+      end
+      params = {"status" => "Published"}
+      api.stub(:get_jwt_token, jwt_proc) do 
+        response = api.send(:api_post, path, token_path, package, params)
+      end
+      assert called
+      assert_requested(:post, "https://apipub.roku.com/developer/v1/test/path", 
+                       body: {"appFileBase64Encoded" => encoded}.to_json,
+                       headers: {
+                         "Accept" => "application/json",
+                         "Content-Type" => "application/json",
+                         "Authorization" => /Bearer token/
+                       },
+                       query: {"status" => "Published"}
+                      )
+    end
+
+    def test_api_post_no_package
+      api = RokuAPI.new(config: @config)
+      path = "/test/path"
+      token_path = "/other/path"
+      api.instance_variable_set(:@api_key, "key1")
+      @requests.push(stub_request(:any, /apipub.roku.com.*/))
+      called = false
+      jwt_proc = proc do |api_key, service_urn, method, path, body|
+        called = true
+        assert_equal path, token_path
+        "token"
+      end
+      api.stub(:get_jwt_token, jwt_proc) do 
+        response = api.send(:api_post, path, token_path)
+      end
+      assert called
+      assert_requested(:post, "https://apipub.roku.com/developer/v1/test/path", 
+                       headers: {
+                         "Accept" => "application/json",
+                         "Content-Type" => "application/json",
+                         "Authorization" => /Bearer .*/
+                       }
+                      )
+    end
+
+    def test_api_patch
+      api = RokuAPI.new(config: @config)
+      path = "/test/path"
+      token_path = "/other/path"
+      api.instance_variable_set(:@api_key, "key1")
+      package = File.open(File.join(test_files_path(RokuAPITest), "test.pkg"))
+      encoded = Base64.encode64(package.read)
+      @requests.push(stub_request(:any, /apipub.roku.com.*/))
+      called = false
+      jwt_proc = proc do |api_key, service_urn, method, path, body|
+        called = true
+        assert_equal path, token_path
+        "token"
+      end
+      api.stub(:get_jwt_token, jwt_proc) do 
+        response = api.send(:api_patch, path, token_path, package)
+      end
+      assert called
+      assert_requested(:patch, "https://apipub.roku.com/developer/v1/test/path", 
+                       body: {"path" => "/appFileBase64Encoded", "value" => encoded, "op" => "replace"}.to_json,
+                       headers: {
+                         "Accept" => "application/json",
+                         "Content-Type" => "application/json",
+                         "Authorization" => /Bearer token/
+                       }
+                      )
+    end
+
+    def test_get_channel_versions
+      api = RokuAPI.new(config: @config)
+      channel = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      response = Minitest::Mock.new
+      body = { "id" => "1234", "version" => "1.1"}
+      response.expect(:body, body.to_json)
+      called = 0
+      get_proc = proc do |path|
+        called +=1
+        assert_equal path, "/external/channels/#{channel}/versions"
+        response
+      end
+      sort_proc = proc do |versions|
+        called += 1
+        versions
+      end
+      api.stub(:api_get, get_proc) do
+        api.stub(:sorted_versions, sort_proc) do
+          result = api.send(:get_channel_versions, channel)
+          assert_equal result, body
+        end
+      end
+      assert_equal 2, called
+    end
+
+    def test_submit_no_channel_id
+      api = RokuAPI.new(config: @config)
+      assert_raises RokuBuilder::InvalidOptions do
+        api.submit(options: {})
+      end
+    end
+
+    def test_submit_without_unpublished
+      api = RokuAPI.new(config: @config)
+      called = {}
+      @options[:no_publish] = true
+      response = Minitest::Mock.new
+      response.expect(:success?, true)
+      response.expect(:body, api_versions[0].to_json)
+      updated = proc {called[:updated] = true; response}
+      created = proc {called[:created] = true; response}
+      @requests.push(stub_request(:any, "https://apipub.roku.com/developer/v1/external/channels/1234/versions").to_return(
+        body: api_versions.to_json
+      ))
+      api.stub(:create_channel_version, created) do
+        api.stub(:update_channel_version, updated) do
+          api.stub(:get_package, "") do
+            api.submit(options: @options)
+          end
+        end
+      end
+      assert called[:created]
+      assert_nil called[:updated]
+      assert api.instance_variable_get(:@no_publish)
+
+    end
+    def test_submit_without_latest_unpublished
+      api = RokuAPI.new(config: @config)
+      called = {}
+      body = api_versions
+      body.push(api_versions.first)
+      body[1]["version"] = "1.3"
+      body[1]["channelState"] = "Unpublished"
+      response = Minitest::Mock.new
+      response.expect(:success?, true)
+      response.expect(:body, body[0].to_json)
+      updated = proc {called[:updated] = true; response}
+      created = proc {called[:created] = true; response}
+      @requests.push(stub_request(:any, "https://apipub.roku.com/developer/v1/external/channels/1234/versions").to_return(
+        body: body.to_json
+      ))
+      api.stub(:create_channel_version, created) do
+        api.stub(:update_channel_version, updated) do
+          api.stub(:get_package, "") do
+            api.submit(options: @options)
+          end
+        end
+      end
+      assert called[:created]
+      assert_nil called[:updated]
+    end
+
+    def test_submit_with_unpublished
+      api = RokuAPI.new(config: @config)
+      body = api_versions
+      body[0]["channelState"] = "Unpublished"
+      called = {}
+      response = Minitest::Mock.new
+      response.expect(:success?, true)
+      response.expect(:body, body[0].to_json)
+      updated = proc do |channel, package, version|
+        called[:updated] = true
+        assert_equal body[0]["id"], version
+        response
+      end
+      created = proc {called[:created] = true; response}
+      @requests.push(stub_request(:any, "https://apipub.roku.com/developer/v1/external/channels/1234/versions").to_return(
+        body: body.to_json
+      ))
+      api.stub(:create_channel_version, created) do
+        api.stub(:update_channel_version, updated) do
+          api.stub(:get_package, "") do
+            api.submit(options: @options)
+          end
+        end
+      end
+      assert called[:updated]
+      assert_nil called[:created]
+    end
+
+    def test_create_channel_version
+      api = RokuAPI.new(config: @config)
+      channel = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      package = File.open(File.join(test_files_path(RokuAPITest), "test.pkg"))
+      called = false
+      post_proc = proc do |path, token_path, package, params|
+        called = true
+        assert_equal path, "/external/channels/#{channel}/versions"
+        assert_equal token_path, "/external/channels/#{channel}/versions"
+        assert_equal "Published", params["channelState"]
+        assert_kind_of File, package
+      end
+      api.stub(:api_post, post_proc) do
+        api.send(:create_channel_version, channel, package)
+      end
+      assert called
+    end
+
+    def test_create_channel_version_no_publish
+      api = RokuAPI.new(config: @config)
+      channel = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      api.instance_variable_set(:@no_publish, true)
+      package = File.open(File.join(test_files_path(RokuAPITest), "test.pkg"))
+      called = false
+      post_proc = proc do |path, token_path, package, params|
+        called = true
+        assert_equal path, "/external/channels/#{channel}/versions"
+        assert_equal token_path, "/external/channels/#{channel}/versions"
+        assert_nil params
+        assert_kind_of File, package
+      end
+      api.stub(:api_post, post_proc) do
+        api.send(:create_channel_version, channel, package)
+      end
+      assert called
+    end
+
+    def test_update_channel_version
+      api = RokuAPI.new(config: @config)
+      channel = "1234"
+      version = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      package = File.open(File.join(test_files_path(RokuAPITest), "test.pkg"))
+      called = false
+      patch_proc = proc do |path, token_path, package|
+        called = true
+        assert_equal path, "/external/channel/#{channel}/#{version}"
+        assert_equal token_path, "/external/channels/#{channel}/#{version}"
+        assert_kind_of File, package
+      end
+      api.stub(:api_patch, patch_proc) do
+        api.send(:update_channel_version, channel, package, version)
+      end
+      assert called
+    end
+
+    def test_publish_no_channel_id
+      api = RokuAPI.new(config: @config)
+      assert_raises RokuBuilder::InvalidOptions do
+        params = {options: {}}
+        api.send(:publish, **params)
+      end
+    end
+
+    def test_publish_without_unpublished
+      api = RokuAPI.new(config: @config)
+      expected_channel = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      body = api_versions
+      called = false
+      get_proc = proc do |channel|
+        called = true
+        assert_equal expected_channel, channel
+        body
+      end
+      api.stub(:get_channel_versions, get_proc) do
+        assert_raises RokuBuilder::ExecutionError do
+          params = {options: {channel_id: expected_channel}}
+          api.send(:publish, **params)
+        end
+      end
+      assert called
+    end
+
+    def test_publish_without_latest_unpublished
+      api = RokuAPI.new(config: @config)
+      expected_channel = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      body = api_versions
+      body.push(api_versions.first)
+      body[1]["version"] = "1.3"
+      body[1]["channelState"] = "Unpublished"
+      called = false
+      get_proc = proc do |channel|
+        called = true
+        assert_equal expected_channel, channel
+        body
+      end
+      api.stub(:get_channel_versions, get_proc) do
+        assert_raises RokuBuilder::ExecutionError do
+          params = {options: {channel_id: expected_channel}}
+          api.send(:publish, **params)
+        end
+      end
+      assert called
+    end
+
+    def test_publish_with_unpublished
+      api = RokuAPI.new(config: @config)
+      expected_channel = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      body = [{ "id" => "1234", "version" => "1.1", "channelState" => "Unpublished"}]
+      called = 0
+      get_proc = proc do |channel|
+        called += 1
+        assert_equal expected_channel, channel
+        body
+      end
+      response = Minitest::Mock.new
+      response.expect(:success?, true)
+      response.expect(:body, body[0].to_json)
+      post_proc = proc do |channel, version|
+        called += 1
+        assert_equal expected_channel, channel
+        assert_equal body.first["id"], version
+        response
+      end
+      api.stub(:get_channel_versions, get_proc) do
+        api.stub(:publish_channel_version, post_proc) do
+          params = {options: {channel_id: expected_channel}}
+          api.send(:publish, **params)
+        end
+      end
+      assert_equal called, 2
+    end
+
+    def test_publish_channel_version
+      api = RokuAPI.new(config: @config)
+      channel = "1234"
+      api.instance_variable_set(:@api_key, "key1")
+      response = Minitest::Mock.new
+      body = { "id" => "1234", "version" => "1.1"}
+      response.expect(:body, body.to_json)
+      called = false
+      post_proc = proc do |path, token_path|
+        called = true
+        assert_equal path, "/external/channels/#{channel}/versions/#{body["id"]}"
+        assert_equal token_path, "/external/channels/#{channel}/versions/#{body["id"]}/state"
+      end
+      api.stub(:api_post, post_proc) do
+        api.send(:publish_channel_version, channel, body["id"])
+      end
+      assert called
+    end
+
+    def test_submit_failure_create
+      api = RokuAPI.new(config: @config)
+      response = Minitest::Mock.new
+      response.expect(:success?, false)
+      response.expect(:reason_phrase, "reason")
+      api.stub(:get_channel_versions, api_versions) do 
+        api.stub(:create_channel_version, response) do
+          api.stub(:get_package, "") do
+            assert_raises RokuBuilder::ExecutionError do
+              api.submit(options: @options)
+            end 
+          end 
+        end 
+      end 
+      assert_mock response
+    end
+
+    def test_submit_response_created
+      api = RokuAPI.new(config: @config)
+      body = { "id" => "1234", "version" => "1.1"}
+      response = Minitest::Mock.new
+      response.expect(:success?, true)
+      response.expect(:body, body.to_json)
+      api.stub(:get_channel_versions, api_versions) do 
+        api.stub(:create_channel_version, response) do
+          api.stub(:get_package, "") do
+            response_json = api.submit(options: @options)
+            assert_equal body, response_json
+          end 
+        end 
+      end 
+      assert_mock response
+    end
+
+    def test_submit_response_updated
+      api = RokuAPI.new(config: @config)
+      body = { "id" => "1234", "version" => "1.1"}
+      response = Minitest::Mock.new
+      response.expect(:success?, true)
+      response.expect(:body, body.to_json)
+      versions = api_versions
+      versions[0]["channelState"] = "Unpublished"
+      api.stub(:get_channel_versions, versions) do 
+        api.stub(:update_channel_version, response) do
+          api.stub(:get_package, "") do
+            response_json = api.submit(options: @options)
+            assert_equal body, response_json
+          end 
+        end 
+      end 
+      assert_mock response
+    end
+
+    def test_publish_response
+      api = RokuAPI.new(config: @config)
+      body = { "id" => "1234", "version" => "1.1"}
+      response = Minitest::Mock.new
+      response.expect(:success?, true)
+      response.expect(:body, body.to_json)
+      versions = api_versions
+      versions[0]["channelState"] = "Unpublished"
+      api.stub(:get_channel_versions, versions) do 
+        api.stub(:publish_channel_version, response) do
+          response_json = api.publish(options: @options)
+          assert_equal body, response_json
+        end 
+      end 
+      assert_mock response
+    end
+  end
+end

data/test/roku_builder/test_config_parser.rb

@@ -44,6 +44,22 @@ module RokuBuilder
       assert_equal File.join(Dir.pwd, "infile"), configs[:root_dir]
     end
 
+    def test_api_keys
+      options = build_options({
+        current: true,
+        validate: true
+      })
+      config = good_config(ConfigParserTest)
+      configs = nil
+      File.stub(:exist?, true) do
+        configs = ConfigParser.parse(options: options, config: config)
+      end
+
+      assert_kind_of Hash, configs
+      assert_kind_of Hash, configs[:api_keys]
+      assert_equal configs[:api_keys][:key1], File.join(test_files_path(ConfigParserTest), "test_key.json")
+    end
+
     def test_manifest_config_current
       options = build_options({
         current: true,

data/test/roku_builder/test_config_validator.rb

@@ -216,5 +216,19 @@ module RokuBuilder
       validator = ConfigValidator.new(config: config)
       assert_equal [12], validator.instance_variable_get(:@codes)
     end
+
+    def test_config_validate_invalid_api_key
+      config = good_config
+      config[:api_keys][:key1] = nil
+      validator = ConfigValidator.new(config: config)
+      assert_equal [22], validator.instance_variable_get(:@codes)
+    end
+
+    def test_confif_validate_no_api_keys
+      config = good_config
+      config[:api_keys] = nil
+      validator = ConfigValidator.new(config: config)
+      assert_equal [0], validator.instance_variable_get(:@codes)
+    end
   end
 end

data/test/roku_builder/test_device_manager.rb

@@ -39,7 +39,7 @@ module RokuBuilder
         @ping.expect(:ping?, false, [config.raw[:devices][:roku][:ip], 1, 0.2, 1])
         manager = DeviceManager.new(config: config, options: options)
         assert_raises(DeviceError) do
-          device = manager.reserve_device
+          manager.reserve_device
         end
       end
     end
@@ -50,9 +50,9 @@ module RokuBuilder
         @ping.expect(:ping?, true, [config.raw[:devices][:roku][:ip], 1, 0.2, 1])
         @ping.expect(:ping?, true, [config.raw[:devices][:roku][:ip], 1, 0.2, 1])
         manager = DeviceManager.new(config: config, options: options)
-        device1 = manager.reserve_device
+        manager.reserve_device
         assert_raises(DeviceError) do
-          device2 = manager.reserve_device
+          manager.reserve_device
         end
       end
     end
@@ -121,7 +121,7 @@ module RokuBuilder
         manager = DeviceManager.new(config: config, options: options)
         device1 = manager.reserve_device
         assert_raises(DeviceError) do
-          device2 = manager.reserve_device
+          manager.reserve_device
         end
         assert_equal "test2", device1.name
       end

data/test/roku_builder/test_files/roku_api_test/test_key.json

@@ -0,0 +1,13 @@
+{
+  "kty": "RSA",
+  "kid": "hbdk0JpkFRc39Dx7WXxKkntR0UeCp-J7PiWWkwGOaHk",
+  "alg": "RS256",
+  "e": "AQAB",
+  "n": "xRFv0nywIFBexub60g-bi4ZwEOj_E-bA_bqO99w6kbAMu_XqAvYaIu2StZK1SedrK-kKcOCXFfEbCGlM0CZnrIXU5usRERvS1dDUZz3KyJ9DPi4VMUgTTONM6m_NrfgOa8-V71LcNXcnQ2ZhWTvffcvgZ7Btz0yMbuwhIKlJNEs9MtrZDV_yWpbns-kQDH1A3PS22ZNGej7ifJJuIX1KitDLvkjrYR8MaCf-PUJewU-7ugpvO1pNi6ChYcTY09YuScPYiZg5i9yClve0lwScw2DBIBMfxyAG626YZtUkv6ffKQuceak-w0vx7gYLOJv_aCyKNcxrmFmMYwDIbXDaHQ",
+  "d": "G0wdBzUKWI-JcVfRaoOK8jq_DziXDLSsCvlqkF7LJh8SxH592ccpO6lY5xnZTtFlgQGY1qXlh76MFhAv-a04MyeepBXvmUUXYVK5-UsP6dZVxCkx-k-XjND3eIngHbb8mGZ6yFnb8vP8VlO6LFgkzxIMlZBUxaA-26aNuC5622lKUoQQiD3eVxu93hIOAjn08dMn4yl8D4MbD8kfkWeQIXM0VI25YjKlt2mJSajyMxxMFTIrevoGo72tEgjpER--EDXMBuq0KsPSU7ZHfLhs6Dk2bcG79JAZ4WG17gkoO1atjta_kPXik4MQEeQYFgT3kaLSsSvhv3ipp28nOwFugQ",
+  "p": "7OeIV6zOUlyWcNvX4uwRy_qKo-JAltmSqIiTQmry9l2HDFEV3hnPnV5uyYU6uIo-OWMTWxWR_41Wl45Na15DYhcY8ttudAseiPHPqczhbm5jCzYSt6vY4prKDMXP3rXbRb9wGPm22BqU-ERxQz_vwMhXxDhLaHjOZ3ihjcFI440",
+  "q": "1PPkKEGmegHkH7YPXoZyz90qk2FRBBY76ulU-ThXaaMDiS0vDJqcwrvpk9UDT3hdnZhh0zLhlS1C9ypvnQDqTA7p8h_my0VL9bXVcEgUzzkgQ_Vjyq9-6Lb2y9HGqXUoycLS4xss5qXZOM26oFGkeRgfGXZo2Ndlb-zGQN88ZNE",
+  "dp": "2Q1FGPclzcYwu9RglvMtVxMEpSRtgwhy22DOcwLj-h801W8RNv20_3z-yjn71Aos-o0wtbosmtRXKuJhQmcKG7wHyrKLH1z0rAnI9szVGkWfDy2KtqeHPg8N4ef3DRjXfq7oOKnKAXNRW6nxj-jrdFjaONhPFrfgfGLEuckGTB0",
+  "dq": "HWWZrnD5oUgXjMUeNAdNXCKE2RmLDIxhMxmI0GqVrpCBUXN6VjwVvdAg-3ZhYZwVGEdL4dLZTzWTU_l4tOzGaz93ziPXQWJMjRvP3hMlREH3kUoTv4wgcdGoGhTYXtY8jjWl1RIQTbrBVNUZmT4L_Wd2C5bL_Hsnlp7R82ydsrE",
+  "qi": "cnrYQq21HMSlYj3Ga_F8Su1H_9cKjZPJoeRcGagkBQpIx2zGxhheTEXZV7X9RFNyLev6zBXxue6PEhjAEEDqlNKNFXSmlLSkbDkKCMb1yeALTPSqrNFvq8DdH0cxMDTPI0U5K2JCwuAoAyXzWxENEiRlq4oizdzZBvilM7TF4fM"
+}

data/test/roku_builder/test_helper.rb

@@ -71,56 +71,79 @@ def tmp_folder()
   Dir.tmpdir()
 end
 
+def is_uuid?(uuid)
+  uuid_regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+  return true if uuid_regex.match?(uuid.to_s.downcase)
+  false
+end
+
 def good_config(klass=nil)
   root_dir = "/tmp"
   root_dir = test_files_path(klass) if klass
   {
     devices: {
-    default: :roku,
-    roku: {
-    ip: "192.168.0.100",
-    user: "user",
-    password: "password"
-  }
-  },
+      default: :roku,
+      roku: {
+        ip: "192.168.0.100",
+        user: "user",
+        password: "password"
+      }
+    },
     projects: {
-    default: :project1,
-    project1: {
-    directory: root_dir,
-    source_files: ["manifest", "images", "source"],
-    app_name: "<app name>",
-    stage_method: :git,
-    stages:{
-    production: {
-    branch: "production",
-    key: {
-    keyed_pkg: File.join(root_dir, "test.pkg"),
-    password: "password"
-  }
-  }
-  }
-  },
-    project2: {
-    directory: root_dir,
-    source_files: ["images","source","manifest"],
-    app_name: "<app name>",
-    stage_method: :script,
-    stages:{
-    production: {
-    script: {stage: "stage_script", unstage: "unstage_script"},
-    key: "a"
-  }
-  }
-  }
-  },
+      default: :project1,
+      project1: {
+        directory: root_dir,
+        source_files: ["manifest", "images", "source"],
+        app_name: "<app name>",
+        stage_method: :git,
+        stages:{
+          production: {
+            branch: "production",
+            key: {
+              keyed_pkg: File.join(root_dir, "test.pkg"),
+              password: "password"
+            }
+          }
+        }
+      },
+      project2: {
+        directory: root_dir,
+        source_files: ["images","source","manifest"],
+        app_name: "<app name>",
+        stage_method: :script,
+        stages:{
+          production: {
+            script: {stage: "stage_script", unstage: "unstage_script"},
+            key: "a"
+          }
+        }
+      }
+    },
     keys: {
-    a: {
-    keyed_pkg: File.join(root_dir, "test.pkg"),
-    password: "password"
-  }
-  },
+      a: {
+        keyed_pkg: File.join(root_dir, "test.pkg"),
+        password: "password"
+      }
+    },
     input_mappings: {
-    "a": ["home", "Home"]
-  }
+      "a": ["home", "Home"]
+    },
+    api_keys: {
+      key1: File.join(root_dir, "test_key.json")
+    }
   }
 end
+
+def api_versions
+  [
+    {
+      "id" => "5735B375-2607-435F-97AE-66954DC2A91F",
+      "channelState" => "Published",
+      "appSize" => 1226192,
+      "channelId" => 722085,
+      "version" => "1.4",
+      "minFirmwareVersion" => 0,
+      "minimumFirmwareVersionTextShort" => "v2.5 b388"
+    }
+  ]
+end

data/test/roku_builder/test_ruby_git.rb

@@ -10,12 +10,12 @@ class GitTest < Minitest::Test
 
     index = 1
     base.expect(:lib, lib)
+    base.expect(:lib, lib)
+    lib.expect(:stashes_all, [])
     lib.expect(:stash_pop, nil, [index])
 
     Dir.mktmpdir do |dir|
-      git = Git.init(File.join(dir, "git"))
-      stashes = git.branch.stashes
-      stashes.instance_variable_set(:@base, base)
+      stashes = Git::Stashes.new(base)
       stashes.pop(index)
     end
 
@@ -29,12 +29,12 @@ class GitTest < Minitest::Test
 
     index = 1
     base.expect(:lib, lib)
+    base.expect(:lib, lib)
+    lib.expect(:stashes_all, [])
     lib.expect(:stash_drop, nil, [index])
 
     Dir.mktmpdir do |dir|
-      git = Git.init(File.join(dir, "git"))
-      stashes = git.branch.stashes
-      stashes.instance_variable_set(:@base, base)
+      stashes = Git::Stashes.new(base)
       stashes.drop(index)
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roku_builder
 version: !ruby/object:Gem::Version
-  version: 4.27.2
+  version: 4.29.1
 platform: ruby
 authors:
 - greeneca
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-13 00:00:00.000000000 Z
+date: 2024-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -150,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -514,6 +528,7 @@ files:
 - lib/roku_builder/plugins/packager.rb
 - lib/roku_builder/plugins/performance_config.json
 - lib/roku_builder/plugins/profiler.rb
+- lib/roku_builder/plugins/rokuapi.rb
 - lib/roku_builder/plugins/sca-cmd/LICENSE
 - lib/roku_builder/plugins/sca-cmd/README.md
 - lib/roku_builder/plugins/sca-cmd/bin/sca-cmd
@@ -536,6 +551,7 @@ files:
 - test/roku_builder/plugins/test_navigator.rb
 - test/roku_builder/plugins/test_packager.rb
 - test/roku_builder/plugins/test_profiler.rb
+- test/roku_builder/plugins/test_rokuapi.rb
 - test/roku_builder/plugins/test_scripter.rb
 - test/roku_builder/plugins/test_tester.rb
 - test/roku_builder/test_config.rb
@@ -614,6 +630,8 @@ files:
 - test/roku_builder/test_files/packager_test/manifest
 - test/roku_builder/test_files/packager_test/scripter_test/manifest
 - test/roku_builder/test_files/packager_test/test.pkg
+- test/roku_builder/test_files/roku_api_test/test.pkg
+- test/roku_builder/test_files/roku_api_test/test_key.json
 - test/roku_builder/test_files/roku_builder_test/config.json
 - test/roku_builder/test_files/scripter_test/manifest
 - test/roku_builder/test_files/scripter_test/test.pkg
@@ -667,6 +685,7 @@ test_files:
 - test/roku_builder/plugins/test_navigator.rb
 - test/roku_builder/plugins/test_packager.rb
 - test/roku_builder/plugins/test_profiler.rb
+- test/roku_builder/plugins/test_rokuapi.rb
 - test/roku_builder/plugins/test_scripter.rb
 - test/roku_builder/plugins/test_tester.rb
 - test/roku_builder/test_config.rb
@@ -745,6 +764,8 @@ test_files:
 - test/roku_builder/test_files/packager_test/manifest
 - test/roku_builder/test_files/packager_test/scripter_test/manifest
 - test/roku_builder/test_files/packager_test/test.pkg
+- test/roku_builder/test_files/roku_api_test/test.pkg
+- test/roku_builder/test_files/roku_api_test/test_key.json
 - test/roku_builder/test_files/roku_builder_test/config.json
 - test/roku_builder/test_files/scripter_test/manifest
 - test/roku_builder/test_files/scripter_test/test.pkg