From 51d96f8bdd831ef8ab6fe8f8ac7efcc430e10d80 Mon Sep 17 00:00:00 2001 From: Srinivas Baride Date: Sun, 11 Jul 2021 20:40:30 +0530 Subject: [PATCH] Added tests for types address, bandwidth, config, and status --- types/address_test.go | 1222 +++++++++++++++++++++++++++++++++++++++ types/bandwidth_test.go | 1067 ++++++++++++++++++++++++++++++++++ types/config_test.go | 200 +++++++ types/status_test.go | 250 ++++++++ 4 files changed, 2739 insertions(+) create mode 100644 types/address_test.go create mode 100644 types/bandwidth_test.go create mode 100644 types/config_test.go create mode 100644 types/status_test.go diff --git a/types/address_test.go b/types/address_test.go new file mode 100644 index 00000000..2657980b --- /dev/null +++ b/types/address_test.go @@ -0,0 +1,1222 @@ +package types + +import ( + "reflect" + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func TestNodeAddressFromBech32(t *testing.T) { + type args struct { + s string + } + tests := []struct { + name string + args args + want NodeAddress + wantErr bool + }{ + { + "empty", + args{ + s: "", + }, + NodeAddress{}, + true, + }, + { + "invalid", + args{ + s: "invalid", + }, + nil, + true, + }, + { + "invalid prefix", + args{ + s: "sent1qypqxpq9qcrsszgszyfpx9q4zct3sxfq0fzduj", + }, + nil, + true, + }, + { + "10 bytes", + args{ + s: "sentnode1qypqxpq9qcrsszgse4wwrm", + }, + nil, + true, + }, + { + "20 bytes", + args{ + s: "sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqelr5ey", + }, + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + false, + }, + { + "30 bytes", + args{ + s: "sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsxqglcv", + }, + nil, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := NodeAddressFromBech32(tt.args.s) + if (err != nil) != tt.wantErr { + t.Errorf("NodeAddressFromBech32() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("NodeAddressFromBech32() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_Bytes(t *testing.T) { + tests := []struct { + name string + n NodeAddress + want []byte + }{ + { + "nil", + nil, + nil, + }, + { + "empty", + NodeAddress{}, + []byte{}, + }, + { + "10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + { + "20 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + { + "30 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.n.Bytes(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Bytes() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_Empty(t *testing.T) { + tests := []struct { + name string + n NodeAddress + want bool + }{ + { + "nil", + nil, + true}, + { + "empty", + NodeAddress{}, + true, + }, + { + "10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + false, + }, + { + "20 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + false, + }, + { + "30 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.n.Empty(); got != tt.want { + t.Errorf("Empty() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_Equals(t *testing.T) { + type args struct { + address sdk.Address + } + tests := []struct { + name string + n NodeAddress + args args + want bool + }{ + { + "nil", + nil, + args{ + address: nil, + }, + true, + }, + { + "equal type with 0 bytes", + NodeAddress{}, + args{ + address: NodeAddress{}, + }, + true, + }, + { + "unequal type with 0 bytes", + NodeAddress{}, + args{ + address: ProvAddress{}, + }, + true, + }, + { + "unequal type with unequal10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: ProvAddress{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + false, + }, + { + "unequal type with equal 10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + true, + }, + { + "equal type with unequal 10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: NodeAddress{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + false, + }, + { + "equal type with equal 10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.n.Equals(tt.args.address); got != tt.want { + t.Errorf("Equals() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_Marshal(t *testing.T) { + tests := []struct { + name string + n NodeAddress + want []byte + wantErr bool + }{ + { + "nil", + nil, + nil, + false, + }, + { + "empty", + NodeAddress{}, + []byte{}, + false, + }, + { + "10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + false, + }, + { + "20 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + false, + }, + { + "30 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.n.Marshal() + if (err != nil) != tt.wantErr { + t.Errorf("Marshal() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("Marshal() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_MarshalJSON(t *testing.T) { + tests := []struct { + name string + n NodeAddress + want []byte + wantErr bool + }{ + { + "nil", + nil, + []byte(`""`), + false, + }, + { + "empty", + NodeAddress{}, + []byte(`""`), + false, + }, + { + "10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + []byte(`"sentnode1qypqxpq9qcrsszgse4wwrm"`), + false, + }, + { + "20 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + []byte(`"sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqelr5ey"`), + false, + }, + { + "30 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + []byte(`"sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsxqglcv"`), + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.n.MarshalJSON() + if (err != nil) != tt.wantErr { + t.Errorf("MarshalJSON() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("MarshalJSON() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_MarshalYAML(t *testing.T) { + tests := []struct { + name string + n NodeAddress + want interface{} + wantErr bool + }{ + { + "nil", + nil, + "", + false, + }, + { + "empty", + NodeAddress{}, + "", + false, + }, + { + "10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + "sentnode1qypqxpq9qcrsszgse4wwrm", + false, + }, + { + "20 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + "sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqelr5ey", + false, + }, + { + "30 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + "sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsxqglcv", + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.n.MarshalYAML() + if (err != nil) != tt.wantErr { + t.Errorf("MarshalYAML() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("MarshalYAML() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_String(t *testing.T) { + tests := []struct { + name string + n NodeAddress + want string + }{ + { + "nil", + nil, + "", + }, + { + "empty", + NodeAddress{}, + "", + }, + { + "10 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + "sentnode1qypqxpq9qcrsszgse4wwrm", + }, + { + "20 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + "sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqelr5ey", + }, + { + "30 bytes", + NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + "sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsxqglcv", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.n.String(); got != tt.want { + t.Errorf("String() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNodeAddress_Unmarshal(t *testing.T) { + type args struct { + data []byte + } + tests := []struct { + name string + n NodeAddress + args args + wantErr bool + }{ + { + "nil", + nil, + args{ + data: nil, + }, + false, + }, + { + "empty", + NodeAddress{}, + args{ + data: []byte{}, + }, + false, + }, + { + "10 bytes", + NodeAddress{}, + args{ + data: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + false, + }, + { + "20 bytes", + NodeAddress{}, + args{ + data: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + false, + }, + { + "30 bytes", + NodeAddress{}, + args{ + data: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := tt.n.Unmarshal(tt.args.data); (err != nil) != tt.wantErr { + t.Errorf("Unmarshal() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestNodeAddress_UnmarshalJSON(t *testing.T) { + type args struct { + data []byte + } + tests := []struct { + name string + n NodeAddress + args args + wantErr bool + }{ + { + "nil", + nil, + args{ + data: []byte(`""`), + }, + true, + }, + { + "empty", + NodeAddress{}, + args{ + data: []byte(`""`), + }, + true, + }, + { + "10 bytes", + NodeAddress{}, + args{ + data: []byte(`"sentnode1qypqxpq9qcrsszgse4wwrm"`), + }, + true, + }, + { + "20 bytes", + NodeAddress{}, + args{ + data: []byte(`"sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqelr5ey"`), + }, + false, + }, + { + "30 bytes", + NodeAddress{}, + args{ + data: []byte(`"sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsxqglcv"`), + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := tt.n.UnmarshalJSON(tt.args.data); (err != nil) != tt.wantErr { + t.Errorf("UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestNodeAddress_UnmarshalYAML(t *testing.T) { + type args struct { + data []byte + } + tests := []struct { + name string + n NodeAddress + args args + wantErr bool + }{ + { + "nil", + nil, + args{ + data: nil, + }, + true, + }, + { + "empty", + NodeAddress{}, + args{ + data: []byte(""), + }, + true, + }, + { + "10 bytes", + NodeAddress{}, + args{ + data: []byte("sentnode1qypqxpq9qcrsszgse4wwrm"), + }, + true, + }, + { + "20 bytes", + NodeAddress{}, + args{ + data: []byte("sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqelr5ey"), + }, + false, + }, + { + "30 bytes", + NodeAddress{}, + args{ + data: []byte("sentnode1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsxqglcv"), + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := tt.n.UnmarshalYAML(tt.args.data); (err != nil) != tt.wantErr { + t.Errorf("UnmarshalYAML() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestProvAddressFromBech32(t *testing.T) { + type args struct { + s string + } + tests := []struct { + name string + args args + want ProvAddress + wantErr bool + }{ + { + "empty", + args{ + s: "", + }, + ProvAddress{}, + true, + }, + { + "invalid", + args{ + s: "invalid", + }, + nil, + true, + }, + { + "invalid prefix", + args{s: "sent1qypqxpq9qcrsszgszyfpx9q4zct3sxfq0fzduj", + }, + nil, + true, + }, + { + "10 bytes", + args{ + s: "sentprov1qypqxpq9qcrsszgsutj8xr", + }, + nil, + true, + }, + { + "20 bytes", + args{ + s: "sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfq877k82", + }, + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + false, + }, + { + "30 bytes", + args{ + s: "sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsh33zgx", + }, + nil, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := ProvAddressFromBech32(tt.args.s) + if (err != nil) != tt.wantErr { + t.Errorf("ProvAddressFromBech32() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("ProvAddressFromBech32() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_Bytes(t *testing.T) { + tests := []struct { + name string + p ProvAddress + want []byte + }{ + { + "nil", + nil, + nil, + }, + { + "empty", + ProvAddress{}, + []byte{}, + }, + { + "10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + { + "20 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + { + "30 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.p.Bytes(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Bytes() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_Empty(t *testing.T) { + tests := []struct { + name string + p ProvAddress + want bool + }{ + { + "nil", + nil, + true, + }, + { + "empty", + ProvAddress{}, + true, + }, + { + "10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + false, + }, + { + "20 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + false, + }, + { + "30 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.p.Empty(); got != tt.want { + t.Errorf("Empty() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_Equals(t *testing.T) { + type args struct { + address sdk.Address + } + tests := []struct { + name string + p ProvAddress + args args + want bool + }{ + { + "nil", + nil, + args{ + address: nil, + }, + true, + }, + { + "equal type with 0 bytes", + ProvAddress{}, + args{ + address: ProvAddress{}, + }, + true, + }, + { + "unequal type with 0 bytes", + ProvAddress{}, + args{ + address: NodeAddress{}, + }, + true, + }, + { + "unequal type with unequal10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: NodeAddress{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + false, + }, + { + "unequal type with equal 10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: NodeAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + true, + }, + { + "equal type with unequal 10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: ProvAddress{0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + false, + }, + { + "equal type with equal 10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + args{ + address: ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.p.Equals(tt.args.address); got != tt.want { + t.Errorf("Equals() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_Marshal(t *testing.T) { + tests := []struct { + name string + p ProvAddress + want []byte + wantErr bool + }{ + { + "nil", + nil, + nil, + false, + }, + { + "empty", + ProvAddress{}, + []byte{}, + false, + }, + { + "10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + false, + }, + { + "20 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + false, + }, + { + "30 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.p.Marshal() + if (err != nil) != tt.wantErr { + t.Errorf("Marshal() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("Marshal() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_MarshalJSON(t *testing.T) { + tests := []struct { + name string + p ProvAddress + want []byte + wantErr bool + }{ + { + "nil", + nil, + []byte(`""`), + false, + }, + { + "empty", + ProvAddress{}, + []byte(`""`), + false, + }, + { + "10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + []byte(`"sentprov1qypqxpq9qcrsszgsutj8xr"`), + false, + }, + { + "20 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + []byte(`"sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfq877k82"`), + false, + }, + { + "30 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + []byte(`"sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsh33zgx"`), + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.p.MarshalJSON() + if (err != nil) != tt.wantErr { + t.Errorf("MarshalJSON() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("MarshalJSON() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_MarshalYAML(t *testing.T) { + tests := []struct { + name string + p ProvAddress + want interface{} + wantErr bool + }{ + { + "nil", + nil, + "", + false, + }, + { + "empty", + ProvAddress{}, + "", + false, + }, + { + "10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + "sentprov1qypqxpq9qcrsszgsutj8xr", + false, + }, + { + "20 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + "sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfq877k82", + false, + }, + { + "30 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + "sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsh33zgx", + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + got, err := tt.p.MarshalYAML() + if (err != nil) != tt.wantErr { + t.Errorf("MarshalYAML() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("MarshalYAML() got = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_String(t *testing.T) { + tests := []struct { + name string + p ProvAddress + want string + }{ + { + "nil", + nil, + "", + }, + { + "empty", + ProvAddress{}, + "", + }, + { + "10 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + "sentprov1qypqxpq9qcrsszgsutj8xr", + }, + { + "20 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + "sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfq877k82", + }, + { + "30 bytes", + ProvAddress{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + "sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsh33zgx", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.p.String(); got != tt.want { + t.Errorf("String() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestProvAddress_Unmarshal(t *testing.T) { + type args struct { + data []byte + } + tests := []struct { + name string + p ProvAddress + args args + wantErr bool + }{ + { + "nil", + nil, + args{ + data: nil, + }, + false, + }, + { + "empty", + ProvAddress{}, + args{ + data: []byte{}, + }, + false, + }, + { + "10 bytes", + ProvAddress{}, + args{ + data: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10}, + }, + false, + }, + { + "20 bytes", + ProvAddress{}, + args{ + data: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20}, + }, + false, + }, + { + "30 bytes", + ProvAddress{}, + args{ + data: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30}, + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := tt.p.Unmarshal(tt.args.data); (err != nil) != tt.wantErr { + t.Errorf("Unmarshal() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestProvAddress_UnmarshalJSON(t *testing.T) { + type args struct { + data []byte + } + tests := []struct { + name string + p ProvAddress + args args + wantErr bool + }{ + { + "nil", + nil, + args{ + data: []byte(`""`), + }, + true, + }, + { + "empty", + ProvAddress{}, + args{ + data: []byte(`""`), + }, + true, + }, + { + "10 bytes", + ProvAddress{}, + args{ + data: []byte(`"sentprov1qypqxpq9qcrsszgsutj8xr"`), + }, + true, + }, + { + "20 bytes", + ProvAddress{}, + args{ + data: []byte(`"sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfq877k82"`), + }, + false, + }, + { + "30 bytes", + ProvAddress{}, + args{ + data: []byte(`"sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsh33zgx"`), + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := tt.p.UnmarshalJSON(tt.args.data); (err != nil) != tt.wantErr { + t.Errorf("UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} + +func TestProvAddress_UnmarshalYAML(t *testing.T) { + type args struct { + data []byte + } + tests := []struct { + name string + p ProvAddress + args args + wantErr bool + }{ + { + "nil", + nil, + args{ + data: nil, + }, + true, + }, + { + "empty", + ProvAddress{}, + args{ + data: []byte(""), + }, + true, + }, + { + "10 bytes", + ProvAddress{}, + args{ + data: []byte("sentprov1qypqxpq9qcrsszgsutj8xr"), + }, + true, + }, + { + "20 bytes", + ProvAddress{}, + args{ + data: []byte("sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfq877k82"), + }, + false, + }, + { + "30 bytes", + ProvAddress{}, + args{ + data: []byte("sentprov1qypqxpq9qcrsszgszyfpx9q4zct3sxfqyy3zxfp9ycnjs2fsh33zgx"), + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if err := tt.p.UnmarshalYAML(tt.args.data); (err != nil) != tt.wantErr { + t.Errorf("UnmarshalYAML() error = %v, wantErr %v", err, tt.wantErr) + } + }) + } +} diff --git a/types/bandwidth_test.go b/types/bandwidth_test.go new file mode 100644 index 00000000..6cb3f2f8 --- /dev/null +++ b/types/bandwidth_test.go @@ -0,0 +1,1067 @@ +package types + +import ( + "reflect" + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func TestBandwidth_Add(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + type args struct { + v Bandwidth + } + tests := []struct { + name string + fields fields + args args + want Bandwidth + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(-1000)}, + }, + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(-1000)}, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(0)}, + }, + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(0)}, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(1000)}, + }, + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(1000)}, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(-1000)}, + }, + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(-1000)}, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(0)}, + }, + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(0)}, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(1000)}, + }, + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(1000)}, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(-1000)}, + }, + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(-1000)}, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(0)}, + }, + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(0)}, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(1000)}, + }, + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(1000)}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.Add(tt.args.v); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Add() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_CeilTo(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + type args struct { + precision sdk.Int + } + tests := []struct { + name string + fields fields + args args + want Bandwidth + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.CeilTo(tt.args.precision); !reflect.DeepEqual(got, tt.want) { + t.Errorf("CeilTo() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_IsAllLTE(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + type args struct { + v Bandwidth + } + tests := []struct { + name string + fields fields + args args + want bool + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(-1000)}, + }, + false, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(0)}, + }, + false, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(1000)}, + }, + false, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(-1000)}, + }, + false, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(0)}, + }, + true, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(1000)}, + }, + true, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(-1000)}, + }, + false, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(0)}, + }, + true, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(1000)}, + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.IsAllLTE(tt.args.v); got != tt.want { + t.Errorf("IsAllLTE() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_IsAllPositive(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + tests := []struct { + name string + fields fields + want bool + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(0), + }, + false, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(1000), + }, + false, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + false, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(1000), + }, + false, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(0), + }, + false, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(1000), + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.IsAllPositive(); got != tt.want { + t.Errorf("IsAllPositive() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_IsAllZero(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + tests := []struct { + name string + fields fields + want bool + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(0), + }, + false, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(1000), + }, + false, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + true, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(1000), + }, + false, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(0), + }, + false, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(1000), + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.IsAllZero(); got != tt.want { + t.Errorf("IsAllZero() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_IsAnyGT(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + type args struct { + v Bandwidth + } + tests := []struct { + name string + fields fields + args args + want bool + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(-1000)}, + }, + true, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(0)}, + }, + true, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(1000)}, + }, + true, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(-1000)}, + }, + true, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(0)}, + }, + false, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(1000)}, + }, + false, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(-1000)}, + }, + true, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(0)}, + }, + false, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(1000)}, + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.IsAnyGT(tt.args.v); got != tt.want { + t.Errorf("IsAnyGT() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_IsAnyNegative(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + tests := []struct { + name string + fields fields + want bool + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(-1000), + }, + true, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(0), + }, + true, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(1000), + }, + true, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(-1000), + }, + true, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + false, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(1000), + }, + false, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(-1000), + }, + true, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(0), + }, + false, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(1000), + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.IsAnyNegative(); got != tt.want { + t.Errorf("IsAnyNegative() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_IsAnyZero(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + tests := []struct { + name string + fields fields + want bool + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(0), + }, + true, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(1000), + }, + false, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(-1000), + }, + true, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + true, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(1000), + }, + true, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(-1000), + }, + false, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(0), + }, + true, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(1000), + }, + false, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.IsAnyZero(); got != tt.want { + t.Errorf("IsAnyZero() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_Sub(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + type args struct { + v Bandwidth + } + tests := []struct { + name string + fields fields + args args + want Bandwidth + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(-1000)}, + }, + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(1000)}, + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(0)}, + }, + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(0)}, + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(1000)}, + }, + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(-1000)}, + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(-1000)}, + }, + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(1000)}, + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(0)}, + }, + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(0)}, + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(1000)}, + }, + Bandwidth{Upload: sdk.NewInt(0), Download: sdk.NewInt(-1000)}, + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(-1000)}, + }, + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(1000)}, + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(0)}, + }, + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(0)}, + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + args{ + Bandwidth{Upload: sdk.NewInt(1000), Download: sdk.NewInt(1000)}, + }, + Bandwidth{Upload: sdk.NewInt(-1000), Download: sdk.NewInt(-1000)}, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.Sub(tt.args.v); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Sub() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestBandwidth_Sum(t *testing.T) { + type fields struct { + Upload sdk.Int + Download sdk.Int + } + tests := []struct { + name string + fields fields + want sdk.Int + }{ + { + "negative upload and negative download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(-1000), + }, + sdk.NewInt(-2000), + }, + { + "negative upload and zero download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(0), + }, + sdk.NewInt(-1000), + }, + { + "negative upload and positive download", + fields{ + Upload: sdk.NewInt(-1000), + Download: sdk.NewInt(1000), + }, + sdk.NewInt(0), + }, + { + "zero upload and negative download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(-1000), + }, + sdk.NewInt(-1000), + }, + { + "zero upload and zero download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(0), + }, + sdk.NewInt(0), + }, + { + "zero upload and positive download", + fields{ + Upload: sdk.NewInt(0), + Download: sdk.NewInt(1000), + }, + sdk.NewInt(1000), + }, + { + "positive upload and negative download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(-1000), + }, + sdk.NewInt(0), + }, + { + "positive upload and zero download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(0), + }, + sdk.NewInt(1000), + }, + { + "positive upload and positive download", + fields{ + Upload: sdk.NewInt(1000), + Download: sdk.NewInt(1000), + }, + sdk.NewInt(2000), + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + b := Bandwidth{ + Upload: tt.fields.Upload, + Download: tt.fields.Download, + } + if got := b.Sum(); !reflect.DeepEqual(got, tt.want) { + t.Errorf("Sum() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNewBandwidth(t *testing.T) { + type args struct { + upload sdk.Int + download sdk.Int + } + tests := []struct { + name string + args args + want Bandwidth + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewBandwidth(tt.args.upload, tt.args.download); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewBandwidth() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestNewBandwidthFromInt64(t *testing.T) { + type args struct { + upload int64 + download int64 + } + tests := []struct { + name string + args args + want Bandwidth + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewBandwidthFromInt64(tt.args.upload, tt.args.download); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewBandwidthFromInt64() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/types/config_test.go b/types/config_test.go new file mode 100644 index 00000000..d75b78ed --- /dev/null +++ b/types/config_test.go @@ -0,0 +1,200 @@ +package types + +import ( + "sync" + "testing" + + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func TestConfig_GetBech32NodeAddrPrefix(t *testing.T) { + type fields struct { + Config *sdk.Config + prefixes map[string]string + sealed bool + mtx sync.Mutex + } + tests := []struct { + name string + fields fields + want string + }{ + { + "invalid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"node_addr": "sent"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sent", + }, + { + "valid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"node_addr": "sentnode"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sentnode", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &Config{ + Config: tt.fields.Config, + prefixes: tt.fields.prefixes, + sealed: tt.fields.sealed, + mtx: tt.fields.mtx, + } + if got := c.GetBech32NodeAddrPrefix(); got != tt.want { + t.Errorf("GetBech32NodeAddrPrefix() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestConfig_GetBech32NodePubPrefix(t *testing.T) { + type fields struct { + Config *sdk.Config + prefixes map[string]string + sealed bool + mtx sync.Mutex + } + tests := []struct { + name string + fields fields + want string + }{ + { + "invalid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"node_pub": "sentpub"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sentpub", + }, + { + "valid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"node_pub": "sentnodepub"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sentnodepub", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &Config{ + Config: tt.fields.Config, + prefixes: tt.fields.prefixes, + sealed: tt.fields.sealed, + mtx: tt.fields.mtx, + } + if got := c.GetBech32NodePubPrefix(); got != tt.want { + t.Errorf("GetBech32NodePubPrefix() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestConfig_GetBech32ProviderAddrPrefix(t *testing.T) { + type fields struct { + Config *sdk.Config + prefixes map[string]string + sealed bool + mtx sync.Mutex + } + tests := []struct { + name string + fields fields + want string + }{ + { + "invalid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"provider_addr": "sent"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sent", + }, + { + "valid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"provider_addr": "sentprov"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sentprov", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &Config{ + Config: tt.fields.Config, + prefixes: tt.fields.prefixes, + sealed: tt.fields.sealed, + mtx: tt.fields.mtx, + } + if got := c.GetBech32ProviderAddrPrefix(); got != tt.want { + t.Errorf("GetBech32ProviderAddrPrefix() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestConfig_GetBech32ProviderPubPrefix(t *testing.T) { + type fields struct { + Config *sdk.Config + prefixes map[string]string + sealed bool + mtx sync.Mutex + } + tests := []struct { + name string + fields fields + want string + }{ + { + "invalid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"provider_pub": "sentpub"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sentpub", + }, + { + "valid prefix", + fields{ + Config: sdk.GetConfig(), + prefixes: map[string]string{"provider_pub": "sentprovpub"}, + sealed: false, + mtx: sync.Mutex{}, + }, + "sentprovpub", + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &Config{ + Config: tt.fields.Config, + prefixes: tt.fields.prefixes, + sealed: tt.fields.sealed, + mtx: tt.fields.mtx, + } + if got := c.GetBech32ProviderPubPrefix(); got != tt.want { + t.Errorf("GetBech32ProviderPubPrefix() = %v, want %v", got, tt.want) + } + }) + } +} diff --git a/types/status_test.go b/types/status_test.go new file mode 100644 index 00000000..fd8bb275 --- /dev/null +++ b/types/status_test.go @@ -0,0 +1,250 @@ +package types + +import ( + "testing" +) + +func TestStatusFromString(t *testing.T) { + type args struct { + s string + } + tests := []struct { + name string + args args + want Status + }{ + { + "empty", + args{ + s: "", + }, + StatusUnknown, + }, + { + "invalid", + args{ + s: "invalid", + }, + StatusUnknown, + }, + { + "unknown", + args{ + s: "unknown", + }, + StatusUnknown, + }, + { + "active", + args{ + s: "Active", + }, + StatusActive, + }, + { + "inactive pending", + args{ + s: "InactivePending", + }, + StatusInactivePending, + }, + { + "inactive", + args{ + s: "Inactive", + }, + StatusInactive, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := StatusFromString(tt.args.s); got != tt.want { + t.Errorf("StatusFromString() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestStatus_Equal(t *testing.T) { + type args struct { + v Status + } + tests := []struct { + name string + s Status + args args + want bool + }{ + { + "unknown and unknown", + StatusUnknown, + args{ + v: StatusUnknown, + }, + true, + }, + { + "unknown and active", + StatusUnknown, + args{ + v: StatusActive, + }, + false, + }, + { + "unknown and inactive pending", + StatusUnknown, + args{ + v: StatusInactivePending, + }, + false, + }, + { + "unknown and inactive", + StatusUnknown, + args{ + v: StatusInactive, + }, + false, + }, + { + "active and unknown", + StatusActive, + args{ + v: StatusUnknown, + }, + false, + }, + { + "active and active", + StatusActive, + args{ + v: StatusActive, + }, + true, + }, + { + "active and inactive pending", + StatusActive, + args{ + v: StatusInactivePending, + }, + false, + }, + { + "active and inactive", + StatusActive, + args{ + v: StatusInactive, + }, + false, + }, + { + "inactive pending and unknown", + StatusInactivePending, + args{ + v: StatusUnknown, + }, + false, + }, + { + "inactive pending and active", + StatusInactivePending, + args{ + v: StatusActive, + }, + false, + }, + { + "inactive pending and inactive pending", + StatusInactivePending, + args{ + v: StatusInactivePending, + }, + true, + }, + { + "inactive pending and inactive", + StatusInactivePending, + args{ + v: StatusInactive, + }, + false, + }, + { + "inactive and unknown", + StatusInactive, + args{ + v: StatusUnknown, + }, + false, + }, + { + "inactive and active", + StatusInactive, + args{ + v: StatusActive, + }, + false, + }, + { + "inactive and inactive pending", + StatusInactive, + args{ + v: StatusInactivePending, + }, + false, + }, + { + "inactive and inactive", + StatusInactive, + args{ + v: StatusInactive, + }, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.s.Equal(tt.args.v); got != tt.want { + t.Errorf("Equal() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestStatus_IsValid(t *testing.T) { + tests := []struct { + name string + s Status + want bool + }{ + { + "unknown", + StatusUnknown, + false, + }, + { + "active", + StatusActive, + true, + }, + { + "inactive pending", + StatusInactive, + true, + }, + { + "inactive", + StatusInactive, + true, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := tt.s.IsValid(); got != tt.want { + t.Errorf("IsValid() = %v, want %v", got, tt.want) + } + }) + } +}