1 /*
2  * Copyright (C) 2022 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.android.systemui.complication;
17 
18 import static com.google.common.truth.Truth.assertThat;
19 
20 import static org.junit.Assert.assertEquals;
21 import static org.mockito.ArgumentMatchers.eq;
22 import static org.mockito.Mockito.verify;
23 import static org.mockito.Mockito.when;
24 
25 import android.content.Context;
26 import android.testing.AndroidTestingRunner;
27 import android.view.View;
28 
29 import androidx.test.filters.SmallTest;
30 
31 import com.android.internal.logging.UiEventLogger;
32 import com.android.systemui.SysuiTestCase;
33 import com.android.systemui.complication.dagger.DreamClockTimeComplicationComponent;
34 import com.android.systemui.condition.SelfExecutingMonitor;
35 import com.android.systemui.dreams.DreamOverlayStateController;
36 import com.android.systemui.shared.condition.Monitor;
37 
38 import org.junit.Before;
39 import org.junit.Test;
40 import org.junit.runner.RunWith;
41 import org.mockito.ArgumentCaptor;
42 import org.mockito.Mock;
43 import org.mockito.MockitoAnnotations;
44 
45 @SmallTest
46 @RunWith(AndroidTestingRunner.class)
47 public class DreamClockTimeComplicationTest extends SysuiTestCase {
48     @SuppressWarnings("HidingField")
49     @Mock
50     private Context mContext;
51 
52     @Mock
53     private DreamOverlayStateController mDreamOverlayStateController;
54 
55     @Mock
56     private DreamClockTimeComplication mComplication;
57 
58     @Mock
59     private DreamClockTimeComplicationComponent.Factory mComponentFactory;
60 
61     @Mock
62     private DreamClockTimeComplicationComponent mComponent;
63 
64     @Mock
65     private DreamClockTimeComplication.DreamClockTimeViewHolder
66             mDreamClockTimeViewHolder;
67 
68     @Mock
69     private ComplicationViewModel mComplicationViewModel;
70 
71     @Mock
72     private View mView;
73 
74     @Mock
75     private ComplicationLayoutParams mLayoutParams;
76 
77     @Mock
78     private DreamClockTimeComplication.DreamClockTimeViewController mViewController;
79 
80     @Mock
81     private UiEventLogger mUiEventLogger;
82 
83     private Monitor mMonitor;
84 
85     @Before
setup()86     public void setup() {
87         MockitoAnnotations.initMocks(this);
88         when(mComponentFactory.create()).thenReturn(mComponent);
89         when(mComponent.getViewHolder()).thenReturn(mDreamClockTimeViewHolder);
90         mMonitor = SelfExecutingMonitor.createInstance();
91     }
92 
93     /**
94      * Ensures {@link DreamClockTimeComplication} is registered.
95      */
96     @Test
testComplicationAdded()97     public void testComplicationAdded() {
98         final DreamClockTimeComplication.Registrant registrant =
99                 new DreamClockTimeComplication.Registrant(
100                         mDreamOverlayStateController,
101                         mComplication,
102                         mMonitor);
103         registrant.start();
104         verify(mDreamOverlayStateController).addComplication(eq(mComplication));
105     }
106 
107     /**
108      * Verifies {@link DreamClockTimeComplication} has the required type.
109      */
110     @Test
testComplicationRequiredTypeAvailability()111     public void testComplicationRequiredTypeAvailability() {
112         final DreamClockTimeComplication complication =
113                 new DreamClockTimeComplication(mComponentFactory);
114         assertEquals(Complication.COMPLICATION_TYPE_TIME,
115                 complication.getRequiredTypeAvailability());
116     }
117 
118     /**
119      * Verifies {@link DreamClockTimeComplication.DreamClockTimeViewHolder} is obtainable from its
120      * component when the complication creates view.
121      */
122     @Test
testComplicationViewHolderComponentOnCreateView()123     public void testComplicationViewHolderComponentOnCreateView() {
124         final DreamClockTimeComplication complication =
125                 new DreamClockTimeComplication(mComponentFactory);
126         final Complication.ViewHolder viewHolder = complication.createView(mComplicationViewModel);
127         verify(mComponent).getViewHolder();
128         assertThat(viewHolder).isEqualTo(mDreamClockTimeViewHolder);
129     }
130 
131     /**
132      * Verifies {@link DreamClockTimeComplication.DreamClockTimeViewHolder} has the intended view
133      * and layout parameters from constructor.
134      */
135     @Test
testComplicationViewHolderContentAccessors()136     public void testComplicationViewHolderContentAccessors() {
137         final DreamClockTimeComplication.DreamClockTimeViewHolder viewHolder =
138                 new DreamClockTimeComplication.DreamClockTimeViewHolder(mView, mLayoutParams,
139                         mViewController);
140         assertThat(viewHolder.getView()).isEqualTo(mView);
141         assertThat(viewHolder.getLayoutParams()).isEqualTo(mLayoutParams);
142     }
143 
144     @Test
testClick_logUiEvent()145     public void testClick_logUiEvent() {
146         final DreamClockTimeComplication.DreamClockTimeViewController controller =
147                 new DreamClockTimeComplication.DreamClockTimeViewController(mView, mUiEventLogger);
148         controller.onViewAttached();
149 
150         final ArgumentCaptor<View.OnClickListener> clickListenerCaptor =
151                 ArgumentCaptor.forClass(View.OnClickListener.class);
152         verify(mView).setOnClickListener(clickListenerCaptor.capture());
153 
154         clickListenerCaptor.getValue().onClick(mView);
155         verify(mUiEventLogger).log(DreamOverlayUiEvent.DREAM_CLOCK_TAPPED);
156     }
157 }
158