Fix/codec tx tests

src/dev_bundler.erl

@@ -202,9 +202,9 @@ tx_error_test() ->
         ?assertMatch({ok, _}, post_data_item(Node, Item1, ClientOpts)),
         % After a tx request fails it should be retried indefinitely. We'll
         % wait for a few retries then continue.
-        TXs = hb_mock_server:get_requests(tx, 4, ServerHandle),
-        ?assert(length(TXs) >= 4),
-        Chunks = hb_mock_server:get_requests(chunk, 1, ServerHandle),
+        TXs = hb_mock_server:get_requests(tx, 2, ServerHandle),
+        ?assert(length(TXs) >= 2),
+        Chunks = hb_mock_server:get_requests(chunk, 1, ServerHandle, 500),
         ?assertEqual([], Chunks),
         ok
     after
@@ -256,7 +256,7 @@ idle_test() ->
     try
         ClientOpts = #{},
         Node = hb_http_server:start_node(NodeOpts#{
-            bundler_max_idle_time => 10000,
+            bundler_max_idle_time => 2000,
             priv_wallet => hb:wallet(),
             store => hb_test_utils:test_store(hb_store_lmdb)
         }),
@@ -265,12 +265,12 @@ idle_test() ->
         ?assertMatch({ok, _}, post_data_item(Node, Item1, ClientOpts)),
         % Wait just to give the server a chance to post a transaction
         % (but it shouldn't)
-        timer:sleep(2000),
+        timer:sleep(1000),
         ?assertEqual(0, length(hb_mock_server:get_requests(tx, 0, ServerHandle))),
         ?assertEqual(0, length(hb_mock_server:get_requests(chunk, 0, ServerHandle))),
         % Wait gain to give the server a chance to trip the max idle time.
         % It should *now* post a transaction.
-        timer:sleep(8000),
+        timer:sleep(1000),
         TXs = hb_mock_server:get_requests(tx, 1, ServerHandle),
         ?assertEqual(1, length(TXs)),
         %% Wait for expected chunks
@@ -284,7 +284,7 @@ idle_test() ->
     end.
 
 dispatch_blocking_test() ->
-    BlockTime = 10000,
+    BlockTime = 2000,
     Anchor = rand:bytes(32),
     Price = 12345,
     % NodeOpts redirects arweave gateway requests to the mock server.
@@ -327,7 +327,6 @@ dispatch_blocking_test() ->
             {slowest, Slowest}, {max_allowed, 2 * Slowest}
         }),
         ?assert(Time4 =< 2 * Slowest),
-        timer:sleep(BlockTime),
         TXs = hb_mock_server:get_requests(tx, 1, ServerHandle),
         ?assertEqual(1, length(TXs)),
         %% Wait for expected chunks
@@ -346,24 +345,39 @@ dispatch_blocking_test() ->
 recover_unbundled_items_test() ->
     Opts = #{store => hb_test_utils:test_store(hb_store_lmdb)},
     % Create and cache some items
-    Item1 = hb_message:convert(new_data_item(1, 10), <<"structured@1.0">>, <<"ans104@1.0">>, Opts),
-    Item2 = hb_message:convert(new_data_item(2, 10), <<"structured@1.0">>, <<"ans104@1.0">>, Opts),
-    Item3 = hb_message:convert(new_data_item(3, 10), <<"structured@1.0">>, <<"ans104@1.0">>, Opts),
+    Item1 = hb_message:convert(
+        new_data_item(1, 10), <<"structured@1.0">>, <<"ans104@1.0">>, Opts),
+    Item2 = hb_message:convert(
+        new_data_item(2, 10), <<"structured@1.0">>, <<"ans104@1.0">>, Opts),
+    Item3 = hb_message:convert(
+        new_data_item(3, 10), <<"structured@1.0">>, <<"ans104@1.0">>, Opts),
     ok = dev_bundler_cache:write_item(Item1, Opts),
     ok = dev_bundler_cache:write_item(Item2, Opts),
     ok = dev_bundler_cache:write_item(Item3, Opts),
     % Bundle Item2 with a fake TX
-    FakeTX = ar_tx:sign(#tx{format = 2, tags = [{<<"test">>, <<"tx">>}]}, hb:wallet()),
-    StructuredTX = hb_message:convert(FakeTX, <<"structured@1.0">>, <<"tx@1.0">>, Opts),
+    FakeTX = ar_tx:sign(
+        #tx{format = 2, tags = [{<<"test">>, <<"tx">>}]}, hb:wallet()),
+    StructuredTX = hb_message:convert(
+        FakeTX, <<"structured@1.0">>, <<"tx@1.0">>, Opts),
     ok = dev_bundler_cache:write_tx(StructuredTX, [Item2], Opts),
     % Now recover unbundled items
     {RecoveredItems, RecoveredBytes} = recover_unbundled_items(Opts),
     ?assertEqual(3924, RecoveredBytes),
     RecoveredItems2 = [
         hb_message:with_commitments(
-            #{ <<"commitment-device">> => <<"ans104@1.0">> }, Item, Opts)
+            #{ 
+                <<"commitment-device">> => <<"ans104@1.0">>,
+                <<"type">> => <<"rsa-pss-sha256">>
+            }, Item, Opts)
         || Item <- RecoveredItems],
-    ?assertEqual(lists:sort([Item1, Item3]), lists:sort(RecoveredItems2)),
+    WrittenItems = [
+        hb_message:with_commitments(
+            #{ 
+                <<"commitment-device">> => <<"ans104@1.0">>,
+                <<"type">> => <<"rsa-pss-sha256">>
+            }, Item, Opts)
+        || Item <- [Item1, Item3]],
+    ?assertEqual(lists:sort(WrittenItems), lists:sort(RecoveredItems2)),
     ok.
 
 recover_respects_max_items_test() ->
@@ -460,11 +474,11 @@ test_api_error(Responses) ->
         }),
         Item1 = new_data_item(1, floor(2.5 * ?DATA_CHUNK_SIZE)),
         ?assertMatch({ok, _}, post_data_item(Node, Item1, ClientOpts)),
-        % Since thre was an error either before or while posting the tx,
+        % Since there was an error either before or while posting the tx,
         % no bundles should be posted and no chunks should be posted.
-        TXs = hb_mock_server:get_requests(tx, 1, ServerHandle),
+        TXs = hb_mock_server:get_requests(tx, 1, ServerHandle, 1000),
         ?assertEqual([], TXs),
-        Chunks = hb_mock_server:get_requests(chunk, 1, ServerHandle),
+        Chunks = hb_mock_server:get_requests(chunk, 1, ServerHandle, 1000),
         ?assertEqual([], Chunks),
         % Now that we dispatch asynchronously, an error won't cause the
         % Item to remain in the queue. Instead we'll rely on the retry

src/dev_bundler_cache.erl

@@ -262,8 +262,14 @@ basic_cache_test() ->
     ?assertEqual(<<"posted">>, get_tx_status(TX, Opts)),
     ok = complete_tx(TX, Opts),
     ?assertEqual(<<"complete">>, get_tx_status(TX, Opts)),
-    ?assertEqual(TX, read_cache(TXID, <<"tx@1.0">>, Opts)),
-    ?assertEqual(Item, read_cache(ItemID, <<"ans104@1.0">>, Opts)),
+    ?assertEqual(
+        hb_message:with_commitments(
+            #{ <<"type">> => <<"rsa-pss-sha256">> }, TX, Opts),
+        read_cache(TXID, <<"tx@1.0">>, Opts)),
+    ?assertEqual(
+        hb_message:with_commitments(
+            #{ <<"type">> => <<"rsa-pss-sha256">> }, Item, Opts),
+        read_cache(ItemID, <<"ans104@1.0">>, Opts)),
     ok.
 
 load_unbundled_items_test() ->
@@ -278,15 +284,22 @@ load_unbundled_items_test() ->
     % Link item2 to a bundle, leave others unbundled
     ok = write_tx(TX, [Item2], Opts),
     % Load unbundled items
-    UnbundledItems1 = load_unbundled_items(Opts),
-    UnbundledItems2 = [
+    LoadedItems1 = load_unbundled_items(Opts),
+    LoadedItems2 = [
         hb_message:with_commitments(
             #{ <<"commitment-device">> => <<"ans104@1.0">> },
-            Item, Opts) || Item <- UnbundledItems1
+            Item, Opts) || Item <- LoadedItems1
         ],
-    UnbundledItems3 = lists:sort(UnbundledItems2),
-    ?event(debug_test, {unbundled_items, UnbundledItems3}),
-    ?assertEqual(lists:sort([Item1, Item3]), UnbundledItems3),
+    LoadedItems3 = lists:sort(LoadedItems2),
+    WrittenItems = [
+        hb_message:with_commitments(
+            #{ 
+                <<"commitment-device">> => <<"ans104@1.0">>,
+                <<"type">> => <<"rsa-pss-sha256">>
+            },
+            Item, Opts) || Item <- [Item1, Item3]],
+    ?event(debug_test, {loaded_items, LoadedItems3}),
+    ?assertEqual(lists:sort(WrittenItems), LoadedItems3),
     ok.
 
 load_bundle_states_test() ->
@@ -320,23 +333,37 @@ load_bundled_items_test() ->
     ok = write_tx(TX1, [Item1, Item2], Opts),
     ok = write_tx(TX2, [Item3], Opts),
     % Load items for bundle 1
-    Bundle1Items1 = load_bundled_items(tx_id(TX1, Opts), Opts),
-    Bundle1Items2 = [
+    Bundle1LoadedItems1 = load_bundled_items(tx_id(TX1, Opts), Opts),
+    Bundle1LoadedItems2 = [
         hb_message:with_commitments(
             #{ <<"commitment-device">> => <<"ans104@1.0">> },
-            Item, Opts) || Item <- Bundle1Items1
+            Item, Opts) || Item <- Bundle1LoadedItems1
         ],
-    Bundle1Items3 = lists:sort(Bundle1Items2),
-    ?assertEqual(lists:sort([Item1, Item2]), Bundle1Items3),
+    Bundle1LoadedItems3 = lists:sort(Bundle1LoadedItems2),
+    Bundle1WrittenItems = [
+        hb_message:with_commitments(
+            #{ 
+                <<"commitment-device">> => <<"ans104@1.0">>,
+                <<"type">> => <<"rsa-pss-sha256">>
+            },
+            Item, Opts) || Item <- [Item1, Item2]],
+    ?assertEqual(lists:sort(Bundle1WrittenItems), Bundle1LoadedItems3),
     % Load items for bundle 2
-    Bundle2Items1 = load_bundled_items(tx_id(TX2, Opts), Opts),
-    Bundle2Items2 = [
+    Bundle2LoadedItems1 = load_bundled_items(tx_id(TX2, Opts), Opts),
+    Bundle2LoadedItems2 = [
         hb_message:with_commitments(
             #{ <<"commitment-device">> => <<"ans104@1.0">> },
-            Item, Opts) || Item <- Bundle2Items1
+            Item, Opts) || Item <- Bundle2LoadedItems1
         ],
-    Bundle2Items3 = lists:sort(Bundle2Items2),
-    ?assertEqual(lists:sort([Item3]), Bundle2Items3),
+    Bundle2LoadedItems3 = lists:sort(Bundle2LoadedItems2),
+    Bundle2WrittenItems = [
+        hb_message:with_commitments(
+            #{ 
+                <<"commitment-device">> => <<"ans104@1.0">>,
+                <<"type">> => <<"rsa-pss-sha256">>
+            },
+            Item, Opts) || Item <- [Item3]],
+    ?assertEqual(lists:sort(Bundle2WrittenItems), Bundle2LoadedItems3),
     ok.
 
 new_data_item(Index, SizeOrData, Opts) ->
@@ -365,7 +392,9 @@ new_tx(Index, Opts) ->
     hb_message:convert(TX, <<"structured@1.0">>, <<"tx@1.0">>, Opts).
 
 read_cache(ID, Device, Opts) ->
-    {ok, Resolved} = hb_ao:resolve(#{ <<"path">> => ID }, Opts),
+    % {ok, Resolved} = hb_ao:resolve(#{ <<"path">> => ID }, Opts),
+    {ok, Resolved} = hb_cache:read(ID, Opts),
     Loaded = hb_cache:ensure_all_loaded(Resolved, Opts),
+    ?event(debug_test, {loaded, Loaded}),
     hb_message:with_commitments(
         #{ <<"commitment-device">> => Device }, Loaded, Opts).

src/dev_bundler_dispatch.erl

@@ -1001,8 +1001,15 @@ recover_bundles_test() ->
             hb_message:with_commitments(
                 #{ <<"commitment-device">> => <<"ans104@1.0">> }, Item, Opts)
             || Item <- Bundle#bundle.items],
+        WrittenItems = [
+            hb_message:with_commitments(
+                #{ 
+                    <<"commitment-device">> => <<"ans104@1.0">>,
+                    <<"type">> => <<"rsa-pss-sha256">>
+                },
+                Item, Opts) || Item <- [Item1, Item2, Item3]],
         ?assertEqual(
-            lists:sort([Item1, Item2, Item3]),
+            lists:sort(WrittenItems),
             lists:sort(RecoveredItems)),
         ?assertEqual(tx_posted, Bundle#bundle.status),
         ?assert(hb_message:verify(Bundle#bundle.tx)),