public void ArchiveTestCaseNotFound()
        {
            repository.Setup(x => x.Find(It.IsAny <string>())).Returns((DownloadItem)null);

            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object, repository.Object);
            var response   = controller.Archive(It.IsAny <string>());

            Assert.AreEqual(404, response.StatusCode);
        }
        public void GetTest(string token, int statusCode)
        {
            repository
            .Setup(x => x.Find(It.IsAny <string>()))
            .Returns(statusCode < 300 ? new DownloadItem() : null);

            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object, repository.Object);
            var response   = controller.Get(token);

            Assert.AreEqual(statusCode, response.StatusCode);
        }
        public void ListTest()
        {
            repository
            .Setup(x => x.FindAllUnarchived())
            .Returns(() => new List <DownloadItem>
            {
                new DownloadItem(),
                new DownloadItem()
            });

            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object, repository.Object);
            var items      = controller.List().Value as IEnumerable <DownloadItem>;

            Assert.AreEqual(2, items.Count());
        }
        public void StartTestTestDuplicateDownload()
        {
            var fileUrl = "ABCD";

            repository.Setup(x => x.FindAllUnarchived())
            .Returns(new List <DownloadItem> {
                new DownloadItem {
                    FileUrl = "ABCD"
                }
            });

            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object, repository.Object);
            var response   = controller.Start(fileUrl);

            Assert.AreEqual(400, response.StatusCode);
        }
        public void StartTestTestFailure(int httpCode, DownloadItemActionError error)
        {
            service.Setup(x => x.StartDownload(It.IsAny <DownloadItem>(), out error)).Returns(false);

            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object,
                                                        repository.Object)
            {
                ControllerContext = new ControllerContext
                {
                    HttpContext = new DefaultHttpContext {
                        User = TestHelper.ItemOwner.MapToClaimPrincipal()
                    }
                }
            };
            var response = controller.Start(It.IsAny <string>());

            Assert.AreEqual(httpCode, response.StatusCode);
        }
        public void StartTestOk()
        {
            var item = new DownloadItem();
            DownloadItemActionError error;

            service.Setup(x => x.StartDownload(item, out error)).Returns(true);
            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object, repository.Object)
            {
                ControllerContext = new ControllerContext
                {
                    HttpContext = new DefaultHttpContext {
                        User = TestHelper.ItemOwner.MapToClaimPrincipal()
                    }
                }
            };
            var response = controller.Start(It.IsAny <string>());

            Assert.AreEqual(201, response.StatusCode);
        }
        public void ArchiveTestCaseUnauthorized()
        {
            var item = new DownloadItem();

            service
            .Setup(x => x.ArchiveDownload(item));

            repository.Setup(x => x.Find(It.IsAny <string>())).Returns(item);

            authorizationService
            .Setup(
                x => x.AuthorizeAsync(
                    It.IsAny <ClaimsPrincipal>(),
                    It.IsAny <DownloadItem>(),
                    DownloadItemPolicies.ArchivePolicy))
            .Returns(Task.FromResult(AuthorizationResult.Failed()));

            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object, repository.Object);

            Assert.Throws <InvalidOperationException>(() => controller.Archive(It.IsAny <string>()));
        }
        public void CancelTestTestOk()
        {
            var item = new DownloadItem();

            service.Setup(x => x.CancelDownload(item));
            repository.Setup(x => x.Find(It.IsAny <string>())).Returns(item);

            authorizationService
            .Setup(
                x => x.AuthorizeAsync(
                    It.IsAny <ClaimsPrincipal>(),
                    It.IsAny <DownloadItem>(),
                    DownloadItemPolicies.CancelPolicy))
            .Returns(Task.FromResult(AuthorizationResult.Success()));

            var controller = new DownloadItemController(logger.Object, service.Object, authorizationService.Object, repository.Object);
            var response   = controller.Cancel(It.IsAny <string>());

            service.Verify(x => x.CancelDownload(item), Times.Once);

            Assert.AreEqual(200, response.StatusCode);
        }