public void DetachAddSubfolderTest()
        {
            string subFolderName = "DetachSubfolderTest";

            int initialSubfoldersCount = FixtureRootRepoFolder.SubFolders.Count;

            IFolder subfolder1 = (IFolder)FixtureRootRepoFolder.CreateSubfolder(subFolderName);

            Assert.AreEqual(initialSubfoldersCount + 1, FixtureRootRepoFolder.SubFolders.Count
                            , "Subfolders count not incremented by creating new subfolder");

            string fullPath = subfolder1.FullPath;

            Assert.IsNotNull(FixtureRootRepoFolder.GetSubFolder(subFolderName), "Making sure new folder is found by parent");

            bool detached = FixtureRootRepoFolder.RemoveFromChildList(subfolder1, true);

            Assert.IsTrue(detached, "Detach real subfolder returned failure");
            detached = FixtureRootRepoFolder.RemoveFromChildList(subfolder1, true);
            Assert.IsFalse(detached, "Detach already detached subfolder returned success");

            Assert.IsTrue(subfolder1.IsDetached);
            Assert.IsNull(subfolder1.ParentFolder);

            Assert.IsNull(FixtureRootRepoFolder.GetSubFolder(subFolderName), "Detached subfolder is still found by parent");

            FixtureRootRepoFolder.AddToChildList(subfolder1, true);

            Assert.IsNotNull(FixtureRootRepoFolder.GetSubFolder(subFolderName), "Re-added after detach still not found by parent");
        }
        public void CoderEncryptorConfigTest()
        {
            const string topFolderName = "CoderEncryptorConfigTest";

            IFolder topFolder = (IFolder)FixtureRootRepoFolder.GetSubFolder(topFolderName);

            if (topFolder != null)
            {
                topFolder.Delete(true, true);
            }

            topFolder = (IFolder)FixtureRootRepoFolder.CreateSubfolder(topFolderName);

            var targetFolder = topFolder.GetDescendant("Intermediate/Target", true);

            Assert.AreEqual(string.Empty, targetFolder.Properties.Encryptor);
            Assert.AreEqual(string.Empty, targetFolder.Properties.Compressor);

            const string coderKey = "my-coder";
            const string encKey   = "my-encryptor";

            using (var repo1 = GetStandaloneRepository())
            {
                var topFolderInner = repo1.RootFolder.GetDescendant(topFolder.LogicalPath, false);
                Assume.That(null != topFolderInner);

                Assert.Throws <ArgumentException>(() => topFolderInner.Properties.Compressor = coderKey);
                Assert.Throws <ArgumentException>(() => topFolderInner.Properties.Encryptor  = encKey);

                repo1.ObjectFactory.AddCompressor(new CoderMock(coderKey), false);
                repo1.ObjectFactory.AddEncryptor(new CoderMock(encKey), false);

                topFolderInner.Properties.Compressor       = coderKey;
                topFolderInner.Properties.Encryptor        = encKey;
                topFolderInner.Properties.EnableEncryption = true;

                Assert.AreEqual(coderKey, topFolderInner.Properties.Compressor);
                Assert.AreEqual(encKey, topFolderInner.Properties.Encryptor);

                var targetFolderInner = repo1.RootFolder.GetDescendant(targetFolder.LogicalPath, false);
                Assume.That(null != targetFolderInner);

                Assert.AreEqual(coderKey, targetFolderInner.Properties.Compressor);
                Assert.AreEqual(encKey, targetFolderInner.Properties.Encryptor);
            }

            using (var repo1 = GetStandaloneRepository())
            {
                var topFolderInner = repo1.RootFolder.GetDescendant(topFolder.LogicalPath, false);
                Assume.That(null != topFolderInner);

                repo1.ObjectFactory.AddCompressor(new CoderMock(coderKey), false);
                repo1.ObjectFactory.AddEncryptor(new CoderMock(encKey), false);

                var targetFolderInner = repo1.RootFolder.GetDescendant(targetFolder.LogicalPath, false);
                Assume.That(null != targetFolderInner);

                Assert.AreEqual(coderKey, targetFolderInner.Properties.Compressor);
                Assert.AreEqual(encKey, targetFolderInner.Properties.Encryptor);

                using (var writer = targetFolderInner.GetWriter())
                {
                    IDataRouter dataRouter = new Mock.NumberedDataRouter(2);
                    writer.DataRouter = dataRouter;
                    writer.AllowSubfoldersCreation = true;

                    IDataItem[] data = RepositoryWriterTest.GetTestData(100, DateTime.Now, 2);

                    for (int n = 0; n < 100; ++n)
                    {
                        writer.Write(data[n]);
                    }
                    //writer.Flush();
                    // flushes data
                    writer.Close();

                    var enm = targetFolderInner.SubFolders.GetEnumerator();
                    Assert.IsTrue(enm.MoveNext());
                    var dataFile = ((IFolder)enm.Current).RootDataFolder.FindFirstDataFile(false);
                    Assert.IsNotNull(dataFile);

                    Assert.IsTrue(dataFile.Path.EndsWith(encKey));

                    using (var reader = targetFolderInner.GetReader(DateTime.MinValue, true))
                    {
                        IDataItem[] dataRead = new IDataItem[data.Length];
                        int         n        = 0;
                        while (reader.HasData)
                        {
                            dataRead[n] = reader.Read().DataItem;
                            Assert.AreEqual(data[n], dataRead[n]);
                            ++n;
                        }
                        Assert.AreEqual(data.Length, n);
                    }
                }
            }
        }
Example #3
0
        public void QuickReaderTest()
        {
            string            targetFolderName = "QuickReaderTest";
            IRepositoryFolder targetFolder     = FixtureRootRepoFolder.GetSubFolder(targetFolderName);

            if (targetFolder != null)
            {
                targetFolder.Delete(true, true);
            }
            targetFolder = FixtureRootRepoFolder.CreateSubfolder(targetFolderName);

            string targetFolderPath = targetFolder.FullPath;

            const int subfolderCount     = 3;
            const int itemsIntervalHours = 1;
            const int desiredFileSize    = 2000;

            targetFolder.Properties.DesiredItemsPerFile = desiredFileSize;
            IRepositoryWriter writer = targetFolder.GetWriter();

            IDataRouter dataRouter = new NumberedDataRouter(subfolderCount);

            writer.DataRouter = dataRouter;
            writer.AllowSubfoldersCreation = true;

            DateTime firstTime  = DateTime.Now.AddDays(-10);
            DateTime lastTime   = DateTime.MinValue;
            int      itemsCount = 100000;
            int      n;

            for (n = 0; n < itemsCount; ++n)
            {
                Mock.TestDataItem item = Mock.TestDataItem.GetTestItem(n);
                lastTime      = firstTime.AddHours(n * itemsIntervalHours);
                item.DateTime = lastTime;
                writer.Write(item);
            }

            writer.Flush();
            writer.Close();
            // will test lazy loading
            targetFolder.UnloadSubfolders();

            Assert.IsTrue(targetFolder.SubFolders.Count == subfolderCount, "Router had to make writer create the configured number of subfolders");

            IRepositoryFolder firstItemSubfolder = targetFolder.GetDescendant(
                dataRouter.GetRelativePath(Mock.TestDataItem.GetTestItem(0)), false);

            Assert.AreEqual(firstTime, firstItemSubfolder.FirstTimestamp
                            , "Fisrt item timestamp reported incorrectly by Folder.FirstTimestamp");

            Assert.AreEqual(firstTime, targetFolder.GetFirstItemTimestamp(true, false)
                            , "Fisrt item timestamp reported incorrectly by Folder.GetFirstItemTimestamp");

            IRepositoryReader reader = targetFolder.GetReader(firstTime, true);

            Assert.IsTrue(reader.HasData, "Folder just populated but no data can be read");

            IDataItemRead ritem = null;

            n = 0;

            IRepositoryReader  altReader          = null;
            SeekStatusListener seekStatusListener = new SeekStatusListener();

            while (reader.HasData)
            {
                if (n > 0 && n % 100 == 0)
                {
                    altReader = Repository.ObjectFactory.GetReader(reader.Position, seekStatusListener.HanldeStatus);
                }
                ritem = reader.Read();
                Assert.IsNotNull(ritem, "reader.Read() returned null after returning true from HasData");
                Assert.AreNotSame(targetFolder, ritem.RepositoryFolder, "Router failed");

                Assert.IsInstanceOf <Mock.TestDataItem>(ritem.DataItem, "Data item read from repository is of different type");
                Assert.AreEqual(firstTime.AddHours(n * itemsIntervalHours), ritem.DataItem.DateTime);
                ((Mock.TestDataItem)ritem.DataItem).Check(n);

                if (altReader != null)
                {
                    IDataItemRead altItem = altReader.Read();
                    Assert.AreEqual(ritem.DataItem.DateTime, altItem.DataItem.DateTime);
                    Assert.AreEqual(0, seekStatusListener.Statuses.Count);
                }

                ++n;
            }

            Assert.AreEqual(lastTime, ritem.DataItem.DateTime, "Last item has unexpected timestamp");
            Assert.AreEqual(itemsCount, n, "Unexpected number of data items read");

            DateTime timestampToSeek = firstTime.AddHours(desiredFileSize / 3 * itemsIntervalHours);

            reader.Seek(timestampToSeek);
            Assert.IsTrue(reader.HasData, "Repeated Seek after reading all failed");
            ritem = reader.Read();
            Assert.IsNotNull(ritem);

            Assert.AreEqual(timestampToSeek, ritem.DataItem.DateTime, "First read item timestamp unexpected");

            reader.Direction = bfs.Repository.Util.EnumerationDirection.Backwards;

            Assert.IsTrue(reader.HasData, "No data after reversing in the middle of data");
            //ritem = reader.Read();
            //Assert.AreEqual<DateTime>(timestampToSeek, ritem.DataItem.DateTime
            //	, "First read item timestamp unexpected after changing direction");
            n         = 0;
            altReader = null;

            while (reader.HasData)
            {
                if (n > 0 && n % 100 == 0)
                {
                    if (altReader != null)
                    {
                        altReader.Dispose();
                    }
                    altReader = Repository.ObjectFactory.GetReader(reader.Position, seekStatusListener.HanldeStatus);
                }
                ritem = reader.Read();
                Assert.IsNotNull(ritem, "reader.Read() returned null after returning true from HasData");
                Assert.AreEqual(timestampToSeek.AddHours(-n * itemsIntervalHours), ritem.DataItem.DateTime);

                if (altReader != null)
                {
                    IDataItemRead altItem = altReader.Read();
                    Assert.AreEqual(ritem.DataItem.DateTime, altItem.DataItem.DateTime);
                }

                ++n;
            }

            Assert.AreEqual(firstTime, ritem.DataItem.DateTime, "Did not pick up first item after reversing");

            // reversing after reaching end
            reader.Direction = bfs.Repository.Util.EnumerationDirection.Forwards;
            ritem            = reader.Read();
            Assert.IsNotNull(ritem, "Did not read firts item reversing after reaching end");

            Assert.AreEqual(firstTime, ritem.DataItem.DateTime, "Did not pick up first item after reversing after reaching end");

            // cleanup
            //targetFolder.Delete(true, false);
            //Assert.IsFalse(Directory.Exists(targetFolderPath), "Test repo directory not removed from disk by Delete()");
        }