public async Task Create_bigger_bucket_creates_a_new_Bucket_bigger_than_supplied_bucketAsync()
        {
            //Arrange
            var storylist = new Mock <IStorylist>();

            storylist
            .SetupGet(fake => fake.DataIsready)
            .Returns(true);

            var bucketReader  = new Mock <IBucketReader>();
            var linkedBuckets = new Mock <ILinkedSyncableBuckets>();

            bucketReader
            .Setup(fake => fake.ReadLinkedBucketsAsync())
            .ReturnsAsync(linkedBuckets.Object);

            var vm = new SortingBucketsViewModel(storylist.Object, bucketReader.Object);

            await vm.OnInitializedAsync();

            var bucket = new SyncableBucket {
                Id = 278
            };

            //Act
            await vm.OnCreateBiggerBucket(bucket);

            //Assert
            linkedBuckets.Verify(mock => mock.CreateEmptyBiggerThan(bucket), Times.Once);
        }
        public async Task OnClickCreateSmallestBucket_creates_a_new_bucket_that_is_not_bigger_than_any_bucket()
        {
            //Arrange
            var storylist = new Mock <IStorylist>();

            storylist
            .SetupGet(fake => fake.DataIsready)
            .Returns(true);

            var bucketReader  = new Mock <IBucketReader>();
            var linkedBuckets = new Mock <ILinkedSyncableBuckets>();

            bucketReader
            .Setup(fake => fake.ReadLinkedBucketsAsync())
            .ReturnsAsync(linkedBuckets.Object);

            var vm = new SortingBucketsViewModel(storylist.Object, bucketReader.Object);
            await vm.OnInitializedAsync();

            //Act
            await vm.OnClickCreateSmallestBucket();

            //Assert
            linkedBuckets.Verify(mock => mock.CreateEmptyBiggerThan(null), Times.Once);
        }
        public void BucketsHidden_until_Buckets_data_has_been_loaded()
        {
            //Arrange
            var storylist = new Mock <IStorylist>();

            storylist
            .SetupGet(fake => fake.DataIsready)
            .Returns(true);

            var bucketTcs    = new TaskCompletionSource <ILinkedSyncableBuckets>();
            var bucketReader = new Mock <IBucketReader>();

            bucketReader
            .Setup(fake => fake.ReadLinkedBucketsAsync())
            .Returns(bucketTcs.Task);

            var vm = new SortingBucketsViewModel(storylist.Object, bucketReader.Object);

            //Act
            var initialized = vm.OnInitializedAsync();

            Thread.Sleep(0); //make sure the code gets a chance to run

            //Assert
            Assert.IsTrue(vm.BucketsHidden);
            bucketTcs.SetResult(new Mock <ILinkedSyncableBuckets>().Object);
            Thread.Sleep(0); //make sure the code gets a chance to run
            Assert.IsFalse(vm.BucketsHidden);
            initialized.Wait();
        }
        public void Read_buckets_populates_Buckets_property()
        {
            //Arrange
            var storylist = new Mock <IStorylist>();

            var bucket1 = new Mock <SyncableBucket>().Object;
            var buckets = new List <SyncableBucket>
            {
                bucket1,
                new Mock <SyncableBucket>().Object,
                new Mock <SyncableBucket>().Object
            };
            var linkedBuckets = new Mock <ILinkedSyncableBuckets>();

            linkedBuckets
            .Setup(fake => fake.GetEnumerator())
            .Returns(() => buckets.GetEnumerator());

            var bucketReader = new Mock <IBucketReader>();

            bucketReader
            .Setup(fake => fake.ReadLinkedBucketsAsync())
            .ReturnsAsync(linkedBuckets.Object);

            var vm = new SortingBucketsViewModel(storylist.Object, bucketReader.Object);

            //Act
            vm.OnInitializedAsync().Wait();

            //Assert
            Assert.AreEqual(buckets.Count(), vm.Buckets.Count());
            Assert.AreEqual(bucket1, vm.Buckets.First());
        }
        public void Read_buckets_OnInitializedAsync()
        {
            //Arrange
            var storylist = new Mock <IStorylist>();

            var bucketReader = new Mock <IBucketReader>();

            bucketReader
            .Setup(fake => fake.ReadLinkedBucketsAsync())
            .ReturnsAsync(new Mock <ILinkedSyncableBuckets>().Object);

            var vm = new SortingBucketsViewModel(storylist.Object, bucketReader.Object);

            //Act
            vm.OnInitializedAsync().Wait();

            //Assert
            bucketReader.Verify(mock => mock.ReadLinkedBucketsAsync(), Times.Once);
        }
        public async Task When_DataIsReady_hide_loader()
        {
            //Arrange
            var storylist = new Mock <IStorylist>();

            storylist
            .SetupGet(fake => fake.DataIsready)
            .Returns(true);

            var bucketReader = new Mock <IBucketReader>();

            bucketReader
            .Setup(fake => fake.ReadLinkedBucketsAsync())
            .ReturnsAsync(new Mock <ILinkedSyncableBuckets>().Object);

            var vm = new SortingBucketsViewModel(storylist.Object, bucketReader.Object);

            //Act
            await vm.OnInitializedAsync();

            //Assert
            Assert.IsTrue(vm.LoaderHidden);
        }