Update test for new behavior of send new tx

 - verify whether node is synced ?
   - last scheduling time is not too old
   - manually ask network

test/archethic/bootstrap_test.exs

@@ -10,7 +10,8 @@ defmodule Archethic.BootstrapTest do
     Replication,
     SharedSecrets,
     TransactionChain,
-    TransactionFactory
+    TransactionFactory,
+    SelfRepair.Resync
   }
 
   alias Archethic.P2P.Message.{
@@ -501,7 +502,7 @@ defmodule Archethic.BootstrapTest do
       :persistent_term.put(:node_shared_secrets_gen_addr, nil)
 
       assert :ok =
-               Bootstrap.do_resync_network_chain(
+               Resync.network_chain(
                  :node_shared_secrets,
                  _nodes = P2P.authorized_and_available_nodes()
                )
@@ -529,7 +530,7 @@ defmodule Archethic.BootstrapTest do
       end)
 
       assert :ok =
-               Bootstrap.do_resync_network_chain(
+               Resync.network_chain(
                  :node_shared_secrets,
                  _nodes = P2P.authorized_and_available_nodes()
                )
@@ -600,7 +601,7 @@ defmodule Archethic.BootstrapTest do
       end)
 
       assert :ok =
-               Bootstrap.do_resync_network_chain(
+               Resync.network_chain(
                  :node_shared_secrets,
                  _nodes = P2P.authorized_and_available_nodes()
                )

test/archethic/contracts/worker_test.exs

@@ -1,41 +1,50 @@
 defmodule Archethic.Contracts.WorkerTest do
   use ArchethicCase
 
-  alias Archethic.{
-    Account,
-    Contracts,
-    ContractRegistry,
-    Crypto,
-    P2P,
-    P2P.Node,
-    PubSub,
-    TransactionChain
-  }
+  alias Archethic.{Account, Contracts, ContractRegistry, Crypto, P2P}
+  alias Archethic.{P2P.Node, PubSub, TransactionChain}
 
   alias Contracts.{Contract, Interpreter, Worker, ContractConstants}
 
   alias P2P.Message.{Ok, StartMining}
 
-  alias TransactionChain.{
-    Transaction,
-    TransactionData,
-    TransactionData.Ledger,
-    TransactionData.Ownership,
-    TransactionData.UCOLedger,
-    TransactionData.UCOLedger.Transfer,
-    TransactionData.TokenLedger,
-    Transaction.ValidationStamp,
-    Transaction.ValidationStamp.LedgerOperations.UnspentOutput,
-    Transaction.ValidationStamp.LedgerOperations.VersionedUnspentOutput
-  }
-
-  alias TransactionChain.TransactionData.TokenLedger.Transfer, as: TokenTransfer
+  alias TransactionChain.{Transaction, TransactionData, Transaction.ValidationStamp}
+  alias ValidationStamp.{LedgerOperations.UnspentOutput, LedgerOperations.VersionedUnspentOutput}
+  alias TransactionData.{Ledger, Ownership, UCOLedger, UCOLedger.Transfer, TokenLedger}
+  alias TransactionData.TokenLedger.Transfer, as: TokenTransfer
 
   import Mox
 
   @bob_address <<0::16, :crypto.strong_rand_bytes(32)::binary>>
 
+  def load_send_tx_constraints() do
+    nss_genesis_address = "nss_genesis_address"
+    nss_last_address = "nss_last_address"
+    :persistent_term.put(:node_shared_secrets_gen_addr, nss_genesis_address)
+
+    MockDB
+    |> stub(:get_last_chain_address, fn ^nss_genesis_address ->
+      {nss_last_address, DateTime.utc_now()}
+    end)
+    |> stub(
+      :get_transaction,
+      fn
+        ^nss_last_address, [validation_stamp: [:timestamp]], :chain ->
+          {:ok,
+           %Transaction{
+             validation_stamp: %{__struct__: :ValidationStamp, timestamp: DateTime.utc_now()}
+           }}
+      end
+    )
+
+    on_exit(:unpersist_data, fn ->
+      :persistent_term.put(:node_shared_secrets_gen_addr, nil)
+    end)
+  end
+
   setup do
+    load_send_tx_constraints()
+
     P2P.add_and_connect_node(%Node{
       ip: {127, 0, 0, 1},
       port: 3000,
@@ -437,17 +446,6 @@ defmodule Archethic.Contracts.WorkerTest do
       end
       """
 
-      {:ok, contract} = Interpreter.parse(code)
-
-      contract = %{
-        contract
-        | constants: %ContractConstants{contract: Map.put(constants, "code", code)}
-      }
-
-      {:ok, _pid} = Worker.start_link(contract)
-
-      Process.sleep(100)
-
       oracle_tx = %Transaction{
         address: "@Oracle1",
         type: :oracle,
@@ -457,10 +455,39 @@ defmodule Archethic.Contracts.WorkerTest do
         validation_stamp: %ValidationStamp{timestamp: DateTime.utc_now()}
       }
 
-      PubSub.notify_new_transaction("@Oracle1", :oracle, DateTime.utc_now())
+      nss_last_address = "nss_last_address"
+      nss_genesis_address = "nss_genesis_address"
 
       MockDB
-      |> expect(:get_transaction, fn "@Oracle1", _, _ -> {:ok, oracle_tx} end)
+      |> stub(:get_last_chain_address, fn ^nss_genesis_address ->
+        {nss_last_address, DateTime.utc_now()}
+      end)
+      |> stub(
+        :get_transaction,
+        fn
+          "@Oracle1", [], :chain ->
+            {:ok, oracle_tx}
+
+          ^nss_last_address, [validation_stamp: [:timestamp]], :chain ->
+            {:ok,
+             %Transaction{
+               validation_stamp: %{__struct__: :ValidationStamp, timestamp: DateTime.utc_now()}
+             }}
+        end
+      )
+
+      {:ok, contract} = Interpreter.parse(code)
+
+      contract = %{
+        contract
+        | constants: %ContractConstants{contract: Map.put(constants, "code", code)}
+      }
+
+      {:ok, pid} = Worker.start_link(contract)
+      allow(MockDB, self(), pid)
+      # Process.sleep(100)
+
+      PubSub.notify_new_transaction("@Oracle1", :oracle, DateTime.utc_now())
 
       receive do
         {:transaction_sent, tx} ->

test/archethic/oracle_chain/scheduler_test.exs

@@ -18,10 +18,37 @@ defmodule Archethic.OracleChain.SchedulerTest do
   alias Archethic.TransactionChain.Transaction.ValidationStamp
   alias Archethic.TransactionChain.TransactionData
 
+  alias Archethic.SharedSecrets
+
   import Mox
 
   setup do
     SelfRepairScheduler.start_link([interval: "0 0 * * *"], [])
+    keys = SharedSecrets.genesis_address_keys()
+
+    nss_genesis_address = "nss_genesis_address"
+    nss_last_address = "nss_last_address"
+    :persistent_term.put(keys.nss, nss_genesis_address)
+
+    MockDB
+    |> stub(:get_last_chain_address, fn ^nss_genesis_address ->
+      {nss_last_address, DateTime.utc_now()}
+    end)
+    |> stub(:get_transaction, fn
+      ^nss_last_address, [validation_stamp: [:timestamp]], :chain ->
+        {:ok,
+         %Transaction{
+           validation_stamp: %{__struct__: :ValidationStamp, timestamp: DateTime.utc_now()}
+         }}
+
+      _, _, _ ->
+        {:error, :transaction_not_exists}
+    end)
+
+    on_exit(:unpersist_data, fn ->
+      :persistent_term.put(keys.nss, nil)
+    end)
+
     :ok
   end
 

test/archethic/reward/scheduler_test.exs

@@ -1,17 +1,35 @@
 defmodule Archethic.Reward.SchedulerTest do
   use ArchethicCase, async: false
 
-  alias Archethic.{
-    Crypto,
-    P2P,
-    P2P.Node,
-    P2P.Message.StartMining,
-    Reward.Scheduler,
-    TransactionChain.Transaction
-  }
+  alias Archethic.{Crypto, P2P, P2P.Node, P2P.Message.StartMining}
+  alias Archethic.{Reward.Scheduler, TransactionChain.Transaction, SharedSecrets}
 
   import Mox
 
+  setup do
+    keys = SharedSecrets.genesis_address_keys()
+    nss_genesis_address = "nss_genesis_address"
+    nss_last_address = "nss_last_address"
+    :persistent_term.put(keys.nss, nss_genesis_address)
+
+    MockDB
+    |> stub(:get_last_chain_address, fn ^nss_genesis_address ->
+      {nss_last_address, DateTime.utc_now()}
+    end)
+    |> stub(:get_transaction, fn ^nss_last_address, [validation_stamp: [:timestamp]], :chain ->
+      {:ok,
+       %Transaction{
+         validation_stamp: %{__struct__: :ValidationStamp, timestamp: DateTime.utc_now()}
+       }}
+    end)
+
+    on_exit(:unpersist_data, fn ->
+      :persistent_term.put(keys.nss, nil)
+    end)
+
+    :ok
+  end
+
   describe "Trigger mint Reward" do
     test "should initiate the reward scheduler and trigger mint reward" do
       P2P.add_and_connect_node(%Node{

test/archethic/shared_secrets/node_renewal_scheduler_test.exs

@@ -18,12 +18,35 @@ defmodule Archethic.SharedSecrets.NodeRenewalSchedulerTest do
 
   alias Archethic.TransactionChain.Transaction
 
+  alias Archethic.SharedSecrets
+
   import Mox
 
   setup do
     SelfRepairScheduler.start_link([interval: "0 0 0 * *"], [])
     start_supervised!({BeaconSlotTimer, interval: "0 * * * * *"})
     Enum.each(BeaconChain.list_subsets(), &Registry.register(SubsetRegistry, &1, []))
+
+    keys = SharedSecrets.genesis_address_keys()
+    nss_genesis_address = "nss_genesis_address"
+    nss_last_address = "nss_last_address"
+    :persistent_term.put(keys.nss, nss_genesis_address)
+
+    MockDB
+    |> stub(:get_last_chain_address, fn ^nss_genesis_address ->
+      {nss_last_address, DateTime.utc_now()}
+    end)
+    |> stub(:get_transaction, fn ^nss_last_address, [validation_stamp: [:timestamp]], :chain ->
+      {:ok,
+       %Transaction{
+         validation_stamp: %{__struct__: :ValidationStamp, timestamp: DateTime.utc_now()}
+       }}
+    end)
+
+    on_exit(:unpersist_data, fn ->
+      :persistent_term.put(keys.nss, nil)
+    end)
+
     :ok
   end