Partial fix for 8332. Update the ef side to pass in the arguments.

dotnet · Mar 26, 2020 · 33f086d · 33f086d
1 parent 922a770
commit 33f086d
Show file tree

Hide file tree

Showing 16 changed files with 93 additions and 47 deletions.
diff --git a/src/EFCore.Design/Design/DbContextActivator.cs b/src/EFCore.Design/Design/DbContextActivator.cs
@@ -22,19 +22,21 @@ public static class DbContextActivator
         /// <param name="contextType"> The <see cref="DbContext" /> type to instantiate. </param>
         /// <param name="startupAssembly"> The application's startup assembly. </param>
         /// <param name="reportHandler"> The design-time report handler. </param>
+        /// <param name="arguments"> Arguments passed to the <see cref="DbContext" /> constructor. </param>
         /// <returns> The newly created object. </returns>
         public static DbContext CreateInstance(
             [NotNull] Type contextType,
             [CanBeNull] Assembly startupAssembly = null,
-            [CanBeNull] IOperationReportHandler reportHandler = null)
+            [CanBeNull] IOperationReportHandler reportHandler = null,
+            [CanBeNull] string[] arguments = null)
         {
             Check.NotNull(contextType, nameof(contextType));
 
             return new DbContextOperations(
                     new OperationReporter(reportHandler),
                     contextType.Assembly,
                     startupAssembly ?? contextType.Assembly,
-                    args: Array.Empty<string>()) // TODO: Issue #8332
+                    args: arguments ?? Array.Empty<string>())
                 .CreateContext(contextType.FullName);
         }
     }

diff --git a/src/EFCore.Design/Design/Internal/AppServiceProviderFactory.cs b/src/EFCore.Design/Design/Internal/AppServiceProviderFactory.cs
@@ -44,7 +44,7 @@ public virtual IServiceProvider Create([NotNull] string[] args)
             _reporter.WriteVerbose(DesignStrings.FindingServiceProvider);
 
             return CreateFromHosting(args)
-                   ?? CreateEmptyServiceProvider();
+                   ?? CreateArgsServiceProvider(args);
         }
 
         private IServiceProvider CreateFromHosting(string[] args)
@@ -97,11 +97,13 @@ private IServiceProvider CreateFromHosting(string[] args)
             }
         }
 
-        private IServiceProvider CreateEmptyServiceProvider()
+        private IServiceProvider CreateArgsServiceProvider(string[] args)
         {
             _reporter.WriteVerbose(DesignStrings.NoServiceProvider);
 
-            return new ServiceCollection().BuildServiceProvider();
+            return new ServiceCollection()
+                .AddScoped(typeof(string[]), sp => args)
+                .BuildServiceProvider();
         }
     }
 }
diff --git a/src/EFCore.Design/Design/OperationExecutor.cs b/src/EFCore.Design/Design/OperationExecutor.cs
@@ -47,6 +47,8 @@ public class OperationExecutor : MarshalByRefObject
         ///     <para><c>startupTargetName</c>--The assembly name of the startup project.</para>
         ///     <para><c>projectDir</c>--The target project's root directory.</para>
         ///     <para><c>rootNamespace</c>--The target project's root namespace.</para>
+        ///     <para><c>language</c>--The programming language to be used to generate classes.</para>
+        ///     <para><c>appArgs</c>--Extra arguments passed into the operation.</para>
         /// </summary>
         /// <param name="reportHandler"> The <see cref="IOperationReportHandler" />. </param>
         /// <param name="args"> The executor arguments. </param>
@@ -61,9 +63,7 @@ public OperationExecutor([NotNull] IOperationReportHandler reportHandler, [NotNu
             _projectDir = (string)args["projectDir"];
             _rootNamespace = (string)args["rootNamespace"];
             _language = (string)args["language"];
-
-            // TODO: Flow in from tools (issue #8332)
-            _designArgs = Array.Empty<string>();
+            _designArgs = (string[])args["appArgs"];
 
             var toolsVersion = (string)args["toolsVersion"];
             var runtimeVersion = ProductInfo.GetVersion();

diff --git a/src/ef/Commands/CommandBase.cs b/src/ef/Commands/CommandBase.cs
@@ -1,20 +1,24 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System.Collections.Generic;
 using Microsoft.DotNet.Cli.CommandLine;
 using Microsoft.EntityFrameworkCore.Tools.Properties;
 
 namespace Microsoft.EntityFrameworkCore.Tools.Commands
 {
     internal abstract class CommandBase
     {
+        protected string[] RemainingArguments { get; private set; }
+
         public virtual void Configure(CommandLineApplication command)
         {
             var verbose = command.Option("-v|--verbose", Resources.VerboseDescription);
             var noColor = command.Option("--no-color", Resources.NoColorDescription);
             var prefixOutput = command.Option("--prefix-output", Resources.PrefixDescription);
 
             command.HandleResponseFiles = true;
+            RemainingArguments = command.RemainingArguments.ToArray();
 
             command.OnExecute(
                 () =>

diff --git a/src/ef/Commands/DatabaseDropCommand.cs b/src/ef/Commands/DatabaseDropCommand.cs
@@ -15,7 +15,7 @@ protected override int Execute()
 
             void LogDropCommand(Func<object, object, string> resource)
             {
-                var result = executor.GetContextInfo(Context.Value());
+                var result = executor.GetContextInfo(Context.Value(), RemainingArguments);
                 var databaseName = result["DatabaseName"] as string;
                 var dataSource = result["DataSource"] as string;
                 Reporter.WriteInformation(resource(databaseName, dataSource));
@@ -38,7 +38,7 @@ void LogDropCommand(Func<object, object, string> resource)
                 }
             }
 
-            executor.DropDatabase(Context.Value());
+            executor.DropDatabase(Context.Value(), RemainingArguments);
 
             return base.Execute();
         }

diff --git a/src/ef/Commands/DatabaseUpdateCommand.cs b/src/ef/Commands/DatabaseUpdateCommand.cs
@@ -8,7 +8,7 @@ internal partial class DatabaseUpdateCommand
     {
         protected override int Execute()
         {
-            CreateExecutor().UpdateDatabase(_migration.Value, _connection.Value(), Context.Value());
+            CreateExecutor().UpdateDatabase(_migration.Value, _connection.Value(), Context.Value(), RemainingArguments);
 
             return base.Execute();
         }

diff --git a/src/ef/Commands/DbContextInfoCommand.cs b/src/ef/Commands/DbContextInfoCommand.cs
@@ -11,7 +11,7 @@ internal partial class DbContextInfoCommand
     {
         protected override int Execute()
         {
-            var result = CreateExecutor().GetContextInfo(Context.Value());
+            var result = CreateExecutor().GetContextInfo(Context.Value(), RemainingArguments);
 
             if (_json.HasValue())
             {

diff --git a/src/ef/Commands/DbContextScaffoldCommand.cs b/src/ef/Commands/DbContextScaffoldCommand.cs
@@ -39,7 +39,8 @@ protected override int Execute()
                 _force.HasValue(),
                 _useDatabaseNames.HasValue(),
                 _namespace.Value(),
-                _contextNamespace.Value());
+                _contextNamespace.Value(),
+                RemainingArguments);
             if (_json.HasValue())
             {
                 ReportJsonResults(result);

diff --git a/src/ef/Commands/DbContextScriptCommand.cs b/src/ef/Commands/DbContextScriptCommand.cs
@@ -13,7 +13,7 @@ internal partial class DbContextScriptCommand
         protected override int Execute()
         {
             var sql = CreateExecutor().ScriptDbContext(
-                Context.Value());
+                Context.Value(), RemainingArguments);
 
             if (!_output.HasValue())
             {

diff --git a/src/ef/Commands/MigrationsAddCommand.cs b/src/ef/Commands/MigrationsAddCommand.cs
@@ -22,7 +22,7 @@ protected override void Validate()
         protected override int Execute()
         {
             var files = CreateExecutor().AddMigration(
-                _name.Value, _outputDir.Value(), Context.Value(), _namespace.Value());
+                _name.Value, _outputDir.Value(), Context.Value(), _namespace.Value(), RemainingArguments);
 
             if (_json.HasValue())
             {

diff --git a/src/ef/Commands/MigrationsListCommand.cs b/src/ef/Commands/MigrationsListCommand.cs
@@ -13,7 +13,8 @@ internal partial class MigrationsListCommand
     {
         protected override int Execute()
         {
-            var migrations = CreateExecutor().GetMigrations(Context.Value()).ToList();
+            var migrations = CreateExecutor()
+                .GetMigrations(Context.Value(), RemainingArguments).ToList();
 
             if (_json.HasValue())
             {

diff --git a/src/ef/Commands/MigrationsRemoveCommand.cs b/src/ef/Commands/MigrationsRemoveCommand.cs
@@ -10,7 +10,7 @@ internal partial class MigrationsRemoveCommand
     {
         protected override int Execute()
         {
-            var result = CreateExecutor().RemoveMigration(Context.Value(), _force.HasValue());
+            var result = CreateExecutor().RemoveMigration(Context.Value(), _force.HasValue(), RemainingArguments);
             if (_json.HasValue())
             {
                 ReportJsonResults(result);

diff --git a/src/ef/Commands/MigrationsScriptCommand.cs b/src/ef/Commands/MigrationsScriptCommand.cs
@@ -16,7 +16,8 @@ protected override int Execute()
                 _from.Value,
                 _to.Value,
                 _idempotent.HasValue(),
-                Context.Value());
+                Context.Value(),
+                RemainingArguments);
 
             if (!_output.HasValue())
             {

diff --git a/src/ef/IOperationExecutor.cs b/src/ef/IOperationExecutor.cs
@@ -9,12 +9,12 @@ namespace Microsoft.EntityFrameworkCore.Tools
 {
     internal interface IOperationExecutor : IDisposable
     {
-        IDictionary AddMigration(string name, string outputDir, string contextType, string migrationNamespace);
-        IDictionary RemoveMigration(string contextType, bool force);
-        IEnumerable<IDictionary> GetMigrations(string contextType);
-        void DropDatabase(string contextType);
-        IDictionary GetContextInfo(string name);
-        void UpdateDatabase(string migration, string connectionString, string contextType);
+        IDictionary AddMigration(string name, string outputDir, string contextType, string @namespace, string[] remainingArguments);
+        IDictionary RemoveMigration(string contextType, bool force, string[] remainingArguments);
+        IEnumerable<IDictionary> GetMigrations(string contextType, string[] remainingArguments);
+        void DropDatabase(string contextType, string[] remainingArguments);
+        IDictionary GetContextInfo(string name, string[] remainingArguments);
+        void UpdateDatabase(string migration, string connectionString, string contextType, string[] remainingArguments);
         IEnumerable<IDictionary> GetContextTypes();
 
         IDictionary ScaffoldContext(
@@ -29,10 +29,11 @@ IDictionary ScaffoldContext(
             bool overwriteFiles,
             bool useDatabaseNames,
             string entityNamespace,
-            string dbContextNamespace);
+            string dbContextNamespace,
+            string[] remainingArguments);
 
-        string ScriptMigration(string fromMigration, string toMigration, bool idempotent, string contextType);
+        string ScriptMigration(string fromMigration, string toMigration, bool idempotent, string contextType, string[] remainingArguments);
 
-        string ScriptDbContext(string contextType);
+        string ScriptDbContext(string contextType, string[] remainingArguments);
     }
 }
diff --git a/src/ef/OperationExecutorBase.cs b/src/ef/OperationExecutorBase.cs
@@ -82,45 +82,47 @@ private object InvokeOperationImpl(string operationName, IDictionary arguments)
             return resultHandler.Result;
         }
 
-        public IDictionary AddMigration(string name, string outputDir, string contextType, string @namespace)
+        public IDictionary AddMigration(string name, string outputDir, string contextType, string @namespace, string[] remainingArguments)
             => InvokeOperation<IDictionary>(
                 "AddMigration",
-                new Dictionary<string, string>
+                new Dictionary<string, object>
                 {
                     ["name"] = name,
                     ["outputDir"] = outputDir,
                     ["contextType"] = contextType,
-                    ["namespace"] = @namespace
+                    ["namespace"] = @namespace,
+                    ["appArgs"] = remainingArguments
                 });
 
-        public IDictionary RemoveMigration(string contextType, bool force)
+        public IDictionary RemoveMigration(string contextType, bool force, string[] remainingArguments)
             => InvokeOperation<IDictionary>(
                 "RemoveMigration",
-                new Dictionary<string, object> { ["contextType"] = contextType, ["force"] = force });
+                new Dictionary<string, object> { ["contextType"] = contextType, ["force"] = force, ["appArgs"] = remainingArguments });
 
-        public IEnumerable<IDictionary> GetMigrations(string contextType)
+        public IEnumerable<IDictionary> GetMigrations(string contextType, string[] remainingArguments)
             => InvokeOperation<IEnumerable<IDictionary>>(
                 "GetMigrations",
-                new Dictionary<string, object> { ["contextType"] = contextType });
+                new Dictionary<string, object> { ["contextType"] = contextType, ["appArgs"] = remainingArguments });
 
-        public void DropDatabase(string contextType)
+        public void DropDatabase(string contextType, string[] remainingArguments)
             => InvokeOperation(
                 "DropDatabase",
-                new Dictionary<string, object> { ["contextType"] = contextType });
+                new Dictionary<string, object> { ["contextType"] = contextType, ["appArgs"] = remainingArguments });
 
-        public IDictionary GetContextInfo(string name)
+        public IDictionary GetContextInfo(string name, string[] remainingArguments)
             => InvokeOperation<IDictionary>(
                 "GetContextInfo",
-                new Dictionary<string, object> { ["contextType"] = name });
+                new Dictionary<string, object> { ["contextType"] = name, ["appArgs"] = remainingArguments });
 
-        public void UpdateDatabase(string migration, string connectionString, string contextType)
+        public void UpdateDatabase(string migration, string connectionString, string contextType, string[] remainingArguments)
             => InvokeOperation(
                 "UpdateDatabase",
-                new Dictionary<string, string>
+                new Dictionary<string, object>
                 {
                     ["targetMigration"] = migration,
                     ["connectionString"] = connectionString,
-                    ["contextType"] = contextType
+                    ["contextType"] = contextType,
+                    ["appArgs"] = remainingArguments
                 });
 
         public IEnumerable<IDictionary> GetContextTypes()
@@ -138,7 +140,8 @@ public IDictionary ScaffoldContext(
             bool overwriteFiles,
             bool useDatabaseNames,
             string modelNamespace,
-            string contextNamespace)
+            string contextNamespace,
+            string[] remainingArguments)
             => InvokeOperation<IDictionary>(
                 "ScaffoldContext",
                 new Dictionary<string, object>
@@ -154,27 +157,30 @@ public IDictionary ScaffoldContext(
                     ["overwriteFiles"] = overwriteFiles,
                     ["useDatabaseNames"] = useDatabaseNames,
                     ["modelNamespace"] = modelNamespace,
-                    ["contextNamespace"] = contextNamespace
+                    ["contextNamespace"] = contextNamespace,
+                    ["appArgs"] = remainingArguments
                 });
 
         public string ScriptMigration(
             string fromMigration,
             string toMigration,
             bool idempotent,
-            string contextType)
+            string contextType,
+            string[] remainingArguments)
             => InvokeOperation<string>(
                 "ScriptMigration",
                 new Dictionary<string, object>
                 {
                     ["fromMigration"] = fromMigration,
                     ["toMigration"] = toMigration,
                     ["idempotent"] = idempotent,
-                    ["contextType"] = contextType
+                    ["contextType"] = contextType,
+                    ["appArgs"] = remainingArguments
                 });
 
-        public string ScriptDbContext(string contextType)
+        public string ScriptDbContext(string contextType, string[] remainingArguments)
             => InvokeOperation<string>(
                 "ScriptDbContext",
-                new Dictionary<string, object> { ["contextType"] = contextType });
+                new Dictionary<string, object> { ["contextType"] = contextType, ["appArgs"] = remainingArguments });
     }
 }
diff --git a/test/EFCore.Design.Tests/Design/DbContextActivatorTest.cs b/test/EFCore.Design.Tests/Design/DbContextActivatorTest.cs
@@ -15,12 +15,40 @@ public void CreateInstance_works()
             Assert.IsType<TestContext>(result);
         }
 
+        [ConditionalFact]
+        public void CreateInstance_can_pass_in_arguments()
+        {
+            var result = DbContextActivator.CreateInstance(
+                typeof(ArgsContext), arguments: new string[] { "Pass", "Me", "In" });
+
+            Assert.IsType<ArgsContext>(result);
+            Assert.Collection<string>(((ArgsContext)result).Args,
+                 s => { Assert.Equal("Pass", s); },
+                 s => { Assert.Equal("Me", s); },
+                 s => { Assert.Equal("In", s); });
+        }
+
         private class TestContext : DbContext
         {
             protected override void OnConfiguring(DbContextOptionsBuilder options)
                 => options
                     .EnableServiceProviderCaching(false)
                     .UseInMemoryDatabase(nameof(DbContextActivatorTest));
         }
+
+        private class ArgsContext : DbContext
+        {
+            public string[] Args { get; set; }
+
+            public ArgsContext(string[] args)
+            {
+                Args = args;
+            }
+
+            protected override void OnConfiguring(DbContextOptionsBuilder options)
+                => options
+                    .EnableServiceProviderCaching(false)
+                    .UseInMemoryDatabase(nameof(DbContextActivatorTest));
+        }
     }
 }