Skip to content

Commit ab5d72e

Browse files
jonas089jonas089
committed
wip cleanup
1 parent 1a81626 commit ab5d72e

19 files changed

+357
-692
lines changed

‎util/hex_address_test.go‎

Lines changed: 28 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -36,198 +36,184 @@ var _ = Describe("hex_address.go", Ordered, func() {
3636
zeroHex := "0x0000000000000000000000000000000000000000000000000000000000000000"
3737

3838
It("Decode (valid) Zero Hex Address", func() {
39-
// Arrange
4039

41-
// Act
4240
address, err := util.DecodeHexAddress(zeroHex)
4341

44-
// Assert
42+
4543
Expect(err).To(BeNil())
4644
Expect(address.IsZeroAddress()).To(BeTrue())
4745
Expect(address.GetInternalId()).To(Equal(uint64(0)))
4846
Expect(address.String()).To(Equal(zeroHex))
4947
})
5048

5149
It("Decode (invalid) Hex Address (to short)", func() {
52-
// Arrange
50+
5351
invalidZeroHex := "0x000000000000000000000000000000000000000000000000000000000000000"
5452

55-
// Act
5653
address, err := util.DecodeHexAddress(invalidZeroHex)
5754

58-
// Assert (Address equals Zero address)
55+
(Address equals Zero address)
5956
Expect(err.Error()).To(Equal("invalid hex address length"))
6057
Expect(address.IsZeroAddress()).To(BeTrue())
6158
Expect(address.GetInternalId()).To(Equal(uint64(0)))
6259
Expect(address.String()).To(Equal(zeroHex))
6360
})
6461

6562
It("Decode (invalid) Hex Address (invalid hex)", func() {
66-
// Arrange
63+
6764
invalidZeroHex := "0x000000000000000000000000000000000000000000000000000000000000000g"
6865

69-
// Act
7066
address, err := util.DecodeHexAddress(invalidZeroHex)
7167

72-
// Assert (Address equals Zero address)
68+
(Address equals Zero address)
7369
Expect(err.Error()).To(Equal("encoding/hex: invalid byte: U+0067 'g'"))
7470
Expect(address.IsZeroAddress()).To(BeTrue())
7571
Expect(address.GetInternalId()).To(Equal(uint64(0)))
7672
Expect(address.String()).To(Equal(zeroHex))
7773
})
7874

7975
It("Address generation", func() {
80-
// Arrange
8176

82-
// Act
8377
identifier := make([]byte, 20)
8478
copy(identifier, "hyperlane")
8579
address := util.GenerateHexAddress([20]byte(identifier), 1, 1)
8680

87-
// Assert
81+
8882
Expect(address.String()).To(Equal("0x68797065726c616e650000000000000000000000000000010000000000000001"))
8983
Expect(address.GetInternalId()).To(Equal(uint64(1)))
9084
Expect(address.GetType()).To(Equal(uint32(1)))
9185
})
9286

9387
It("Proto marshalling", func() {
94-
// Arrange
88+
9589
identifier := make([]byte, 20)
9690
copy(identifier, "hyperlane")
9791
address := util.GenerateHexAddress([20]byte(identifier), 1, 1)
9892

99-
// Act
10093
bytes, err := address.Marshal()
10194
Expect(err).To(BeNil())
10295

103-
// Assert
96+
10497
Expect(string(bytes)).To(Equal("0x68797065726c616e650000000000000000000000000000010000000000000001"))
10598
Expect(address.Size()).To(Equal(2 + 2*32))
10699
})
107100

108101
It("Proto marshalling 2", func() {
109-
// Arrange
102+
110103
identifier := make([]byte, 20)
111104
copy(identifier, "hyperlane")
112105
address := util.GenerateHexAddress([20]byte(identifier), 1, 1)
113106

114107
bytes := make([]byte, 66)
115-
// Act
108+
116109
n, err := address.MarshalTo(bytes)
117110
Expect(err).To(BeNil())
118111

119-
// Assert
112+
120113
Expect(n).To(Equal(66))
121114
Expect(string(bytes)).To(Equal("0x68797065726c616e650000000000000000000000000000010000000000000001"))
122115
Expect(address.Size()).To(Equal(2 + 2*32))
123116
})
124117

125118
It("Proto marshalling 2 (wrong length)", func() {
126-
// Arrange
119+
127120
identifier := make([]byte, 20)
128121
copy(identifier, "hyperlane")
129122
address := util.GenerateHexAddress([20]byte(identifier), 1, 1)
130123

131124
bytes := make([]byte, 64)
132-
// Act
125+
133126
n, err := address.MarshalTo(bytes)
134127

135-
// Assert
128+
136129
Expect(err.Error()).To(Equal("invalid hex address length: 64"))
137130
Expect(n).To(Equal(64))
138131
Expect(address.Size()).To(Equal(2 + 2*32))
139132
})
140133

141134
It("Proto marshalling (JSON)", func() {
142-
// Arrange
135+
143136
rawAddress := "0x68797065726c616e650000000000000000000000000000010000000000000001"
144137
address, _ := util.DecodeHexAddress(rawAddress)
145138

146-
// Act
147139
bytes, err := address.MarshalJSON()
148140
Expect(err).To(BeNil())
149141

150-
// Assert
142+
151143
Expect(string(bytes)).To(Equal(fmt.Sprintf(`"%s"`, rawAddress)))
152144
Expect(address.Size()).To(Equal(2 + 2*32))
153145
})
154146

155147
It("Proto unmarshalling", func() {
156-
// Arrange
148+
157149
rawAddress := "0x68797065726c616e650000000000000000000000000000010000000000000001"
158150
var address util.HexAddress
159151

160-
// Act
161152
err := address.Unmarshal([]byte(rawAddress))
162153
Expect(err).To(BeNil())
163154

164-
// Assert
155+
165156
Expect(address.String()).To(Equal("0x68797065726c616e650000000000000000000000000000010000000000000001"))
166157
Expect(address.Size()).To(Equal(2 + 2*32))
167158
})
168159

169160
It("Proto unmarshalling (wrong length)", func() {
170-
// Arrange
161+
171162
rawAddress := "0x68797065726c616e65000000000000000000000000000001000000000000000"
172163
var address util.HexAddress
173164

174-
// Act
175165
err := address.Unmarshal([]byte(rawAddress))
176166

177-
// Assert
167+
178168
Expect(err.Error()).To(Equal("invalid hex address length"))
179169
Expect(address.String()).To(Equal(zeroHex))
180170
})
181171

182172
It("Proto unmarshalling (invalid)", func() {
183-
// Arrange
173+
184174
rawAddress := "0x68797065726c616e65000000000000000000000000000001000000000000000g"
185175
var address util.HexAddress
186176

187-
// Act
188177
err := address.Unmarshal([]byte(rawAddress))
189178

190-
// Assert
179+
191180
Expect(err.Error()).To(Equal("encoding/hex: invalid byte: U+0067 'g'"))
192181
Expect(address.String()).To(Equal(zeroHex))
193182
})
194183

195184
It("Proto unmarshalling (JSON)", func() {
196-
// Arrange
185+
197186
rawAddress := "\"0x68797065726c616e650000000000000000000000000000010000000000000001\""
198187
var address util.HexAddress
199188

200-
// Act
201189
err := address.UnmarshalJSON([]byte(rawAddress))
202190
Expect(err).To(BeNil())
203191

204-
// Assert
192+
205193
Expect(address.String()).To(Equal("0x68797065726c616e650000000000000000000000000000010000000000000001"))
206194
Expect(address.Size()).To(Equal(2 + 2*32))
207195
})
208196

209197
It("Proto unmarshalling (JSON) (invalid json)", func() {
210-
// Arrange
198+
211199
rawAddress := "\"0x68797065726c616e650000000000000000000000000000010000000000000001"
212200
var address util.HexAddress
213201

214-
// Act
215202
err := address.UnmarshalJSON([]byte(rawAddress))
216203

217-
// Assert
204+
218205
Expect(err.Error()).To(Equal("unexpected end of JSON input"))
219206
Expect(address.String()).To(Equal(util.NewZeroAddress().String()))
220207
})
221208

222209
It("Proto unmarshalling (JSON) (invalid hex address)", func() {
223-
// Arrange
210+
224211
rawAddress := "\"0x68797065726c616e65000000000000000000000000000001000000000000000g\""
225212
var address util.HexAddress
226213

227-
// Act
228214
err := address.UnmarshalJSON([]byte(rawAddress))
229215

230-
// Assert
216+
231217
Expect(err.Error()).To(Equal("encoding/hex: invalid byte: U+0067 'g'"))
232218
Expect(address.String()).To(Equal(util.NewZeroAddress().String()))
233219
})

‎util/hyperlane_message_test.go‎

Lines changed: 2 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -29,12 +29,9 @@ var _ = Describe("hyperlane_message.go", Ordered, func() {
2929
"000000000000000000000000f254e1ce6b468e5c118214d13faa263011046715" // Recipient
3030

3131
It("Decode (valid) Empty Hyperlane Message", func() {
32-
// Arrange
3332

34-
// Act
3533
message, err := util.ParseHyperlaneMessage(MustDecodeHex(validWarpMessage))
3634

37-
// Assert
3835
Expect(err).To(BeNil())
3936
Expect(message.Version).To(Equal(uint8(3)))
4037
Expect(message.Nonce).To(Equal(uint32(3)))
@@ -52,15 +49,13 @@ var _ = Describe("hyperlane_message.go", Ordered, func() {
5249
})
5350

5451
It("Decode (valid) Hyperlane Warp Message", func() {
55-
// Arrange
52+
5653
rawMessage := validWarpMessage +
5754
"0000000000000000000000000c60e7ecd06429052223c78452f791aab5c5cac6" + // WarpPayload: Recipient
5855
"000000000000000000000000000000000000000000000000000000000000000b" // WarpPayload: amount
5956

60-
// Act
6157
message, err := util.ParseHyperlaneMessage(MustDecodeHex(rawMessage))
6258

63-
// Assert
6459
Expect(err).To(BeNil())
6560
Expect(message.Version).To(Equal(uint8(3)))
6661
Expect(message.Nonce).To(Equal(uint32(3)))
@@ -78,13 +73,11 @@ var _ = Describe("hyperlane_message.go", Ordered, func() {
7873
})
7974

8075
It("Decode (invalid) Hyperlane Warp Message (too short)", func() {
81-
// Arrange
76+
8277
tooShortMessage := validWarpMessage[:len(validWarpMessage)-2]
8378

84-
// Act
8579
message, err := util.ParseHyperlaneMessage(MustDecodeHex(tooShortMessage))
8680

87-
// Assert
8881
Expect(err.Error()).To(Equal("invalid hyperlane message"))
8982
Expect(message.Version).To(Equal(uint8(0)))
9083
Expect(message.Nonce).To(Equal(uint32(0)))

‎util/merkle_tree_test.go‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -21,13 +21,11 @@ var _ = Describe("merkle_tree.go", Ordered, func() {
2121
})
2222

2323
It("Create new empty tree", func() {
24-
// Arrange
24+
2525
tree := util.NewTree(util.ZeroHashes, 0)
2626

27-
// Act
2827
checkpoint, n, err := tree.GetLatestCheckpoint()
2928

30-
// Assert
3129
Expect(tree).ToNot(BeNil())
3230
Expect(tree.Count).To(Equal(uint32(0)))
3331
Expect(tree.GetCount()).To(Equal(uint32(0)))

0 commit comments

Comments
 (0)