roku_builder 3.12.8 → 3.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (57) hide show
  1. checksums.yaml +4 -4
  2. data/.rubocop.yml +2 -2
  3. data/CHANGELOG +9 -0
  4. data/Gemfile.lock +17 -11
  5. data/bin/roku +4 -8
  6. data/lib/roku_builder.rb +16 -24
  7. data/lib/roku_builder/config.rb +213 -0
  8. data/lib/roku_builder/config_parser.rb +304 -267
  9. data/lib/roku_builder/config_validator.rb +149 -126
  10. data/lib/roku_builder/controller.rb +34 -184
  11. data/lib/roku_builder/controller_commands.rb +85 -79
  12. data/lib/roku_builder/error_handler.rb +0 -11
  13. data/lib/roku_builder/errors.rb +12 -0
  14. data/lib/roku_builder/inspector.rb +6 -4
  15. data/lib/roku_builder/keyer.rb +1 -1
  16. data/lib/roku_builder/loader.rb +1 -1
  17. data/lib/roku_builder/logger.rb +32 -0
  18. data/lib/roku_builder/manifest_manager.rb +2 -2
  19. data/lib/roku_builder/monitor.rb +1 -1
  20. data/lib/roku_builder/options.rb +113 -0
  21. data/lib/roku_builder/stager.rb +2 -2
  22. data/lib/roku_builder/tester.rb +57 -11
  23. data/lib/roku_builder/util.rb +3 -4
  24. data/lib/roku_builder/version.rb +1 -1
  25. data/roku_builder.gemspec +2 -1
  26. data/test/roku_builder/test_config.rb +168 -0
  27. data/test/roku_builder/test_config_parser.rb +347 -394
  28. data/test/roku_builder/test_config_validator.rb +193 -190
  29. data/test/roku_builder/test_controller.rb +59 -178
  30. data/test/roku_builder/test_controller_commands.rb +407 -394
  31. data/test/roku_builder/test_error_handler.rb +67 -69
  32. data/test/roku_builder/test_files/config_test/bad.json +2 -0
  33. data/test/roku_builder/test_files/config_test/child.json +11 -0
  34. data/test/roku_builder/test_files/config_test/config.json +29 -0
  35. data/test/roku_builder/test_files/config_test/non_json.json +1 -0
  36. data/test/roku_builder/test_files/config_test/parent.json +21 -0
  37. data/test/roku_builder/test_files/config_test/parent_projects.json +35 -0
  38. data/test/roku_builder/test_files/manifest_manager_test/manifest_template_2 +1 -1
  39. data/test/roku_builder/test_helper.rb +55 -45
  40. data/test/roku_builder/test_inspector.rb +278 -213
  41. data/test/roku_builder/test_keyer.rb +144 -147
  42. data/test/roku_builder/test_linker.rb +91 -95
  43. data/test/roku_builder/test_loader.rb +279 -289
  44. data/test/roku_builder/test_logger.rb +47 -0
  45. data/test/roku_builder/test_manifest_manager.rb +92 -94
  46. data/test/roku_builder/test_monitor.rb +101 -103
  47. data/test/roku_builder/test_navigator.rb +240 -245
  48. data/test/roku_builder/test_options.rb +156 -0
  49. data/test/roku_builder/test_packager.rb +108 -108
  50. data/test/roku_builder/test_profiler.rb +20 -19
  51. data/test/roku_builder/test_scripter.rb +83 -81
  52. data/test/roku_builder/test_stager.rb +299 -311
  53. data/test/roku_builder/test_tester.rb +112 -115
  54. data/test/roku_builder/test_util.rb +18 -17
  55. metadata +39 -6
  56. data/lib/roku_builder/config_manager.rb +0 -161
  57. data/test/roku_builder/test_config_manager.rb +0 -372
data/test/roku_builder/test_loader.rb CHANGED
@@ -2,346 +2,336 @@
2
2
 
3
3
  require_relative "test_helper.rb"
4
4
 
5
- class LoaderTest < Minitest::Test
6
- def test_loader_sideload
7
- connection = Minitest::Mock.new
8
- faraday = Minitest::Mock.new
9
- io = Minitest::Mock.new
10
- response = Minitest::Mock.new
11
- navigator = Minitest::Mock.new
5
+ module RokuBuilder
6
+ class LoaderTest < Minitest::Test
7
+ def test_loader_sideload
8
+ connection = Minitest::Mock.new
9
+ faraday = Minitest::Mock.new
10
+ io = Minitest::Mock.new
11
+ response = Minitest::Mock.new
12
+ navigator = Minitest::Mock.new
12
13
 
13
- root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
14
- logger = Logger.new("/dev/null")
15
- device_config = {
16
- ip: "111.222.333",
17
- user: "user",
18
- password: "password",
19
- logger: logger,
20
- init_params: {root_dir: root_dir}
21
- }
22
- loader_config = {
23
- content: {
14
+ root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
15
+ device_config = {
16
+ ip: "111.222.333",
17
+ user: "user",
18
+ password: "password",
19
+ init_params: {root_dir: root_dir}
20
+ }
21
+ loader_config = {
22
+ content: {
24
23
  folders: ["source"],
25
24
  files: ["manifest"]
26
25
  }
27
- }
28
- payload = {
29
- mysubmit: "Replace",
30
- archive: io,
31
- }
32
- path = "/plugin_install"
26
+ }
27
+ payload = {
28
+ mysubmit: "Replace",
29
+ archive: io,
30
+ }
31
+ path = "/plugin_install"
33
32
 
34
- navigator.expect(:nav, nil, [commands: [:home]])
35
- faraday.expect(:headers, {})
36
- faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
37
- faraday.expect(:request, nil, [:multipart])
38
- faraday.expect(:request, nil, [:url_encoded])
39
- faraday.expect(:adapter, nil, [Faraday.default_adapter])
40
- connection.expect(:post, response) do |arg1, arg2|
41
- assert_equal path, arg1
42
- assert_equal payload[:mysubmit], arg2[:mysubmit]
43
- assert payload[:archive] === arg2[:archive]
44
- end
45
- response.expect(:status, 200)
46
- response.expect(:body, "Install Success")
47
- response.expect(:status, 200)
48
- response.expect(:body, "Install Success")
33
+ navigator.expect(:nav, nil, [commands: [:home]])
34
+ faraday.expect(:headers, {})
35
+ faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
36
+ faraday.expect(:request, nil, [:multipart])
37
+ faraday.expect(:request, nil, [:url_encoded])
38
+ faraday.expect(:adapter, nil, [Faraday.default_adapter])
39
+ connection.expect(:post, response) do |arg1, arg2|
40
+ assert_equal path, arg1
41
+ assert_equal payload[:mysubmit], arg2[:mysubmit]
42
+ assert payload[:archive] === arg2[:archive]
43
+ end
44
+ response.expect(:status, 200)
45
+ response.expect(:body, "Install Success")
46
+ response.expect(:status, 200)
47
+ response.expect(:body, "Install Success")
49
48
 
50
- loader = RokuBuilder::Loader.new(**device_config)
51
- result = nil
52
- build_version = nil
53
- RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
54
- loader.stub(:build, "zip_file") do
55
- Faraday.stub(:new, connection, faraday) do
56
- Faraday::UploadIO.stub(:new, io) do
57
- File.stub(:delete, nil) do
58
- RokuBuilder::Navigator.stub(:new, navigator) do
59
- result, build_version = loader.sideload(**loader_config)
49
+ loader = Loader.new(**device_config)
50
+ result = nil
51
+ build_version = nil
52
+ ManifestManager.stub(:build_version, "build_version") do
53
+ loader.stub(:build, "zip_file") do
54
+ Faraday.stub(:new, connection, faraday) do
55
+ Faraday::UploadIO.stub(:new, io) do
56
+ File.stub(:delete, nil) do
57
+ Navigator.stub(:new, navigator) do
58
+ result, build_version = loader.sideload(**loader_config)
59
+ end
60
60
  end
61
61
  end
62
62
  end
63
63
  end
64
64
  end
65
- end
66
65
 
67
- assert_equal "build_version", build_version
68
- assert_equal RokuBuilder::SUCCESS, result
66
+ assert_equal "build_version", build_version
67
+ assert_equal SUCCESS, result
69
68
 
70
- connection.verify
71
- faraday.verify
72
- io.verify
73
- response.verify
74
- end
75
- def test_loader_sideload_infile
76
- connection = Minitest::Mock.new
77
- faraday = Minitest::Mock.new
78
- io = Minitest::Mock.new
79
- response = Minitest::Mock.new
80
- navigator = Minitest::Mock.new
69
+ connection.verify
70
+ faraday.verify
71
+ io.verify
72
+ response.verify
73
+ end
74
+ def test_loader_sideload_infile
75
+ connection = Minitest::Mock.new
76
+ faraday = Minitest::Mock.new
77
+ io = Minitest::Mock.new
78
+ response = Minitest::Mock.new
79
+ navigator = Minitest::Mock.new
81
80
 
82
- infile = File.join(File.dirname(__FILE__), "test_files", "loader_test", "infile_test.zip")
83
- logger = Logger.new("/dev/null")
84
- device_config = {
85
- ip: "111.222.333",
86
- user: "user",
87
- password: "password",
88
- logger: logger,
89
- }
90
- loader_config = {
91
- infile: infile
92
- }
93
- payload = {
94
- mysubmit: "Replace",
95
- archive: io,
96
- }
97
- path = "/plugin_install"
81
+ infile = File.join(File.dirname(__FILE__), "test_files", "loader_test", "infile_test.zip")
82
+ device_config = {
83
+ ip: "111.222.333",
84
+ user: "user",
85
+ password: "password"
86
+ }
87
+ loader_config = {
88
+ infile: infile
89
+ }
90
+ payload = {
91
+ mysubmit: "Replace",
92
+ archive: io,
93
+ }
94
+ path = "/plugin_install"
98
95
 
99
- navigator.expect(:nav, nil, [commands: [:home]])
100
- faraday.expect(:headers, {})
101
- faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
102
- faraday.expect(:request, nil, [:multipart])
103
- faraday.expect(:request, nil, [:url_encoded])
104
- faraday.expect(:adapter, nil, [Faraday.default_adapter])
105
- connection.expect(:post, response) do |arg1, arg2|
106
- assert_equal path, arg1
107
- assert_equal payload[:mysubmit], arg2[:mysubmit]
108
- assert payload[:archive] === arg2[:archive]
109
- end
110
- response.expect(:status, 200)
111
- response.expect(:body, "Install Success")
112
- response.expect(:status, 200)
113
- response.expect(:body, "Install Success")
96
+ navigator.expect(:nav, nil, [commands: [:home]])
97
+ faraday.expect(:headers, {})
98
+ faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
99
+ faraday.expect(:request, nil, [:multipart])
100
+ faraday.expect(:request, nil, [:url_encoded])
101
+ faraday.expect(:adapter, nil, [Faraday.default_adapter])
102
+ connection.expect(:post, response) do |arg1, arg2|
103
+ assert_equal path, arg1
104
+ assert_equal payload[:mysubmit], arg2[:mysubmit]
105
+ assert payload[:archive] === arg2[:archive]
106
+ end
107
+ response.expect(:status, 200)
108
+ response.expect(:body, "Install Success")
109
+ response.expect(:status, 200)
110
+ response.expect(:body, "Install Success")
114
111
 
115
- loader = RokuBuilder::Loader.new(**device_config)
116
- result = nil
117
- build_version = nil
118
- RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
119
- Faraday.stub(:new, connection, faraday) do
120
- Faraday::UploadIO.stub(:new, io) do
121
- File.stub(:delete, nil) do
122
- RokuBuilder::Navigator.stub(:new, navigator) do
123
- result, build_version = loader.sideload(**loader_config)
112
+ loader = Loader.new(**device_config)
113
+ result = nil
114
+ build_version = nil
115
+ ManifestManager.stub(:build_version, "build_version") do
116
+ Faraday.stub(:new, connection, faraday) do
117
+ Faraday::UploadIO.stub(:new, io) do
118
+ File.stub(:delete, nil) do
119
+ Navigator.stub(:new, navigator) do
120
+ result, build_version = loader.sideload(**loader_config)
121
+ end
124
122
  end
125
123
  end
126
124
  end
127
125
  end
128
- end
129
126
 
130
- assert_equal "build_version", build_version
131
- assert_equal RokuBuilder::SUCCESS, result
127
+ assert_equal "build_version", build_version
128
+ assert_equal SUCCESS, result
132
129
 
133
- connection.verify
134
- faraday.verify
135
- io.verify
136
- response.verify
137
- end
138
- def test_loader_sideload_update
139
- connection = Minitest::Mock.new
140
- faraday = Minitest::Mock.new
141
- io = Minitest::Mock.new
142
- response = Minitest::Mock.new
143
- navigator = Minitest::Mock.new
130
+ connection.verify
131
+ faraday.verify
132
+ io.verify
133
+ response.verify
134
+ end
135
+ def test_loader_sideload_update
136
+ connection = Minitest::Mock.new
137
+ faraday = Minitest::Mock.new
138
+ io = Minitest::Mock.new
139
+ response = Minitest::Mock.new
140
+ navigator = Minitest::Mock.new
144
141
 
145
- root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
146
- logger = Logger.new("/dev/null")
147
- device_config = {
148
- ip: "111.222.333",
149
- user: "user",
150
- password: "password",
151
- logger: logger,
152
- init_params: {root_dir: root_dir}
153
- }
154
- loader_config = {
155
- update_manifest: true,
156
- content: {
142
+ root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
143
+ device_config = {
144
+ ip: "111.222.333",
145
+ user: "user",
146
+ password: "password",
147
+ init_params: {root_dir: root_dir}
148
+ }
149
+ loader_config = {
150
+ update_manifest: true,
151
+ content: {
157
152
  folders: ["source"],
158
153
  files: ["manifest"]
159
154
  }
160
- }
161
- payload = {
162
- mysubmit: "Replace",
163
- archive: io,
164
- }
165
- path = "/plugin_install"
155
+ }
156
+ payload = {
157
+ mysubmit: "Replace",
158
+ archive: io,
159
+ }
160
+ path = "/plugin_install"
166
161
 
167
- navigator.expect(:nav, nil, [commands: [:home]])
168
- faraday.expect(:headers, {})
169
- faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
170
- faraday.expect(:request, nil, [:multipart])
171
- faraday.expect(:request, nil, [:url_encoded])
172
- faraday.expect(:adapter, nil, [Faraday.default_adapter])
173
- connection.expect(:post, response) do |arg1, arg2|
174
- assert_equal path, arg1
175
- assert_equal payload[:mysubmit], arg2[:mysubmit]
176
- assert payload[:archive] === arg2[:archive]
177
- end
178
- response.expect(:status, 200)
179
- response.expect(:body, "Install Success")
180
- response.expect(:status, 200)
181
- response.expect(:body, "Install Success")
162
+ navigator.expect(:nav, nil, [commands: [:home]])
163
+ faraday.expect(:headers, {})
164
+ faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
165
+ faraday.expect(:request, nil, [:multipart])
166
+ faraday.expect(:request, nil, [:url_encoded])
167
+ faraday.expect(:adapter, nil, [Faraday.default_adapter])
168
+ connection.expect(:post, response) do |arg1, arg2|
169
+ assert_equal path, arg1
170
+ assert_equal payload[:mysubmit], arg2[:mysubmit]
171
+ assert payload[:archive] === arg2[:archive]
172
+ end
173
+ response.expect(:status, 200)
174
+ response.expect(:body, "Install Success")
175
+ response.expect(:status, 200)
176
+ response.expect(:body, "Install Success")
182
177
 
183
- loader = RokuBuilder::Loader.new(**device_config)
184
- result = nil
185
- build_version = nil
186
- RokuBuilder::ManifestManager.stub(:update_build, "build_version") do
187
- loader.stub(:build, "zip_file") do
188
- Faraday.stub(:new, connection, faraday) do
189
- Faraday::UploadIO.stub(:new, io) do
190
- File.stub(:delete, nil) do
191
- RokuBuilder::Navigator.stub(:new, navigator) do
192
- result, build_version = loader.sideload(**loader_config)
178
+ loader = Loader.new(**device_config)
179
+ result = nil
180
+ build_version = nil
181
+ ManifestManager.stub(:update_build, "build_version") do
182
+ loader.stub(:build, "zip_file") do
183
+ Faraday.stub(:new, connection, faraday) do
184
+ Faraday::UploadIO.stub(:new, io) do
185
+ File.stub(:delete, nil) do
186
+ Navigator.stub(:new, navigator) do
187
+ result, build_version = loader.sideload(**loader_config)
188
+ end
193
189
  end
194
190
  end
195
191
  end
196
192
  end
197
193
  end
198
- end
199
194
 
200
- assert_equal "build_version", build_version
201
- assert_equal RokuBuilder::SUCCESS, result
195
+ assert_equal "build_version", build_version
196
+ assert_equal SUCCESS, result
202
197
 
203
- connection.verify
204
- faraday.verify
205
- io.verify
206
- response.verify
207
- end
198
+ connection.verify
199
+ faraday.verify
200
+ io.verify
201
+ response.verify
202
+ end
208
203
 
209
- def test_loader_build_defining_folder_and_files
210
- root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
211
- logger = Logger.new("/dev/null")
212
- device_config = {
213
- ip: "111.222.333",
214
- user: "user",
215
- password: "password",
216
- logger: logger,
217
- init_params: {root_dir: root_dir}
218
- }
219
- build_config = {
220
- content: {
204
+ def test_loader_build_defining_folder_and_files
205
+ root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
206
+ device_config = {
207
+ ip: "111.222.333",
208
+ user: "user",
209
+ password: "password",
210
+ init_params: {root_dir: root_dir}
211
+ }
212
+ build_config = {
213
+ content: {
221
214
  folders: ["source"],
222
215
  files: ["manifest"]
223
216
  }
224
- }
225
- loader = RokuBuilder::Loader.new(**device_config)
226
- outfile = nil
227
- RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
228
- outfile = loader.build(**build_config)
229
- end
230
- Zip::File.open(outfile) do |file|
231
- assert file.find_entry("manifest") != nil
232
- assert_nil file.find_entry("a")
233
- assert file.find_entry("source/b") != nil
234
- assert file.find_entry("source/c/d") != nil
235
- end
236
- end
237
- def test_loader_build_all_contents
238
- root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
239
- logger = Logger.new("/dev/null")
240
- device_config = {
241
- ip: "111.222.333",
242
- user: "user",
243
- password: "password",
244
- logger: logger,
245
- init_params: {root_dir: root_dir}
246
- }
247
- build_config = {}
248
- loader = RokuBuilder::Loader.new(**device_config)
249
- outfile = nil
250
- RokuBuilder::ManifestManager.stub(:build_version, "build_version") do
251
- outfile = loader.build(**build_config)
217
+ }
218
+ loader = Loader.new(**device_config)
219
+ outfile = nil
220
+ ManifestManager.stub(:build_version, "build_version") do
221
+ outfile = loader.build(**build_config)
222
+ end
223
+ Zip::File.open(outfile) do |file|
224
+ assert file.find_entry("manifest") != nil
225
+ assert_nil file.find_entry("a")
226
+ assert file.find_entry("source/b") != nil
227
+ assert file.find_entry("source/c/d") != nil
228
+ end
252
229
  end
253
- Zip::File.open(outfile) do |file|
254
- assert file.find_entry("manifest") != nil
255
- assert file.find_entry("a") != nil
256
- assert file.find_entry("source/b") != nil
257
- assert file.find_entry("source/c/d") != nil
230
+ def test_loader_build_all_contents
231
+ root_dir = File.join(File.dirname(__FILE__), "test_files", "loader_test")
232
+ device_config = {
233
+ ip: "111.222.333",
234
+ user: "user",
235
+ password: "password",
236
+ init_params: {root_dir: root_dir}
237
+ }
238
+ build_config = {}
239
+ loader = Loader.new(**device_config)
240
+ outfile = nil
241
+ ManifestManager.stub(:build_version, "build_version") do
242
+ outfile = loader.build(**build_config)
243
+ end
244
+ Zip::File.open(outfile) do |file|
245
+ assert file.find_entry("manifest") != nil
246
+ assert file.find_entry("a") != nil
247
+ assert file.find_entry("source/b") != nil
248
+ assert file.find_entry("source/c/d") != nil
249
+ end
258
250
  end
259
- end
260
251
 
261
- def test_loader_unload
262
- connection = Minitest::Mock.new
263
- faraday = Minitest::Mock.new
264
- response = Minitest::Mock.new
252
+ def test_loader_unload
253
+ connection = Minitest::Mock.new
254
+ faraday = Minitest::Mock.new
255
+ response = Minitest::Mock.new
265
256
 
266
- device_config = {
267
- ip: "111.222.333",
268
- user: "user",
269
- password: "password",
270
- logger: Logger.new("/dev/null"),
271
- init_params: {root_dir: "/dev/null"}
272
- }
273
- payload = {
274
- mysubmit: "Delete",
275
- archive: "",
276
- }
277
- path = "/plugin_install"
257
+ device_config = {
258
+ ip: "111.222.333",
259
+ user: "user",
260
+ password: "password",
261
+ init_params: {root_dir: "/dev/null"}
262
+ }
263
+ payload = {
264
+ mysubmit: "Delete",
265
+ archive: "",
266
+ }
267
+ path = "/plugin_install"
278
268
 
279
- faraday.expect(:headers, {})
280
- faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
281
- faraday.expect(:request, nil, [:multipart])
282
- faraday.expect(:request, nil, [:url_encoded])
283
- faraday.expect(:adapter, nil, [Faraday.default_adapter])
284
- connection.expect(:post, response) do |arg1, arg2|
285
- assert_equal path, arg1
286
- assert_equal payload[:mysubmit], arg2[:mysubmit]
287
- assert payload[:archive] === arg2[:archive]
288
- end
289
- response.expect(:status, 200)
290
- response.expect(:body, "Install Success")
269
+ faraday.expect(:headers, {})
270
+ faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
271
+ faraday.expect(:request, nil, [:multipart])
272
+ faraday.expect(:request, nil, [:url_encoded])
273
+ faraday.expect(:adapter, nil, [Faraday.default_adapter])
274
+ connection.expect(:post, response) do |arg1, arg2|
275
+ assert_equal path, arg1
276
+ assert_equal payload[:mysubmit], arg2[:mysubmit]
277
+ assert payload[:archive] === arg2[:archive]
278
+ end
279
+ response.expect(:status, 200)
280
+ response.expect(:body, "Install Success")
291
281
 
292
- loader = RokuBuilder::Loader.new(**device_config)
293
- result = nil
294
- Faraday.stub(:new, connection, faraday) do
295
- result = loader.unload
296
- end
282
+ loader = Loader.new(**device_config)
283
+ result = nil
284
+ Faraday.stub(:new, connection, faraday) do
285
+ result = loader.unload
286
+ end
297
287
 
298
- assert result
288
+ assert result
299
289
 
300
- connection.verify
301
- faraday.verify
302
- response.verify
303
- end
304
- def test_loader_unload_fail
305
- connection = Minitest::Mock.new
306
- faraday = Minitest::Mock.new
307
- response = Minitest::Mock.new
290
+ connection.verify
291
+ faraday.verify
292
+ response.verify
293
+ end
294
+ def test_loader_unload_fail
295
+ connection = Minitest::Mock.new
296
+ faraday = Minitest::Mock.new
297
+ response = Minitest::Mock.new
308
298
 
309
- device_config = {
310
- ip: "111.222.333",
311
- user: "user",
312
- password: "password",
313
- logger: Logger.new("/dev/null"),
314
- init_params: {root_dir: "/dev/null"}
315
- }
316
- payload = {
317
- mysubmit: "Delete",
318
- archive: "",
319
- }
320
- path = "/plugin_install"
299
+ device_config = {
300
+ ip: "111.222.333",
301
+ user: "user",
302
+ password: "password",
303
+ init_params: {root_dir: "/dev/null"}
304
+ }
305
+ payload = {
306
+ mysubmit: "Delete",
307
+ archive: "",
308
+ }
309
+ path = "/plugin_install"
321
310
 
322
- faraday.expect(:headers, {})
323
- faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
324
- faraday.expect(:request, nil, [:multipart])
325
- faraday.expect(:request, nil, [:url_encoded])
326
- faraday.expect(:adapter, nil, [Faraday.default_adapter])
327
- connection.expect(:post, response) do |arg1, arg2|
328
- assert_equal path, arg1
329
- assert_equal payload[:mysubmit], arg2[:mysubmit]
330
- assert payload[:archive] === arg2[:archive]
331
- end
332
- response.expect(:status, 200)
333
- response.expect(:body, "Install Filed")
311
+ faraday.expect(:headers, {})
312
+ faraday.expect(:request, nil, [:digest, device_config[:user], device_config[:password]])
313
+ faraday.expect(:request, nil, [:multipart])
314
+ faraday.expect(:request, nil, [:url_encoded])
315
+ faraday.expect(:adapter, nil, [Faraday.default_adapter])
316
+ connection.expect(:post, response) do |arg1, arg2|
317
+ assert_equal path, arg1
318
+ assert_equal payload[:mysubmit], arg2[:mysubmit]
319
+ assert payload[:archive] === arg2[:archive]
320
+ end
321
+ response.expect(:status, 200)
322
+ response.expect(:body, "Install Filed")
334
323
 
335
- loader = RokuBuilder::Loader.new(**device_config)
336
- result = nil
337
- Faraday.stub(:new, connection, faraday) do
338
- result = loader.unload
339
- end
324
+ loader = Loader.new(**device_config)
325
+ result = nil
326
+ Faraday.stub(:new, connection, faraday) do
327
+ result = loader.unload
328
+ end
340
329
 
341
- assert !result
330
+ assert !result
342
331
 
343
- connection.verify
344
- faraday.verify
345
- response.verify
332
+ connection.verify
333
+ faraday.verify
334
+ response.verify
335
+ end
346
336
  end
347
337
  end