public void Merge_Should_DeepMerge_Configurations()
{
// arrange
var convention = new MockFilterConvention(
x => x.Configure <ComparableOperationFilterInput <int> >(d => d.Name("Foo")));
var extension = new FilterConventionExtension(
x => x.Configure <ComparableOperationFilterInput <int> >(d => d.Name("Bar")));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
List <ConfigureFilterInputType> configuration =
Assert.Single(convention.DefinitionAccessor !.Configurations.Values) !;
Assert.Equal(2, configuration.Count);
}
/// <inheritdoc />
public void Apply(ConventionContext context)
{
if (context.ModelType == null)
{
return;
}
if (context.Application.Arguments.Any(a => string.IsNullOrEmpty(a.Name)))
{
throw new ModelException($"An argument name is not defined for class {context.ModelType}.");
}
if (context.Application.Options.Any(a => string.IsNullOrEmpty(a.LongName)))
{
throw new ModelException($"An option long name is not defined for class {context.ModelType}.");
}
if (string.IsNullOrEmpty(context.Application.Name))
{
throw new ModelException($"A command name is not defined for class {context.ModelType}.");
}
foreach (var command in context.Application.Arguments.Where(a => string.IsNullOrEmpty(a.Name)))
{
}
}
public static IValidator <NewSubcommand> GetValidator <T>(this ConventionContext context)
where T : IValidator <NewSubcommand>
{
return(context.Application
.GetServices <IValidator <NewSubcommand> >()
.FirstOrDefault(s => s.GetType() == typeof(T)));
}
public void Apply(ConventionContext context, MemberInfo member)
{
Contract.Requires(context != null);
Contract.Requires(member != null);
var opt = context.Application.Option("-s|--skiped-steps <steps>", "The steps to skip, use comma to separate step number, like '1,2,3'", CommandOptionType.SingleValue);
opt.Validators.Add(this);
context.Application.OnParsingComplete(_ => {
var value = opt.Value();
if (value != null)
{
var skippedSteps = (member as PropertyInfo).GetValue(context.ModelAccessor.GetModel()) as HashSet <int>;
var numbers = value.Split(',');
foreach (var number in numbers)
{
if (int.TryParse(number.Trim(), out int index))
{
// step is zero-based
skippedSteps.Add(index - 1);
}
}
}
});
}
public void Apply(ConventionContext context, MemberInfo member)
{
context.Application.OnParsingComplete(_ =>
{
if (_.ShowHelp())
{
return;
}
var solution = context.GetStringValue(nameof(NewSubcommand.Solution));
var fileSystemService = context.Application.GetService <IFileSystemService>();
IOperationResponse <string> response = solution.IsNotProvidedByUser()
? fileSystemService.GetSolutionPath(InitDirectory)
: fileSystemService.GetSolutionPath(solution);
if (context.ModelAccessor?.GetModel() is NewSubcommand model && model != null)
{
if (!response.IsSuccessful && response.Message.Exists())
{
model.SetResolvedSolutionErrorMessage(response.Message);
}
model?.SetResolvedSolution(response?.Payload ?? string.Empty);
var solutionValidator = context.GetValidator <SolutionValidator>();
solutionValidator.Validate(model !);
}
});
}
public void Apply(ConventionContext context)
{
context.Application.Description = "This command is defined in " + context.ModelType.Assembly.FullName;
if (!Directory.Exists($"{Directory.GetCurrentDirectory()}/.bionic") ||
!ProjectHelper.InClientOrStandaloneDir())
{
return;
}
var plugins = Directory.GetDirectories($"{Directory.GetCurrentDirectory()}/.bionic", "Bionic*Plugin");
foreach (var path in plugins)
{
var fp = $"{path}/lib/netstandard2.0/{new DirectoryInfo(path).Name}.dll";
var a = AssemblyLoader.LoadFromAssemblyPath(fp);
IList <Type> commandPluginTypes = (
from t in a.GetTypes()
where t.GetTypeInfo().ImplementedInterfaces.Contains(typeof(ICommandPlugin))
select t
).ToList();
foreach (var commandPluginType in commandPluginTypes)
{
var name = commandPluginType.Name;
var plugin = (ICommandPlugin)commandPluginType.Assembly.CreateInstance(commandPluginType.FullName);
context.Application.Command(plugin.CommandName, cmd => { plugin.Initialize(cmd); });
}
}
}
public void Merge_Should_Merge_ProviderExtensions()
{
// arrange
var provider1 = new MockProviderExtensions();
var convention = new MockProjectionConvention(x => x.AddProviderExtension(provider1));
var provider2 = new MockProviderExtensions();
var extension =
new ProjectionConventionExtension(x => x.AddProviderExtension(provider2));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
Assert.Collection(
convention.DefinitionAccessor !.ProviderExtensions,
x => Assert.Equal(provider1, x),
x => Assert.Equal(provider2, x));
}
private InternalSkipNavigationBuilder RunConvention(InternalSkipNavigationBuilder skipNavBuilder)
{
var context = new ConventionContext <IConventionSkipNavigationBuilder>(skipNavBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);
CreateManyToManyConvention().ProcessSkipNavigationAdded(skipNavBuilder, context);
return(context.ShouldStopProcessing() ? (InternalSkipNavigationBuilder)context.Result : skipNavBuilder);
}
private void RunConvention(InternalPropertyBuilder propertyBuilder)
{
var context = new ConventionContext <IConventionPropertyBuilder>(
propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);
CreateKeyDiscoveryConvention().ProcessPropertyAdded(propertyBuilder, context);
}
private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
{
var context = new ConventionContext <IConventionEntityTypeBuilder>(
entityTypeBuilder.Metadata.Model.ConventionDispatcher);
CreateKeyDiscoveryConvention().ProcessEntityTypeAdded(entityTypeBuilder, context);
}
public void Merge_Should_DeepMerge_EnumConfigurations()
{
// arrange
var convention = new MockSortConvention(
x => x.ConfigureEnum <DefaultSortEnumType>(d => d.Name("Foo")));
var extension = new SortConventionExtension(
x => x.ConfigureEnum <DefaultSortEnumType>(d => d.Name("Foo")));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
List <ConfigureSortEnumType> configuration =
Assert.Single(convention.DefinitionAccessor !.EnumConfigurations.Values) !;
Assert.Equal(2, configuration.Count);
}
private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
{
var context = new ConventionContext <IConventionEntityTypeBuilder>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);
new BaseTypeDiscoveryConvention(CreateDependencies())
.ProcessEntityTypeAdded(entityTypeBuilder, context);
}
public async Task Test2()
{
var builder = new ConventionContextBuilder(new Dictionary <object, object?>());
var context = ConventionContext.From(builder
.Set <IConfiguration>(new ConfigurationBuilder().Build())
.Set(new MediatRServiceConfiguration().AsSingleton())
.EnableConventionAttributes()
.UseAssemblies(new TestAssemblyProvider().GetAssemblies())
);
var services = new ServiceCollection().ApplyConventions(context);
var sub = A.Fake <IPipelineBehavior <Request, Unit> >();
services.AddSingleton(sub);
services.Should().Contain(
x => x.ServiceType == typeof(IMediator) && x.Lifetime == ServiceLifetime.Singleton
);
var r = services.BuildServiceProvider();
var mediator = r.GetRequiredService <IMediator>();
await mediator.Send(new Request()).ConfigureAwait(false);
A.CallTo(() => sub.Handle(A <Request> ._, A <CancellationToken> ._, A <RequestHandlerDelegate <Unit> > ._))
.MustHaveHappenedOnceExactly();
}
/// <inheritdoc />
public sealed override void ConfigureAppConfiguration(IFunctionsConfigurationBuilder builder)
{
Setup(_builder);
_context = ConventionContext.From(_builder);
builder.ConfigurationBuilder.ApplyConventions(_context);
ConfigureAppConfiguration(builder, _context);
}
internal CommandLineApplication(
CommandLineApplication?parent,
IHelpTextGenerator helpTextGenerator,
CommandLineContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
Parent = parent;
Options = new List <CommandOption>();
Arguments = new List <CommandArgument>();
Commands = new List <CommandLineApplication>();
RemainingArguments = new List <string>();
_helpTextGenerator = helpTextGenerator ?? throw new ArgumentNullException(nameof(helpTextGenerator));
_handler = DefaultAction;
_validationErrorHandler = DefaultValidationErrorHandler;
Out = context.Console.Out;
Error = context.Console.Error;
SetContext(context);
_services = new Lazy <IServiceProvider>(() => new ServiceProvider(this));
ValueParsers = parent?.ValueParsers ?? new ValueParserProvider();
_parserConfig = new ParserConfig();
_clusterOptions = parent?._clusterOptions;
UsePagerForHelpText = parent?.UsePagerForHelpText ?? false;
_conventionContext = CreateConventionContext();
if (Parent != null)
{
foreach (var convention in Parent._conventions)
{
Conventions.AddConvention(convention);
}
}
}
private static void RunConvention(InternalPropertyBuilder propertyBuilder)
{
var dependencies = CreateDependencies();
var context = new ConventionContext <IConventionPropertyBuilder>(
propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);
new ConcurrencyCheckAttributeConvention(dependencies)
.ProcessPropertyAdded(propertyBuilder, context);
new DatabaseGeneratedAttributeConvention(dependencies)
.ProcessPropertyAdded(propertyBuilder, context);
new KeyAttributeConvention(dependencies)
.ProcessPropertyAdded(propertyBuilder, context);
new MaxLengthAttributeConvention(dependencies)
.ProcessPropertyAdded(propertyBuilder, context);
new RequiredPropertyAttributeConvention(dependencies)
.ProcessPropertyAdded(propertyBuilder, context);
new StringLengthAttributeConvention(dependencies)
.ProcessPropertyAdded(propertyBuilder, context);
new TimestampAttributeConvention(dependencies)
.ProcessPropertyAdded(propertyBuilder, context);
}
private void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
{
var context = new ConventionContext <IConventionEntityTypeBuilder>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);
new RelationalTableAttributeConvention(CreateDependencies(), CreateRelationalDependencies())
.ProcessEntityTypeAdded(entityTypeBuilder, context);
}
private void RunConvention(InternalModelBuilder modelBuilder)
{
var context = new ConventionContext <IConventionModelBuilder>(modelBuilder.Metadata.ConventionDispatcher);
new ModelCleanupConvention(CreateDependencies())
.ProcessModelFinalized(modelBuilder, context);
}
public ImmediateConventionScope(ConventionSet conventionSet, ConventionDispatcher dispatcher)
{
_conventionSet = conventionSet;
_dispatcher = dispatcher;
_entityTypeBuilderConventionContext = new ConventionContext <IConventionEntityTypeBuilder>(dispatcher);
_entityTypeConventionContext = new ConventionContext <IConventionEntityType>(dispatcher);
_relationshipBuilderConventionContext = new ConventionContext <IConventionForeignKeyBuilder>(dispatcher);
_foreignKeyConventionContext = new ConventionContext <IConventionForeignKey>(dispatcher);
_skipNavigationBuilderConventionContext = new ConventionContext <IConventionSkipNavigationBuilder>(dispatcher);
_skipNavigationConventionContext = new ConventionContext <IConventionSkipNavigation>(dispatcher);
_navigationConventionBuilderContext = new ConventionContext <IConventionNavigationBuilder>(dispatcher);
_navigationConventionContext = new ConventionContext <IConventionNavigation>(dispatcher);
_indexBuilderConventionContext = new ConventionContext <IConventionIndexBuilder>(dispatcher);
_indexConventionContext = new ConventionContext <IConventionIndex>(dispatcher);
_keyBuilderConventionContext = new ConventionContext <IConventionKeyBuilder>(dispatcher);
_keyConventionContext = new ConventionContext <IConventionKey>(dispatcher);
_propertyBuilderConventionContext = new ConventionContext <IConventionPropertyBuilder>(dispatcher);
_propertyConventionContext = new ConventionContext <IConventionProperty>(dispatcher);
_modelBuilderConventionContext = new ConventionContext <IConventionModelBuilder>(dispatcher);
_annotationConventionContext = new ConventionContext <IConventionAnnotation>(dispatcher);
_propertyListConventionContext = new ConventionContext <IReadOnlyList <IConventionProperty> >(dispatcher);
_stringConventionContext = new ConventionContext <string>(dispatcher);
_fieldInfoConventionContext = new ConventionContext <FieldInfo>(dispatcher);
_boolConventionContext = new ConventionContext <bool?>(dispatcher);
}
internal CommandLineApplication(CommandLineApplication parent,
IHelpTextGenerator helpTextGenerator,
CommandLineContext context,
bool throwOnUnexpectedArg)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
Parent = parent;
ThrowOnUnexpectedArgument = throwOnUnexpectedArg;
Options = new List <CommandOption>();
Arguments = new List <CommandArgument>();
Commands = new List <CommandLineApplication>();
RemainingArguments = new List <string>();
HelpTextGenerator = helpTextGenerator;
Invoke = () => 0;
ValidationErrorHandler = DefaultValidationErrorHandler;
SetContext(context);
_conventionContext = CreateConventionContext();
if (Parent != null)
{
foreach (var convention in Parent._conventions)
{
Conventions.AddConvention(convention);
}
}
}
public void DiscoverKeyProperties_does_not_discover_key_when_multiple_ids()
{
var entityBuilder = CreateInternalEntityBuilder <EntityWithMultipleIds>();
RunConvention(entityBuilder);
var key = entityBuilder.Metadata.FindPrimaryKey();
Assert.Null(key);
var logEntry = ListLoggerFactory.Log.Single();
Assert.Equal(LogLevel.Debug, logEntry.Level);
Assert.Equal(
CoreResources.LogMultiplePrimaryKeyCandidates(new TestLogger <TestLoggingDefinitions>()).GenerateMessage(
nameof(EntityWithMultipleIds.ID), nameof(EntityWithMultipleIds.Id), nameof(EntityWithMultipleIds)), logEntry.Message);
var context = new ConventionContext <string>(
entityBuilder.Metadata.Model.ConventionDispatcher);
entityBuilder.Ignore("ID", ConfigurationSource.DataAnnotation);
CreateKeyDiscoveryConvention().ProcessEntityTypeMemberIgnored(entityBuilder, "ID", context);
Assert.Equal("Id", entityBuilder.Metadata.FindPrimaryKey().Properties.Single().Name);
}
internal CommandLineApplication(CommandLineApplication parent,
IHelpTextGenerator helpTextGenerator,
CommandLineContext context,
bool throwOnUnexpectedArg)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
Parent = parent;
ThrowOnUnexpectedArgument = throwOnUnexpectedArg;
Options = new List <CommandOption>();
Arguments = new List <CommandArgument>();
Commands = new List <CommandLineApplication>();
RemainingArguments = new List <string>();
HelpTextGenerator = helpTextGenerator;
Invoke = () => 0;
ValidationErrorHandler = DefaultValidationErrorHandler;
SetContext(context);
_services = new Lazy <IServiceProvider>(() => new ServiceProvider(this));
ValueParsers = parent?.ValueParsers ?? new ValueParserProvider();
_clusterOptions = parent?._clusterOptions;
UsePagerForHelpText = parent?.UsePagerForHelpText ?? true;
_conventionContext = CreateConventionContext();
if (Parent != null)
{
foreach (var convention in Parent._conventions)
{
Conventions.AddConvention(convention);
}
}
}
private static void RunConvention(InternalEntityTypeBuilder entityTypeBuilder)
{
var context = new ConventionContext <IConventionEntityTypeBuilder>(entityTypeBuilder.Metadata.Model.ConventionDispatcher);
new RelationalTableAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestRelationalLoggingDefinitions>())
.ProcessEntityTypeAdded(entityTypeBuilder, context);
}
public void Merge_Should_Merge_HandlersAndPrependExtensionHandlers()
{
// arrange
var firstFieldHandler = new QueryableDefaultSortFieldHandler();
var extensionFieldHandler = new MockFieldHandler();
var convention = new MockProvider(x => x.AddFieldHandler(firstFieldHandler));
var extension = new MockProviderExtensions(
x => x.AddFieldHandler(extensionFieldHandler));
var context = new ConventionContext(
"Scope",
new ServiceCollection().BuildServiceProvider(),
DescriptorContext.Create());
convention.Initialize(context);
extension.Initialize(context);
// act
extension.Merge(context, convention);
// assert
Assert.NotNull(convention.DefinitionAccessor);
Assert.Collection(
convention.DefinitionAccessor !.Handlers,
x => Assert.Equal(extensionFieldHandler, x.HandlerInstance),
x => Assert.Equal(firstFieldHandler, x.HandlerInstance));
}
public CompositionDependencyResolver(IAssembliesResolver assembliesResolver, string appSettingsPath = null, Action <ConventionBuilder> webApiConventions = null)
{
Contract.Requires(assembliesResolver != null);
var configuration = new ContainerConfiguration();
var conventions = new ConventionBuilder();
var assemblies = new ComposedAssemblies(assembliesResolver);
var context = new ConventionContext(conventions, assemblies);
var rules = new IRule <ConventionContext>[]
{
new RequiredComponentConvention(),
new RuntimeComponentConvention(),
new MessageBusConvention(),
new AggregateConvention(),
new CommandAndEventConvention(),
new ReadModelRepositoryConvention(),
new ControllerConvention()
};
settings = new Lazy <IConfigurationRoot>(() => CreateSettingsConfiguration(appSettingsPath));
rules.ForEach(rule => rule.Evaluate(context));
configuration.WithDefaultConventions(conventions);
configuration.WithAssemblies(assemblies);
configuration.WithProvider(new SelfExportDescriptorProvider(this));
configuration.WithProvider(new ConfigurationExportProvider((key, type) => settings.Value.GetValue(type, key)));
configuration.WithProvider(new SqlConfigurationExportDescriptorProvider(ConnectionStringKey, SubscriptionKey));
configuration.WithProvider(new SagaMetadataExportDescriptorProvider(context));
configuration.WithProvider(new HttpRequestExportDescriptorProvider());
configuration.WithParts(context.ClosedGenericTypes);
webApiConventions?.Invoke(conventions);
host = configuration.CreateContainer();
}
private void RunConvention(InternalPropertyBuilder propertyBuilder)
{
var context = new ConventionContext <IConventionPropertyBuilder>(
propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);
new RelationalColumnAttributeConvention(new TestLogger <DbLoggerCategory.Model, TestRelationalLoggingDefinitions>())
.ProcessPropertyAdded(propertyBuilder, context);
}
private Navigation RunConvention(InternalRelationshipBuilder relationshipBuilder, Navigation navigation)
{
var context = new ConventionContext <IConventionNavigation>(
relationshipBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);
CreateNotNullNavigationConvention().ProcessNavigationAdded(relationshipBuilder, navigation, context);
return(context.ShouldStopProcessing() ? (Navigation)context.Result : navigation);
}
private void RunConvention(IMutableNavigation navigation)
{
var context = new ConventionContext <IConventionNavigationBuilder>(
((ForeignKey)navigation.ForeignKey).DeclaringEntityType.Model.ConventionDispatcher);
new BackingFieldConvention(CreateDependencies())
.ProcessNavigationAdded(((IConventionNavigation)navigation).Builder, context);
}
private void Validate(InternalEntityTypeBuilder entityTypeBuilder)
{
var context = new ConventionContext <IConventionModelBuilder>(
entityTypeBuilder.Metadata.Model.ConventionDispatcher);
new KeyAttributeConvention(CreateDependencies())
.ProcessModelFinalized(entityTypeBuilder.ModelBuilder, context);
}
private void RunConvention(InternalPropertyBuilder propertyBuilder)
{
var context = new ConventionContext <IConventionPropertyBuilder>(
propertyBuilder.Metadata.DeclaringEntityType.Model.ConventionDispatcher);
new NonNullableReferencePropertyConvention(CreateDependencies())
.ProcessPropertyAdded(propertyBuilder, context);
}
