Skip to content

Commit b7e6f55

Browse files
TonioMacaronioTonioMacaronio
committed
fixed tests for ens
1 parent 0a6e5b0 commit b7e6f55

File tree

2 files changed

+88
-61
lines changed

2 files changed

+88
-61
lines changed

‎web3swift/Utils/Classes/ENSResolver.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -110,7 +110,7 @@ public struct ResolverENS {
110110
guard let transaction = self.resolverContract.read("ABI", parameters: [nameHash, contentType] as [AnyObject], extraData: Data(), transactionOptions: defaultOptions) else {throw Web3Error.transactionSerializationError}
111111
guard let result = try? transaction.call(transactionOptions: defaultOptions) else {throw Web3Error.processingError(desc: "Can't call transaction")}
112112
guard let encoding = result["0"] as? BigUInt else {throw Web3Error.processingError(desc: "Can't get encoding")}
113-
guard let data = result["0"] as? Data else {throw Web3Error.processingError(desc: "Can't get data")}
113+
guard let data = result["1"] as? Data else {throw Web3Error.processingError(desc: "Can't get data")}
114114
return (encoding, data)
115115
}
116116

‎web3swiftTests/web3swift_ENS_Tests.swift

Lines changed: 87 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -22,87 +22,114 @@ class web3swift_ENS_Tests: XCTestCase {
2222
}
2323

2424
func testResolverAddress() {
25-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
26-
var ens = ENS(web3: web)
27-
guard case .success(let resolver) = ens.resolver(forDomain: "somename.eth") else { XCTAssert(false); return }
28-
XCTAssertEqual(resolver.resolverAddress.address.lowercased(), "0x5ffc014343cd971b7eb70732021e26c35b744cc4")
25+
do {
26+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
27+
let ens = ENS(web3: web)
28+
let domain = "somename.eth"
29+
let resolver = try ens.resolver(forDomain: domain)
30+
XCTAssertEqual(resolver.resolverAddress.address.lowercased(), "0x5ffc014343cd971b7eb70732021e26c35b744cc4")
31+
} catch {
32+
XCTFail()
33+
}
2934
}
3035

3136
func testResolver() {
32-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
33-
var ens = ENS(web3: web)
34-
let domain = "somename.eth"
35-
guard case .success(var resolver) = ens.resolver(forDomain: domain) else { XCTAssert(false); return }
36-
guard case .success(let address) = resolver.addr(forDomain: domain) else { XCTAssert(false); return }
37-
XCTAssertEqual(address.address.lowercased(), "0x3487acfb1479ad1df6c0eb56ae743d34897798ac")
38-
37+
do {
38+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
39+
let ens = ENS(web3: web)
40+
let domain = "somename.eth"
41+
var resolver = try ens.resolver(forDomain: domain)
42+
let address = try resolver.addr(forDomain: domain)
43+
XCTAssertEqual(address.address.lowercased(), "0x3487acfb1479ad1df6c0eb56ae743d34897798ac")
44+
} catch {
45+
XCTFail()
46+
}
3947
}
4048

4149
func testSupportsInterface() {
42-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
43-
var ens = ENS(web3: web)
44-
let domain = "somename.eth"
45-
guard case .success(var resolver) = ens.resolver(forDomain: domain) else { XCTAssert(false); return }
46-
guard case .success(let isAddrSupports) = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.addr.hash()) else { XCTAssert(false); return }
47-
XCTAssertEqual(isAddrSupports, true)
48-
guard case .success(let isNameSupports) = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.name.hash()) else { XCTAssert(false); return }
49-
XCTAssertEqual(isNameSupports, true)
50-
guard case .success(let isABIsupports) = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.ABI.hash()) else { XCTAssert(false); return }
51-
XCTAssertEqual(isABIsupports, true)
52-
guard case .success(let isPubkeySupports) = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.pubkey.hash()) else { XCTAssert(false); return }
53-
XCTAssertEqual(isPubkeySupports, true)
50+
do {
51+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
52+
let ens = ENS(web3: web)
53+
let domain = "somename.eth"
54+
var resolver = try ens.resolver(forDomain: domain)
55+
let isAddrSupports = try resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.addr.hash())
56+
let isNameSupports = try resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.name.hash())
57+
let isABIsupports = try resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.ABI.hash())
58+
let isPubkeySupports = try resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.pubkey.hash())
59+
XCTAssertEqual(isAddrSupports, true)
60+
XCTAssertEqual(isNameSupports, true)
61+
XCTAssertEqual(isABIsupports, true)
62+
XCTAssertEqual(isPubkeySupports, true)
63+
} catch {
64+
XCTFail()
65+
}
5466
}
5567

5668
func testABI() {
57-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
58-
var ens = ENS(web3: web)
59-
let domain = "somename.eth"
60-
guard case .success(var resolver) = ens.resolver(forDomain: domain) else { XCTAssert(false); return }
61-
guard case .success(let isABIsupported) = resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.ABI.hash()) else { XCTAssert(false); return }
62-
if isABIsupported {
63-
guard case .success(let res) = resolver.ABI(node: domain, contentType: 2) else { XCTAssert(false); return }
64-
XCTAssert(res.0 == 0)
65-
XCTAssert(res.1.count == 0)
69+
do {
70+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
71+
let ens = ENS(web3: web)
72+
let domain = "somename.eth"
73+
var resolver = try ens.resolver(forDomain: domain)
74+
let isABIsupported = try resolver.supportsInterface(interfaceID: ResolverENS.InterfaceName.ABI.hash())
75+
if isABIsupported {
76+
let res = try resolver.ABI(node: domain, contentType: 2)
77+
XCTAssert(res.0 == 0)
78+
XCTAssert(res.1.count == 0)
79+
} else {
80+
XCTFail()
81+
}
82+
} catch {
83+
XCTFail()
6684
}
6785
}
6886

6987
func testOwner() {
70-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
71-
var ens = ENS(web3: web)
72-
let domain = "somename.eth"
73-
guard case .success(let result) = ens.owner(node: domain) else { XCTAssert(false); return }
74-
XCTAssertEqual("0xc67247454e720328714c4e17bec7640572657bee", result.address.lowercased())
88+
do {
89+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
90+
let ens = ENS(web3: web)
91+
let domain = "somename.eth"
92+
let owner = try ens.owner(node: domain)
93+
XCTAssertEqual("0xc67247454e720328714c4e17bec7640572657bee", owner.address.lowercased())
94+
} catch {
95+
XCTFail()
96+
}
7597
}
7698

7799
func testTTL() {
78-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
79-
var ens = ENS(web3: web)
80-
let domain = "somename.eth"
81-
guard case .success(let result) = ens.ttl(node: domain) else { XCTAssert(false); return }
82-
print(result)
100+
do {
101+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
102+
let ens = ENS(web3: web)
103+
let domain = "somename.eth"
104+
let ttl = try ens.ttl(node: domain)
105+
print(ttl)
106+
} catch {
107+
XCTFail()
108+
}
83109
}
84110

85111
func testGetAddress() {
86-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
87-
var ens = ENS(web3: web)
88-
let domain = "somename.eth"
89-
guard case .success(let address) = ens.getAddress(domain) else { XCTAssert(false); return }
90-
XCTAssertEqual(address.address.lowercased(), "0x3487acfb1479ad1df6c0eb56ae743d34897798ac")
112+
do {
113+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
114+
let ens = ENS(web3: web)
115+
let domain = "somename.eth"
116+
let address = try ens.getAddress(domain)
117+
XCTAssertEqual(address.address.lowercased(), "0x3487acfb1479ad1df6c0eb56ae743d34897798ac")
118+
} catch {
119+
XCTFail()
120+
}
91121
}
92122

93123
func testGetPubkey() {
94-
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
95-
var ens = ENS(web3: web)
96-
let domain = "somename.eth"
97-
guard case .success(let point) = ens.getPubkey(domain: domain) else { XCTAssert(false); return }
98-
XCTAssert(point.x == "0x0000000000000000000000000000000000000000000000000000000000000000")
99-
XCTAssert(point.y == "0x0000000000000000000000000000000000000000000000000000000000000000")
124+
do {
125+
let web = web3(provider: InfuraProvider(Networks.Mainnet)!)
126+
let ens = ENS(web3: web)
127+
let domain = "somename.eth"
128+
let pubkey = try ens.getPubkey(domain: domain)
129+
XCTAssert(pubkey.x == "0x0000000000000000000000000000000000000000000000000000000000000000")
130+
XCTAssert(pubkey.y == "0x0000000000000000000000000000000000000000000000000000000000000000")
131+
} catch {
132+
XCTFail()
133+
}
100134
}
101-
102-
103-
104-
105-
106-
107-
108135
}

0 commit comments

Comments
 (0)