Provide remaining Weather API test coverage

Change-Id: I15acbb4193158e7b2b98f7298b1774e1a1bc0cc2
TICKET: CYNGNOS-3043

tests/AndroidManifest.xml

@@ -28,7 +28,7 @@
     <uses-permission android:name="cyanogenmod.permission.ACCESS_THEME_MANAGER" />
     <uses-permission android:name="cyanogenmod.permission.MANAGE_LIVEDISPLAY" />
     <uses-permission android:name="cyanogenmod.permission.OBSERVE_AUDIO_SESSIONS" />
-
+    <uses-permission android:name="cyanogenmod.permission.ACCESS_WEATHER_MANAGER" />
     <uses-permission android:name="android.permission.STATUS_BAR_SERVICE" />
 
     <application android:name=".CyanogenModTestApplication"

tests/src/org/cyanogenmod/tests/weather/unit/CMWeatherManagerTest.java

@@ -0,0 +1,243 @@
+/**
+ * Copyright (C) 2016 The CyanogenMod 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 org.cyanogenmod.tests.weather.unit;
+
+import android.location.Location;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.MediumTest;
+import android.test.suitebuilder.annotation.SmallTest;
+import cyanogenmod.weather.CMWeatherManager;
+import cyanogenmod.weather.CMWeatherManager.LookupCityRequestListener;
+import cyanogenmod.weather.CMWeatherManager.WeatherServiceProviderChangeListener;
+import cyanogenmod.weather.CMWeatherManager.WeatherUpdateRequestListener;
+import cyanogenmod.weather.ICMWeatherManager;
+import cyanogenmod.weather.RequestInfo;
+import cyanogenmod.weather.WeatherInfo;
+import cyanogenmod.weather.WeatherLocation;
+import org.cyanogenmod.tests.common.MockIBinderStubForInterface;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+public class CMWeatherManagerTest extends AndroidTestCase {
+
+    private CMWeatherManager mWeatherManager;
+    private static final String CITY_NAME = "Seattle, WA";
+    private static final int COUNTDOWN = 1;
+    private static final int REQUEST_ID = 42;
+    private static final String MOCKED_WEATHER_PROVIDER_LABEL = "Mock'd Weather Service";
+    private ICMWeatherManager.Stub mICMWeatherManagerSpy;
+    private static final String DESCRIPTOR = "cyanogenmod.weather.ICMWeatherManager";
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        setUpMockICMWeatherManager();
+    }
+
+    private void setUpMockICMWeatherManager() {
+        mWeatherManager = CMWeatherManager.getInstance(getContext());
+        Field f;
+        try {
+            f = mWeatherManager.getClass().getDeclaredField("sWeatherManagerService");
+            f.setAccessible(true);
+
+            mICMWeatherManagerSpy
+                    = MockIBinderStubForInterface.getMockInterface(ICMWeatherManager.Stub.class);
+            f.set(mWeatherManager, mICMWeatherManagerSpy);
+
+            Mockito.doAnswer(new WeatherUpdateRequestAnswer())
+                    .when(mICMWeatherManagerSpy).updateWeather(Mockito.any(RequestInfo.class));
+
+            Mockito.doAnswer(new LookUpCityAnswer())
+                    .when(mICMWeatherManagerSpy).lookupCity(Mockito.any(RequestInfo.class));
+
+            Mockito.doAnswer(new GetActiveWeatherServiceProviderLabelAnser())
+                    .when(mICMWeatherManagerSpy).getActiveWeatherServiceProviderLabel();
+
+            Mockito.doAnswer(new CancelRequestAnswer())
+                    .when(mICMWeatherManagerSpy).cancelRequest(Mockito.eq(REQUEST_ID));
+        } catch (Exception e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    private static class WeatherUpdateRequestAnswer implements Answer<Integer> {
+
+        @Override
+        public Integer answer(InvocationOnMock invocation) throws Throwable {
+            final RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+            if (requestInfo.getRequestType() == RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ) {
+                assertNotNull(requestInfo.getLocation());
+            } else {
+                assertNotNull(requestInfo.getWeatherLocation());
+            }
+            final WeatherInfo weatherInfo = new WeatherInfo.Builder(CITY_NAME,
+                    30d, requestInfo.getTemperatureUnit()).build();
+            requestInfo.getRequestListener().onWeatherRequestCompleted(requestInfo,
+                    CMWeatherManager.RequestStatus.COMPLETED, weatherInfo);
+            return REQUEST_ID;
+        }
+    }
+
+    private static class LookUpCityAnswer implements Answer<Integer> {
+
+        @Override
+        public Integer answer(InvocationOnMock invocation) throws Throwable {
+            final RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+            final List<WeatherLocation> locations = new ArrayList<>();
+            final String cityName = requestInfo.getCityName();
+            assertNotNull(cityName);
+            locations.add(new WeatherLocation.Builder(cityName).build());
+            requestInfo.getRequestListener().onLookupCityRequestCompleted(requestInfo,
+                    CMWeatherManager.RequestStatus.COMPLETED, locations);
+            return REQUEST_ID;
+        }
+    }
+
+    private static class GetActiveWeatherServiceProviderLabelAnser implements Answer<String> {
+
+        @Override
+        public String answer(InvocationOnMock invocation) throws Throwable {
+            return MOCKED_WEATHER_PROVIDER_LABEL;
+        }
+    }
+
+    private static class CancelRequestAnswer implements Answer<Void> {
+
+        @Override
+        public Void answer(InvocationOnMock invocation) throws Throwable {
+            final int requestId = (Integer) invocation.getArguments()[0];
+            assertEquals(requestId, REQUEST_ID);
+            return null;
+        }
+    }
+
+    @SmallTest
+    public void testGetActiveWeatherServiceProviderLabel() {
+        String providerLabel = mWeatherManager.getActiveWeatherServiceProviderLabel();
+        assertEquals(MOCKED_WEATHER_PROVIDER_LABEL, providerLabel);
+    }
+
+    @MediumTest
+    public void testLookupCity() {
+        final CountDownLatch signal = new CountDownLatch(COUNTDOWN);
+        final boolean[] error = {false};
+        mWeatherManager.lookupCity(CITY_NAME,
+                new LookupCityRequestListener() {
+                    @Override
+                    public void onLookupCityRequestCompleted(int status,
+                            List<WeatherLocation> locations) {
+                        final int totalLocations = locations != null ? locations.size() : 0;
+                        if (status != CMWeatherManager.RequestStatus.COMPLETED
+                                || totalLocations < 1) {
+                            error[0] = true;
+                        }
+                        signal.countDown();
+                    }
+                });
+        try {
+            signal.await();
+            assertFalse(error[0]);
+        } catch (InterruptedException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    @SmallTest
+    public void testRegisterListener() {
+        mWeatherManager.registerWeatherServiceProviderChangeListener(mListener);
+
+        try {
+            mWeatherManager.registerWeatherServiceProviderChangeListener(mListener);
+            throw new AssertionError("Listener was registered twice!");
+        } catch (IllegalArgumentException e) {
+            //EXPECTED
+        }
+
+        mWeatherManager.unregisterWeatherServiceProviderChangeListener(mListener);
+
+        try {
+            mWeatherManager.unregisterWeatherServiceProviderChangeListener(mListener);
+            throw new AssertionError("Listener was de-registered twice!");
+        } catch (IllegalArgumentException e) {
+            //EXPECTED
+        }
+    }
+
+    private WeatherServiceProviderChangeListener mListener
+            = new WeatherServiceProviderChangeListener() {
+        @Override
+        public void onWeatherServiceProviderChanged(String providerLabel) {}
+    };
+
+    @MediumTest
+    public void testRequestWeatherUpdateByWeatherLocation() {
+        final CountDownLatch signal = new CountDownLatch(COUNTDOWN);
+        final WeatherLocation weatherLocation = new WeatherLocation.Builder(CITY_NAME).build();
+        final boolean[] error = {false};
+        mWeatherManager.requestWeatherUpdate(weatherLocation, new WeatherUpdateRequestListener() {
+            @Override
+            public void onWeatherRequestCompleted(int status, WeatherInfo weatherInfo) {
+                if (status != CMWeatherManager.RequestStatus.COMPLETED
+                        || !weatherInfo.getCity().equals(CITY_NAME)) {
+                    error[0] = true;
+                }
+                signal.countDown();
+            }
+        });
+        try {
+            signal.await();
+            assertFalse(error[0]);
+        } catch (InterruptedException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    @MediumTest
+    public void testRequestWeatherUpdateByLocation() {
+        final CountDownLatch signal = new CountDownLatch(COUNTDOWN);
+        final Location location = new Location("test_location_provider");
+        final boolean[] error = {false};
+        mWeatherManager.requestWeatherUpdate(location, new WeatherUpdateRequestListener() {
+            @Override
+            public void onWeatherRequestCompleted(int status, WeatherInfo weatherInfo) {
+                if (status != CMWeatherManager.RequestStatus.COMPLETED
+                        || !weatherInfo.getCity().equals(CITY_NAME)) {
+                    error[0] = true;
+                }
+                signal.countDown();
+            }
+        });
+        try {
+            signal.await();
+            assertFalse(error[0]);
+        } catch (InterruptedException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    @SmallTest
+    public void testCancelRequest() {
+        mWeatherManager.cancelRequest(REQUEST_ID);
+    }
+}

tests/src/org/cyanogenmod/tests/weather/unit/MockWeatherProviderService.java

@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 The CyanogenMod 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 org.cyanogenmod.tests.weather.unit;
+
+import cyanogenmod.weatherservice.ServiceRequest;
+import cyanogenmod.weatherservice.WeatherProviderService;
+import org.mockito.Mockito;
+
+public class MockWeatherProviderService extends WeatherProviderService {
+
+    private MockWeatherProviderService mCallTracker;
+
+    public MockWeatherProviderService() {
+        mCallTracker = Mockito.mock(MockWeatherProviderService.class);
+    }
+
+    public MockWeatherProviderService getCallTracker() {
+        return mCallTracker;
+    }
+
+    @Override
+    protected void onConnected() {
+        mCallTracker.onConnected();
+    }
+
+    @Override
+    protected void onDisconnected() {
+        mCallTracker.onDisconnected();
+    }
+
+    @Override
+    protected void onRequestSubmitted(ServiceRequest request) {
+        mCallTracker.onRequestSubmitted(request);
+    }
+
+    @Override
+    protected void onRequestCancelled(ServiceRequest request) {
+        mCallTracker.onRequestCancelled(request);
+    }
+}

tests/src/org/cyanogenmod/tests/weather/unit/WeatherProviderServiceTest.java

@@ -0,0 +1,302 @@
+/*
+ * Copyright (C) 2016 The CyanogenMod 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 org.cyanogenmod.tests.weather.unit;
+
+import android.location.Location;
+import android.os.IBinder;
+import cyanogenmod.weather.CMWeatherManager;
+import cyanogenmod.weather.RequestInfo;
+import cyanogenmod.weather.WeatherLocation;
+import cyanogenmod.weatherservice.IWeatherProviderService;
+import cyanogenmod.weatherservice.IWeatherProviderServiceClient;
+import cyanogenmod.weatherservice.ServiceRequest;
+import cyanogenmod.weatherservice.ServiceRequestResult;
+import org.cyanogenmod.tests.common.MockIBinderStubForInterface;
+import org.cyanogenmod.tests.common.ThreadServiceTestCase;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+public class WeatherProviderServiceTest extends ThreadServiceTestCase<MockWeatherProviderService> {
+
+    public WeatherProviderServiceTest() {
+        super(MockWeatherProviderService.class);
+    }
+
+    private static final String CITY_NAME = "Seattle";
+
+    public void testCityNameLookupRequest() throws Exception {
+        IBinder binder = bindService((ServiceRunnable) null);
+        assertNotNull(binder);
+
+        final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+        assertNotNull(provider);
+
+        provider.processCityNameLookupRequest(
+                buildMockdRequestInfo(RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ));
+        runOnServiceThread(new Runnable() {
+            @Override
+            public void run() {
+                ArgumentCaptor<ServiceRequest> params
+                        = ArgumentCaptor.forClass(ServiceRequest.class);
+
+                Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+                        .onRequestSubmitted(params.capture());
+
+                ServiceRequest request = params.getValue();
+                assertEquals(request.getRequestInfo().getRequestType(),
+                        RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ);
+
+                assertEquals(request.getRequestInfo().getCityName(), CITY_NAME);
+            }
+        });
+    }
+
+    public void testWeatherUpdateRequestByWeatherLocation() throws Exception {
+        IBinder binder = bindService((ServiceRunnable) null);
+        assertNotNull(binder);
+
+        final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+        assertNotNull(provider);
+
+        provider.processWeatherUpdateRequest(
+                buildMockdRequestInfo(RequestInfo.TYPE_WEATHER_BY_WEATHER_LOCATION_REQ));
+        runOnServiceThread(new Runnable() {
+            @Override
+            public void run() {
+                ArgumentCaptor<ServiceRequest> params
+                        = ArgumentCaptor.forClass(ServiceRequest.class);
+
+                Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+                        .onRequestSubmitted(params.capture());
+
+                ServiceRequest request = params.getValue();
+                assertEquals(request.getRequestInfo().getRequestType(),
+                        RequestInfo.TYPE_WEATHER_BY_WEATHER_LOCATION_REQ);
+
+                WeatherLocation weatherLocation = request.getRequestInfo().getWeatherLocation();
+                assertNotNull(weatherLocation);
+                assertEquals(weatherLocation.getCity(), CITY_NAME);
+            }
+        });
+    }
+
+    public void testWeatherUpdateRequestByGeoLocation() throws Exception {
+        IBinder binder = bindService((ServiceRunnable) null);
+        assertNotNull(binder);
+
+        final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+        assertNotNull(provider);
+
+        provider.processWeatherUpdateRequest(
+                buildMockdRequestInfo(RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ));
+        runOnServiceThread(new Runnable() {
+            @Override
+            public void run() {
+                ArgumentCaptor<ServiceRequest> params
+                        = ArgumentCaptor.forClass(ServiceRequest.class);
+
+                Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+                        .onRequestSubmitted(params.capture());
+
+                ServiceRequest request = params.getValue();
+                assertEquals(request.getRequestInfo().getRequestType(),
+                        RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ);
+
+                Location location = request.getRequestInfo().getLocation();
+                assertNotNull(location);
+            }
+        });
+    }
+
+    public void testServiceRequestResult() throws Exception {
+        final CountDownLatch latch = new CountDownLatch(3);
+        IBinder binder = bindService((ServiceRunnable) null);
+        assertNotNull(binder);
+
+        final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+        assertNotNull(provider);
+
+        IWeatherProviderServiceClient client =
+                MockIBinderStubForInterface.getMockInterface(
+                        IWeatherProviderServiceClient.Stub.class);
+
+        Mockito.doAnswer(new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+                int result = (int) invocation.getArguments()[2];
+
+                assertNotNull(requestInfo);
+                assertEquals(result, CMWeatherManager.RequestStatus.FAILED);
+
+                latch.countDown();
+                return null;
+            }
+        }).when(client)
+                .setServiceRequestState(Mockito.any(RequestInfo.class),
+                        Mockito.any(ServiceRequestResult.class),
+                                Mockito.eq(CMWeatherManager.RequestStatus.FAILED));
+
+        Mockito.doAnswer(new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+
+                RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+                int result = (int) invocation.getArguments()[2];
+
+                assertNotNull(requestInfo);
+                assertEquals(result, CMWeatherManager.RequestStatus.SUBMITTED_TOO_SOON);
+
+                latch.countDown();
+                return null;
+            }
+        }).when(client)
+                .setServiceRequestState(Mockito.any(RequestInfo.class),
+                        Mockito.any(ServiceRequestResult.class),
+                        Mockito.eq(CMWeatherManager.RequestStatus.SUBMITTED_TOO_SOON));
+
+        Mockito.doAnswer(new Answer() {
+            @Override
+            public Object answer(InvocationOnMock invocation) throws Throwable {
+                RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+                ServiceRequestResult requestResult
+                        = (ServiceRequestResult) invocation.getArguments()[1];
+                int result = (int) invocation.getArguments()[2];
+
+                assertNotNull(requestInfo);
+                assertNotNull(requestResult);
+                assertNotNull(requestResult.getLocationLookupList());
+                assertEquals(result, CMWeatherManager.RequestStatus.COMPLETED);
+
+                latch.countDown();
+                return null;
+            }
+        }).when(client)
+                .setServiceRequestState(Mockito.any(RequestInfo.class),
+                        Mockito.any(ServiceRequestResult.class),
+                        Mockito.eq(CMWeatherManager.RequestStatus.COMPLETED));
+
+        provider.setServiceClient(client);
+
+        final RequestInfo requestInfo
+                = buildMockdRequestInfo(RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ);
+
+        Mockito.reset(getService().getCallTracker());
+        provider.processCityNameLookupRequest(requestInfo);
+        runOnServiceThread(new Runnable() {
+            @Override
+            public void run() {
+                ArgumentCaptor<ServiceRequest> params
+                        = ArgumentCaptor.forClass(ServiceRequest.class);
+
+                Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+                        .onRequestSubmitted(params.capture());
+
+                ServiceRequest request = params.getValue();
+                request.fail();
+            }
+        });
+
+        Mockito.reset(getService().getCallTracker());
+        provider.processCityNameLookupRequest(requestInfo);
+        runOnServiceThread(new Runnable() {
+            @Override
+            public void run() {
+                ArgumentCaptor<ServiceRequest> params
+                        = ArgumentCaptor.forClass(ServiceRequest.class);
+
+                Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+                        .onRequestSubmitted(params.capture());
+
+                ServiceRequest request = params.getValue();
+                request.reject(CMWeatherManager.RequestStatus.SUBMITTED_TOO_SOON);
+            }
+        });
+
+        Mockito.reset(getService().getCallTracker());
+        provider.processCityNameLookupRequest(requestInfo);
+        runOnServiceThread(new Runnable() {
+            @Override
+            public void run() {
+                ArgumentCaptor<ServiceRequest> params
+                        = ArgumentCaptor.forClass(ServiceRequest.class);
+
+                Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+                        .onRequestSubmitted(params.capture());
+
+                ServiceRequest request = params.getValue();
+
+                List<WeatherLocation> locations = new ArrayList<>();
+                locations.add(new WeatherLocation.Builder(CITY_NAME).build());
+                ServiceRequestResult result = new ServiceRequestResult.Builder(locations).build();
+                request.complete(result);
+            }
+        });
+
+        try  {
+            latch.await();
+        } catch (InterruptedException e) {
+            throw new AssertionError(e);
+        }
+
+    }
+
+    private RequestInfo buildMockdRequestInfo(int requestType) {
+        try {
+            Constructor<RequestInfo> c = RequestInfo.class.getDeclaredConstructor();
+            c.setAccessible(true);
+            RequestInfo info = c.newInstance();
+            Field type;
+            type = info.getClass().getDeclaredField("mRequestType");
+            type.setAccessible(true);
+            type.set(info, requestType);
+            switch (requestType) {
+                case RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ:
+                    Field cityName;
+                    cityName = info.getClass().getDeclaredField("mCityName");
+                    cityName.setAccessible(true);
+                    cityName.set(info, CITY_NAME);
+                    break;
+                case RequestInfo.TYPE_WEATHER_BY_WEATHER_LOCATION_REQ:
+                    Field weatherLocation;
+                    weatherLocation = info.getClass().getDeclaredField("mWeatherLocation");
+                    weatherLocation.setAccessible(true);
+                    weatherLocation.set(info, new WeatherLocation.Builder(CITY_NAME).build());
+                    break;
+                case RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ:
+                    Field location;
+                    location = info.getClass().getDeclaredField("mLocation");
+                    location.setAccessible(true);
+                    location.set(info, new Location("dummy_location_provider"));
+                    break;
+                default:
+                    throw new AssertionError("Unknown request type");
+            }
+            return info;
+        } catch (Exception e) {
+            throw new AssertionError(e);
+        }
+    }
+}