# frozen_string_literal: true
require "test_helper"
require "registration"
class RegistrationTest < Minitest::Test
def test_for_activated
skip "Registration#for activated not implemented yet"
iq = Blather::Stanza::Iq::Command.new
Registration.for(iq, Customer.new("test"), Minitest::Mock.new).sync
end
em :test_for_activated
def test_for_not_activated_with_customer_id
BACKEND_SGX.expect(
:registered?,
EMPromise.resolve(nil),
["test"]
)
web_manager = WebRegisterManager.new
web_manager["test@example.com"] = "+15555550000"
iq = Blather::Stanza::Iq::Command.new
iq.from = "test@example.com"
result = Registration.for(
iq,
Customer.new("test"),
web_manager
).sync
assert_kind_of Registration::Activation, result
end
em :test_for_not_activated_with_customer_id
def test_for_not_activated_without_customer_id
skip "customer_id creation not implemented yet"
iq = Blather::Stanza::Iq::Command.new
Registration.for(iq, nil, Minitest::Mock.new).sync
end
em :test_for_not_activated_without_customer_id
class ActivationTest < Minitest::Test
Registration::Activation::COMMAND_MANAGER = Minitest::Mock.new
def setup
iq = Blather::Stanza::Iq::Command.new
@activation = Registration::Activation.new(iq, "test", "+15555550000")
end
def test_write
stub_request(
:get,
"https://dashboard.bandwidth.com/v1.0/tns/+15555550000"
).to_return(status: 201, body: <<~RESPONSE)
<TelephoneNumberResponse>
<TelephoneNumber>5555550000</TelephoneNumber>
</TelephoneNumberResponse>
RESPONSE
stub_request(
:get,
"https://dashboard.bandwidth.com/v1.0/tns/5555550000/ratecenter"
).to_return(status: 201, body: <<~RESPONSE)
<TelephoneNumberResponse>
<TelephoneNumberDetails>
<State>KE</State>
<RateCenter>FA</RateCenter>
</TelephoneNumberDetails>
</TelephoneNumberResponse>
RESPONSE
result = Minitest::Mock.new
result.expect(:then, result)
result.expect(:then, EMPromise.resolve(:test_result))
Registration::Activation::COMMAND_MANAGER.expect(
:write,
result,
[Matching.new do |iq|
assert_equal :form, iq.form.type
assert_equal(
"Going to activate +15555550000 (FA, KE)",
iq.form.instructions
)
end]
)
assert_equal :test_result, @activation.write.sync
end
em :test_write
end
class PaymentTest < Minitest::Test
Customer::BRAINTREE = Minitest::Mock.new
Registration::Payment::Bitcoin::ELECTRUM = Minitest::Mock.new
def test_for_bitcoin
Registration::Payment::Bitcoin::ELECTRUM.expect(:createnewaddress, "addr")
iq = Blather::Stanza::Iq::Command.new
iq.form.fields = [
{ var: "activation_method", value: "bitcoin" },
{ var: "plan_name", value: "test_usd" }
]
result = Registration::Payment.for(
iq,
Customer.new("test"),
"+15555550000"
)
assert_kind_of Registration::Payment::Bitcoin, result
end
def test_for_credit_card
braintree_customer = Minitest::Mock.new
Customer::BRAINTREE.expect(
:customer,
braintree_customer
)
braintree_customer.expect(
:find,
EMPromise.resolve(OpenStruct.new(payment_methods: [])),
["test"]
)
iq = Blather::Stanza::Iq::Command.new
iq.from = "test@example.com"
iq.form.fields = [
{ var: "activation_method", value: "credit_card" },
{ var: "plan_name", value: "test_usd" }
]
result = Registration::Payment.for(
iq,
Customer.new("test"),
"+15555550000"
).sync
assert_kind_of Registration::Payment::CreditCard, result
end
em :test_for_credit_card
def test_for_code
skip "Code not implemented yet"
iq = Blather::Stanza::Iq::Command.new
iq.form.fields = [
{ var: "activation_method", value: "code" },
{ var: "plan_name", value: "test_usd" }
]
result = Registration::Payment.for(iq, "test", "+15555550000")
assert_kind_of Registration::Payment::Code, result
end
class BitcoinTest < Minitest::Test
Registration::Payment::Bitcoin::ELECTRUM = Minitest::Mock.new
Registration::Payment::Bitcoin::REDIS = Minitest::Mock.new
Registration::Payment::Bitcoin::BTC_SELL_PRICES = Minitest::Mock.new
Registration::Payment::Bitcoin::BLATHER = Minitest::Mock.new
def setup
Registration::Payment::Bitcoin::ELECTRUM.expect(
:createnewaddress,
EMPromise.resolve("testaddr")
)
iq = Blather::Stanza::Iq::Command.new
@bitcoin = Registration::Payment::Bitcoin.new(
iq,
Customer.new("test", plan_name: "test_usd"),
"+15555550000"
)
end
def test_write
reply_text = <<~NOTE
Activate your account by sending at least 1.000000 BTC to
testaddr
You will receive a notification when your payment is complete.
NOTE
Registration::Payment::Bitcoin::BLATHER.expect(
:<<,
nil,
[Matching.new do |reply|
assert_equal :completed, reply.status
assert_equal :info, reply.note_type
assert_equal reply_text, reply.note.content
true
end]
)
Registration::Payment::Bitcoin::BTC_SELL_PRICES.expect(
:usd,
EMPromise.resolve(BigDecimal.new(1))
)
@bitcoin.stub(:save, EMPromise.resolve(nil)) do
@bitcoin.write.sync
end
Registration::Payment::Bitcoin::BLATHER.verify
end
em :test_write
end
class CreditCardTest < Minitest::Test
def setup
@iq = Blather::Stanza::Iq::Command.new
@iq.from = "test@example.com"
@credit_card = Registration::Payment::CreditCard.new(
@iq,
Customer.new("test"),
"+15555550000"
)
end
def test_for
customer = Minitest::Mock.new(Customer.new("test"))
customer.expect(
:payment_methods,
EMPromise.resolve(OpenStruct.new(default_payment_method: :test))
)
assert_kind_of(
Registration::Payment::CreditCard::Activate,
Registration::Payment::CreditCard.for(
@iq,
customer,
"+15555550000"
).sync
)
end
em :test_for
def test_reply
assert_equal [:execute, :next], @credit_card.reply.allowed_actions
assert_equal(
"Add credit card, then return here and choose next: " \
"http://creditcard.example.com",
@credit_card.reply.note.content
)
end
end
class ActivateTest < Minitest::Test
Registration::Payment::CreditCard::Activate::Finish =
Minitest::Mock.new
Registration::Payment::CreditCard::Activate::Transaction =
Minitest::Mock.new
Registration::Payment::CreditCard::Activate::COMMAND_MANAGER =
Minitest::Mock.new
def test_write
transaction = PromiseMock.new
transaction.expect(
:insert,
EMPromise.resolve(nil)
)
customer = Minitest::Mock.new(
Customer.new("test", plan_name: "test_usd")
)
Registration::Payment::CreditCard::Activate::Transaction.expect(
:sale,
transaction,
[
customer,
CONFIG[:activation_amount],
:test_default_method
]
)
iq = Blather::Stanza::Iq::Command.new
customer.expect(:bill_plan, nil)
Registration::Payment::CreditCard::Activate::Finish.expect(
:new,
OpenStruct.new(write: nil),
[Blather::Stanza::Iq, customer, "+15555550000"]
)
Registration::Payment::CreditCard::Activate.new(
iq,
customer,
:test_default_method,
"+15555550000"
).write.sync
Registration::Payment::CreditCard::Activate::Transaction.verify
transaction.verify
customer.verify
Registration::Payment::CreditCard::Activate::Finish.verify
end
em :test_write
def test_write_declines
customer = Minitest::Mock.new(
Customer.new("test", plan_name: "test_usd")
)
Registration::Payment::CreditCard::Activate::Transaction.expect(
:sale,
EMPromise.reject("declined"),
[
customer,
CONFIG[:activation_amount],
:test_default_method
]
)
iq = Blather::Stanza::Iq::Command.new
iq.from = "test@example.com"
result = Minitest::Mock.new
result.expect(:then, nil)
Registration::Payment::CreditCard::Activate::COMMAND_MANAGER.expect(
:write,
result,
[Matching.new do |reply|
assert_equal :error, reply.note_type
assert_equal(
Registration::Payment::CreditCard::Activate::DECLINE_MESSAGE +
": http://creditcard.example.com",
reply.note.content
)
end]
)
Registration::Payment::CreditCard::Activate.new(
iq,
customer,
:test_default_method,
"+15555550000"
).write.sync
Registration::Payment::CreditCard::Activate::Transaction.verify
end
em :test_write_declines
end
end
class FinishTest < Minitest::Test
Registration::Finish::BLATHER = Minitest::Mock.new
def setup
@finish = Registration::Finish.new(
Blather::Stanza::Iq::Command.new,
Customer.new("test"),
"+15555550000"
)
end
def test_write
create_order = stub_request(
:post,
"https://dashboard.bandwidth.com/v1.0/accounts//orders"
).to_return(status: 201, body: <<~RESPONSE)
<OrderResponse>
<Order>
<id>test_order</id>
</Order>
</OrderResponse>
RESPONSE
stub_request(
:get,
"https://dashboard.bandwidth.com/v1.0/accounts//orders/test_order"
).to_return(status: 201, body: <<~RESPONSE)
<OrderResponse>
<OrderStatus>COMPLETE</OrderStatus>
</OrderResponse>
RESPONSE
BACKEND_SGX.expect(
:register!,
EMPromise.resolve(OpenStruct.new(error?: false)),
["test", "+15555550000"]
)
Registration::Finish::BLATHER.expect(
:<<,
nil,
[Matching.new do |reply|
assert_equal :completed, reply.status
assert_equal :info, reply.note_type
assert_equal(
"Your JMP account has been activated as +15555550000",
reply.note.content
)
end]
)
@finish.write.sync
assert_requested create_order
BACKEND_SGX.verify
Registration::Finish::BLATHER.verify
end
em :test_write
def test_write_tn_fail
create_order = stub_request(
:post,
"https://dashboard.bandwidth.com/v1.0/accounts//orders"
).to_return(status: 201, body: <<~RESPONSE)
<OrderResponse>
<Order>
<id>test_order</id>
</Order>
</OrderResponse>
RESPONSE
stub_request(
:get,
"https://dashboard.bandwidth.com/v1.0/accounts//orders/test_order"
).to_return(status: 201, body: <<~RESPONSE)
<OrderResponse>
<OrderStatus>FAILED</OrderStatus>
</OrderResponse>
RESPONSE
Registration::Finish::BLATHER.expect(
:<<,
nil,
[Matching.new do |reply|
assert_equal :completed, reply.status
assert_equal :error, reply.note_type
assert_equal(
"The JMP number +15555550000 is no longer available, " \
"please visit https://jmp.chat and choose another.",
reply.note.content
)
end]
)
@finish.write.sync
assert_requested create_order
Registration::Finish::BLATHER.verify
end
em :test_write_tn_fail
end
end