Esempio n. 1
0
        public void DetectModifications(string directoryPath)
        {
            FileMetadataCollection lastRun;

            var lastRunFilePath = Path.Combine(directoryPath, LastRunDataFileName);
            var exists          = File.Exists(LastRunDataFileName);

            if (exists)
            {
                var fileText = File.ReadAllText(lastRunFilePath);
                lastRun = JsonConvert.DeserializeObject <FileMetadataCollection>(fileText);
            }
            else
            {
                lastRun = new FileMetadataCollection();
            }

            var filelist = Directory.EnumerateFiles(directoryPath)
                           .Where(f => !f.EndsWith(LastRunDataFileName))
                           .ToList();

            var delta       = _fileListDiffService.Compare(filelist, lastRun.Files);
            var updated     = _fileListDiffService.Apply(delta, lastRun.Files);
            var updatedJson = JsonConvert.SerializeObject(updated);

            File.WriteAllText(lastRunFilePath, updatedJson);
        }
            public void ModifiedFilesAreIdentified()
            {
                // Arrange

                const string file1             = "File1";
                const string file1Hash         = "File1Hash";
                const string file2             = "File2";
                const string file2ModifiedHash = "File2ModifiedHash";

                var filesInDirectory = new[] { file1, file2 };

                var hashService = Mock.Of <IFileHashService>(s =>
                                                             s.ComputeHash(file1) == file1Hash &&
                                                             s.ComputeHash(file2) == file2ModifiedHash);

                var lastRun = new FileMetadataCollection
                {
                    Files = new List <FileMetadata>
                    {
                        new FileMetadata
                        {
                            Hash = file1Hash,
                            Name = file1
                        },
                        new FileMetadata
                        {
                            Hash = "File2Hash",
                            Name = file2
                        }
                    }
                };

                var diff = new FileListDiffService(
                    hashService,
                    Mock.Of <ITimeProvider>());

                // Act

                var result = diff.Compare(filesInDirectory, lastRun.Files);

                // Assert

                Assert.IsEmpty(result.Added);
                Assert.AreEqual(1, result.Modified.Count);
                Assert.AreEqual(file2ModifiedHash, result.Modified[0].Hash);
                Assert.AreEqual(file2, result.Modified[0].Name);
                Assert.IsEmpty(result.Removed);
            }
        public FileMetadataCollection Apply(DiffResult delta, IList <FileMetadata> target)
        {
            var metadataList = new List <FileMetadata>();

            foreach (var metadata in target)
            {
                var add = !delta.Removed.Contains(metadata.Name);

                if (add)
                {
                    var modified = delta.Modified.SingleOrDefault(m =>
                                                                  m.Name == metadata.Name);

                    var hash = modified == null
                        ? metadata.Hash
                        : modified.Hash;

                    metadataList.Add(new FileMetadata
                    {
                        Hash = hash,
                        Name = metadata.Name
                    });
                }
            }

            foreach (var metadata in delta.Added)
            {
                metadataList.Add(new FileMetadata
                {
                    Hash = metadata.Hash,
                    Name = metadata.Name
                });
            }

            var collection = new FileMetadataCollection
            {
                Files       = metadataList.OrderBy(m => m.Name).ToList(),
                LastUpdated = _timeProvider.UtcNow
            };

            return(collection);
        }
            public void RemovedFilesAreIdentified()
            {
                // Arrange

                const string file1 = "File1";
                const string file2 = "File2";

                var filesInDirectory = new[] { file1 };

                var lastRun = new FileMetadataCollection
                {
                    Files = new List <FileMetadata>
                    {
                        new FileMetadata {
                            Name = file1
                        },
                        new FileMetadata {
                            Name = file2
                        }
                    }
                };

                var diff = new FileListDiffService(
                    Mock.Of <IFileHashService>(),
                    Mock.Of <ITimeProvider>());

                // Act

                var result = diff.Compare(filesInDirectory, lastRun.Files);

                // Assert

                Assert.IsEmpty(result.Added);
                Assert.IsEmpty(result.Modified);
                Assert.AreEqual(1, result.Removed.Count);
                Assert.AreEqual(file2, result.Removed[0]);
            }