1 /*
2  * Copyright (C) 2007 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 android.test;
18 
19 import com.google.android.collect.Sets;
20 
21 import android.content.Context;
22 import android.content.ContextWrapper;
23 import android.content.ContentProvider;
24 import android.database.DatabaseErrorHandler;
25 import android.database.sqlite.SQLiteDatabase;
26 import android.os.FileUtils;
27 import android.util.Log;
28 
29 import java.io.File;
30 import java.io.FileInputStream;
31 import java.io.FileNotFoundException;
32 import java.io.FileOutputStream;
33 import java.util.Set;
34 
35 /**
36  * This is a class which delegates to the given context, but performs database
37  * and file operations with a renamed database/file name (prefixes default
38  * names with a given prefix).
39  */
40 public class RenamingDelegatingContext extends ContextWrapper {
41 
42     private Context mFileContext;
43     private String mFilePrefix = null;
44     private File mCacheDir;
45     private final Object mSync = new Object();
46 
47     private Set<String> mDatabaseNames = Sets.newHashSet();
48     private Set<String> mFileNames = Sets.newHashSet();
49 
providerWithRenamedContext( Class<T> contentProvider, Context c, String filePrefix)50     public static <T extends ContentProvider> T providerWithRenamedContext(
51             Class<T> contentProvider, Context c, String filePrefix)
52             throws IllegalAccessException, InstantiationException {
53         return providerWithRenamedContext(contentProvider, c, filePrefix, false);
54     }
55 
providerWithRenamedContext( Class<T> contentProvider, Context c, String filePrefix, boolean allowAccessToExistingFilesAndDbs)56     public static <T extends ContentProvider> T providerWithRenamedContext(
57             Class<T> contentProvider, Context c, String filePrefix,
58             boolean allowAccessToExistingFilesAndDbs)
59             throws IllegalAccessException, InstantiationException {
60         Class<T> mProviderClass = contentProvider;
61         T mProvider = mProviderClass.newInstance();
62         RenamingDelegatingContext mContext = new RenamingDelegatingContext(c, filePrefix);
63         if (allowAccessToExistingFilesAndDbs) {
64             mContext.makeExistingFilesAndDbsAccessible();
65         }
66         mProvider.attachInfoForTesting(mContext, null);
67         return mProvider;
68     }
69 
70     /**
71      * Makes accessible all files and databases whose names match the filePrefix that was passed to
72      * the constructor. Normally only files and databases that were created through this context are
73      * accessible.
74      */
makeExistingFilesAndDbsAccessible()75     public void makeExistingFilesAndDbsAccessible() {
76         String[] databaseList = mFileContext.databaseList();
77         for (String diskName : databaseList) {
78             if (shouldDiskNameBeVisible(diskName)) {
79                 mDatabaseNames.add(publicNameFromDiskName(diskName));
80             }
81         }
82         String[] fileList = mFileContext.fileList();
83         for (String diskName : fileList) {
84             if (shouldDiskNameBeVisible(diskName)) {
85                 mFileNames.add(publicNameFromDiskName(diskName));
86             }
87         }
88     }
89 
90     /**
91      * Returns if the given diskName starts with the given prefix or not.
92      * @param diskName name of the database/file.
93      */
shouldDiskNameBeVisible(String diskName)94     boolean shouldDiskNameBeVisible(String diskName) {
95         return diskName.startsWith(mFilePrefix);
96     }
97 
98     /**
99      * Returns the public name (everything following the prefix) of the given diskName.
100      * @param diskName name of the database/file.
101      */
publicNameFromDiskName(String diskName)102     String publicNameFromDiskName(String diskName) {
103         if (!shouldDiskNameBeVisible(diskName)) {
104             throw new IllegalArgumentException("disk file should not be visible: " + diskName);
105         }
106         return diskName.substring(mFilePrefix.length(), diskName.length());
107     }
108 
109     /**
110      * @param context : the context that will be delegated.
111      * @param filePrefix : a prefix with which database and file names will be
112      * prefixed.
113      */
RenamingDelegatingContext(Context context, String filePrefix)114     public RenamingDelegatingContext(Context context, String filePrefix) {
115         super(context);
116         mFileContext = context;
117         mFilePrefix = filePrefix;
118     }
119 
120     /**
121      * @param context : the context that will be delegated.
122      * @param fileContext : the context that file and db methods will be delegated to
123      * @param filePrefix : a prefix with which database and file names will be
124      * prefixed.
125      */
RenamingDelegatingContext(Context context, Context fileContext, String filePrefix)126     public RenamingDelegatingContext(Context context, Context fileContext, String filePrefix) {
127         super(context);
128         mFileContext = fileContext;
129         mFilePrefix = filePrefix;
130     }
131 
getDatabasePrefix()132     public String getDatabasePrefix() {
133         return mFilePrefix;
134     }
135 
renamedFileName(String name)136     private String renamedFileName(String name) {
137         return mFilePrefix + name;
138     }
139 
140     @Override
openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory)141     public SQLiteDatabase openOrCreateDatabase(String name,
142             int mode, SQLiteDatabase.CursorFactory factory) {
143         final String internalName = renamedFileName(name);
144         if (!mDatabaseNames.contains(name)) {
145             mDatabaseNames.add(name);
146             mFileContext.deleteDatabase(internalName);
147         }
148         return mFileContext.openOrCreateDatabase(internalName, mode, factory);
149     }
150 
151     @Override
openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler)152     public SQLiteDatabase openOrCreateDatabase(String name,
153             int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
154         final String internalName = renamedFileName(name);
155         if (!mDatabaseNames.contains(name)) {
156             mDatabaseNames.add(name);
157             mFileContext.deleteDatabase(internalName);
158         }
159         return mFileContext.openOrCreateDatabase(internalName, mode, factory, errorHandler);
160     }
161 
162     @Override
deleteDatabase(String name)163     public boolean deleteDatabase(String name) {
164         if (mDatabaseNames.contains(name)) {
165             mDatabaseNames.remove(name);
166             return mFileContext.deleteDatabase(renamedFileName(name));
167         } else {
168             return false;
169         }
170     }
171 
172     @Override
getDatabasePath(String name)173     public File getDatabasePath(String name) {
174         return mFileContext.getDatabasePath(renamedFileName(name));
175     }
176 
177     @Override
databaseList()178     public String[] databaseList() {
179         return mDatabaseNames.toArray(new String[]{});
180     }
181 
182     @Override
openFileInput(String name)183     public FileInputStream openFileInput(String name)
184             throws FileNotFoundException {
185         final String internalName = renamedFileName(name);
186         if (mFileNames.contains(name)) {
187             return mFileContext.openFileInput(internalName);
188         } else {
189             throw new FileNotFoundException(internalName);
190         }
191     }
192 
193     @Override
openFileOutput(String name, int mode)194     public FileOutputStream openFileOutput(String name, int mode)
195             throws FileNotFoundException {
196         mFileNames.add(name);
197         return mFileContext.openFileOutput(renamedFileName(name), mode);
198     }
199 
200     @Override
getFileStreamPath(String name)201     public File getFileStreamPath(String name) {
202         return mFileContext.getFileStreamPath(renamedFileName(name));
203     }
204 
205     @Override
deleteFile(String name)206     public boolean deleteFile(String name) {
207         if (mFileNames.contains(name)) {
208             mFileNames.remove(name);
209             return mFileContext.deleteFile(renamedFileName(name));
210         } else {
211             return false;
212         }
213     }
214 
215     @Override
fileList()216     public String[] fileList() {
217         return mFileNames.toArray(new String[]{});
218     }
219 
220     /**
221      * In order to support calls to getCacheDir(), we create a temp cache dir (inside the real
222      * one) and return it instead.  This code is basically getCacheDir(), except it uses the real
223      * cache dir as the parent directory and creates a test cache dir inside that.
224      */
225     @Override
getCacheDir()226     public File getCacheDir() {
227         synchronized (mSync) {
228             if (mCacheDir == null) {
229                 mCacheDir = new File(mFileContext.getCacheDir(), renamedFileName("cache"));
230             }
231             if (!mCacheDir.exists()) {
232                 if(!mCacheDir.mkdirs()) {
233                     Log.w("RenamingDelegatingContext", "Unable to create cache directory");
234                     return null;
235                 }
236                 FileUtils.setPermissions(
237                         mCacheDir.getPath(),
238                         FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH,
239                         -1, -1);
240             }
241         }
242         return mCacheDir;
243     }
244 
245 
246 //    /**
247 //     * Given an array of files returns only those whose names indicate that they belong to this
248 //     * context.
249 //     * @param allFiles the original list of files
250 //     * @return the pruned list of files
251 //     */
252 //    private String[] prunedFileList(String[] allFiles) {
253 //        List<String> files = Lists.newArrayList();
254 //        for (String file : allFiles) {
255 //            if (file.startsWith(mFilePrefix)) {
256 //                files.add(file);
257 //            }
258 //        }
259 //        return files.toArray(new String[]{});
260 //    }
261 }
262