github.com/storacha/go-ucanto@v0.7.2/core/receipt/datamodel/receipt_test.go (about)

     1  package datamodel_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/ipfs/go-cid"
     7  	"github.com/ipld/go-ipld-prime"
     8  	cidlink "github.com/ipld/go-ipld-prime/linking/cid"
     9  	"github.com/storacha/go-ucanto/core/ipld/block"
    10  	"github.com/storacha/go-ucanto/core/ipld/codec/cbor"
    11  	"github.com/storacha/go-ucanto/core/ipld/hash/sha256"
    12  	rdm "github.com/storacha/go-ucanto/core/receipt/datamodel"
    13  )
    14  
    15  type resultOk struct {
    16  	Status string
    17  }
    18  
    19  type resultErr struct {
    20  	Message string
    21  }
    22  
    23  func TestReceiptEncodeDecode(t *testing.T) {
    24  	typ, err := rdm.NewReceiptModelType([]byte(`
    25  		type Result union {
    26  			| Ok "ok"
    27  			| Err "error"
    28  		} representation keyed
    29  
    30  		type Ok struct {
    31  			status String (rename "Status")
    32  		}
    33  
    34  		type Err struct {
    35  			message String (rename "Message")
    36  		}
    37  	`))
    38  	if err != nil {
    39  		t.Fatalf("loading result schema: %s", err)
    40  	}
    41  
    42  	l := cidlink.Link{Cid: cid.MustParse("bafkreiem4twkqzsq2aj4shbycd4yvoj2cx72vezicletlhi7dijjciqpui")}
    43  	r0 := rdm.ReceiptModel[resultOk, resultErr]{
    44  		Ocm: rdm.OutcomeModel[resultOk, resultErr]{
    45  			Ran: l,
    46  			Out: rdm.ResultModel[resultOk, resultErr]{
    47  				Ok: &resultOk{Status: "done"},
    48  			},
    49  		},
    50  	}
    51  	b0, err := block.Encode(&r0, typ, cbor.Codec, sha256.Hasher)
    52  	if err != nil {
    53  		t.Fatalf("encoding receipt: %s", err)
    54  	}
    55  	r1 := rdm.ReceiptModel[resultOk, resultErr]{}
    56  	err = block.Decode(b0, &r1, typ, cbor.Codec, sha256.Hasher)
    57  	if err != nil {
    58  		t.Fatalf("decoding receipt: %s", err)
    59  	}
    60  	if r1.Ocm.Out.Error != nil {
    61  		t.Fatalf("result err was not nil")
    62  	}
    63  	if r1.Ocm.Out.Ok.Status != "done" {
    64  		t.Fatalf("status was not done")
    65  	}
    66  
    67  	r2 := rdm.ReceiptModel[resultOk, resultErr]{
    68  		Ocm: rdm.OutcomeModel[resultOk, resultErr]{
    69  			Ran: l,
    70  			Out: rdm.ResultModel[resultOk, resultErr]{
    71  				Error: &resultErr{Message: "boom"},
    72  			},
    73  		},
    74  	}
    75  	b1, err := block.Encode(&r2, typ, cbor.Codec, sha256.Hasher)
    76  	if err != nil {
    77  		t.Fatalf("encoding receipt: %s", err)
    78  	}
    79  	r3 := rdm.ReceiptModel[resultOk, resultErr]{}
    80  	err = block.Decode(b1, &r3, typ, cbor.Codec, sha256.Hasher)
    81  	if err != nil {
    82  		t.Fatalf("decoding receipt: %s", err)
    83  	}
    84  	if r3.Ocm.Out.Ok != nil {
    85  		t.Fatalf("result ok was not nil")
    86  	}
    87  	if r3.Ocm.Out.Error.Message != "boom" {
    88  		t.Fatalf("error message was not boom")
    89  	}
    90  }
    91  
    92  func TestEncodeDecoderFromTypes(t *testing.T) {
    93  	ts, err := ipld.LoadSchemaBytes([]byte(`
    94  		type Ok struct {
    95  			status String (rename "Status")
    96  		}
    97  
    98  		type Err struct {
    99  			message String (rename "Message")
   100  		}
   101  	`))
   102  	if err != nil {
   103  		t.Fatalf("loading schemas: %s", err)
   104  	}
   105  
   106  	typ, err := rdm.NewReceiptModelFromTypes(ts.TypeByName("Ok"), ts.TypeByName("Err"))
   107  	if err != nil {
   108  		t.Fatalf("loading result schema: %s", err)
   109  	}
   110  
   111  	l := cidlink.Link{Cid: cid.MustParse("bafkreiem4twkqzsq2aj4shbycd4yvoj2cx72vezicletlhi7dijjciqpui")}
   112  	r0 := rdm.ReceiptModel[resultOk, resultErr]{
   113  		Ocm: rdm.OutcomeModel[resultOk, resultErr]{
   114  			Ran: l,
   115  			Out: rdm.ResultModel[resultOk, resultErr]{
   116  				Ok: &resultOk{Status: "done"},
   117  			},
   118  		},
   119  	}
   120  	b0, err := block.Encode(&r0, typ, cbor.Codec, sha256.Hasher)
   121  	if err != nil {
   122  		t.Fatalf("encoding receipt: %s", err)
   123  	}
   124  	r1 := rdm.ReceiptModel[resultOk, resultErr]{}
   125  	err = block.Decode(b0, &r1, typ, cbor.Codec, sha256.Hasher)
   126  	if err != nil {
   127  		t.Fatalf("decoding receipt: %s", err)
   128  	}
   129  	if r1.Ocm.Out.Error != nil {
   130  		t.Fatalf("result err was not nil")
   131  	}
   132  	if r1.Ocm.Out.Ok.Status != "done" {
   133  		t.Fatalf("status was not done")
   134  	}
   135  
   136  	r2 := rdm.ReceiptModel[resultOk, resultErr]{
   137  		Ocm: rdm.OutcomeModel[resultOk, resultErr]{
   138  			Ran: l,
   139  			Out: rdm.ResultModel[resultOk, resultErr]{
   140  				Error: &resultErr{Message: "boom"},
   141  			},
   142  		},
   143  	}
   144  	b1, err := block.Encode(&r2, typ, cbor.Codec, sha256.Hasher)
   145  	if err != nil {
   146  		t.Fatalf("encoding receipt: %s", err)
   147  	}
   148  	r3 := rdm.ReceiptModel[resultOk, resultErr]{}
   149  	err = block.Decode(b1, &r3, typ, cbor.Codec, sha256.Hasher)
   150  	if err != nil {
   151  		t.Fatalf("decoding receipt: %s", err)
   152  	}
   153  	if r3.Ocm.Out.Ok != nil {
   154  		t.Fatalf("result ok was not nil")
   155  	}
   156  	if r3.Ocm.Out.Error.Message != "boom" {
   157  		t.Fatalf("error message was not boom")
   158  	}
   159  }