public void Create_works_when_no_BuildWebHost()
{
var factory = new TestAppServiceProviderFactory(
MockAssembly.Create(typeof(ProgramWithoutBuildWebHost)));
var services = factory.Create(Array.Empty <string>());
Assert.NotNull(services);
}
public void AssemblyFilenameInXmlMatchesOriginallyPassedNameToExecutor()
{
using (MockAssembly mockAssembly = new MockAssembly())
{
mockAssembly.Compile("");
XmlNode assemblyNode = mockAssembly.Run(null);
ResultXmlUtility.AssertAttribute(assemblyNode, "name", mockAssembly.FileName);
}
}
public void MigrationIds_should_not_return_migration_when_no_default_ctor()
{
var mockType = new MockType("20110816231110_Migration", hasDefaultCtor: false, @namespace: "Migrations");
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void MigrationIds_should_not_return_migration_when_not_subclass_of_db_migration()
{
var mockType = new MockType("20110816231110_Migration", @namespace: "Migrations");
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void GetBindingRedirectsTest()
{
// A, B, C2, G
// A -> C1
// B -> G
// G -> C2
var A = new MockAssembly {
Name = "A",
Version = new Version("1.0.0.0"),
PublicKeyToken = "a34a755ec277222f"
};
var B = new MockAssembly {
Name = "B",
Version = new Version("1.0.0.0"),
PublicKeyToken = "b34a755ec277222f"
};
var C1 = new MockAssembly {
Name = "C",
Version = new Version("1.0.0.0"),
PublicKeyToken = "c34a755ec277222f"
};
var C2 = new MockAssembly {
Name = "C",
Version = new Version("2.0.0.0"),
PublicKeyToken = "c34a755ec277222f"
};
var D = new MockAssembly {
Name = "D",
Version = new Version("1.0.0.0"),
PublicKeyToken = "f34a755ec277222f"
};
var G = new MockAssembly {
Name = "G",
Version = new Version("1.0.0.0"),
PublicKeyToken = "d34a755ec277222f"
};
var assemblies = new[] { A, B, C2, D, G };
B.References.Add(G);
D.References.Add(C2);
G.References.Add(C1);
A.References.Add(C2);
// Act
var redirectAssemblies = BindingRedirectResolver.GetBindingRedirects(assemblies).ToList();
// Assert
Assert.AreEqual(1, redirectAssemblies.Count);
Assert.AreEqual("C", redirectAssemblies[0].Name);
Assert.AreEqual("2.0.0.0", redirectAssemblies[0].NewVersion);
}
public void MigrationIds_should_not_return_migration_when_name_does_not_match_pattern()
{
var mockType = new MockType("Z0110816231110_Migration", @namespace: "Migrations");
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void CreateContext_get_service()
{
var assembly = MockAssembly.Create(typeof(Startup));
var operations = new DbContextOperations(
new TestOperationReporter(),
assembly,
assembly);
operations.CreateContext(typeof(TestContext).FullName);
}
public void Create_works()
{
var factory = new TestAppServiceProviderFactory(
MockAssembly.Create(typeof(Program)));
Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", null);
var services = factory.Create(new[] { "arg1" });
Assert.NotNull(services.GetRequiredService <TestService>());
}
public void Init()
{
mockDIContainer = new Mock <ConcurrentDictDIContainer>();
mockScanner = new Mock <DependencyScanner>(MockAssembly.GetMock().Object);
mockScanner.Setup(scanner => scanner.Scan()).Verifiable();
mockRegistrar = new Mock <DependencyRegistrar>(mockDIContainer.Object);
mockRegistrar.Setup(registrar => registrar.Register(It.IsAny <Type[]>())).Verifiable();
}
public void ConfigureServices_injects_services()
{
var assembly = MockAssembly.Create(typeof(StartupInjected));
var startup = new StartupInvoker(assembly, "Injected", @"C:\The\Right\Path");
var services = startup.ConfigureServices();
var service = services.GetRequiredService <TestService>();
Assert.Equal("Injected", service.Value);
}
public void ConfigureServices_is_noop_when_not_found()
{
var startup = CreateStartupInvoker(
MockAssembly.Create(),
"Unknown");
var services = startup.ConfigureServices();
Assert.NotNull(services);
}
public void ConfigureServices_works()
{
var startup = CreateStartupInvoker(MockAssembly.Create(typeof(StartupDevelopment)));
var services = startup.ConfigureServices();
var service = services.GetRequiredService <TestService>();
Assert.Equal("Development", service.Value);
}
private static void TestCreateServices(Type programType)
{
var factory = new TestAppServiceProviderFactory(
MockAssembly.Create(programType));
Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", null);
Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", null);
var services = factory.Create(new[] { "arg1" });
Assert.NotNull(services.GetRequiredService <TestService>());
}
public void CreateContext_gets_service()
{
var assembly = MockAssembly.Create(typeof(TestProgram), typeof(TestContext));
var operations = new TestDbContextOperations(
new TestOperationReporter(),
assembly,
assembly,
new TestAppServiceProviderFactory(assembly, typeof(TestProgram)));
operations.CreateContext(typeof(TestContext).FullName);
}
public void ConfigureDesignTimeServices_works_on_IDesignTimeServices_implementations()
{
var services = new ServiceCollection();
var startup = CreateStartupInvoker(MockAssembly.Create(typeof(DesignTimeServices)));
startup.ConfigureDesignTimeServices(services);
var service = services.BuildServiceProvider().GetRequiredService <TestService>();
Assert.Equal("DesignTimeServices", service.Value);
}
private static TestDbContextOperations CreateOperations(Type testProgramType)
{
var assembly = MockAssembly.Create(testProgramType, typeof(TestContext));
return(new TestDbContextOperations(
new TestOperationReporter(),
assembly,
assembly,
/* args: */ Array.Empty <string>(),
new TestAppServiceProviderFactory(assembly)));
}
public void ConfigureDesignTimeServices_works_on_IStartup_implementations()
{
var startup = CreateStartupInvoker(
MockAssembly.Create(typeof(MyStartup)),
environment: null);
var services = startup.ConfigureServices();
var service = services.GetRequiredService <TestService>();
Assert.Equal("MyStartup", service.Value);
}
public ModelBuilderAssemblyScanTest()
{
_mockEntityTypeAssembly = MockAssembly.Create(
typeof(ScannerCustomerEntityConfiguration), typeof(ScannerCustomerEntityConfiguration2),
typeof(AbstractCustomerEntityConfiguration), typeof(AbstractCustomerEntityConfigurationImpl));
_mockQueryTypeAssembly = MockAssembly.Create(
typeof(ScannerCustomerQueryConfiguration), typeof(ScannerCustomerQueryConfiguration2),
typeof(AbstractCustomerQueryConfiguration), typeof(AbstractCustomerEntityQueryConfigurationImpl));
_mockMixedTypeAssembly = MockAssembly.Create(
typeof(ScannerCustomerEntityConfiguration), typeof(ScannerCustomer2QueryConfiguration));
}
public void MigrationIds_should_not_return_migration_when_abstract()
{
var mockType
= new MockType("20110816231110_Migration", @namespace: "Migrations")
.TypeAttributes(TypeAttributes.Abstract);
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void ConfigureServices_injects_services()
{
var assembly = MockAssembly.Create(typeof(StartupInjected));
var startup = new StartupInvoker(
new TestOperationReporter(),
assembly);
var services = startup.ConfigureServices();
var service = services.GetRequiredService <TestService>();
Assert.Equal("Injected", service.Value);
}
public void FindManifest_ReturnsNullWhenNoManifestsFound()
{
ManifestLoader.ManifestLoaderDelegates.Add(ManifestLoader.LoadJsonManifestFrom);
ManifestLoader.ManifestLoaderDelegates.Add(ManifestLoader.LoadVirtualManifestFrom);
var mockAssembly = new MockAssembly
{
};
var manifest = ManifestLoader.FindManifest(mockAssembly);
Assert.Null(manifest);
}
public void MigrationIds_should_not_return_migration_when_nested()
{
var mockType = new MockType("20110816231110_Migration", @namespace: "Migrations");
mockType.SetupGet(t => t.DeclaringType).Returns(typeof(object));
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void MigrationIds_should_not_return_migration_when_generic()
{
var mockType = new MockType("20110816231110_Migration", @namespace: "Migrations");
mockType.SetupGet(t => t.IsGenericType).Returns(true);
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void ConfigureServices_uses_Development_environment_when_unspecified()
{
var startup = CreateStartupInvoker(
MockAssembly.Create(typeof(StartupDevelopment)),
environment: null);
var services = startup.ConfigureServices();
var service = services.GetRequiredService <TestService>();
Assert.Equal("Development", service.Value);
}
public void ConfigureServices_invokes_static_methods()
{
var startup = CreateStartupInvoker(
MockAssembly.Create(typeof(StartupStatic)),
"Static");
var services = startup.ConfigureServices();
var service = services.GetRequiredService <TestService>();
Assert.Equal("Static", service.Value);
}
public void ConfigureServices_invokes_method_with_alternative_signature()
{
var startup = CreateStartupInvoker(
MockAssembly.Create(typeof(StartupAlternative)),
"Alternative");
var services = startup.ConfigureServices();
var service = services.GetRequiredService <TestService>();
Assert.Equal("Alternative", service.Value);
}
public void ConfigureDesignTimeServices_works_on_other_types()
{
var services = new ServiceCollection();
var startup = CreateStartupInvoker(
MockAssembly.Create(typeof(NotStartup)),
environment: null);
startup.ConfigureDesignTimeServices(typeof(NotStartup), services);
var service = services.BuildServiceProvider().GetRequiredService <TestService>();
Assert.Equal("NotStartup", service.Value);
}
public void ConfigureDesignTimeServices_uses_Development_environment_when_unspecified()
{
var services = new ServiceCollection();
var startup = CreateStartupInvoker(
MockAssembly.Create(typeof(StartupDevelopment)),
environment: null);
startup.ConfigureDesignTimeServices(services);
var service = services.BuildServiceProvider().GetRequiredService <TestService>();
Assert.Equal("Development", service.Value);
}
public void ConfigureDesignTimeServices_invokes_static_methods()
{
var services = new ServiceCollection();
var startup = CreateStartupInvoker(
MockAssembly.Create(typeof(StartupStatic)),
"Static");
startup.ConfigureDesignTimeServices(services);
var service = services.BuildServiceProvider().GetRequiredService <TestService>();
Assert.Equal("Static", service.Value);
}
public void Create_with_no_builder_method()
{
var factory = new TestAppServiceProviderFactory(
MockAssembly.Create(
new[] { typeof(ProgramWithNoHostBuilder) },
new MockMethodInfo(typeof(ProgramWithNoHostBuilder), InjectHostIntoDiagnostics)));
Environment.SetEnvironmentVariable("ASPNETCORE_ENVIRONMENT", null);
Environment.SetEnvironmentVariable("DOTNET_ENVIRONMENT", null);
var services = factory.Create(new[] { "arg1" });
Assert.NotNull(services.GetRequiredService <TestService>());
}
public void DiscoverInheritanceRelationships_PatchesBaseType()
{
var mockType1 = new MockType("Foo");
var mockType2 = new MockType("Bar").BaseType(mockType1);
var mockAssembly = new MockAssembly(mockType1, mockType2);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(mockAssembly));
var builder = new ODataConventionModelBuilder(configuration);
var entity1 = builder.AddEntity(mockType1);
var entity2 = builder.AddEntity(mockType2);
builder.DiscoverInheritanceRelationships();
Assert.Equal(entity1, entity2.BaseType);
}
public void CanModelBindNonStringData()
{
// Arrange
HttpServer server = new HttpServer();
MockAssembly assembly = new MockAssembly(typeof(TestController));
server.Configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(assembly));
ODataModelBuilder builder = new ODataConventionModelBuilder();
builder.EntitySet<TestClass>("Test");
server.Configuration.MapODataServiceRoute("odata", "", builder.GetEdmModel());
HttpClient client = new HttpClient(server);
// Act
var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Test");
request.ODataProperties().RoutingConventionsStore["test"] = new TestClass { Id = 42 };
var response = client.SendAsync(request).Result;
// Assert
TestClass result = response.Content.ReadAsAsync<TestClass>().Result;
Assert.Equal(42, result.Id);
}
public void DerivedTypes_Can_DefineKeys_InQueryCompositionMode()
{
// Arrange
MockType baseType =
new MockType("BaseType")
.Property(typeof(int), "ID");
MockType derivedType =
new MockType("DerivedType")
.Property(typeof(int), "DerivedTypeId")
.BaseType(baseType);
MockAssembly assembly = new MockAssembly(baseType, derivedType);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(assembly));
var builder = new ODataConventionModelBuilder(configuration, isQueryCompositionMode: true);
builder.AddEntitySet("bases", builder.AddEntity(baseType));
// Act
IEdmModel model = builder.GetEdmModel();
// Assert
model.AssertHasEntitySet("bases", baseType);
IEdmEntityType baseEntityType = model.AssertHasEntityType(baseType);
IEdmEntityType derivedEntityType = model.AssertHasEntityType(derivedType, baseType);
baseEntityType.AssertHasKey(model, "ID", EdmPrimitiveTypeKind.Int32);
derivedEntityType.AssertHasPrimitiveProperty(model, "DerivedTypeId", EdmPrimitiveTypeKind.Int32, isNullable: false);
}
public void RemoveBaseTypeProperties_RemovesAllBaseTypePropertiesFromDerivedTypes()
{
var mockType1 = new MockType("Foo").Property<int>("P1");
var mockType2 = new MockType("Bar").BaseType(mockType1).Property<int>("P1").Property<int>("P2");
var mockType3 = new MockType("FooBar").BaseType(mockType2).Property<int>("P1").Property<int>("P2");
var mockAssembly = new MockAssembly(mockType1, mockType2, mockType3);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(mockAssembly));
var builder = new ODataConventionModelBuilder(configuration);
var entity1 = builder.AddEntity(mockType1);
entity1.AddProperty(mockType1.GetProperty("P1"));
var entity2 = builder.AddEntity(mockType2).DerivesFrom(entity1);
entity2.AddProperty(mockType2.GetProperty("P2"));
var entity3 = builder.AddEntity(mockType3);
entity3.AddProperty(mockType3.GetProperty("P1"));
entity3.AddProperty(mockType3.GetProperty("P2"));
builder.RemoveBaseTypeProperties(entity3, entity2);
Assert.Empty(entity3.Properties);
}
public void TestCountConsidersFiltersOnMethods() {
var filter = new CategoryFilterMock();
var recipe = RecipeFactory.NewRecipe(string.Empty) as Recipe;
var mockAssembly = new MockAssembly();
// ReSharper disable PossibleNullReferenceException
recipe.AddAssembly(mockAssembly);
// ReSharper restore PossibleNullReferenceException
Assert.Equals(2, recipe.CountTests());
recipe.RegisterSelector(filter);
Assert.Equals(1, recipe.CountTests());
}
public void IgnoredPropertyOnBaseType_DoesnotShowupOnDerivedType()
{
// Arrange
var baseType =
new MockType("BaseType")
.Property<int>("BaseTypeProperty");
var derivedType =
new MockType("DerivedType")
.BaseType(baseType)
.Property<int>("DerivedTypeProperty");
var mockAssembly = new MockAssembly(baseType, derivedType);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(mockAssembly));
var builder = new ODataConventionModelBuilder(configuration);
// Act
var baseEntity = builder.AddEntity(baseType);
baseEntity.RemoveProperty(baseType.GetProperty("BaseTypeProperty"));
IEdmModel model = builder.GetEdmModel();
// Assert
IEdmEntityType baseEntityType = model.AssertHasEntityType(derivedType);
Assert.DoesNotContain("BaseTypeProperty", baseEntityType.Properties().Select(p => p.Name));
IEdmEntityType derivedEntityType = model.AssertHasEntityType(derivedType);
Assert.DoesNotContain("BaseTypeProperty", derivedEntityType.Properties().Select(p => p.Name));
}
public MockBuildManager(Type[] types)
{
MockAssembly assembly = new MockAssembly(types);
_assemblies = new Assembly[] { assembly };
}
public void MigrationIds_should_not_return_migration_when_name_does_not_match_pattern()
{
var mockType = new MockType("Z0110816231110_Migration", @namespace: "Migrations");
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void MigrationIds_should_not_return_migration_when_not_subclass_of_db_migration()
{
var mockType = new MockType("20110816231110_Migration", @namespace: "Migrations");
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void MigrationIds_should_not_return_migration_when_no_default_ctor()
{
var mockType = new MockType("20110816231110_Migration", hasDefaultCtor: false, @namespace: "Migrations");
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void MapDerivedTypes_BringsAllDerivedTypes_InTheAssembly()
{
var mockType1 = new MockType("FooBar");
var mockType2 = new MockType("Foo").BaseType(mockType1);
var mockType3 = new MockType("Fo").BaseType(mockType2);
var mockType4 = new MockType("Bar").BaseType(mockType1);
var mockAssembly = new MockAssembly(mockType1, mockType2, mockType3, mockType4);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(mockAssembly));
var builder = new ODataConventionModelBuilder(configuration);
var entity1 = builder.AddEntity(mockType1);
builder.MapDerivedTypes(entity1);
Assert.Equal(
new[] { "FooBar", "Foo", "Fo", "Bar" }.OrderBy(name => name),
builder.StructuralTypes.Select(t => t.Name).OrderBy(name => name));
}
public void MigrationIds_should_not_return_migration_when_abstract()
{
var mockType
= new MockType("20110816231110_Migration", @namespace: "Migrations")
.TypeAttributes(TypeAttributes.Abstract);
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void MigrationIds_should_not_return_migration_when_nested()
{
var mockType = new MockType("20110816231110_Migration", @namespace: "Migrations");
mockType.SetupGet(t => t.DeclaringType).Returns(typeof(object));
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void MigrationIds_should_not_return_migration_when_generic()
{
var mockType = new MockType("20110816231110_Migration", @namespace: "Migrations");
mockType.SetupGet(t => t.IsGenericType).Returns(true);
var mockAssembly = new MockAssembly(mockType);
var migrationAssembly = new MigrationAssembly(mockAssembly, mockType.Object.Namespace);
Assert.False(migrationAssembly.MigrationIds.Any());
}
public void ModelBuilder_DerivedComplexTypeHavingKeys_Throws()
{
MockType baseComplexType = new MockType("BaseComplexType");
MockType derivedComplexType =
new MockType("DerivedComplexType")
.Property(typeof(int), "DerivedComplexTypeId")
.BaseType(baseComplexType);
MockType entityType =
new MockType("EntityType")
.Property(typeof(int), "ID")
.Property(baseComplexType.Object, "ComplexProperty");
MockAssembly assembly = new MockAssembly(baseComplexType, derivedComplexType, entityType);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(assembly));
var builder = new ODataConventionModelBuilder(configuration);
builder.AddEntitySet("entities", builder.AddEntity(entityType));
Assert.Throws<InvalidOperationException>(
() => builder.GetEdmModel(),
"Cannot define keys on type 'DefaultNamespace.DerivedComplexType' deriving from 'DefaultNamespace.BaseComplexType'. Only the root type in the entity inheritance hierarchy can contain keys.");
}
public void ModelBuilder_DerivedComplexTypeHavingKeys_SuccedsIfToldToBeComplex()
{
MockType baseComplexType = new MockType("BaseComplexType");
MockType derivedComplexType =
new MockType("DerivedComplexType")
.Property(typeof(int), "DerivedComplexTypeId")
.BaseType(baseComplexType);
MockType entityType =
new MockType("EntityType")
.Property(typeof(int), "ID")
.Property(baseComplexType.Object, "ComplexProperty");
MockAssembly assembly = new MockAssembly(baseComplexType, derivedComplexType, entityType);
HttpConfiguration configuration = new HttpConfiguration();
configuration.Services.Replace(typeof(IAssembliesResolver), new TestAssemblyResolver(assembly));
var builder = new ODataConventionModelBuilder(configuration);
builder.AddEntitySet("entities", builder.AddEntity(entityType));
builder.AddComplexType(baseComplexType);
IEdmModel model = builder.GetEdmModel();
Assert.Equal(3, model.SchemaElements.Count());
Assert.NotNull(model.FindType("DefaultNamespace.EntityType"));
Assert.NotNull(model.FindType("DefaultNamespace.BaseComplexType"));
}
public TestAssemblyResolver(MockAssembly assembly)
{
_assemblies = new List<Assembly>();
_assemblies.Add(assembly);
}
public AzureHostSupportTest()
{
fileSystem = new MockFileSystem();
assembly = new MockAssembly();
azureHostSupport = new AzureHostSupport(fileSystem, assembly);
}
