1# frozen_string_literal: true
2
3require "test_helper"
4require "customer"
5require "registration"
6
7BandwidthTnReservationRepo::REDIS = FakeRedis.new
8
9class RegistrationTest < Minitest::Test
10 def test_for_registered
11 sgx = OpenStruct.new(
12 registered?: OpenStruct.new(phone: "+15555550000")
13 )
14 iq = Blather::Stanza::Iq::Command.new
15 iq.from = "test@example.com"
16 result = execute_command(iq) do
17 Registration.for(
18 customer(sgx: sgx),
19 nil,
20 Minitest::Mock.new
21 )
22 end
23 assert_kind_of Registration::Registered, result
24 end
25 em :test_for_registered
26
27 def test_for_activated
28 reservation_req = stub_request(
29 :post,
30 "https://dashboard.bandwidth.com/v1.0/accounts//tnreservation"
31 ).to_return(
32 status: 201,
33 headers: {
34 location: "https://dashboard.bandwidth.com/api/accounts//TnReservation/8da0f39c-043c-4806-9f0f-497b2d197bc5"
35 }
36 )
37 stub_request(
38 :get, "https://dashboard.bandwidth.com/v1.0/accounts//tnreservation/8da0f39c-043c-4806-9f0f-497b2d197bc5"
39 ).to_return(status: 200, body: <<~RESPONSE)
40 <ReservationResponse>
41 <Reservation>
42 <ReservationId>f342904f-b03a-4499-bac0-e8f43a2664a1</ReservationId>
43 <AccountId>12346099</AccountId>
44 <ReservationExpires>1492</ReservationExpires>
45 <ReservedTn>4354776010</ReservedTn>
46 </Reservation>
47 </ReservationResponse>
48 RESPONSE
49 web_manager = TelSelections.new(
50 redis: FakeRedis.new, db: FakeDB.new, memcache: FakeMemcache.new
51 )
52 web_manager.set(
53 "test@example.net",
54 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
55 )
56 result = execute_command do
57 sgx = OpenStruct.new(registered?: false)
58 Registration.for(
59 customer(
60 plan_name: "test_usd",
61 expires_at: Time.now + 999,
62 sgx: sgx
63 ),
64 nil,
65 web_manager
66 )
67 end
68 assert_kind_of Registration::Finish, result
69 assert_requested reservation_req
70 end
71 em :test_for_activated
72
73 def test_for_not_activated_approved
74 sgx = OpenStruct.new(registered?: false)
75 web_manager = TelSelections.new(
76 redis: FakeRedis.new, db: FakeDB.new, memcache: FakeMemcache.new
77 )
78 web_manager.set(
79 "test\\40approved.example.com@component",
80 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
81 )
82 iq = Blather::Stanza::Iq::Command.new
83 iq.from = "test@approved.example.com"
84 result = execute_command(iq) do
85 Registration::Activation.for(
86 customer(
87 sgx: sgx,
88 jid: Blather::JID.new("test\\40approved.example.com@component")
89 ),
90 nil,
91 web_manager
92 )
93 end
94 assert_kind_of Registration::Activation::Allow, result
95 end
96 em :test_for_not_activated_approved
97
98 def test_for_not_activated_googleplay
99 skip
100 sgx = OpenStruct.new(registered?: false)
101 web_manager = TelSelections.new(
102 redis: FakeRedis.new, db: FakeDB.new, memcache: FakeMemcache.new
103 )
104 web_manager.set(
105 "test@example.net",
106 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
107 )
108 iq = Blather::Stanza::Iq::Command.new
109 iq.from = "test@approved.example.com"
110 result = execute_command(iq) do
111 Registration::Activation.for(
112 customer(sgx: sgx),
113 "GARBLEDYGOOK==",
114 web_manager
115 )
116 end
117 assert_kind_of Registration::Activation::GooglePlay, result
118 end
119 em :test_for_not_activated_googleplay
120
121 def test_for_not_activated_with_customer_id
122 sgx = OpenStruct.new(registered?: false)
123 web_manager = TelSelections.new(
124 redis: FakeRedis.new, db: FakeDB.new, memcache: FakeMemcache.new
125 )
126 web_manager.set(
127 "test@example.net",
128 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
129 )
130 iq = Blather::Stanza::Iq::Command.new
131 iq.from = "test@example.com"
132 result = execute_command(iq) do
133 Registration::Activation.for(
134 customer(sgx: sgx),
135 nil,
136 web_manager
137 )
138 end
139 assert_kind_of Registration::Activation, result
140 end
141 em :test_for_not_activated_with_customer_id
142
143 class ActivationTest < Minitest::Test
144 Registration::Activation::DB = Minitest::Mock.new
145 Registration::Activation::REDIS = FakeRedis.new(
146 "jmp_parent_codes" => {
147 "PARENT_CODE" => "1",
148 "PARENT_TOMB" => "2",
149 "PARENT_MANY_SUBACCOUNTS" => "many_subaccounts"
150 },
151 "jmp_customer_trust_level-2" => "Tomb"
152 )
153 Registration::Activation::Payment = Minitest::Mock.new
154 Registration::Activation::Finish = Minitest::Mock.new
155 Command::COMMAND_MANAGER = Minitest::Mock.new
156
157 def setup
158 @customer = Minitest::Mock.new(customer)
159 @tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
160 @activation = Registration::Activation.new(@customer, @tel)
161 end
162
163 def test_write
164 Command::COMMAND_MANAGER.expect(
165 :write,
166 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
167 iq.form.fields = [{ var: "plan_name", value: "test_usd" }]
168 }),
169 [Matching.new do |iq|
170 assert_equal :form, iq.form.type
171 assert_equal(
172 "You've selected (555) 555-0000 as your JMP number.",
173 iq.form.instructions.lines.first.chomp
174 )
175 end]
176 )
177 @customer.expect(:with_plan, @customer) do |*args, **|
178 assert_equal ["test_usd"], args
179 end
180 @customer.expect(:save_plan!, EMPromise.resolve(nil), [])
181 Registration::Activation::Payment.expect(
182 :for,
183 EMPromise.reject(:test_result),
184 [Blather::Stanza::Iq, @customer, @tel]
185 )
186 assert_equal(
187 :test_result,
188 execute_command { @activation.write.catch { |e| e } }
189 )
190 assert_mock Command::COMMAND_MANAGER
191 assert_mock @customer
192 assert_mock Registration::Activation::Payment
193 end
194 em :test_write
195
196 def test_write_with_onboarding_jid
197 Command::COMMAND_MANAGER.expect(
198 :write,
199 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
200 iq.form.fields = [{ var: "plan_name", value: "test_usd" }]
201 }),
202 [Matching.new do |iq|
203 assert_equal :form, iq.form.type
204 assert_equal(
205 "You've selected (555) 555-0000 as your JMP number.",
206 iq.form.instructions.lines.first.chomp
207 )
208 end]
209 )
210 @customer.expect(
211 :jid,
212 Blather::JID.new("test\\40onboarding.example.com@proxy")
213 )
214 @customer.expect(:with_plan, @customer) do |*args, **|
215 assert_equal ["test_usd"], args
216 end
217 @customer.expect(:save_plan!, EMPromise.resolve(nil), [])
218 Registration::Activation::Payment.expect(
219 :for,
220 EMPromise.reject(:test_result),
221 [Blather::Stanza::Iq, @customer, @tel]
222 )
223 assert_equal(
224 :test_result,
225 execute_command { @activation.write.catch { |e| e } }
226 )
227 assert_mock Command::COMMAND_MANAGER
228 assert_mock @customer
229 assert_mock Registration::Activation::Payment
230 end
231 em :test_write_with_onboarding_jid
232
233 def test_write_bad_plan
234 Command::COMMAND_MANAGER.expect(
235 :write,
236 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
237 iq.form.fields = [{ var: "plan_name", value: "test_usd_no_register" }]
238 }),
239 [Matching.new do |iq|
240 assert_equal :form, iq.form.type
241 assert_equal(
242 "You've selected (555) 555-0000 as your JMP number.",
243 iq.form.instructions.lines.first.chomp
244 )
245 end]
246 )
247 assert_equal(
248 "No registration plan by that name",
249 execute_command { @activation.write.catch { |e| e } }.message
250 )
251 assert_mock Command::COMMAND_MANAGER
252 assert_mock @customer
253 end
254 em :test_write_bad_plan
255
256 def test_write_with_code
257 Command::COMMAND_MANAGER.expect(
258 :write,
259 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
260 iq.form.fields = [
261 { var: "plan_name", value: "test_usd" },
262 { var: "code", value: "123" }
263 ]
264 }),
265 [Matching.new do |iq|
266 assert_equal :form, iq.form.type
267 assert_equal(
268 "You've selected (555) 555-0000 as your JMP number.",
269 iq.form.instructions.lines.first.chomp
270 )
271 end]
272 )
273 @customer.expect(:with_plan, @customer) do |*args, **|
274 assert_equal ["test_usd"], args
275 end
276 @customer.expect(:save_plan!, EMPromise.resolve(nil), [])
277 @customer.expect(:activate_plan_starting_now, EMPromise.resolve(nil), [])
278 Registration::Activation::DB.expect(:transaction, []) { |&blk| blk.call }
279 Registration::Activation::DB.expect(
280 :exec,
281 OpenStruct.new(cmd_tuples: 1),
282 [String, ["test", "123"]]
283 )
284 Registration::Activation::Finish.expect(
285 :new,
286 OpenStruct.new(write: EMPromise.reject(:test_result)),
287 [@customer, @tel]
288 )
289 assert_equal(
290 :test_result,
291 execute_command { @activation.write.catch { |e| e } }
292 )
293 assert_mock Command::COMMAND_MANAGER
294 assert_mock @customer
295 assert_mock Registration::Activation::Payment
296 assert_mock Registration::Activation::DB
297 end
298 em :test_write_with_code
299
300 def test_write_with_group_code
301 Command::COMMAND_MANAGER.expect(
302 :write,
303 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
304 iq.form.fields = [
305 { var: "plan_name", value: "test_usd" },
306 { var: "code", value: "123" }
307 ]
308 }),
309 [Matching.new do |iq|
310 assert_equal :form, iq.form.type
311 assert_equal(
312 "You've selected (555) 555-0000 as your JMP number.",
313 iq.form.instructions.lines.first.chomp
314 )
315 end]
316 )
317 @customer.expect(:with_plan, @customer) do |*args, **|
318 assert_equal ["test_usd"], args
319 end
320 @customer.expect(:save_plan!, EMPromise.resolve(nil), [])
321 Registration::Activation::DB.expect(:transaction, []) { |&blk| blk.call }
322 Registration::Activation::DB.expect(
323 :exec,
324 OpenStruct.new(cmd_tuples: 0),
325 [String, ["test", "123"]]
326 )
327 Registration::Activation::Payment.expect(
328 :for,
329 EMPromise.reject(:test_result),
330 [Blather::Stanza::Iq, @customer, @tel]
331 )
332 assert_equal(
333 :test_result,
334 execute_command { @activation.write.catch { |e| e } }
335 )
336 assert_equal(
337 "123",
338 Registration::Activation::REDIS.get(
339 "jmp_customer_pending_invite-test"
340 ).sync
341 )
342 assert_mock Command::COMMAND_MANAGER
343 assert_mock @customer
344 assert_mock Registration::Activation::Payment
345 assert_mock Registration::Activation::DB
346 end
347 em :test_write_with_group_code
348
349 def test_write_with_parent_code
350 execute_command do
351 Command::COMMAND_MANAGER.expect(
352 :write,
353 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
354 iq.form.fields = [
355 { var: "plan_name", value: "test_usd" },
356 { var: "code", value: "PARENT_CODE" }
357 ]
358 }),
359 [Matching.new do |iq|
360 assert_equal :form, iq.form.type
361 assert_equal(
362 "You've selected (555) 555-0000 as your JMP number.",
363 iq.form.instructions.lines.first.chomp
364 )
365 end]
366 )
367 Registration::Activation::DB.expect(
368 :query_one, {}, [String, "1"], default: {}
369 )
370 Registration::Activation::DB.expect(
371 :query_one, { c: 0 }, [String, "1"], default: { c: 0 }
372 )
373 @customer.expect(:with_plan, @customer) do |*args, **|
374 assert_equal ["test_usd"], args
375 end
376 @customer.expect(:with_plan, @customer) do |*, **kwargs|
377 assert_equal({ parent_customer_id: "1" }, kwargs)
378 end
379 @customer.expect(:save_plan!, EMPromise.resolve(nil), [])
380 @customer.expect(:balance, 100, [])
381 Command.execution.customer_repo.expect(
382 :find,
383 EMPromise.resolve(@customer), ["test"]
384 )
385 Registration::Payment::MaybeBill::BillPlan.expect(
386 :new,
387 EMPromise.reject(:test_result)
388 ) do |*args, **|
389 assert_equal @tel, args[1]
390 end
391 assert_equal(
392 :test_result,
393 @activation.write.catch { |e| e }.sync
394 )
395 end
396 assert_mock Command::COMMAND_MANAGER
397 assert_mock @customer
398 assert_mock Registration::Activation::Payment
399 assert_mock Registration::Activation::DB
400 assert_mock Registration::Payment::MaybeBill::BillPlan
401 end
402 em :test_write_with_parent_code
403
404 def test_write_with_parent_code_onboarding_jid
405 Command::COMMAND_MANAGER.expect(
406 :write,
407 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
408 iq.form.fields = [
409 { var: "plan_name", value: "test_usd" },
410 { var: "code", value: "PARENT_CODE" }
411 ]
412 }),
413 [Matching.new do |iq|
414 assert_equal :form, iq.form.type
415 assert_equal(
416 "You've selected (555) 555-0000 as your JMP number.",
417 iq.form.instructions.lines.first.chomp
418 )
419 end]
420 )
421 Registration::Activation::DB.expect(
422 :query_one, {}, [String, "1"], default: {}
423 )
424 Registration::Activation::DB.expect(
425 :query_one, { c: 0 }, [String, "1"], default: { c: 0 }
426 )
427 @customer.expect(:with_plan, @customer, ["test_usd"])
428 @customer.expect(
429 :jid,
430 Blather::JID.new("test\\40onboarding.example.com@proxy")
431 )
432 iq = Blather::Stanza::Iq::Command.new
433 iq.from = "test\\40onboarding.example.com@proxied"
434 assert_equal(
435 "Please create a new Jabber ID before creating a subaccount.",
436 execute_command(iq) { @activation.write.catch(&:to_s) }
437 )
438 assert_mock Command::COMMAND_MANAGER
439 assert_mock @customer
440 assert_mock Registration::Activation::Payment
441 assert_mock Registration::Activation::DB
442 end
443 em :test_write_with_parent_code_onboarding_jid
444
445 def test_write_with_parent_code_tombed_parent
446 Command::COMMAND_MANAGER.expect(
447 :write,
448 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
449 iq.form.fields = [
450 { var: "plan_name", value: "test_usd" },
451 { var: "code", value: "PARENT_TOMB" }
452 ]
453 }),
454 [Matching.new do |iq|
455 assert_equal :form, iq.form.type
456 assert_equal(
457 "You've selected (555) 555-0000 as your JMP number.",
458 iq.form.instructions.lines.first.chomp
459 )
460 end]
461 )
462 Registration::Activation::DB.expect(
463 :query_one, {}, [String, "2"], default: {}
464 )
465 Registration::Activation::DB.expect(
466 :query_one, { c: 0 }, [String, "2"], default: { c: 0 }
467 )
468 assert_equal(
469 "Please contact support to create a subaccount",
470 execute_command { @activation.write.catch(&:to_s) }
471 )
472 assert_mock Command::COMMAND_MANAGER
473 assert_mock @customer
474 assert_mock Registration::Activation::Payment
475 assert_mock Registration::Activation::DB
476 end
477 em :test_write_with_parent_code_tombed_parent
478
479 def test_write_with_parent_code_too_many
480 Command::COMMAND_MANAGER.expect(
481 :write,
482 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
483 iq.form.fields = [
484 { var: "plan_name", value: "test_usd" },
485 { var: "code", value: "PARENT_MANY_SUBACCOUNTS" }
486 ]
487 }),
488 [Matching.new do |iq|
489 assert_equal :form, iq.form.type
490 assert_equal(
491 "You've selected (555) 555-0000 as your JMP number.",
492 iq.form.instructions.lines.first.chomp
493 )
494 end]
495 )
496 Registration::Activation::DB.expect(
497 :query_one, {}, [String, "many_subaccounts"], default: {}
498 )
499 Registration::Activation::DB.expect(
500 :query_one, { c: 2 }, [String, "many_subaccounts"], default: { c: 0 }
501 )
502 assert_equal(
503 "Please contact support to create a subaccount",
504 execute_command { @activation.write.catch(&:to_s) }
505 )
506 assert_mock Command::COMMAND_MANAGER
507 assert_mock @customer
508 assert_mock Registration::Activation::Payment
509 assert_mock Registration::Activation::DB
510 end
511 em :test_write_with_parent_code_too_many
512 end
513
514 class AllowTest < Minitest::Test
515 Command::COMMAND_MANAGER = Minitest::Mock.new
516 Registration::Activation::Allow::DB = Minitest::Mock.new
517
518 def test_write_credit_to_nil
519 tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
520 cust = Minitest::Mock.new(customer("test"))
521 allow = Registration::Activation::Allow.new(cust, tel, nil)
522
523 Command::COMMAND_MANAGER.expect(
524 :write,
525 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
526 iq.form.fields = [{ var: "plan_name", value: "test_usd" }]
527 }),
528 [Matching.new do |iq|
529 assert_equal :form, iq.form.type
530 assert_equal(
531 "You've selected (555) 555-0000 as your JMP number.",
532 iq.form.instructions.lines.first.chomp
533 )
534 assert_equal 1, iq.form.fields.length
535 end]
536 )
537 Registration::Activation::Allow::DB.expect(
538 :transaction,
539 EMPromise.reject(:test_result)
540 ) do |&blk|
541 blk.call
542 true
543 end
544 cust.expect(:with_plan, cust, ["test_usd"])
545 cust.expect(:activate_plan_starting_now, nil)
546 assert_equal(
547 :test_result,
548 execute_command { allow.write.catch { |e| e } }
549 )
550 assert_mock Command::COMMAND_MANAGER
551 end
552 em :test_write_credit_to_nil
553
554 def test_write_credit_to_refercust
555 cust = Minitest::Mock.new(customer("test"))
556 tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
557 allow = Registration::Activation::Allow.new(
558 cust, tel, "refercust"
559 )
560
561 Command::COMMAND_MANAGER.expect(
562 :write,
563 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
564 iq.form.fields = [{ var: "plan_name", value: "test_usd" }]
565 }),
566 [Matching.new do |iq|
567 assert_equal :form, iq.form.type
568 assert_equal(
569 "You've selected (555) 555-0000 as your JMP number.",
570 iq.form.instructions.lines.first.chomp
571 )
572 assert_equal 1, iq.form.fields.length
573 end]
574 )
575 Registration::Activation::Allow::DB.expect(
576 :transaction,
577 EMPromise.reject(:test_result)
578 ) do |&blk|
579 blk.call
580 true
581 end
582 Registration::Activation::Allow::DB.expect(
583 :exec,
584 nil,
585 [String, ["refercust", "test"]]
586 )
587 cust.expect(:with_plan, cust, ["test_usd"])
588 cust.expect(:activate_plan_starting_now, nil)
589 assert_equal(
590 :test_result,
591 execute_command { allow.write.catch { |e| e } }
592 )
593 assert_mock Command::COMMAND_MANAGER
594 end
595 em :test_write_credit_to_refercust
596 end
597
598 class GooglePlayTest < Minitest::Test
599 CustomerPlan::DB = Minitest::Mock.new
600 Registration::Activation::GooglePlay::Finish = Minitest::Mock.new
601
602 def setup
603 @customer = customer
604 @tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
605 @google_play = Registration::Activation::GooglePlay.new(
606 @customer,
607 "abcd",
608 @tel
609 )
610 end
611
612 def test_write
613 Command::COMMAND_MANAGER.expect(
614 :write,
615 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
616 iq.form.fields = [{ var: "plan_name", value: "test_usd" }]
617 }),
618 [Matching.new do |iq|
619 assert_equal :form, iq.form.type
620 assert_equal(
621 "You've selected (555) 555-0000 as your JMP number.",
622 iq.form.instructions.lines.first.chomp
623 )
624 end]
625 )
626 CustomerPlan::DB.expect(
627 :exec,
628 OpenStruct.new(cmd_tuples: 1),
629 [String, ["test", "test_usd", nil]]
630 )
631 CustomerPlan::DB.expect(
632 :exec,
633 OpenStruct.new(cmd_tuples: 0),
634 [String, ["test"]]
635 )
636 Transaction::DB.expect(:transaction, true, [])
637 Registration::Activation::GooglePlay::Finish.expect(
638 :new,
639 OpenStruct.new(write: EMPromise.reject(:test_result)),
640 [Customer, @tel]
641 )
642 result = execute_command { @google_play.write.catch { |e| e } }
643 assert_equal :test_result, result
644 assert_mock Command::COMMAND_MANAGER
645 assert_mock CustomerPlan::DB
646 assert_mock Transaction::DB
647 assert_mock Registration::Activation::GooglePlay::Finish
648 end
649 em :test_write
650 end
651
652 class PaymentTest < Minitest::Test
653 CustomerFinancials::BRAINTREE = Minitest::Mock.new
654
655 def test_for_bitcoin
656 tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
657 iq = Blather::Stanza::Iq::Command.new
658 iq.form.fields = [
659 { var: "activation_method", value: "bitcoin" },
660 { var: "plan_name", value: "test_usd" }
661 ]
662 result = Registration::Payment.for(iq, customer, tel)
663 assert_kind_of Registration::Payment::Bitcoin, result
664 end
665
666 def test_for_bch
667 tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
668 iq = Blather::Stanza::Iq::Command.new
669 iq.form.fields = [
670 { var: "activation_method", value: "bch" },
671 { var: "plan_name", value: "test_usd" }
672 ]
673 result = Registration::Payment.for(iq, customer, tel)
674 assert_kind_of Registration::Payment::BCH, result
675 end
676
677 def test_for_credit_card
678 tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
679 iq = Blather::Stanza::Iq::Command.new
680 iq.from = "test@example.com"
681 iq.form.fields = [
682 { var: "activation_method", value: "credit_card" },
683 { var: "plan_name", value: "test_usd" }
684 ]
685 cust = customer
686 result = execute_command do
687 Command.execution.customer_repo.expect(:find, cust, ["test"])
688 Registration::Payment.for(
689 iq,
690 cust,
691 tel
692 )
693 end
694 assert_kind_of Registration::Payment::CreditCard, result
695 end
696 em :test_for_credit_card
697
698 def test_for_code
699 iq = Blather::Stanza::Iq::Command.new
700 iq.form.fields = [
701 { var: "activation_method", value: "code" },
702 { var: "plan_name", value: "test_usd" }
703 ]
704 cust = customer
705 result = execute_command do
706 Command.execution.customer_repo.expect(:find, cust, ["test"])
707 Registration::Payment.for(
708 iq,
709 cust,
710 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
711 )
712 end
713 assert_kind_of Registration::Payment::InviteCode, result
714 end
715 em :test_for_code
716
717 class BitcoinTest < Minitest::Test
718 Registration::Payment::Bitcoin::BTC_SELL_PRICES = Minitest::Mock.new
719 CustomerFinancials::REDIS = Minitest::Mock.new
720
721 def setup
722 @customer = Minitest::Mock.new(
723 customer(plan_name: "test_usd")
724 )
725 @customer.expect(
726 :add_btc_address,
727 EMPromise.resolve("testaddr")
728 )
729 @tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
730 @bitcoin = Registration::Payment::Bitcoin.new(
731 @customer,
732 @tel
733 )
734 end
735
736 def test_write
737 CustomerFinancials::REDIS.expect(
738 :smembers,
739 EMPromise.resolve([]),
740 ["jmp_customer_btc_addresses-test"]
741 )
742 blather = Minitest::Mock.new
743 Command::COMMAND_MANAGER.expect(
744 :write,
745 EMPromise.reject(SessionManager::Timeout.new),
746 [Matching.new do |reply|
747 assert_equal :canceled, reply.status
748 assert_equal "1.000000", reply.form.field("amount").value
749 assert_equal "testaddr", reply.form.field("btc_addresses").value
750 true
751 end]
752 )
753 Registration::Payment::Bitcoin::BTC_SELL_PRICES.expect(
754 :usd,
755 EMPromise.resolve(BigDecimal(1))
756 )
757 @bitcoin.stub(:save, EMPromise.resolve(nil)) do
758 execute_command(blather: blather) do
759 @bitcoin.write
760 end
761 end
762 assert_mock blather
763 end
764 em :test_write
765 end
766
767 class BCHTest < Minitest::Test
768 Registration::Payment::BCH::BCH_SELL_PRICES = Minitest::Mock.new
769 CustomerFinancials::REDIS = Minitest::Mock.new
770
771 def setup
772 @customer = Minitest::Mock.new(
773 customer(plan_name: "test_usd")
774 )
775 @customer.expect(
776 :add_bch_address,
777 EMPromise.resolve("testaddr")
778 )
779 @tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
780 @bch = Registration::Payment::BCH.new(
781 @customer,
782 @tel
783 )
784 end
785
786 def test_write
787 CustomerFinancials::REDIS.expect(
788 :smembers,
789 EMPromise.resolve([]),
790 ["jmp_customer_bch_addresses-test"]
791 )
792 blather = Minitest::Mock.new
793 Command::COMMAND_MANAGER.expect(
794 :write,
795 EMPromise.reject(SessionManager::Timeout.new),
796 [Matching.new do |reply|
797 assert_equal :canceled, reply.status
798 assert_equal "1.000000", reply.form.field("amount").value
799 assert_equal "testaddr", reply.form.field("bch_addresses").value
800 true
801 end]
802 )
803 Registration::Payment::BCH::BCH_SELL_PRICES.expect(
804 :usd,
805 EMPromise.resolve(BigDecimal(1))
806 )
807 @bch.stub(:save, EMPromise.resolve(nil)) do
808 execute_command(blather: blather) do
809 @bch.write
810 end
811 end
812 assert_mock blather
813 end
814 em :test_write
815 end
816
817 class CreditCardTest < Minitest::Test
818 def setup
819 @tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
820 @credit_card = Registration::Payment::CreditCard.new(
821 customer,
822 @tel
823 )
824 end
825
826 def test_new
827 tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
828 cust = Minitest::Mock.new(customer)
829 cust.expect(
830 :payment_methods,
831 EMPromise.resolve(OpenStruct.new(default_payment_method: :test))
832 )
833 execute_command do
834 Command.execution.customer_repo.expect(:find, cust, ["test"])
835 assert_kind_of(
836 Registration::Payment::CreditCard,
837 Registration::Payment::CreditCard.new(cust, tel)
838 )
839 end
840 end
841 em :test_new
842
843 def test_write
844 result = execute_command do
845 Command::COMMAND_MANAGER.expect(
846 :write,
847 EMPromise.reject(:test_result),
848 [Matching.new do |reply|
849 assert_equal [:execute, :next, :prev], reply.allowed_actions
850 assert_equal(
851 "Pay by credit card, save, then next here to continue: " \
852 "http://creditcard.example.com?&amount=1",
853 reply.note.content
854 )
855 end]
856 )
857
858 @credit_card.write.catch { |e| e }
859 end
860
861 assert_equal :test_result, result
862 end
863 em :test_write
864 end
865
866 class MailTest < Minitest::Test
867 def setup
868 @tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
869 @mail = Registration::Payment::Mail.new(
870 customer(plan_name: "test_cad"),
871 @tel
872 )
873 end
874
875 def test_write
876 result = execute_command do
877 Command::COMMAND_MANAGER.expect(
878 :write,
879 EMPromise.reject(:test_result),
880 [Matching.new do |reply|
881 assert_equal [:execute, :prev], reply.allowed_actions
882 refute reply.form.instructions.empty?
883 assert_equal(
884 "A Mailing Address",
885 reply.form.field("adr").value
886 )
887 assert_equal(
888 "interac@example.com",
889 reply.form.field("interac_email").value
890 )
891 end]
892 )
893
894 @mail.write.catch { |e| e }
895 end
896
897 assert_equal :test_result, result
898 end
899 em :test_write
900 end
901
902 class InviteCodeTest < Minitest::Test
903 Registration::Payment::InviteCode::DB =
904 Minitest::Mock.new
905 Registration::Payment::InviteCode::REDIS =
906 Minitest::Mock.new
907 Command::COMMAND_MANAGER = Minitest::Mock.new
908 Registration::Payment::InviteCode::Finish =
909 Minitest::Mock.new
910 Registration::Payment::MaybeBill::BillPlan =
911 Minitest::Mock.new
912
913 def setup
914 @tel = TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
915 end
916
917 def test_write
918 customer = customer(plan_name: "test_usd")
919 Registration::Payment::InviteCode::DB.expect(:transaction, true, [])
920 Registration::Payment::InviteCode::Finish.expect(
921 :new,
922 OpenStruct.new(write: nil),
923 [
924 customer,
925 @tel
926 ]
927 )
928 execute_command do
929 Registration::Payment::InviteCode::REDIS.expect(
930 :get,
931 EMPromise.resolve(nil),
932 ["jmp_invite_tries-test"]
933 )
934 Registration::Payment::InviteCode::REDIS.expect(
935 :hget,
936 EMPromise.resolve(nil),
937 ["jmp_parent_codes", "abc"]
938 )
939 Command::COMMAND_MANAGER.expect(
940 :write,
941 EMPromise.resolve(
942 Blather::Stanza::Iq::Command.new.tap { |iq|
943 iq.form.fields = [{ var: "code", value: "abc" }]
944 }
945 ),
946 [Matching.new do |reply|
947 assert_equal :form, reply.form.type
948 assert_nil reply.form.instructions
949 end]
950 )
951
952 Registration::Payment::InviteCode.new(
953 customer,
954 @tel
955 ).write
956 end
957 assert_mock Command::COMMAND_MANAGER
958 assert_mock Registration::Payment::InviteCode::DB
959 assert_mock Registration::Payment::InviteCode::REDIS
960 assert_mock Registration::Payment::InviteCode::Finish
961 end
962 em :test_write
963
964 def test_write_parent_code
965 customer = customer(plan_name: "test_usd")
966 Registration::Payment::MaybeBill::BillPlan.expect(
967 :new,
968 OpenStruct.new(write: nil)
969 ) { |*| true }
970 Registration::Payment::InviteCode::DB.expect(
971 :query_one, {}, [String, "parent_customer"], default: {}
972 )
973 Registration::Payment::InviteCode::DB.expect(
974 :query_one, { c: 0 }, [String, "parent_customer"], default: { c: 0 }
975 )
976 execute_command do
977 Registration::Payment::InviteCode::REDIS.expect(
978 :hget,
979 EMPromise.resolve("parent_customer"),
980 ["jmp_parent_codes", "pabc"]
981 )
982 Registration::Payment::InviteCode::REDIS.expect(
983 :get,
984 EMPromise.resolve(nil),
985 ["jmp_customer_trust_level-parent_customer"]
986 )
987 CustomerPlan::DB.expect(
988 :query,
989 [{ "plan_name" => "test_usd" }],
990 [String, ["parent_customer"]]
991 )
992 CustomerPlan::DB.expect(
993 :exec_defer,
994 EMPromise.resolve(nil),
995 [String, ["test", "test_usd", "parent_customer"]]
996 )
997 Command.execution.customer_repo.expect(
998 :find,
999 customer.with_balance(10000),
1000 ["test"]
1001 )
1002 Command::COMMAND_MANAGER.expect(
1003 :write,
1004 EMPromise.resolve(
1005 Blather::Stanza::Iq::Command.new.tap { |iq|
1006 iq.form.fields = [{ var: "code", value: "pabc" }]
1007 }
1008 ),
1009 [Matching.new do |reply|
1010 assert_equal :form, reply.form.type
1011 assert_nil reply.form.instructions
1012 end]
1013 )
1014
1015 Registration::Payment::InviteCode.new(
1016 customer,
1017 @tel
1018 ).write
1019 end
1020 assert_mock Command::COMMAND_MANAGER
1021 assert_mock Registration::Payment::InviteCode::DB
1022 assert_mock Registration::Payment::InviteCode::REDIS
1023 assert_mock Registration::Payment::MaybeBill::BillPlan
1024 end
1025 em :test_write_parent_code
1026
1027 def test_write_bad_code
1028 result = execute_command do
1029 customer = customer(plan_name: "test_usd")
1030 Registration::Payment::InviteCode::REDIS.expect(
1031 :set,
1032 EMPromise.resolve(nil),
1033 ["jmp_customer_pending_invite-test", "abc"]
1034 )
1035 Registration::Payment::InviteCode::REDIS.expect(
1036 :get,
1037 EMPromise.resolve(0),
1038 ["jmp_invite_tries-test"]
1039 )
1040 Registration::Payment::InviteCode::REDIS.expect(
1041 :hget,
1042 EMPromise.resolve(nil),
1043 ["jmp_parent_codes", "abc"]
1044 )
1045 Registration::Payment::InviteCode::DB.expect(
1046 :transaction,
1047 []
1048 ) { |&blk| blk.call }
1049 Registration::Payment::InviteCode::DB.expect(
1050 :exec,
1051 OpenStruct.new(cmd_tuples: 0),
1052 [String, ["test", "abc"]]
1053 )
1054 Registration::Payment::InviteCode::REDIS.expect(
1055 :incr,
1056 EMPromise.resolve(nil),
1057 ["jmp_invite_tries-test"]
1058 )
1059 Registration::Payment::InviteCode::REDIS.expect(
1060 :expire,
1061 EMPromise.resolve(nil),
1062 ["jmp_invite_tries-test", 60 * 60]
1063 )
1064 Registration::Payment::InviteCode::REDIS.expect(
1065 :hexists,
1066 EMPromise.resolve(0),
1067 ["jmp_group_codes", "abc"]
1068 )
1069 Command::COMMAND_MANAGER.expect(
1070 :write,
1071 EMPromise.resolve(
1072 Blather::Stanza::Iq::Command.new.tap { |iq|
1073 iq.form.fields = [{ var: "code", value: "abc" }]
1074 }
1075 ),
1076 [Matching.new do |reply|
1077 assert_equal :form, reply.form.type
1078 assert_nil reply.form.instructions
1079 end]
1080 )
1081 Command::COMMAND_MANAGER.expect(
1082 :write,
1083 EMPromise.reject(:test_result),
1084 [Matching.new do |reply|
1085 assert_equal :form, reply.form.type
1086 assert_equal(
1087 "Not a valid invite code: abc",
1088 reply.form.instructions
1089 )
1090 end]
1091 )
1092
1093 Registration::Payment::InviteCode.new(
1094 customer,
1095 @tel
1096 ).write.catch { |e| e }
1097 end
1098 assert_equal :test_result, result
1099 assert_mock Command::COMMAND_MANAGER
1100 assert_mock Registration::Payment::InviteCode::DB
1101 assert_mock Registration::Payment::InviteCode::REDIS
1102 end
1103 em :test_write_bad_code
1104
1105 def test_write_group_code
1106 result = execute_command do
1107 customer = customer(plan_name: "test_usd")
1108 Registration::Payment::InviteCode::REDIS.expect(
1109 :set,
1110 EMPromise.resolve(nil),
1111 ["jmp_customer_pending_invite-test", "abc"]
1112 )
1113 Registration::Payment::InviteCode::REDIS.expect(
1114 :get,
1115 EMPromise.resolve(0),
1116 ["jmp_invite_tries-test"]
1117 )
1118 Registration::Payment::InviteCode::REDIS.expect(
1119 :hget,
1120 EMPromise.resolve(nil),
1121 ["jmp_parent_codes", "abc"]
1122 )
1123 Registration::Payment::InviteCode::DB.expect(
1124 :transaction,
1125 []
1126 ) { |&blk| blk.call }
1127 Registration::Payment::InviteCode::DB.expect(
1128 :exec,
1129 OpenStruct.new(cmd_tuples: 0),
1130 [String, ["test", "abc"]]
1131 )
1132 Registration::Payment::InviteCode::REDIS.expect(
1133 :incr,
1134 EMPromise.resolve(nil),
1135 ["jmp_invite_tries-test"]
1136 )
1137 Registration::Payment::InviteCode::REDIS.expect(
1138 :expire,
1139 EMPromise.resolve(nil),
1140 ["jmp_invite_tries-test", 60 * 60]
1141 )
1142 Registration::Payment::InviteCode::REDIS.expect(
1143 :hexists,
1144 EMPromise.resolve(1),
1145 ["jmp_group_codes", "abc"]
1146 )
1147 Command::COMMAND_MANAGER.expect(
1148 :write,
1149 EMPromise.resolve(
1150 Blather::Stanza::Iq::Command.new.tap { |iq|
1151 iq.form.fields = [{ var: "code", value: "abc" }]
1152 }
1153 ),
1154 [Matching.new do |reply|
1155 assert_equal :form, reply.form.type
1156 assert_nil reply.form.instructions
1157 end]
1158 )
1159 Command::COMMAND_MANAGER.expect(
1160 :write,
1161 EMPromise.reject(:test_result),
1162 [Matching.new do |reply|
1163 assert_equal :form, reply.form.type
1164 assert_equal(
1165 "abc is a post-payment referral",
1166 reply.form.instructions
1167 )
1168 end]
1169 )
1170
1171 Registration::Payment::InviteCode.new(
1172 customer,
1173 @tel
1174 ).write.catch { |e| e }
1175 end
1176 assert_equal :test_result, result
1177 assert_mock Command::COMMAND_MANAGER
1178 assert_mock Registration::Payment::InviteCode::DB
1179 assert_mock Registration::Payment::InviteCode::REDIS
1180 end
1181 em :test_write_group_code
1182
1183 def test_write_bad_code_over_limit
1184 result = execute_command do
1185 customer = customer(plan_name: "test_usd")
1186 Registration::Payment::InviteCode::REDIS.expect(
1187 :get,
1188 EMPromise.resolve(11),
1189 ["jmp_invite_tries-test"]
1190 )
1191 Registration::Payment::InviteCode::REDIS.expect(
1192 :hget,
1193 EMPromise.resolve(nil),
1194 ["jmp_parent_codes", "abc"]
1195 )
1196 Command::COMMAND_MANAGER.expect(
1197 :write,
1198 EMPromise.resolve(
1199 Blather::Stanza::Iq::Command.new.tap { |iq|
1200 iq.form.fields = [{ var: "code", value: "abc" }]
1201 }
1202 ),
1203 [Matching.new do |reply|
1204 assert_equal :form, reply.form.type
1205 assert_nil reply.form.instructions
1206 end]
1207 )
1208 Command::COMMAND_MANAGER.expect(
1209 :write,
1210 EMPromise.reject(:test_result),
1211 [Matching.new do |reply|
1212 assert_equal :form, reply.form.type
1213 assert_equal "Too many wrong attempts", reply.form.instructions
1214 end]
1215 )
1216 Registration::Payment::InviteCode.new(
1217 customer,
1218 @tel
1219 ).write.catch { |e| e }
1220 end
1221 assert_equal :test_result, result
1222 assert_mock Command::COMMAND_MANAGER
1223 assert_mock Registration::Payment::InviteCode::REDIS
1224 end
1225 em :test_write_bad_code_over_limit
1226 end
1227 end
1228
1229 class FinishTest < Minitest::Test
1230 Customer::BLATHER = Minitest::Mock.new
1231 Command::COMMAND_MANAGER = Minitest::Mock.new
1232 Registration::Finish::TEL_SELECTIONS = FakeTelSelections.new
1233 Registration::Finish::REDIS = Minitest::Mock.new
1234 Registration::Finish::DB = Minitest::Mock.new
1235 Bwmsgsv2Repo::REDIS = Minitest::Mock.new
1236 Registration::FinishOnboarding::DB = FakeDB.new
1237 Transaction::DB = Minitest::Mock.new
1238
1239 def setup
1240 @sgx = Minitest::Mock.new(mksgx)
1241 iq = Blather::Stanza::Iq::Command.new
1242 iq.from = "test\\40example.com@cheogram.com"
1243 @finish = Registration::Finish.new(
1244 customer(sgx: @sgx, plan_name: "test_usd"),
1245 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
1246 )
1247 end
1248
1249 def test_write
1250 create_order = stub_request(
1251 :post,
1252 "https://dashboard.bandwidth.com/v1.0/accounts//orders"
1253 ).to_return(status: 201, body: <<~RESPONSE)
1254 <OrderResponse>
1255 <Order>
1256 <id>test_order</id>
1257 </Order>
1258 </OrderResponse>
1259 RESPONSE
1260 stub_request(
1261 :get,
1262 "https://dashboard.bandwidth.com/v1.0/accounts//orders/test_order"
1263 ).to_return(status: 201, body: <<~RESPONSE)
1264 <OrderResponse>
1265 <OrderStatus>COMPLETE</OrderStatus>
1266 <CompletedNumbers>
1267 <TelephoneNumber>
1268 <FullNumber>5555550000</FullNumber>
1269 </TelephoneNumber>
1270 </CompletedNumbers>
1271 </OrderResponse>
1272 RESPONSE
1273 stub_request(
1274 :post,
1275 "https://dashboard.bandwidth.com/v1.0/accounts//sites//sippeers//movetns"
1276 )
1277 Registration::Finish::REDIS.expect(
1278 :get,
1279 nil,
1280 ["jmp_customer_pending_invite-test"]
1281 )
1282 Registration::Finish::REDIS.expect(
1283 :del,
1284 nil,
1285 ["jmp_customer_pending_invite-test"]
1286 )
1287 Registration::Finish::REDIS.expect(
1288 :hget,
1289 nil,
1290 ["jmp_group_codes", nil]
1291 )
1292 Bwmsgsv2Repo::REDIS.expect(
1293 :get,
1294 EMPromise.resolve(nil),
1295 ["jmp_customer_backend_sgx-test"]
1296 )
1297 Bwmsgsv2Repo::REDIS.expect(
1298 :set,
1299 nil,
1300 [
1301 "catapult_fwd-+15555550000",
1302 "xmpp:test@example.net"
1303 ]
1304 )
1305 Bwmsgsv2Repo::REDIS.expect(
1306 :set,
1307 nil,
1308 ["catapult_fwd_timeout-customer_test@component", 25]
1309 )
1310 Customer::BLATHER.expect(
1311 :<<,
1312 nil,
1313 [Matching.new do |m|
1314 assert_equal :chat, m.type
1315 assert m.body =~ /^Welcome to JMP/
1316 end]
1317 )
1318 blather = Minitest::Mock.new
1319 blather.expect(
1320 :<<,
1321 nil,
1322 [Matching.new do |reply|
1323 assert_equal :completed, reply.status
1324 assert_equal :info, reply.note_type
1325 assert_equal(
1326 "Your JMP account has been activated as (555) 555-0000",
1327 reply.note.content
1328 )
1329 end]
1330 )
1331 execute_command(blather: blather) do
1332 @sgx.expect(
1333 :register!,
1334 EMPromise.resolve(@sgx.with(
1335 registered?: Blather::Stanza::Iq::IBR.new.tap do |ibr|
1336 ibr.phone = "+15555550000"
1337 end
1338 )),
1339 ["+15555550000"]
1340 )
1341
1342 @finish.write
1343 end
1344 assert_requested create_order
1345 assert_mock @sgx
1346 assert_mock Registration::Finish::REDIS
1347 assert_mock Bwmsgsv2Repo::REDIS
1348 assert_mock Customer::BLATHER
1349 assert_mock blather
1350 end
1351 em :test_write
1352
1353 def test_write_with_pending_code
1354 create_order = stub_request(
1355 :post,
1356 "https://dashboard.bandwidth.com/v1.0/accounts//orders"
1357 ).to_return(status: 201, body: <<~RESPONSE)
1358 <OrderResponse>
1359 <Order>
1360 <id>test_order</id>
1361 </Order>
1362 </OrderResponse>
1363 RESPONSE
1364 stub_request(
1365 :get,
1366 "https://dashboard.bandwidth.com/v1.0/accounts//orders/test_order"
1367 ).to_return(status: 201, body: <<~RESPONSE)
1368 <OrderResponse>
1369 <OrderStatus>COMPLETE</OrderStatus>
1370 <CompletedNumbers>
1371 <TelephoneNumber>
1372 <FullNumber>5555550000</FullNumber>
1373 </TelephoneNumber>
1374 </CompletedNumbers>
1375 </OrderResponse>
1376 RESPONSE
1377 stub_request(
1378 :post,
1379 "https://dashboard.bandwidth.com/v1.0/accounts//sites//sippeers//movetns"
1380 )
1381 Registration::Finish::REDIS.expect(
1382 :get,
1383 EMPromise.resolve("123"),
1384 ["jmp_customer_pending_invite-test"]
1385 )
1386 Registration::Finish::REDIS.expect(
1387 :del,
1388 nil,
1389 ["jmp_customer_pending_invite-test"]
1390 )
1391 Registration::Finish::REDIS.expect(
1392 :hget,
1393 EMPromise.resolve("test-inviter"),
1394 ["jmp_group_codes", "123"]
1395 )
1396 Registration::Finish::DB.expect(
1397 :exec,
1398 EMPromise.resolve(nil),
1399 [String, ["test-inviter", "test"]]
1400 )
1401 Transaction::DB.expect(:transaction, nil) do |&blk|
1402 blk.call
1403 true
1404 end
1405 Transaction::DB.expect(
1406 :exec,
1407 nil,
1408 [String, Matching.new { |params|
1409 assert_equal "test", params[0]
1410 assert params[1].start_with?("referral_")
1411 assert_equal 1, params[4]
1412 assert_equal "Referral Bonus", params[5]
1413 }]
1414 )
1415 Bwmsgsv2Repo::REDIS.expect(
1416 :get,
1417 EMPromise.resolve(nil),
1418 ["jmp_customer_backend_sgx-test"]
1419 )
1420 Bwmsgsv2Repo::REDIS.expect(
1421 :set,
1422 nil,
1423 [
1424 "catapult_fwd-+15555550000",
1425 "xmpp:test@example.net"
1426 ]
1427 )
1428 Bwmsgsv2Repo::REDIS.expect(
1429 :set,
1430 nil,
1431 ["catapult_fwd_timeout-customer_test@component", 25]
1432 )
1433 Customer::BLATHER.expect(
1434 :<<,
1435 nil,
1436 [Matching.new do |m|
1437 assert_equal :chat, m.type
1438 assert m.body =~ /^Welcome to JMP/
1439 end]
1440 )
1441 blather = Minitest::Mock.new
1442 blather.expect(
1443 :<<,
1444 nil,
1445 [Matching.new do |reply|
1446 assert_equal :completed, reply.status
1447 assert_equal :info, reply.note_type
1448 assert_equal(
1449 "Your JMP account has been activated as (555) 555-0000",
1450 reply.note.content
1451 )
1452 end]
1453 )
1454 execute_command(blather: blather) do
1455 @sgx.expect(
1456 :register!,
1457 EMPromise.resolve(@sgx.with(
1458 registered?: Blather::Stanza::Iq::IBR.new.tap do |ibr|
1459 ibr.phone = "+15555550000"
1460 end
1461 )),
1462 ["+15555550000"]
1463 )
1464
1465 @finish.write
1466 end
1467 assert_requested create_order
1468 assert_mock @sgx
1469 assert_mock Registration::Finish::REDIS
1470 assert_mock Bwmsgsv2Repo::REDIS
1471 assert_mock Customer::BLATHER
1472 assert_mock blather
1473 assert_mock Transaction::DB
1474 end
1475 em :test_write_with_pending_code
1476
1477 def test_write_onboarding
1478 create_order = stub_request(
1479 :post,
1480 "https://dashboard.bandwidth.com/v1.0/accounts//orders"
1481 ).to_return(status: 201, body: <<~RESPONSE)
1482 <OrderResponse>
1483 <Order>
1484 <id>test_order</id>
1485 </Order>
1486 </OrderResponse>
1487 RESPONSE
1488 stub_request(
1489 :get,
1490 "https://dashboard.bandwidth.com/v1.0/accounts//orders/test_order"
1491 ).to_return(status: 201, body: <<~RESPONSE)
1492 <OrderResponse>
1493 <OrderStatus>COMPLETE</OrderStatus>
1494 <CompletedNumbers>
1495 <TelephoneNumber>
1496 <FullNumber>5555550000</FullNumber>
1497 </TelephoneNumber>
1498 </CompletedNumbers>
1499 </OrderResponse>
1500 RESPONSE
1501 stub_request(
1502 :post,
1503 "https://dashboard.bandwidth.com/v1.0/accounts//sites//sippeers//movetns"
1504 )
1505 Registration::Finish::REDIS.expect(
1506 :get,
1507 nil,
1508 ["jmp_customer_pending_invite-test"]
1509 )
1510 Registration::Finish::REDIS.expect(
1511 :del,
1512 nil,
1513 ["jmp_customer_pending_invite-test"]
1514 )
1515 Registration::Finish::REDIS.expect(
1516 :hget,
1517 nil,
1518 ["jmp_group_codes", nil]
1519 )
1520 Bwmsgsv2Repo::REDIS.expect(
1521 :get,
1522 EMPromise.resolve(nil),
1523 ["jmp_customer_backend_sgx-test"]
1524 )
1525 Bwmsgsv2Repo::REDIS.expect(
1526 :set,
1527 nil,
1528 [
1529 "catapult_fwd-+15555550000",
1530 "xmpp:test\\40onboarding.example.com@proxy"
1531 ]
1532 )
1533 Bwmsgsv2Repo::REDIS.expect(
1534 :set,
1535 nil,
1536 ["catapult_fwd_timeout-customer_test@component", 25]
1537 )
1538 result = execute_command do
1539 @sgx.expect(
1540 :register!,
1541 EMPromise.resolve(@sgx.with(
1542 registered?: Blather::Stanza::Iq::IBR.new.tap do |ibr|
1543 ibr.phone = "+15555550000"
1544 end
1545 )),
1546 ["+15555550000"]
1547 )
1548
1549 Command::COMMAND_MANAGER.expect(
1550 :write,
1551 EMPromise.reject(:test_result),
1552 [Matching.new do |iq|
1553 assert_equal :form, iq.form.type
1554 assert iq.form.field("subdomain")
1555 end]
1556 )
1557
1558 Registration::Finish.new(
1559 customer(
1560 sgx: @sgx,
1561 jid: Blather::JID.new("test\\40onboarding.example.com@proxy")
1562 ),
1563 TelSelections::ChooseTel::Tn.for_pending_value("+15555550000")
1564 ).write.catch { |e| e }
1565 end
1566 assert_equal :test_result, result
1567 assert_requested create_order
1568 assert_mock @sgx
1569 assert_mock Registration::Finish::REDIS
1570 assert_mock Bwmsgsv2Repo::REDIS
1571 assert_mock Command::COMMAND_MANAGER
1572 end
1573 em :test_write_onboarding
1574
1575 def test_write_local_inventory
1576 stub_request(
1577 :post,
1578 "https://dashboard.bandwidth.com/v1.0/accounts/moveto/moveTns"
1579 ).with(
1580 body: {
1581 CustomerOrderId: "test",
1582 SourceAccountId: "bandwidth_account_id",
1583 SiteId: "test_site",
1584 SipPeerId: "test_peer",
1585 TelephoneNumbers: { TelephoneNumber: "5555550000" }
1586 }.to_xml(indent: 0, root: "MoveTnsOrder")
1587 ).to_return(status: 200, body: "", headers: {})
1588
1589 Registration::Finish::REDIS.expect(
1590 :get,
1591 nil,
1592 ["jmp_customer_pending_invite-test"]
1593 )
1594 Registration::Finish::REDIS.expect(
1595 :del,
1596 nil,
1597 ["jmp_customer_pending_invite-test"]
1598 )
1599 Registration::Finish::REDIS.expect(
1600 :hget,
1601 nil,
1602 ["jmp_group_codes", nil]
1603 )
1604 Registration::Finish::DB.expect(
1605 :exec_defer,
1606 EMPromise.resolve(OpenStruct.new(cmd_tuples: 1)),
1607 [String, ["+15555550000"]]
1608 )
1609 Bwmsgsv2Repo::REDIS.expect(
1610 :get,
1611 EMPromise.resolve(nil),
1612 ["jmp_customer_backend_sgx-test"]
1613 )
1614 Bwmsgsv2Repo::REDIS.expect(
1615 :set,
1616 nil,
1617 [
1618 "catapult_fwd-+15555550000",
1619 "xmpp:test\\40onboarding.example.com@proxy"
1620 ]
1621 )
1622 Bwmsgsv2Repo::REDIS.expect(
1623 :set,
1624 nil,
1625 ["catapult_fwd_timeout-customer_test@component", 25]
1626 )
1627 result = execute_command do
1628 @sgx.expect(
1629 :register!,
1630 EMPromise.resolve(@sgx.with(
1631 registered?: Blather::Stanza::Iq::IBR.new.tap do |ibr|
1632 ibr.phone = "+15555550000"
1633 end
1634 )),
1635 ["+15555550000"]
1636 )
1637
1638 Command::COMMAND_MANAGER.expect(
1639 :write,
1640 EMPromise.reject(:test_result),
1641 [Matching.new do |iq|
1642 assert_equal :form, iq.form.type
1643 assert iq.form.field("subdomain")
1644 end]
1645 )
1646
1647 Registration::Finish.new(
1648 customer(
1649 sgx: @sgx,
1650 jid: Blather::JID.new("test\\40onboarding.example.com@proxy")
1651 ),
1652 TelSelections::ChooseTel::Tn::LocalInventory.new(
1653 TelSelections::ChooseTel::Tn.new("+15555550000"),
1654 "bandwidth_account_id"
1655 )
1656 ).write.catch { |e| e }
1657 end
1658 assert_equal :test_result, result
1659 assert_mock @sgx
1660 assert_mock Registration::Finish::REDIS
1661 assert_mock Bwmsgsv2Repo::REDIS
1662 assert_mock Command::COMMAND_MANAGER
1663 end
1664 em :test_write_local_inventory
1665
1666 def test_write_local_inventory_must_pay
1667 low_cust = customer(
1668 sgx: @sgx,
1669 jid: Blather::JID.new("test\\40onboarding.example.com@proxy")
1670 ).with_balance(5.0)
1671 high_cust = customer(
1672 sgx: @sgx,
1673 jid: Blather::JID.new("test\\40onboarding.example.com@proxy")
1674 ).with_balance(100.0)
1675
1676 stub_request(
1677 :post,
1678 "https://dashboard.bandwidth.com/v1.0/accounts/moveto/moveTns"
1679 ).with(
1680 body: {
1681 CustomerOrderId: "test",
1682 SourceAccountId: "bandwidth_account_id",
1683 SiteId: "test_site",
1684 SipPeerId: "test_peer",
1685 TelephoneNumbers: { TelephoneNumber: "5555550000" }
1686 }.to_xml(indent: 0, root: "MoveTnsOrder")
1687 ).to_return(status: 200, body: "", headers: {})
1688
1689 Registration::Finish::REDIS.expect(
1690 :get,
1691 nil,
1692 ["jmp_customer_pending_invite-test"]
1693 )
1694 Registration::Finish::REDIS.expect(
1695 :del,
1696 nil,
1697 ["jmp_customer_pending_invite-test"]
1698 )
1699 Registration::Finish::REDIS.expect(
1700 :hget,
1701 nil,
1702 ["jmp_group_codes", nil]
1703 )
1704 Registration::Finish::DB.expect(
1705 :exec_defer,
1706 EMPromise.resolve(OpenStruct.new(cmd_tuples: 1)),
1707 [String, ["+15555550000"]]
1708 )
1709 Bwmsgsv2Repo::REDIS.expect(
1710 :get,
1711 EMPromise.resolve(nil),
1712 ["jmp_customer_backend_sgx-test"]
1713 )
1714 Bwmsgsv2Repo::REDIS.expect(
1715 :set,
1716 nil,
1717 [
1718 "catapult_fwd-+15555550000",
1719 "xmpp:test\\40onboarding.example.com@proxy"
1720 ]
1721 )
1722 Bwmsgsv2Repo::REDIS.expect(
1723 :set,
1724 nil,
1725 ["catapult_fwd_timeout-customer_test@component", 25]
1726 )
1727
1728 local_tel = Minitest::Mock.new(
1729 TelSelections::ChooseTel::Tn::LocalInventory.new(
1730 TelSelections::ChooseTel::Tn.new("+15555550000"),
1731 "bandwidth_account_id",
1732 price: 10.0
1733 )
1734 )
1735
1736 result = execute_command do
1737 local_tel.expect(:charge, EMPromise.reject(:test_result), [Customer])
1738 @sgx.expect(
1739 :register!,
1740 EMPromise.resolve(@sgx.with(
1741 registered?: Blather::Stanza::Iq::IBR.new.tap do |ibr|
1742 ibr.phone = "+15555550000"
1743 end
1744 )),
1745 ["+15555550000"]
1746 )
1747
1748 Command::COMMAND_MANAGER.expect(
1749 :write,
1750 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
1751 iq.from = "customer@example.org"
1752 iq.form.fields = [
1753 { var: "activation_method", value: "credit_card" }
1754 ]
1755 }),
1756 [Matching.new do |iq|
1757 assert_equal :form, iq.form.type
1758 assert_equal "Purchase Number", iq.form.title
1759 end]
1760 )
1761
1762 Command.execution.customer_repo.expect(
1763 :find,
1764 EMPromise.resolve(high_cust),
1765 ["test"]
1766 )
1767
1768 Command::COMMAND_MANAGER.expect(
1769 :write,
1770 EMPromise.resolve(Blather::Stanza::Iq::Command.new.tap { |iq|
1771 iq.from = "customer@example.org"
1772 }),
1773 [Matching.new do |iq|
1774 assert_equal(
1775 "Pay by credit card, save, then next here to continue: " \
1776 "http://creditcard.example.com?&amount=10",
1777 iq.note.text
1778 )
1779 end]
1780 )
1781
1782 Registration::Finish.new(
1783 low_cust,
1784 local_tel
1785 ).write.catch { |e| e }
1786 end
1787
1788 assert_equal :test_result, result
1789 assert_mock @sgx
1790 assert_mock Registration::Finish::REDIS
1791 assert_mock Bwmsgsv2Repo::REDIS
1792 assert_mock Command::COMMAND_MANAGER
1793 end
1794 em :test_write_local_inventory_must_pay
1795
1796 def test_write_tn_fail
1797 create_order = stub_request(
1798 :post,
1799 "https://dashboard.bandwidth.com/v1.0/accounts//orders"
1800 ).to_return(status: 201, body: <<~RESPONSE)
1801 <OrderResponse>
1802 <Order>
1803 <id>test_order</id>
1804 </Order>
1805 </OrderResponse>
1806 RESPONSE
1807 stub_request(
1808 :get,
1809 "https://dashboard.bandwidth.com/v1.0/accounts//orders/test_order"
1810 ).to_return(status: 201, body: <<~RESPONSE)
1811 <OrderResponse>
1812 <OrderStatus>FAILED</OrderStatus>
1813 </OrderResponse>
1814 RESPONSE
1815
1816 result = execute_command do
1817 Command::COMMAND_MANAGER.expect(
1818 :write,
1819 EMPromise.reject(:test_result),
1820 [Matching.new do |iq|
1821 assert_equal :form, iq.form.type
1822 assert_equal(
1823 "The JMP number (555) 555-0000 is no longer available.",
1824 iq.form.instructions
1825 )
1826 end]
1827 )
1828
1829 @finish.write.catch { |e| e }
1830 end
1831
1832 assert_equal :test_result, result
1833 assert_mock Command::COMMAND_MANAGER
1834 assert_instance_of(
1835 TelSelections::ChooseTel,
1836 Registration::Finish::TEL_SELECTIONS["test@example.com"]
1837 )
1838 assert_requested create_order
1839 end
1840 em :test_write_tn_fail
1841 end
1842
1843 # class SnikketTest < Minitest::Test
1844 # Command::COMMAND_MANAGER = Minitest::Mock.new
1845 # Registration::FinishOnboarding::Snikket::IQ_MANAGER = Minitest::Mock.new
1846
1847 # def setup
1848 # @sgx = Minitest::Mock.new(mksgx)
1849 # @snikket = Registration::FinishOnboarding::Snikket.new(
1850 # customer(sgx: @sgx),
1851 # "+15555550000",
1852 # db: FakeDB.new
1853 # )
1854 # end
1855
1856 # def test_write
1857 # xmpp_uri = "xmpp:test.snikket.chat?register;preauth=NEWTOKEN"
1858
1859 # subdomain_form = Blather::Stanza::Iq::Command.new
1860 # subdomain_form.form.fields = [
1861 # { var: "subdomain", value: "test" }
1862 # ]
1863
1864 # launched = Snikket::Launched.new
1865 # launched << Niceogiri::XML::Node.new(
1866 # :launched, launched.document, "xmpp:snikket.org/hosting/v1"
1867 # ).tap { |inner|
1868 # inner << Niceogiri::XML::Node.new(
1869 # :'instance-id', launched.document, "xmpp:snikket.org/hosting/v1"
1870 # ).tap { |id|
1871 # id.content = "si-1234"
1872 # }
1873 # inner << Niceogiri::XML::Node.new(
1874 # :bootstrap, launched.document, "xmpp:snikket.org/hosting/v1"
1875 # ).tap { |bootstrap|
1876 # bootstrap << Niceogiri::XML::Node.new(
1877 # :token, launched.document, "xmpp:snikket.org/hosting/v1"
1878 # ).tap { |token|
1879 # token.content = "TOKEN"
1880 # }
1881 # }
1882 # }
1883
1884 # blather = Minitest::Mock.new
1885 # blather.expect(
1886 # :<<,
1887 # nil,
1888 # [Matching.new do |reply|
1889 # assert_equal :completed, reply.status
1890 # assert_equal(
1891 # xmpp_uri,
1892 # OOB.find_or_create(reply.command).url
1893 # )
1894 # end]
1895 # )
1896
1897 # execute_command(blather: blather) do
1898 # Command::COMMAND_MANAGER.expect(
1899 # :write,
1900 # EMPromise.resolve(subdomain_form),
1901 # [Matching.new do |iq|
1902 # assert_equal :form, iq.form.type
1903 # assert iq.form.field("subdomain")
1904 # end]
1905 # )
1906
1907 # Registration::FinishOnboarding::Snikket::IQ_MANAGER.expect(
1908 # :write,
1909 # EMPromise.resolve(launched),
1910 # [Matching.new do |iq|
1911 # assert_equal :set, iq.type
1912 # assert_equal CONFIG[:snikket_hosting_api], iq.to.to_s
1913 # assert_equal(
1914 # "test.snikket.chat",
1915 # iq.xpath(
1916 # "./ns:launch/ns:domain",
1917 # ns: "xmpp:snikket.org/hosting/v1"
1918 # ).text
1919 # )
1920 # end]
1921 # )
1922
1923 # # Webmock doesn't support redirects properly, but they work live
1924 # stub_request(
1925 # :head, "https://test.snikket.chat/invites_bootstrap?token=TOKEN"
1926 # ).to_return(
1927 # status: 200,
1928 # headers: {
1929 # "link" => "<#{xmpp_uri}>; rel=\"alternate\""
1930 # }
1931 # )
1932
1933 # @snikket.write
1934 # end
1935
1936 # assert_mock Command::COMMAND_MANAGER
1937 # assert_mock Registration::FinishOnboarding::Snikket::IQ_MANAGER
1938 # assert_mock blather
1939 # end
1940 # em :test_write
1941
1942 # def test_write_not_yet
1943 # subdomain_form = Blather::Stanza::Iq::Command.new
1944 # subdomain_form.form.fields = [
1945 # { var: "subdomain", value: "test" }
1946 # ]
1947
1948 # launched = Snikket::Launched.new
1949 # launched << Niceogiri::XML::Node.new(
1950 # :launched, launched.document, "xmpp:snikket.org/hosting/v1"
1951 # ).tap { |inner|
1952 # inner << Niceogiri::XML::Node.new(
1953 # :'instance-id', launched.document, "xmpp:snikket.org/hosting/v1"
1954 # ).tap { |id|
1955 # id.content = "si-1234"
1956 # }
1957 # inner << Niceogiri::XML::Node.new(
1958 # :bootstrap, launched.document, "xmpp:snikket.org/hosting/v1"
1959 # ).tap { |bootstrap|
1960 # bootstrap << Niceogiri::XML::Node.new(
1961 # :token, launched.document, "xmpp:snikket.org/hosting/v1"
1962 # ).tap { |token|
1963 # token.content = "TOKEN"
1964 # }
1965 # }
1966 # }
1967
1968 # result = execute_command do
1969 # Command::COMMAND_MANAGER.expect(
1970 # :write,
1971 # EMPromise.resolve(subdomain_form),
1972 # [Matching.new do |iq|
1973 # assert_equal :form, iq.form.type
1974 # assert iq.form.field("subdomain")
1975 # end]
1976 # )
1977
1978 # Registration::FinishOnboarding::Snikket::IQ_MANAGER.expect(
1979 # :write,
1980 # EMPromise.resolve(launched),
1981 # [Matching.new do |iq|
1982 # assert_equal :set, iq.type
1983 # assert_equal CONFIG[:snikket_hosting_api], iq.to.to_s
1984 # assert_equal(
1985 # "test.snikket.chat",
1986 # iq.xpath(
1987 # "./ns:launch/ns:domain",
1988 # ns: "xmpp:snikket.org/hosting/v1"
1989 # ).text
1990 # )
1991 # end]
1992 # )
1993
1994 # stub_request(
1995 # :head, "https://test.snikket.chat/invites_bootstrap?token=TOKEN"
1996 # ).to_timeout
1997
1998 # Command::COMMAND_MANAGER.expect(
1999 # :write,
2000 # EMPromise.reject(:test_result),
2001 # [Matching.new do |iq|
2002 # assert_equal :result, iq.form.type
2003 # assert iq.form.instructions =~ / test\.snikket\.chat /
2004 # assert_equal "jid-single", iq.form.field("support").type
2005 # end]
2006 # )
2007
2008 # @snikket.write.catch { |e| e }
2009 # end
2010
2011 # assert_equal :test_result, result
2012 # assert_mock Command::COMMAND_MANAGER
2013 # assert_mock Registration::FinishOnboarding::Snikket::IQ_MANAGER
2014 # end
2015 # em :test_write_not_yet
2016
2017 # def test_write_already_taken
2018 # subdomain_form = Blather::Stanza::Iq::Command.new
2019 # subdomain_form.form.fields = [
2020 # { var: "subdomain", value: "test" }
2021 # ]
2022
2023 # launched = Snikket::Launched.new.as_error(
2024 # "internal-server-error",
2025 # :wait,
2026 # "This is an error"
2027 # )
2028
2029 # result = execute_command do
2030 # Command::COMMAND_MANAGER.expect(
2031 # :write,
2032 # EMPromise.resolve(subdomain_form),
2033 # [Matching.new do |iq|
2034 # assert_equal :form, iq.form.type
2035 # assert iq.form.field("subdomain")
2036 # end]
2037 # )
2038
2039 # Registration::FinishOnboarding::Snikket::IQ_MANAGER.expect(
2040 # :write,
2041 # EMPromise.reject(launched),
2042 # [Matching.new do |iq|
2043 # assert_equal :set, iq.type
2044 # assert_equal CONFIG[:snikket_hosting_api], iq.to.to_s
2045 # assert_equal(
2046 # "test.snikket.chat",
2047 # iq.xpath(
2048 # "./ns:launch/ns:domain",
2049 # ns: "xmpp:snikket.org/hosting/v1"
2050 # ).text
2051 # )
2052 # end]
2053 # )
2054
2055 # stub_request(
2056 # :head, "https://test.snikket.chat/invites_bootstrap?token=TOKEN"
2057 # ).to_timeout
2058
2059 # Command::COMMAND_MANAGER.expect(
2060 # :write,
2061 # EMPromise.reject(:test_result),
2062 # [Matching.new do |iq|
2063 # assert iq.executing?
2064 # assert_equal(
2065 # "This is an error",
2066 # iq.form.field("subdomain").desc
2067 # )
2068 # end]
2069 # )
2070
2071 # @snikket.write.catch { |e| e }
2072 # end
2073
2074 # assert_equal :test_result, result
2075 # assert_mock Command::COMMAND_MANAGER
2076 # assert_mock Registration::FinishOnboarding::Snikket::IQ_MANAGER
2077 # end
2078 # em :test_write_already_taken
2079 # end
2080
2081 # class SnikketCustomDomainTest < Minitest::Test
2082 # def setup
2083 # @snikket = Registration::FinishOnboarding::CustomDomain.new(
2084 # customer,
2085 # "+15555550000",
2086 # db: FakeDB.new
2087 # )
2088 # end
2089
2090 # def test_write_needs_dns
2091 # domain_form = Blather::Stanza::Iq::Command.new
2092 # domain_form.form.fields = [
2093 # { var: "domain", value: "snikket.example.com" }
2094 # ]
2095
2096 # launched = Snikket::Launched.new
2097 # launched << Niceogiri::XML::Node.new(
2098 # :launched, launched.document, "xmpp:snikket.org/hosting/v1"
2099 # ).tap { |inner|
2100 # inner << Niceogiri::XML::Node.new(
2101 # :'instance-id', launched.document, "xmpp:snikket.org/hosting/v1"
2102 # ).tap { |id|
2103 # id.content = "si-1234"
2104 # }
2105 # inner << Niceogiri::XML::Node.new(
2106 # :status, launched.document, "xmpp:snikket.org/hosting/v1"
2107 # ).tap { |id|
2108 # id.content = "needs_dns"
2109 # }
2110 # inner << Niceogiri::XML::Node.new(
2111 # :records, launched.document, "xmpp:snikket.org/hosting/v1"
2112 # ).tap { |records|
2113 # records << Niceogiri::XML::Node.new(
2114 # :record, launched.document, "xmpp:snikket.org/hosting/v1"
2115 # ).tap { |record|
2116 # record << Niceogiri::XML::Node.new(
2117 # :name, launched.document, "xmpp:snikket.org/hosting/v1"
2118 # ).tap { |name| name.content = "snikket.example.com" }
2119 # record << Niceogiri::XML::Node.new(
2120 # :type, launched.document, "xmpp:snikket.org/hosting/v1"
2121 # ).tap { |type| type.content = "AAAA" }
2122 # record << Niceogiri::XML::Node.new(
2123 # :status, launched.document, "xmpp:snikket.org/hosting/v1"
2124 # ).tap { |type| type.content = "incorrect" }
2125 # record << Niceogiri::XML::Node.new(
2126 # :expected, launched.document, "xmpp:snikket.org/hosting/v1"
2127 # ).tap { |expected|
2128 # expected << Niceogiri::XML::Node.new(
2129 # :value, launched.document, "xmpp:snikket.org/hosting/v1"
2130 # ).tap { |value| value.content = "1::2" }
2131 # }
2132 # record << Niceogiri::XML::Node.new(
2133 # :found, launched.document, "xmpp:snikket.org/hosting/v1"
2134 # ).tap { |found|
2135 # found << Niceogiri::XML::Node.new(
2136 # :value, launched.document, "xmpp:snikket.org/hosting/v1"
2137 # ).tap { |value| value.content = "0::0" }
2138 # }
2139 # }
2140 # }
2141 # }
2142
2143 # result = execute_command do
2144 # Command::COMMAND_MANAGER.expect(
2145 # :write,
2146 # EMPromise.resolve(domain_form),
2147 # [Matching.new do |iq|
2148 # assert_equal :form, iq.form.type
2149 # assert iq.form.field("domain")
2150 # end]
2151 # )
2152
2153 # Registration::FinishOnboarding::Snikket::IQ_MANAGER.expect(
2154 # :write,
2155 # EMPromise.resolve(launched),
2156 # [Matching.new do |iq|
2157 # assert_equal :set, iq.type
2158 # assert_equal CONFIG[:snikket_hosting_api], iq.to.to_s
2159 # assert_equal(
2160 # "snikket.example.com",
2161 # iq.xpath(
2162 # "./ns:launch/ns:domain",
2163 # ns: "xmpp:snikket.org/hosting/v1"
2164 # ).text
2165 # )
2166 # end]
2167 # )
2168
2169 # Command::COMMAND_MANAGER.expect(
2170 # :write,
2171 # EMPromise.reject(:test_result),
2172 # [Matching.new do |iq|
2173 # assert_equal :form, iq.form.type
2174 # assert_equal(
2175 # ["snikket.example.com"],
2176 # iq.form.xpath(
2177 # "./ns:item/ns:field[@var='name']/ns:value",
2178 # ns: "jabber:x:data"
2179 # ).map(&:content)
2180 # )
2181 # assert_equal(
2182 # ["1::2"],
2183 # iq.form.xpath(
2184 # "./ns:item/ns:field[@var='expected']/ns:value",
2185 # ns: "jabber:x:data"
2186 # ).map(&:content)
2187 # )
2188 # end]
2189 # )
2190
2191 # @snikket.write.catch { |e| e }
2192 # end
2193
2194 # assert_equal :test_result, result
2195 # assert_mock Command::COMMAND_MANAGER
2196 # assert_mock Registration::FinishOnboarding::Snikket::IQ_MANAGER
2197 # end
2198 # em :test_write_needs_dns
2199 # end
2200end