Support loading sketches from rss/atom feeds

Assets/Editor/Tests/TestBrush.cs

@@ -16,6 +16,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Newtonsoft.Json;
 using NUnit.Framework;
 using UnityEditor;
@@ -64,13 +65,13 @@ void IDisposable.Dispose()
         }
 
         [OneTimeSetUp]
-        public void RunBeforeAnyTests()
+        public async Task RunBeforeAnyTests()
         {
             m_container = new GameObject("Singletons for TestBrush");
             Coords.AsLocal[m_container.transform] = TrTransform.identity;
 
             var path = Path.Combine(Application.dataPath, "../Support/Sketches/PerfTest/Simple.tilt");
-            m_testStrokes = GetStrokesFromTilt(path);
+            m_testStrokes = await GetStrokesFromTiltAsync(path);
 
             if (DevOptions.I == null)
             {
@@ -103,13 +104,13 @@ public void RunAfterAllTests()
         }
 
         /// Returns strokes read from the passed .tilt file
-        public static List<Stroke> GetStrokesFromTilt(string path)
+        public static async Task<List<Stroke>> GetStrokesFromTiltAsync(string path)
         {
             var file = new DiskSceneFileInfo(path, readOnly: true);
             SketchMetadata metadata;
             using (var jsonReader = new JsonTextReader(
                 new StreamReader(
-                    SaveLoadScript.GetMetadataReadStream(file))))
+                    await SaveLoadScript.GetMetadataReadStreamAsync(file))))
             {
                 // TODO: should cache this?
                 var serializer = new JsonSerializer();
@@ -121,7 +122,7 @@ public static List<Stroke> GetStrokesFromTilt(string path)
                 metadata = serializer.Deserialize<SketchMetadata>(jsonReader);
             }
 
-            using (var stream = file.GetReadStream(TiltFile.FN_SKETCH))
+            using (var stream = await file.GetReadStreamAsync(TiltFile.FN_SKETCH))
             {
                 var bufferedStream = new BufferedStream(stream, 4096);
                 return SketchWriter.GetStrokes(

Assets/Editor/Tests/TestDownloadingCache.cs

@@ -0,0 +1,76 @@
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+
+namespace TiltBrush
+{
+    [TestFixture]
+    public class TestDownloadingCache
+    {
+        private DownloadingCache m_dlCache;
+        private FileCache m_Cache;
+        private string m_Path;
+
+        private const string kLocalFile = "file://TestData/main_1.png";
+        private const string kRemoteFile = "http://openbrush.app/assets/icon.png";
+
+        [SetUp]
+        public void Setup()
+        {
+            m_Path = Path.Combine(Path.GetTempPath(), "FileCacheTest");
+            if (File.Exists(m_Path))
+            {
+                File.Delete(m_Path);
+            }
+            if (Directory.Exists(m_Path))
+            {
+                Directory.Delete(m_Path, recursive: true);
+            }
+            m_Cache = new FileCache(m_Path, 1);
+            m_dlCache = new DownloadingCache(m_Cache);
+        }
+
+        [TearDown]
+        public void Teardown()
+        {
+            if (Directory.Exists(m_Path))
+            {
+                Directory.Delete(m_Path, recursive: true);
+            }
+        }
+
+        [Test]
+        public async void LocalFileLoads()
+        {
+            var bytes = await m_dlCache.Read("test", "logo1", kLocalFile);
+            Assert.That(bytes != null);
+            Assert.That(bytes.Length == 32983);
+        }
+
+        [Test]
+        public async void RemoteFileLoads()
+        {
+            var bytes = await m_dlCache.Read("test", "logo1", kRemoteFile);
+            Assert.That(bytes != null);
+            Assert.That(bytes.Length == 32983);
+        }
+
+        [Test]
+        public async void RemoteFileIsStoredInCache()
+        {
+            var bytes = await m_dlCache.Read("test", "logo1", kRemoteFile);
+            Assert.That(m_Cache.CacheSize == 32983);
+        }
+
+        [Test]
+        public async void RemoteFileCanBeLoadedFromCache()
+        {
+            var bytes = await m_dlCache.Read("test", "logo1", kRemoteFile);
+            var bytes2 = m_Cache.Read("test", "logo1");
+            Assert.That(Enumerable.SequenceEqual(bytes, bytes2));
+            var bytes3 = await m_dlCache.Read("test", "logo1", kRemoteFile);
+            Assert.That(Enumerable.SequenceEqual(bytes, bytes3));
+        }
+
+    }
+}

Assets/Editor/Tests/TestFileCache.cs

@@ -0,0 +1,142 @@
+using System.IO;
+using System.Linq;
+using NUnit.Framework;
+
+namespace TiltBrush
+{
+    [TestFixture]
+    internal class TestFileCache
+    {
+        private FileCache m_Cache;
+        private string m_Path;
+        [SetUp]
+        public void Setup()
+        {
+            m_Path = Path.Combine(Path.GetTempPath(), "FileCacheTest");
+            if (File.Exists(m_Path))
+            {
+                File.Delete(m_Path);
+            }
+            if (Directory.Exists(m_Path))
+            {
+                Directory.Delete(m_Path, recursive: true);
+            }
+            m_Cache = new FileCache(m_Path, 1);
+        }
+
+        [TearDown]
+        public void Teardown()
+        {
+            if (Directory.Exists(m_Path))
+            {
+                Directory.Delete(m_Path, recursive: true);
+            }
+        }
+
+        [Test]
+        public void IsDirectoryCreated()
+        {
+            Assert.IsTrue(Directory.Exists(m_Path));
+        }
+
+        [Test]
+        public void IsCacheSizeUpdated()
+        {
+            Assert.That(m_Cache.CacheSize == 0);
+            byte[] bytes = new byte[1000];
+            m_Cache.Write("test", "onethousand", bytes);
+            Assert.That(m_Cache.CacheSize == 1000);
+        }
+
+        [Test]
+        public void IsCacheLimitRespected()
+        {
+            byte[] bytes = new byte[100000];
+            for (int i = 0; i < 11; i++)
+            {
+                m_Cache.Write($"test_{i}", "100kbytes", bytes);
+            }
+            Assert.That(m_Cache.CacheSize == 1000000);
+            var rootDir = new DirectoryInfo(m_Path);
+            Assert.That(rootDir.EnumerateFiles("*", SearchOption.AllDirectories)
+                .Sum(x => x.Length) == 1000000);
+        }
+
+        [Test]
+        public void IsLastCreatedExpunged()
+        {
+            byte[] bytes = new byte[100000];
+            for (int i = 0; i < 11; i++)
+            {
+                m_Cache.Write($"test_{i}", "100kbytes", bytes);
+            }
+            Assert.IsFalse(m_Cache.FilesetExists("test_0"));
+        }
+
+        [Test]
+        public void CanWriteMultipleFilesSetAndFiles()
+        {
+            byte[] bytes = new byte[1000];
+            for (int i = 0; i < 5; i++)
+            {
+                for (int j = 0; j < 5; ++j)
+                {
+                    m_Cache.Write($"test_{i}", $"100kbytes_{j}", bytes);
+                }
+            }
+
+            for (int i = 0; i < 5; i++)
+            {
+                Assert.That(m_Cache.FilesetExists($"test_{i}"));
+                for (int j = 0; j < 5; ++j)
+                {
+                    Assert.That(m_Cache.FileExists($"test_{i}", $"100kbytes_{j}"));
+                }
+            }
+        }
+
+        [Test]
+        public void ThingsThatDontExistDontExist()
+        {
+            byte[] bytes = new byte[1000];
+            m_Cache.Write("Real", "onethousand", bytes);
+
+            Assert.IsFalse(m_Cache.FilesetExists("Imaginary"));
+            Assert.IsFalse(m_Cache.FileExists("Imaginary", "onethousand"));
+            Assert.IsFalse(m_Cache.FileExists("Real", "twothousand"));
+        }
+
+        [Test]
+        public void FilesCanBeDeleted()
+        {
+            byte[] bytes = new byte[1000];
+            m_Cache.Write("Real", "onethousand", bytes);
+            Assert.That(m_Cache.FileExists("Real", "onethousand"));
+            m_Cache.DeleteFile("Real", "onethousand");
+            Assert.That(!m_Cache.FileExists("Real", "onethousand"));
+        }
+
+        [Test]
+        public void FileHasTheRightContents()
+        {
+            byte[] bytes = Enumerable.Range(0, 127).Select(x => (byte)x).ToArray();
+            m_Cache.Write("test", "data", bytes);
+            byte[] read = m_Cache.Read("test", "data");
+            Assert.That(bytes.SequenceEqual(read));
+        }
+
+        [Test]
+        public void TestStreamRead()
+        {
+            byte[] bytes = Enumerable.Range(0, 127).Select(x => (byte)x).ToArray();
+            m_Cache.Write("test", "data", bytes);
+            using (var stream = m_Cache.ReadStream("test", "data"))
+            {
+                for (int i = 0; i < 127; ++i)
+                {
+                    Assert.That(stream.ReadByte() == i);
+                }
+            }
+        }
+    }
+}