Example #1
0
        public void MergeRaisesSynchronizedEvent()
        {
            MockHost.MockJson();
            MockHost.JsonFactory.Setup(f => f.Create <SynchronizedData>())
            .Returns(new SynchronizedData());

            TrelloConfiguration.RefreshThrottle = TimeSpan.FromDays(1);

            var counter = 0;

            var target = new SynchronizedObject
            {
                NewData = new SynchronizedData {
                    Test = "one"
                }
            };

            target.PublicSynchronized += properties => counter++;

            target.Merge(new SynchronizedData {
                Test = "two"
            });

            counter.Should().Be(1);
            target.Data.Test.Should().Be("two");
        }
Example #2
0
        public async Task NoRefreshThrottleAllowsCalls()
        {
            var currentThrottle = TrelloConfiguration.RefreshThrottle;

            try
            {
                MockHost.MockJson();
                MockHost.JsonFactory.Setup(f => f.Create <SynchronizedData>())
                .Returns(new SynchronizedData());

                TrelloConfiguration.RefreshThrottle = TimeSpan.Zero;

                var target = new SynchronizedObject();

                await target.Synchronize(false, CancellationToken.None);

                await target.Synchronize(false, CancellationToken.None);

                target.RetrievalCount.Should().Be(2);
            }
            finally
            {
                TrelloConfiguration.RefreshThrottle = currentThrottle;
            }
        }
Example #3
0
        public async Task ForcedRefreshOverridesThrottle()
        {
            var currentThrottle = TrelloConfiguration.RefreshThrottle;

            try
            {
                MockHost.MockJson();
                MockHost.JsonFactory.Setup(f => f.Create <SynchronizedData>())
                .Returns(new SynchronizedData());

                TrelloConfiguration.RefreshThrottle = TimeSpan.FromDays(1);

                var target = new SynchronizedObject();

                await target.Synchronize(true, CancellationToken.None);

                await target.Synchronize(true, CancellationToken.None);

                target.RetrievalCount.Should().Be(2);
            }
            finally
            {
                TrelloConfiguration.RefreshThrottle = currentThrottle;
            }
        }
Example #4
0
        public async Task SynchronizeRaisesSynchronizedEvent()
        {
            var currentThrottle = TrelloConfiguration.RefreshThrottle;

            try
            {
                MockHost.MockJson();
                MockHost.JsonFactory.Setup(f => f.Create <SynchronizedData>())
                .Returns(new SynchronizedData());

                TrelloConfiguration.RefreshThrottle = TimeSpan.FromDays(1);

                var counter = 0;

                var target = new SynchronizedObject
                {
                    NewData = new SynchronizedData {
                        Test = "one"
                    }
                };
                target.PublicSynchronized += properties => counter++;

                await target.Synchronize(false, CancellationToken.None);

                counter.Should().Be(1);
            }
            finally
            {
                TrelloConfiguration.RefreshThrottle = currentThrottle;
            }
        }
Example #5
0
            public TestHarness(int taskId = 42)
            {
                MockHost = Mocks.Create <PSHost>();
                MockUI   = Mocks.Create <PSHostUserInterface>(MockBehavior.Loose);

                MockHost
                .SetupGet(h => h.UI)
                .Returns(MockUI.Object);

                TaskHost = new TaskHost(MockHost.Object, new ConsoleState(), taskId);
            }
        /// <summary>
        /// Instantiate and Initialize a new loggingService.
        /// This is used by the test setup method to create
        /// a new logging service before each test.
        /// </summary>
        private void InitializeLoggingService()
        {
            BuildParameters parameters = new BuildParameters();

            parameters.MaxNodeCount = 2;
            MockHost mockHost = new MockHost(parameters);

            IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1);

            logServiceComponent.InitializeComponent(mockHost);
            _initializedService = logServiceComponent as LoggingService;
        }
Example #7
0
        public void GetValueDoesNotRetrieve()
        {
            MockHost.MockJson();
            MockHost.JsonFactory.Setup(f => f.Create <SynchronizedData>())
            .Returns(new SynchronizedData());

            var target = new SynchronizedObject();

            var value = target.GetValue <string>(nameof(SynchronizedData.Test));

            value.Should().Be("default");
            target.RetrievalCount.Should().Be(0);
        }
Example #8
0
        public async Task UnsupportedUpdateSkipsSubmission()
        {
            MockHost.MockJson();
            MockHost.JsonFactory.Setup(f => f.Create <SynchronizedData>())
            .Returns(new SynchronizedData());

            var target = new SynchronizedObject {
                SupportsUpdates = false
            };

            await target.Synchronize(false, CancellationToken.None);

            target.SubmissionCount.Should().Be(0);
        }
Example #9
0
        public async Task SettingDataMergesRequests()
        {
            MockHost.MockJson();
            MockHost.JsonFactory.Setup(f => f.Create <SynchronizedData>())
            .Returns(new SynchronizedData());

            TrelloConfiguration.ChangeSubmissionTime = TimeSpan.FromMilliseconds(100);

            var target = new SynchronizedObject();

            await target.SetValue(nameof(SynchronizedData.Test), "one", CancellationToken.None);

            await target.SetValue(nameof(SynchronizedData.Test), "two", CancellationToken.None);

            await Task.Delay(150);

            target.SubmissionCount.Should().Be(1);
        }
Example #10
0
        private void RunFormTest(Func <MockHost, Task> testDriverAsync)
        {
            UITest.RunForm(
                () =>
            {
                _form = new MockHost(_referenceRepository.Module)
                {
                    Size = new(800, 400)
                };

                _settingsPage      = SettingsPageBase.Create <BuildServerIntegrationSettingsPage>(_form);
                _settingsPage.Dock = DockStyle.Fill;

                _form.Controls.Add(_settingsPage);

                _form.ShowDialog(owner: null);
            },
                testDriverAsync);
        }
        public void InitializeComponent()
        {
            IBuildComponent logServiceComponent = (IBuildComponent)LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1);

            BuildParameters parameters = new BuildParameters();

            parameters.MaxNodeCount          = 4;
            parameters.OnlyLogCriticalEvents = true;

            IBuildComponentHost loggingHost = new MockHost(parameters);

            // Make sure we are in the Instantiated state before initializing
            Assert.Equal(((LoggingService)logServiceComponent).ServiceState, LoggingServiceState.Instantiated);

            logServiceComponent.InitializeComponent(loggingHost);

            // Makesure that the parameters in the host are set in the logging service
            LoggingService service = (LoggingService)logServiceComponent;

            Assert.Equal(service.ServiceState, LoggingServiceState.Initialized);
            Assert.Equal(4, service.MaxCPUCount);
            Assert.True(service.OnlyLogCriticalEvents);
        }
Example #12
0
 public void TearDown()
 {
     MockHost.ResetRest();
 }
Example #13
0
 public void Setup()
 {
     MockHost.MockRest <SynchronizedData>();
     TrelloAuthorization.Default.AppKey = "test";
 }