public void Should_Return_File_Successfully()
 {
     RunActionInTransaction(session =>
     {
         var file = CreateFakeFile(session);
         var repository = CreateRepository(session);
         using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
         {
             var loadedFile = service.GetFile(file.Id);
             Assert.IsNotNull(loadedFile);
             Assert.AreEqual(loadedFile.Id, file.Id);
         }
     });
 }
        public void Should_Return_Files_List_Successfully()
        {
            RunActionInTransaction(session =>
            {
                CreateFakeMedias(session);
                var repository = CreateRepository(session);

                using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
                {
                    var request = new GetFilesRequest(itemsCount: 3);
                    var files = service.GetFiles(request);
                    Assert.IsNotNull(files);
                    Assert.GreaterOrEqual(files.Items.Count, 1);
                    Assert.LessOrEqual(files.Items.Count, 3);
                }
            });
        }
        public void Should_Return_Folders_List_Successfully()
        {
            RunActionInTransaction(session =>
            {
                CreateFakeMedias(session);
                var repository = CreateRepository(session);

                using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
                {
                    var request = new GetFoldersRequest(MediaType.Image, itemsCount: 2);
                    var imageFolders = service.GetFolders(request);
                    Assert.IsNotNull(imageFolders);
                    Assert.LessOrEqual(imageFolders.Items.Count, 2);

                    request = new GetFoldersRequest(MediaType.File, itemsCount: 2);
                    var fileFolders = service.GetFolders(request);
                    Assert.IsNotNull(fileFolders);
                    Assert.LessOrEqual(fileFolders.Items.Count, 2);
                }
            });
        }
        public void Should_Return_Images_Folder_Medias_List_Successfully()
        {
            RunActionInTransaction(session =>
            {
                var medias = CreateFakeMedias(session);
                var repository = CreateRepository(session);

                using (var api = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
                {
                    // Images1 folder has 2 images and 2 folders
                    var folder = medias.First( m => m is MediaFolder && m.Title == "Images1");
                    var folderMedias = api.GetFolderMedias(new GetFolderMediasRequest(MediaType.Image, folder.Id));
                    Assert.IsNotNull(folderMedias);
                    Assert.AreEqual(folderMedias.Items.Count, 4);
                    Assert.AreEqual(folderMedias.Items.Count(m => m is MediaImage), 2);
                    Assert.AreEqual(folderMedias.Items.Count(m => m is MediaFolder), 2);
                }
            });
        }
 public void TEST_Should_Return_Ordered_Images_List_Successfully()
 {
     RunActionInTransaction(session =>
     {
         CreateFakeMedias(session);
         var repository = CreateRepository(session);
         using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
         {
             var request = new GetImagesRequest(order: p => p.Title);
             var images = service.GetImages(request);
             Assert.IsNotNull(images);
             Assert.GreaterOrEqual(images.Items.Count, 0);
         }
     });
 }
        public void Should_Return_Root_Image_Folder_Medias_List_Successfully()
        {
            RunActionInTransaction(session =>
            {
                CreateFakeMedias(session, false);
                var repository = CreateRepository(session);
                using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
                {
                    // Root images folder has at least 2 folders and at least 3 files
                    var request = new GetFolderMediasRequest(MediaType.Image, itemsCount: 5);

                    var folderMedias = service.GetFolderMedias(request);
                    Assert.IsNotNull(folderMedias);
                    Assert.AreEqual(folderMedias.Items.Count, 5);
                }
            });
        }
        public void Should_Return_Ordered_Images_List_Successfully()
        {
            RunActionInTransaction(session =>
            {
                var medias = CreateFakeMedias(session);
                var repository = CreateRepository(session);
                using (var service = new MediaManagerApiContext(Container.BeginLifetimeScope(), repository))
                {
                    var folder = medias.First(m => m is MediaFolder && m.Title == "Images1");
                    var request = new GetImagesRequest(p => p.Folder.Id == folder.Id, p => p.Title);
                    request.AddPaging(1, 2);

                    var images = service.GetImages(request);
                    Assert.IsNotNull(images);
                    Assert.AreEqual(images.Items.Count, 1);
                    Assert.AreEqual(images.TotalCount, 2);
                    Assert.AreEqual(images.Items[0].Title, "Image1__2");
                }
            });
        }