roku_builder 3.12.8 → 3.13.0

data/test/roku_builder/test_keyer.rb

@@ -2,178 +2,175 @@
 
 require_relative "test_helper.rb"
 
-class KeyerTest < Minitest::Test
-  def test_keyer_dev_id
-    connection = Minitest::Mock.new
-    faraday = Minitest::Mock.new
-    response = Minitest::Mock.new
-
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    path = "/plugin_package"
-    body = "v class=\"roku-font-5\"><label>Your Dev ID: &nbsp;</label> dev_id<hr></div>"
-
-    connection.expect(:get, response, [path])
-    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
-    faraday.expect(:adapter, nil, [Faraday.default_adapter])
-    response.expect(:body, body)
-    response.expect(:body, body)
-
-
-    dev_id = nil
-    keyer = RokuBuilder::Keyer.new(**device_config)
-    Faraday.stub(:new, connection, faraday) do
-      dev_id = keyer.dev_id
-    end
+module RokuBuilder
+  class KeyerTest < Minitest::Test
+    def test_keyer_dev_id
+      connection = Minitest::Mock.new
+      faraday = Minitest::Mock.new
+      response = Minitest::Mock.new
+
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      path = "/plugin_package"
+      body = "v class=\"roku-font-5\"><label>Your Dev ID: &nbsp;</label> dev_id<hr></div>"
+
+      connection.expect(:get, response, [path])
+      faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+      faraday.expect(:adapter, nil, [Faraday.default_adapter])
+      response.expect(:body, body)
+      response.expect(:body, body)
+
+
+      dev_id = nil
+      keyer = Keyer.new(**device_config)
+      Faraday.stub(:new, connection, faraday) do
+        dev_id = keyer.dev_id
+      end
 
-    assert_equal "dev_id", dev_id
+      assert_equal "dev_id", dev_id
 
-    connection.verify
-    faraday.verify
-    response.verify
-  end
-  def test_keyer_dev_id_old_interface
-    connection = Minitest::Mock.new
-    faraday = Minitest::Mock.new
-    response = Minitest::Mock.new
-
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    path = "/plugin_package"
-    body = "<p> Your Dev ID: <font face=\"Courier\">dev_id</font> </p>"
-
-    connection.expect(:get, response, [path])
-    faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
-    faraday.expect(:adapter, nil, [Faraday.default_adapter])
-    response.expect(:body, body)
-
-
-    dev_id = nil
-    keyer = RokuBuilder::Keyer.new(**device_config)
-    Faraday.stub(:new, connection, faraday) do
-      dev_id = keyer.dev_id
+      connection.verify
+      faraday.verify
+      response.verify
     end
+    def test_keyer_dev_id_old_interface
+      connection = Minitest::Mock.new
+      faraday = Minitest::Mock.new
+      response = Minitest::Mock.new
+
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      path = "/plugin_package"
+      body = "<p> Your Dev ID: <font face=\"Courier\">dev_id</font> </p>"
+
+      connection.expect(:get, response, [path])
+      faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
+      faraday.expect(:adapter, nil, [Faraday.default_adapter])
+      response.expect(:body, body)
+
+
+      dev_id = nil
+      keyer = Keyer.new(**device_config)
+      Faraday.stub(:new, connection, faraday) do
+        dev_id = keyer.dev_id
+      end
 
-    assert_equal "dev_id", dev_id
+      assert_equal "dev_id", dev_id
 
-    connection.verify
-    faraday.verify
-    response.verify
-  end
-
-  def test_keyer_rekey_changed
-    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",
-      logger: Logger.new("/dev/null")
-    }
-    path = "/plugin_inspect"
-    password = "password"
-    payload ={
-      mysubmit: "Rekey",
-      password: password,
-      archive: io
-    }
-
-    connection.expect(:post, response) do |arg1, arg2|
-      assert_equal path, arg1
-      assert_equal payload[:mysubmit], arg2[:mysubmit]
-      assert_equal payload[:password], arg2[:passwd]
-      assert payload[:archive] === arg2[:archive]
+      connection.verify
+      faraday.verify
+      response.verify
     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])
-
-    # This test fails with the following seeds due to the random number
-    # generator spitting out the same number twice
-    # SEED=21894
-    # SEED=31813
-    dev_id = Proc.new {"#{Random.rand(100)}"}
-    keyer = RokuBuilder::Keyer.new(**device_config)
-    key_changed = nil
-    Faraday.stub(:new, connection, faraday) do
-      Faraday::UploadIO.stub(:new, io) do
-        keyer.stub(:dev_id, dev_id) do
-          key_changed = keyer.rekey(keyed_pkg: "pkg/path", password: password)
+
+    def test_keyer_rekey_changed
+      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"
+      }
+      path = "/plugin_inspect"
+      password = "password"
+      payload ={
+        mysubmit: "Rekey",
+        password: password,
+        archive: io
+      }
+
+      connection.expect(:post, response) do |arg1, arg2|
+        assert_equal path, arg1
+        assert_equal payload[:mysubmit], arg2[:mysubmit]
+        assert_equal payload[:password], arg2[:passwd]
+        assert payload[:archive] === arg2[:archive]
+      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])
+
+      # This test fails with the following seeds due to the random number
+      # generator spitting out the same number twice
+      # SEED=21894
+      # SEED=31813
+      dev_id = Proc.new {"#{Random.rand(100)}"}
+      keyer = Keyer.new(**device_config)
+      key_changed = nil
+      Faraday.stub(:new, connection, faraday) do
+        Faraday::UploadIO.stub(:new, io) do
+          keyer.stub(:dev_id, dev_id) do
+            key_changed = keyer.rekey(keyed_pkg: "pkg/path", password: password)
+          end
         end
       end
-    end
 
-    assert key_changed
+      assert key_changed
 
-    connection.verify
-    faraday.verify
-    io.verify
-    response.verify
-  end
+      connection.verify
+      faraday.verify
+      io.verify
+      response.verify
+    end
 
-  def test_keyer_generate_new_key
-    connection = Minitest::Mock.new
+    def test_keyer_generate_new_key
+      connection = Minitest::Mock.new
 
-    connection.expect(:puts, nil, ["genkey"])
-    connection.expect(:waitfor, nil) do |config, &blk|
+      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, [])
+
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      keyer = Keyer.new(**device_config)
+      Net::Telnet.stub(:new, connection) do
+        keyer.send(:generate_new_key)
+      end
     end
-    connection.expect(:close, nil, [])
-
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    keyer = RokuBuilder::Keyer.new(**device_config)
-    Net::Telnet.stub(:new, connection) do
-      keyer.send(:generate_new_key)
-    end
-  end
 
-  def test_keyer_genkey
-    loader = Minitest::Mock.new
-    packager = Minitest::Mock.new
+    def test_keyer_genkey
+      loader = Minitest::Mock.new
+      packager = Minitest::Mock.new
 
-    loader.expect(:sideload, nil)
-    packager.expect(:package, nil, [app_name_version: "key_dev_id", out_file: "/tmp/key_dev_id.pkg", password: "password"])
+      loader.expect(:sideload, nil)
+      packager.expect(:package, nil, [app_name_version: "key_dev_id", out_file: "/tmp/key_dev_id.pkg", password: "password"])
 
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
 
-    keyer = RokuBuilder::Keyer.new(**device_config)
+      keyer = Keyer.new(**device_config)
 
-    RokuBuilder::Loader.stub(:new, loader) do
-      RokuBuilder::Packager.stub(:new, packager) do
-        keyer.stub(:generate_new_key, ["password", "dev_id"]) do
-          keyer.genkey
+      Loader.stub(:new, loader) do
+        Packager.stub(:new, packager) do
+          keyer.stub(:generate_new_key, ["password", "dev_id"]) do
+            keyer.genkey
+          end
         end
       end
-    end
 
-    loader.verify
-    packager.verify
+      loader.verify
+      packager.verify
+    end
   end
 end

data/test/roku_builder/test_linker.rb

@@ -2,113 +2,109 @@
 
 require_relative "test_helper.rb"
 
-class LinkerTest < Minitest::Test
-  def test_linker_link
-    connection = Minitest::Mock.new
-    faraday = Minitest::Mock.new
-    response = Minitest::Mock.new
+module RokuBuilder
+  class LinkerTest < Minitest::Test
+    def test_linker_link
+      connection = Minitest::Mock.new
+      faraday = Minitest::Mock.new
+      response = Minitest::Mock.new
 
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    path = "/launch/dev?a=A&b=B%3AC&d=a%5Cb"
-    options = 'a:A, b:B:C, d:a\b'
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      path = "/launch/dev?a=A&b=B%3AC&d=a%5Cb"
+      options = 'a:A, b:B:C, d:a\b'
 
-    connection.expect(:post, response, [path])
-    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])
-    response.expect(:success?, true)
+      connection.expect(:post, response, [path])
+      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])
+      response.expect(:success?, true)
 
-    linker = RokuBuilder::Linker.new(**device_config)
-    success = nil
-    Faraday.stub(:new, connection, faraday) do
-      success = linker.launch(options: options)
-    end
+      linker = Linker.new(**device_config)
+      success = nil
+      Faraday.stub(:new, connection, faraday) do
+        success = linker.launch(options: options)
+      end
 
-    assert success
+      assert success
 
-    connection.verify
-    faraday.verify
-    response.verify
-  end
-  def test_linker_link_nothing
-    logger = Minitest::Mock.new
-    connection = Minitest::Mock.new
-    faraday = Minitest::Mock.new
-    response = Minitest::Mock.new
-
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: logger
-    }
-    path = "/launch/dev"
-    options = ''
-    logger.expect(:warn, nil, ["No options sent to launched app"])
-    connection.expect(:post, response, [path])
-    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])
-    response.expect(:success?, true)
-    linker = RokuBuilder::Linker.new(**device_config)
-    success = nil
-    Faraday.stub(:new, connection, faraday) do
-      success = linker.launch(options: options)
+      connection.verify
+      faraday.verify
+      response.verify
     end
+    def test_linker_link_nothing
+      connection = Minitest::Mock.new
+      faraday = Minitest::Mock.new
+      response = Minitest::Mock.new
 
-    assert success
-    logger.verify
-    connection.verify
-    faraday.verify
-    response.verify
-  end
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      path = "/launch/dev"
+      options = ''
+      connection.expect(:post, response, [path])
+      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])
+      response.expect(:success?, true)
+      linker = Linker.new(**device_config)
+      success = nil
+      Faraday.stub(:new, connection, faraday) do
+        success = linker.launch(options: options)
+      end
+
+      assert success
+      connection.verify
+      faraday.verify
+      response.verify
+    end
 
-  def test_linker_list
-    connection = Minitest::Mock.new
-    faraday = Minitest::Mock.new
-    response = Minitest::Mock.new
+    def test_linker_list
+      connection = Minitest::Mock.new
+      faraday = Minitest::Mock.new
+      response = Minitest::Mock.new
 
-    device_config = {
-      ip: "111.222.333",
-      user: "user",
-      password: "password",
-      logger: Logger.new("/dev/null")
-    }
-    path = "/query/apps"
-    body = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<apps>\n\t
-<app id=\"31012\" type=\"menu\" version=\"1.6.3\">Movie Store and TV Store</app>\n\t
-<app id=\"31863\" type=\"menu\" version=\"1.2.6\">Roku Home News</app>\n\t
-<app id=\"65066\" type=\"appl\" version=\"1.3.0\">Nick</app>\n\t
-<app id=\"68161\" type=\"appl\" version=\"1.3.0\">Nick</app>\n\t
-</apps>\n"
-    connection.expect(:get, response, [path])
-    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])
-    response.expect(:success?, true)
-    response.expect(:body, body)
-    linker = RokuBuilder::Linker.new(**device_config)
+      device_config = {
+        ip: "111.222.333",
+        user: "user",
+        password: "password"
+      }
+      path = "/query/apps"
+      body = "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<apps>\n\t
+      <app id=\"31012\" type=\"menu\" version=\"1.6.3\">Movie Store and TV Store</app>\n\t
+      <app id=\"31863\" type=\"menu\" version=\"1.2.6\">Roku Home News</app>\n\t
+      <app id=\"65066\" type=\"appl\" version=\"1.3.0\">Nick</app>\n\t
+      <app id=\"68161\" type=\"appl\" version=\"1.3.0\">Nick</app>\n\t
+      </apps>\n"
+      connection.expect(:get, response, [path])
+      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])
+      response.expect(:success?, true)
+      response.expect(:body, body)
+      linker = Linker.new(**device_config)
 
-    print_count = 0
-    did_print = Proc.new { |msg| print_count+=1 }
+      print_count = 0
+      did_print = Proc.new { |msg| print_count+=1 }
 
-    Faraday.stub(:new, connection, faraday) do
-      linker.stub(:printf, did_print) do
-        linker.list
+      Faraday.stub(:new, connection, faraday) do
+        linker.stub(:printf, did_print) do
+          linker.list
+        end
       end
-    end
 
-    assert_equal 6, print_count
+      assert_equal 6, print_count
+    end
   end
 end