There are a couple of things going on here. First, MockWebServer.url() resolves the given url against the mock server's base url, it does not set the url. If you want to set the url, you'll need to pass it to the start() method. Generally, you configure your retrofit to call the server's endpoint --

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl(server.url("/"))
    // Other builder methods.
    .build();

Second, to get responses from the mock web server, you need to enqueue the expected responses as MockResponses. Otherwise it doesn't know what to send back. Do something like the following before making your request --

server.enqueue(new MockResponse().setBody("Success!"));

You'll need to build your response to mirror the expected response.

See the README for some more examples.

Using Dispatcher

        Dispatcher dispatcher = new Dispatcher() {
            @Override
            public MockResponse dispatch(RecordedRequest request) {
                switch (request.getPath()) {
                    case "/get":
                        return new MockResponse().setResponseCode(200).setBody("test");
                }
                return new MockResponse().setResponseCode(404);
            }
        };

        mockBackEnd.setDispatcher(dispatcher);

Above can be written inside your test method. You can have a bunch of URLs conditions there.

The mockwebserver can be started once like:

   public static MockWebServer mockBackEnd;

    @BeforeAll
    static void setUp() throws IOException {
        mockBackEnd = new MockWebServer();
        mockBackEnd.start();
    }


    @AfterAll
    static void tearDown() throws IOException {
        mockBackEnd.shutdown();
    }

Use @DynamicPropertySource to change any property with mockserver host/port.

You could implement a Dispatcher where you add actions to a list, each with a predicate to match the request. Once an action has matched you discard it so the next action can be applied.

public class MyDispatcher implements Dispatcher {
   public static class MyDispatcherEntry {
      private Predicate<RecordedRequest> predicate;
      private Function<RecordedRequest, MockResponse> action;

      // TODO constructor
   }

   private final List<MyDispatcherEntry> entries = new LinkedList<>();

   public void enqueue(String path, MockResponse response) {
      enqueue(req -> req.getPath().equals(path), req -> response);
   }

   public void enqueue(
      Predicate<RecordedRequest> predicate, 
      Function<RecordedRequest, MockResponse> action
   ) {
      entries.add(new MyDispatcherEntry(predicate, action));
   }

   public MockResponse dispatch(RecordedRequest req) {
      for (Iterator<MyDispatcherEntry> it = entries.iterator(); it.hasNext(); ) {
         MyDispatcherEntry entry = it.next();
         if (entry.predicate.test(req)) {
            it.remove(); // discard this action so another can match next time
            return entry.action.apply(req);
         }
      }
      throw new RuntimeException("No matching entries for " + req);
   }

}

Usage

MyDispatcher dispatcher = new MyDispatcher();
dispatcher.enqueue("/query1", new MockResponse().setResponseCode(200).setBody(...));
dispatcher.enqueue("/query2", new MockResponse().setResponseCode(200).setBody(...));
dispatcher.enqueue("/query3", new MockResponse().setResponseCode(502));
dispatcher.enqueue("/query3", new MockResponse().setResponseCode(502));
dispatcher.enqueue("/query3", new MockResponse().setResponseCode(200).setBody(...));

From their documentation

By default MockWebServer uses a queue to specify a series of responses. Use a Dispatcher to handle requests using another policy. One natural policy is to dispatch on the request path. You can, for example, filter the request instead of using server.enqueue()

What you can do is this make changes in the code below.

final Dispatcher dispatcher = new Dispatcher() {

    @Override
    public MockResponse dispatch (RecordedRequest request) throws InterruptedException {

        switch (request.getPath()) {
            case "/v1/login/auth/":
                return new MockResponse().setResponseCode(200);
            case "v1/check/version/":
                return new MockResponse().setResponseCode(200).setBody("version=9");
            case "/v1/profile/info":
                return new MockResponse().setResponseCode(200).setBody("{\\\"info\\\":{\\\"name\":\"Lucas Albuquerque\",\"age\":\"21\",\"gender\":\"male\"}}");
        }
        return new MockResponse().setResponseCode(404);
    }
};
server.setDispatcher(dispatcher);

They use a switch statement on path but you can change it and implement your custom logic in here.

To handle the sequence of responses I have written a dispatcher for my MockServer instance. It receives a request, checks it's URL's endpoint and returns corresponding response

Dispatcher mDispatcher = new Dispatcher() {
    @Override
    public MockResponse dispatch(RecordedRequest request) {
         if (request.getPath().contains("/request1")) {
             return new MockResponse().setBody("reponse1");
         }
         if (request.getPath().contains("/request2")) {
             return new MockResponse().setBody("reponse2");
         }
         return new MockResponse().setResponseCode(404);
       }
     }
 mMockServer.setDispatcher(mDispatcher);