// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

package org.chromium.chrome.browser.media.router.caf;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyDouble;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.inOrder;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;

import com.google.android.gms.cast.ApplicationMetadata;
import com.google.android.gms.cast.CastDevice;
import com.google.android.gms.cast.framework.CastSession;
import com.google.android.gms.common.api.Status;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.robolectric.annotation.Config;

import org.chromium.base.test.BaseRobolectricTestRunner;
import org.chromium.chrome.browser.media.router.CastSessionUtil;
import org.chromium.chrome.browser.media.router.ClientRecord;
import org.chromium.chrome.browser.media.router.JSONTestUtils.JSONObjectLike;
import org.chromium.chrome.browser.media.router.JSONTestUtils.JSONStringLike;
import org.chromium.chrome.browser.media.router.MediaSink;
import org.chromium.chrome.browser.media.router.caf.CafMessageHandler.RequestRecord;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Robolectric tests for CastSession.
 */
@RunWith(BaseRobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class CafMessageHandlerTest {
    private static final String TAG = "MediaRouter";

    private static final String SESSION_ID = "SESSION_ID";
    private static final String INVALID_SESSION_ID = "INVALID_SESSION_ID";
    private static final String CLIENT_ID1 = "client-id-1";
    private static final String CLIENT_ID2 = "client-id-2";
    private static final String INVALID_CLIENT_ID = "xxxxxxxxxxxxxxxxx";
    private static final String NAMESPACE1 = "namespace1";
    private static final String NAMESPACE2 = "namespace2";
    private static final String MEDIA_NAMESPACE = CastSessionUtil.MEDIA_NAMESPACE;
    private static final int SEQUENCE_NUMBER1 = 1;
    private static final int SEQUENCE_NUMBER2 = 2;
    private static final int REQUEST_ID1 = 1;
    private static final int REQUEST_ID2 = 2;
    private static final int VOID_SEQUENCE_NUMBER = CafMessageHandler.VOID_SEQUENCE_NUMBER;
    private CafMediaRouteProvider mRouteProvider;
    @Mock
    private CastSession mSession;
    @Mock
    private CastSessionController mSessionController;
    private ClientRecord mClientRecord1;
    private ClientRecord mClientRecord2;
    private Map<String, ClientRecord> mClientRecordMap;
    private CafMessageHandler mMessageHandler;
    private int mNumStopApplicationCalled;

    private interface CheckedRunnable { void run() throws Exception; }

    @Before
    public void setUp() {
        MockitoAnnotations.initMocks(this);
        mRouteProvider = mock(CafMediaRouteProvider.class);
        mClientRecord1 =
                new ClientRecord("route-id-1", CLIENT_ID1, "app-id", "auto-join", "origin", 1);
        mClientRecord2 =
                new ClientRecord("route-id-2", CLIENT_ID2, "app-id", "auto-join", "origin2", 1);

        mMessageHandler = spy(new CafMessageHandler(mRouteProvider, mSessionController));

        doReturn(SESSION_ID).when(mSessionController).getSessionId();
        doReturn(true)
                .when(mMessageHandler)
                .sendStringCastMessage(anyString(), anyString(), anyString(), anyInt());
        doReturn(mSession).when(mSessionController).getSession();
        doReturn(true).when(mSessionController).isConnected();
        doReturn(SESSION_ID).when(mSessionController).getSessionId();

        mClientRecordMap = new HashMap<>();

        mClientRecordMap.put(CLIENT_ID1, mClientRecord1);
        mClientRecordMap.put(CLIENT_ID2, mClientRecord2);
        doReturn(mClientRecordMap).when(mRouteProvider).getClientIdToRecords();
        doNothing().when(mRouteProvider).sendMessageToClient(anyString(), anyString());
    }

    void setUpForAppMessageTest() throws JSONException {
        List<String> namespaces = new ArrayList<String>();
        namespaces.add(NAMESPACE1);
        doReturn(namespaces).when(mSessionController).getNamespaces();
        doReturn(true)
                .when(mMessageHandler)
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testOnSessionStarted() {
        doReturn("session_message").when(mMessageHandler).buildSessionMessage();
        // The call in setUp() actually only sets the session. This call will notify the clients
        // that have sent "client_connect"
        mClientRecord1.isConnected = true;

        mMessageHandler.onSessionStarted();

        verify(mMessageHandler)
                .sendEnclosedMessageToClient(
                        CLIENT_ID1, "new_session", "session_message", VOID_SEQUENCE_NUMBER);
        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(eq(CLIENT_ID2), anyString(), anyString(), anyInt());
    }

    @Test
    public void testHandleClientConnectMessage_sessionConnected() throws JSONException {
        doReturn("session_message").when(mMessageHandler).buildSessionMessage();
        mClientRecord1.isConnected = false;
        JSONObject message = new JSONObject();
        message.put("type", "client_connect");
        message.put("clientId", mClientRecord1.clientId);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        assertTrue(mClientRecord1.isConnected);
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(mClientRecord1.clientId, "new_session",
                        "session_message", VOID_SEQUENCE_NUMBER);
        verify(mRouteProvider).flushPendingMessagesToClient(mClientRecord1);
    }

    @Test
    public void testHandleClientConnectMessage_sessionNotConnected() throws JSONException {
        doReturn("session_message").when(mMessageHandler).buildSessionMessage();
        doReturn(false).when(mSessionController).isConnected();
        mClientRecord1.isConnected = false;
        JSONObject message = new JSONObject();
        message.put("type", "client_connect");
        message.put("clientId", mClientRecord1.clientId);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        assertTrue(mClientRecord1.isConnected);
        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        verify(mRouteProvider).flushPendingMessagesToClient(mClientRecord1);
    }

    @Test
    public void testHandleClientConnectMessage_noClientRecord() throws JSONException {
        doReturn("session_message").when(mMessageHandler).buildSessionMessage();
        JSONObject message = new JSONObject();
        message.put("type", "client_connect");
        message.put("clientId", "other-client-id");

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        verify(mRouteProvider, never()).flushPendingMessagesToClient(any(ClientRecord.class));
    }

    @Test
    public void testHandleClientConnectMessage_noClientId() throws JSONException {
        doReturn("session_message").when(mMessageHandler).buildSessionMessage();
        JSONObject message = new JSONObject();
        message.put("type", "client_connect");

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        verify(mRouteProvider, never()).flushPendingMessagesToClient(any(ClientRecord.class));
    }

    @Test
    public void testHandleClientDisconnectMessage() throws JSONException {
        JSONObject message = new JSONObject();
        message.put("type", "client_disconnect");
        message.put("clientId", mClientRecord1.clientId);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider).removeRoute("route-id-1", null);
    }

    @Test
    public void testHandleClientDisconnectMessage_noClientRecord() throws JSONException {
        JSONObject message = new JSONObject();
        message.put("type", "client_disconnect");
        message.put("clientId", "other-client-id");

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider, never()).removeRoute(anyString(), anyString());
    }

    @Test
    public void testHandleClientDisconnectMessage_noClientId() throws JSONException {
        JSONObject message = new JSONObject();
        message.put("type", "client_disconnect");

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider, never()).removeRoute(anyString(), anyString());
    }

    @Test
    public void testHandleClientLeaveSessionMessage() throws JSONException {
        JSONObject message = buildLeaveSessionMessage(mClientRecord1.clientId, SESSION_ID, 12345);
        ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider)
                .sendMessageToClient(eq(mClientRecord1.clientId), messageCaptor.capture());
        JSONObject capturedMessage = new JSONObject(messageCaptor.getValue());
        verifySimpleSessionMessage(
                capturedMessage, "leave_session", 12345, mClientRecord1.clientId);
    }

    @Test
    public void testHandleClientLeaveSessionMessage_noSequenceNumber() throws JSONException {
        JSONObject message = buildLeaveSessionMessage(mClientRecord1.clientId, SESSION_ID, 12345);
        message.remove("sequenceNumber");
        ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider)
                .sendMessageToClient(eq(mClientRecord1.clientId), messageCaptor.capture());
        JSONObject capturedMessage = new JSONObject(messageCaptor.getValue());
        verifySimpleSessionMessage(
                capturedMessage, "leave_session", VOID_SEQUENCE_NUMBER, mClientRecord1.clientId);
    }

    @Test
    public void testHandleClientLeaveSessionMessage_noClientRecord() throws JSONException {
        JSONObject message = buildLeaveSessionMessage("other-client-id", SESSION_ID, 12345);

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider, never()).sendMessageToClient(anyString(), anyString());
    }

    @Test
    public void testHandleClientLeaveSessionMessage_wrongSessionId() throws JSONException {
        JSONObject message =
                buildLeaveSessionMessage(mClientRecord1.clientId, "other-session-id", 12345);

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider, never()).sendMessageToClient(anyString(), anyString());
    }

    @Test
    public void testHandleClientLeaveSessionMessage_sessionNotConnected() throws JSONException {
        doReturn(false).when(mSessionController).isConnected();
        JSONObject message = buildLeaveSessionMessage(mClientRecord1.clientId, SESSION_ID, 12345);

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider, never()).sendMessageToClient(anyString(), anyString());
    }

    @Test
    public void testHandleClientLeaveSessionMessage_noClientId() throws JSONException {
        JSONObject message = buildLeaveSessionMessage(mClientRecord1.clientId, SESSION_ID, 12345);
        message.remove("clientId");

        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));

        verify(mRouteProvider, never()).sendMessageToClient(anyString(), anyString());
    }

    @Test
    public void testHandleClientLeaveSessionMessage_removeRoutes_tabAndOriginScoped()
            throws JSONException {
        mClientRecordMap.clear();

        prepareClientRecord(
                "route-id-1", "client-id-1", "app-id", "tab_and_origin_scoped", "origin", 1);
        prepareClientRecord("route-id-2", "client-id-2", "app-id", "auto-join", "origin", 1);
        prepareClientRecord("route-id-3", "client-id-3", "app-id", "auto-join", "origin2", 1);
        prepareClientRecord("route-id-4", "client-id-4", "app-id", "auto-join", "origin", 2);

        JSONObject message = buildLeaveSessionMessage("client-id-1", SESSION_ID, 12345);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        // Only routes with same origin and tab ID will be removed.
        verify(mRouteProvider).removeRoute("route-id-1", null);
        verify(mRouteProvider).removeRoute("route-id-2", null);
        verify(mRouteProvider, never()).removeRoute("route-id-3", null);
        verify(mRouteProvider, never()).removeRoute("route-id-4", null);
    }

    @Test
    public void testHandleClientLeaveSessionMessage_removeRoutes_originScoped()
            throws JSONException {
        prepareClientRecord("route-id-1", "client-id-1", "app-id", "origin_scoped", "origin", 1);
        prepareClientRecord("route-id-2", "client-id-2", "app-id", "auto-join", "origin", 1);
        prepareClientRecord("route-id-3", "client-id-3", "app-id", "auto-join", "origin2", 1);
        prepareClientRecord("route-id-4", "client-id-4", "app-id", "auto-join", "origin", 2);

        JSONObject message = buildLeaveSessionMessage("client-id-1", SESSION_ID, 12345);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        // Only routes with same origin will be removed.
        verify(mRouteProvider).removeRoute("route-id-1", null);
        verify(mRouteProvider).removeRoute("route-id-2", null);
        verify(mRouteProvider, never()).removeRoute("route-id-3", null);
        verify(mRouteProvider).removeRoute("route-id-4", null);
    }

    @Test
    public void testHandleClientLeaveSessionMessage_removeRoutes_otherScoped()
            throws JSONException {
        prepareClientRecord("route-id-1", "client-id-1", "app-id", "other_scoped", "origin", 1);
        prepareClientRecord("route-id-2", "client-id-2", "app-id", "auto-join", "origin", 1);
        prepareClientRecord("route-id-3", "client-id-3", "app-id", "auto-join", "origin2", 1);
        prepareClientRecord("route-id-4", "client-id-4", "app-id", "auto-join", "origin", 2);

        JSONObject message = buildLeaveSessionMessage("client-id-1", SESSION_ID, 12345);

        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

        // No route should be removed.
        verify(mRouteProvider, never()).removeRoute(anyString(), anyString());
    }

    @Test
    public void testHandleSessionMessageOfV2MessageType() throws JSONException {
        doReturn(true).when(mMessageHandler).handleCastV2MessageFromClient(any(JSONObject.class));

        JSONObject message = new JSONObject();
        message.put("type", "v2_message");
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler).handleCastV2MessageFromClient(argThat(new JSONObjectLike(message)));
    }

    @Test
    public void testHandleSessionMessageOfAppMessageType() throws JSONException {
        doReturn(true).when(mMessageHandler).handleAppMessageFromClient(any(JSONObject.class));

        JSONObject message = new JSONObject();
        message.put("type", "app_message");
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler).handleAppMessageFromClient(argThat(new JSONObjectLike(message)));
    }

    @Test
    public void testHandleSessionMessageOfUnsupportedType() throws JSONException {
        doReturn(true).when(mMessageHandler).handleCastV2MessageFromClient(any(JSONObject.class));

        JSONObject message = new JSONObject();
        message.put("type", "unsupported");
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never()).handleCastV2MessageFromClient(any(JSONObject.class));
        verify(mMessageHandler, never()).handleAppMessageFromClient(any(JSONObject.class));
    }

    @Test
    public void testCastV2MessageWithWrongTypeInnerMessage() throws JSONException {
        org.robolectric.shadows.ShadowLog.stream = System.out;
        JSONObject innerMessage = new JSONObject().put("type", "STOP");
        final JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
        // Replace the inner JSON message with string.
        message.put("message", "wrong type inner message");
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never()).handleStopMessage(anyString(), anyInt());
        verify(mMessageHandler, never())
                .handleVolumeMessage(any(JSONObject.class), anyString(), anyInt());
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testCastV2MessageOfStopType() throws JSONException {
        JSONObject innerMessage = new JSONObject().put("type", "STOP");
        JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler).handleStopMessage(eq(CLIENT_ID1), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testCastV2MessageofSetVolumeTypeShouldWait() throws Exception {
        doReturn(true).when(mSession).isMute();
        JSONObject innerMessage =
                new JSONObject()
                        .put("type", "SET_VOLUME")
                        .put("volume",
                                new JSONObject().put("level", (double) 1).put("muted", false));
        JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        JSONObject volumeMessage = innerMessage.getJSONObject("volume");
        verify(mSession).setMute(false);
        verify(mSession).setVolume(1.0);
        verify(mMessageHandler)
                .handleVolumeMessage(
                        argThat(new JSONObjectLike(innerMessage.getJSONObject("volume"))),
                        eq(CLIENT_ID1), eq(SEQUENCE_NUMBER1));
        assertEquals(mMessageHandler.getVolumeRequestsForTest().size(), 1);
    }

    @Test
    public void testCastV2MessageofSetVolumeTypeShouldNotWait() throws Exception {
        doReturn(false).when(mSession).isMute();
        doReturn(1.0).when(mSession).getVolume();
        JSONObject innerMessage =
                new JSONObject()
                        .put("type", "SET_VOLUME")
                        .put("volume",
                                new JSONObject().put("level", (double) 1).put("muted", false));
        JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        JSONObject volumeMessage = innerMessage.getJSONObject("volume");
        verify(mSession, never()).setMute(anyBoolean());
        verify(mSession, never()).setVolume(anyDouble());
        verify(mMessageHandler)
                .handleVolumeMessage(
                        argThat(new JSONObjectLike(innerMessage.getJSONObject("volume"))),
                        eq(CLIENT_ID1), eq(SEQUENCE_NUMBER1));
        assertEquals(mMessageHandler.getVolumeRequestsForTest().size(), 0);
    }

    @Test
    public void testCastV2MessageofSetVolumeTypeWithNullVolumeMessage() throws JSONException {
        JSONObject innerMessage = new JSONObject().put("type", "SET_VOLUME");
        final JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .handleVolumeMessage(any(JSONObject.class), anyString(), anyInt());
    }

    @Test
    public void testCastV2MessageofSetVolumeTypeWithWrongTypeVolumeMessage() throws JSONException {
        JSONObject innerMessage = new JSONObject()
                                          .put("type", "SET_VOLUME")
                                          .put("volume", "wrong type volume message");
        final JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .handleVolumeMessage(any(JSONObject.class), anyString(), anyInt());
    }

    @Test
    public void testCastV2MessageOfMediaMessageType() throws JSONException {
        doReturn(true)
                .when(mMessageHandler)
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
        for (String messageType : CafMessageHandler.getMediaMessageTypesForTest()) {
            // TODO(zqzhang): SET_VOLUME and STOP should not reach here?
            if ("MEDIA_SET_VOLUME".equals(messageType) || "STOP_MEDIA".equals(messageType)) {
                continue;
            }
            JSONObject innerMessage = new JSONObject().put("type", messageType);
            JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
            assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));

            JSONObject expected = new JSONObject();
            if (CafMessageHandler.getMediaOverloadedMessageTypesForTest().containsKey(
                        messageType)) {
                expected.put("type",
                        CafMessageHandler.getMediaOverloadedMessageTypesForTest().get(messageType));
            } else {
                expected.put("type", messageType);
            }
            verify(mMessageHandler)
                    .sendJsonCastMessage(argThat(new JSONObjectLike(expected)),
                            eq(CastSessionUtil.MEDIA_NAMESPACE), eq(CLIENT_ID1),
                            eq(SEQUENCE_NUMBER1));
        }
    }

    @Test
    public void testCastV2MessageWithNullSequenceNumber() throws JSONException {
        JSONObject innerMessage = new JSONObject().put("type", "STOP");
        JSONObject message = buildCastV2Message(CLIENT_ID1, innerMessage);
        message.remove("sequenceNumber");
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler).handleStopMessage(eq(CLIENT_ID1), eq(VOID_SEQUENCE_NUMBER));
    }

    @Test
    public void testHandleStopMessage() throws JSONException {
        InOrder inOrder = inOrder(mSessionController);
        assertEquals(0, mMessageHandler.getStopRequestsForTest().size());
        mMessageHandler.handleStopMessage(CLIENT_ID1, SEQUENCE_NUMBER1);
        assertEquals(1, mMessageHandler.getStopRequestsForTest().get(CLIENT_ID1).size(), 1);
        inOrder.verify(mSessionController).endSession();
        mMessageHandler.handleStopMessage(CLIENT_ID1, SEQUENCE_NUMBER2);
        assertEquals(2, mMessageHandler.getStopRequestsForTest().get(CLIENT_ID1).size(), 2);
        inOrder.verify(mSessionController).endSession();
    }

    @Test
    public void testAppMessageWithExistingNamespace() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler)
                .sendJsonCastMessage(argThat(new JSONObjectLike(actualMessage)), eq(NAMESPACE1),
                        eq(CLIENT_ID1), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testAppMessageWithNonexistingNamespace() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE2, actualMessage);
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithoutSequenceNumber() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.remove("sequenceNumber");
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler)
                .sendJsonCastMessage(argThat(new JSONObjectLike(actualMessage)), eq(NAMESPACE1),
                        eq(CLIENT_ID1), eq(VOID_SEQUENCE_NUMBER));
    }

    @Test
    public void testAppMessageWithNullSessionId() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        final JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.getJSONObject("message").remove("sessionId");
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithWrongSessionId() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.getJSONObject("message").put("sessionId", INVALID_SESSION_ID);
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithNullActualMessage() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        final JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.getJSONObject("message").remove("message");
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithStringMessage() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.getJSONObject("message").put("message", "string message");
        assertTrue(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
        verify(mMessageHandler)
                .sendStringCastMessage(
                        eq("string message"), eq(NAMESPACE1), eq(CLIENT_ID1), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testAppMessageWithNullAppMessage() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        final JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.remove("message");
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithEmptyAppMessage() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        final JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.put("message", new JSONObject());
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithWrongTypeAppMessage() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        final JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.put("message", "wrong type app message");
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithNullClient() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        final JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.remove("clientId");
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testAppMessageWithNonexistingClient() throws JSONException {
        setUpForAppMessageTest();

        JSONObject actualMessage = buildActualAppMessage();
        JSONObject message = buildAppMessage(CLIENT_ID1, NAMESPACE1, actualMessage);
        message.put("clientId", INVALID_CLIENT_ID);
        assertFalse(mMessageHandler.handleMessageFromClient(message.toString()));
        verify(mMessageHandler, never())
                .sendJsonCastMessage(any(JSONObject.class), anyString(), anyString(), anyInt());
    }

    @Test
    public void testSendJsonCastMessage() throws JSONException {
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        JSONObject message = buildJsonCastMessage("message");
        assertTrue(mMessageHandler.sendJsonCastMessage(
                message, NAMESPACE1, CLIENT_ID1, SEQUENCE_NUMBER1));
        assertEquals(mMessageHandler.getRequestsForTest().size(), 1);
        verify(mMessageHandler)
                .sendStringCastMessage(
                        argThat(new JSONStringLike(message)), anyString(), anyString(), anyInt());
    }

    @Test
    public void testSendJsonCastMessageWhileDisconnected() throws JSONException {
        doReturn(false).when(mSessionController).isConnected();

        JSONObject message = buildJsonCastMessage("message");
        assertFalse(mMessageHandler.sendJsonCastMessage(
                message, NAMESPACE1, CLIENT_ID1, SEQUENCE_NUMBER1));
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        verify(mMessageHandler, never())
                .sendStringCastMessage(anyString(), anyString(), anyString(), anyInt());
    }

    @Test
    public void testSendJsonCastMessageWithInvalidSequenceNumber() throws JSONException {
        JSONObject message = buildJsonCastMessage("message");
        assertTrue(mMessageHandler.sendJsonCastMessage(
                message, NAMESPACE1, CLIENT_ID1, VOID_SEQUENCE_NUMBER));
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        verify(mMessageHandler)
                .sendStringCastMessage(
                        argThat(new JSONStringLike(message)), anyString(), anyString(), anyInt());
    }

    @Test
    public void testSendJsonCastMessageWithNullRequestId() throws JSONException {
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        JSONObject message = buildJsonCastMessage("message");
        message.remove("requestId");
        assertTrue(mMessageHandler.sendJsonCastMessage(
                message, NAMESPACE1, CLIENT_ID1, SEQUENCE_NUMBER1));
        assertTrue(message.has("requestId"));
        assertEquals(mMessageHandler.getRequestsForTest().size(), 1);
        verify(mMessageHandler)
                .sendStringCastMessage(
                        argThat(new JSONStringLike(message)), anyString(), anyString(), anyInt());
    }

    @Test
    public void testOnMessageReceivedWithExistingRequestId() throws JSONException {
        doNothing()
                .when(mMessageHandler)
                .onAppMessage(anyString(), anyString(), any(RequestRecord.class));
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        RequestRecord request = new RequestRecord(CLIENT_ID1, SEQUENCE_NUMBER1);
        mMessageHandler.getRequestsForTest().append(REQUEST_ID1, request);
        assertEquals(mMessageHandler.getRequestsForTest().size(), 1);
        JSONObject message = new JSONObject();
        message.put("requestId", REQUEST_ID1);
        mMessageHandler.onMessageReceived(NAMESPACE1, message.toString());
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        verify(mMessageHandler).onAppMessage(eq(message.toString()), eq(NAMESPACE1), eq(request));
    }

    @Test
    public void testOnMessageReceivedWithNonexistingRequestId() throws JSONException {
        doNothing()
                .when(mMessageHandler)
                .onAppMessage(anyString(), anyString(), any(RequestRecord.class));
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        RequestRecord request = new RequestRecord(CLIENT_ID1, SEQUENCE_NUMBER1);
        mMessageHandler.getRequestsForTest().append(REQUEST_ID1, request);
        assertEquals(mMessageHandler.getRequestsForTest().size(), 1);
        JSONObject message = new JSONObject();
        message.put("requestId", REQUEST_ID2);
        mMessageHandler.onMessageReceived(NAMESPACE1, message.toString());
        assertEquals(mMessageHandler.getRequestsForTest().size(), 1);
        verify(mMessageHandler)
                .onAppMessage(eq(message.toString()), eq(NAMESPACE1), (RequestRecord) isNull());
    }

    @Test
    public void testOnMessageReceivedWithoutRequestId() throws JSONException {
        doNothing()
                .when(mMessageHandler)
                .onAppMessage(anyString(), anyString(), any(RequestRecord.class));
        assertEquals(mMessageHandler.getRequestsForTest().size(), 0);
        RequestRecord request = new RequestRecord(CLIENT_ID1, SEQUENCE_NUMBER1);
        mMessageHandler.getRequestsForTest().append(REQUEST_ID1, request);
        assertEquals(mMessageHandler.getRequestsForTest().size(), 1);
        JSONObject message = new JSONObject();
        mMessageHandler.onMessageReceived(NAMESPACE1, message.toString());
        assertEquals(mMessageHandler.getRequestsForTest().size(), 1);
        verify(mMessageHandler)
                .onAppMessage(eq(message.toString()), eq(NAMESPACE1), (RequestRecord) isNull());
    }

    @Test
    public void testOnMessageReceivedOfMediaNamespace() throws JSONException {
        doNothing().when(mMessageHandler).onMediaMessage(anyString(), any(RequestRecord.class));
        mMessageHandler.onMessageReceived(MEDIA_NAMESPACE, "anymessage");
        verify(mMessageHandler).onMediaMessage(eq("anymessage"), (RequestRecord) isNull());
    }

    @Test
    public void testOnMediaMessageOfMediaStatusTypeWithRequestRecord() {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        doReturn(true).when(mMessageHandler).isMediaStatusMessage(anyString());
        RequestRecord request = new RequestRecord(CLIENT_ID1, SEQUENCE_NUMBER1);
        mMessageHandler.onMediaMessage("anymessage", request);
        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(eq(CLIENT_ID1), eq("v2_message"), eq("anymessage"),
                        eq(VOID_SEQUENCE_NUMBER));
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(eq(CLIENT_ID2), eq("v2_message"), eq("anymessage"),
                        eq(VOID_SEQUENCE_NUMBER));
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(
                        eq(CLIENT_ID1), eq("v2_message"), eq("anymessage"), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testOnMediaMessageOfMediaStatusTypeWithNullRequestRecord() {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        doReturn(true).when(mMessageHandler).isMediaStatusMessage(anyString());
        mMessageHandler.onMediaMessage("anymessage", null);
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(eq(CLIENT_ID1), eq("v2_message"), eq("anymessage"),
                        eq(VOID_SEQUENCE_NUMBER));
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(eq(CLIENT_ID2), eq("v2_message"), eq("anymessage"),
                        eq(VOID_SEQUENCE_NUMBER));
    }

    @Test
    public void testOnMediaMessageOfNonMediaStatusTypeWithRequestRecord() {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        doReturn(false).when(mMessageHandler).isMediaStatusMessage(anyString());
        RequestRecord request = new RequestRecord(CLIENT_ID1, SEQUENCE_NUMBER1);
        mMessageHandler.onMediaMessage("anymessage", request);
        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(
                        anyString(), anyString(), anyString(), eq(VOID_SEQUENCE_NUMBER));
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(
                        eq(CLIENT_ID1), eq("v2_message"), eq("anymessage"), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testOnMediaMessageOfNonMediaStatusTypeWithNullRequestRecord() {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        doReturn(false).when(mMessageHandler).isMediaStatusMessage(anyString());
        mMessageHandler.onMediaMessage("anymessage", null);
        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(
                        anyString(), anyString(), anyString(), eq(VOID_SEQUENCE_NUMBER));
        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
    }

    @Test
    public void testOnAppMessageWithRequestRecord() throws JSONException {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        RequestRecord request = new RequestRecord(CLIENT_ID1, SEQUENCE_NUMBER1);
        mMessageHandler.onAppMessage("anyMessage", NAMESPACE1, request);
        JSONObject expected = new JSONObject();
        expected.put("sessionId", SESSION_ID);
        expected.put("namespaceName", NAMESPACE1);
        expected.put("message", "anyMessage");
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(eq(CLIENT_ID1), eq("app_message"),
                        argThat(new JSONStringLike(expected)), eq(SEQUENCE_NUMBER1));
        verify(mMessageHandler, never()).broadcastClientMessage(anyString(), anyString());
    }

    @Test
    public void testOnAppMessageWithNullRequestRecord() throws JSONException {
        doNothing().when(mMessageHandler).broadcastClientMessage(anyString(), anyString());
        mMessageHandler.onAppMessage("anyMessage", NAMESPACE1, null);
        JSONObject expected = new JSONObject();
        expected.put("sessionId", SESSION_ID);
        expected.put("namespaceName", NAMESPACE1);
        expected.put("message", "anyMessage");
        verify(mMessageHandler, never())
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        verify(mMessageHandler)
                .broadcastClientMessage(eq("app_message"), argThat(new JSONStringLike(expected)));
    }

    @Test
    public void testOnSessionEnded() {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        assertEquals(0, mMessageHandler.getStopRequestsForTest().size());
        mMessageHandler.getStopRequestsForTest().put(CLIENT_ID1, new ArrayDeque<Integer>());
        mMessageHandler.getStopRequestsForTest().get(CLIENT_ID1).add(SEQUENCE_NUMBER1);
        mMessageHandler.getStopRequestsForTest().get(CLIENT_ID1).add(SEQUENCE_NUMBER2);
        assertEquals(1, mMessageHandler.getStopRequestsForTest().size());
        assertEquals(2, mMessageHandler.getStopRequestsForTest().get(CLIENT_ID1).size());

        mMessageHandler.onSessionEnded();
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(
                        eq(CLIENT_ID1), eq("remove_session"), eq(SESSION_ID), eq(SEQUENCE_NUMBER1));
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(
                        eq(CLIENT_ID1), eq("remove_session"), eq(SESSION_ID), eq(SEQUENCE_NUMBER2));
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(eq(CLIENT_ID2), eq("remove_session"), eq(SESSION_ID),
                        eq(VOID_SEQUENCE_NUMBER));
    }

    @Test
    public void testOnVolumeChanged() {
        doNothing().when(mMessageHandler).onVolumeChanged(anyString(), anyInt());
        assertEquals(0, mMessageHandler.getVolumeRequestsForTest().size());
        mMessageHandler.getVolumeRequestsForTest().add(
                new RequestRecord(CLIENT_ID1, SEQUENCE_NUMBER1));
        assertEquals(1, mMessageHandler.getVolumeRequestsForTest().size());

        mMessageHandler.onVolumeChanged();
        verify(mMessageHandler).onVolumeChanged(CLIENT_ID1, SEQUENCE_NUMBER1);
        assertEquals(0, mMessageHandler.getVolumeRequestsForTest().size());
    }

    @Test
    public void testOnVolumeChangedWithEmptyVolumeRequests() {
        mMessageHandler.onVolumeChanged();
        verify(mMessageHandler, never()).onVolumeChanged(eq(CLIENT_ID1), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testOnVolumeChangedForClient() {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        mMessageHandler.onVolumeChanged(CLIENT_ID1, SEQUENCE_NUMBER1);
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(
                        eq(CLIENT_ID1), eq("v2_message"), (String) isNull(), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testOnAppMessageSent() {
        Status mockResult = mock(Status.class);
        doReturn(true).when(mockResult).isSuccess();
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        mMessageHandler.onSendAppMessageResult(mockResult, CLIENT_ID1, SEQUENCE_NUMBER1);
        verify(mMessageHandler)
                .sendEnclosedMessageToClient(
                        eq(CLIENT_ID1), eq("app_message"), (String) isNull(), eq(SEQUENCE_NUMBER1));
    }

    @Test
    public void testSendEnclosedMessageToClient() throws JSONException {
        String message = "dontcare_message1";
        doReturn(message)
                .when(mMessageHandler)
                .buildEnclosedClientMessage(anyString(), anyString(), anyString(), anyInt());
        mMessageHandler.sendEnclosedMessageToClient(
                CLIENT_ID1, "anytype", "dontcare_message2", SEQUENCE_NUMBER1);

        verify(mRouteProvider).sendMessageToClient(eq(CLIENT_ID1), eq(message));
    }

    @Test
    public void testBroadcastClientMessage() {
        doNothing()
                .when(mMessageHandler)
                .sendEnclosedMessageToClient(anyString(), anyString(), anyString(), anyInt());
        mMessageHandler.broadcastClientMessage("anytype", "anymessage");
        for (String clientId : mRouteProvider.getClientIdToRecords().keySet()) {
            verify(mMessageHandler)
                    .sendEnclosedMessageToClient(eq(clientId), eq("anytype"), eq("anymessage"),
                            eq(VOID_SEQUENCE_NUMBER));
        }
    }

    @Test
    public void testSendReceiverActionToClient() throws JSONException {
        MediaSink sink = mock(MediaSink.class);
        doReturn("sink-id").when(sink).getId();
        doReturn("sink-name").when(sink).getName();
        doReturn(Arrays.asList("audio_in", "audio_out", "video_in", "video_out"))
                .when(mSessionController)
                .getCapabilities();

        mMessageHandler.sendReceiverActionToClient("route-id", sink, "client-id", "action");

        ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
        verify(mRouteProvider).sendMessageToClient(eq("client-id"), messageCaptor.capture());
        JSONObject capturedMessage = new JSONObject(messageCaptor.getValue());
        assertEquals(capturedMessage.getString("type"), "receiver_action");
        assertEquals(capturedMessage.getInt("sequenceNumber"), VOID_SEQUENCE_NUMBER);
        assertEquals(capturedMessage.getInt("timeoutMillis"), 0);
        assertEquals(capturedMessage.getString("clientId"), "client-id");

        JSONObject receiverAction = capturedMessage.getJSONObject("message");
        assertEquals(receiverAction.getString("action"), "action");

        JSONObject receiverInfo = receiverAction.getJSONObject("receiver");
        assertEquals(receiverInfo.getString("label"), "sink-id");
        assertEquals(receiverInfo.getString("friendlyName"), "sink-name");
        assertFalse(receiverInfo.has("volume"));
        assertFalse(receiverInfo.has("isActiveInput"));
        assertFalse(receiverInfo.has("displayStatus"));
        assertEquals(receiverInfo.getString("receiverType"), "cast");

        JSONArray capabilities = receiverInfo.getJSONArray("capabilities");
        assertEquals(capabilities.getString(0), "audio_in");
        assertEquals(capabilities.getString(1), "audio_out");
        assertEquals(capabilities.getString(2), "video_in");
        assertEquals(capabilities.getString(3), "video_out");
    }

    @Test
    public void testBuildEnclosedClientMessageWithNullMessage() throws JSONException {
        String message = mMessageHandler.buildEnclosedClientMessage(
                "anytype", null, CLIENT_ID1, SEQUENCE_NUMBER1);
        JSONObject expected = new JSONObject();
        expected.put("type", "anytype");
        expected.put("sequenceNumber", SEQUENCE_NUMBER1);
        expected.put("timeoutMillis", 0);
        expected.put("clientId", CLIENT_ID1);
        expected.put("message", null);

        assertTrue("\nexpected: " + expected.toString() + ",\n  actual: " + message.toString(),
                new JSONObjectLike(expected).matches(new JSONObject(message)));
    }

    @Test
    public void testBuildEnclosedClientMessageOfRemoveSessionType() throws JSONException {
        String message = mMessageHandler.buildEnclosedClientMessage(
                "remove_session", SESSION_ID, CLIENT_ID1, SEQUENCE_NUMBER1);
        JSONObject expected = new JSONObject();
        expected.put("type", "remove_session");
        expected.put("sequenceNumber", SEQUENCE_NUMBER1);
        expected.put("timeoutMillis", 0);
        expected.put("clientId", CLIENT_ID1);
        expected.put("message", SESSION_ID);

        assertTrue("\nexpected: " + expected.toString() + ",\n  actual: " + message.toString(),
                new JSONObjectLike(expected).matches(new JSONObject(message)));
    }

    @Test
    public void testBuildEnclosedClientMessageOfDisconnectSessionType() throws JSONException {
        String message = mMessageHandler.buildEnclosedClientMessage(
                "disconnect_session", SESSION_ID, CLIENT_ID1, SEQUENCE_NUMBER1);
        JSONObject expected = new JSONObject();
        expected.put("type", "disconnect_session");
        expected.put("sequenceNumber", SEQUENCE_NUMBER1);
        expected.put("timeoutMillis", 0);
        expected.put("clientId", CLIENT_ID1);
        expected.put("message", SESSION_ID);

        assertTrue("\nexpected: " + expected.toString() + ",\n  actual: " + message.toString(),
                new JSONObjectLike(expected).matches(new JSONObject(message)));
    }

    @Test
    public void testBuildEnclosedClientMessageWithInnerMessage() throws JSONException {
        JSONObject innerMessage = buildSessionMessage(SESSION_ID);
        String message = mMessageHandler.buildEnclosedClientMessage(
                "anytype", innerMessage.toString(), CLIENT_ID1, SEQUENCE_NUMBER1);
        JSONObject expected = new JSONObject();
        expected.put("type", "anytype");
        expected.put("sequenceNumber", SEQUENCE_NUMBER1);
        expected.put("timeoutMillis", 0);
        expected.put("clientId", CLIENT_ID1);
        expected.put("message", innerMessage);

        assertTrue("\nexpected: " + expected.toString() + ",\n  actual: " + message.toString(),
                new JSONObjectLike(expected).matches(new JSONObject(message)));
    }

    @Test
    public void testBuildSessionMessage() throws JSONException {
        CastDevice castDevice = mock(CastDevice.class);
        doReturn("device-id").when(castDevice).getDeviceId();
        doReturn("CastDevice friendly name").when(castDevice).getFriendlyName();
        doReturn(castDevice).when(mSession).getCastDevice();
        ApplicationMetadata appMetadata = mock(ApplicationMetadata.class);
        doReturn("app-id").when(appMetadata).getApplicationId();
        doReturn(appMetadata).when(mSession).getApplicationMetadata();
        doReturn(1.0).when(mSession).getVolume();
        doReturn(false).when(mSession).isMute();
        doReturn("status text").when(mSession).getApplicationStatus();
        doReturn(1).when(mSession).getActiveInputState();
        doReturn(Arrays.asList("namespace-1", "namespace-2"))
                .when(mSessionController)
                .getNamespaces();
        doReturn(Arrays.asList("audio_in", "audio_out", "video_in", "video_out"))
                .when(mSessionController)
                .getCapabilities();

        JSONObject message = new JSONObject(mMessageHandler.buildSessionMessage());

        assertEquals(message.getString("sessionId"), SESSION_ID);
        assertEquals(message.getString("statusText"), "status text");
        assertEquals(message.getString("status"), "connected");
        assertEquals(message.getString("transportId"), "web-4");
        assertEquals(message.getString("appId"), "app-id");
        assertEquals(message.getString("displayName"), "CastDevice friendly name");

        JSONArray mediaArray = message.getJSONArray("media");

        assertEquals(mediaArray.length(), 0);

        JSONArray namespacesArray = message.getJSONArray("namespaces");
        assertEquals(namespacesArray.length(), 2);
        assertEquals(namespacesArray.getJSONObject(0).getString("name"), "namespace-1");
        assertEquals(namespacesArray.getJSONObject(1).getString("name"), "namespace-2");

        JSONObject receiverInfo = message.getJSONObject("receiver");
        assertEquals(receiverInfo.getString("label"), "device-id");
        assertEquals(receiverInfo.getString("friendlyName"), "CastDevice friendly name");
        assertEquals(receiverInfo.getInt("isActiveInput"), 1);
        assertEquals(receiverInfo.getString("receiverType"), "cast");
        assertFalse(receiverInfo.has("displayStatus"));

        JSONArray capabilities = receiverInfo.getJSONArray("capabilities");
        assertEquals(capabilities.getString(0), "audio_in");
        assertEquals(capabilities.getString(1), "audio_out");
        assertEquals(capabilities.getString(2), "video_in");
        assertEquals(capabilities.getString(3), "video_out");

        JSONObject volume = receiverInfo.getJSONObject("volume");
        assertEquals(volume.getDouble("level"), 1.0, 1e-6);
        assertFalse(volume.getBoolean("muted"));
    }

    @Test
    public void testBuildSessionMessage_sessionDisconnected() {
        doReturn(false).when(mSessionController).isConnected();

        CastDevice castDevice = mock(CastDevice.class);
        doReturn("device-id").when(castDevice).getDeviceId();
        doReturn("CastDevice friendly name").when(castDevice).getFriendlyName();
        doReturn(castDevice).when(mSession).getCastDevice();
        ApplicationMetadata appMetadata = mock(ApplicationMetadata.class);
        doReturn("app-id").when(appMetadata).getApplicationId();
        doReturn(appMetadata).when(mSession).getApplicationMetadata();
        doReturn(1.0).when(mSession).getVolume();
        doReturn(false).when(mSession).isMute();
        doReturn("status text").when(mSession).getApplicationStatus();
        doReturn(1).when(mSession).getActiveInputState();
        doReturn(Arrays.asList("namespace-1", "namespace-2"))
                .when(mSessionController)
                .getNamespaces();
        doReturn(Arrays.asList("audio_in", "audio_out", "video_in", "video_out"))
                .when(mSessionController)
                .getCapabilities();

        assertEquals(mMessageHandler.buildSessionMessage(), "{}");
    }

    private JSONObject buildCastV2Message(String clientId, JSONObject innerMessage)
            throws JSONException {
        JSONObject message = new JSONObject();
        message.put("type", "v2_message");
        message.put("message", innerMessage);
        message.put("sequenceNumber", SEQUENCE_NUMBER1);
        message.put("timeoutMillis", 0);
        message.put("clientId", clientId);

        return message;
    }

    private JSONObject buildAppMessage(String clientId, String namespace, Object actualMessage)
            throws JSONException {
        JSONObject innerMessage = new JSONObject();
        innerMessage.put("sessionId", mSessionController.getSessionId());
        innerMessage.put("namespaceName", namespace);
        innerMessage.put("message", actualMessage);

        JSONObject message = new JSONObject();
        message.put("type", "app_message");
        message.put("message", innerMessage);
        message.put("sequenceNumber", SEQUENCE_NUMBER1);
        message.put("timeoutMillis", 0);
        message.put("clientId", clientId);

        return message;
    }

    private JSONObject buildActualAppMessage() throws JSONException {
        JSONObject message = new JSONObject();
        message.put("type", "actual app message type");

        return message;
    }

    private JSONObject buildSessionMessage(String sessionId) throws JSONException {
        JSONObject message = new JSONObject();
        message.put("sessionId", sessionId);

        return message;
    }

    private void expectException(CheckedRunnable r, Class exceptionClass) {
        boolean caughtException = false;
        try {
            r.run();
        } catch (Exception e) {
            if (e.getClass() == exceptionClass) caughtException = true;
        }
        assertTrue(caughtException);
    }

    private JSONObject buildJsonCastMessage(String message) throws JSONException {
        JSONObject jsonMessage = new JSONObject();
        jsonMessage.put("requestId", REQUEST_ID1);
        jsonMessage.put("message", message);
        return jsonMessage;
    }

    private void verifySimpleSessionMessage(JSONObject message, String type, int sequenceNumber,
            String clientId) throws JSONException {
        assertEquals(message.getString("type"), type);
        assertEquals(message.getInt("sequenceNumber"), sequenceNumber);
        assertEquals(message.getInt("timeoutMillis"), 0);
        assertEquals(message.getInt("sequenceNumber"), sequenceNumber);
    }

    private void prepareClientRecord(String routeId, String clientId, String appId,
            String autoJoinPolicy, String origin, int tabId) {
        ClientRecord clientRecord =
                new ClientRecord(routeId, clientId, appId, autoJoinPolicy, origin, tabId);
        mClientRecordMap.put(clientId, clientRecord);
    }

    private JSONObject buildLeaveSessionMessage(
            String clientId, String sessionId, int sequenceNumber) throws JSONException {
        JSONObject message = new JSONObject();
        message.put("type", "leave_session");
        message.put("clientId", clientId);
        message.put("message", sessionId);
        message.put("sequenceNumber", sequenceNumber);
        return message;
    }
}