public SubstitutionsMonitor(IEnumerable <ISubstitutionProvider> providers, ISubstitutionProvider initialSubstitutionProvider = null)
        {
            Substitutions initialSubstitutions = null;

            if (initialSubstitutionProvider != null)
            {
                var task = initialSubstitutionProvider.GetSubstitutionsAsync();
                task.Wait();
                initialSubstitutions = task.Result;
            }

            foreach (var provider in providers)
            {
                provider.OnSubstitutionsUpdated += async(Substitutions substitutions) =>
                {
                    await Task.WhenAll(providers
                                       .Where(p => p != provider)
                                       .Select(p => p.UpdateSubstitutionsAsync(substitutions)));
                };
                if (initialSubstitutions != null && !initialSubstitutionProvider.Equals(provider))
                {
                    provider.UpdateSubstitutionsAsync(initialSubstitutions).Wait();
                }
            }
        }
        public async Task UpdateSubstitutionsAsync(Substitutions substitutions)
        {
            watcher.EnableRaisingEvents = false;
            await this.fileLoader.saveFileAsync(substitutions, this.file);

            watcher.EnableRaisingEvents = true;
        }
예제 #3
0
 public async Task saveFileAsync(Substitutions substitutions, string path)
 {
     Console.WriteLine("Writing JSON");
     var content = JsonSerializer.Serialize(substitutions, new JsonSerializerOptions
     {
         WriteIndented        = true,
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase
     });
     await File.WriteAllTextAsync(path, content);
 }
예제 #4
0
        public async Task saveFileAsync(Substitutions newSubstitutions, string path)
        {
            Console.WriteLine("Writing Mac");

            using (var connection = GetConnection(path))
            {
                await connection.OpenAsync();

                var existingSubstitutions = await loadSubstitutionsFromConnection(connection);

                var addedSubs    = SubstitutionsComparator.FindAddedSubstitutions(existingSubstitutions, newSubstitutions.substitutions);
                var deletedSubs  = SubstitutionsComparator.FindDeletedSubstitutions(existingSubstitutions, newSubstitutions.substitutions);
                var modifiedSubs = SubstitutionsComparator.FindModifiedSubstitutions(existingSubstitutions, newSubstitutions.substitutions);
                addedSubs.ToList().ForEach(async addedSub => await this.addSubstitutionToConnection(connection, addedSub));
                deletedSubs.ToList().ForEach(async deletedSub => await this.removeSubstitutionToConnection(connection, deletedSub));
                modifiedSubs.ToList().ForEach(async modifiedSub => await this.updateSubstitutionToConnection(connection, modifiedSub));
            }
        }
        public void ShouldUpdateSubstitutionsWhenOneUpdates()
        {
            // given
            var provider1     = A.Fake <ISubstitutionProvider>();
            var provider2     = A.Fake <ISubstitutionProvider>();
            var provider3     = A.Fake <ISubstitutionProvider>();
            var monitor       = new SubstitutionsMonitor(new[] { provider1, provider2, provider3 });
            var substitutions = new Substitutions();

            // when
            provider1.OnSubstitutionsUpdated += Raise.FreeForm.With(substitutions);

            // then
            A.CallTo(() => provider2.UpdateSubstitutionsAsync(substitutions))
            .MustHaveHappenedOnceExactly();
            A.CallTo(() => provider3.UpdateSubstitutionsAsync(substitutions))
            .MustHaveHappenedOnceExactly();
            A.CallTo(() => provider1.UpdateSubstitutionsAsync(substitutions))
            .MustNotHaveHappened();
        }
        public void ShouldInitializeSubstitutionsWithMain()
        {
            // given
            var provider1     = A.Fake <ISubstitutionProvider>();
            var provider2     = A.Fake <ISubstitutionProvider>();
            var provider3     = A.Fake <ISubstitutionProvider>();
            var substitutions = new Substitutions();

            A.CallTo(() => provider1.GetSubstitutionsAsync()).ReturnsLazily(() => substitutions);

            // when
            var monitor = new SubstitutionsMonitor(new[] { provider1, provider2, provider3 }, provider1);

            // then
            A.CallTo(() => provider2.UpdateSubstitutionsAsync(substitutions))
            .MustHaveHappenedOnceExactly();
            A.CallTo(() => provider3.UpdateSubstitutionsAsync(substitutions))
            .MustHaveHappenedOnceExactly();
            A.CallTo(() => provider1.UpdateSubstitutionsAsync(substitutions))
            .MustNotHaveHappened();
        }