예제 #1
0
        public async Task When_write_file_text_Then_returns_contetn()
        {
            _validatorsMock.Setup(m => m.FileValidator).Returns(new Mock <IFileValidator>().Object);
            _validatorsMock.Setup(m => m.StringValidator).Returns(new Mock <IStringValidator>().Object);

            await _sut.WriteFileText(FileNewContent, ValidFilePath);

            var contetnt = _fileSystemMock.File.ReadAllText(ValidFilePath);

            Assert.AreEqual(FileNewContent, contetnt);
        }
예제 #2
0
        public async Task Write(TemplateModel model, string outputPath, string oroginalTemplatePath)
        {
            _stringValidator.IsNullOrWhitespace(outputPath, nameof(outputPath));
            _stringValidator.IsNullOrWhitespace(oroginalTemplatePath, nameof(oroginalTemplatePath));
            _objectValidator.IsNull(model, nameof(model));

            var orifinalFileContent = await _diskService.ReadFileText(oroginalTemplatePath);

            //This is stupid version of algorithm, should be improved in the future
            foreach (var keyValue in model.Fields)
            {
                var indexOfKey     = orifinalFileContent.IndexOf(keyValue.Key);
                var indexOfEndLine = orifinalFileContent.IndexOf(Environment.NewLine, indexOfKey);
                if (indexOfEndLine == -1)
                {
                    indexOfEndLine = orifinalFileContent.Length;
                }
                var charactersToCheck     = indexOfEndLine - indexOfKey;
                var indexOfAssign         = orifinalFileContent.IndexOf(AssignChar, indexOfKey, charactersToCheck);
                var indexOffirstCharacter = GetFirstNonWhitespace(orifinalFileContent, indexOfAssign, indexOfEndLine);
                var lengthToReplace       = indexOfEndLine - indexOffirstCharacter;
                var partToReplace         = orifinalFileContent.Substring(indexOffirstCharacter, lengthToReplace);
                orifinalFileContent = orifinalFileContent.Replace(partToReplace, keyValue.Value);
            }

            await _diskService.WriteFileText(orifinalFileContent, outputPath);
        }
        public async Task Encrypt(string sourcePath, string outputPath)
        {
            _stringValidator.IsNullOrWhitespace(sourcePath, nameof(sourcePath));
            _stringValidator.IsNullOrWhitespace(outputPath, nameof(outputPath));
            var entropyPath = GetEntropyFilePath(outputPath);

            _fileValidator.IsExist(sourcePath);
            _fileValidator.IsNotExist(outputPath);
            _fileValidator.IsNotExist(entropyPath);

            var content = await _diskService.ReadFileText(sourcePath);

            var cipher = _pbkdF2Service.Encrypt(content);

            await _diskService.WriteFileText(cipher.cipherText, outputPath);

            await _diskService.WriteFileText(cipher.entropy, entropyPath);
        }