1 /*
<lambda>null2  * 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 
17 package com.android.systemui.statusbar.pipeline.wifi.shared.model
18 
19 import android.net.wifi.WifiManager.UNKNOWN_SSID
20 import android.telephony.SubscriptionManager.INVALID_SUBSCRIPTION_ID
21 import androidx.test.ext.junit.runners.AndroidJUnit4
22 import androidx.test.filters.SmallTest
23 import com.android.systemui.SysuiTestCase
24 import com.android.systemui.log.table.TableRowLogger
25 import com.android.systemui.statusbar.pipeline.wifi.shared.model.WifiNetworkModel.Active.Companion.MAX_VALID_LEVEL
26 import com.android.systemui.statusbar.pipeline.wifi.shared.model.WifiNetworkModel.Companion.MIN_VALID_LEVEL
27 import com.android.wifitrackerlib.WifiEntry.WIFI_LEVEL_UNREACHABLE
28 import com.google.common.truth.Truth.assertThat
29 import org.junit.Test
30 import org.junit.runner.RunWith
31 
32 @SmallTest
33 @RunWith(AndroidJUnit4::class)
34 class WifiNetworkModelTest : SysuiTestCase() {
35     @Test
36     fun active_levelsInValidRange_createsActive() {
37         (MIN_VALID_LEVEL..MAX_VALID_LEVEL).forEach { level ->
38             val result = WifiNetworkModel.Active.of(level = level)
39             assertThat(result).isInstanceOf(WifiNetworkModel.Active::class.java)
40         }
41     }
42 
43     fun active_levelTooLow_returnsInactive() {
44         val result = WifiNetworkModel.Active.of(level = MIN_VALID_LEVEL - 1)
45         assertThat(result).isInstanceOf(WifiNetworkModel.Inactive::class.java)
46     }
47 
48     @Test(expected = IllegalArgumentException::class)
49     fun active_levelTooLow_createdByCopy_exceptionThrown() {
50         val starting = WifiNetworkModel.Active.of(level = MIN_VALID_LEVEL)
51 
52         (starting as WifiNetworkModel.Active).copy(level = MIN_VALID_LEVEL - 1)
53     }
54 
55     fun active_levelTooHigh_returnsInactive() {
56         val result = WifiNetworkModel.Active.of(level = MAX_VALID_LEVEL + 1)
57 
58         assertThat(result).isInstanceOf(WifiNetworkModel.Inactive::class.java)
59     }
60 
61     @Test(expected = IllegalArgumentException::class)
62     fun active_levelTooHigh_createdByCopy_exceptionThrown() {
63         val starting = WifiNetworkModel.Active.of(level = MAX_VALID_LEVEL)
64 
65         (starting as WifiNetworkModel.Active).copy(level = MAX_VALID_LEVEL + 1)
66     }
67 
68     fun active_levelUnreachable_returnsInactive() {
69         val result = WifiNetworkModel.Active.of(level = WIFI_LEVEL_UNREACHABLE)
70 
71         assertThat(result).isInstanceOf(WifiNetworkModel.Inactive::class.java)
72     }
73 
74     @Test(expected = IllegalArgumentException::class)
75     fun active_levelUnreachable_createdByCopy_exceptionThrown() {
76         val starting = WifiNetworkModel.Active.of(level = MAX_VALID_LEVEL)
77 
78         (starting as WifiNetworkModel.Active).copy(level = WIFI_LEVEL_UNREACHABLE)
79     }
80 
81     fun carrierMerged_invalidSubId_returnsInvalid() {
82         val result = WifiNetworkModel.CarrierMerged.of(INVALID_SUBSCRIPTION_ID, level = 1)
83 
84         assertThat(result).isInstanceOf(WifiNetworkModel.Invalid::class.java)
85     }
86 
87     @Test(expected = IllegalArgumentException::class)
88     fun carrierMerged_invalidSubId_createdByCopy_exceptionThrown() {
89         val starting = WifiNetworkModel.CarrierMerged.of(subscriptionId = 1, level = 1)
90 
91         (starting as WifiNetworkModel.CarrierMerged).copy(subscriptionId = INVALID_SUBSCRIPTION_ID)
92     }
93 
94     fun carrierMerged_levelUnreachable_returnsInvalid() {
95         val result =
96             WifiNetworkModel.CarrierMerged.of(subscriptionId = 1, level = WIFI_LEVEL_UNREACHABLE)
97 
98         assertThat(result).isInstanceOf(WifiNetworkModel.Invalid::class.java)
99     }
100 
101     @Test(expected = IllegalArgumentException::class)
102     fun carrierMerged_levelUnreachable_createdByCopy_exceptionThrown() {
103         val starting = WifiNetworkModel.CarrierMerged.of(subscriptionId = 1, level = 1)
104 
105         (starting as WifiNetworkModel.CarrierMerged).copy(level = WIFI_LEVEL_UNREACHABLE)
106     }
107 
108     @Test
109     fun active_hasValidSsid_nullSsid_false() {
110         val network =
111             WifiNetworkModel.Active.of(
112                 level = MAX_VALID_LEVEL,
113                 ssid = null,
114             )
115 
116         assertThat((network as WifiNetworkModel.Active).hasValidSsid()).isFalse()
117     }
118 
119     @Test
120     fun active_hasValidSsid_unknownSsid_false() {
121         val network =
122             WifiNetworkModel.Active.of(
123                 level = MAX_VALID_LEVEL,
124                 ssid = UNKNOWN_SSID,
125             )
126 
127         assertThat((network as WifiNetworkModel.Active).hasValidSsid()).isFalse()
128     }
129 
130     @Test
131     fun active_hasValidSsid_validSsid_true() {
132         val network =
133             WifiNetworkModel.Active.of(
134                 level = MAX_VALID_LEVEL,
135                 ssid = "FakeSsid",
136             )
137 
138         assertThat((network as WifiNetworkModel.Active).hasValidSsid()).isTrue()
139     }
140 
141     // Non-exhaustive logDiffs test -- just want to make sure the logging logic isn't totally broken
142 
143     @Test
144     fun logDiffs_carrierMergedToInactive_resetsAllFields() {
145         val logger = TestLogger()
146         val prevVal =
147             WifiNetworkModel.CarrierMerged.of(
148                 subscriptionId = 3,
149                 level = 1,
150             )
151 
152         WifiNetworkModel.Inactive(inactiveReason = "TestReason").logDiffs(prevVal, logger)
153 
154         assertThat(logger.changes)
155             .contains(Pair(COL_NETWORK_TYPE, "$TYPE_INACTIVE[reason=TestReason]"))
156         assertThat(logger.changes).contains(Pair(COL_VALIDATED, "false"))
157         assertThat(logger.changes).contains(Pair(COL_LEVEL, LEVEL_DEFAULT.toString()))
158         assertThat(logger.changes).contains(Pair(COL_SSID, "null"))
159     }
160 
161     @Test
162     fun logDiffs_inactiveToCarrierMerged_logsAllFields() {
163         val logger = TestLogger()
164         val carrierMerged =
165             WifiNetworkModel.CarrierMerged.of(
166                 subscriptionId = 3,
167                 level = 2,
168             )
169 
170         carrierMerged.logDiffs(prevVal = WifiNetworkModel.Inactive(), logger)
171 
172         assertThat(logger.changes).contains(Pair(COL_NETWORK_TYPE, TYPE_CARRIER_MERGED))
173         assertThat(logger.changes).contains(Pair(COL_SUB_ID, "3"))
174         assertThat(logger.changes).contains(Pair(COL_VALIDATED, "true"))
175         assertThat(logger.changes).contains(Pair(COL_LEVEL, "2"))
176         assertThat(logger.changes).contains(Pair(COL_SSID, "null"))
177     }
178 
179     @Test
180     fun logDiffs_inactiveToActive_logsAllActiveFields() {
181         val logger = TestLogger()
182         val activeNetwork =
183             WifiNetworkModel.Active.of(
184                 isValidated = true,
185                 level = 3,
186                 ssid = "Test SSID",
187                 hotspotDeviceType = WifiNetworkModel.HotspotDeviceType.LAPTOP,
188             )
189 
190         activeNetwork.logDiffs(prevVal = WifiNetworkModel.Inactive(), logger)
191 
192         assertThat(logger.changes).contains(Pair(COL_NETWORK_TYPE, TYPE_ACTIVE))
193         assertThat(logger.changes).contains(Pair(COL_VALIDATED, "true"))
194         assertThat(logger.changes).contains(Pair(COL_LEVEL, "3"))
195         assertThat(logger.changes).contains(Pair(COL_SSID, "Test SSID"))
196         assertThat(logger.changes).contains(Pair(COL_HOTSPOT, "LAPTOP"))
197     }
198 
199     @Test
200     fun logDiffs_activeToInactive_resetsAllActiveFields() {
201         val logger = TestLogger()
202         val activeNetwork =
203             WifiNetworkModel.Active.of(isValidated = true, level = 3, ssid = "Test SSID")
204 
205         WifiNetworkModel.Inactive(inactiveReason = "TestReason")
206             .logDiffs(prevVal = activeNetwork, logger)
207 
208         assertThat(logger.changes)
209             .contains(Pair(COL_NETWORK_TYPE, "$TYPE_INACTIVE[reason=TestReason]"))
210         assertThat(logger.changes).contains(Pair(COL_VALIDATED, "false"))
211         assertThat(logger.changes).contains(Pair(COL_LEVEL, LEVEL_DEFAULT.toString()))
212         assertThat(logger.changes).contains(Pair(COL_SSID, "null"))
213         assertThat(logger.changes).contains(Pair(COL_HOTSPOT, "null"))
214     }
215 
216     @Test
217     fun logDiffs_carrierMergedToActive_logsAllActiveFields() {
218         val logger = TestLogger()
219         val activeNetwork =
220             WifiNetworkModel.Active.of(
221                 isValidated = true,
222                 level = 3,
223                 ssid = "Test SSID",
224                 hotspotDeviceType = WifiNetworkModel.HotspotDeviceType.AUTO,
225             )
226         val prevVal =
227             WifiNetworkModel.CarrierMerged.of(
228                 subscriptionId = 3,
229                 level = 1,
230             )
231 
232         activeNetwork.logDiffs(prevVal, logger)
233 
234         assertThat(logger.changes).contains(Pair(COL_NETWORK_TYPE, TYPE_ACTIVE))
235         assertThat(logger.changes).contains(Pair(COL_VALIDATED, "true"))
236         assertThat(logger.changes).contains(Pair(COL_LEVEL, "3"))
237         assertThat(logger.changes).contains(Pair(COL_SSID, "Test SSID"))
238         assertThat(logger.changes).contains(Pair(COL_HOTSPOT, "AUTO"))
239     }
240 
241     @Test
242     fun logDiffs_activeToCarrierMerged_logsAllFields() {
243         val logger = TestLogger()
244         val activeNetwork =
245             WifiNetworkModel.Active.of(isValidated = true, level = 3, ssid = "Test SSID")
246         val carrierMerged =
247             WifiNetworkModel.CarrierMerged.of(
248                 subscriptionId = 3,
249                 level = 2,
250             )
251 
252         carrierMerged.logDiffs(prevVal = activeNetwork, logger)
253 
254         assertThat(logger.changes).contains(Pair(COL_NETWORK_TYPE, TYPE_CARRIER_MERGED))
255         assertThat(logger.changes).contains(Pair(COL_SUB_ID, "3"))
256         assertThat(logger.changes).contains(Pair(COL_VALIDATED, "true"))
257         assertThat(logger.changes).contains(Pair(COL_LEVEL, "2"))
258         assertThat(logger.changes).contains(Pair(COL_SSID, "null"))
259     }
260 
261     @Test
262     fun logDiffs_activeChangesLevel_onlyLevelLogged() {
263         val logger = TestLogger()
264         val prevActiveNetwork =
265             WifiNetworkModel.Active.of(isValidated = true, level = 3, ssid = "Test SSID")
266         val newActiveNetwork =
267             WifiNetworkModel.Active.of(isValidated = true, level = 2, ssid = "Test SSID")
268 
269         newActiveNetwork.logDiffs(prevActiveNetwork, logger)
270 
271         assertThat(logger.changes).isEqualTo(listOf(Pair(COL_LEVEL, "2")))
272     }
273 
274     private class TestLogger : TableRowLogger {
275         val changes = mutableListOf<Pair<String, String>>()
276 
277         override fun logChange(columnName: String, value: String?) {
278             changes.add(Pair(columnName, value.toString()))
279         }
280 
281         override fun logChange(columnName: String, value: Int) {
282             changes.add(Pair(columnName, value.toString()))
283         }
284 
285         override fun logChange(columnName: String, value: Boolean) {
286             changes.add(Pair(columnName, value.toString()))
287         }
288     }
289 }
290