Skip to content

Commit dc897e6

Browse files
ibauersachsibauersachs
committed
Use mocks for address lookups to avoid network access
Closes dnsjava#77
1 parent 937c54c commit dc897e6

2 files changed

Lines changed: 108 additions & 5 deletions

File tree

‎pom.xml‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -227,6 +227,12 @@
227227
<version>${org.junit.version}</version>
228228
<scope>test</scope>
229229
</dependency>
230+
<dependency>
231+
<groupId>org.mockito</groupId>
232+
<artifactId>mockito-core</artifactId>
233+
<version>3.1.0</version>
234+
<scope>test</scope>
235+
</dependency>
230236
</dependencies>
231237

232238
<profiles>

‎src/test/java/org/xbill/DNS/AddressTest.java‎

Lines changed: 102 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -40,10 +40,17 @@
4040
import static org.junit.jupiter.api.Assertions.assertNull;
4141
import static org.junit.jupiter.api.Assertions.assertThrows;
4242
import static org.junit.jupiter.api.Assertions.assertTrue;
43+
import static org.mockito.ArgumentMatchers.any;
44+
import static org.mockito.ArgumentMatchers.argThat;
45+
import static org.mockito.Mockito.doReturn;
46+
import static org.mockito.Mockito.when;
4347

48+
import java.io.IOException;
4449
import java.net.InetAddress;
4550
import java.net.UnknownHostException;
4651
import org.junit.jupiter.api.Test;
52+
import org.mockito.ArgumentMatchers;
53+
import org.mockito.Mockito;
4754

4855
class AddressTest {
4956
@Test
@@ -302,36 +309,105 @@ void addressLength() {
302309
}
303310

304311
@Test
305-
void getByName() throws UnknownHostException {
312+
void getByName() throws IOException {
306313
InetAddress out = Address.getByName("128.145.198.231");
307314
assertEquals("128.145.198.231", out.getHostAddress());
308315

316+
Name aRootServer = Name.fromString("a.root-servers.net.");
317+
Message aMessage = new Message();
318+
aMessage.getHeader().setRcode(Rcode.NOERROR);
319+
aMessage.addRecord(Record.newRecord(aRootServer, Type.A, DClass.IN), Section.QUESTION);
320+
aMessage.addRecord(
321+
new ARecord(
322+
aRootServer,
323+
DClass.IN,
324+
60,
325+
InetAddress.getByAddress(new byte[] {(byte) 198, 41, 0, 4})),
326+
Section.ANSWER);
327+
328+
Resolver mockResolver = Mockito.mock(Resolver.class);
329+
when(mockResolver.send(ArgumentMatchers.any(Message.class))).thenReturn(aMessage);
330+
Lookup.setDefaultResolver(mockResolver);
331+
309332
out = Address.getByName("a.root-servers.net");
310333
assertEquals("198.41.0.4", out.getHostAddress());
334+
335+
// reset resolver
336+
Lookup.refreshDefault();
311337
}
312338

313339
@Test
314-
void getByName_invalid() {
340+
void getByName_invalid() throws IOException {
341+
Message m = new Message();
342+
m.getHeader().setRcode(Rcode.NXDOMAIN);
343+
Resolver mockResolver = Mockito.mock(Resolver.class);
344+
when(mockResolver.send(ArgumentMatchers.any(Message.class))).thenReturn(m);
345+
Lookup.setDefaultResolver(mockResolver);
315346
assertThrows(UnknownHostException.class, () -> Address.getByName("example.invalid"));
347+
// reset resolver
348+
Lookup.refreshDefault();
349+
316350
assertThrows(UnknownHostException.class, () -> Address.getByName(""));
317351
}
318352

319353
@Test
320-
void getAllByName() throws UnknownHostException {
354+
void getAllByName() throws IOException {
321355
InetAddress[] out = Address.getAllByName("128.145.198.231");
322356
assertEquals(1, out.length);
323357
assertEquals("128.145.198.231", out[0].getHostAddress());
324358

359+
Name aRootServer = Name.fromString("a.root-servers.net.");
360+
Message aMessage = new Message();
361+
aMessage.getHeader().setRcode(Rcode.NOERROR);
362+
aMessage.addRecord(Record.newRecord(aRootServer, Type.A, DClass.IN), Section.QUESTION);
363+
aMessage.addRecord(
364+
new ARecord(
365+
aRootServer,
366+
DClass.IN,
367+
60,
368+
InetAddress.getByAddress(new byte[] {(byte) 198, 41, 0, 4})),
369+
Section.ANSWER);
370+
Message aaaaMessage = new Message();
371+
aaaaMessage.getHeader().setRcode(Rcode.NOERROR);
372+
aaaaMessage.addRecord(Record.newRecord(aRootServer, Type.AAAA, DClass.IN), Section.QUESTION);
373+
aaaaMessage.addRecord(
374+
new AAAARecord(
375+
aRootServer,
376+
DClass.IN,
377+
60,
378+
InetAddress.getByAddress(
379+
new byte[] {0x20, 1, 5, 3, (byte) 0xba, 0x3e, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0x30})),
380+
Section.ANSWER);
381+
Resolver mockResolver = Mockito.mock(Resolver.class);
382+
doReturn(aMessage)
383+
.when(mockResolver)
384+
.send(argThat(message -> message.getQuestion().getType() == Type.A));
385+
doReturn(aaaaMessage)
386+
.when(mockResolver)
387+
.send(argThat(message -> message.getQuestion().getType() == Type.AAAA));
388+
Lookup.setDefaultResolver(mockResolver);
389+
325390
out = Address.getAllByName("a.root-servers.net");
326391
assertEquals(2, out.length);
327392
assertEquals("198.41.0.4", out[0].getHostAddress());
328393
assertEquals("2001:503:ba3e:0:0:0:2:30", out[1].getHostAddress());
329394

395+
// reset resolver
396+
Lookup.refreshDefault();
330397
}
331398

332399
@Test
333-
void getAllByName_invalid() {
400+
void getAllByName_invalid() throws IOException {
401+
Message m = new Message();
402+
m.getHeader().setRcode(Rcode.NXDOMAIN);
403+
Resolver mockResolver = Mockito.mock(Resolver.class);
404+
when(mockResolver.send(ArgumentMatchers.any(Message.class))).thenReturn(m);
405+
Lookup.setDefaultResolver(mockResolver);
334406
assertThrows(UnknownHostException.class, () -> Address.getAllByName("example.invalid"));
407+
408+
// reset resolver
409+
Lookup.refreshDefault();
410+
335411
assertThrows(UnknownHostException.class, () -> Address.getAllByName(""));
336412
}
337413

@@ -343,12 +419,33 @@ void familyOf() throws UnknownHostException {
343419
}
344420

345421
@Test
346-
void getHostName() throws UnknownHostException {
422+
void getHostName() throws IOException {
423+
Name aRootServer = Name.fromString("a.root-servers.net.");
424+
Name aRootServerPtr = Name.fromString("4.0.41.198.in-addr.arpa.");
425+
Message ptrMessage = new Message();
426+
ptrMessage.getHeader().setRcode(Rcode.NOERROR);
427+
ptrMessage.addRecord(Record.newRecord(aRootServerPtr, Type.PTR, DClass.IN), Section.QUESTION);
428+
ptrMessage.addRecord(new PTRRecord(aRootServerPtr, DClass.IN, 60, aRootServer), Section.ANSWER);
429+
Resolver mockResolver = Mockito.mock(Resolver.class);
430+
when(mockResolver.send(any(Message.class))).thenReturn(ptrMessage);
431+
Lookup.setDefaultResolver(mockResolver);
432+
347433
String out = Address.getHostName(InetAddress.getByName("198.41.0.4"));
348434
assertEquals("a.root-servers.net.", out);
349435

436+
Message ptrMessage2 = new Message();
437+
ptrMessage.getHeader().setRcode(Rcode.NXDOMAIN);
438+
ptrMessage.addRecord(
439+
Record.newRecord(Name.fromString("1.1.168.192.in-addr.arpa."), Type.PTR, DClass.IN),
440+
Section.QUESTION);
441+
mockResolver = Mockito.mock(Resolver.class);
442+
when(mockResolver.send(any())).thenReturn(ptrMessage2);
443+
Lookup.setDefaultResolver(mockResolver);
350444
assertThrows(
351445
UnknownHostException.class,
352446
() -> Address.getHostName(InetAddress.getByName("192.168.1.1")));
447+
448+
// reset resolver
449+
Lookup.refreshDefault();
353450
}
354451
}

0 commit comments

Comments
 (0)