Serialize threading for download manager testing.
[android/platform/packages/providers/DownloadProvider.git] / tests / src / com / android / providers / downloads / AbstractDownloadManagerFunctionalTest.java
1 /*
2  * Copyright (C) 2010 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.providers.downloads;
18
19 import android.content.ComponentName;
20 import android.content.ContentResolver;
21 import android.content.Context;
22 import android.content.Intent;
23 import android.database.ContentObserver;
24 import android.database.Cursor;
25 import android.net.Uri;
26 import android.provider.Downloads;
27 import android.test.MoreAsserts;
28 import android.test.RenamingDelegatingContext;
29 import android.test.ServiceTestCase;
30 import android.test.mock.MockContentResolver;
31 import android.util.Log;
32 import tests.http.MockResponse;
33 import tests.http.MockWebServer;
34 import tests.http.RecordedRequest;
35
36 import java.io.BufferedReader;
37 import java.io.File;
38 import java.io.IOException;
39 import java.io.InputStream;
40 import java.io.InputStreamReader;
41 import java.net.MalformedURLException;
42 import java.util.Arrays;
43 import java.util.HashSet;
44 import java.util.Set;
45
46 public abstract class AbstractDownloadManagerFunctionalTest extends
47         ServiceTestCase<DownloadService> {
48
49     protected static final String LOG_TAG = "DownloadManagerFunctionalTest";
50     private static final String PROVIDER_AUTHORITY = "downloads";
51     protected static final long RETRY_DELAY_MILLIS = 61 * 1000;
52     protected static final String FILE_CONTENT = "hello world";
53     protected static final int HTTP_OK = 200;
54     protected static final int HTTP_PARTIAL_CONTENT = 206;
55     protected static final int HTTP_NOT_FOUND = 404;
56     protected static final int HTTP_SERVICE_UNAVAILABLE = 503;
57
58     protected MockWebServer mServer;
59     protected MockContentResolverWithNotify mResolver;
60     protected TestContext mTestContext;
61     protected FakeSystemFacade mSystemFacade;
62
63     static class MockContentResolverWithNotify extends MockContentResolver {
64         public boolean mNotifyWasCalled = false;
65
66         public synchronized void resetNotified() {
67             mNotifyWasCalled = false;
68         }
69
70         @Override
71         public synchronized void notifyChange(Uri uri, ContentObserver observer,
72                 boolean syncToNetwork) {
73             mNotifyWasCalled = true;
74             notifyAll();
75         }
76     }
77
78     /**
79      * Context passed to the provider and the service.  Allows most methods to pass through to the
80      * real Context (this is a LargeTest), with a few exceptions, including renaming file operations
81      * to avoid file and DB conflicts (via RenamingDelegatingContext).
82      */
83     static class TestContext extends RenamingDelegatingContext {
84         private static final String FILENAME_PREFIX = "test.";
85
86         private Context mRealContext;
87         private Set<String> mAllowedSystemServices;
88         private ContentResolver mResolver;
89
90         boolean mHasServiceBeenStarted = false;
91
92         public TestContext(Context realContext) {
93             super(realContext, FILENAME_PREFIX);
94             mRealContext = realContext;
95             mAllowedSystemServices = new HashSet<String>(Arrays.asList(new String[] {
96                     Context.NOTIFICATION_SERVICE,
97                     Context.POWER_SERVICE,
98             }));
99         }
100
101         public void setResolver(ContentResolver resolver) {
102             mResolver = resolver;
103         }
104
105         /**
106          * Direct DownloadService to our test instance of DownloadProvider.
107          */
108         @Override
109         public ContentResolver getContentResolver() {
110             assert mResolver != null;
111             return mResolver;
112         }
113
114         /**
115          * Stub some system services, allow access to others, and block the rest.
116          */
117         @Override
118         public Object getSystemService(String name) {
119             if (mAllowedSystemServices.contains(name)) {
120                 return mRealContext.getSystemService(name);
121             }
122             return super.getSystemService(name);
123         }
124
125         /**
126          * Record when DownloadProvider starts DownloadService.
127          */
128         @Override
129         public ComponentName startService(Intent service) {
130             if (service.getComponent().getClassName().equals(DownloadService.class.getName())) {
131                 mHasServiceBeenStarted = true;
132                 return service.getComponent();
133             }
134             throw new UnsupportedOperationException("Unexpected service: " + service);
135         }
136     }
137
138     public AbstractDownloadManagerFunctionalTest(FakeSystemFacade systemFacade) {
139         super(DownloadService.class);
140         mSystemFacade = systemFacade;
141     }
142
143     @Override
144     protected void setUp() throws Exception {
145         super.setUp();
146
147         Context realContext = getContext();
148         mTestContext = new TestContext(realContext);
149         setupProviderAndResolver();
150         assert isDatabaseEmpty(); // ensure we're not messing with real data
151
152         mTestContext.setResolver(mResolver);
153         setContext(mTestContext);
154         setupService();
155         getService().mSystemFacade = mSystemFacade;
156
157         mServer = new MockWebServer();
158         mServer.play();
159     }
160
161     @Override
162     protected void tearDown() throws Exception {
163         cleanUpDownloads();
164         super.tearDown();
165     }
166
167     private boolean isDatabaseEmpty() {
168         Cursor cursor = mResolver.query(Downloads.CONTENT_URI, null, null, null, null);
169         try {
170             return cursor.getCount() == 0;
171         } finally {
172             cursor.close();
173         }
174     }
175
176     void setupProviderAndResolver() {
177         DownloadProvider provider = new DownloadProvider();
178         provider.mSystemFacade = mSystemFacade;
179         provider.attachInfo(mTestContext, null);
180         mResolver = new MockContentResolverWithNotify();
181         mResolver.addProvider(PROVIDER_AUTHORITY, provider);
182     }
183
184     /**
185      * Remove any downloaded files and delete any lingering downloads.
186      */
187     void cleanUpDownloads() {
188         if (mResolver == null) {
189             return;
190         }
191         String[] columns = new String[] {Downloads._DATA};
192         Cursor cursor = mResolver.query(Downloads.CONTENT_URI, columns, null, null, null);
193         try {
194             for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) {
195                 String filePath = cursor.getString(0);
196                 if (filePath == null) continue;
197                 Log.d(LOG_TAG, "Deleting " + filePath);
198                 new File(filePath).delete();
199             }
200         } finally {
201             cursor.close();
202         }
203         mResolver.delete(Downloads.CONTENT_URI, null, null);
204     }
205
206     /**
207      * Enqueue a response from the MockWebServer.
208      */
209     MockResponse enqueueResponse(int status, String body) {
210         MockResponse response = new MockResponse()
211                                 .setResponseCode(status)
212                                 .setBody(body);
213         response.addHeader("Content-type", "text/plain");
214         mServer.enqueue(response);
215         return response;
216     }
217
218     MockResponse enqueueEmptyResponse(int status) {
219         return enqueueResponse(status, "");
220     }
221
222     /**
223      * Fetch the last request received by the MockWebServer.
224      */
225     protected RecordedRequest takeRequest() throws InterruptedException {
226         RecordedRequest request = mServer.takeRequestWithTimeout(0);
227         assertNotNull("Expected request was not made", request);
228         return request;
229     }
230
231     String getServerUri(String path) throws MalformedURLException {
232         return mServer.getUrl(path).toString();
233     }
234
235     public void runService() throws Exception {
236         startService(null);
237         mSystemFacade.runAllThreads();
238         mServer.checkForExceptions();
239     }
240
241     protected String readStream(InputStream inputStream) throws IOException {
242         BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
243         try {
244             char[] buffer = new char[1024];
245             int length = reader.read(buffer);
246             assertTrue("Failed to read anything from input stream", length > -1);
247             return String.valueOf(buffer, 0, length);
248         } finally {
249             reader.close();
250         }
251     }
252
253     protected void assertStartsWith(String expectedPrefix, String actual) {
254         String regex = "^" + expectedPrefix + ".*";
255         MoreAsserts.assertMatchesRegex(regex, actual);
256     }
257 }