public void FindAll_ReturnsExpectedData()
{
// Arrange
DummyEntity[] data =
{
new DummyEntity {
Name = "Some Name", Id = 1
},
new DummyEntity {
Name = "Other Name", Id = 2
}
};
TestHelpers.InjectData(_options, data);
using DummyContext context = new DummyContext(_options);
IDummyRepository dummyRepository = new DummyRepository(context);
// Act
IEnumerable <DummyEntity> result = dummyRepository.FindAll().ToList();
// Assert
Assert.AreEqual(2, result.Count());
Assert.AreEqual("Some Name", result.First().Name);
Assert.AreEqual("Other Name", result.Last().Name);
}
public void TestSetup()
{
_folder = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
Directory.CreateDirectory(_folder);
var cacheFolder = Path.Combine(_folder, "Cache");
Directory.CreateDirectory(cacheFolder);
// override configuration
var config = UQConfiguration.Instance as UQConfiguration;
config.HorizontalCacheConfigurationSection.SetParameter("folder", cacheFolder);
config.HorizontalCacheConfigurationSection.ProviderType = typeof(TestTextFileCacheProvider <>);
config.HorizontalCacheConfigurationSection.SetCacheDataProviderType(typeof(TestCacheDataProvider <>));
config.HorizontalCacheConfigurationSection.IsEnabled = true;
// create 1000 files for testing
var dao = new DummyEntityDAO2();
dao.SetProperties(new Dictionary <string, object>
{
["folder"] = _folder
});
dao.GenerateFiles(1000);
// forces the cache initialization
var context = new DummyContext(_folder);
context.DummyEntitiesWithCache.Select(x => x.Key).ToList();
}
public void TestOrderByWithTake()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
// Act
var result = context.DummyEntitiesWithCache
.OrderBy(x => x.Key)
.Select(x => new
{
x.Key,
x.Name
})
.Take(3)
.ToList();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(3, result.Count);
Assert.AreEqual("0", result[0].Key);
Assert.AreEqual("Dummy Item 0", result[0].Name);
Assert.AreEqual("1", result[1].Key);
Assert.AreEqual("Dummy Item 1", result[1].Name);
Assert.AreEqual("10", result[2].Key);
Assert.AreEqual("Dummy Item 10", result[2].Name);
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(0, cacheProvider.CreateEntityFromCachedEntryCount); //ok that's not nice
Assert.AreEqual(0, methodCounter.EntityCallsCount);
}
private void Creating_graphs_of_detached_change_tracking_proxies_does_not_use_expensive_lookup(
Func <DummyContext, FullyVirtualPrin> createPrincipal,
Func <DummyContext, FullyVirtualDep> createDependent)
{
using (var context = new DummyContext())
{
var principal = createPrincipal(context);
var dependent = createDependent(context);
Assert.IsAssignableFrom <IEntityWithRelationships>(principal);
Assert.IsAssignableFrom <IEntityWithRelationships>(dependent);
context.Entry(principal).State = EntityState.Detached;
context.Entry(dependent).State = EntityState.Detached;
var stateManager = ((IObjectContextAdapter)context).ObjectContext.ObjectStateManager;
var principalManager = stateManager.GetRelationshipManager(principal);
var dependentManager = stateManager.GetRelationshipManager(dependent);
var mockPrincipalLoader = new Mock <ExpensiveOSpaceLoader>();
principalManager.SetExpensiveLoader(mockPrincipalLoader.Object);
var mockDependentLoader = new Mock <ExpensiveOSpaceLoader>();
dependentManager.SetExpensiveLoader(mockDependentLoader.Object);
principal.Dependents.Add(dependent);
dependent.Principal = principal;
mockPrincipalLoader.Verify(m => m.LoadTypesExpensiveWay(It.IsAny <Assembly>()), Times.Never());
mockDependentLoader.Verify(m => m.LoadTypesExpensiveWay(It.IsAny <Assembly>()), Times.Never());
mockPrincipalLoader.Verify(m => m.GetRelationshipTypeExpensiveWay(It.IsAny <Type>(), It.IsAny <string>()), Times.Never());
mockDependentLoader.Verify(m => m.GetAllRelationshipTypesExpensiveWay(It.IsAny <Assembly>()), Times.Never());
mockPrincipalLoader.Verify(m => m.GetRelationshipTypeExpensiveWay(It.IsAny <Type>(), It.IsAny <string>()), Times.Never());
mockDependentLoader.Verify(m => m.GetAllRelationshipTypesExpensiveWay(It.IsAny <Assembly>()), Times.Never());
}
}
public void ExecuteAsync()
{
foreach (var item in TestCases())
{
var filter = new DerivedSequenceFilter(item.shortCircuiting);
var source = new DummySource[] {
new DummySource(),
new DummySource(),
};
var context = new DummyContext();
var invokedNext = false;
SequenceFilterFunc <DummySource> next = _ => {
invokedNext = true;
return(Task.FromResult(_));
};
new TestCaseRunner($"No.{item.testNumber}")
.Run(() => filter.ExecuteAsync(source, context, next))
.Verify((actual, desc) => {
Assert.AreEqual(source, actual, $"{desc}: 入力シーケンスが出力に素通しされていません。");
Assert.AreEqual(context, filter.ActualContext, $"{desc}: フィルター時のコンテキストが同一インスタンスではありません。");
Assert.AreEqual(item.shortCircuiting, !invokedNext, $"{desc}: ショートサーキットの有無が期待値と一致しません。");
}, (Type)null);
}
(int testNumber, bool shortCircuiting)[] TestCases() => new[] {
/// <summary>
/// Inject test data
/// </summary>
internal static void InjectData <T>(DbContextOptions <DummyContext> options, params T[] entities)
where T : class
{
using DummyContext context = new DummyContext(options);
context.Set <T>().AddRange(entities);
context.SaveChanges();
}
public void CreateAsync_Abyss()
{
var createResult = Rand.Array <DummyEntity>();
IEnumerable <DummyEntity> actualSource = default;
var middleware = new SpyFilterMiddlewareToCreateAsync(src => {
actualSource = src;
return(createResult);
}, cancelled: false);
var nextResult = Rand.Array <DummyEntity>();
DummyContext actualNextContext = default;
IEnumerable <DummyEntity> actualNextSource = default;
Func <DummyContext, Task <FilterFunc <DummyEntity> > > next = ctx => {
actualNextContext = ctx;
return(Task.FromResult <FilterFunc <DummyEntity> >(src => {
actualNextSource = src;
return nextResult;
}));
};
var context = new DummyContext();
var source = new[] { new DummyEntity(), new DummyEntity() };
new TestCaseRunner()
.Run(async() => (await middleware.CreateAsync(context, next))(source))
.Verify((actual, desc) => {
Assert.AreEqual(nextResult, actual, desc);
Assert.AreEqual(context, middleware.ActualContext, desc);
Assert.AreEqual(false, middleware.ActualCancelled, desc);
Assert.AreEqual(source, actualSource, desc);
Assert.AreEqual(context, actualNextContext, desc);
Assert.AreEqual(createResult, actualNextSource, desc);
}, (Type)null);
}
protected override Task <FilterFunc <DummyEntity> > CreateAsync(DummyContext context, Func <DummyContext, Task <FilterFunc <DummyEntity> > > next)
{
ActualContext = context;
ActualNext = next;
return(Task.FromResult(_createAsyncResult));
}
public void TestCountWithContainsFilter()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
var identifiers = Enumerable.Range(177, 20000).Select(i => i.ToString());
// Act
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
var data = context.DummyEntitiesWithCache
.Count(x => identifiers.Contains(x.Key));
stopWatch.Stop();
// Assert
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(0, cacheProvider.CreateEntityFromCachedEntryCount);
Assert.IsTrue(stopWatch.ElapsedMilliseconds < 40); //YSV: successive call might take only 20 ms. Not sure what happens when it call it first
Assert.AreEqual(0, methodCounter.EntityCallsCount);
Assert.AreEqual(0, methodCounter.GetIdentifiersCallsCount);
Assert.AreEqual(823, data);
}
public void Build()
{
var pipeline = new PipelineBuilder <DummySource, DummyContext>();
var factoryLogs = new List <int?>();
var filterLogs = new List <int?>();
{
Func <SequenceFilterFunc <DummySource, DummyContext>, SequenceFilterFunc <DummySource, DummyContext> > FilterFactory(int id)
{
return(next => {
factoryLogs.Add(id);
return (source, context) => {
filterLogs.Add(id);
return next(source, context);
};
});
}
pipeline.Add(FilterFactory(0));
pipeline.Add(FilterFactory(1));
pipeline.Add(FilterFactory(2));
}
new TestCaseRunner()
.Run(() => pipeline.Build())
.Verify((actual, _) => {
var source = new DummySource[] { new DummySource(), new DummySource() };
var context = new DummyContext();
var actualSource = actual(source, context).GetAwaiter().GetResult();
CollectionAssert.AreEqual(new int[] { 2, 1, 0 }, factoryLogs, "フィルターファクトリーの呼び出し順序が一致しません。");
CollectionAssert.AreEqual(new int[] { 0, 1, 2 }, filterLogs, "フィルターの適用順序が一致しません。");
Assert.AreEqual(source, actualSource, "入力シーケンスが出力に素通しされていません。");
}, (Type)null);
}
public void Configure(StoreDatabaseDriverSettings settings)
{
_settings = settings;
var ctx = new DummyContext(_settings.ConnectionString);
ctx.Database.EnsureCreated();
}
public void PrependNamespaceToRelationshipName_can_expand_a_name_using_expensive_lookup_as_a_last_resort()
{
using (var context = new DummyContext())
{
var anEntity = context.NavVirtuals.Attach(new NavVirtual());
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
var manager = objectContext.ObjectStateManager.GetRelationshipManager(anEntity);
var oSpaceType = objectContext.MetadataWorkspace
.GetItemCollection(DataSpace.OSpace)
.GetItem <EdmType>(typeof(NavVirtual).FullName);
var edmTypes = new Dictionary <string, EdmType>
{
{ typeof(NavVirtual).FullName, oSpaceType }
};
var mockLoader = new Mock <ExpensiveOSpaceLoader>();
mockLoader.Setup(m => m.LoadTypesExpensiveWay(typeof(NavVirtual).Assembly))
.Returns(edmTypes);
manager.SetExpensiveLoader(mockLoader.Object);
manager.WrappedOwner.DetachContext();
typeof(RelationshipManager).GetField("_relationships", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(manager, null);
Assert.Equal(
"System.Data.Entity.Core.Objects.DataClasses.FullyVirtualPrin_Other",
manager.PrependNamespaceToRelationshipName("FullyVirtualPrin_Other"));
}
}
public void TestSelectManySimple()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
// Act
var result = context.DummyEntitiesWithCache
.SelectMany(x => x.ListData.Select(i =>
new
{
x.Key,
Number = i
}).ToList())
.Where(x => x.Key.Contains(x.Number))
.ToList();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(813, result.Count);
foreach (var x in result)
{
Assert.IsTrue(x.Key.Contains(x.Number));
}
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(1000, cacheProvider.CreateEntityFromCachedEntryCount);
Assert.AreEqual(0, methodCounter.EntityCallsCount);
}
public void TestFirstOrDefaultWithContainsFilter()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
var identifiers = Enumerable.Range(177, 20000).Select(i => i.ToString());
// Act
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
//var data = context.DummyEntitiesWithCache
// .FirstOrDefault(x => identifiers.Contains(x.Key));
var data = context.DummyEntitiesWithCache
.FirstOrDefault(x => x.Key == "177");
stopWatch.Stop();
// Assert
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(0, cacheProvider.CreateEntityFromCachedEntryCount);
Assert.IsTrue(stopWatch.ElapsedMilliseconds < 30); //YSV: one call to the datastorage
// Ok, that's a problem here
Assert.AreEqual(1, methodCounter.EntityCallsCount);
Assert.AreEqual(0, methodCounter.GetIdentifiersCallsCount);
Assert.IsNotNull(data);
}
public void TestEffectivelyProcessesContains()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
var identifiers = Enumerable.Range(0, 20000).Select(i => i.ToString());
// Act
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
var data = context.DummyEntitiesWithCache
.Where(x => identifiers.Contains(x.Key))
.Select(x => x.Key)
.ToList();
stopWatch.Stop();
// Assert
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(0, cacheProvider.CreateEntityFromCachedEntryCount); // only identifiers are used
Assert.IsTrue(stopWatch.ElapsedMilliseconds < 30); // proves that Where is replaced
Assert.AreEqual(0, methodCounter.EntityCallsCount);
}
public void TestWhereWithFilterByString()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
// Act
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
var data = context.DummyEntitiesWithCache
.Where(x => (x.Name ?? string.Empty).IndexOf("11", StringComparison.InvariantCultureIgnoreCase) >= 0)
.Select(x => new { Id = x.Key, x.Name })
.ToList();
stopWatch.Stop();
// Assert
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(0, cacheProvider.CreateEntityFromCachedEntryCount); // only identifiers are used
Assert.IsTrue(stopWatch.ElapsedMilliseconds < 30); // proves that Where is replaced
Assert.AreEqual(0, methodCounter.EntityCallsCount);
}
public void TestGroupByWithToList()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
// Act
var result = context.DummyEntitiesWithCache.GroupBy(x => int.Parse(x.Key) % 10)
.Select(g =>
new
{
g.Key,
Data = g.ToList()
})
.ToList();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(10, result.Count);
foreach (var x in result)
{
Assert.AreEqual(100, x.Data.Count);
foreach (var d in x.Data)
{
Assert.IsNotNull(d.NonCachedField);
}
}
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(0, cacheProvider.CreateEntityFromCachedEntryCount);
Assert.AreEqual(1000, methodCounter.EntityCallsCount);
}
public void Seed_ShouldInitializeDatabase()
{
var stores = 10;
var persons = 10;
var transactions = 10;
var productsPerStore = 100;
var purchasesPerTransaction = 10;
var options = new DbContextOptionsBuilder <DummyContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using var context = new DummyContext(options);
var initializer = new ContextInitializer(persons, stores, productsPerStore, purchasesPerTransaction, transactions);
initializer.Seed(context);
Assert.AreEqual(persons, context.Persons.Count());
Assert.AreEqual(stores, context.Stores.Count());
Assert.AreEqual(productsPerStore, context.Stores.First().Products.Count());
Assert.AreEqual(productsPerStore, context.Stores.Last().Products.Count());
Assert.AreEqual(purchasesPerTransaction, context.Transactions.Include(o => o.Purchases).First().Purchases.Count());
Assert.AreEqual(purchasesPerTransaction, context.Transactions.Include(o => o.Purchases).Last().Purchases.Count());
Assert.AreEqual(transactions, context.Persons.First().Transactions.Count());
Assert.AreEqual(transactions, context.Persons.Last().Transactions.Count());
}
public void InitializeRelatedCollection_throws_for_change_tracking_proxy_related_end_that_has_been_serialized()
{
using (var context = new DummyContext())
{
var anEntity = SerializeAndDeserialize(context.Principals.Create());
Assert.IsAssignableFrom <IEntityWithRelationships>(anEntity);
var stateManager = ((IObjectContextAdapter)context).ObjectContext.ObjectStateManager;
var manager = stateManager.GetRelationshipManager(anEntity);
var mockLoader = new Mock <ExpensiveOSpaceLoader>();
manager.SetExpensiveLoader(mockLoader.Object);
var relatedEnd = manager.GetRelatedCollection <FullyVirtualDep>(
"System.Data.Entity.Core.Objects.DataClasses.FullyVirtualPrin_Dependents", "FullyVirtualPrin_Dependents_Target");
Assert.Equal(
Strings.RelationshipManager_CollectionAlreadyInitialized(
Strings.RelationshipManager_CollectionInitializeIsForDeserialization),
Assert.Throws <InvalidOperationException>(
() =>
manager.InitializeRelatedCollection(
"System.Data.Entity.Core.Objects.DataClasses.FullyVirtualPrin_Dependents",
"FullyVirtualPrin_Dependents_Target",
relatedEnd)).Message);
}
}
public void TestFilterWithCachedProperties()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
// Act
var stopWatch = new System.Diagnostics.Stopwatch();
stopWatch.Start();
var result = context.DummyEntitiesWithCache.Any(x => x.Name.Contains("100"));
stopWatch.Stop();
// Assert
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
// That's vary from 1 to 129, but we ultimately want it only once
Assert.AreEqual(0, cacheProvider.CreateEntityFromCachedEntryCount);
Assert.IsTrue(stopWatch.ElapsedMilliseconds < 30); //effectively gets data from cache
Assert.IsTrue(result);
Assert.AreEqual(0, methodCounter.EntityCallsCount);
Assert.AreEqual(0, methodCounter.GetIdentifiersCallsCount);
}
public void TestCombinesWithPendingChangesAddUpdate()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
var newItem = new DummyEntity
{
Key = "1051",
Name = "Test 1051"
};
var newItem2 = new DummyEntity
{
Key = "751",
Name = "Test 751"
};
context.DummyEntitiesWithCache.Add(newItem);
context.DummyEntitiesWithCache.Update(newItem2);
// Act
var addedItem = context.DummyEntitiesWithCache.FirstOrDefault(x => x.Key == "1051");
var updatedItem = context.DummyEntitiesWithCache.FirstOrDefault(x => x.Key == "751");
// Assert
Assert.AreEqual(newItem2, updatedItem);
Assert.AreEqual(newItem, addedItem);
Assert.AreEqual(0, methodCounter.EntityCallsCount);
Assert.AreEqual(0, methodCounter.GetIdentifiersCallsCount);
}
public DummyController(DummyContext context)
{
_context = context;
Bag bag1 = new Bag()
{
Name = "Bag1",
};
_context.Bags.Add(bag1);
_context.SaveChangesAsync();
Dummy dummy1 = new Dummy()
{
Name = "d1",
BagId = 1
};
Dummy dummy2 = new Dummy()
{
Name = "d2",
BagId = 1
};
_context.Dummies.Add(dummy1);
_context.Dummies.Add(dummy2);
_context.SaveChangesAsync();
}
public UnitOfWork(DummyContext context)
{
_myAppContext = context;
//Initialise our specific model Repositories
Customer = new CustomerRepository(_myAppContext);
Order = new OrderRepository(_myAppContext);
Product = new ProductRepository(_myAppContext);
}
public void Initialize()
{
today = System.DateTime.Now;
yesterday = today.AddDays(-1);
aantal = -1;
p = new Product();
Tim = new Student();
context = new DummyContext();
}
public DummyRepo CreateNewDummyRepo(string dbName)
{
var builder = new DbContextOptionsBuilder <DummyContext>();
builder.UseInMemoryDatabase(dbName);
var context = new DummyContext(builder.Options);
return(new DummyRepo(context));
}
public void AddReferenceToCollection_NullPropertyName()
{
try
{
IUpdatable context = new DummyContext();
context.AddReferenceToCollection(new object(), null, new object());
Assert.Fail("An ArgumentException was expected when passing null in for the property name.");
}
catch (System.ArgumentException) { }
}
public void AddReferenceToCollection_NullResourceToBeAdded()
{
try
{
IUpdatable context = new DummyContext();
context.AddReferenceToCollection(new object(), "PropertyName", null);
Assert.Fail("An ArgumentNullException was expected when passing null in for resource to be added.");
}
catch (System.ArgumentException) { }
}
public void LoadProperty_NullSelector()
{
try
{
DummyContext context = new DummyContext();
context.LoadProperty<TestModel>(new TestModel(), null);
Assert.Fail("An ArgumentNullException was expected.");
}
catch (ArgumentNullException) { }
}
public void AddReferenceToCollection_PropertyNotFound()
{
try
{
IUpdatable context = new DummyContext();
context.AddReferenceToCollection(this, System.Guid.NewGuid().ToString(), new object());
Assert.Fail("An UnknownPropertyException is expected if a property name is given that doesn't exist on the resource object.");
}
catch(UnknownPropertyException) { }
}
public void ProjectConfiguration_UsesCachedValue()
{
var options = TestHelper.CreateOptions($@"ResourceTests\SonarProjectConfig\Path_Windows\SonarProjectConfig.xml");
var context = new DummyContext();
var firstSut = new SonarAnalysisContext(context, Enumerable.Empty <DiagnosticDescriptor>());
var secondSut = new SonarAnalysisContext(context, Enumerable.Empty <DiagnosticDescriptor>());
var firstConfig = firstSut.ProjectConfiguration(options);
secondSut.ProjectConfiguration(options).Should().BeSameAs(firstConfig);
}
public void DummyContext_ShouldBuildWithoutErrors()
{
string connectionString = $"Server=DESKTOP-6AQTT80;Database=TransactionContextTest;Trusted_Connection=True";
var options = new DbContextOptionsBuilder <DummyContext>()
.UseSqlServer(connectionString)
.Options;
using var context = new DummyContext(options);
context.Database.EnsureCreated();
context.Database.EnsureDeleted();
}
public void AddReferenceToCollection_MakeSureObjectIsAdded()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
up.AddReferenceToCollection(context, "CollectionProperty", "TestString");
Assert.AreEqual(1, context.CollectionProperty.Count, "The number of items in the collection property is not correct.");
Assert.AreEqual("TestString", context.CollectionProperty[0], @"
The first string in the collection is not correct.
");
}
public void TestSelectManyCombinesWithPendingChangesAddOrUpdate()
{
// Arrange
var methodCounter = new DaoMethodCallsCounter();
var context = new DummyContext(_folder, methodCounter);
context.DummyEntitiesWithCache.Add(new DummyEntity
{
Key = "1001",
ListData = new[]
{
"1", "2", "10"
}
});
context.DummyEntitiesWithCache.Update(new DummyEntity
{
Key = "0",
ListData = new[]
{
"0", "1", "2"
}
});
// Act
var result = context.DummyEntitiesWithCache
.SelectMany(x => x.ListData.Select(i =>
new
{
x.Key,
Number = i
}).ToList())
.Where(x => x.Key.Contains(x.Number))
.ToList();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(816, result.Count);
foreach (var x in result)
{
Assert.IsTrue(x.Key.Contains(x.Number));
}
Assert.IsNotNull(result.FirstOrDefault(x => x.Key == "1001" && x.Number == "1"));
Assert.IsNotNull(result.FirstOrDefault(x => x.Key == "1001" && x.Number == "10"));
Assert.IsNotNull(result.FirstOrDefault(x => x.Key == "0" && x.Number == "0"));
var cacheProvider = ReflectionHelper.WinkleCacheDataProviderOut(context.DummyEntitiesWithCache);
Assert.AreEqual(1000, cacheProvider.CreateEntityFromCachedEntryCount);
Assert.AreEqual(0, methodCounter.EntityCallsCount);
}
public void FindAll_ReturnsEmptyListOnNoDummies()
{
// Arrange
using DummyContext context = new DummyContext(_options);
IDummyRepository dummyRepository = new DummyRepository(context);
// Act
IEnumerable <DummyEntity> result = dummyRepository.FindAll();
// Assert
Assert.AreEqual(0, result.Count());
}
public static void ClassInitialize(TestContext ctx)
{
_connection = new SqliteConnection("DataSource=:memory:");
_connection.Open();
_options = new DbContextOptionsBuilder <DummyContext>()
.UseSqlite(_connection)
.Options;
using DummyContext context = new DummyContext(_options);
context.Database.EnsureCreated();
}
public void LoadProperty_InvalidExpression()
{
try
{
DummyContext context = new DummyContext();
context.LoadProperty<TestModel>(new TestModel(), (a) => new object());
Assert.Fail(@"
An ArgumentException was expected when we have an invalid expression.
The selector must be in the form of (entity) => entity.Property where Property is
a property on the object.
");
}
catch (ArgumentException) { }
}
public void CommandTimeout_is_obtained_from_and_set_in_ObjectContext_if_ObjectContext_exists()
{
using (var context = new DummyContext())
{
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
objectContext.CommandTimeout = 77;
var internalContext = new EagerInternalContext(context, objectContext, false);
Assert.Equal(77, internalContext.CommandTimeout);
internalContext.CommandTimeout = 88;
Assert.Equal(88, objectContext.CommandTimeout);
}
}
public void LoadProperty_CorrectParametersArePassed()
{
TestModel model = new TestModel();
DummyContext context = new DummyContext();
context.LoadProperty(model, a => a.Name);
Assert.AreEqual(1, context.LoadPropertyParameters.Count, @"
The context.LoadProperty method was not called.
");
Assert.AreEqual(model, context.LoadPropertyParameters[0].Item1, @"
The entity passed to the context.LoadProperty method was not correct.
");
Assert.AreEqual("Name", context.LoadPropertyParameters[0].Item2, @"
The property name passed to the context.LaodProperty method was not correct.
");
}
public void DbContexts_are_associated_with_interception_context_when_InternalContexts_are_constructed()
{
using (var context = new DummyContext())
{
var objectContext = ((IObjectContextAdapter)context).ObjectContext;
// One context already associated due to LazyInternalContext in construction path above
Assert.Equal(new[] { context }, objectContext.InterceptionContext.DbContexts);
using (var context2 = new DummyContext())
{
new EagerInternalContext(context2, objectContext, false);
// Now both contexts are associated
Assert.Contains(context, objectContext.InterceptionContext.DbContexts);
Assert.Contains(context2, objectContext.InterceptionContext.DbContexts);
}
}
}
public void RemoveReferenceFromCollection_WhitespacePropertyName()
{
try
{
IUpdatable context = new DummyContext();
context.RemoveReferenceFromCollection(new object(), " ", new object());
Assert.Fail("An ArgumentException was expected when passing an empty string in for the property name.");
}
catch (System.ArgumentException) { }
}
public void SetValue_EmptyPropertyName()
{
try
{
IUpdatable context = new DummyContext();
context.SetValue(new object(), string.Empty, "Value");
Assert.Fail("An ArgumentException was expected.");
}
catch (System.ArgumentException) { }
}
public void SetValue_CorrectValueSet()
{
IUpdatable context = new DummyContext();
TestModel model = new TestModel() { Name = "TestString" };
context.SetValue(model, "Name", "TestStringAgain");
Assert.AreEqual("TestStringAgain", model.Name,
"The Name property should have been reset.");
}
public void SetReference_NullPropertyName()
{
try
{
IUpdatable context = new DummyContext();
context.SetReference(new object(), null, "Value");
Assert.Fail("An ArgumentException was expected.");
}
catch (System.ArgumentException) { }
}
public void SaveChanges_PendingChangesIsCleared()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
context.PendingChanges.Add(new Tuple<WhippedCreamUpdatableContext.ODataOperation, object>(
WhippedCreamUpdatableContext.ODataOperation.Insert, "TestString"));
context.PendingChanges.Add(new Tuple<WhippedCreamUpdatableContext.ODataOperation, object>(
WhippedCreamUpdatableContext.ODataOperation.Delete, "TestStringAgain"));
up.SaveChanges();
Assert.AreEqual(0, context.PendingChanges.Count, "The number of items in the pending collection should be zero after a call to SaveChanges.");
}
public void GetResource_NullQuery()
{
try
{
IUpdatable context = new DummyContext();
context.GetResource(null, null);
Assert.Fail("An ArgumentNullException was expected for a null query.");
}
catch(System.ArgumentNullException) { }
}
public void AddReferenceToCollection_PropertyShouldBeAList()
{
try
{
IUpdatable context = new DummyContext();
context.AddReferenceToCollection(context, "NotACollectionProperty", new object());
Assert.Fail(@"
A PropertyTypeMustBeACollectionException is expected if a property name is given of a property that isn't a collection.
");
}
catch (PropertyTypeMustBeACollectionException) { }
}
public void SetValue_WhiteSpacePropertyName()
{
try
{
IUpdatable context = new DummyContext();
context.SetValue(new object(), "\t", "value");
Assert.Fail("An ArgumentException was expected.");
}
catch (System.ArgumentException) { }
}
public void SetValue_NullResource()
{
try
{
IUpdatable context = new DummyContext();
context.SetValue(null, "Name", "Value");
Assert.Fail("An ArgumentNullException was expected.");
}
catch (System.ArgumentNullException) { }
}
public void RemoveReferenceFromCollection_NullResource()
{
try
{
IUpdatable context = new DummyContext();
context.RemoveReferenceFromCollection(null, "PropertyName", new object());
Assert.Fail("An ArgumentNullException was expected when passing null in for the target resource.");
}
catch (System.ArgumentNullException) { }
}
public void CreateResource_WhiteSpaceFullTypeName()
{
try
{
IUpdatable context = new DummyContext();
context.CreateResource("TestContainer", " ");
Assert.Fail("An ArgumentException was expected.");
}
catch(System.ArgumentException) { }
}
public void GetValue_CorrectValueReturned()
{
IUpdatable context = new DummyContext();
TestModel model = new TestModel() { Name = "TestString" };
Assert.AreEqual("TestString", context.GetValue(model, "Name"),
"The value of the Name property should have been returned.");
}
public void GetResource_ReturnsNullIfCollectionIsEmpty()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
Assert.IsNull(up.GetResource(context.Models.AsQueryable(), null),
"There were not items in the collection, so null should have been returned.");
}
public void GetResource_ReturnsFirstItem()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
context.Models.Add(new TestModel() { Name = "TestName" });
context.Models.Add(new TestModel() { Name = "TestNameAgain" });
var result = up.GetResource(context.Models.AsQueryable(), null);
Assert.IsNotNull(result);
Assert.IsInstanceOf<TestModel>(result, "The returned object should be a TestModel.");
Assert.AreEqual("TestName", (result as TestModel).Name,
"The Name property on the returned object should be equal to the first item that was added to the collection.");
}
public void DeleteResource_AddsDeleteEntryIntoPendingChanges()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
if(context.PendingChanges.Count != 0)
Assert.Fail("Unable to determine if an operation item was added to the PendingChanges collection.");
object target = new object();
up.DeleteResource(target);
Assert.AreEqual(1, context.PendingChanges.Count,
"There should have been an operation entry added to the PendingChanges collection.");
Assert.AreEqual(WhippedCreamUpdatableContext.ODataOperation.Delete,
context.PendingChanges.First().Item1,
"The operation type should be a delete operation.");
Assert.AreEqual(target,
context.PendingChanges.First().Item2,
"The object queued for deletion should have been the object passed to the DeleteResource method.");
}
public void SetValue_UnknownPropertyName()
{
try
{
IUpdatable context = new DummyContext();
TestModel model = new TestModel() { Name = "TestName" };
context.SetValue(model, "NotNameProperty", "Value");
Assert.Fail("An UnknownPropertyException was expected.");
}
catch (UnknownPropertyException) { }
}
public void ResolveResource_ReturnsWhatWasPassedToit()
{
IUpdatable context = new DummyContext();
object resource = new object();
Assert.AreEqual(resource, context.ResolveResource(resource),
"The resource returned is not correct.");
}
public void SaveChanges_CallsSaveEntityCorrectNumberOfTimes()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
context.PendingChanges.Add(new Tuple<WhippedCreamUpdatableContext.ODataOperation, object>(
WhippedCreamUpdatableContext.ODataOperation.Insert, "TestString"));
context.PendingChanges.Add(new Tuple<WhippedCreamUpdatableContext.ODataOperation, object>(
WhippedCreamUpdatableContext.ODataOperation.Delete, "TestStringAgain"));
up.SaveChanges();
Assert.AreEqual(2, context.SaveEntityParameters.Count, "The number of times SaveEntity was called should have been two.");
}
public void SaveChanges_CorrectParametersWerePassed()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
context.PendingChanges.Add(new Tuple<WhippedCreamUpdatableContext.ODataOperation, object>(
WhippedCreamUpdatableContext.ODataOperation.Insert, "TestString"));
up.SaveChanges();
Assert.AreEqual(WhippedCreamUpdatableContext.ODataOperation.Insert,
context.SaveEntityParameters[0].Item1,
"The first item in the first parameter set should be an insert flag.");
Assert.AreEqual("TestString",
context.SaveEntityParameters[0].Item2,
"The second item in the first parameter set should be \"TestString\".");
}
public void RemoveReferenceFromCollection_MakeSureObjectIsRemoved()
{
DummyContext context = new DummyContext();
IUpdatable up = context;
context.CollectionProperty.Add("TestString");
if(context.CollectionProperty.Count != 1)
Assert.Fail("Unable to determine if the 'TestString' instance was removed.");
up.RemoveReferenceFromCollection(context, "CollectionProperty", "TestString");
Assert.AreEqual(0, context.CollectionProperty.Count, "The number of items in the collection property is not correct.");
}
public void DeleteResource_NullResource()
{
try
{
IUpdatable context = new DummyContext();
context.DeleteResource(null);
Assert.Fail("An ArgumentNullException was expected for a null resource.");
}
catch(System.ArgumentNullException) { }
}
