@@ -22,31 +22,31 @@ func TestCalculator(t *testing.T) {
2222
2323 calculator := NewCalculator (sub , identity )
2424
25- sub .EXPECT ().GetTFTPrice ().Return (types .U32 (1 ), nil ).AnyTimes ()
25+ sub .EXPECT ().GetTFTPrice ().Return (types .U32 (5 ), nil ).AnyTimes ()
2626 sub .EXPECT ().GetPricingPolicy (1 ).Return (substrate.PricingPolicy {
2727 ID : 1 ,
2828 SU : substrate.Policy {
29- Value : 2 ,
29+ Value : 50000 ,
3030 },
3131 CU : substrate.Policy {
32- Value : 2 ,
32+ Value : 100000 ,
3333 },
3434 IPU : substrate.Policy {
35- Value : 2 ,
35+ Value : 40000 ,
3636 },
3737 }, nil ).AnyTimes ()
3838
3939 cost , err := calculator .CalculateCost (8 , 32 , 0 , 50 , true , true )
4040 assert .NoError (t , err )
41- assert .Equal (t , cost , 16.2 )
41+ assert .Equal (t , 76.725 , cost )
4242
4343 sub .EXPECT ().GetBalance (identity ).Return (substrate.Balance {
4444 Free : types.U128 {
4545 Int : big .NewInt (50000000 ),
4646 },
4747 }, nil )
4848
49- dedicatedPrice , sharedPrice , err := calculator .CalculateDiscount (cost )
49+ dedicatedPrice , sharedPrice , err := calculator .CalculatePricesAfterDiscount (cost )
5050 assert .NoError (t , err )
5151 assert .Equal (t , dedicatedPrice , sharedPrice )
5252}
@@ -61,33 +61,148 @@ func TestSubstrateErrors(t *testing.T) {
6161
6262 calculator := NewCalculator (sub , identity )
6363
64- t .Run ("test tft price error" , func (t * testing.T ) {
65- sub .EXPECT ().GetTFTPrice ().Return (types .U32 (1 ), errors .New ("error" )).AnyTimes ()
66-
67- _ , err := calculator .CalculateCost (0 , 0 , 0 , 0 , false , false )
68- assert .Error (t , err )
69-
70- _ , _ , err = calculator .CalculateDiscount (200 )
71- assert .Error (t , err )
72- })
73-
7464 t .Run ("test tft pricing policy error" , func (t * testing.T ) {
75- sub .EXPECT ().GetTFTPrice ().Return (types .U32 (1 ), nil ).AnyTimes ()
7665 sub .EXPECT ().GetPricingPolicy (1 ).Return (substrate.PricingPolicy {}, errors .New ("error" )).AnyTimes ()
7766
7867 _ , err := calculator .CalculateCost (0 , 0 , 0 , 0 , false , false )
7968 assert .Error (t , err )
8069
81- _ , _ , err = calculator .CalculateDiscount (200 )
70+ _ , _ , err = calculator .CalculatePricesAfterDiscount (200 )
8271 assert .Error (t , err )
8372 })
8473
8574 t .Run ("test tft balance error" , func (t * testing.T ) {
86- sub .EXPECT ().GetTFTPrice ().Return (types .U32 (1 ), nil ).AnyTimes ()
8775 sub .EXPECT ().GetPricingPolicy (1 ).Return (substrate.PricingPolicy {}, nil ).AnyTimes ()
8876 sub .EXPECT ().GetBalance (identity ).Return (substrate.Balance {}, errors .New ("error" )).AnyTimes ()
8977
90- _ , _ , err = calculator .CalculateDiscount (0 )
78+ _ , _ , err = calculator .CalculatePricesAfterDiscount (0 )
79+ assert .Error (t , err )
80+ })
81+ }
82+
83+ func TestGetApplicableDiscount (t * testing.T ) {
84+ testCases := []struct {
85+ name string
86+ balance float64
87+ dedicatedPrice float64
88+ sharedPrice float64
89+ expectedDedicatedDiscount float64
90+ expectedSharedDiscount float64
91+ }{
92+ {
93+ name : "No balance" ,
94+ balance : 0 ,
95+ dedicatedPrice : 100 ,
96+ sharedPrice : 80 ,
97+ expectedDedicatedDiscount : 0 ,
98+ expectedSharedDiscount : 0 ,
99+ },
100+ {
101+ name : "Insufficient balance for any package" ,
102+ balance : 50 ,
103+ dedicatedPrice : 100 ,
104+ sharedPrice : 80 ,
105+ expectedDedicatedDiscount : 0 ,
106+ expectedSharedDiscount : 0 ,
107+ },
108+ {
109+ name : "Balance enough for default package only for shared" ,
110+ balance : 130 , // > 80 * 1.5 but < 100 * 1.5
111+ dedicatedPrice : 100 ,
112+ sharedPrice : 80 ,
113+ expectedDedicatedDiscount : 0 ,
114+ expectedSharedDiscount : 0.2 , // Default package discount 20%
115+ },
116+ {
117+ name : "Balance enough for default package for both" ,
118+ balance : 160 , // > 100 * 1.5 and > 80 * 1.5
119+ dedicatedPrice : 100 ,
120+ sharedPrice : 80 ,
121+ expectedDedicatedDiscount : 0.2 , // Default package discount 20%
122+ expectedSharedDiscount : 0.2 , // Default package discount 20%
123+ },
124+ {
125+ name : "Balance enough for bronze package for shared, default for dedicated" ,
126+ balance : 250 , // > 80 * 3 and < 100 * 1.5
127+ dedicatedPrice : 100 ,
128+ sharedPrice : 80 ,
129+ expectedDedicatedDiscount : 0.2 , // Default Package discount 20%
130+ expectedSharedDiscount : 0.3 , // Bronze package discount 30%
131+ },
132+ {
133+ name : "Balance enough for bronze package for both" ,
134+ balance : 350 , // > 100 * 3 and > 80 * 3
135+ dedicatedPrice : 100 ,
136+ sharedPrice : 80 ,
137+ expectedDedicatedDiscount : 0.3 , // Bronze package discount 30%
138+ expectedSharedDiscount : 0.3 , // Bronze package discount 30%
139+ },
140+ {
141+ name : "Balance enough for silver package for shared, and bronze for dedicated" ,
142+ balance : 500 , // > 80 * 6 but < 100 * 6
143+ dedicatedPrice : 100 ,
144+ sharedPrice : 80 ,
145+ expectedDedicatedDiscount : 0.3 , // Bronze package discount 30%
146+ expectedSharedDiscount : 0.4 , // Silver package discount 40%
147+ },
148+ {
149+ name : "Balance enough for silver package for both" ,
150+ balance : 650 , // > 100 * 6 and > 80 * 6
151+ dedicatedPrice : 100 ,
152+ sharedPrice : 80 ,
153+ expectedDedicatedDiscount : 0.4 ,
154+ expectedSharedDiscount : 0.4 ,
155+ },
156+ {
157+ name : "Balance enough for gold package for shared, and Silver for dedicated" ,
158+ balance : 1500 , // > 80 * 18 but < 100 * 18
159+ dedicatedPrice : 100 ,
160+ sharedPrice : 80 ,
161+ expectedDedicatedDiscount : 0.4 , // Silver package discount 40%
162+ expectedSharedDiscount : 0.6 , // Gold package discount 60%
163+ },
164+ {
165+ name : "Balance enough for gold package for both" ,
166+ balance : 2000 , // > 100 * 18 and > 80 * 18
167+ dedicatedPrice : 100 ,
168+ sharedPrice : 80 ,
169+ expectedDedicatedDiscount : 0.6 ,
170+ expectedSharedDiscount : 0.6 ,
171+ },
172+ }
173+
174+ for _ , tc := range testCases {
175+ t .Run (tc .name , func (t * testing.T ) {
176+ sharedDiscount , dedicatedDiscount := getApplicableDiscount (tc .balance , tc .dedicatedPrice , tc .sharedPrice )
177+
178+ assert .Equal (t , tc .expectedDedicatedDiscount , dedicatedDiscount , "Dedicated discount percentage mismatch" )
179+ assert .Equal (t , tc .expectedSharedDiscount , sharedDiscount , "Shared discount percentage mismatch" )
180+ })
181+ }
182+ }
183+
184+ func TestTFTtoUSD (t * testing.T ) {
185+ ctrl := gomock .NewController (t )
186+ defer ctrl .Finish ()
187+
188+ sub := mocks .NewMockSubstrateExt (ctrl )
189+ identity , err := substrate .NewIdentityFromSr25519Phrase ("//Alice" )
190+ assert .NoError (t , err )
191+
192+ calculator := NewCalculator (sub , identity )
193+
194+ t .Run ("success case" , func (t * testing.T ) {
195+ sub .EXPECT ().GetTFTPrice ().Return (types .U32 (5 ), nil )
196+
197+ result , err := calculator .TFTtoUSD (10 )
198+ assert .NoError (t , err )
199+ assert .Equal (t , 0.05 , result )
200+ })
201+
202+ t .Run ("error case" , func (t * testing.T ) {
203+ sub .EXPECT ().GetTFTPrice ().Return (types .U32 (0 ), errors .New ("failed to get TFT price" ))
204+
205+ _ , err := calculator .TFTtoUSD (100 )
91206 assert .Error (t , err )
92207 })
93208}
0 commit comments