package blob_test import ( "testing" "github.com/lightningnetwork/lnd/watchtower/blob" ) var unknownFlag = blob.Flag(16) type typeStringTest struct { name string typ blob.Type expStr string } var typeStringTests = []typeStringTest{ { name: "commit no-reward", typ: blob.TypeAltruistCommit, expStr: "[FlagCommitOutputs|No-FlagReward]", }, { name: "commit reward", typ: blob.TypeRewardCommit, expStr: "[FlagCommitOutputs|FlagReward]", }, { name: "unknown flag", typ: unknownFlag.Type(), expStr: "0000000000010000[No-FlagCommitOutputs|No-FlagReward]", }, } // TestTypeStrings asserts that the proper human-readable string is returned for // various blob.Types func TestTypeStrings(t *testing.T) { for _, test := range typeStringTests { t.Run(test.name, func(t *testing.T) { typeStr := test.typ.String() if typeStr != test.expStr { t.Fatalf("mismatched type string, want: %v, "+ "got %v", test.expStr, typeStr) } }) } } // TestUnknownFlagString asserts that the proper string is returned from // unallocated flags. func TestUnknownFlagString(t *testing.T) { if unknownFlag.String() != "FlagUnknown" { t.Fatalf("unknown flags should return FlagUnknown, instead "+ "got: %v", unknownFlag.String()) } } type typeFromFlagTest struct { name string flags []blob.Flag expType blob.Type } var typeFromFlagTests = []typeFromFlagTest{ { name: "no flags", flags: nil, expType: blob.Type(0), }, { name: "single flag", flags: []blob.Flag{blob.FlagReward}, expType: blob.Type(blob.FlagReward), }, { name: "multiple flags", flags: []blob.Flag{blob.FlagReward, blob.FlagCommitOutputs}, expType: blob.TypeRewardCommit, }, { name: "duplicate flag", flags: []blob.Flag{blob.FlagReward, blob.FlagReward}, expType: blob.Type(blob.FlagReward), }, } // TestTypeFromFlags asserts that blob.Types constructed using // blob.TypeFromFlags are correct, and properly deduplicate flags. We also // assert that Has returns true for the generated blob.Type for all of the flags // that were used to create it. func TestTypeFromFlags(t *testing.T) { for _, test := range typeFromFlagTests { t.Run(test.name, func(t *testing.T) { blobType := blob.TypeFromFlags(test.flags...) // Assert that the constructed type matches our // expectation. if blobType != test.expType { t.Fatalf("mismatch, expected blob type %s, "+ "got %s", test.expType, blobType) } // Assert that Has returns true for all flags used to // construct the type. for _, flag := range test.flags { if blobType.Has(flag) { continue } t.Fatalf("expected type to have flag %s, "+ "but didn't", flag) } }) } } // TestSupportedTypes verifies that blob.IsSupported returns true for all // blob.Types returned from blob.SupportedTypes. It also asserts that the // blob.DefaultType returns true. func TestSupportedTypes(t *testing.T) { // Assert that the package's default type is supported. if !blob.IsSupportedType(blob.TypeAltruistCommit) { t.Fatalf("default type %s is not supported", blob.TypeAltruistCommit) } // Assert that all claimed supported types are actually supported. for _, supType := range blob.SupportedTypes() { if blob.IsSupportedType(supType) { continue } t.Fatalf("supposedly supported type %s is not supported", supType) } }