public void Should_validate() { var testEntity = new TestEntity(); repository.Expect(x => x.GetById(3)).Return(testEntity); binder.BindModel(controllerContext, context); validatingBinder.AssertWasCalled(x => x.UpdateFrom(testEntity, controllerContext.HttpContext.Request.Form, context.ModelState, "foo")); }
public void Test_UpperCase_BulkInsert() { // Use Upper Case Schema Name: subject = new PostgreSQLCopyHelper<TestEntity>("SAMPLE", "UNIT_TEST") .MapSmallInt("col_smallint", x => x.SmallInt); // Try to work with the Bulk Inserter: var entity0 = new TestEntity() { SmallInt = Int16.MinValue }; var entity1 = new TestEntity() { SmallInt = Int16.MaxValue }; subject.SaveAll(connection, new[] { entity0, entity1 }); var result = connection.GetAll("sample", "unit_test"); // Check if we have the amount of rows: Assert.AreEqual(2, result.Count); Assert.IsNotNull(result[0][0]); Assert.IsNotNull(result[1][0]); Assert.AreEqual(Int16.MinValue, (Int16)result[0][0]); Assert.AreEqual(Int16.MaxValue, (Int16)result[1][0]); }
public void EntitiesWithDifferentIdShouldNotBeEqual() { var entity1 = new TestEntity(Guid.NewGuid()); var entity2 = new TestEntity(Guid.NewGuid()); Assert.IsFalse(entity1.Equals(entity2)); }
public ComparisonAttributeTest() { _validEntity = new TestEntity { FirstProperty = 10, SecondProperty = 10 }; _invalidEntity = new TestEntity {FirstProperty = 10, SecondProperty = 20}; _attribute = new ComparisonAttribute("SecondProperty", ComparisonAttribute.ComparisonCondition.Equal); _attribute.ErrorMessage = _errorMessage; }
private static void SetEntityId(TestEntity entity, long id) { var idProperty = entity.GetType() .GetProperty("Id", BindingFlags.Instance | BindingFlags.Public); var setter = idProperty.SetMethod; setter.Invoke(entity, new object[] { id }); }
public void When_include_has_no_conflicts_happy_path() { var entity1 = new TestEntity("INV-0001"); var entity2 = new TestEntity("INV-0002"); EventData[] events = { CreateEvent("e1", Include.Insert(entity1)), CreateEvent("e2", Include.Insert(entity2)) }; var result = Stream.Write(new Stream(partition), events); var stored = RetrieveTestEntity(entity1.RowKey); Assert.That(stored, Is.Not.Null); stored = RetrieveTestEntity(entity2.RowKey); Assert.That(stored, Is.Not.Null); Assert.That(result.Includes.Length, Is.EqualTo(2)); Assert.That(result.Includes[0], Is.SameAs(entity1)); Assert.That(result.Includes[0].ETag, Is.Not.Null.Or.Empty); Assert.That(result.Includes[1], Is.SameAs(entity2)); Assert.That(result.Includes[1].ETag, Is.Not.Null.Or.Empty); }
public void GivenValueDoesNotMatchInvalidValue_AndValidationContext_WhenValidate_ThenSucceed() { TestEntity toValidate = new TestEntity { Value = "not invalid" }; ValidationContext validationContext = new ValidationContext(toValidate) { DisplayName = "Test Entity Value", MemberName = "Value" }; Target.Validate(toValidate.Value, validationContext); }
public void Entity_ConstructorAssignsValues() { var guid = Guid.NewGuid(); var entity = new TestEntity(guid); entity.Id.Should().Be(guid); }
public void Castle() { SystemConfig.ConfigFilesAssemblyName = "CodeSharp.Framework.Castles.Test"; SystemConfig.Configure("ConfigFiles") .Castle() .BusinessDependency(Assembly.GetExecutingAssembly()); Assert.AreEqual("abc", SystemConfig.Settings["key1"]); Assert.DoesNotThrow(() => DependencyResolver.Resolve<ILoggerFactory>().Create(this.GetType()).Info("hi")); Assert.DoesNotThrow(() => DependencyResolver.Resolve<ITestService>()); Assert.DoesNotThrow(() => DependencyResolver.Resolve<NHibernate.ISessionFactory>()); //NH Tests var e = new TestEntity("abc"); var s = DependencyResolver.Resolve<ITestService>(); s.Create(e); DependencyResolver.Resolve<Castle.Facilities.NHibernateIntegration.ISessionManager>().OpenSession().Evict(e); var e2= s.Get(e.ID); //private setter? Assert.AreEqual(e.Name, e2.Name); Assert.AreEqual("abc", e2.Name); Assert.DoesNotThrow(() => SystemConfig.Cleanup()); }
public virtual void Context() { Entity = new TestEntity(); Session = Mock<ISession>(); var unitOfWork = CreateUnitOfWorkWithStartedTransaction(); Repository = new NhibernateRepository<TestEntity>(unitOfWork); }
public void GetHashCode_returns_hash_code_of_Id() { var entity = new TestEntity(); long id = 2; SetEntityId(entity, id); Assert.AreEqual(id.GetHashCode(), entity.GetHashCode()); }
public void GetHashCode_uses_hash_code_that_was_generated_pre_id_set() { var entity = new TestEntity(); var hash = entity.GetHashCode(); SetEntityId(entity, 1); Assert.AreEqual(hash, entity.GetHashCode()); }
public void EqualsWithNewObjectsUsesReferenceEquals() { // Arrange var ent1 = new TestEntity(); var ent2 = new TestEntity(); // Act bool different = ent1.Equals( ent2 ); bool different2 = ent2.Equals( ent1 ); bool different3 = ent1 == ent2; bool equal3 = ent1 != ent2; var ent3 = ent1; bool equal = ent1.Equals( ent3 ); bool equal2 = ent3.Equals( ent1 ); bool equal4 = ent1 == ent3; bool different4 = ent1 != ent3; // Assert Assert.IsFalse( different ); Assert.IsFalse( different2 ); Assert.IsFalse( different3 ); Assert.IsFalse( different4 ); Assert.IsTrue( equal ); Assert.IsTrue( equal2 ); Assert.IsTrue( equal3 ); Assert.IsTrue( equal4 ); }
public void IntersectTest() { var a = new TestEntity(Vector2.Zero, new Vector2(10, 10)); var b = new TestEntity(Vector2.Zero, new Vector2(10, 10)); Assert.IsTrue(a.Intersects(b)); a.Position = new Vector2(9, 9); Assert.IsTrue(a.Intersects(b)); a.Position = new Vector2(-9, -9); Assert.IsTrue(a.Intersects(b)); a.Position = new Vector2(-9, 0); Assert.IsTrue(a.Intersects(b)); a.Position = new Vector2(0, -9); Assert.IsTrue(a.Intersects(b)); a.Position = new Vector2(-11, -11); Assert.IsFalse(a.Intersects(b)); a.Position = new Vector2(-11, 0); Assert.IsFalse(a.Intersects(b)); a.Position = new Vector2(0, -11); Assert.IsFalse(a.Intersects(b)); a.Position = new Vector2(11, 11); Assert.IsFalse(a.Intersects(b)); }
public void EntityID_Can_Init() { var entity = new TestEntity(); Assert.IsTrue(entity.Id == Guid.Empty); var id = Guid.NewGuid(); entity.Id = id; Assert.IsTrue(entity.Id == id); }
public void EntitiesWithSameIdShouldBeEqual() { var guid = Guid.NewGuid(); var entity1 = new TestEntity(guid); var entity2 = new TestEntity(guid); Assert.IsTrue(entity1.Equals(entity2)); }
public void Equals_should_return_true_if_both_entities_have_same_Id() { var entity = new TestEntity(); var entity2 = new TestEntity(); SetEntityId(entity, 1); SetEntityId(entity2, 1); Assert.True(entity.Equals(entity2)); }
public void GivenNumbersEqual_AndAllowEquality_AndValidationContext_WhenValidate_ThenSucceed() { TestEntity toValidate = new TestEntity { Value = "10" }; ValidationContext validationContext = new ValidationContext(toValidate) { DisplayName = "Test Entity Value", MemberName = "Value" }; var target = new NumericGreaterThanAttribute("Value") { AllowEquality = true }; target.Validate("10", validationContext); }
public void Equals_should_return_false_if_entities_have_different_Id() { var entity = new TestEntity(); var entity2 = new TestEntity(); SetEntityId(entity, 1); SetEntityId(entity2, 2); Assert.False(entity.Equals(entity2)); }
public void GivenValueContainsTerm_AndValidationContext_WhenValidate_ThenThrowException() { TestEntity toValidate = new TestEntity { Value = "mcblah" }; ValidationContext validationContext = new ValidationContext(toValidate) { DisplayName = "Test Entity Value", MemberName = "Value" }; var target = new DoesNotContainAttribute("blah"); target.ExpectException<ValidationException>(() => target.Validate(toValidate.Value, validationContext)); }
public void GivenValueDoesntContainTerm_AndValidationContext_WhenValidate_ThenSucceed() { TestEntity toValidate = new TestEntity { Value = "test" }; ValidationContext validationContext = new ValidationContext(toValidate) { DisplayName = "Test Entity Value", MemberName = "Value" }; var target = new DoesNotContainAttribute("blah"); target.Validate(toValidate.Value, validationContext); }
public void GetValue_ShouldReturnFieldValue() { var expected = "expected"; var entity = new TestEntity() { PublicField = expected }; var setter = new FieldPropertySetter(typeof (TestEntity).GetField("PublicField")); Assert.Equal(expected, setter.GetValue(entity)); }
public void Should_fetch_from_primary_key() { var testEntity = new TestEntity(); repository.Expect(x => x.GetById(3)).Return(testEntity); var result = binder.BindModel(controllerContext, context); result.ShouldBeTheSameAs(testEntity); }
public void EntityRemovedEventShouldBeTriggeredWhenEntityAddedTest() { var serviceEntity = new TestEntity { Name = "name" }; Context.Service.AddEntity(serviceEntity); Assert.IsTrue(Context.WaitFor(() => Context.Entities.Count() == 1, Context.WaitingPeriod)); Context.Service.RemoveEntity(serviceEntity); Assert.IsTrue(Context.WaitFor(() => !Context.Entities.Any(), Context.WaitingPeriod)); }
public void AddTest() { foreach (var spatial in GetSpatials()) { var entity = new TestEntity(); spatial.Add(entity); Assert.IsTrue(spatial.CollectionContains(entity), "Current spatial: " + spatial); } }
public void WithTestEntity() { Entity = new TestEntity { Description = "This is it", Name = "THENAME", Enabled = true }; }
public void Can_changetracker_manipulatecollection() { var tracker = new ObservableChangeTracker(); var entity = new TestEntity(); tracker.Add(entity); tracker.Remove(entity); tracker.Add(entity); }
public void GivenInvalidValue_AndValidationContext_WhenValidate_ThenThrowException() { TestEntity toValidate = new TestEntity { Value = "blah" }; ValidationContext validationContext = new ValidationContext(toValidate) { DisplayName = "Test Entity Value", MemberName = "Value" }; var target = new NumericGreaterThanAttribute("Value"); ValidationException actual = target.ExpectException<ValidationException>(() => target.Validate("10", validationContext)); Assert.AreEqual("Value is not a numeric value.", actual.Message); }
public void GivenPropertyIsEqual_AndDontAllowEquality_AndValidationContext_WhenValidate_ThenThrowException() { TestEntity toValidate = new TestEntity { Value = "10" }; ValidationContext validationContext = new ValidationContext(toValidate) { DisplayName = "Test Entity Value", MemberName = "Value" }; var target = new NumericGreaterThanAttribute("Value") { AllowEquality = false }; ValidationException actual = target.ExpectException<ValidationException>(() => target.Validate("10", validationContext)); Assert.AreEqual("AllowEquality has been set to false so values cannot be equal.", actual.Message); }
public void GivenInvalidProperty_AndValidationContext_WhenValidate_ThenThrowException() { TestEntity toValidate = new TestEntity { Value = "10" }; ValidationContext validationContext = new ValidationContext(toValidate) { DisplayName = "Test Entity Value", MemberName = "Value" }; var target = new NumericLessThanAttribute("blah"); ValidationException actual = target.ExpectException<ValidationException>(() => target.Validate("10", validationContext)); Assert.AreEqual("Could not find a property named blah.", actual.Message); }
public void ListEntityBase_Remove() { TestEntity entity = new TestEntity(); entity.InnerList.AddRange(Enumerable.Range(3, 3).Cast <object>()); entity.InnerList.Add(3); entity.Remove(3); Assert.Equal(3, entity.InnerList.Count); Assert.Equal(4, entity.InnerList[0]); Assert.Equal(5, entity.InnerList[1]); Assert.Equal(3, entity.InnerList[2]); entity.Remove(0); entity.Remove("test"); Assert.Equal(3, entity.InnerList.Count); entity.Remove(3); entity.Remove(4); entity.Remove(5); Assert.Empty(entity.InnerList); }
public void MatchAction_with_keyFunc() { Func <TestItem, string, bool> matchKey = (model, key) => model.Key == Guid.Parse(key); var map = new MapTask <TestEntity>() .MatchAction((x, y) => { x.List = y.ToList(); }, "items", matchKey); var modelMap = map.ModelMaps.First(); var entity = new TestEntity(); var items = new List <TestItem> { new TestItem() }; Assert.That(map.ModelMaps.Count, Is.EqualTo(1)); Assert.That(modelMap.Alias, Is.EqualTo("items")); Assert.That(modelMap.IsMatch, Is.Not.EqualTo(matchKey)); Assert.That(modelMap.IsMany); modelMap.SetModel(entity, items); Assert.That(entity.List, Is.EqualTo(items)); }
public void CanPersistLinqWhereIEnumerable() { using (var store = GetDocumentStore()) { using (var session = store.OpenSession()) { var entity = new TestEntity { Property = new[] { "one", "two" }.Where(s => s.Length > 1) }; session.Store(entity); session.SaveChanges(); } using (var session = store.OpenSession()) { var loadedEntity = session.Load <TestEntity>("TestEntities/1-A"); Assert.Contains("one", loadedEntity.Property); Assert.Contains("two", loadedEntity.Property); } } }
public void EFCoreDataContextTest() { using (var connection = new SqliteConnection("DataSource=:memory:")) { connection.Open(); var builder = new DbContextOptionsBuilder(); var options = builder.UseSqlite(connection).Options; var testEntity = new TestEntity { Key = 10, Value = "Sample Value" }; using (var dc = new EFCoreTestDataContext(options)) { dc.Database.EnsureCreated(); dc.Set <TestEntity> ().Add(testEntity); dc.SaveChanges(); } using (var dc = new EFCoreTestDataContext(options)) { Assert.Equal(1, dc.Set <TestEntity> ().Count()); } } }
public void ReusabilitySucceeds() { const string dbName = "MyDatabase"; const string value = "prop"; using (var context = InMemoryContextBuilder.Build <TestDataContext>(dbName)) { var entity = new TestEntity { Property = value }; context.Add(entity); context.SaveChanges(); } TestEntity res; using (var context = InMemoryContextBuilder.Build <TestDataContext>(dbName)) { res = context.TestEntities.First(e => e.Property == value); } Assert.NotNull(res); }
public when_saving_entity() { this.eventStore = new Mock <IEventStore>(); this.publisher = new Mock <IEventStoreBusPublisher>(); var sut = new AzureEventSourcedRepository <TestEntity>(eventStore.Object, publisher.Object, new JsonTextSerializer(), new StandardMetadataProvider(), null); this.id = Guid.NewGuid(); var entity = new TestEntity { Id = id, Events = { new TestEvent { SourceId = id, Version = 1, Foo = "Bar" }, new TestEvent { SourceId = id, Version = 2, Foo = "Baz" } } }; sut.Save(entity, "correlation"); }
void assertHasComponentA(TestEntity e, IComponent componentA = null) { if (componentA == null) { componentA = Component.A; } e.GetComponentA().should_be_same(componentA); var components = e.GetComponents(); components.Length.should_be(1); components.should_contain(componentA); var indices = e.GetComponentIndices(); indices.Length.should_be(1); indices.should_contain(CID.ComponentA); e.HasComponentA().should_be_true(); e.HasComponents(_indicesA).should_be_true(); e.HasAnyComponent(_indicesA).should_be_true(); }
public async Task WithFileAndNoDb() { new SqlInstance <TestDbContext>( constructInstance: builder => new TestDbContext(builder.Options), instanceSuffix: "EfWithFileAndNoDb"); LocalDbApi.StopAndDelete("TestDbContext_EfWithFileAndNoDb"); var instance = new SqlInstance <TestDbContext>( constructInstance: builder => new TestDbContext(builder.Options), instanceSuffix: "EfWithFileAndNoDb"); var entity = new TestEntity { Property = "prop" }; using (var database = await instance.Build(new List <object> { entity })) { Assert.NotNull(database.Context.TestEntities.FindAsync(entity.Id)); } }
public void When_including_unconditional_replace() { var entity = new TestEntity(EntityRowKey) { Data = "123" }; InsertTestEntity(entity); entity = new TestEntity(EntityRowKey) { Data = "456", ETag = "*" }; Assert.DoesNotThrow(() => Stream.Write(stream, CreateEvent(Include.Replace(entity))), "Will be always executed and will fully replace contents"); var stored = RetrieveTestEntity(EntityRowKey); Assert.That(stored.Data, Is.EqualTo("456")); }
public void ShouldDetectMostRecentChangesForAdded() { var detector = new TestEntityChangeDetector(); EntityChangeTracker <TestEntity> tracker = new EntityChangeTracker <TestEntity>(detector); TestEntity entity = new TestEntity() { IntValue = 123 }; tracker.Add(entity); entity.IntValue = 234; var after = tracker.DetectChanges(entity); Assert.AreEqual(EntityState.Added, after.State, "The entity should have remained Added."); Assert.IsTrue(after.HasChange(x => x.IntValue), "The IntValue should have changed."); var change = after.GetChange(x => x.IntValue); Assert.IsNotNull(change, "The change was null after detecting its prescence."); Assert.AreEqual(234, change.UpdatedValue, "The latest value was not returned."); }
public void SortBy_Should_Sort_Collection_Successfully() { //Arrange var numberSortedList = new int[] { 1, 2, 3, 4, 5, 6 }; var testEntity2 = new TestEntity { Id = 2, Name = "test2" }; var testEntity3 = new TestEntity { Id = 3, Name = "test3" }; var testEntity1 = new TestEntity { Id = 1, Name = "test1" }; var entityCollection = new TestEntity[] { testEntity2, testEntity3, testEntity1 }; //Act var sortedEntityCollection = entityCollection.SortBy(numberSortedList, x => x.Id); //Assert Assert.AreEqual(sortedEntityCollection.First().Id, 1); Assert.AreEqual(sortedEntityCollection.ElementAt(1).Id, 2); Assert.AreEqual(sortedEntityCollection.Last().Id, 3); }
public void MainTest() { Require.ProviderIs(StorageProvider.SqlServer, "Uses multiple databases and native SQL"); long id; var domain1 = BuildDomain(MultidatabaseTest.Database1Name); using (var session = domain1.OpenSession()) using (var tx = session.OpenTransaction()) { id = new TestEntity().Id; tx.Complete(); } var domain2 = BuildDomain(MultidatabaseTest.Database2Name); using (var session = domain2.OpenSession()) using (var tx = session.OpenTransaction()) { session.Services.Demand <DirectSqlAccessor>().RegisterInitializationSql(GetUseDatabaseScript(MultidatabaseTest.Database1Name)); var entity = session.Query.Single <TestEntity>(id); Assert.That(entity.Id, Is.EqualTo(id)); } }
public void UpdateCommenters_OnValidCall_ExecuteNonQuery() { // Arrange SetupShimsForSqlClient(); ShimSqlCommand.AllInstances.ExecuteScalar = _ => UserRole.Assignee; // Act TestEntity.UpdateCommenters(new Thread { Users = new[] { new User { Id = DummyInt, Role = UserRole.Commenter }, new User { Id = DummyInt, Role = UserRole.Assignee } } }); // Assert _executeNonQueryInvoked.ShouldBeTrue(); }
public void ListEntityBaseOfT_CompareTo_LongerLength() { TestEntity <string> entity1 = new TestEntity <string> { "a", null, "b", null, "c" }; TestEntity <string> entity2 = new TestEntity <string> { "a", null, "b", null }; int result = entity1.CompareTo(entity2); Assert.Equal(1, result); }
public void EscapeNetworkTest() { var tt = new Timetable(TimetableType.Network); var e = new TestEntity("test", tt); e.SetAttribute("rvctest", "0:foo:bar;;baz::;;;;;1:test;2:;"); var rvc = new RouteValueCollection <string>(e, tt, "rvctest", "default;:test", s => s, s => s, false); rvc.TestForErrors(); // Should do nothing Assert.AreEqual("foo:bar;baz::;;", rvc.GetValue(0)); Assert.AreEqual("test", rvc.GetValue(1)); Assert.AreEqual("default;:test", rvc.GetValue(2)); Assert.AreEqual("default;:test", rvc.GetValue(3)); // test default value rvc.SetValue(0, ""); rvc.SetValue(1, "test;:test"); rvc.Write(); Assert.AreEqual("0:;1:test;;:test;2:default;;:test", e.GetAttribute <string>("rvctest")); }
public void CanDocumentCreationWithExplicitMetadata_CreationDateOnly() { var createdDate = new DateTime(2000, 1, 1); const string createdByUser = null; var entity = new TestEntity { CreatedDate = createdDate, CreatedByUser = createdByUser, }; object[] values = CreateValues(entity); EntityMetadataUtils.DocumentCreation(entity, values, _properties); Assert.AreEqual(createdDate, entity.CreatedDate); Assert.AreEqual(GetUserName(), entity.CreatedByUser); // the LastChanged information will be set to the Creation information if missing Assert.AreEqual(createdDate, entity.LastChangedDate); Assert.AreEqual(GetUserName(), entity.LastChangedByUser); AssertEqualState(entity, values); }
public void CanDocumentCreationWithExplicitMetadata_LastChangedOnly() { var lastChangedDate = new DateTime(2010, 1, 1); const string lastChangedByUser = "******"; var entity = new TestEntity { LastChangedDate = lastChangedDate, LastChangedByUser = lastChangedByUser, }; object[] values = CreateValues(entity); EntityMetadataUtils.DocumentCreation(entity, values, _properties); Assert.AreEqual(lastChangedDate, entity.LastChangedDate); Assert.AreEqual(lastChangedByUser, entity.LastChangedByUser); // the Created information will be set to the LastChanged information if missing Assert.AreEqual(lastChangedDate, entity.CreatedDate); Assert.AreEqual(lastChangedByUser, entity.CreatedByUser); AssertEqualState(entity, values); }
public void Test_NullableTimeSpan() { var entity0 = new TestEntity() { TimeSpan = TimeSpan.FromDays(1) }; var entity1 = new TestEntity() { TimeSpan = TimeSpan.FromDays(2) }; subject.SaveAll(connection, new[] { entity0, entity1 }); var result = GetAll(); // Check if we have the amount of rows: Assert.AreEqual(2, result.Count); Assert.AreEqual(entity0.TimeSpan, (TimeSpan)result[0][13]); Assert.AreEqual(entity1.TimeSpan, (TimeSpan)result[1][13]); }
public void UpdateMultipleSameEntity() { using (var context = InMemoryContextBuilder.Build <TestDataContext>()) { var entity1 = new TestEntity { Id1 = 1, Id2 = 1, Property = "prop" }; var entity2 = new TestEntity { Id1 = 1, Id2 = 2, Property = "prop" }; context.AddRange(entity1, entity2); context.SaveChanges(); entity1.Property = "Something new"; entity2.Property = "Something new"; context.SaveChanges(); } }
public void SelectByIdTest() { var repository = RepositoryManager.GetRepository <ITestRepository>(); Assert.IsNotNull(repository); var entity = new TestEntity() { Name = TestHelper.RandomizeString(), UpdateDate = DateTime.Now }; Assert.AreEqual(0, entity.Id); var result = repository.Save(entity); Assert.IsTrue(result); Assert.IsTrue(0 < entity.Id); var dbEntity = repository.FindById(entity.Id); Assert.AreEqual(entity.Id, dbEntity.Id); Assert.AreEqual(entity.Name, dbEntity.Name); Assert.AreEqual(0, (entity.UpdateDate - dbEntity.UpdateDate).Minutes); }
public void ListEntityBase_CompareTo_LongerLength() { TestEntity entity1 = new TestEntity { 1, null, 2, null, 3 }; TestEntity entity2 = new TestEntity { 1, null, 2, null }; int result = entity1.CompareTo(entity2); Assert.Equal(1, result); }
public void SerializeToString_WhenVersionedMessage_ExpectCorrectString() { // Arrange var serializerSettings = new SerializerSettings { SerializerType = SerializerType.Json }; var messageSerializer = new MessageSerializer(serializerSettings); var testEntity = new TestEntity { Data = "val" }.SerializeToVersionedMessage(SerializerType.Json); // Act var stopwatch = Stopwatch.StartNew(); var serializeToString = messageSerializer.SerializeToString(testEntity); stopwatch.Stop(); // Assert this.WriteTimeElapsed(stopwatch); Assert.That(serializeToString, Is.EqualTo("{\"v\":{\"T\":\"TestEntity\",\"Ma\":1,\"Mi\":0,\"P\":0,\"VT\":0,\"VTV\":0},\"d\":\"{\\\"Data\\\":\\\"val\\\"}\"}")); }
public async Task DeleteByIdTest_Should_Delete_Entity() { // Arrange var testEntity1 = new TestEntity { Id = Guid.NewGuid() }; var testEntity2 = new TestEntity { Id = Guid.NewGuid() }; SeedDatabase(new List <TestEntity> { testEntity1, testEntity2 }); using (var testDbContextBeforeDelete = new TestDbContext(ContextOptions)) { Assert.AreEqual(2, testDbContextBeforeDelete.TestEntities.Count()); } // Act var result = await _testBaseController.DeleteByIdTest(testEntity1.Id); // Assert var noContentResult = result as NoContentResult; Assert.IsNotNull(noContentResult); using var testDbContext = new TestDbContext(ContextOptions); Assert.AreEqual(1, testDbContext.TestEntities.Count()); var remainingEntity = testDbContext.TestEntities.First(); Assert.AreEqual(testEntity2.Id, remainingEntity.Id); }
public void CanDoCrud() { using (var session = factory.OpenSession()) { var entity = new TestEntity { Name = "Test 1", Tags = new string[] { "hello", "world" }, JsonField = "{ \"val\": 1 }", JsonbField = "{ \"val\": 1 }", UpdateTime = DateTime.Now, Int16Arr = new short[] { 1, 2, 3 }, Int32Arr = new int[] { 1, 2, 3 }, Int64Arr = new long[] { 1L, 2L, 3L }, FloatArr = new float[] { 1.1F, 2.2F, 3.3F }, DoubleArr = new double[] { 1.1, 2.2, 3.3 }, BooleanArr = new bool[] { true, false } }; session.Save(entity); session.Flush(); session.Clear(); Assert.True(entity.Id == 0); Console.WriteLine($"entity id: {entity.Id}"); var query = session.Query <TestEntity>(); var entities = query.ToList(); Assert.NotNull(entities); foreach (var e in entities) { session.Delete(e); } session.Flush(); } }
public async Task Should_insert_specified_properties_only() { var testEntity = new TestEntity { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), Name = "Name", Count = 42 }; var testEntities = new[] { testEntity }; var idProperty = typeof(TestEntity).GetProperty(nameof(TestEntity.Id)) ?? throw new Exception($"Property {nameof(TestEntity.Id)} not found."); var countProperty = typeof(TestEntity).GetProperty(nameof(TestEntity.Count)) ?? throw new Exception($"Property {nameof(TestEntity.Count)} not found."); var propertyWithBackingField = typeof(TestEntity).GetProperty(nameof(TestEntity.PropertyWithBackingField)) ?? throw new Exception($"Property {nameof(TestEntity.PropertyWithBackingField)} not found."); var privateField = typeof(TestEntity).GetField("_privateField", BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new Exception($"Field _privateField not found."); await ActDbContext.BulkInsertAsync(testEntities, new SqlServerBulkInsertOptions { MembersToInsert = new EntityMembersProvider(new MemberInfo[] { idProperty, countProperty, propertyWithBackingField, privateField }) }); var loadedEntities = await AssertDbContext.TestEntities.ToListAsync(); loadedEntities.Should().HaveCount(1); var loadedEntity = loadedEntities[0]; loadedEntity.Should().BeEquivalentTo(new TestEntity { Id = new Guid("40B5CA93-5C02-48AD-B8A1-12BC13313866"), Count = 42 }); }
public async Task GeneticEntityCollectionExtensions_GetEntitiesSortedByFitness_SortRawMinimize() { TestEntity testEntity1 = new TestEntity { TestFitnessValue = 1 }; TestEntity testEntity2 = new TestEntity { TestFitnessValue = 3 }; TestEntity testEntity3 = new TestEntity { TestFitnessValue = 2 }; List <GeneticEntity> entities = new List <GeneticEntity> { testEntity1, testEntity2, testEntity3, }; MockGeneticAlgorithm algorithm = new MockGeneticAlgorithm { FitnessEvaluator = new TestFitnessEvalutor() }; foreach (GeneticEntity entity in entities) { entity.Initialize(algorithm); await entity.EvaluateFitnessAsync(); } List <GeneticEntity> results = GeneticEntityCollectionExtensions.GetEntitiesSortedByFitness(entities, FitnessType.Raw, FitnessEvaluationMode.Minimize).ToList(); Assert.Equal(3, results.Count); Assert.Same(testEntity2, results[0]); Assert.Same(testEntity3, results[1]); Assert.Same(testEntity1, results[2]); }
public async Task WithPrematureAbortCallInNestedScope_ShouldPerformOperationsAndThenRollBack(Overload overload) { await this.Execute(overload, this.Provider, async (scope, ct) => { await this.Execute(overload, this.Provider, (scope, ct) => { // Doing this early is just fine // It will only take effect once the current execution scope ends scope.Abort(); var entityToInsert = new TestEntity() { Id = 1 }; scope.DbContext.Add(entityToInsert); scope.DbContext.SaveChanges(); var uncommittedEntityCount = ((TestDbContext)scope.DbContext).TestEntities.Count(); Assert.Equal(1, uncommittedEntityCount); return(Task.FromResult(true)); }); // We should have rolled back when the inner scope was disposed { using var dbContext = this.TestDbContextFactory.CreateDbContext(); dbContext.Database.BeginTransaction(System.Data.IsolationLevel.ReadUncommitted); // By reading even uncommitted changes, we can confirm that the change was rolled back var entityCount = dbContext.TestEntities.Count(); Assert.Equal(0, entityCount); } return(Task.FromResult(true)); }); }
public async Task Should_create_draft_version() { TestEntity content = null; try { // STEP 1: Create a new item. content = await _.Contents.CreateAsync(new TestEntityData { Number = 1 }, true); // STEP 2: Create draft. content = await _.Contents.CreateDraftAsync(content.Id); // STEP 3: Update the item and ensure that the data has not changed. await _.Contents.PatchAsync(content.Id, new TestEntityData { Number = 2 }); var updated = await _.Contents.GetAsync(content.Id); Assert.Equal(1, updated.Data.Number); Assert.Null(updated.NewStatus); // STEP 4: Get the unpublished version var unpublished = await _.Contents.GetAsync(content.Id, QueryContext.Default.Unpublished()); Assert.Equal(2, unpublished.Data.Number); Assert.Equal("Draft", unpublished.NewStatus); } finally { if (content != null) { await _.Contents.DeleteAsync(content.Id); } } }
public void Test_FilterGroup_Or() { using (LogGroup logGroup = LogGroup.Start("Testing a filter group query with the OR operator.", NLog.LogLevel.Debug)) { TestEntity e1 = new TestEntity(); e1.Name = "Test E1"; FilterGroup filterGroup = new FilterGroup(); filterGroup.Operator = FilterGroupOperator.Or; PropertyFilter filter1 = (PropertyFilter)DataAccess.Data.CreateFilter(typeof(PropertyFilter)); filter1.PropertyName = "Name"; filter1.PropertyValue = e1.Name; filter1.AddType(typeof(TestEntity)); PropertyFilter filter2 = (PropertyFilter)DataAccess.Data.CreateFilter(typeof(PropertyFilter)); filter2.PropertyName = "Name"; filter2.PropertyValue = "Another value"; filter2.AddType(typeof(TestEntity)); filterGroup.Filters = new BaseFilter[] { filter1, filter2 }; DataAccess.Data.Stores[typeof(TestEntity)].Saver.Save(e1); IEntity[] found = (IEntity[])DataAccess.Data.Indexer.GetEntities(filterGroup); Assert.IsNotNull(found, "Null value returned."); if (found != null) { Assert.IsTrue(found.Length > 0, "No results found."); } DataAccess.Data.Deleter.Delete(e1); } }
public async Task UpdateFieldsAsync_WithProperties_ShouldUpdateSpecifiedEntityProperty() { // Arrange var testEntity = new TestEntity { Id = Guid.NewGuid(), Name = "Kylo Ren", Number = 1 }; DbContextOptions <TestDbContext> options = new DbContextOptionsBuilder <TestDbContext>() .UseInMemoryDatabase(databaseName: "InMemory_TestDb") .Options; using (var dbContext = new TestDbContext(options)) { dbContext.Add(testEntity); await dbContext.SaveChangesAsync(); } testEntity.Name = "Rey Skywalker"; TestEntity updatedTeamMember = null; using (var dbContext = new TestDbContext(options)) { var repository = new ReadWriteRepository <TestEntity, Guid>(() => dbContext); // Act await repository.UpdateFieldsAsync(testEntity, te => te.Name); // Assert updatedTeamMember = await repository.GetByIdAsync(testEntity.Id); } // Assert updatedTeamMember.Name.Should().Be("Rey Skywalker"); }