public void OnError_RestoreObservableShouldNotify()
        {
            var onErrorWasCalled          = false;
            var done                      = false;
            var recoveryStatusReponseMock = new Mock <IRecoveryStatusResponse>();

            recoveryStatusReponseMock.SetupGet(x => x.IsValid).Returns(false);
            var elastickClientMock = new Mock <IElasticClient>();

            elastickClientMock.Setup(x => x.Restore(It.IsAny <IRestoreRequest>()))
            .Returns(new RestoreResponse());
            elastickClientMock.Setup(x => x.RecoveryStatus(It.IsAny <IRecoveryStatusRequest>()))
            .Returns(recoveryStatusReponseMock.Object);

            var sut = new RestoreObservable(elastickClientMock.Object,
                                            RestoreRequestFixture());

            sut.Subscribe(new RestoreObserver(response => done = true, exception => onErrorWasCalled = done = true, () => done = true));

            while (!done)
            {
                Thread.Sleep(10);
            }

            Assert.AreEqual(true, onErrorWasCalled);
        }
        public void ShouldNotNotifyOnNextWhenDisposed()
        {
            var disposed = false;
            var onNextCalledAfterDispose = false;
            var done = true;
            var elastickClientMock = ElastickClientMock(RecoveryStatusFixture("test", 1, 2));

            var sut = new RestoreObservable(elastickClientMock.Object,
                                            RestoreRequestFixture(), TimeSpan.FromMilliseconds(5));

            Action <IRecoveryStatusResponse> onNext = response =>
            {
                done = true;
                if (disposed)
                {
                    onNextCalledAfterDispose = true;
                }
            };

            using (sut.Subscribe(new RestoreObserver(onNext, exception => done = true, () => done = true)))
            {
                while (!done)
                {
                    Thread.Sleep(10);
                }
            }

            disposed = true;

            Thread.Sleep(100);

            Assert.AreEqual(false, onNextCalledAfterDispose);
        }
		/// <inheritdoc />
		public IObservable<IRecoveryStatusResponse> RestoreObservable(TimeSpan interval, Func<RestoreDescriptor, RestoreDescriptor> restoreSelector = null)
		{
			restoreSelector.ThrowIfNull("restoreSelector");

			var restoreDescriptor = restoreSelector(new RestoreDescriptor());
			var observable = new RestoreObservable(this, restoreDescriptor);
			return observable;
		}
        public void ObserverIsNull_Exception()
        {
            var elastickClientMock = new Mock <IElasticClient>();

            var sut = new RestoreObservable(elastickClientMock.Object, new RestoreRequest("repository", "snapshot"));

            using (sut.Subscribe(null))
            {
            }
        }
        public void ShouldCallRestoreMethodOnce()
        {
            var elastickClientMock = new Mock <IElasticClient>();

            var sut = new RestoreObservable(elastickClientMock.Object, new RestoreRequest("repository", "snapshot"));

            sut.Subscribe(new RestoreObserver());

            elastickClientMock.Verify(x => x
                                      .Restore(
                                          It.Is <IRestoreRequest>(
                                              request =>
                                              request.Repository == "repository" && request.Snapshot == "snapshot" &&
                                              request.RequestParameters.ContainsKey("wait_for_completion") == true &&
                                              request.RequestParameters.GetQueryStringValue <bool>("wait_for_completion") == false)),
                                      Times.Once);
        }
        public void OnCompleted_RestoreObservableShouldNotify()
        {
            var onCompletedWasCalled = false;
            var done = false;
            var elastickClientMock = ElastickClientMock(RecoveryStatusFixture("test", 1, 1));

            var sut = new RestoreObservable(elastickClientMock.Object,
                                            RestoreRequestFixture());

            sut.Subscribe(new RestoreObserver(response => done           = true, exception => done = true,
                                              () => onCompletedWasCalled = done = true));

            while (!done)
            {
                Thread.Sleep(10);
            }

            Assert.AreEqual(true, onCompletedWasCalled);
        }
        public void OnNext_RestoreObservableShouldNotify()
        {
            var onNextWasCalled    = false;
            var done               = false;
            var onNextCounter      = 0;
            var elastickClientMock = ElastickClientMock(RecoveryStatusFixture("test", 1, 2));

            var sut = new RestoreObservable(elastickClientMock.Object,
                                            RestoreRequestFixture(), TimeSpan.FromMilliseconds(200));

            sut.Subscribe(new RestoreObserver(response =>
            {
                onNextCounter++;
                onNextWasCalled = done = true;
            }, exception => done = true, () => done = true));

            while (!done)
            {
                Thread.Sleep(10);
            }

            Assert.AreEqual(true, onNextWasCalled);
            Assert.AreEqual(1, onNextCounter);
        }
		/// <inheritdoc />
		public IObservable<IRecoveryStatusResponse> RestoreObservable(TimeSpan interval, IRestoreRequest restoreRequest)
		{
			restoreRequest.ThrowIfNull("restoreRequest");
			var observable = new RestoreObservable(this, restoreRequest);
			return observable;
		}
		/// <inheritdoc/>
		public IObservable<IRecoveryStatusResponse> RestoreObservable(Name repository, Name snapshot, TimeSpan interval, Func<RestoreDescriptor, IRestoreRequest> selector = null)
		{
			var restoreDescriptor = selector.InvokeOrDefault(new RestoreDescriptor(repository, snapshot));
			var observable = new RestoreObservable(this, restoreDescriptor, interval);
			return observable;
		}
 public void IncorrectTimeInterval_Exception()
 {
     var elastickClientMock = new Mock <IElasticClient>();
     var sut = new RestoreObservable(elastickClientMock.Object, new RestoreRequest("repository", "snapshot"),
                                     TimeSpan.FromMilliseconds(-1));
 }
 public void ClientIsNull_Exception()
 {
     var sut = new RestoreObservable(null, new RestoreRequest("repository", "snapshot"));
 }
        public void RequestIsNull_Exception()
        {
            var elastickClientMock = new Mock <IElasticClient>();

            var sut = new RestoreObservable(elastickClientMock.Object, null);
        }