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