Mocking DNS

import static org.mockserver.model.DnsRequestDefinition.dnsRequest;
import static org.mockserver.model.DnsResponse.dnsResponse;
import static org.mockserver.model.DnsRecord.aRecord;
import static org.mockserver.model.DnsRecordType.A;

new MockServerClient("localhost", 1080)
    .when(
        dnsRequest("example.com", A)
    )
    .respondWithDns(
        dnsResponse()
            .withAnswerRecord(aRecord("example.com", "127.0.0.1"))
    );

var mockServerClient = require('mockserver-client').mockServerClient;
mockServerClient("localhost", 1080).respondWithDns(
    { dnsName: "example.com", dnsType: "A" },
    {
        answerRecords: [
            { name: "example.com", type: "A", value: "127.0.0.1" }
        ],
        responseCode: "NOERROR"
    }
).then(
    function () { console.log("expectation created"); },
    function (error) { console.log(error); }
);

See REST API for full JSON specification

Unlike the other tabs on this page, this JavaScript example only answers the first matching DNS query. respondWithDns (and every other respondWith... convenience method in the JS client) defaults its own times argument to { remainingTimes: 1, unlimited: false } when omitted — unlike the server's own default (unlimited) that the REST tab, Java, Python, Ruby, Go and .NET examples all get by leaving times out of the request entirely. Pass an explicit times argument (a number, or { unlimited: true }) as the third argument to match more than once: respondWithDns(requestMatcher, dnsResponse, { unlimited: true }).

from mockserver import MockServerClient, DnsRequestDefinition, DnsResponse, DnsRecord

client = MockServerClient("localhost", 1080)
client.when(
    DnsRequestDefinition.dns_request("example.com", dns_type="A")
).respond_with_dns(
    DnsResponse(
        answer_records=[DnsRecord.a_record("example.com", "127.0.0.1")],
        response_code="NOERROR"
    )
)

require 'mockserver-client'
include MockServer

client = MockServer::Client.new('localhost', 1080)
client.when(
  HttpRequest.dns_request('example.com', dns_type: 'A')
).respond_with_dns(
  DnsResponse.new(
    answer_records: [DnsRecord.a_record('example.com', '127.0.0.1')],
    response_code: 'NOERROR'
  )
)

import mockserver "github.com/mock-server/mockserver-monorepo/mockserver-client-go/v9"

client := mockserver.New("localhost", 1080)
client.Upsert(mockserver.Expectation{
    HttpRequest: &mockserver.HttpRequest{DnsName: "example.com", DnsType: "A"},
    DnsResponse: &mockserver.DnsResponse{
        ResponseCode:  "NOERROR",
        AnswerRecords: []mockserver.DnsRecord{mockserver.ARecord("example.com", "127.0.0.1")},
    },
})

The Go client's fluent Request() builder has no DNS-matcher setter yet, so the DNS fields are set directly on the exported HttpRequest struct and sent via Upsert instead of When(...).RespondDns(...).

using MockServer.Client;
using MockServer.Client.Models;

using var client = new MockServerClient("localhost", 1080);
client.When(
    new HttpRequest { DnsName = "example.com", DnsType = "A" }
).RespondWithDns(
    DnsResponse.Response()
        .WithResponseCode("NOERROR")
        .WithAnswerRecord(DnsRecord.ARecord("example.com", "127.0.0.1"))
);

curl -v -X PUT "http://localhost:1080/mockserver/expectation" -d '{
  "httpRequest": {
    "dnsName": "example.com",
    "dnsType": "A"
  },
  "dnsResponse": {
    "answerRecords": [
      { "name": "example.com", "type": "A", "value": "127.0.0.1" }
    ],
    "responseCode": "NOERROR"
  }
}'