test(genesis): add unit tests for the functions

Signed-off-by: Akhil Repala <[email protected]>

Author: arepala-uml

ledger/alonzo/genesis_test.go

@@ -430,3 +430,62 @@ func TestGenesisFromJson(t *testing.T) {
 		)
 	}
 }
+
+func TestNewAlonzoGenesisFromReader(t *testing.T) {
+	jsonData := `{
+        "lovelacePerUTxOWord": 34482,
+        "maxValueSize": 5000,
+        "collateralPercentage": 150,
+        "maxCollateralInputs": 3,
+        "executionPrices": {
+            "prSteps": { "numerator": 721, "denominator": 10000 },
+            "prMem": { "numerator": 577, "denominator": 10000 }
+        },
+        "maxTxExUnits": { "exUnitsMem": 1000000, "exUnitsSteps": 10000000 },
+        "maxBlockExUnits": { "exUnitsMem": 50000000, "exUnitsSteps": 40000000000 },
+        "costModels": {
+            "PlutusV1": {
+                "addInteger-cpu-arguments-intercept": 205665,
+                "addInteger-cpu-arguments-slope": 812
+            }
+        }
+    }`
+
+	reader := strings.NewReader(jsonData)
+	result, err := alonzo.NewAlonzoGenesisFromReader(reader)
+	if err != nil {
+		t.Errorf("Failed to decode JSON: %v", err)
+	}
+
+	if result.LovelacePerUtxoWord != 34482 {
+		t.Errorf("Expected LovelacePerUtxoWord 34482, got %d", result.LovelacePerUtxoWord)
+	} else {
+		t.Logf("LovelacePerUtxoWord is correct: %d", result.LovelacePerUtxoWord)
+	}
+
+	if result.ExecutionPrices.Steps.Rat.Cmp(big.NewRat(721, 10000)) != 0 {
+		t.Errorf("Unexpected prSteps: got %v, expected 721/10000", result.ExecutionPrices.Steps.Rat)
+	} else {
+		t.Logf("prSteps is correct: %v", result.ExecutionPrices.Steps.Rat)
+	}
+
+	if result.ExecutionPrices.Mem.Rat.Cmp(big.NewRat(577, 10000)) != 0 {
+		t.Errorf("Unexpected prMem: got %v, expected 577/10000", result.ExecutionPrices.Mem.Rat)
+	} else {
+		t.Logf("prMem is correct: %v", result.ExecutionPrices.Mem.Rat)
+	}
+
+	expectedCostModels := map[string]map[string]int{
+		"PlutusV1": {
+			"addInteger-cpu-arguments-intercept": 205665,
+			"addInteger-cpu-arguments-slope":     812,
+		},
+	}
+	if !reflect.DeepEqual(result.CostModels, expectedCostModels) {
+		t.Errorf("Unexpected CostModels:\nGot:  %v\nExpected: %v", result.CostModels, expectedCostModels)
+	} else {
+		t.Logf("CostModels are correct")
+	}
+
+	t.Logf("AlonzoGenesis JSON decoding test completed successfully.")
+}

ledger/byron/genesis_test.go

@@ -356,3 +356,76 @@ func TestGenesisAvvmUtxos(t *testing.T) {
 		)
 	}
 }
+
+func TestNewByronGenesisFromReader(t *testing.T) {
+	jsonData := `{
+        "avvmDistr": { "addr1": "1000" },
+        "blockVersionData": {
+            "heavyDelThd": "1",
+            "maxBlockSize": "2",
+            "maxHeaderSize": "3",
+            "maxProposalSize": "4",
+            "maxTxSize": "5",
+            "mpcThd": "6",
+            "scriptVersion": 1,
+            "slotDuration": "7",
+            "softforkRule": {
+                "initThd": "8",
+                "minThd": "9",
+                "thdDecrement": "10"
+            },
+            "txFeePolicy": {
+                "multiplier": "11",
+                "summand": "12"
+            },
+            "unlockStakeEpoch": "13",
+            "updateImplicit": "14",
+            "updateProposalThd": "15",
+            "updateVoteThd": "16"
+        },
+        "ftsSeed": "seed",
+        "protocolConsts": {
+            "k": 1,
+            "protocolMagic": 42,
+            "vssMinTtl": 2,
+            "vssMaxTtl": 10
+        },
+        "startTime": 100000,
+        "bootStakeholders": { "stakeholder1": 1 },
+        "heavyDelegation": {
+            "key1": {
+                "cert": "cert-val",
+                "delegatePk": "delegate-pk",
+                "issuerPk": "issuer-pk",
+                "omega": 5
+            }
+        },
+        "nonAvvmBalances": { "addr2": "2000" },
+        "vssCerts": {
+            "cert1": {
+                "expiryEpoch": 5,
+                "signature": "sig",
+                "signingKey": "sign-key",
+                "vssKey": "vss-key"
+            }
+        }
+    }`
+
+	expected := byron.ByronGenesis{}
+	err := json.Unmarshal([]byte(jsonData), &expected)
+	if err != nil {
+		t.Errorf("Failed to unmarshal expected: %v", err)
+	}
+
+	reader := strings.NewReader(jsonData)
+	result, err := byron.NewByronGenesisFromReader(reader)
+	if err != nil {
+		t.Errorf("Failed to decode: %v", err)
+	}
+
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("ByronGenesis struct does not match expected.\nGot: %#v\nExpected: %#v", result, expected)
+	} else {
+		t.Logf("ByronGenesis decoded correctly")
+	}
+}

ledger/conway/genesis_test.go

@@ -15,6 +15,7 @@
 package conway_test
 
 import (
+	"encoding/json"
 	"math/big"
 	"reflect"
 	"strings"
@@ -401,3 +402,64 @@ func TestGenesisFromJson(t *testing.T) {
 		)
 	}
 }
+
+func TestNewConwayGenesisFromReader(t *testing.T) {
+	jsonData := `{
+    "poolVotingThresholds": {
+      "committeeNormal": null,
+      "committeeNoConfidence": null,
+      "hardForkInitiation": null,
+      "motionNoConfidence": null,
+      "ppSecurityGroup": null
+    },
+    "dRepVotingThresholds": {
+      "motionNoConfidence": null,
+      "committeeNormal": null,
+      "committeeNoConfidence": null,
+      "updateToConstitution": null,
+      "hardForkInitiation": null,
+      "ppNetworkGroup": null,
+      "ppEconomicGroup": null,
+      "ppTechnicalGroup": null,
+      "ppGovGroup": null,
+      "treasuryWithdrawal": null
+    },
+    "committeeMinSize": 5,
+    "committeeMaxTermLength": 365,
+    "govActionLifetime": 90,
+    "govActionDeposit": 1000,
+    "dRepDeposit": 200,
+    "dRepActivity": 60,
+    "minFeeRefScriptCostPerByte": null,
+    "plutusV3CostModel": [1, 2, 3],
+    "constitution": {
+      "anchor": {
+        "dataHash": "abc123",
+        "url": "https://example.com"
+      },
+      "script": "example-script"
+    },
+    "committee": {
+      "members": { "key1": 1 },
+      "threshold": { "key1": 2 }
+    }
+  }`
+
+	expected := conway.ConwayGenesis{}
+	err := json.Unmarshal([]byte(jsonData), &expected)
+	if err != nil {
+		t.Errorf("Failed to unmarshal expected JSON: %v", err)
+	}
+
+	reader := strings.NewReader(jsonData)
+	actual, err := conway.NewConwayGenesisFromReader(reader)
+	if err != nil {
+		t.Errorf("Failed to decode JSON via NewConwayGenesisFromReader: %v", err)
+	}
+
+	if !reflect.DeepEqual(expected, actual) {
+		t.Errorf("Mismatch between expected and actual structs\nExpected: %#v\nActual:   %#v", expected, actual)
+	} else {
+		t.Logf("ConwayGenesis decoded correctly and matches expected structure")
+	}
+}