Пример #1
0
        public void GithubHookConsumer_NothingInDb_WhenHandlingBadHook()
        {
            ISalesHandlerFactory fileHandlerFactory = new TestGithubSalesHandlerFactory(DependencyContainer.Container);
            IHookConsumer        hookConsumer       = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
            {
                new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
                new ParameterOverride("githubRepoToken", Token),
                new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
            });

            using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
            {
                lock (lockObject)
                {
                    int customersCount   = unitOfWork.Customers.Get().Count();
                    int productsCount    = unitOfWork.Products.Get().Count();
                    int sourceFilesCount = unitOfWork.SourceFiles.Get().Count();
                    int salesCount       = unitOfWork.Sales.Get().Count();
                    int errorsCount      = unitOfWork.ErrorFiles.Get().Count();

                    hookConsumer.ConsumeHookAsync("../../Data/bad_hook1.json").GetAwaiter().GetResult();

                    int customersCountAfter   = unitOfWork.Customers.Get().Count();
                    int productsCountAfter    = unitOfWork.Products.Get().Count();
                    int sourceFilesCountAfter = unitOfWork.SourceFiles.Get().Count();
                    int salesCountAfter       = unitOfWork.Sales.Get().Count();
                    int errorsCountAfter      = unitOfWork.ErrorFiles.Get().Count();
                    Assert.AreEqual(customersCount, customersCountAfter);
                    Assert.AreEqual(productsCount, productsCountAfter);
                    Assert.AreEqual(sourceFilesCount, sourceFilesCountAfter);
                    Assert.AreEqual(salesCount, salesCountAfter);
                    Assert.AreEqual(errorsCount, errorsCountAfter);
                }
            }
        }
        public async Task <IActionResult> RenameFile()
        {
            try
            {
                FileRenameDto fileRenameDto = await requestService.GetRequestBody <FileRenameDto>(Request)
                                              .ConfigureAwait(false);

                var(result, errorMsg) = new FileNameValidator(fileRenameDto.FileName).Validate();
                if (!result)
                {
                    return(new BadSentRequest <string>(errorMsg));
                }

                await fileService.RenameFileAsync(fileRenameDto.FolderID, fileRenameDto.FileName)
                .ConfigureAwait(false);

                return(new Ok());
            }
            catch (ArgumentException)
            {
                return(new BadSentRequest <string>("Such file does not exist"));
            }
            catch (DatabaseException ex)
            {
                return(new InternalServerError(ex.Message));
            }
            catch (Exception ex)
            {
                exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
                return(new InternalServerError());
            }
        }
		public void ReturnSuccessForValidFile()
		{
			Validator validator = new FileNameValidator();
			ValidationResults validationResults = validator.Validate("class.cs");

			Assert.IsTrue(validationResults.IsValid);
			Assert.AreEqual(0, NumberOfErrors(validationResults));
		}
		public void ReturnFailureForFileTooLong()
		{
			Validator validator = new FileNameValidator();
			ValidationResults validationResults = validator.Validate(new String('a',111));

			Assert.IsFalse(validationResults.IsValid);
			Assert.AreEqual(1, NumberOfErrors(validationResults));
		}
Пример #5
0
        public void ReturnFailureForFileTooLong()
        {
            Validator         validator         = new FileNameValidator();
            ValidationResults validationResults = validator.Validate(new String('a', 111));

            Assert.IsFalse(validationResults.IsValid);
            Assert.AreEqual(1, NumberOfErrors(validationResults));
        }
Пример #6
0
        public void ReturnFailureForFileWithInvalidCharacters()
        {
            Validator         validator         = new FileNameValidator();
            ValidationResults validationResults = validator.Validate("?class.cs");

            Assert.IsFalse(validationResults.IsValid);
            Assert.AreEqual(1, NumberOfErrors(validationResults));
        }
		public void ReturnFailureForEmptyFile()
		{
			Validator validator = new FileNameValidator();
			ValidationResults validationResults = validator.Validate(string.Empty);

			Assert.IsFalse(validationResults.IsValid);
			Assert.AreEqual(2, NumberOfErrors(validationResults));
		}
		public void ReturnFailureForFileWithInvalidCharacters()
		{
			Validator validator = new FileNameValidator();
			ValidationResults validationResults = validator.Validate("?class.cs");

			Assert.IsFalse(validationResults.IsValid);
			Assert.AreEqual(1, NumberOfErrors(validationResults));
		}
Пример #9
0
        public void ReturnSuccessForValidFile()
        {
            Validator         validator         = new FileNameValidator();
            ValidationResults validationResults = validator.Validate("class.cs");

            Assert.IsTrue(validationResults.IsValid);
            Assert.AreEqual(0, NumberOfErrors(validationResults));
        }
Пример #10
0
        public void ReturnFailureForFileWithReservedSystemWords()
        {
            Validator         validator         = new FileNameValidator();
            ValidationResults validationResults = validator.Validate("PRN");

            Assert.IsFalse(validationResults.IsValid);
            Assert.AreEqual(1, NumberOfErrors(validationResults));
        }
Пример #11
0
        public void ReturnFailureForEmptyFile()
        {
            Validator         validator         = new FileNameValidator();
            ValidationResults validationResults = validator.Validate(string.Empty);

            Assert.IsFalse(validationResults.IsValid);
            Assert.AreEqual(2, NumberOfErrors(validationResults));
        }
		public void ReturnFailureForFileWithReservedSystemWords()
		{
			Validator validator = new FileNameValidator();
			ValidationResults validationResults = validator.Validate("PRN");

			Assert.IsFalse(validationResults.IsValid);
			Assert.AreEqual(1, NumberOfErrors(validationResults));
		}
Пример #13
0
        public void FileNameValidation_Correct()
        {
            foreach (var entry in fileNamesSource)
            {
                var validationResult = FileNameValidator.Validate(entry.Key);

                Assert.AreEqual(entry.Value, validationResult);
            }
        }
Пример #14
0
        CustomRepoMod[] GetMods(IEnumerable <Mod> networkMods)
        {
            var network = GetNetwork();

            return(Config.Mods
                   // TODO: Validate names on import and dont even save them
                   .Where(x => FileNameValidator.IsValidName(x.Key))
                   .Select(x => x.Value.ToMod(x.Key, network, networkMods))
                   .ToArray());
        }
        public void Validate_RecognizesNotExistingFolderAsValid()
        {
            var tempDir = Path.GetFullPath(@".\temp\");

            var validator = new FileNameValidator(tempDir);

            var result = validator.Validate("newfolder");

            Assert.True(result.IsValid);
            Assert.True(result.Errors.Count == 0);
        }
Пример #16
0
        public void NameValidatorCreateTest()
        {
            var tested          = new FileNameValidator();
            var expectedRegex   = new Regex($"[{Regex.Escape(new string(Path.GetInvalidFileNameChars()))}]");
            var testString      = new string(Path.GetInvalidFileNameChars());
            var expectedMatches = expectedRegex.Matches(testString);
            var receivedMatches = new Regex(tested.InvalidCharsRegexString).Matches(testString);
            var expected        = expectedMatches[0];
            var received        = receivedMatches[0];

            Assert.AreEqual(expected.Value, received.Value);
        }
        public void Validate_RecognizesNotExistingFileAsValid()
        {
            var tempDir = Path.GetFullPath(@".\temp\");

            Directory.CreateDirectory(Path.Combine(Environment.CurrentDirectory, "temp"));

            var validator = new FileNameValidator(tempDir);

            var result = validator.Validate("newfile");

            Assert.True(result.IsValid);
            Assert.True(result.Errors.Count == 0);
        }
Пример #18
0
        public void NameValidatorValueNameTest()
        {
            var culture = System.Globalization.CultureInfo.GetCultureInfoByIetfLanguageTag("EN");
            var tested  = new FileNameValidator();
            var result  = tested.Validate("qwertyuiop|", culture);

            Assert.IsFalse(result.IsValid);
            Assert.IsTrue(result.ErrorContent.ToString().Contains(tested.ValueName));
            tested.ValueName = "custom value name";
            result           = tested.Validate("qwertyuiop|", culture);
            Assert.IsFalse(result.IsValid);
            Assert.IsTrue(result.ErrorContent.ToString().Contains("custom value name"));
        }
Пример #19
0
        public void NameValidatorValidateTestInvariantCulture2()
        {
            var invalid = new string(Path.GetInvalidFileNameChars());
            var culture = System.Globalization.CultureInfo.InvariantCulture;
            var tested  = new FileNameValidator();
            var result  = tested.Validate("qwertyuiop|", culture);

            Assert.IsFalse(result.IsValid);
            result = tested.Validate("abc?2 ", culture);
            Assert.IsFalse(result.IsValid);
            result = tested.Validate("%21313!weq  ", culture);
            Assert.IsTrue(result.IsValid);
        }
Пример #20
0
        public void GithubHookConsumer_HandlingSameHookInParallelThreads_EachFileSavedOnlyOnce()
        {
            ISalesHandlerFactory fileHandlerFactory = new TestGithubSalesHandlerFactory(DependencyContainer.Container);
            IHookConsumer        hookConsumer       = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
            {
                new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
                new ParameterOverride("githubRepoToken", Token),
                new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
            });
            IHookConsumer hookConsumer2 = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
            {
                new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
                new ParameterOverride("githubRepoToken", Token),
                new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
            });

            using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
            {
                lock (lockObject)
                {
                    unitOfWork.Customers.Delete(x => true);
                    unitOfWork.Products.Delete(x => true);
                    unitOfWork.SourceFiles.Delete(x => true);
                    unitOfWork.Sales.Delete(x => true);
                    unitOfWork.ErrorFiles.Delete(x => true);
                    unitOfWork.SaveChanges();
                    string hookJson = File.ReadAllText("../../Data/hook1.json");

                    var task1 = hookConsumer.ConsumeHookAsync(hookJson);
                    var task2 = hookConsumer2.ConsumeHookAsync(hookJson);
                    Task.WaitAll(task1, task2);

                    int customersCountAfter   = unitOfWork.Customers.Get().Count();
                    int productsCountAfter    = unitOfWork.Products.Get().Count();
                    int sourceFilesCountAfter = unitOfWork.SourceFiles.Get().Count();
                    int salesCountAfter       = unitOfWork.Sales.Get().Count();
                    int errorsCountAfter      = unitOfWork.ErrorFiles.Get().Count();
                    Assert.AreEqual(5, customersCountAfter);
                    Assert.AreEqual(4, productsCountAfter);
                    Assert.AreEqual(2, sourceFilesCountAfter);
                    Assert.AreEqual(10, salesCountAfter);
                    Assert.IsTrue(errorsCountAfter >= 2);
                }
            }
        }
Пример #21
0
        public void NameValidatorValidateTestInvariantCulture()
        {
            var culture = System.Globalization.CultureInfo.InvariantCulture;
            var tested  = new FileNameValidator();
            var result  = tested.Validate(null, culture);

            Assert.IsFalse(result.IsValid);
            result = tested.Validate("", culture);
            Assert.IsFalse(result.IsValid);
            result = tested.Validate(" ", culture);
            Assert.IsFalse(result.IsValid);
            result = tested.Validate("      ", culture);
            Assert.IsFalse(result.IsValid);
            result = tested.Validate("\t\t\t", culture);
            Assert.IsFalse(result.IsValid);
            result = tested.Validate("sgfyiwegfiweg hfwuiegfi  ywegfygiw   gefoyweoryu123675887989091823", culture);
            Assert.IsTrue(result.IsValid);
        }
        public void Validate_RecognizesExistingFileAsInvalid()
        {
            var tempDir = Path.GetFullPath(@".\temp\");

            Directory.CreateDirectory(Path.Combine(Environment.CurrentDirectory, "temp"));

            using (File.Create(Path.Combine(Environment.CurrentDirectory, "temp\\testfile.txt")))
            {
                var validator = new FileNameValidator(tempDir);

                var result = validator.Validate("testfile");

                Assert.False(result.IsValid);
                Assert.True(result.Errors.Count == 1);
                Assert.Equal(ValidationErrorType.AlreadyExists, result.Errors.FirstOrDefault()?.ErrorType);
                Assert.Equal(nameof(FileNameValidator), result.Errors.FirstOrDefault()?.ValidatorName);
            }

            Directory.Delete(tempDir, true);
        }
        public async Task <IActionResult> CreateNewFile()
        {
            try
            {
                ObjectId userID = ObjectId.Parse(tokenService.GetTokenClaim(requestService.GetToken(Request), "ID"));

                NewFileDto newFile = await requestService.GetRequestBody <NewFileDto>(Request)
                                     .ConfigureAwait(false);

                var(result, errorMessage) = new FileNameValidator(newFile.FileName).Validate();
                if (!result)
                {
                    return(new BadSentRequest <string>(errorMessage));
                }

                var createdFileID = await fileService.CreateNewFileAsync(userID, newFile.ParentFolderObjectId, newFile.FileName)
                                    .ConfigureAwait(false);

                var file = await fileService.GetFileAsync(createdFileID).ConfigureAwait(false);

                file.DocumentID = await SendCreationRequestToDocumentsAPI(createdFileID, userID,
                                                                          file.FileName, DocumentType.UserOnly).ConfigureAwait(false);

                await fileService.UpdateAsync(file);

                return(new Ok());
            }
            catch (DatabaseException ex)
            {
                return(new InternalServerError(ex.Message));
            }
            catch (Exception ex)
            {
                exceptionLogger.Log(new ApplicationError(ex), LogLevel.Error, logConfiguration);
                return(new InternalServerError());
            }
        }
Пример #24
0
        public void GithubHookConsumer_DbHasCorrectData_WhenHandlingGoodHook()
        {
            ISalesHandlerFactory fileHandlerFactory = new TestGithubSalesHandlerFactory(DependencyContainer.Container);
            IHookConsumer        hookConsumer       = DependencyContainer.Container.Resolve <IHookConsumer>(new ResolverOverride[]
            {
                new ParameterOverride(typeof(ISalesHandlerFactory), fileHandlerFactory),
                new ParameterOverride("githubRepoToken", Token),
                new ParameterOverride("hookParser", new GithubHookParser(f => FileNameValidator.Validate(f)))
            });

            using (ISalesUnitOfWork unitOfWork = DependencyContainer.Container.Resolve <ISalesUnitOfWork>())
            {
                lock (lockObject)
                {
                    unitOfWork.Customers.Delete(x => true);
                    unitOfWork.Products.Delete(x => true);
                    unitOfWork.SourceFiles.Delete(x => true);
                    unitOfWork.Sales.Delete(x => true);
                    unitOfWork.ErrorFiles.Delete(x => true);
                    unitOfWork.SaveChanges();
                    string hookJson = File.ReadAllText("../../Data/hook1.json");

                    hookConsumer.ConsumeHookAsync(hookJson).GetAwaiter().GetResult();

                    int customersCountAfter   = unitOfWork.Customers.Get().Count();
                    int productsCountAfter    = unitOfWork.Products.Get().Count();
                    int sourceFilesCountAfter = unitOfWork.SourceFiles.Get().Count();
                    int salesCountAfter       = unitOfWork.Sales.Get().Count();
                    int errorsCountAfter      = unitOfWork.ErrorFiles.Get().Count();
                    Assert.AreEqual(5, customersCountAfter);
                    Assert.AreEqual(4, productsCountAfter);
                    Assert.AreEqual(2, sourceFilesCountAfter);
                    Assert.AreEqual(10, salesCountAfter);
                    Assert.AreEqual(2, errorsCountAfter);
                }
            }
        }
Пример #25
0
        public HookConsumerTestClass(string token)
        {
            ISalesHandlerFactory handlerFactory = new FileHandlerFactoryTestClass();

            hookConsumer = new HookConsumer(handlerFactory, token, new HookParserTestClass(fileName => FileNameValidator.Validate(fileName)));
        }
Пример #26
0
 public static string ValidMissionName(string x) => FileNameValidator.ReplaceInvalidCharacters(x.Replace("%20", " "));
Пример #27
0
 private static void CreateRegistrations()
 {
     container.RegisterFactory <GithubHookParser>(cnt => new GithubHookParser(fileName => FileNameValidator.Validate(fileName)));
     container.RegisterType <ISalesUnitOfWork, SalesDbUnitOfWork>();
     container.RegisterType <ISalesDataManager, SaleDbDataManager>();
     container.RegisterType <SalesHandlerBase, GithubSalesHandler>();
     container.RegisterType <ISaleDataSource, GithubSaleDataSource>();
     container.RegisterType <ISalesHandlerFactory, SalesHandlerFactory>(Invoke.Constructor(Container));
 }
Пример #28
0
        /// <summary>
        /// Registers the type mappings with the Unity container.
        /// </summary>
        /// <param name="container">The unity container to configure.</param>
        /// <remarks>
        /// There is no need to register concrete types such as controllers or
        /// API controllers (unless you want to change the defaults), as Unity
        /// allows resolving a concrete type even if it was not previously
        /// registered.
        /// </remarks>
        public static void RegisterTypes(IUnityContainer container)
        {
            // NOTE: To load from web.config uncomment the line below.
            // Make sure to add a Unity.Configuration to the using statements.
            // container.LoadConfiguration();

            // TODO: Register your type's mappings here.
            // container.RegisterType<IProductRepository, ProductRepository>();

            string token = ConfigurationManager.AppSettings["token"];

            container.RegisterFactory <GithubHookParser>(cnt => new GithubHookParser(fileName => FileNameValidator.Validate(fileName)));
            container.RegisterType <ISalesUnitOfWork, SalesDbUnitOfWork>();
            container.RegisterType <ISalesDataManager, SaleDbDataManager>();
            container.RegisterType <SalesHandlerBase, GithubSalesHandler>();
            container.RegisterType <ISaleDataSource, GithubSaleDataSource>();
            container.RegisterType <ISalesHandlerFactory, SalesHandlerFactory>();
            container.RegisterType <IHookConsumer, GithubHookConsumer>(Invoke.Constructor(container.Resolve <ISalesHandlerFactory>(), token, container.Resolve <GithubHookParser>()));
        }
Пример #29
0
        public static LocalMod FromStringIfValid(string modPath, ISupportModding game)
        {
            if (!(!string.IsNullOrWhiteSpace(modPath)))
            {
                throw new ArgumentNullException("!string.IsNullOrWhiteSpace(modPath)");
            }
            if (game == null)
            {
                throw new ArgumentNullException(nameof(game));
            }

            if (modPath.IsValidAbsoluteFilePath())
            {
                var filePath = modPath.ToAbsoluteFilePath();
                return(CreateLocalMod(filePath.FileName, filePath.ParentDirectoryPath, game));
            }

            if (modPath.IsValidAbsoluteDirectoryPath())
            {
                var dirPath = modPath.ToAbsoluteDirectoryPath();
                return(CreateLocalMod(dirPath.DirectoryName, dirPath.ParentDirectoryPath, game));
            }

            if (!FileNameValidator.IsValidName(modPath))
            {
                return(null);
            }

            // TODO: Horrible non-determinism; is it a file, is it a folder, is it located in the game or mod dir?
            var modPaths = game.ModPaths;

            if (modPaths.IsValid)
            {
                try {
                    if (modPaths.Path.GetChildDirectoryWithName(modPath).Exists)
                    {
                        return(CreateLocalMod(modPath, modPaths.Path, game));
                    }
                } catch (Exception) {}
                try {
                    if (modPaths.Path.GetChildFileWithName(modPath).Exists)
                    {
                        return(CreateLocalMod(modPath, modPaths.Path, game));
                    }
                } catch (Exception) {}
            }

            var installedState = game.InstalledState;

            if (installedState.IsInstalled)
            {
                try {
                    if (installedState.Directory.GetChildDirectoryWithName(modPath).Exists)
                    {
                        return(CreateLocalMod(modPath, installedState.Directory, game));
                    }
                } catch (Exception) {}
                try {
                    if (installedState.Directory.GetChildFileWithName(modPath).Exists)
                    {
                        return(CreateLocalMod(modPath, installedState.Directory, game));
                    }
                } catch (Exception) {}
            }

            return(CreateLocalMod(modPath, null, game));
        }