public IInputProvider Generate(InputProviderTypes inputProviderType)
        {
            if (!Enum.IsDefined(typeof(InputProviderTypes), inputProviderType))
            {
                throw new InputProviderNotValidException(inputProviderType.ToString());
            }

            IInputProvider inputProvider;

            switch (inputProviderType)
            {
            case InputProviderTypes.Console:
                inputProvider = _inputProviders.FirstOrDefault(p => p is IConsoleInputProvider);
                break;

            case InputProviderTypes.File:
                inputProvider = _inputProviders.FirstOrDefault(p => p is IFileInputProvider);
                break;

            default:
                throw new DevelopmentException($"There is uncovered switch-case state [{inputProviderType.ToString()}]");
            }

            if (inputProvider == null)
            {
                throw new DevelopmentException($"There is no predefined {nameof(IInputProvider)} for {inputProviderType}");
            }

            return(inputProvider);
        }
Esempio n. 2
0
        public IInputProvider Generate(InputProviderTypes inputProviderType)
        {
            if (!Enum.IsDefined(typeof(InputProviderTypes), inputProviderType))
            {
                throw new NotValidException($"Input provider type is not valid ({inputProviderType.ToString()})", null);
            }

            var inputProvider = inputProviderType switch
            {
                InputProviderTypes.Console => _inputProviders.FirstOrDefault(p => p is IConsoleInputProvider),
                _ => throw new Exception($"Input provider type not found [{inputProviderType.ToString()}]")
            };

            if (inputProvider == null)
            {
                throw new Exception($"No predefined {nameof(IInputProvider)} for {inputProviderType}");
            }

            return(inputProvider);
        }
    }
Esempio n. 3
0
        private static void Main()
        {
            AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionHandler;

            IServiceCollection serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton <IFileProcessor, BasicFileProcessor>();
            serviceCollection.AddTransient <IStreamReader, BasicStreamReader>();
            serviceCollection.AddSingleton <IVehicleFactory, VehicleFactory>();
            serviceCollection.AddImplementedTypes <IVehicleBuilder>(ServiceLifetime.Singleton, typeof(IVehicleBuilder).Assembly);
            serviceCollection.AddSingleton <IVehicleContextFactory, VehicleContextFactory>();
            serviceCollection.AddSingleton <ISurfaceBuilderFactory, SurfaceBuilderFactory>();
            serviceCollection.AddImplementedTypes <ISurfaceBuilder>(ServiceLifetime.Singleton, typeof(ISurfaceBuilder).Assembly);
            serviceCollection.AddTransient <IInputProviderFactory, InputProviderFactory>();
            serviceCollection.AddImplementedTypes <IInputProvider>(ServiceLifetime.Transient, typeof(IInputProvider).Assembly);
            serviceCollection.AddSingleton <IVehicleActionProvider, BulkStringVehicleActionProvider>();

            using (ServiceProvider serviceProvider = serviceCollection.BuildServiceProvider())
            {
                InputProviderTypes inputProviderType = SelectInputProviderType();

                var            inputProviderFactory = serviceProvider.GetRequiredService <IInputProviderFactory>();
                IInputProvider inputProvider        = inputProviderFactory.Generate(inputProviderType);

                var surfaceBuilderFactory = serviceProvider.GetRequiredService <ISurfaceBuilderFactory>();

                var vehicleFactory = serviceProvider.GetRequiredService <IVehicleFactory>();

                var vehicleContextFactory = serviceProvider.GetRequiredService <IVehicleContextFactory>();

                var vehicleActionProvider = serviceProvider.GetRequiredService <IVehicleActionProvider>();

                string inputProviderArgument = GetInputProviderArgument(inputProvider);
                Input  input = inputProvider.Provide(inputProviderArgument);

                ISurfaceBuilder surfaceBuilder = surfaceBuilderFactory.Generate(typeof(Plateau));
                Surface         surface        = surfaceBuilder.Build(input.SurfaceParameter);

                foreach ((string vehicleParameter, string moveCommandParameter) in input.VehicleAndCommandsParameterList)
                {
                    IVehicleContext vehicleContext;
                    Vehicle         movable = vehicleFactory.Generate(VehicleTypes.Rover, vehicleParameter);
                    try
                    {
                        vehicleContext = vehicleContextFactory.Generate(surface, movable);
                    }
                    catch (VehicleDeployException)
                    {
                        Console.WriteLine($"Rover could not land on surface");
                        continue;
                    }

                    IEnumerable <VehicleActions> vehicleActions = vehicleActionProvider.Provide(moveCommandParameter);

                    try
                    {
                        foreach (VehicleActions action in vehicleActions)
                        {
                            vehicleContext.Move(action);
                        }

                        Console.WriteLine(vehicleContext.Vehicle.ToString());
                    }
                    catch (VehicleConnectionLostException)
                    {
                        Console.WriteLine($"Connection lost. Rover is not on surface anymore");
                    }
                }

                Exit(0);
            }
        }
        public void WhenParametersAreValid_And_InputProviderIsFound__ResponseShouldNotBeNull(InputProviderTypes inputProviderType, Type expectedType)
        {
            var sut = new InputProviderFactory(new List <IInputProvider>
            {
                new Mock <IFileInputProvider>().Object,
                new Mock <IConsoleInputProvider>().Object
            });

            IInputProvider inputProvider = sut.Generate(inputProviderType);

            Assert.NotNull(inputProvider);
            Assert.True(expectedType.IsInstanceOfType(inputProvider));
        }