Beispiel #1
0
        public void BrunchOfDeleteTest()
        {
            //Arragnge
            var uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);

            var encodeInfo = new EncodeInformation()
            {
                DownloadInformation = new DownloadInformation()
                {
                    QueueInformation = new QueueInformation()
                    {
                        VideoMessage = new VideoMessage()
                        {
                            Delete = true
                        }
                    }
                }
            };

            //Act
            var uploadInfo = uploadProcess.ProcessMethod(encodeInfo, new CancellationToken());

            //Assert
            Assert.AreEqual(encodeInfo.DownloadInformation, uploadInfo.DownloadInformation);

            _videoRepository.Verify(m => m.DeleteWatchVideos(It.IsAny <string>(), It.IsAny <string>()), Times.Once());
            _screenshotRepository.Verify(m => m.DeleteScreenshots(It.IsAny <string>(), It.IsAny <string>()), Times.Once());
        }
Beispiel #2
0
        public void UploadExceptionHandlerTest()
        {
            //Arrange
            const string localPath     = "local path";
            var          uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);

            _fileSystem.Setup(m => m.DirectoryExists(localPath)).Returns(true);

            var encodeInfo = new EncodeInformation()
            {
                DownloadInformation = new DownloadInformation()
                {
                    LocalPath        = localPath,
                    QueueInformation = new QueueInformation()
                    {
                        VideoMessage = new VideoMessage()
                    }
                }
            };

            //Act
            uploadProcess.ExceptionHandler(new Exception(), encodeInfo);

            //Asert
            _videoRepository.Verify(m => m.SetEncodingState(It.IsAny <string>(), EncodingState.Failed, EncodingStage.Uploading, null));
            _fileSystem.Verify(m => m.DirectoryExists(localPath), Times.Once());
            _fileSystem.Verify(m => m.DirectoryDelete(localPath), Times.Once());
        }
        public void EncodeTest()
        {
            //Arrange
            var cloudStorageConfiguration = new CloudStorageConfiguration(CloudStorageAccount.DevelopmentStorageAccount, new Version());

            var queueVideoRepository = new QueueVideoRepository(cloudStorageConfiguration.StorageAccount.CreateCloudQueueClient());
            var videoRepository      = new FakeVideoRepository(_blobSource, _blobDestination);
            var screenshotRepository = new FakeScreenshotRepository(_blobDestination);
            var mediaInfoReader      = new MediaInfoReader();
            var encoder           = new Encoder();
            var fileSystemWrapper = new FileSystemWrapper();

            var queueProcess    = new QueueProcess(1000, queueVideoRepository);
            var downloadProcess = new DownloadProcess(5, videoRepository, fileSystemWrapper);
            var encoderProcess  = new EncodeProcess(5, encoder, videoRepository, mediaInfoReader, queueVideoRepository, fileSystemWrapper);
            var uploadProcess   = new UploadProcess(5, videoRepository, screenshotRepository, fileSystemWrapper);
            var finishProcess   = new FinishProcess(queueVideoRepository, videoRepository, fileSystemWrapper);

            var queueContainer    = new ProcessContainer <object, QueueInformation, DownloadInformation>(queueProcess, downloadProcess);
            var downloadContainer = new ProcessContainer <QueueInformation, DownloadInformation, EncodeInformation>(downloadProcess, encoderProcess);
            var encoderContainer  = new ProcessContainer <DownloadInformation, EncodeInformation, UploadInformation>(encoderProcess, uploadProcess);
            var uploadContainer   = new ProcessContainer <EncodeInformation, UploadInformation, object>(uploadProcess, finishProcess);

            var processManager = new EncodeProcessManager(queueVideoRepository.DeleteMessageLocal);

            processManager.Add(queueContainer);
            processManager.Add(downloadContainer);
            processManager.Add(encoderContainer);
            processManager.Add(uploadContainer);

            var timer = new Timer(UpdateMessages, queueVideoRepository, (int)queueVideoRepository.InvisibleTime.TotalMilliseconds / 2, (int)queueVideoRepository.InvisibleTime.TotalMilliseconds / 2);

            //Act & Assert
            Task task = processManager.Start();

            StartQueueWork();

            Thread.Sleep(30000);


            while (queueVideoRepository.ApproximateMessageCount > 0)
            {
                Thread.Sleep(60000);
            }

            //Thread.Sleep(50*60*1000);

            processManager.Stop();

            task.Wait();
        }
        public void EncodeTest()
        {
            //Arrange
            var cloudStorageConfiguration = new CloudStorageConfiguration(CloudStorageAccount.DevelopmentStorageAccount, new Version());

            var queueVideoRepository = new QueueVideoRepository(cloudStorageConfiguration.StorageAccount.CreateCloudQueueClient());
            var videoRepository = new FakeVideoRepository(_blobSource, _blobDestination);
            var screenshotRepository = new FakeScreenshotRepository(_blobDestination);
            var mediaInfoReader = new MediaInfoReader();
            var encoder = new Encoder();
            var fileSystemWrapper = new FileSystemWrapper();

            var queueProcess = new QueueProcess(1000, queueVideoRepository);
            var downloadProcess = new DownloadProcess(5, videoRepository, fileSystemWrapper);
            var encoderProcess = new EncodeProcess(5, encoder, videoRepository, mediaInfoReader, queueVideoRepository, fileSystemWrapper);
            var uploadProcess = new UploadProcess(5, videoRepository, screenshotRepository, fileSystemWrapper);
            var finishProcess = new FinishProcess(queueVideoRepository, videoRepository, fileSystemWrapper);

            var queueContainer = new ProcessContainer<object, QueueInformation, DownloadInformation>(queueProcess, downloadProcess);
            var downloadContainer = new ProcessContainer<QueueInformation, DownloadInformation, EncodeInformation>(downloadProcess, encoderProcess);
            var encoderContainer = new ProcessContainer<DownloadInformation, EncodeInformation, UploadInformation>(encoderProcess, uploadProcess);
            var uploadContainer = new ProcessContainer<EncodeInformation, UploadInformation, object>(uploadProcess, finishProcess);

            var processManager = new EncodeProcessManager(queueVideoRepository.DeleteMessageLocal);
            processManager.Add(queueContainer);
            processManager.Add(downloadContainer);
            processManager.Add(encoderContainer);
            processManager.Add(uploadContainer);

            var timer = new Timer(UpdateMessages, queueVideoRepository, (int) queueVideoRepository.InvisibleTime.TotalMilliseconds/2, (int) queueVideoRepository.InvisibleTime.TotalMilliseconds/2);

            //Act & Assert
            Task task = processManager.Start();
            StartQueueWork();

            Thread.Sleep(30000);


            while (queueVideoRepository.ApproximateMessageCount > 0)
            {
                Thread.Sleep(60000);
            }

            //Thread.Sleep(50*60*1000);

            processManager.Stop();

            task.Wait();
        }
        public void UploadVerifyTest()
        {
            //Arrange
            var uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);

            var encodeInfo = new EncodeInformation()
                                 {
                                     EncodeScreenshotList = new List<ScreenshotData>()
                                                                {
                                                                    new ScreenshotData(),
                                                                    new ScreenshotData()
                                                                },
                                     EncodeVideoList = new List<VideoData>()
                                                           {
                                                               new VideoData(),
                                                               new VideoData()
                                                           },
                                     DownloadInformation = new DownloadInformation()
                                                               {
                                                                   QueueInformation = new QueueInformation()
                                                                                          {
                                                                                              VideoMessage = new VideoMessage()
                                                                                          }
                                                               }
                                 };

            //Act
            uploadProcess.ProcessMethod(encodeInfo, new CancellationToken());

            //Assert
            _videoRepository.Verify(m=>m.SetEncodingState(It.IsAny<string>(),EncodingState.InProcess, EncodingStage.Uploading, null), Times.Once());
            _videoRepository.Verify(m => m.UploadEncodedVideo(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<string>(), It.IsAny<DateTime>(), It.IsAny<DateTime>()), 
                Times.Exactly(encodeInfo.EncodeVideoList.Count));

            _screenshotRepository.Verify(m => m.UploadScreenshot(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<long>(), It.IsAny<string>()), 
                Times.Exactly(encodeInfo.EncodeScreenshotList.Count));

            _videoRepository.Verify(m => m.DeleteWatchVideos(It.IsAny<string>(), It.IsAny<string>()), Times.Once());
            _videoRepository.Verify(m => m.AddWatchVideos(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Once());
            _screenshotRepository.Verify(m => m.DeleteScreenshots(It.IsAny<string>(), It.IsAny<string>()), Times.Once());
            _screenshotRepository.Verify(m => m.AddScreenshots(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Once());
        }
Beispiel #6
0
        public void UploadVerifyTest()
        {
            //Arrange
            var uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);

            var encodeInfo = new EncodeInformation()
            {
                EncodeScreenshotList = new List <ScreenshotData>()
                {
                    new ScreenshotData(),
                    new ScreenshotData()
                },
                EncodeVideoList = new List <VideoData>()
                {
                    new VideoData(),
                    new VideoData()
                },
                DownloadInformation = new DownloadInformation()
                {
                    QueueInformation = new QueueInformation()
                    {
                        VideoMessage = new VideoMessage()
                    }
                }
            };

            //Act
            uploadProcess.ProcessMethod(encodeInfo, new CancellationToken());

            //Assert
            _videoRepository.Verify(m => m.SetEncodingState(It.IsAny <string>(), EncodingState.InProcess, EncodingStage.Uploading, null), Times.Once());
            _videoRepository.Verify(m => m.UploadEncodedVideo(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <DateTime>()),
                                    Times.Exactly(encodeInfo.EncodeVideoList.Count));

            _screenshotRepository.Verify(m => m.UploadScreenshot(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <long>(), It.IsAny <string>()),
                                         Times.Exactly(encodeInfo.EncodeScreenshotList.Count));

            _videoRepository.Verify(m => m.DeleteWatchVideos(It.IsAny <string>(), It.IsAny <string>()), Times.Once());
            _videoRepository.Verify(m => m.AddWatchVideos(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()), Times.Once());
            _screenshotRepository.Verify(m => m.DeleteScreenshots(It.IsAny <string>(), It.IsAny <string>()), Times.Once());
            _screenshotRepository.Verify(m => m.AddScreenshots(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()), Times.Once());
        }
        public void UploadSuccessfulTest()
        {
            //Arrange
            var uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);
            var encodeInfo = new EncodeInformation()
                                 {
                                     DownloadInformation = new DownloadInformation()
                                                               {
                                                                   QueueInformation = new QueueInformation()
                                                                                          {
                                                                                              VideoMessage = new VideoMessage()
                                                                                          }
                                                               }
                                 };

            //Act
            var uploadInfo = uploadProcess.ProcessMethod(encodeInfo, new CancellationToken());

            //Assert
            Assert.AreEqual(encodeInfo.DownloadInformation, uploadInfo.DownloadInformation);
        }
Beispiel #8
0
        public void UploadSuccessfulTest()
        {
            //Arrange
            var uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);
            var encodeInfo    = new EncodeInformation()
            {
                DownloadInformation = new DownloadInformation()
                {
                    QueueInformation = new QueueInformation()
                    {
                        VideoMessage = new VideoMessage()
                    }
                }
            };

            //Act
            var uploadInfo = uploadProcess.ProcessMethod(encodeInfo, new CancellationToken());

            //Assert
            Assert.AreEqual(encodeInfo.DownloadInformation, uploadInfo.DownloadInformation);
        }
        public void BrunchOfDeleteTest()
        {
            //Arragnge
            var uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);

            var encodeInfo = new EncodeInformation()
            {
                DownloadInformation = new DownloadInformation()
                {
                    QueueInformation = new QueueInformation()
                    {
                        VideoMessage = new VideoMessage() { Delete=true}
                    }
                }
            };

            //Act
            var uploadInfo = uploadProcess.ProcessMethod(encodeInfo, new CancellationToken());

            //Assert
            Assert.AreEqual(encodeInfo.DownloadInformation, uploadInfo.DownloadInformation);

            _videoRepository.Verify(m => m.DeleteWatchVideos(It.IsAny<string>(), It.IsAny<string>()), Times.Once());
            _screenshotRepository.Verify(m => m.DeleteScreenshots(It.IsAny<string>(), It.IsAny<string>()), Times.Once());
        }
        public void UploadExceptionHandlerTest()
        {
            //Arrange
            const string localPath = "local path";
            var uploadProcess = new UploadProcess(5, _videoRepository.Object, _screenshotRepository.Object, _fileSystem.Object);

            _fileSystem.Setup(m => m.DirectoryExists(localPath)).Returns(true);

            var encodeInfo = new EncodeInformation()
                                 {
                                     DownloadInformation = new DownloadInformation()
                                                               {
                                                                   LocalPath = localPath,
                                                                   QueueInformation = new QueueInformation()
                                                                                          {
                                                                                              VideoMessage = new VideoMessage()
                                                                                          }
                                                               }
                                 };

            //Act
            uploadProcess.ExceptionHandler(new Exception(), encodeInfo);

            //Asert
            _videoRepository.Verify(m => m.SetEncodingState(It.IsAny<string>(), EncodingState.Failed, EncodingStage.Uploading, null));
            _fileSystem.Verify(m => m.DirectoryExists(localPath), Times.Once());
            _fileSystem.Verify(m => m.DirectoryDelete(localPath), Times.Once());
        }