packages/SystemUI/tests/src/com/android/systemui/media/MediaDataCombineLatestTest.java

/*
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.android.systemui.media;

import static com.google.common.truth.Truth.assertThat;

import static org.mockito.Mockito.any;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;

import android.graphics.Color;
import android.testing.AndroidTestingRunner;
import android.testing.TestableLooper;

import androidx.test.filters.SmallTest;

import com.android.systemui.SysuiTestCase;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;

import java.util.ArrayList;
import java.util.Map;

@SmallTest
@RunWith(AndroidTestingRunner.class)
@TestableLooper.RunWithLooper
public class MediaDataCombineLatestTest extends SysuiTestCase {

    private static final String KEY = "TEST_KEY";
    private static final String APP = "APP";
    private static final String PACKAGE = "PKG";
    private static final int BG_COLOR = Color.RED;
    private static final String ARTIST = "ARTIST";
    private static final String TITLE = "TITLE";
    private static final String DEVICE_NAME = "DEVICE_NAME";
    private static final int USER_ID = 0;

    private MediaDataCombineLatest mManager;

    @Mock private MediaDataManager mDataSource;
    @Mock private MediaDeviceManager mDeviceSource;
    @Mock private MediaDataManager.Listener mListener;

    private MediaDataManager.Listener mDataListener;
    private MediaDeviceManager.Listener mDeviceListener;

    private MediaData mMediaData;
    private MediaDeviceData mDeviceData;

    @Before
    public void setUp() {
        mDataSource = mock(MediaDataManager.class);
        mDeviceSource = mock(MediaDeviceManager.class);
        mListener = mock(MediaDataManager.Listener.class);

        mManager = new MediaDataCombineLatest(mDataSource, mDeviceSource);

        mDataListener = captureDataListener();
        mDeviceListener = captureDeviceListener();

        mManager.addListener(mListener);

        mMediaData = new MediaData(USER_ID, true, BG_COLOR, APP, null, ARTIST, TITLE, null,
                new ArrayList<>(), new ArrayList<>(), PACKAGE, null, null, null, true, null, false,
                KEY, false);
        mDeviceData = new MediaDeviceData(true, null, DEVICE_NAME);
    }

    @Test
    public void eventNotEmittedWithoutDevice() {
        // WHEN data source emits an event without device data
        mDataListener.onMediaDataLoaded(KEY, null, mMediaData);
        // THEN an event isn't emitted
        verify(mListener, never()).onMediaDataLoaded(eq(KEY), any(), any());
    }

    @Test
    public void eventNotEmittedWithoutMedia() {
        // WHEN device source emits an event without media data
        mDeviceListener.onMediaDeviceChanged(KEY, mDeviceData);
        // THEN an event isn't emitted
        verify(mListener, never()).onMediaDataLoaded(eq(KEY), any(), any());
    }

    @Test
    public void emitEventAfterDeviceFirst() {
        // GIVEN that a device event has already been received
        mDeviceListener.onMediaDeviceChanged(KEY, mDeviceData);
        // WHEN media event is received
        mDataListener.onMediaDataLoaded(KEY, null, mMediaData);
        // THEN the listener receives a combined event
        ArgumentCaptor<MediaData> captor = ArgumentCaptor.forClass(MediaData.class);
        verify(mListener).onMediaDataLoaded(eq(KEY), any(), captor.capture());
        assertThat(captor.getValue().getDevice()).isNotNull();
    }

    @Test
    public void emitEventAfterMediaFirst() {
        // GIVEN that media event has already been received
        mDataListener.onMediaDataLoaded(KEY, null, mMediaData);
        // WHEN device event is received
        mDeviceListener.onMediaDeviceChanged(KEY, mDeviceData);
        // THEN the listener receives a combined event
        ArgumentCaptor<MediaData> captor = ArgumentCaptor.forClass(MediaData.class);
        verify(mListener).onMediaDataLoaded(eq(KEY), any(), captor.capture());
        assertThat(captor.getValue().getDevice()).isNotNull();
    }

    @Test
    public void mediaDataRemoved() {
        // WHEN media data is removed without first receiving device or data
        mDataListener.onMediaDataRemoved(KEY);
        // THEN a removed event isn't emitted
        verify(mListener, never()).onMediaDataRemoved(eq(KEY));
    }

    @Test
    public void mediaDataRemovedAfterMediaEvent() {
        mDataListener.onMediaDataLoaded(KEY, null, mMediaData);
        mDataListener.onMediaDataRemoved(KEY);
        verify(mListener).onMediaDataRemoved(eq(KEY));
    }

    @Test
    public void mediaDataRemovedAfterDeviceEvent() {
        mDeviceListener.onMediaDeviceChanged(KEY, mDeviceData);
        mDataListener.onMediaDataRemoved(KEY);
        verify(mListener).onMediaDataRemoved(eq(KEY));
    }

    @Test
    public void mediaDataKeyUpdated() {
        // GIVEN that device and media events have already been received
        mDataListener.onMediaDataLoaded(KEY, null, mMediaData);
        mDeviceListener.onMediaDeviceChanged(KEY, mDeviceData);
        // WHEN the key is changed
        mDataListener.onMediaDataLoaded("NEW_KEY", KEY, mMediaData);
        // THEN the listener gets a load event with the correct keys
        ArgumentCaptor<MediaData> captor = ArgumentCaptor.forClass(MediaData.class);
        verify(mListener).onMediaDataLoaded(eq("NEW_KEY"), any(), captor.capture());
    }

    @Test
    public void getDataIncludesDevice() {
        // GIVEN that device and media events have been received
        mDeviceListener.onMediaDeviceChanged(KEY, mDeviceData);
        mDataListener.onMediaDataLoaded(KEY, null, mMediaData);

        // THEN the result of getData includes device info
        Map<String, MediaData> results = mManager.getData();
        assertThat(results.get(KEY)).isNotNull();
        assertThat(results.get(KEY).getDevice()).isEqualTo(mDeviceData);
    }

    private MediaDataManager.Listener captureDataListener() {
        ArgumentCaptor<MediaDataManager.Listener> captor = ArgumentCaptor.forClass(
                MediaDataManager.Listener.class);
        verify(mDataSource).addListener(captor.capture());
        return captor.getValue();
    }

    private MediaDeviceManager.Listener captureDeviceListener() {
        ArgumentCaptor<MediaDeviceManager.Listener> captor = ArgumentCaptor.forClass(
                MediaDeviceManager.Listener.class);
        verify(mDeviceSource).addListener(captor.capture());
        return captor.getValue();
    }
}