diff --git a/.gitignore b/.gitignore index 708830d..82bb634 100644 --- a/.gitignore +++ b/.gitignore @@ -21,4 +21,6 @@ src/*/v6obj # NuGet packages packages/* !packages/repositories.config -Build/*.nupkg \ No newline at end of file +Build/*.nupkg + +src/Rainbow.*.Tests/license.xml \ No newline at end of file diff --git a/Rainbow.sln b/Rainbow.sln index a498ae2..c633f59 100644 --- a/Rainbow.sln +++ b/Rainbow.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio 14 -VisualStudioVersion = 14.0.22823.1 +VisualStudioVersion = 14.0.23107.0 MinimumVisualStudioVersion = 10.0.40219.1 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rainbow.Tests", "src\Rainbow.Tests\Rainbow.Tests.csproj", "{3A8495AE-E286-44A2-8BBB-EE9911F5BA43}" EndProject @@ -13,6 +13,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rainbow.Storage.Yaml.Tests" EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rainbow.Storage.Sc", "src\Rainbow.Storage.Sc\Rainbow.Storage.Sc.csproj", "{956AFE8B-51CD-4D61-B8C1-BFFDC749FD82}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Rainbow.Storage.Sc.Tests", "src\Rainbow.Storage.Sc.Tests\Rainbow.Storage.Sc.Tests.csproj", "{20031F60-CD51-4F57-A13C-33D6D85D68ED}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -39,6 +41,10 @@ Global {956AFE8B-51CD-4D61-B8C1-BFFDC749FD82}.Debug|Any CPU.Build.0 = Debug|Any CPU {956AFE8B-51CD-4D61-B8C1-BFFDC749FD82}.Release|Any CPU.ActiveCfg = Release|Any CPU {956AFE8B-51CD-4D61-B8C1-BFFDC749FD82}.Release|Any CPU.Build.0 = Release|Any CPU + {20031F60-CD51-4F57-A13C-33D6D85D68ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {20031F60-CD51-4F57-A13C-33D6D85D68ED}.Debug|Any CPU.Build.0 = Debug|Any CPU + {20031F60-CD51-4F57-A13C-33D6D85D68ED}.Release|Any CPU.ActiveCfg = Release|Any CPU + {20031F60-CD51-4F57-A13C-33D6D85D68ED}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/src/Rainbow.Storage.Sc.Tests/App.config b/src/Rainbow.Storage.Sc.Tests/App.config new file mode 100644 index 0000000..2381a81 --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/App.config @@ -0,0 +1,224 @@ + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ true +
+ + + + + + $(id) + + + + + + + $(id) + + + + + + + $(id) + + + + + + + + + + roles + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/Rainbow.Storage.Sc.Tests/App_Config/FieldTypes.config b/src/Rainbow.Storage.Sc.Tests/App_Config/FieldTypes.config new file mode 100644 index 0000000..55de84c --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/App_Config/FieldTypes.config @@ -0,0 +1,59 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/Rainbow.Storage.Sc.Tests/Deserialization/DefaultDeserializerTests.cs b/src/Rainbow.Storage.Sc.Tests/Deserialization/DefaultDeserializerTests.cs new file mode 100644 index 0000000..bcd531b --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/Deserialization/DefaultDeserializerTests.cs @@ -0,0 +1,262 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using NSubstitute; +using NUnit.Framework; +using Rainbow.Filtering; +using Rainbow.Model; +using Rainbow.Storage.Sc.Deserialization; +using Rainbow.Tests; +using Sitecore; +using Sitecore.Data; +using Sitecore.Data.Items; +using Sitecore.FakeDb; + +namespace Rainbow.Storage.Sc.Tests.Deserialization +{ + public class DefaultDeserializerTests + { + private readonly ID _testTemplateId = ID.NewID; + private readonly ID _testTemplate2Id = ID.NewID; + private readonly ID _testSharedFieldId = ID.NewID; + private readonly ID _testVersionedFieldId = ID.NewID; + + [Test] + public void Deserialize_DeserializesNewItem() + { + using (var db = new Db()) + { + var deserializer = CreateTestDeserializer(db); + + var item = new FakeItem( + id: Guid.NewGuid(), + parentId: ItemIDs.ContentRoot.Guid, + templateId: _testTemplateId.Guid, + versions: new[] + { + new FakeItemVersion(1, "en", new[] + { + new FakeFieldValue("Hello", fieldId: _testVersionedFieldId.Guid) + }) + }); + + var deserialized = deserializer.Deserialize(item, false); + + Assert.IsNotNull(deserialized); + + var fromDb = db.GetItem(new ID(item.Id)); + + Assert.IsNotNull(fromDb); + Assert.AreEqual("Hello", fromDb[_testVersionedFieldId]); + Assert.AreEqual(item.ParentId, fromDb.ParentID.Guid); + Assert.AreEqual(item.TemplateId, fromDb.TemplateID.Guid); + } + } + + [Test] + public void Deserialize_DeserializesExistingItem_WithSharedFieldChanges() + { + RunItemChangeTest( + setup: itemData => + { + var fields = itemData.SharedFields.ToList(); + fields.Add(new FakeFieldValue("Shared Value", fieldId: _testSharedFieldId.Guid)); + itemData.SharedFields = fields; + }, + assert: dbItem => + { + Assert.AreEqual("Shared Value", dbItem[_testSharedFieldId]); + } + ); + } + + [Test] + public void Deserialize_DeserializesExistingItem_WithVersionedFieldChanges() + { + RunItemChangeTest( + setup: itemData => + { + var version = (ProxyItemVersion)itemData.Versions.First(); + var fields = version.Fields.ToList(); + fields.Add(new FakeFieldValue("Versioned Value", fieldId: _testVersionedFieldId.Guid)); + version.Fields = fields; + }, + assert: dbItem => + { + Assert.AreEqual("Versioned Value", dbItem[_testVersionedFieldId]); + } + ); + } + + [Test] + public void Deserialize_DeserializesExistingItem_WithRenamed() + { + RunItemChangeTest( + setup: itemData => + { + itemData.Name = "Testy Item"; + }, + assert: dbItem => + { + Assert.AreEqual("Testy Item", dbItem.Name); + } + ); + } + + [Test] + public void Deserialize_DeserializesExistingItem_WithMoved() + { + RunItemChangeTest( + setup: itemData => + { + itemData.ParentId = ItemIDs.TemplateRoot.Guid; + }, + assert: dbItem => + { + Assert.AreEqual(ItemIDs.TemplateRoot, dbItem.ParentID); + Assert.AreEqual("/sitecore/templates/test item", dbItem.Paths.FullPath); + } + ); + } + + [Test] + public void Deserialize_DeserializesExistingItem_WithTemplateChanged() + { + // TODO: https://github.com/sergeyshushlyapin/Sitecore.FakeDb/issues/84 + //RunItemChangeTest( + // setup: itemData => + // { + // itemData.TemplateId = _testTemplate2Id.Guid; + // }, + // assert: dbItem => + // { + // Assert.AreEqual(_testTemplate2Id, dbItem.TemplateID); + // } + //); + } + + [Test] + public void Deserialize_DeserializesExistingItem_WithVersionAdded() + { + RunItemChangeTest( + setup: itemData => + { + var versions = itemData.Versions.ToList(); + versions.Add(new FakeItemVersion(2)); + + itemData.Versions = versions; + }, + assert: dbItem => + { + Assert.AreEqual(2, dbItem.Versions.Count); + } + ); + } + + [Test] + public void Deserialize_DeserializesExistingItem_WithVersionRemoved() + { + RunItemChangeTest( + setup: itemData => + { + var versions = new List(); + itemData.Versions = versions; + }, + assert: dbItem => + { + Assert.AreEqual(0, dbItem.Versions.Count); + } + ); + } + + [Test] + public void Deserialize_IgnoresField_ExcludedWithFieldFilter() + { + var ignoredFieldId = ID.NewID; + + var fieldFilter = Substitute.For(); + fieldFilter.Includes(Arg.Any()).Returns(true); + fieldFilter.Includes(ignoredFieldId.Guid).Returns(false); + + var deserializer = new DefaultDeserializer(Substitute.For(), fieldFilter); + deserializer.ParentDataStore = new SitecoreDataStore(deserializer); + + using (var db = new Db()) + { + var itemId = ID.NewID; + + db.Add(new DbItem("Test Item", itemId) + { + {ignoredFieldId, "Test Value"} + }); + + var itemData = new ProxyItem(new ItemData(db.GetItem(itemId))); + + var fields = new List(); + fields.Add(new FakeFieldValue("Changed Ignored Value", fieldId:ignoredFieldId.Guid)); + ((ProxyItemVersion)itemData.Versions.First()).Fields = fields; + + deserializer.Deserialize(itemData, false); + + var fromDb = db.GetItem(itemId); + + Assert.AreEqual(fromDb[ignoredFieldId], "Test Value"); + } + } + + protected IDeserializer CreateTestDeserializer(Db db) + { + var fieldFilter = Substitute.For(); + fieldFilter.Includes(Arg.Any()).Returns(true); + + var deserializer = new DefaultDeserializer(Substitute.For(), fieldFilter); + deserializer.ParentDataStore = new SitecoreDataStore(deserializer); + + db.Add(new DbTemplate("Test Template", _testTemplateId) + { + new DbField("Test Field", _testVersionedFieldId), + new DbField("Test Shared", _testSharedFieldId) { Shared = true } + }); + + db.Add(new DbTemplate("Test Template2", _testTemplate2Id) + { + new DbField("Test Field"), + new DbField("Test Shared") { Shared = true } + }); + + return deserializer; + } + + protected ID AddExistingItem(Db db, Action customize = null) + { + ID id = ID.NewID; + var item = new DbItem("test item", id, _testTemplateId); + if (customize != null) customize(item); + + db.Add(item); + + return id; + } + + private void RunItemChangeTest(Action setup, Action assert) + { + using (var db = new Db()) + { + var deserializer = CreateTestDeserializer(db); + + var itemId = AddExistingItem(db); + + var itemData = new ProxyItem(new ItemData(db.GetItem(itemId))); + + setup(itemData); + + deserializer.Deserialize(itemData, false); + + var fromDb = db.GetItem(itemId); + + Assert.IsNotNull(fromDb); + assert(fromDb); + } + } + } +} diff --git a/src/Rainbow.Storage.Sc.Tests/ItemDataTests.cs b/src/Rainbow.Storage.Sc.Tests/ItemDataTests.cs new file mode 100644 index 0000000..b58e5fe --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/ItemDataTests.cs @@ -0,0 +1,213 @@ +using System; +using System.Linq; +using NUnit.Framework; +using Rainbow.Model; +using Sitecore.Data; +using Sitecore.FakeDb; + +namespace Rainbow.Storage.Sc.Tests +{ + public class ItemDataTests + { + [Test] + public void Id_ReturnsExpectedValue() + { + var id = ID.NewID; + var item = new DbItem("hello", id); + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual(id.Guid, testItem.Id); + }); + } + + [Test] + public void DatabaseName_ReturnsExpectedValue() + { + var item = new DbItem("hello"); + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual("master", testItem.DatabaseName); + }); + } + + [Test] + public void ParentId_ReturnsExpectedValue() + { + var pid = ID.NewID; + var item = new DbItem("hello", pid); + + RunItemTest(item, (testItem, db) => + { + db.Add(new DbItem("hellochild") { ParentID = pid }); + + var child = db.GetItem("/sitecore/content/hello/hellochild"); + + Assert.AreEqual(pid, child.ParentID); + }); + } + + [Test] + public void Path_ReturnsExpectedValue() + { + var item = new DbItem("hello"); + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual("/sitecore/content/hello", testItem.Path); + }); + } + + [Test] + public void Name_ReturnsExpectedValue() + { + var item = new DbItem("hello"); + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual("hello", testItem.Name); + }); + } + + [Test] + public void BranchId_ReturnsExpectedValue() + { + var id = ID.NewID; + var item = new DbItem("hello") { BranchId = id }; + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual(id.Guid, testItem.BranchId); + }); + } + + [Test] + public void TemplateId_ReturnsExpectedValue() + { + var id = ID.NewID; + var item = new DbItem("hello") { TemplateID = id }; + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual(id.Guid, testItem.TemplateId); + }); + } + + [Test] + public void SharedFields_ReturnsExpectedValues() + { + var id = ID.NewID; + var item = new DbItem("hello") + { + new DbField(id) { Shared = true, Value = "test field"} + }; + + RunItemTest(item, (testItem, db) => + { + Assert.IsTrue(testItem.SharedFields.Any(f => f.FieldId == id.Guid)); + }); + } + + [Test] + public void Versions_ReturnsExpectedVersions() + { + var id = ID.NewID; + var item = new DbItem("hello") + { + new DbField(id) + { + {"en", 1, "test value"}, + {"en", 2, "test v2"} + } + }; + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual(2, testItem.Versions.Count()); + Assert.IsTrue(testItem.Versions.Any(v => v.Language.Name == "en" && v.VersionNumber == 1)); + Assert.IsTrue(testItem.Versions.Any(v => v.Language.Name == "en" && v.VersionNumber == 2)); + }); + } + + [Test] + public void Field_Value_ReturnsExpectedValue() + { + var id = ID.NewID; + var item = new DbItem("hello") + { + new DbField(id) + { + Shared = true, + Value = "test" + } + }; + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual(id.Guid, testItem.SharedFields.First(f => f.FieldId == id.Guid).FieldId); + }); + } + + [Test] + public void Field_FieldType_ReturnsExpectedValue() + { + var id = ID.NewID; + var item = new DbItem("hello") + { + new DbField(id) {Value = "test", Type = "test type", Shared = true} + }; + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual("test type", testItem.SharedFields.First(f => f.FieldId == id.Guid).FieldType); + }); + } + + [Test] + public void Field_NameHint_ReturnsExpectedValue() + { + var id = ID.NewID; + var item = new DbItem("hello") + { + new DbField(id) {Value = "test", Name = "Foo", Shared = true} + }; + + RunItemTest(item, (testItem, db) => + { + Assert.AreEqual("Foo", testItem.SharedFields.First(f => f.FieldId == id.Guid).NameHint); + }); + } + + [Test] + public void Version_Fields_ReturnsExpectedValues() + { + var id = ID.NewID; + var item = new DbItem("hello") + { + new DbField(id) + { + {"en", 1, "test"} + } + }; + + RunItemTest(item, (testItem, db) => + { + var version = testItem.Versions.First(); + Assert.AreEqual("test", version.Fields.FirstOrDefault(f => f.FieldId == id.Guid).Value); + }); + } + + private void RunItemTest(DbItem testItem, Action test) + { + using (var db = new Db()) + { + db.Add(testItem); + + var item = db.GetItem(testItem.ID); + + test(new ItemData(item), db); + } + } + } +} diff --git a/src/Rainbow.Storage.Sc.Tests/Properties/AssemblyInfo.cs b/src/Rainbow.Storage.Sc.Tests/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..0e0502b --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Rainbow.Storage.Sc.Tests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Rainbow.Storage.Sc.Tests")] +[assembly: AssemblyCopyright("Copyright © 2015")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("20031f60-cd51-4f57-a13c-33d6d85d68ed")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/Rainbow.Storage.Sc.Tests/Rainbow.Storage.Sc.Tests.csproj b/src/Rainbow.Storage.Sc.Tests/Rainbow.Storage.Sc.Tests.csproj new file mode 100644 index 0000000..62368f1 --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/Rainbow.Storage.Sc.Tests.csproj @@ -0,0 +1,109 @@ + + + + + Debug + AnyCPU + {20031F60-CD51-4F57-A13C-33D6D85D68ED} + Library + Properties + Rainbow.Storage.Sc.Tests + Rainbow.Storage.Sc.Tests + v4.5 + 512 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + False + ..\..\lib\Sitecore\v7\Lucene.Net.dll + + + ..\..\packages\NSubstitute.1.8.2.0\lib\net45\NSubstitute.dll + True + + + ..\..\packages\NUnit.2.6.4\lib\nunit.framework.dll + True + + + ..\..\lib\Sitecore\v7\Sitecore.Analytics.dll + + + ..\..\packages\Sitecore.FakeDb.0.29.2\lib\net45\Sitecore.FakeDb.dll + True + + + False + ..\..\lib\Sitecore\v7\Sitecore.Kernel.dll + + + False + ..\..\lib\Sitecore\v7\Sitecore.Logging.dll + + + ..\..\lib\Sitecore\v7\sitecore.nexus.dll + + + + + + + + + + + + + + + + + + + + + + + + {956afe8b-51cd-4d61-b8c1-bffdc749fd82} + Rainbow.Storage.Sc + + + {3a8495ae-e286-44a2-8bbb-ee9911f5ba43} + Rainbow.Tests + + + {8ff75c8b-2a9e-4d95-91ad-333071813199} + Rainbow + + + + + + + + + \ No newline at end of file diff --git a/src/Rainbow.Storage.Sc.Tests/SitecoreDataStoreTests.cs b/src/Rainbow.Storage.Sc.Tests/SitecoreDataStoreTests.cs new file mode 100644 index 0000000..c56722c --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/SitecoreDataStoreTests.cs @@ -0,0 +1,202 @@ +using System; +using System.Linq; +using NSubstitute; +using NUnit.Framework; +using Rainbow.Storage.Sc.Deserialization; +using Rainbow.Tests; +using Sitecore.Data; +using Sitecore.FakeDb; + +namespace Rainbow.Storage.Sc.Tests +{ + public class SitecoreDataStoreTests + { + [Test] + public void GetDatabaseNames_ShouldReturnDatabaseNames() + { + + } + + [Test] + public void Save_ShouldDeserializeItem() + { + var deserializer = Substitute.For(); + var dataStore = new SitecoreDataStore(deserializer); + + var item = new FakeItem(); + + dataStore.Save(item); + + deserializer.Received().Deserialize(item, Arg.Any()); + } + + [Test] + public void MoveOrRename_ThrowsNotImplementedException() + { + var dataStore = CreateTestDataStore(); + Assert.Throws(() => dataStore.MoveOrRenameItem(new FakeItem(), "/sitecore")); + } + + [Test] + public void GetByPath_ReturnsExpectedItem_WhenPathExists() + { + using (new Db()) + { + var dataStore = CreateTestDataStore(); + + var item = dataStore.GetByPath("/sitecore/templates", "master").ToArray(); + + Assert.IsNotEmpty(item); + Assert.AreEqual("templates", item.First().Name); + } + } + + [Test] + public void GetByPath_ReturnsNull_WhenPathDoesNotExist() + { + using (new Db()) + { + var dataStore = CreateTestDataStore(); + + var item = dataStore.GetByPath("/sitecore/templates/Monkey Bars", "master"); + + Assert.IsEmpty(item); + } + } + + [Test] + public void GetByPathAndId_ReturnsItem_WhenItemIdExists() + { + GetById_ReturnsItem_WhenItemIdExists(); // for now. in case implementation changes later, keep this redundant test. + } + + [Test] + public void GetById_ReturnsItem_WhenItemIdExists() + { + using (var db = new Db()) + { + var id = new ID(); + db.Add(new DbItem("Hello", id)); + + var dataStore = CreateTestDataStore(); + + var item = dataStore.GetById(id.Guid, "master"); + + Assert.IsNotNull(item); + Assert.AreEqual("Hello", item.Name); + } + } + + [Test] + public void GetById_ReturnsNull_WhenItemIdDoesNotExist() + { + using (new Db()) + { + var dataStore = CreateTestDataStore(); + + var item = dataStore.GetById(Guid.NewGuid(), "master"); + + Assert.IsNull(item); + } + } + + [Test] + public void GetMetadataByTemplateId_ThrowsNotImplementedException() + { + var dataStore = CreateTestDataStore(); + Assert.Throws(() => dataStore.GetMetadataByTemplateId(Guid.NewGuid(), "master")); + } + + [Test] + public void GetChildren_ReturnsExpectedChildren() + { + using (var db = new Db()) + { + db.Add(new DbItem("Hello")); + + var dataStore = CreateTestDataStore(); + + var parent = dataStore.GetByPath("/sitecore/content", "master").First(); + + var children = dataStore.GetChildren(parent); + + Assert.IsNotNull(children); + Assert.IsNotEmpty(children); + Assert.AreEqual("Hello", children.First().Name); + } + } + + [Test] + public void GetChildren_ReturnsEmptyEnumerable_IfItemDoesNotExist() + { + using (new Db()) + { + var dataStore = CreateTestDataStore(); + + var parent = new FakeItem(Guid.NewGuid(), name: "LOL"); + + var children = dataStore.GetChildren(parent); + + Assert.IsNotNull(children); + Assert.IsEmpty(children); + } + } + + [Test] + public void Remove_RemovesExpectedItem() + { + using (var db = new Db()) + { + var id = new ID(); + db.Add(new DbItem("Hello", id)); + + var dataStore = CreateTestDataStore(); + + var item = dataStore.GetById(id.Guid, "master"); + + var result = dataStore.Remove(item); + + var itemAfterDelete = dataStore.GetById(id.Guid, "master"); + + Assert.IsTrue(result); + Assert.IsNull(itemAfterDelete); + } + } + + [Test] + public void Remove_ReturnsFalse_WhenItemDoesNotExist() + { + using (new Db()) + { + var dataStore = CreateTestDataStore(); + + var item = new FakeItem(Guid.NewGuid(), name: "lol"); + + var result = dataStore.Remove(item); + + Assert.IsFalse(result); + } + } + + [Test] + public void RegisterForChanges_ThrowsNotImplementedException() + { + var dataStore = CreateTestDataStore(); + Assert.Throws(() => dataStore.RegisterForChanges((metadata, s) => { })); + } + + [Test] + public void Clear_ThrowsNotImplementedException() + { + var dataStore = CreateTestDataStore(); + Assert.Throws(() => dataStore.Clear()); + } + + protected IDataStore CreateTestDataStore() + { + var deserializer = Substitute.For(); + + return new SitecoreDataStore(deserializer); + } + } +} diff --git a/src/Rainbow.Storage.Sc.Tests/packages.config b/src/Rainbow.Storage.Sc.Tests/packages.config new file mode 100644 index 0000000..1d396e0 --- /dev/null +++ b/src/Rainbow.Storage.Sc.Tests/packages.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/src/Rainbow.Storage.Sc/SitecoreDataStore.cs b/src/Rainbow.Storage.Sc/SitecoreDataStore.cs index e6cfde2..43eaac8 100644 --- a/src/Rainbow.Storage.Sc/SitecoreDataStore.cs +++ b/src/Rainbow.Storage.Sc/SitecoreDataStore.cs @@ -1,7 +1,6 @@ using System; using System.Collections.Generic; using System.Linq; -using System.Reflection; using Rainbow.Model; using Rainbow.Storage.Sc.Deserialization; using Sitecore.Collections; @@ -31,6 +30,8 @@ public IEnumerable GetDatabaseNames() public void Save(IItemData item) { + Assert.ArgumentNotNull(item, "item"); + _deserializer.Deserialize(item, true); } @@ -92,6 +93,8 @@ public IEnumerable GetChildren(IItemData parentItem) var item = db.GetItem(new ID(parentItem.Id)); + if (item == null) return Enumerable.Empty(); + return item.GetChildren(ChildListOptions.SkipSorting).Select(child => (IItemData)new ItemData(child, this)).ToArray(); } @@ -110,6 +113,8 @@ public void ResetTemplateEngine() public bool Remove(IItemData item) { + Assert.ArgumentNotNull(item, "item"); + var databaseRef = GetDatabase(item.DatabaseName); var scId = new ID(item.Id); var scItem = databaseRef.GetItem(scId); diff --git a/src/Rainbow/Model/ProxyFieldValue.cs b/src/Rainbow/Model/ProxyFieldValue.cs index d312f10..a42eef0 100644 --- a/src/Rainbow/Model/ProxyFieldValue.cs +++ b/src/Rainbow/Model/ProxyFieldValue.cs @@ -13,13 +13,13 @@ public ProxyFieldValue(IItemFieldValue fieldToProxy) BlobId = fieldToProxy.BlobId; } - public Guid FieldId { get; private set; } + public Guid FieldId { get; set; } - public string NameHint { get; private set; } + public string NameHint { get; set; } - public string Value { get; private set; } + public string Value { get; set; } - public string FieldType { get; private set; } - public Guid? BlobId { get; private set; } + public string FieldType { get; set; } + public Guid? BlobId { get; set; } } } diff --git a/src/Rainbow/Model/ProxyItem.cs b/src/Rainbow/Model/ProxyItem.cs index 9715c7e..f691b7c 100644 --- a/src/Rainbow/Model/ProxyItem.cs +++ b/src/Rainbow/Model/ProxyItem.cs @@ -24,16 +24,16 @@ public ProxyItem(IItemData itemToProxy) DatabaseName = itemToProxy.DatabaseName; } - public Guid Id { get; private set; } + public Guid Id { get; set; } public string DatabaseName { get; set; } - public Guid ParentId { get; private set; } - public string Path { get; private set; } - public string Name { get; private set; } - public Guid BranchId { get; private set; } - public Guid TemplateId { get; private set; } - public IEnumerable SharedFields { get; private set; } - public IEnumerable Versions { get; private set; } - public string SerializedItemId { get; private set; } + public Guid ParentId { get; set; } + public string Path { get; set; } + public string Name { get; set; } + public Guid BranchId { get; set; } + public Guid TemplateId { get; set; } + public IEnumerable SharedFields { get; set; } + public IEnumerable Versions { get; set; } + public string SerializedItemId { get; set; } public IEnumerable GetChildren() { throw new NotImplementedException("Cannot get children of a proxied item"); diff --git a/src/Rainbow/Model/ProxyItemVersion.cs b/src/Rainbow/Model/ProxyItemVersion.cs index 2417da5..67f985e 100644 --- a/src/Rainbow/Model/ProxyItemVersion.cs +++ b/src/Rainbow/Model/ProxyItemVersion.cs @@ -13,8 +13,8 @@ public ProxyItemVersion(IItemVersion versionToProxy) Fields = versionToProxy.Fields.Select(field => new ProxyFieldValue(field)).ToArray(); } - public IEnumerable Fields { get; private set; } - public CultureInfo Language { get; private set; } - public int VersionNumber { get; private set; } + public IEnumerable Fields { get; set; } + public CultureInfo Language { get; set; } + public int VersionNumber { get; set; } } }