Java tutorial
/* * Copyright (C) 2014 The Android Open Source 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 com.android.sdklib.internal.repository; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.sdklib.AndroidLocationTestCase; import com.android.sdklib.internal.repository.DownloadCache.Strategy; import com.android.sdklib.io.FileOp; import com.android.sdklib.io.IFileOp; import com.android.sdklib.io.MockFileOp; import com.android.utils.Pair; import com.google.common.base.Charsets; import org.apache.http.Header; import org.apache.http.HttpResponse; import org.apache.http.ProtocolVersion; import org.apache.http.StatusLine; import org.apache.http.message.BasicHttpResponse; import org.apache.http.message.BasicStatusLine; import java.io.BufferedReader; import java.io.ByteArrayInputStream; import java.io.FileNotFoundException; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.util.Arrays; import java.util.HashMap; import java.util.Map; public class DownloadCacheTest extends AndroidLocationTestCase { private MockFileOp mFileOp; private MockMonitor mMonitor; /** * A private version of DownloadCache that never calls {@link UrlOpener}. */ private static class NoDownloadCache extends DownloadCache { private final Map<String, Pair<InputStream, HttpResponse>> mReplies = new HashMap<String, Pair<InputStream, HttpResponse>>(); public NoDownloadCache(@NonNull Strategy strategy) { super(strategy); } public NoDownloadCache(@NonNull IFileOp fileOp, @NonNull Strategy strategy) { super(fileOp, strategy); } @Override protected Pair<InputStream, HttpResponse> openUrl(@NonNull String url, boolean needsMarkResetSupport, @NonNull ITaskMonitor monitor, @Nullable Header[] headers) throws IOException, CanceledByUserException { Pair<InputStream, HttpResponse> reply = mReplies.get(url); if (reply != null) { return reply; } // http-client's behavior is to return a FNF instead of 404. throw new FileNotFoundException(url); } public void registerResponse(@NonNull String url, int httpCode, @Nullable String content) { InputStream is = null; if (content != null) { is = new ByteArrayInputStream(content.getBytes(Charsets.UTF_8)); } ProtocolVersion p = new ProtocolVersion("HTTP", 1, 1); StatusLine statusLine = new BasicStatusLine(p, httpCode, "Code " + httpCode); HttpResponse httpResponse = new BasicHttpResponse(statusLine); Pair<InputStream, HttpResponse> reply = Pair.of(is, httpResponse); mReplies.put(url, reply); } } @Override public void setUp() throws Exception { super.setUp(); mFileOp = new MockFileOp(); mMonitor = new MockMonitor(); } @Override public void tearDown() throws Exception { super.tearDown(); } public void testMissingResource() throws Exception { // Downloads must fail when using the only-cache strategy and there's nothing in the cache. // In that case, it returns null to indicate the resource is simply not found. // Since the mock implementation always returns a 404 and no stream, there is no // difference between the various cache strategies. mFileOp.reset(); NoDownloadCache d1 = new NoDownloadCache(mFileOp, Strategy.ONLY_CACHE); InputStream is1 = d1.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNull(is1); assertEquals("", mMonitor.getAllCapturedLogs()); assertTrue(mFileOp.hasRecordedExistingFolder(d1.getCacheRoot())); assertEquals("[]", Arrays.toString(mFileOp.getOutputStreams())); // HTTP-Client's behavior is to return a FNF instead of 404 so we'll try that first mFileOp.reset(); NoDownloadCache d2 = new NoDownloadCache(mFileOp, Strategy.DIRECT); try { d2.openCachedUrl("http://www.example.com/download1.xml", mMonitor); fail("Expected: NoDownloadCache.openCachedUrl should have thrown a FileNotFoundException"); } catch (FileNotFoundException e) { assertEquals("http://www.example.com/download1.xml", e.getMessage()); } assertEquals("", mMonitor.getAllCapturedLogs()); assertEquals("[]", Arrays.toString(mFileOp.getOutputStreams())); // Try again but this time we'll define a 404 reply to test the rest of the code path. mFileOp.reset(); d2.registerResponse("http://www.example.com/download1.xml", 404, null); InputStream is2 = d2.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNull(is2); assertEquals("", mMonitor.getAllCapturedLogs()); assertEquals("[]", Arrays.toString(mFileOp.getOutputStreams())); mFileOp.reset(); NoDownloadCache d3 = new NoDownloadCache(mFileOp, Strategy.SERVE_CACHE); d3.registerResponse("http://www.example.com/download1.xml", 404, null); InputStream is3 = d3.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNull(is3); assertEquals("", mMonitor.getAllCapturedLogs()); assertEquals("[]", Arrays.toString(mFileOp.getOutputStreams())); mFileOp.reset(); NoDownloadCache d4 = new NoDownloadCache(mFileOp, Strategy.FRESH_CACHE); d4.registerResponse("http://www.example.com/download1.xml", 404, null); InputStream is4 = d4.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNull(is4); assertEquals("", mMonitor.getAllCapturedLogs()); assertEquals("[]", Arrays.toString(mFileOp.getOutputStreams())); } public void testExistingResource() throws Exception { // The resource exists but only-cache doesn't hit the network so it will // fail when the resource is not cached. mFileOp.reset(); NoDownloadCache d1 = new NoDownloadCache(mFileOp, Strategy.ONLY_CACHE); d1.registerResponse("http://www.example.com/download1.xml", 200, "Blah blah blah"); InputStream is1 = d1.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNull(is1); assertEquals("", mMonitor.getAllCapturedLogs()); assertTrue(mFileOp.hasRecordedExistingFolder(d1.getCacheRoot())); assertEquals("[]", Arrays.toString(mFileOp.getOutputStreams())); // HTTP-Client's behavior is to return a FNF instead of 404 so we'll try that first mFileOp.reset(); NoDownloadCache d2 = new NoDownloadCache(mFileOp, Strategy.DIRECT); d2.registerResponse("http://www.example.com/download1.xml", 200, "Blah blah blah"); InputStream is2 = d2.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNotNull(is2); assertEquals("Blah blah blah", new BufferedReader(new InputStreamReader(is2, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertEquals("[]", Arrays.toString(mFileOp.getOutputStreams())); mFileOp.reset(); NoDownloadCache d3 = new NoDownloadCache(mFileOp, Strategy.SERVE_CACHE); d3.registerResponse("http://www.example.com/download1.xml", 200, "Blah blah blah"); InputStream is3 = d3.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNotNull(is3); assertEquals("Blah blah blah", new BufferedReader(new InputStreamReader(is3, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertEquals("[<$CACHE/sdkbin-1_9b8dc757-download1_xml: 'Blah blah blah'>, " + "<$CACHE/sdkinf-1_9b8dc757-download1_xml: '### Meta data for SDK Manager cache. Do not modify.\n" + "#<creation timestamp>\n" + "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n" + "'>]", sanitize(d3, Arrays.toString(mFileOp.getOutputStreams()))); mFileOp.reset(); NoDownloadCache d4 = new NoDownloadCache(mFileOp, Strategy.FRESH_CACHE); d4.registerResponse("http://www.example.com/download1.xml", 200, "Blah blah blah"); InputStream is4 = d4.openCachedUrl("http://www.example.com/download1.xml", mMonitor); assertNotNull(is4); assertEquals("Blah blah blah", new BufferedReader(new InputStreamReader(is4, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertEquals("[<$CACHE/sdkbin-1_9b8dc757-download1_xml: 'Blah blah blah'>, " + "<$CACHE/sdkinf-1_9b8dc757-download1_xml: '### Meta data for SDK Manager cache. Do not modify.\n" + "#<creation timestamp>\n" + "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n" + "'>]", sanitize(d4, Arrays.toString(mFileOp.getOutputStreams()))); } public void testCachedResource() throws Exception { mFileOp.reset(); NoDownloadCache d1 = new NoDownloadCache(mFileOp, Strategy.ONLY_CACHE); d1.registerResponse("http://www.example.com/download1.xml", 200, "This is the new content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d1.getCacheRoot(), "sdkbin-1_9b8dc757-download1_xml")), 123456L, "This is the cached content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d1.getCacheRoot(), "sdkinf-1_9b8dc757-download1_xml")), 123456L, "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n"); InputStream is1 = d1.openCachedUrl("http://www.example.com/download1.xml", mMonitor); // Only-cache strategy returns the value from the cache, not the actual resource. assertEquals("This is the cached content", new BufferedReader(new InputStreamReader(is1, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertTrue(mFileOp.hasRecordedExistingFolder(d1.getCacheRoot())); // The cache hasn't been modified, only read assertEquals("[]", sanitize(d1, Arrays.toString(mFileOp.getOutputStreams()))); // Direct ignores the cache. mFileOp.reset(); NoDownloadCache d2 = new NoDownloadCache(mFileOp, Strategy.DIRECT); d2.registerResponse("http://www.example.com/download1.xml", 200, "This is the new content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d2.getCacheRoot(), "sdkbin-1_9b8dc757-download1_xml")), 123456L, "This is the cached content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d2.getCacheRoot(), "sdkinf-1_9b8dc757-download1_xml")), 123456L, "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n"); InputStream is2 = d2.openCachedUrl("http://www.example.com/download1.xml", mMonitor); // Direct strategy ignores the cache. assertEquals("This is the new content", new BufferedReader(new InputStreamReader(is2, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertTrue(mFileOp.hasRecordedExistingFolder(d2.getCacheRoot())); // Direct strategy doesn't update the cache. assertEquals("[]", sanitize(d2, Arrays.toString(mFileOp.getOutputStreams()))); // Serve-cache reads from the cache if available, ignoring its freshness (here the timestamp // is way older than the 10-minute freshness encoded in the DownloadCache.) mFileOp.reset(); NoDownloadCache d3 = new NoDownloadCache(mFileOp, Strategy.SERVE_CACHE); d3.registerResponse("http://www.example.com/download1.xml", 200, "This is the new content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d3.getCacheRoot(), "sdkbin-1_9b8dc757-download1_xml")), 123456L, "This is the cached content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d3.getCacheRoot(), "sdkinf-1_9b8dc757-download1_xml")), 123456L, "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n"); InputStream is3 = d3.openCachedUrl("http://www.example.com/download1.xml", mMonitor); // We get content from the cache. assertEquals("This is the cached content", new BufferedReader(new InputStreamReader(is3, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertTrue(mFileOp.hasRecordedExistingFolder(d3.getCacheRoot())); // Cache isn't updated since nothing fresh was read. assertEquals("[]", sanitize(d3, Arrays.toString(mFileOp.getOutputStreams()))); // fresh-cache reads the cache, finds it stale (here the timestamp // is way older than the 10-minute freshness encoded in the DownloadCache) // and will fetch the new resource instead and update the cache. mFileOp.reset(); NoDownloadCache d4 = new NoDownloadCache(mFileOp, Strategy.FRESH_CACHE); d4.registerResponse("http://www.example.com/download1.xml", 200, "This is the new content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d4.getCacheRoot(), "sdkbin-1_9b8dc757-download1_xml")), 123456L, "This is the cached content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d4.getCacheRoot(), "sdkinf-1_9b8dc757-download1_xml")), 123456L, "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n"); InputStream is4 = d4.openCachedUrl("http://www.example.com/download1.xml", mMonitor); // Cache is discarded, actual resource is returned. assertEquals("This is the new content", new BufferedReader(new InputStreamReader(is4, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertTrue(mFileOp.hasRecordedExistingFolder(d4.getCacheRoot())); // Cache isn updated since something fresh was read. assertEquals("[<$CACHE/sdkbin-1_9b8dc757-download1_xml: 'This is the new content'>, " + "<$CACHE/sdkinf-1_9b8dc757-download1_xml: '### Meta data for SDK Manager cache. Do not modify.\n" + "#<creation timestamp>\n" + "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n" + "'>]", sanitize(d4, Arrays.toString(mFileOp.getOutputStreams()))); // fresh-cache reads the cache, finds it still valid stale (less than 10-minute old), // and uses the cached resource. mFileOp.reset(); NoDownloadCache d5 = new NoDownloadCache(mFileOp, Strategy.FRESH_CACHE); d5.registerResponse("http://www.example.com/download1.xml", 200, "This is the new content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d5.getCacheRoot(), "sdkbin-1_9b8dc757-download1_xml")), System.currentTimeMillis() - 1000, "This is the cached content"); mFileOp.recordExistingFile( mFileOp.getAgnosticAbsPath(FileOp.append(d5.getCacheRoot(), "sdkinf-1_9b8dc757-download1_xml")), System.currentTimeMillis() - 1000, "URL=http\\://www.example.com/download1.xml\n" + "Status-Code=200\n"); InputStream is5 = d5.openCachedUrl("http://www.example.com/download1.xml", mMonitor); // Cache is used. assertEquals("This is the cached content", new BufferedReader(new InputStreamReader(is5, Charsets.UTF_8)).readLine()); assertEquals("", mMonitor.getAllCapturedLogs()); assertTrue(mFileOp.hasRecordedExistingFolder(d5.getCacheRoot())); // Cache isn't updated since nothing fresh was read. assertEquals("[]", sanitize(d5, Arrays.toString(mFileOp.getOutputStreams()))); } // -------- @Nullable private String sanitize(@NonNull DownloadCache dc, @Nullable String msg) { if (msg != null) { msg = msg.replace("\r\n", "\n"); String absRoot = mFileOp.getAgnosticAbsPath(dc.getCacheRoot()); msg = msg.replace(absRoot, "$CACHE"); // Cached files also contain a creation timestamp which we need to find and remove. msg = msg.replaceAll("\n#[A-Z][A-Za-z0-9: ]+20[0-9]{2}\n", "\n#<creation timestamp>\n"); } return msg; } }