public void HardcodedEntityAndPolymorphicTests() { using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); var implementation1 = new TestHardcodedEntity.ReferenceToHardcodedImplementation1 { ID = Guid.NewGuid() }; repository.TestHardcodedEntity.ReferenceToHardcodedImplementation1.Insert(implementation1); var implementation2 = new TestHardcodedEntity.ReferenceToHardcodedImplementation2 { ID = Guid.NewGuid() }; repository.TestHardcodedEntity.ReferenceToHardcodedImplementation2.Insert(implementation2); Assert.AreEqual(TestHardcodedEntity.SimpleHardcodedEntity.SpecialDescription, repository.TestHardcodedEntity.ReferenceToHardcoded.Query(x => x.ID == implementation1.ID).First().SimpleHardcodedEntityID.Value); Assert.AreEqual(TestHardcodedEntity.SimpleHardcodedEntity.StatusWithoutIntPropertyDefined, repository.TestHardcodedEntity.ReferenceToHardcoded.Query(x => x.ID == implementation2.ID).First().SimpleHardcodedEntityID.Value); } }
public void SqlTest() { using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); repository.TestHardcodedEntity.ReferenceToHardcodedEntity.Insert(new TestHardcodedEntity.ReferenceToHardcodedEntity { Content = "Message 1", SimpleHardcodedEntityID = TestHardcodedEntity.SimpleHardcodedEntity.StatusWithDefinedAllPropertity }); repository.TestHardcodedEntity.ReferenceToHardcodedEntity.Insert(new TestHardcodedEntity.ReferenceToHardcodedEntity { Content = "Message 2", SimpleHardcodedEntityID = TestHardcodedEntity.SimpleHardcodedEntity.StatusWithoutIntPropertyDefined }); Assert.AreEqual(1, repository.TestHardcodedEntity.HardcodedEntityInSqlTest.Query().Count()); } }
public void BeforeCloseFailed() { var id1 = Guid.NewGuid(); var log = new List <string>(); var systemLog = new List <string>(); string testName = TestNamePrefix + Guid.NewGuid(); using (var scope = TestScope.Create(builder => builder.ConfigureLogMonitor(systemLog, EventType.Trace))) { var transaction = scope.Resolve <IPersistenceTransaction>(); transaction.BeforeClose += () => log.Add("before1"); transaction.BeforeClose += () => throw new InvalidOperationException(testName); transaction.BeforeClose += () => log.Add("before2"); transaction.AfterClose += () => log.Add("after"); var repository = scope.Resolve <Common.DomRepository>(); repository.TestEntity.BaseEntity.Insert(new TestEntity.BaseEntity { ID = id1, Name = testName }); TestUtility.ShouldFail <InvalidOperationException>( () => scope.CommitAndClose(), testName); TestUtility.AssertContains( string.Join(Environment.NewLine, systemLog), new[] { "Rolling back transaction", "Closing connection" }); TestUtility.ShouldFail <FrameworkException>( () => Assert.IsNull(transaction.Connection), "Trying to use the Connection property of a disposed persistence transaction."); } Assert.AreEqual("before1", TestUtility.Dump(log)); using (var scope = TestScope.Create()) { var context = scope.Resolve <Common.ExecutionContext>(); Assert.IsFalse(context.Repository.TestEntity.BaseEntity.Query(new[] { id1 }).Any()); } }
public void ActionSetLock_MyRedundantLock() { using (var scope = TestScope.Create()) { var parentId = Guid.NewGuid(); scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestPessimisticLocking.Article;", "DELETE FROM TestPessimisticLocking.ArticleGroup;", "DELETE FROM Common.ExclusiveLock;", "INSERT INTO TestPessimisticLocking.ArticleGroup (ID, Name) SELECT '" + parentId + "', 'group1';", "INSERT INTO TestPessimisticLocking.Article (ID, Name, ParentID) SELECT '" + Guid.NewGuid() + "', 'aaa', '" + parentId + "';" }); var repository = scope.Resolve <Common.DomRepository>(); var article = repository.TestPessimisticLocking.Article.Load().Single(); var oldLock = new Common.ExclusiveLock { UserName = scope.Resolve <IUserInfo>().UserName, Workstation = scope.Resolve <IUserInfo>().Workstation, ResourceType = "TestPessimisticLocking.Article", ResourceID = article.ID, LockStart = DbTime(scope).AddSeconds(-10), LockFinish = DbTime(scope).AddSeconds(4) }; repository.Common.ExclusiveLock.Insert(new[] { oldLock }); TestSetLock(new Common.SetLock { ResourceType = "TestPessimisticLocking.Article", ResourceID = article.ID }, repository); var myLock = repository.Common.ExclusiveLock.Load().Single(); Assert.AreEqual("TestPessimisticLocking.Article", myLock.ResourceType); Assert.AreEqual(article.ID, myLock.ResourceID); Assert.AreEqual(scope.Resolve <IUserInfo>().UserName, myLock.UserName); Assert.AreEqual(scope.Resolve <IUserInfo>().Workstation, myLock.Workstation); var now = DbTime(scope); AssertInRange(myLock.LockStart.Value, now.AddSeconds(-1), now); AssertInRange(myLock.LockFinish.Value, now.AddMinutes(defaultLockMinutes).AddSeconds(-1), now.AddMinutes(defaultLockMinutes)); } }
public void CascadeDelete() { var log = new List <string>(); using (var scope = TestScope.Create(builder => builder.ConfigureLogMonitor(log, EventType.Info))) { var repository = scope.Resolve <Common.DomRepository>(); var pid1 = Guid.NewGuid(); var pid2 = Guid.NewGuid(); var pid3 = Guid.NewGuid(); var cid11 = Guid.NewGuid(); var cid12 = Guid.NewGuid(); var cid21 = Guid.NewGuid(); var cid31 = Guid.NewGuid(); scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestEntity.Child", "DELETE FROM TestEntity.BaseEntity", "INSERT INTO TestEntity.BaseEntity (ID, Name) SELECT '" + pid1 + "', '1'", "INSERT INTO TestEntity.BaseEntity (ID, Name) SELECT '" + pid2 + "', '2'", "INSERT INTO TestEntity.BaseEntity (ID, Name) SELECT '" + pid3 + "', '3'", "INSERT INTO TestEntity.Child (ID, Name, ParentID) SELECT '" + cid11 + "', '1a', '" + pid1 + "'", "INSERT INTO TestEntity.Child (ID, Name, ParentID) SELECT '" + cid12 + "', '1b', '" + pid1 + "'", "INSERT INTO TestEntity.Child (ID, Name, ParentID) SELECT '" + cid21 + "', '2a', '" + pid2 + "'", "INSERT INTO TestEntity.Child (ID, Name, ParentID) SELECT '" + cid31 + "', '3a', '" + pid3 + "'", }); Assert.AreEqual("1a, 1b, 2a, 3a", TestUtility.DumpSorted(repository.TestEntity.Child.Query(), item => item.Name)); log.Clear(); repository.TestEntity.BaseEntity.Delete(new [] { new TestEntity.BaseEntity { ID = pid1 }, new TestEntity.BaseEntity { ID = pid2 } }); Assert.AreEqual("3a", TestUtility.DumpSorted(repository.TestEntity.Child.Query(), item => item.Name)); Assert.AreEqual("[Info] Child.Deletions: 1a, 1b, 2a.", TestUtility.Dump(log), "Deletion of detail entity should be done through the object model (not just deleted in database by cascade delete)."); } }
public void InvalidFormat() { foreach (var test in new[] { "a+a", "a++a", "+a", "++a", "+a+", "++a+", "+a++", "++a++" }) { Console.WriteLine("Test: " + test); using (var scope = TestScope.Create()) { DeleteOldData(scope); var repository = scope.Resolve <Common.DomRepository>(); TestUtility.ShouldFail( () => repository.TestAutoCode.Simple.Insert(new[] { new TestAutoCode.Simple { ID = Guid.NewGuid(), Code = test } }), "invalid code"); } } }
public void DifferentLengths() { using (var scope = TestScope.Create()) { DeleteOldData(scope); var repository = scope.Resolve <Common.DomRepository>(); TestSimple(repository, "002", "002"); TestSimple(repository, "55", "55"); TestSimple(repository, "+", "56"); TestSimple(repository, "A002", "A002"); TestSimple(repository, "A55", "A55"); TestSimple(repository, "A++", "A56"); TestSimple(repository, "C100", "C100"); TestSimple(repository, "C99", "C99"); TestSimple(repository, "C+", "C101"); } }
public void AllowedNullValueInternally() { using (var scope = TestScope.Create()) { DeleteOldData(scope); var context = scope.Resolve <Common.ExecutionContext>(); var s1 = new TestAutoCode.Simple { ID = Guid.NewGuid(), Code = null }; AutoCodeHelper.UpdateCodesWithoutCache( context.SqlExecuter, "TestAutoCode.Simple", "Code", new[] { AutoCodeItem.Create(s1, s1.Code) }, (item, newCode) => item.Code = newCode); Assert.AreEqual("1", s1.Code); } }
public void UpdateTryRemoveLock() { using (var scope = TestScope.Create()) { scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestLockItems.Simple;" }); var repository = scope.Resolve <Common.DomRepository>(); var s3Lock = new TestLockItems.Simple { ID = Guid.NewGuid(), Name = "s3_lock" }; repository.TestLockItems.Simple.Insert(new[] { s3Lock }); AssertData("s3_lock", repository); s3Lock.Name = "abc"; AssertData("s3_lock", repository); TestUtility.ShouldFail(() => repository.TestLockItems.Simple.Update(new[] { s3Lock }), "[Test] Name contains lock mark."); AssertData("s3_lock", repository); } }
public void RecomputeAfterInsert() { using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); var artist = new TestComputedFromSelfExtension.Artist() { Name = "a2", ToursRevenue = 1000 }; repository.TestComputedFromSelfExtension.Artist.Insert(new[] { artist }); var computedArtist = repository.TestComputedFromSelfExtension.Artist .Query(item => item.ID == artist.ID) .SingleOrDefault(); decimal expectedTotalRevenue = 1000; Assert.AreEqual(expectedTotalRevenue, computedArtist.TotalRevenue); } }
public void DontFailOnEmpty() { using (var scope = TestScope.Create()) { scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestHierarchy.Simple" }); var repository = scope.Resolve <Common.DomRepository>(); repository.TestHierarchy.SimpleParentHierarchy.Recompute(); Assert.AreEqual("", ReportSimple(repository), "Initially empty."); PrepareSimpleData(repository, "a, a-b"); Assert.AreEqual("a1/4, b2/3", ReportSimple(repository)); var toDelete = repository.TestHierarchy.Simple.Query() .OrderByDescending(item => item.Extension_SimpleParentHierarchy.LeftIndex) .ToList(); repository.TestHierarchy.Simple.Delete(toDelete); Assert.AreEqual("", ReportSimple(repository), "Empty after delete."); } }
public void SerializationCsStringEncoding() { using (var scope = TestScope.Create()) { foreach (string s in StringoviSaOstalimUnicodeZnakovima) { var item = new TestDataStructure.SimpleDataStructure2 { SimpleShortString = s }; string xml = scope.Resolve <XmlUtility>().SerializeToXml(item); Console.WriteLine(xml); var item2 = scope.Resolve <XmlUtility>().DeserializeFromXml <TestDataStructure.SimpleDataStructure2>(xml); Assert.IsNotNull(item2); Assert.AreEqual(item.SimpleShortString, item2.SimpleShortString); TestUtility.AssertContains(xml.ToLower(), "utf-16", "C# string is always in UTF-16 encoding."); } } }
public void RollbackOnDisposeTest() { var id = Guid.NewGuid(); #pragma warning disable CS0618 // Type or member is obsolete using (var rhetos = new RhetosTestContainer("CommonConcepts.Test.dll", false)) { #pragma warning restore CS0618 var repository = rhetos.Resolve <Common.DomRepository>(); repository.TestEntity.BaseEntity.Insert(new TestEntity.BaseEntity { ID = id, Name = TestNamePrefix + "e2" }); } using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); Assert.IsFalse(repository.TestEntity.BaseEntity.Query().Any(x => x.ID == id)); } }
public void UpdateInvalidData() { using (var scope = TestScope.Create()) { scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestInvalidData.Simple;" }); var repository = scope.Resolve <Common.DomRepository>(); var s3 = CreateSimple(3).Single(); repository.TestInvalidData.Simple.Insert(new[] { s3 }); s3.Name = "s3b"; s3.Count = 33; repository.TestInvalidData.Simple.Update(new[] { s3 }); AssertData(repository, "s3b"); s3.Name = "s3c"; s3.Count = 300; TestUtility.ShouldFail(() => repository.TestInvalidData.Simple.Update(new[] { s3 }), "larger than 100"); } }
public void ShortStringPropertyBasicRhetosTypeValidation() { using (var scope = TestScope.Create()) { scope.Resolve <ISqlExecuter>().ExecuteSql("DELETE FROM TestEntity.Principal"); var repository = scope.Resolve <Common.DomRepository>(); TestEntity.Principal item = new TestEntity.Principal(); item.Name = new string('x', 256); repository.TestEntity.Principal.Insert(item); TestUtility.ShouldFail( () => { item.Name = new string('x', 257); repository.TestEntity.Principal.Update(item); }, "Principal", "Name", "256"); } }
public void OptimizedInheritingRowPermissions() { using (var scope = TestScope.Create()) { var context = scope.Resolve <Common.ExecutionContext>(); var repository = context.Repository; var query = repository.DemoRowPermissions2.DocumentInfo.Query(); string rowPermissionFilter = repository.DemoRowPermissions2.DocumentInfo .GetRowPermissionsReadExpression(query, repository, context) .ToString(); Console.WriteLine("[Row permission filter] " + rowPermissionFilter); TestUtility.AssertNotContains(rowPermissionFilter, "documentinfoItem.Base.Division", "SamePropertyValue concept should optimize row permissions to use Division property directly on 'DocumentInfo', instead of referencing the base entity 'Document'."); TestUtility.AssertContains(rowPermissionFilter, "documentinfoItem.Division2", "Internal error: Division2 property should be used in this row permissions."); } }
public void Serialization() { using (var scope = TestScope.Create()) { var item = new TestDataStructure.SimpleDataStructure2 { SimpleShortString = "abc" }; string xml = scope.Resolve <XmlUtility>().SerializeToXml(item); Console.WriteLine(xml); TestUtility.AssertContains(xml, "TestDataStructure"); TestUtility.AssertContains(xml, "SimpleDataStructure2"); TestUtility.AssertContains(xml, "SimpleShortString"); TestUtility.AssertContains(xml, "abc"); var item2 = scope.Resolve <XmlUtility>().DeserializeFromXml <TestDataStructure.SimpleDataStructure2>(xml); Assert.IsNotNull(item2); Assert.AreEqual(item.SimpleShortString, item2.SimpleShortString); } }
public void Paging() { using (var scope = TestScope.Create()) { InitializeData(scope); var info = new ReadCommandInfo { DataSource = "TestQueryDataStructureCommand.E", Top = 3, Skip = 3, OrderByProperties = new[] { new OrderByProperty { Property = "Name", Descending = true } }, ReadRecords = true, ReadTotalCount = true }; Assert.AreEqual("b, a /5", ReportCommandResult(scope, info)); } }
public void OptimizeContainsNullableWithNullValueTest() { using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); var id1 = Guid.NewGuid(); scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { $@"INSERT INTO Test12.Entity1 (ID) SELECT '{id1}';", }); var listWithNullValue = new List <Guid?> { null }; var record1 = repository.Test12.Entity1.Query().Where(EFExpression.OptimizeContains <Common.Queryable.Test12_Entity1>(x => listWithNullValue.Contains(x.GuidProperty))).Single(); Assert.AreEqual(id1, record1.ID); } }
public void SearchWithRankTop() { PrepareData(); using (var scope = TestScope.Create()) { var tests = new Dictionary <string, string> { { "\"ab*\"", "ab, abc, cd ab" }, { "\"12*\"", "123, ab, xy" }, }; var repository = scope.Resolve <Common.DomRepository>(); foreach (var test in tests) { Console.WriteLine("Searching '" + test.Key + "'"); // rankTop > count: int rankTop = 10; var filteredQuery = repository.TestFullTextSearch.SimpleBrowse.Query() .Where(item => DatabaseExtensionFunctions.FullTextSearch(item.ID, test.Key, "TestFullTextSearch.SimpleFTS", "*", rankTop)); Console.WriteLine(filteredQuery.ToString()); Assert.AreEqual(test.Value, TestUtility.DumpSorted(filteredQuery, item => item.Name), $"Searching top {rankTop} '{test.Key}'."); // rankTop < count: rankTop = 2; Assert.AreEqual(rankTop, filteredQuery.ToList().Count, $"Searching top {rankTop} '{test.Key}'."); // rankTop as a literal: filteredQuery = repository.TestFullTextSearch.SimpleBrowse.Query() .Where(item => DatabaseExtensionFunctions.FullTextSearch(item.ID, test.Key, "TestFullTextSearch.SimpleFTS", "*", 2)); Assert.AreEqual(rankTop, filteredQuery.ToList().Count, $"Searching '{test.Key}' with rankTop int literal."); } } }
public void MultiSync_InsertBase() { using (var scope = TestScope.Create()) { var deleteTables = new[] { "MultiSync", "Base1", "Base2" }; scope.Resolve <ISqlExecuter>().ExecuteSql(deleteTables.Select(t => "DELETE FROM TestComputedFrom." + t)); var repository = scope.Resolve <Common.DomRepository>(); Assert.AreEqual("", TestUtility.DumpSorted(repository.TestComputedFrom.MultiSync.Query(), Dump)); var b = new TestComputedFrom.Base1 { ID = Guid.NewGuid(), Name1 = "b1" }; repository.TestComputedFrom.Base1.Insert(new[] { b }); Assert.AreEqual("b1 b1a b1b ", TestUtility.DumpSorted(repository.TestComputedFrom.MultiSync.Query().ToList(), Dump)); var ms = repository.TestComputedFrom.MultiSync.Load().Single(); AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>())); AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>())); ms.Start = new DateTime(2001, 2, 3); ms.LastModifiedName1bx = new DateTime(2001, 2, 3); repository.TestComputedFrom.MultiSync.Update(new[] { ms }); ms = repository.TestComputedFrom.MultiSync.Load().Single(); AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>()), false); AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>()), false); b.Info = "xxx"; repository.TestComputedFrom.Base1.Update(new[] { b }); ms = repository.TestComputedFrom.MultiSync.Load().Single(); AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>()), false); AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>()), false); b.Name1 = "b1new"; repository.TestComputedFrom.Base1.Update(new[] { b }); Assert.AreEqual("b1new b1newa b1newb ", TestUtility.DumpSorted(repository.TestComputedFrom.MultiSync.Query().ToList(), Dump)); ms = repository.TestComputedFrom.MultiSync.Load().Single(); AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>()), false); AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>())); } }
public void ParallelInsertsLockingTestSamePrefix() { // One process must wait for another, since they use the same code prefix and code group: var endTimes = new DateTime[2]; Execute2ParallelInserts(1, (process, repository) => { repository.Insert(new[] { new TestAutoCode.Simple { Code = "+", Data = process.ToString() } }); System.Threading.Thread.Sleep(200); endTimes[process] = DateTime.Now; }); using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>().TestAutoCode.Simple; var generatedCodes = repository.Query().Select(item => item.Code).ToList(); var expected = Enumerable.Range(1, 2); Assert.AreEqual(TestUtility.DumpSorted(expected), TestUtility.DumpSorted(generatedCodes)); var codeByProcessReport = TestUtility.Dump(repository.Query() .OrderBy(item => item.Code) .Take(4) .Select(item => item.Data + ":" + item.Code)); Assert.IsTrue(codeByProcessReport == "0:1, 1:2" || codeByProcessReport == "1:1, 0:2"); TestUtility.DumpSorted(endTimes); var delay = Math.Abs(endTimes[0].Subtract(endTimes[1]).TotalMilliseconds); Console.WriteLine(delay); if (delay < 200) { Assert.Fail("One process did not wait for another."); } if (delay > 300) { Assert.Inconclusive("System too slow. Delay should be a little above 200."); } } }
public void QueryFilterCustomPareter() { using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); var items = new[] { new TestFilter.SimpleItem { Name = "si0" }, new TestFilter.SimpleItem { Name = "si1" }, new TestFilter.SimpleItem { Name = "si2" }, new TestFilter.SimpleItem { Name = "si3" }, }; repository.TestFilter.SimpleItem.Insert(items); var filter = new HashSet <string>(new[] { "si0", "si1" }); var ids = items.Select(item => item.ID).ToList(); var query = repository.TestFilter.SimpleItem.Query(); var directFilterImplementation = repository.TestFilter.SimpleItem.Filter(query, filter).Where(item => ids.Contains(item.ID)); Assert.AreEqual("si0, si1", TestUtility.DumpSorted(directFilterImplementation, item => item.Name)); var genericWithExplicitFilterType = repository.TestFilter.SimpleItem.Load(filter, filter.GetType()).Where(item => ids.Contains(item.ID)); Assert.AreEqual("si0, si1", TestUtility.DumpSorted(genericWithExplicitFilterType, item => item.Name)); var genericWithImplicitFilterType = repository.TestFilter.SimpleItem.Load(filter).Where(item => ids.Contains(item.ID)); Assert.AreEqual("si0, si1", TestUtility.DumpSorted(genericWithImplicitFilterType, item => item.Name)); var legacyFilterMethod = repository.TestFilter.SimpleItem.Filter(filter).Where(item => ids.Contains(item.ID)); Assert.AreEqual("si0, si1", TestUtility.DumpSorted(legacyFilterMethod, item => item.Name)); } }
public void ActivePropertyValueDoesNotHaveToBeDefinedOnUpdate() { using (var scope = TestScope.Create()) { var id1 = Guid.NewGuid(); var id2 = Guid.NewGuid(); var id3 = Guid.NewGuid(); var id4 = Guid.NewGuid(); scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestDeactivatable.BasicEnt", "INSERT INTO TestDeactivatable.BasicEnt (ID, Name) VALUES (" + SqlUtility.QuoteGuid(id1) + ", 'a')", "INSERT INTO TestDeactivatable.BasicEnt (ID, Name, Active) VALUES (" + SqlUtility.QuoteGuid(id2) + ", 'b', 0)", "INSERT INTO TestDeactivatable.BasicEnt (ID, Name) VALUES (" + SqlUtility.QuoteGuid(id3) + ", 'c')", "INSERT INTO TestDeactivatable.BasicEnt (ID, Name, Active) VALUES (" + SqlUtility.QuoteGuid(id4) + ", 'd', 1)", }); var repository = scope.Resolve <Common.DomRepository>(); Assert.AreEqual( "a , b False, c , d True", TestUtility.DumpSorted(repository.TestDeactivatable.BasicEnt.Query(), item => item.Name + " " + item.Active)); var e1 = new BasicEnt { ID = id1, Name = "a2", Active = false }; var e2 = new BasicEnt { ID = id2, Name = "b2" }; var e3 = new BasicEnt { ID = id3, Name = "c2" }; var e4 = new BasicEnt { ID = id4, Name = "d2" }; repository.TestDeactivatable.BasicEnt.Update(new[] { e1, e2, e3, e4 }); var afterUpdate = repository.TestDeactivatable.BasicEnt.Query(); Assert.AreEqual( "a2 False, b2 False, c2 True, d2 True", TestUtility.DumpSorted(afterUpdate, item => item.Name + " " + item.Active)); } }
public void TableConstraints() { using (var scope = TestScope.Create()) { var sqlExecuter = scope.Resolve <ISqlExecuter>(); var repository = scope.Resolve <Common.DomRepository>(); sqlExecuter.ExecuteSql(new[] { @"DELETE FROM TestExtension.EntityExtension1", @"DELETE FROM TestExtension.Old1", @"INSERT INTO TestExtension.Old1 (ID, i, s) SELECT ID = '5D089327-97EF-418D-A7DF-783D3873A5B4', i = 1, s = 'a'", @"INSERT INTO TestExtension.Old1 (ID, i, s) SELECT ID = 'DB97EA5F-FB8C-408F-B35B-AD6642C593D7', i = 2, s = 'b'", @"INSERT INTO TestExtension.EntityExtension1 (ID, info) SELECT ID = '5D089327-97EF-418D-A7DF-783D3873A5B4', info = '1-a'", @"INSERT INTO TestExtension.EntityExtension1 (ID, info) SELECT ID = 'DB97EA5F-FB8C-408F-B35B-AD6642C593D7', info = '2-b'" }); // Test querying: var secondDescription = repository.TestExtension.EntityExtension1.Query().Where(item => item.Base.i == 2).Select(item => item.info).Single(); Assert.AreEqual("2-b", secondDescription); // Test FK: TestUtility.ShouldFail( () => sqlExecuter.ExecuteSql(@"INSERT INTO TestExtension.EntityExtension1 (ID, info) SELECT ID = NEWID(), info = '3-c'"), "Old1", "The INSERT statement conflicted with the FOREIGN KEY constraint"); // Test cascade delete in database: // (the release should ship with "CommonConcepts.Legacy.CascadeDeleteInDatabase" set to "False") TestUtility.ShouldFail( () => sqlExecuter.ExecuteSql(@"DELETE FROM TestExtension.Old1 WHERE i = 2"), "EntityExtension1", "The DELETE statement conflicted with the REFERENCE constraint"); Assert.AreEqual(2, repository.TestExtension.Old1.Query().Count(), "Testing the Old1 setup to avoid false-positive."); Assert.AreEqual(2, repository.TestExtension.EntityExtension1.Query().Count(), "Testing the EntityExtension1 setup to avoid false-positive."); repository.TestExtension.Legacy1.Delete(new TestExtension.Legacy1 { ID = new Guid("DB97EA5F-FB8C-408F-B35B-AD6642C593D7") }); Assert.AreEqual(1, repository.TestExtension.Old1.Query().Count(), "Old1 should have been deleted as it is a source for Legacy1."); Assert.AreEqual(1, repository.TestExtension.EntityExtension1.Query().Count(), "'On delete cascade' should delete one extension record."); } }
public void OptimizeEqualsGuidTest() { using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); var id = Guid.NewGuid(); var sqlQuery1 = repository.TestGenericFilter.Child.Query(new FilterCriteria("ID", "equals", id)).ToString(); TestUtility.AssertNotContains(sqlQuery1, id.ToString()); var sqlQuery2 = repository.TestGenericFilter.Child.Query(new FilterCriteria("ParentID", "equals", id)).ToString(); TestUtility.AssertNotContains(sqlQuery2, id.ToString()); var nullableId = new Nullable <Guid>(Guid.NewGuid()); var sqlQuery3 = repository.TestGenericFilter.Child.Query(new FilterCriteria("ID", "equals", nullableId)).ToString(); TestUtility.AssertNotContains(sqlQuery3, nullableId.Value.ToString()); var sqlQuery4 = repository.TestGenericFilter.Child.Query(new FilterCriteria("ParentID", "equals", nullableId)).ToString(); TestUtility.AssertNotContains(sqlQuery4, nullableId.Value.ToString()); } }
public void PersistCustom() { using (var scope = TestScope.Create()) { scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestComputedFrom.PersistCustom" }); var repository = scope.Resolve <Common.DomRepository>(); Assert.AreEqual("", TestUtility.DumpSorted(repository.TestComputedFrom.PersistCustom.Load(), Dump)); repository.TestComputedFrom.PersistCustom.RecomputeFromSource(new FilterAll(), items => items.Where(item => item.Code == 11)); Assert.AreEqual("aa 11", TestUtility.DumpSorted(repository.TestComputedFrom.PersistCustom.Load(), Dump), "recompute all with SaveFilter to sync only Code 11 "); repository.TestComputedFrom.PersistCustom.RecomputeFromSource(); Assert.AreEqual("aa 11, bb 22", TestUtility.DumpSorted(repository.TestComputedFrom.PersistCustom.Load(), Dump), "recompute all"); repository.TestComputedFrom.PersistCustom.Delete(repository.TestComputedFrom.PersistCustom.Load()); repository.TestComputedFrom.PersistCustom.RecomputeFromSource(new[] { repository.TestComputedFrom.Source.Load().Where(item => item.Code == 22).Single().ID }); Assert.AreEqual("bb 22", TestUtility.DumpSorted(repository.TestComputedFrom.PersistCustom.Load(), Dump), "recompute by ID (code 22)"); } }
public void UseExecutionContext() { using (var scope = TestScope.Create()) { var repository = scope.Resolve <Common.DomRepository>(); scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM Test11.Source;", "INSERT INTO Test11.Source (Name) SELECT 'a';", "INSERT INTO Test11.Source (Name) SELECT 'b';" }); var userInfo = scope.Resolve <IUserInfo>(); Assert.IsFalse(string.IsNullOrEmpty(userInfo.UserName)); string expected = string.Format("a {0}, b {0}", userInfo.UserName); Console.WriteLine(expected); Assert.AreEqual(expected, TestUtility.DumpSorted(repository.Test11.QEContext.Query(), item => item.UserInfo)); } }
public void PersistPartial() { using (var scope = TestScope.Create()) { scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestComputedFrom.PersistPartial" }); var repository = scope.Resolve <Common.DomRepository>(); Assert.AreEqual("", TestUtility.DumpSorted(repository.TestComputedFrom.PersistPartial.Load(), Dump)); repository.TestComputedFrom.PersistPartial.RecomputeFromSource(new Rhetos.Dom.DefaultConcepts.FilterAll(), items => items.Where(item => item.Name == "aa")); Assert.AreEqual("aa", TestUtility.DumpSorted(repository.TestComputedFrom.PersistPartial.Load(), Dump), "recompute all with SaveFilter to sync only Name aa "); repository.TestComputedFrom.PersistPartial.RecomputeFromSource(); Assert.AreEqual("aa, bb", TestUtility.DumpSorted(repository.TestComputedFrom.PersistPartial.Load(), Dump), "recompute all"); repository.TestComputedFrom.PersistPartial.Delete(repository.TestComputedFrom.PersistPartial.Load()); repository.TestComputedFrom.PersistPartial.RecomputeFromSource(new[] { repository.TestComputedFrom.Source.Load().Where(item => item.Name == "bb").Single().ID }); Assert.AreEqual("bb", TestUtility.DumpSorted(repository.TestComputedFrom.PersistPartial.Load(), Dump), "recompute by ID (name bb)"); } }
public void NonEditablePropertyUpdateFromNull() { using (var scope = TestScope.Create()) { var simpleID = Guid.NewGuid(); scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestDenyUserEdit.Simple", "DELETE FROM TestDenyUserEdit.Parent", "INSERT INTO TestDenyUserEdit.Simple (ID, Editable, NonEditable) VALUES (" + SqlUtility.QuoteGuid(simpleID) + ", 'a', NULL)" }); var repository = scope.Resolve <Common.DomRepository>(); var simple = new TestDenyUserEdit.Simple { ID = simpleID, Editable = "a", NonEditable = "x" }; TestUtility.ShouldFail(() => repository.TestDenyUserEdit.Simple.Save(null, new[] { simple }, null, true), "Simple", "NonEditable", "not allowed"); } }