1# frozen_string_literal: true
2
3require "trust_level_repo"
4
5class TrustLevelRepoTest < Minitest::Test
6 def setup
7 CustomerPlan::DB.expect(
8 :query_one, {}, [String, "test"]
9 )
10 end
11
12 def teardown
13 assert_mock CustomerPlan::DB
14 end
15
16 def test_manual_tomb
17 trust_level = TrustLevelRepo.new(
18 db: FakeDB.new,
19 redis: FakeRedis.new(
20 "jmp_customer_trust_level-test" => "Tomb"
21 )
22 ).find(customer(plan_name: "test_usd")).sync
23 assert_equal "Manual(Tomb)", trust_level.to_s
24 end
25 em :test_manual_tomb
26
27 def test_manual_cellar
28 trust_level = TrustLevelRepo.new(
29 db: FakeDB.new,
30 redis: FakeRedis.new(
31 "jmp_customer_trust_level-test" => "Cellar"
32 )
33 ).find(customer(plan_name: "test_usd")).sync
34 assert_equal "Manual(Cellar)", trust_level.to_s
35 end
36 em :test_manual_cellar
37
38 def test_manual_basement
39 trust_level = TrustLevelRepo.new(
40 db: FakeDB.new,
41 redis: FakeRedis.new(
42 "jmp_customer_trust_level-test" => "Basement"
43 )
44 ).find(customer(plan_name: "test_usd")).sync
45 assert_equal "Manual(Basement)", trust_level.to_s
46 end
47 em :test_manual_basement
48
49 def test_manual_customer
50 trust_level = TrustLevelRepo.new(
51 db: FakeDB.new,
52 redis: FakeRedis.new(
53 "jmp_customer_trust_level-test" => "Customer"
54 )
55 ).find(customer(plan_name: "test_usd")).sync
56 assert_equal "Manual(Customer)", trust_level.to_s
57 end
58 em :test_manual_customer
59
60 def test_manual_paragon
61 trust_level = TrustLevelRepo.new(
62 db: FakeDB.new,
63 redis: FakeRedis.new(
64 "jmp_customer_trust_level-test" => "Paragon"
65 )
66 ).find(customer(plan_name: "test_usd")).sync
67 assert_equal "Manual(Paragon)", trust_level.to_s
68 end
69 em :test_manual_paragon
70
71 def test_manual_unknown
72 trust_level = TrustLevelRepo.new(
73 db: FakeDB.new,
74 redis: FakeRedis.new(
75 "jmp_customer_trust_level-test" => "UNKNOWN"
76 )
77 ).find(customer(plan_name: "test_usd")).sync
78 assert_equal "Manual(Customer)", trust_level.to_s
79 end
80 em :test_manual_unknown
81
82 def test_new_customer
83 trust_level = TrustLevelRepo.new(
84 db: FakeDB.new,
85 redis: FakeRedis.new
86 ).find(customer(plan_name: "test_usd")).sync
87 assert_kind_of TrustLevel::Cellar, trust_level
88 end
89 em :test_new_customer
90
91 def test_new_customer_with_activater
92 trust_level = TrustLevelRepo.new(
93 db: FakeDB.new,
94 redis: FakeRedis.new(
95 "jmp_customer_activater-test" => "+15551234567"
96 )
97 ).find(customer(plan_name: "test_usd")).sync
98 assert_kind_of TrustLevel::Basement, trust_level
99 end
100 em :test_new_customer_with_activater
101
102 def test_invited_customer
103 trust_level = TrustLevelRepo.new(
104 db: FakeDB.new(
105 ["test"] => FakeDB::MultiResult.new([{ used_at: Time.now }], [])
106 ),
107 redis: FakeRedis.new
108 ).find(customer(plan_name: "test_usd")).sync
109 assert_kind_of TrustLevel::Basement, trust_level
110 end
111 em :test_invited_customer
112
113 def test_old_customer
114 CustomerPlan::DB.query_one("", "test")
115 CustomerPlan::DB.expect(
116 :query_one, { start_date: Time.parse("2026-02-25") }, [String, "test"]
117 )
118 trust_level = TrustLevelRepo.new(
119 db: FakeDB.new,
120 redis: FakeRedis.new
121 ).find(customer(plan_name: "test_usd")).sync
122 assert_kind_of TrustLevel::Basement, trust_level
123 end
124 em :test_old_customer
125
126 def test_regular_customer
127 trust_level = TrustLevelRepo.new(
128 db: FakeDB.new(["test"] => [{ "settled_amount" => 15 }]),
129 redis: FakeRedis.new(
130 "jmp_customer_activater-test" => "+15551234567"
131 )
132 ).find(customer(plan_name: "test_usd")).sync
133 assert_kind_of TrustLevel::Customer, trust_level
134 end
135 em :test_regular_customer
136
137 def test_settled_customer
138 trust_level = TrustLevelRepo.new(
139 db: FakeDB.new(["test"] => [{ "settled_amount" => 61 }]),
140 redis: FakeRedis.new(
141 "jmp_customer_activater-test" => "+15551234567"
142 )
143 ).find(customer(plan_name: "test_usd")).sync
144 assert_kind_of TrustLevel::Paragon, trust_level
145 end
146 em :test_settled_customer
147end