fix billing invocations calculation

If balance is zero, invocations should be deducted from remaining invocations.

Author: wilsonianb

billing/handler.go

@@ -24,17 +24,20 @@ func NewFunctionBalance(credit, invocations, costPerUnitInvocations, unitInvocat
 	fnBalance := FunctionBalance{}
 
 	totalCharge := calculateInvocationsCost(invocations, costPerUnitInvocations, unitInvocations)
-	if credit < totalCharge {
+	unpaidAmount := uint64(0)
+	if credit <= totalCharge {
 		fnBalance.Balance = 0
-		remainingInvocations := calculateRemainingInvocations(totalCharge-credit, costPerUnitInvocations, unitInvocations)
-		if bonusInvocations < remainingInvocations {
-			fnBalance.Invocations = 0
-		} else {
-			fnBalance.Invocations = bonusInvocations - remainingInvocations
-		}
+		unpaidAmount = totalCharge - credit
 	} else {
 		fnBalance.Balance = credit - totalCharge
-		fnBalance.Invocations = bonusInvocations + calculateRemainingInvocations(fnBalance.Balance, costPerUnitInvocations, unitInvocations)
+	}
+
+	unpaidInvocations := uint64(unpaidAmount*unitInvocations/costPerUnitInvocations + invocations%unitInvocations)
+	remainingInvocations := bonusInvocations + uint64(fnBalance.Balance*unitInvocations/costPerUnitInvocations)
+	if remainingInvocations < unpaidInvocations {
+		fnBalance.Invocations = 0
+	} else {
+		fnBalance.Invocations = remainingInvocations - unpaidInvocations
 	}
 
 	return fnBalance
@@ -44,10 +47,6 @@ func calculateInvocationsCost(invocations, costPerUnitInvocations, unitInvocatio
 	return uint64(costPerUnitInvocations * invocations / unitInvocations)
 }
 
-func calculateRemainingInvocations(balance, costPerUnitInvocations, unitInvocations uint64) uint64 {
-	return uint64(balance * unitInvocations / costPerUnitInvocations)
-}
-
 func Handle(w http.ResponseWriter, r *http.Request) {
 
 	fnName, err := parseFunctionName(r)

billing/handler_test.go

@@ -75,28 +75,19 @@ func Test_calculateInvocationsCost_whenRounded(t *testing.T) {
 	}
 }
 
-func Test_calculateRemainingInvocations_whenExact(t *testing.T) {
-	balance := uint64(1)
+func Test_NewFunctionBalance_whenBalanceZero(t *testing.T) {
+	credit := uint64(0)
+	invocations := uint64(5)
 	costPerUnitInvocations := uint64(10)
-	unitInvocations := uint64(1000)
-
-	expected := uint64(100)
-
-	got := calculateRemainingInvocations(balance, costPerUnitInvocations, unitInvocations)
+	unitInvocations := uint64(100)
+	bonusInvocations := uint64(50)
 
-	if expected != got {
-		t.Errorf("Expected: %d, got: %d", expected, got)
+	expected := FunctionBalance{
+		Balance:     0,
+		Invocations: 45,
 	}
-}
 
-func Test_calculateRemainingInvocations_whenRounded(t *testing.T) {
-	balance := uint64(1)
-	costPerUnitInvocations := uint64(10)
-	unitInvocations := uint64(1)
-
-	expected := uint64(0)
-
-	got := calculateRemainingInvocations(balance, costPerUnitInvocations, unitInvocations)
+	got := NewFunctionBalance(credit, invocations, costPerUnitInvocations, unitInvocations, bonusInvocations)
 
 	if expected != got {
 		t.Errorf("Expected: %d, got: %d", expected, got)
@@ -112,7 +103,7 @@ func Test_NewFunctionBalance_whenBalancePositive(t *testing.T) {
 
 	expected := FunctionBalance{
 		Balance:     99,
-		Invocations: 9950,
+		Invocations: 9850,
 	}
 
 	got := NewFunctionBalance(credit, invocations, costPerUnitInvocations, unitInvocations, bonusInvocations)