public void Expression_from_instance_method_with_variable()
{
using (var context = new SimpleModelContext())
{
var testInstance = new InstanceExpressions();
var products = context.Products.Where(testInstance.MethodWithVariable());
products.ToList();
}
}
public void Expression_from_instance_delegate_with_parameter()
{
using (var context = new SimpleModelContext())
{
var testInstance = new InstanceExpressions();
var products = context.Products.Where(testInstance.DelegateWithParameter(1));
products.ToList();
}
}
public void Scenario_Query_With_Skip_And_Take_On_SqlCe40()
{
using (var context = new SimpleModelContext())
{
var products = context.Products.OrderBy(p => p.Name).Skip(3).Take(2).ToList();
Assert.Equal(2, products.Count);
Assert.True(products.TrueForAll(p => GetStateEntry(context, p).State == EntityState.Unchanged));
}
}
public void Expression_from_instance_property()
{
using (var context = new SimpleModelContext())
{
var testInstance = new InstanceExpressions();
var products = context.Products.Where(testInstance.Property);
products.ToList();
}
}
public void Connection_can_be_obtained_from_DbContext_created_with_existing_ObjectContext()
{
using (var outerContext = new SimpleModelContext())
{
using (var context = new SimpleModelContext(GetObjectContext(outerContext)))
{
Connection_can_be_obtained_after_initializing_the_context(context);
}
}
}
public void Connection_name_is_found_in_app_config_when_using_name_keyword()
{
EnsureAppConfigDatabaseExists();
using (var context = new SimpleModelContext("name=SimpleModelInAppConfig"))
{
Assert.Equal("SimpleModel.SimpleModel", context.Database.Connection.Database);
Assert.IsType <SqlConnection>(context.Database.Connection);
}
}
public void Expression_from_instance_delegate()
{
using (var context = new SimpleModelContext())
{
var testInstance = new InstanceExpressions();
var products = context.Products.Where(testInstance.Delegate());
Assert.DoesNotThrow(() => products.ToList());
}
}
private void EnsureAppConfigDatabaseExists()
{
using (var context = new SimpleModelContext("name=SimpleModelInAppConfig"))
{
if (!context.Database.Exists())
{
context.Database.Initialize(force: true);
}
}
}
public void Connection_can_be_obtained_after_initializing_the_context_when_using_existing_store_connection()
{
using (var connection = SimpleConnection <SimpleModelContext>())
{
using (var context = new SimpleModelContext(connection))
{
Connection_can_be_obtained_after_initializing_the_context(context);
}
}
}
/// <summary>
/// Asserts that an operation on a set throws if the type of the set is not valid for the model.
/// </summary>
/// <typeparam name="TEntity"> The type of entity for which a set should be created. </typeparam>
/// <param name="test"> The test to run on the set. </param>
private void ThrowsForInvalidType <TEntity>(Action <IDbSet <TEntity> > test) where TEntity : class
{
using (var context = new SimpleModelContext())
{
var set = context.Set <TEntity>();
Assert.Throws <InvalidOperationException>(() => test(set)).ValidateMessage(
"DbSet_EntityTypeNotInModel",
typeof(TEntity).Name);
}
}
/// <summary>
/// Asserts that an operation on a set throws if the type of the set is not valid for the model.
/// </summary>
/// <param name="entityType"> The type of entity for which the set is for. </param>
/// <param name="test"> The test to run on the set. </param>
private void ThrowsForInvalidTypeNonGeneric(Type entityType, Action <DbSet> test)
{
using (var context = new SimpleModelContext())
{
var set = context.Set(entityType);
Assert.Throws <InvalidOperationException>(() => test(set)).ValidateMessage(
"DbSet_EntityTypeNotInModel",
entityType.Name);
}
}
public void Expression_from_static_method_with_parameter()
{
using (var context = new SimpleModelContext())
{
var products = context.Products.Where(StaticExpressions.MethodWithParameter(1));
Assert.DoesNotThrow(() =>
products.ToList());
}
}
public void Non_expression_embedded_static_method_throws()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => p.Id == StaticExpressions.NonExpressionMethod());
Assert.Throws <NotSupportedException>(() => products.ToList());
}
}
public void Expression_from_instance_method_with_parameter()
{
using (var context = new SimpleModelContext())
{
var testInstance = new InstanceExpressions();
var products = context.Products.Where(testInstance.MethodWithParameter(1));
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Expression_embedded_static_method_with_variable()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.MethodWithVariable())
.Contains(p));
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Expression_embedded_static_delegate_with_parameter()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.DelegateWithParameter(1))
.Contains(p));
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Expression_embedded_static_property()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.Property)
.Contains(p));
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Expression_from_variable()
{
Expression <Func <Product, bool> > testExpression = p => p.Id == 1;
using (var context = new SimpleModelContext(ConnectionString))
{
var products = context.Products.Where(testExpression);
Assert.DoesNotThrow(() => products.ToList());
}
}
public void Expression_embedded_static_method_with_parameter()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.MethodWithParameter(1))
.Contains(p));
products.ToList();
}
}
public void Generic_DbEntityEntry_can_be_implicitly_converted_to_non_generic_version()
{
using (var context = new SimpleModelContext())
{
var product = context.Products.Find(1);
var genericEntry = context.Entry(product);
NonGenericTestMethod(genericEntry, genericEntry.Entity);
}
}
public void Non_expression_embedded_instance_delegate_throws()
{
using (var context = new SimpleModelContext())
{
var testInstance = new InstanceExpressions();
var products = context.Products
.Where(p => p.Id == testInstance.NonExpressionDelegate());
Assert.Throws <NotSupportedException>(() => products.ToList());
}
}
public void SQL_query_for_non_entity_where_columns_dont_map_throws()
{
using (var context = new SimpleModelContext())
{
var query = context.Database.SqlQuery <UnMappedProduct>("select * from Categories");
Assert.Throws <InvalidOperationException>(() => query.ToList()).ValidateMessage(
"Materializer_InvalidCastReference", "System.String",
"System.Int32");
}
}
/// <summary>
/// Creates a disposed context.
/// </summary>
private SimpleModelContext CreateDisposedContext()
{
SimpleModelContext context;
using (context = new SimpleModelContext())
{
// Ensures that the context actually gets initialized.
var objectContext = GetObjectContext(context);
}
return(context);
}
public void DbContext_SaveChangesAsync_does_not_deadlock()
{
using (var context = new SimpleModelContext())
{
using (context.Database.BeginTransaction())
{
context.Products.Add(new Product());
RunDeadlockTest(context.SaveChangesAsync);
}
}
}
public void SQL_query_for_entity_where_columns_dont_map_throws()
{
using (var context = new SimpleModelContext())
{
var query = context.Products.SqlQuery("select * from Categories");
Assert.Throws <EntityCommandExecutionException>(() => query.ToList()).ValidateMessage(
"ADP_InvalidDataReaderMissingColumnForType",
"SimpleModel.Product", "CategoryId");
}
}
public void Expression_from_variable()
{
Expression <Func <Product, bool> > testExpression = p => p.Id == 1;
using (var context = new SimpleModelContext())
{
var products = context.Products.Where(testExpression);
products.ToList();
}
}
public void Expression_embedded_static_delegate()
{
using (var context = new SimpleModelContext())
{
var products = context.Products
.Where(p => context.Products.Where(StaticExpressions.Delegate())
.Contains(p));
products.ToList();
}
}
public void Scenario_Query()
{
using (var context = new SimpleModelContext())
{
var products = context.Products.ToList();
// Scenario ends; simple validation of final state follows
Assert.Equal(7, products.Count);
Assert.True(products.TrueForAll(p => GetStateEntry(context, p).State == EntityState.Unchanged));
}
}
public void Initialization_hooks_are_run_once_on_EF_initialization_in_the_app_domain()
{
// Make sure that EF has been used if this happens to be the first test run
using (var context = new SimpleModelContext())
{
context.Database.Initialize(force: false);
}
Assert.Equal(
new[] { "Hook1()", "Hook1(2013, 'December 31')", "Hook2()", "Hook2('January 1', 2014)", "Hook2()", "Hook1(4102, '1 yraunaJ')", "Hook1()" },
TestLoadedInterceptor.HooksRun.Reverse().ToArray());
}
// TODO: [Fact(Skip = "SDE Merge - No partial trust yet")]
public void DbEntityEntry_Member_works_for_collections_under_partial_trust()
{
using (var context = new SimpleModelContext())
{
var category = context.Categories.First();
var collection = context.Entry(category).Member <ICollection <Product> >("Products");
Assert.NotNull(collection);
Assert.IsType <DbCollectionEntry <Category, Product> >(collection);
}
}
