1431 lines
49 KiB
C#
1431 lines
49 KiB
C#
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Text;
|
|
using NUnit.Framework;
|
|
using Rhino.Mocks;
|
|
using ScrewTurn.Wiki.PluginFramework;
|
|
|
|
namespace ScrewTurn.Wiki.Tests {
|
|
|
|
[TestFixture]
|
|
public abstract class FilesStorageProviderTestScaffolding {
|
|
|
|
private MockRepository mocks = new MockRepository();
|
|
private string testDir = Path.Combine(Environment.GetEnvironmentVariable("TEMP"), Guid.NewGuid().ToString());
|
|
|
|
[TearDown]
|
|
public void TearDown() {
|
|
try {
|
|
Directory.Delete(testDir, true);
|
|
}
|
|
catch {
|
|
//Console.WriteLine("Test: could not delete temp directory");
|
|
}
|
|
}
|
|
|
|
protected IHostV30 MockHost() {
|
|
if(!Directory.Exists(testDir)) Directory.CreateDirectory(testDir);
|
|
|
|
IHostV30 host = mocks.DynamicMock<IHostV30>();
|
|
Expect.Call(host.GetSettingValue(SettingName.PublicDirectory)).Return(testDir).Repeat.AtLeastOnce();
|
|
|
|
mocks.Replay(host);
|
|
|
|
return host;
|
|
}
|
|
|
|
protected IPagesStorageProviderV30 MockPagesProvider() {
|
|
IPagesStorageProviderV30 prov = mocks.DynamicMock<IPagesStorageProviderV30>();
|
|
|
|
mocks.Replay(prov);
|
|
|
|
return prov;
|
|
}
|
|
|
|
public abstract IFilesStorageProviderV30 GetProvider();
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void Init_NullHost() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
prov.Init(null, "");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void Init_NullConfig() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
prov.Init(MockHost(), null);
|
|
}
|
|
|
|
private Stream FillStream(string content) {
|
|
MemoryStream ms = new MemoryStream();
|
|
byte[] buff = Encoding.UTF8.GetBytes(content);
|
|
ms.Write(buff, 0, buff.Length);
|
|
ms.Seek(0, SeekOrigin.Begin);
|
|
return ms;
|
|
}
|
|
|
|
[Test]
|
|
public void StoreFile_ListFiles() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
Assert.AreEqual(0, prov.ListFiles("/").Length, "Wrong file count");
|
|
|
|
using(Stream s = FillStream("File1")) {
|
|
Assert.IsTrue(prov.StoreFile("/File1.txt", s, false), "StoreFile should return true");
|
|
}
|
|
using(Stream s = FillStream("File2")) {
|
|
Assert.IsTrue(prov.StoreFile("/File2.txt", s, true), "StoreFile should return true");
|
|
}
|
|
|
|
string[] files = prov.ListFiles("/");
|
|
Assert.AreEqual(2, files.Length, "Wrong file count");
|
|
Assert.AreEqual("/File1.txt", files[0], "Wrong file");
|
|
Assert.AreEqual("/File2.txt", files[1], "Wrong file");
|
|
}
|
|
|
|
[Test]
|
|
public void StoreFile_SubDir() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", "Test");
|
|
|
|
Assert.AreEqual(0, prov.ListFiles("/Test").Length, "Wrong file count");
|
|
|
|
using(Stream s = FillStream("File1")) {
|
|
Assert.IsTrue(prov.StoreFile("/Test/File1.txt", s, false), "StoreFile should return true");
|
|
}
|
|
using(Stream s = FillStream("File2")) {
|
|
Assert.IsTrue(prov.StoreFile("/Test/File2.txt", s, true), "StoreFile should return true");
|
|
}
|
|
|
|
string[] files = prov.ListFiles("/Test");
|
|
Assert.AreEqual(2, files.Length, "Wrong file count");
|
|
Assert.AreEqual("/Test/File1.txt", files[0], "Wrong file");
|
|
Assert.AreEqual("/Test/File2.txt", files[1], "Wrong file");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void StoreFile_InvalidFullName(string fn) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile(fn, s, false);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void StoreFile_NullStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.StoreFile("/Blah.txt", null, false);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void StoreFile_ClosedStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
Stream s = FillStream("Blah");
|
|
s.Close();
|
|
|
|
prov.StoreFile("Blah.txt", s, false);
|
|
}
|
|
|
|
[Test]
|
|
public void StoreFile_Overwrite_RetrieveFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
Assert.IsTrue(prov.StoreFile("/File.txt", s, false), "StoreFile should return true");
|
|
}
|
|
|
|
using(Stream s = FillStream("Blah222")) {
|
|
Assert.IsFalse(prov.StoreFile("/File.txt", s, false), "StoreFile should return false");
|
|
}
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
prov.RetrieveFile("/File.txt", ms, false);
|
|
ms.Seek(0, SeekOrigin.Begin);
|
|
string c = Encoding.UTF8.GetString(ms.ToArray());
|
|
Assert.AreEqual("Blah", c, "Wrong content (seems modified");
|
|
|
|
using(Stream s = FillStream("Blah222")) {
|
|
Assert.IsTrue(prov.StoreFile("/File.txt", s, true), "StoreFile should return true");
|
|
}
|
|
|
|
ms = new MemoryStream();
|
|
prov.RetrieveFile("/File.txt", ms, false);
|
|
ms.Seek(0, SeekOrigin.Begin);
|
|
c = Encoding.UTF8.GetString(ms.ToArray());
|
|
Assert.AreEqual("Blah222", c, "Wrong content (seems modified");
|
|
}
|
|
|
|
[Test]
|
|
public void ListFiles_NullOrEmptyDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
Assert.IsTrue(prov.StoreFile("/File.txt", s, false), "StoreFile should return true");
|
|
}
|
|
|
|
string[] files = prov.ListFiles(null);
|
|
Assert.AreEqual(1, files.Length, "Wrong file count");
|
|
Assert.AreEqual("/File.txt", files[0], "Wrong file");
|
|
|
|
files = prov.ListFiles("");
|
|
Assert.AreEqual(1, files.Length, "Wrong file count");
|
|
Assert.AreEqual("/File.txt", files[0], "Wrong file");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void ListFiles_InexistentDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
prov.ListFiles("/dir/that/does/not/exist");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void RetrieveFile_InvalidFile(string f) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(MemoryStream s = new MemoryStream()) {
|
|
prov.RetrieveFile(f, s, false);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RetrieveFile_InexistentFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(MemoryStream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/Inexistent.txt", s, false);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void RetrieveFile_NullStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
}
|
|
|
|
prov.RetrieveFile("/File.txt", null, false);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RetrieveFile_ClosedStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
}
|
|
|
|
MemoryStream s2 = new MemoryStream();
|
|
s2.Close();
|
|
prov.RetrieveFile("/File.txt", s2, false);
|
|
}
|
|
|
|
[Test]
|
|
public void GetFileDetails_SetFileRetrievalCount() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
DateTime now = DateTime.Now;
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
}
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/File2.txt", s, false);
|
|
}
|
|
|
|
FileDetails details = prov.GetFileDetails("/File.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/File.txt", s, false);
|
|
}
|
|
details = prov.GetFileDetails("/File.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/File2.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/File.txt", s, true);
|
|
}
|
|
details = prov.GetFileDetails("/File.txt");
|
|
Assert.AreEqual(2, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetFileDetails("/File2.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
prov.SetFileRetrievalCount("/File2.txt", 0);
|
|
|
|
details = prov.GetFileDetails("/File.txt");
|
|
Assert.AreEqual(2, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetFileDetails("/File2.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
prov.DeleteFile("/File.txt");
|
|
|
|
Assert.IsNull(prov.GetFileDetails("/File.txt"), "GetFileDetails should return null");
|
|
|
|
details = prov.GetFileDetails("/File2.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
}
|
|
|
|
[Test]
|
|
public void GetFileDetails_RenameFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
DateTime now = DateTime.Now;
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
}
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/File.txt", s, true);
|
|
}
|
|
|
|
prov.RenameFile("/File.txt", "/File2.txt");
|
|
|
|
FileDetails details = prov.GetFileDetails("/File.txt");
|
|
Assert.IsNull(details, "GetFileDetails should return null");
|
|
|
|
details = prov.GetFileDetails("/File2.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
}
|
|
|
|
[Test]
|
|
public void GetFileDetails_RenameDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
DateTime now = DateTime.Now;
|
|
prov.CreateDirectory("/", "Dir");
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/Dir/File.txt", s, false);
|
|
}
|
|
prov.CreateDirectory("/Dir/", "Sub");
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/Dir/Sub/File.txt", s, false);
|
|
}
|
|
prov.CreateDirectory("/", "Dir100");
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/Dir100/File.txt", s, false);
|
|
}
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/Dir/File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/Dir/Sub/File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/Dir100/File.txt", s, true);
|
|
}
|
|
|
|
prov.RenameDirectory("/Dir/", "/Dir2/");
|
|
|
|
FileDetails details;
|
|
|
|
details = prov.GetFileDetails("/Dir100/File.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
Assert.IsNull(prov.GetFileDetails("/Dir/File.txt"), "GetFileDetails should return null");
|
|
|
|
details = prov.GetFileDetails("/Dir2/File.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
Assert.IsNull(prov.GetFileDetails("/Dir/Sub/File.txt"), "GetFileDetails should return null");
|
|
|
|
details = prov.GetFileDetails("/Dir2/Sub/File.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
}
|
|
|
|
[Test]
|
|
public void GetFileDetails_DeleteDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
DateTime now = DateTime.Now;
|
|
prov.CreateDirectory("/", "Dir");
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/Dir/File.txt", s, false);
|
|
}
|
|
prov.CreateDirectory("/Dir/", "Sub");
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/Dir/Sub/File.txt", s, false);
|
|
}
|
|
prov.CreateDirectory("/", "Dir2");
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StoreFile("/Dir2/File.txt", s, false);
|
|
}
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/Dir/File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/Dir2/File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrieveFile("/Dir/Sub/File.txt", s, true);
|
|
}
|
|
|
|
prov.DeleteDirectory("/Dir/");
|
|
|
|
FileDetails details = prov.GetFileDetails("/Dir2/File.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong file retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong file size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
Assert.IsNull(prov.GetFileDetails("/Dir/File.txt"), "GetFileDetails should return null");
|
|
Assert.IsNull(prov.GetFileDetails("/Dir/Sub/File.txt"), "GetFileDetails should return null");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void GetFileDetails_InvalidFile(string f) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.GetFileDetails(f);
|
|
}
|
|
|
|
[Test]
|
|
public void GetFileDetails_InexistentFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
Assert.IsNull(prov.GetFileDetails("/Inexistent.txt"), "GetFileDetails should return null");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void SetFileRetrievalCount_InvalidFile(string f) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.SetFileRetrievalCount(f, 10);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentOutOfRangeException))]
|
|
public void SetFileRetrievalCount_NegativeCount() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.SetFileRetrievalCount("/File.txt", -1);
|
|
}
|
|
|
|
[Test]
|
|
public void DeleteFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", "Sub");
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
prov.StoreFile("/Sub/File.txt", s, false);
|
|
}
|
|
|
|
Assert.IsTrue(prov.DeleteFile("/File.txt"), "DeleteFile should return true");
|
|
Assert.IsTrue(prov.DeleteFile("/Sub/File.txt"), "DeleteFile should return true");
|
|
Assert.AreEqual(0, prov.ListFiles("/").Length, "Wrong file count");
|
|
Assert.AreEqual(0, prov.ListFiles("/Sub/").Length, "Wrong file count");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void DeleteFile_InvalidFile(string f) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.DeleteFile(f);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void DeleteFile_InexistentFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.DeleteFile("/File.txt");
|
|
}
|
|
|
|
[Test]
|
|
public void RenameFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", "Sub");
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
prov.StoreFile("/Sub/File.txt", s, false);
|
|
}
|
|
|
|
Assert.IsTrue(prov.RenameFile("/File.txt", "/File2.txt"), "RenameFile should return true");
|
|
Assert.IsTrue(prov.RenameFile("/Sub/File.txt", "/Sub/File2.txt"), "RenameFile should return true");
|
|
|
|
string[] files = prov.ListFiles("/");
|
|
Assert.AreEqual(1, files.Length, "Wrong file count");
|
|
Assert.AreEqual("/File2.txt", files[0], "Wrong file");
|
|
|
|
files = prov.ListFiles("/Sub/");
|
|
Assert.AreEqual(1, files.Length, "Wrong file count");
|
|
Assert.AreEqual("/Sub/File2.txt", files[0], "Wrong file");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void RenameFile_InvalidFile(string f) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.RenameFile(f, "/Blah.txt");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RenameFile_InexistentFile() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.RenameFile("/Blah.txt", "/Blah2.txt");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void RenameFile_InvalidName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
}
|
|
|
|
prov.RenameFile("/File.txt", n);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RenameFile_ExistentName() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/File.txt", s, false);
|
|
prov.StoreFile("/File2.txt", s, false);
|
|
}
|
|
|
|
prov.RenameFile("/File.txt", "/File2.txt");
|
|
}
|
|
|
|
[Test]
|
|
public void CreateDirectory_ListDirectories() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
Assert.IsTrue(prov.CreateDirectory("/", "Dir1"), "CreateDirectory should return true");
|
|
Assert.IsTrue(prov.CreateDirectory("/", "Dir2"), "CreateDirectory should return true");
|
|
Assert.IsTrue(prov.CreateDirectory("/Dir1", "Sub"), "CreateDirectory should return true");
|
|
|
|
string[] dirs = prov.ListDirectories("/");
|
|
Assert.AreEqual(2, dirs.Length, "Wrong dir count");
|
|
Assert.AreEqual("/Dir1/", dirs[0], "Wrong dir");
|
|
Assert.AreEqual("/Dir2/", dirs[1], "Wrong dir");
|
|
|
|
dirs = prov.ListDirectories("/Dir1/");
|
|
Assert.AreEqual(1, dirs.Length, "Wrong dir count");
|
|
Assert.AreEqual("/Dir1/Sub/", dirs[0], "Wrong dir");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void CreateDirectory_NullDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory(null, "Dir");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void CreateDirectory_InexistentDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/Inexistent/Dir/", "Sub");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void CreateDirectory_InvalidName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", n);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void CreateDirectory_ExistentName() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
Assert.IsTrue(prov.CreateDirectory("/", "Dir"), "CreateDirectory should return true");
|
|
prov.CreateDirectory("/", "Dir");
|
|
}
|
|
|
|
[Test]
|
|
public void ListDirectories_NullOrEmptyDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
string[] dirs = prov.ListDirectories(null);
|
|
Assert.AreEqual(0, dirs.Length, "Wrong dir count");
|
|
|
|
prov.CreateDirectory("/", "Dir");
|
|
|
|
dirs = prov.ListDirectories(null);
|
|
Assert.AreEqual(1, dirs.Length, "Wrong dir count");
|
|
Assert.AreEqual("/Dir/", dirs[0], "Wrong dir");
|
|
|
|
dirs = prov.ListDirectories("");
|
|
Assert.AreEqual(1, dirs.Length, "Wrong dir count");
|
|
Assert.AreEqual("/Dir/", dirs[0], "Wrong dir");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void ListDirectories_InexistentDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.ListDirectories("/Inexistent/");
|
|
}
|
|
|
|
[Test]
|
|
public void DeleteDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", "Dir");
|
|
prov.CreateDirectory("/", "Dir2");
|
|
prov.CreateDirectory("/Dir/", "Sub");
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/Dir/File.txt", s, false);
|
|
}
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/Dir/Sub/File.txt", s, false);
|
|
}
|
|
|
|
Assert.IsTrue(prov.DeleteDirectory("/Dir"), "DeleteDirectory should return true");
|
|
Assert.AreEqual("/Dir2/", prov.ListDirectories("/")[0], "Wrong directory");
|
|
Assert.IsTrue(prov.DeleteDirectory("/Dir2"), "DeleteDirectory should return true");
|
|
Assert.AreEqual(0, prov.ListDirectories("/").Length, "Wrong dir count");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
[TestCase("/", ExpectedException = typeof(ArgumentException))]
|
|
public void DeleteDirectory_InvalidDirectory(string d) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.DeleteDirectory(d);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void DeleteDirectory_InexistentDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.DeleteDirectory("/Inexistent/");
|
|
}
|
|
|
|
[Test]
|
|
public void RenameDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", "Dir");
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/Dir/File.txt", s, false);
|
|
}
|
|
|
|
Assert.IsTrue(prov.RenameDirectory("/Dir/", "/Dir2/"), "RenameDirectory should return true");
|
|
|
|
Assert.AreEqual("/Dir2/", prov.ListDirectories("/")[0], "Wrong directory");
|
|
|
|
bool thisHouldBeTrue = false;
|
|
try {
|
|
Assert.AreEqual(0, prov.ListFiles("/Dir/").Length, "Wrong file count");
|
|
}
|
|
catch(ArgumentException) {
|
|
thisHouldBeTrue = true;
|
|
}
|
|
Assert.IsTrue(thisHouldBeTrue, "ListFiles did not throw an exception");
|
|
Assert.AreEqual("/Dir2/File.txt", prov.ListFiles("/Dir2/")[0], "Wrong file");
|
|
|
|
prov.CreateDirectory("/Dir2/", "Sub");
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StoreFile("/Dir2/Sub/File.txt", s, false);
|
|
}
|
|
|
|
Assert.IsTrue(prov.RenameDirectory("/Dir2/Sub/", "/Dir2/Sub2/"), "RenameDirectory should return true");
|
|
|
|
Assert.AreEqual("/Dir2/Sub2/", prov.ListDirectories("/Dir2/")[0], "Wrong dir");
|
|
|
|
thisHouldBeTrue = false;
|
|
try {
|
|
Assert.AreEqual(0, prov.ListFiles("/Dir/Sub/").Length, "Wrong file count");
|
|
}
|
|
catch(ArgumentException) {
|
|
thisHouldBeTrue = true;
|
|
}
|
|
Assert.IsTrue(thisHouldBeTrue, "ListFiles did not throw an exception");
|
|
Assert.AreEqual("/Dir2/Sub2/File.txt", prov.ListFiles("/Dir2/Sub2/")[0], "Wrong file");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
[TestCase("/", ExpectedException = typeof(ArgumentException))]
|
|
public void RenameDirectory_InvalidDirectory(string d) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.RenameDirectory(d, "/Dir/");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RenameDirectory_InexistentDirectory() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.RenameDirectory("/Inexistent/", "/Inexistent2/");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
[TestCase("/", ExpectedException = typeof(ArgumentException))]
|
|
public void RenameDirectory_InvalidNewDir(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", "Dir");
|
|
|
|
prov.RenameDirectory("/Dir/", n);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RenameDirectory_ExistentNewDir() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.CreateDirectory("/", "Dir");
|
|
prov.CreateDirectory("/", "Dir2");
|
|
|
|
prov.RenameDirectory("/Dir/", "/Dir2/");
|
|
}
|
|
|
|
[Test]
|
|
public void StorePageAttachment_ListPageAttachments_GetPagesWithAttachments() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi1 = new PageInfo("MainPage", null, DateTime.Now);
|
|
PageInfo pi2 = new PageInfo("Page2", null, DateTime.Now);
|
|
|
|
Assert.AreEqual(0, prov.ListPageAttachments(pi1).Length, "Wrong attachment count");
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
Assert.IsTrue(prov.StorePageAttachment(pi1, "File.txt", s, false), "StorePageAttachment should return true");
|
|
Assert.IsTrue(prov.StorePageAttachment(pi1, "File2.txt", s, false), "StorePageAttachment should return true");
|
|
Assert.IsTrue(prov.StorePageAttachment(pi2, "File.txt", s, false), "StorePageAttachment should return true");
|
|
}
|
|
|
|
string[] attachs = prov.ListPageAttachments(pi1);
|
|
Assert.AreEqual(2, attachs.Length, "Wrong attachment count");
|
|
Assert.AreEqual("File.txt", attachs[0], "Wrong attachment");
|
|
Assert.AreEqual("File2.txt", attachs[1], "Wrong attachment");
|
|
|
|
attachs = prov.ListPageAttachments(pi2);
|
|
Assert.AreEqual(1, attachs.Length, "Wrong attachment count");
|
|
Assert.AreEqual("File.txt", attachs[0], "Wrong attachment");
|
|
|
|
string[] pages = prov.GetPagesWithAttachments();
|
|
Assert.AreEqual(2, pages.Length, "Wrong page count");
|
|
Assert.AreEqual(pi1.FullName, pages[0], "Wrong page");
|
|
Assert.AreEqual(pi2.FullName, pages[1], "Wrong page");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void ListPageAttachments_NullPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.ListPageAttachments(null);
|
|
}
|
|
|
|
[Test]
|
|
public void ListPageAttachments_InexistentPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
Assert.AreEqual(0, prov.ListPageAttachments(new PageInfo("Page", MockPagesProvider(), DateTime.Now)).Length, "Wrong attachment count");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void StorePageAttachment_NullPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(null, "File.txt", s, false);
|
|
}
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void StorePageAttachment_InvalidName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, n, s, false);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void StorePageAttachment_ExistentName() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
Assert.IsTrue(prov.StorePageAttachment(pi, "File.txt", s, false), "StorePageAttachment should return true");
|
|
Assert.IsFalse(prov.StorePageAttachment(pi, "File.txt", s, false), "StorePageAttachment should return false");
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void StorePageAttachment_Overwrite_RetrievePageAttachment() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
Assert.IsTrue(prov.StorePageAttachment(pi, "File.txt", s, false), "StorePageAttachment should return true");
|
|
}
|
|
|
|
using(Stream s = FillStream("Blah222")) {
|
|
Assert.IsTrue(prov.StorePageAttachment(pi, "File.txt", s, true), "StorePageAttachment should return true");
|
|
}
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
Assert.IsTrue(prov.RetrievePageAttachment(pi, "File.txt", ms, false), "RetrievePageAttachment should return true");
|
|
ms.Seek(0, SeekOrigin.Begin);
|
|
|
|
Assert.AreEqual("Blah222", Encoding.UTF8.GetString(ms.ToArray()), "Wrong attachment content");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void StorePageAttachment_NullStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.StorePageAttachment(pi, "File.txt", null, false);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void StorePageAttachment_ClosedStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
ms.Close();
|
|
prov.StorePageAttachment(pi, "File.txt", ms, false);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void RetrievePageAttachment_NullPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
using(MemoryStream ms = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(null, "File.txt", ms, false);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RetrievePageAttachment_InexistentPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
pi = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(MemoryStream ms = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(pi, "File.txt", ms, false);
|
|
}
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void RetrievePageAttachment_InvalidName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(MemoryStream ms = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(pi, n, ms, false);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RetrievePageAttachment_InexistentName() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(MemoryStream ms = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(pi, "File.txt", ms, false);
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void RetrievePageAttachment_NullStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
prov.RetrievePageAttachment(pi, "File.txt", null, false);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RetrievePageAttachment_ClosedStream() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
ms.Close();
|
|
prov.RetrievePageAttachment(pi, "File.txt", ms, false);
|
|
}
|
|
|
|
[Test]
|
|
public void GetPageAttachmentDetails_SetPageAttachmentRetrievalCount() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo page1 = new PageInfo("Page1", null, DateTime.Now);
|
|
PageInfo page2 = new PageInfo("Page2", null, DateTime.Now);
|
|
|
|
DateTime now = DateTime.Now;
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StorePageAttachment(page1, "File.txt", s, false);
|
|
}
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StorePageAttachment(page2, "File.txt", s, false);
|
|
}
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StorePageAttachment(page1, "File2.txt", s, false);
|
|
}
|
|
|
|
FileDetails details;
|
|
|
|
details = prov.GetPageAttachmentDetails(page1, "File.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(page2, "File.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(page1, "File2.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(page1, "File.txt", s, false);
|
|
}
|
|
details = prov.GetPageAttachmentDetails(page1, "File.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(page1, "File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(page1, "File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(page2, "File.txt", s, true);
|
|
}
|
|
|
|
details = prov.GetPageAttachmentDetails(page1, "File.txt");
|
|
Assert.AreEqual(2, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(page2, "File.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(page1, "File2.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
prov.SetPageAttachmentRetrievalCount(page2, "File.txt", 0);
|
|
|
|
details = prov.GetPageAttachmentDetails(page1, "File.txt");
|
|
Assert.AreEqual(2, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(page2, "File.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(page1, "File2.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
prov.DeletePageAttachment(page1, "File.txt");
|
|
|
|
Assert.IsNull(prov.GetPageAttachmentDetails(page1, "File.txt"), "GetPageAttachmentDetails should return null");
|
|
|
|
details = prov.GetPageAttachmentDetails(page2, "File.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(page1, "File2.txt");
|
|
Assert.AreEqual(0, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
}
|
|
|
|
[Test]
|
|
public void GetPageAttachmentDetails_NotifyPageRenaming() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo page = new PageInfo("Page", null, DateTime.Now);
|
|
PageInfo page2 = new PageInfo("Page2", null, DateTime.Now);
|
|
PageInfo newPage = new PageInfo("newPage", null, DateTime.Now);
|
|
|
|
DateTime now = DateTime.Now;
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StorePageAttachment(page, "File.txt", s, false);
|
|
}
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StorePageAttachment(page2, "File.txt", s, false);
|
|
}
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(page, "File.txt", s, true);
|
|
}
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(page2, "File.txt", s, true);
|
|
}
|
|
|
|
prov.NotifyPageRenaming(page, newPage);
|
|
|
|
FileDetails details;
|
|
|
|
Assert.IsNull(prov.GetPageAttachmentDetails(page, "File.txt"), "GetPageAttachmentDetails should return null");
|
|
|
|
details = prov.GetPageAttachmentDetails(page2, "File.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
|
|
details = prov.GetPageAttachmentDetails(newPage, "File.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
}
|
|
|
|
[Test]
|
|
public void GetPageAttachmentDetails_RenamePageAttachment() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo page = new PageInfo("Page", null, DateTime.Now);
|
|
|
|
DateTime now = DateTime.Now;
|
|
using(Stream s = FillStream("Content")) {
|
|
prov.StorePageAttachment(page, "File.txt", s, false);
|
|
}
|
|
|
|
using(Stream s = new MemoryStream()) {
|
|
prov.RetrievePageAttachment(page, "File.txt", s, true);
|
|
}
|
|
|
|
prov.RenamePageAttachment(page, "File.txt", "File2.txt");
|
|
|
|
FileDetails details;
|
|
|
|
Assert.IsNull(prov.GetPageAttachmentDetails(page, "File.txt"), "GetPageAttachmentDetails should return null");
|
|
|
|
details = prov.GetPageAttachmentDetails(page, "File2.txt");
|
|
Assert.AreEqual(1, details.RetrievalCount, "Wrong attachment retrieval count");
|
|
Assert.AreEqual(7, details.Size, "Wrong attachment size");
|
|
Tools.AssertDateTimesAreEqual(now, details.LastModified, true);
|
|
}
|
|
|
|
[Test]
|
|
public void GetPageAttachmentDetails_InexistentAttachment() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
Assert.IsNull(prov.GetPageAttachmentDetails(new PageInfo("Inexistent", null, DateTime.Now), "File.txt"), "GetPageAttachmentDetails should retur null");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void GetPageAttachmentDetails_NullPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.GetPageAttachmentDetails(null, "File.txt");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void GetPageAttachmentDetails_InvalidName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.GetPageAttachmentDetails(new PageInfo("Page", null, DateTime.Now), n);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void SetPageAttachmentRetrievalCount_NullPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.SetPageAttachmentRetrievalCount(null, "File.txt", 10);
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void SetPageAttachmentRetrievalCount_InvalidFile(string f) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.SetPageAttachmentRetrievalCount(new PageInfo("Page", null, DateTime.Now), f, 10);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentOutOfRangeException))]
|
|
public void SetPageAttachmentRetrievalCount_NegativeCount() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.SetPageAttachmentRetrievalCount(new PageInfo("Page", null, DateTime.Now), "File.txt", -1);
|
|
}
|
|
|
|
[Test]
|
|
public void DeletePageAttachment() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
Assert.IsTrue(prov.DeletePageAttachment(pi, "File.txt"), "DeletePageAttachment should return true");
|
|
|
|
Assert.IsNull(prov.GetPageAttachmentDetails(pi, "File.txt"), "GetPageAttachmentDetails should return null");
|
|
Assert.AreEqual(0, prov.ListPageAttachments(pi).Length, "Wrong attachment count");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void DeletePageAttachment_NullPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.DeletePageAttachment(null, "File.txt");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void DeletePageAttachment_InexistentPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.DeletePageAttachment(pi, "File.txt");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void DeletePageAttachment_InvalidName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.DeletePageAttachment(pi, n);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void DeletePageAttachment_InexistentName() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
prov.DeletePageAttachment(pi, "File222.txt");
|
|
}
|
|
|
|
[Test]
|
|
public void RenamePageAttachment() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
Assert.IsTrue(prov.RenamePageAttachment(pi, "File.txt", "File2.txt"), "RenamePageAttachment should return true");
|
|
|
|
string[] attachs = prov.ListPageAttachments(pi);
|
|
Assert.AreEqual(1, attachs.Length, "Wrong attachment count");
|
|
Assert.AreEqual("File2.txt", attachs[0], "Wrong attachment");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void RenamePageAttachment_NullPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
prov.RenamePageAttachment(null, "File.txt", "File2.txt");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RenamePageAttachment_InexistentPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.RenamePageAttachment(pi, "File.txt", "File2.txt");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void RenamePageAttachment_InvalidName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.RenamePageAttachment(pi, n, "File2.txt");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RenamePageAttachment_InexistentName() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
}
|
|
|
|
prov.RenamePageAttachment(pi, "File1.txt", "File2.txt");
|
|
}
|
|
|
|
[TestCase(null, ExpectedException = typeof(ArgumentNullException))]
|
|
[TestCase("", ExpectedException = typeof(ArgumentException))]
|
|
public void RenamePageAttachment_InvalidNewName(string n) {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.RenamePageAttachment(pi, "File.txt", n);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void RenamePageAttachment_ExistentNewName() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo pi = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(pi, "File.txt", s, false);
|
|
prov.StorePageAttachment(pi, "File2.txt", s, false);
|
|
}
|
|
|
|
prov.RenamePageAttachment(pi, "File.txt", "File2.txt");
|
|
}
|
|
|
|
[Test]
|
|
public void NotifyPageRenaming() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
|
|
PageInfo p2 = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(p1, "File1.txt", s, false);
|
|
prov.StorePageAttachment(p1, "File2.txt", s, false);
|
|
}
|
|
|
|
prov.NotifyPageRenaming(p1, p2);
|
|
|
|
Assert.AreEqual(0, prov.ListPageAttachments(p1).Length, "Wrong attachment count");
|
|
|
|
string[] attachs = prov.ListPageAttachments(p2);
|
|
Assert.AreEqual(2, attachs.Length, "Wrong attachment count");
|
|
Assert.AreEqual("File1.txt", attachs[0], "Wrong attachment");
|
|
Assert.AreEqual("File2.txt", attachs[1], "Wrong attachment");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void NotifyPageRenaming_NullOldPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo p2 = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.NotifyPageRenaming(null, p2);
|
|
}
|
|
|
|
[Test]
|
|
public void NotifyPageRenaming_InexistentOldPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
|
|
PageInfo p2 = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.NotifyPageRenaming(p1, p2);
|
|
|
|
// Nothing specific to verify
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentNullException))]
|
|
public void NotifyPageRenaming_NullNewPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
|
|
|
|
prov.NotifyPageRenaming(p1, null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException(typeof(ArgumentException))]
|
|
public void NotifyPageRenaming_ExistentNewPage() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
|
|
PageInfo p2 = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
prov.StorePageAttachment(p1, "File1.txt", s, false);
|
|
prov.StorePageAttachment(p2, "File2.txt", s, false);
|
|
}
|
|
|
|
prov.NotifyPageRenaming(p1, p2);
|
|
}
|
|
|
|
[Test]
|
|
public void CompleteTestsForCaseInsensitivity_Files() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
Assert.IsTrue(prov.StoreFile("/File.TXT", s, false), "StoreFile should return true");
|
|
Assert.IsFalse(prov.StoreFile("/file.txt", s, false), "StoreFile should return false");
|
|
prov.CreateDirectory("/", "Sub");
|
|
Assert.IsTrue(prov.StoreFile("/Sub/File.TXT", s, false), "StoreFile should return true");
|
|
Assert.IsFalse(prov.StoreFile("/SUB/File.TXT", s, false), "StoreFile should return false");
|
|
}
|
|
|
|
Assert.IsNotNull(prov.GetFileDetails("/file.TXT"), "GetFileDetails should return something");
|
|
Assert.IsNotNull(prov.GetFileDetails("/suB/fILe.TXT"), "GetFileDetails should return something");
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
Assert.IsTrue(prov.RetrieveFile("/FILE.tXt", ms, false), "RetrieveFile should return true");
|
|
ms = new MemoryStream();
|
|
Assert.IsTrue(prov.RetrieveFile("/SuB/FILe.tXt", ms, false), "RetrieveFile should return true");
|
|
|
|
Assert.IsTrue(prov.RenameFile("/FILE.TXT", "/NEWfile.txt"), "RenameFile should return true");
|
|
Assert.IsTrue(prov.RenameFile("/SUB/FILE.TXT", "/sub/NEWfile.txt"), "RenameFile should return true");
|
|
|
|
Assert.IsTrue(prov.DeleteFile("/newfile.txt"), "DeleteFile should return true");
|
|
Assert.IsTrue(prov.DeleteFile("/sub/newfile.txt"), "DeleteFile should return true");
|
|
}
|
|
|
|
[Test]
|
|
public void CompleteTestsForCaseInsensitivity_Attachments() {
|
|
IFilesStorageProviderV30 prov = GetProvider();
|
|
|
|
PageInfo page = new PageInfo("Page", MockPagesProvider(), DateTime.Now);
|
|
|
|
using(Stream s = FillStream("Blah")) {
|
|
Assert.IsTrue(prov.StorePageAttachment(page, "Attachment.TXT", s, false), "StorePageAttachment should return true");
|
|
Assert.IsFalse(prov.StorePageAttachment(page, "ATTACHMENT.txt", s, false), "StorePageAttachment should return false");
|
|
}
|
|
|
|
Assert.IsNotNull(prov.GetPageAttachmentDetails(page, "attachment.txt"), "GetPageAttachmentDetails should return a value");
|
|
|
|
MemoryStream ms = new MemoryStream();
|
|
Assert.IsTrue(prov.RetrievePageAttachment(page, "Attachment.txt", ms, false), "RetrievePageAttachment should return true");
|
|
|
|
Assert.IsTrue(prov.RenamePageAttachment(page, "Attachment.txt", "NEWATT.txt"), "RenamePageAttachment should return true");
|
|
|
|
Assert.IsTrue(prov.DeletePageAttachment(page, "newatt.TXT"), "DeletePageAttachment should return true");
|
|
}
|
|
|
|
}
|
|
|
|
}
|