bank*: distribute initial balances uniformly

Before this commit the initial distribution was the following: first
account has `total-amount` balances, other 9 ones have zero balance.

From time to time is appears that there are no attempts to transfer from
the first account. It means that all transfers are marked as failed and
the history analysis reports fail.

Even when there are some successful transfers, there are many attempts
to transfer from an account with zero balance: those transfers are
useless in terms of tarantool testing.

This commit changes the initial distribution to the uniform one and
resolves the problems, which are described above. See the linked issue
for details.

Aside of the problematic bank-lua I changed other banking tests in the
same way to unify the approach. How each test is changed:

* bank-lua: [100 0 0 0 0 0 0 0 0 0] -> [10 10 10 10 10 10 10 10 10 10].
* bank-multitable-lua: the test already distributes initial balances
  uniformly, but hardcodes balance value. Now it is deduced from the
  `total-amount` parameter.
* bank: same as bank-lua.
* bank-multitable: same as bank-lua.

'bank' and 'bank-multitable' fixes are blind, because they're disabled.
See #83.

'bank-lua' and 'bank-multitable-lua' are passed in a manual run.
'bank-lua' gives 2-3 failed transfers of ~40 ones. Before it was like
5-15 *successful* ones of 30-40. (I have no representative statistics,
just looked over several runs in CI, but the numbers looks expected.)

Fixes #94

Author: Totktonada

src/tarantool/bank.clj

@@ -37,10 +37,13 @@
                              balance INT NOT NULL)")])
            (doseq [a (:accounts test)]
                (info "Populating account")
-               (sql/insert! conn table-name {:id      a
-                                             :balance (if (= a (first (:accounts test)))
-                                                       (:total-amount test)
-                                                       0)}))))
+               ; Distribute initial balances uniformly.
+               (let [initial-balance (/ (:total-amount test)
+                                        (count (:accounts test)))]
+                   (sql/insert! conn table-name
+                       {:id a
+                        :balance initial-balance})))))
+
         (assoc this :conn conn :node node))))
 
   (invoke! [this test op]
@@ -91,10 +94,14 @@
                                        "account_id      INT NOT NULL,"
                                        "balance INT NOT NULL)")])
                   (info "Populating account" a)
-                  (sql/insert! conn (str table-name a)
-                             {:id 0
-                              :account_id a
-                              :balance 10})))))
+                  ; Distribute initial balances uniformly.
+                  (let [initial-balance (/ (:total-amount test)
+                                           (count (:accounts test)))]
+                      (sql/insert! conn (str table-name a)
+                          {:id 0
+                           :account_id a
+                           :balance initial-balance}))))))
+
         (assoc this :conn conn :node node))))
 
   (invoke! [this test op]
@@ -157,10 +164,13 @@
                              balance INT NOT NULL)")])
            (doseq [a (:accounts test)]
                (info "Populating account")
-               (sql/insert! conn table-name {:id      a
-                                             :balance (if (= a (first (:accounts test)))
-                                                       (:total-amount test)
-                                                       0)}))))
+               ; Distribute initial balances uniformly.
+               (let [initial-balance (/ (:total-amount test)
+                                        (count (:accounts test)))]
+                   (sql/insert! conn table-name
+                       {:id a
+                        :balance initial-balance})))))
+
         (assoc this :conn conn :node node))))
 
   (invoke! [this test op]
@@ -220,11 +230,13 @@
                                        "(id     INT NOT NULL PRIMARY KEY,"
                                        "balance INT NOT NULL)")])
                   (info "Populating account" a)
-                  (sql/insert! conn (str table-name a)
-                             {:id 0
-                              :balance (if (= a (first (:accounts test)))
-                                         (:total-amount test)
-                                         0)})))))
+                  ; Distribute initial balances uniformly.
+                  (let [initial-balance (/ (:total-amount test)
+                                           (count (:accounts test)))]
+                      (sql/insert! conn (str table-name a)
+                          {:id 0
+                           :balance initial-balance}))))))
+
         (assoc this :conn conn :node node))))
 
   (invoke! [this test op]