public void Dequeue_ShouldFetchAJob_FromTheSpecifiedQueue()
        {
            // Arrange
            UseConnection(connection =>
            {
                var jobQueue = new JobQueueDto
                {
                    JobId = 1,
                    Queue = "default"
                };

                connection.JobQueue.InsertOne(jobQueue);

                var id    = jobQueue.Id;
                var queue = CreateJobQueue(connection);

                // Act
                MongoFetchedJob payload = (MongoFetchedJob)queue.Dequeue(DefaultQueues, CreateTimingOutCancellationToken());

                // Assert
                Assert.Equal(id, payload.Id);
                Assert.Equal("1", payload.JobId);
                Assert.Equal("default", payload.Queue);
            });
        }
        public void Ctor_CorrectlySets_AllInstanceProperties()
        {
            ConnectionUtils.UseConnection(database =>
            {
                var fetchedJob = new MongoFetchedJob(database, ObjectId.GenerateNewId(), JobId, Queue);

                Assert.Equal(JobId, fetchedJob.JobId);
                Assert.Equal(Queue, fetchedJob.Queue);
            });
        }
        public void Ctor_CorrectlySets_AllInstanceProperties()
        {
            UseConnection(connection =>
            {
                var fetchedJob = new MongoFetchedJob(connection, ObjectId.GenerateNewId(), JobId, Queue);

                Assert.Equal(JobId.ToString(), fetchedJob.JobId);
                Assert.Equal(Queue, fetchedJob.Queue);
            });
        }
		public void Ctor_CorrectlySets_AllInstanceProperties()
		{
			UseConnection(connection =>
			{
				var fetchedJob = new MongoFetchedJob(connection, 1, JobId, Queue);

				Assert.Equal(1, fetchedJob.Id);
				Assert.Equal(JobId, fetchedJob.JobId);
				Assert.Equal(Queue, fetchedJob.Queue);
			});
		}
        public void Ctor_CorrectlySets_AllInstanceProperties()
        {
            UseConnection(connection =>
            {
                var fetchedJob = new MongoFetchedJob(connection, 1, JobId, Queue);

                Assert.Equal(1, fetchedJob.Id);
                Assert.Equal(JobId, fetchedJob.JobId);
                Assert.Equal(Queue, fetchedJob.Queue);
            });
        }
        public void Requeue_SetsFetchedAtValueToNull()
        {
            // Arrange
            var queue         = "default";
            var jobId         = ObjectId.GenerateNewId();
            var id            = CreateJobQueueRecord(_dbContext, jobId, queue);
            var processingJob = new MongoFetchedJob(_dbContext, id, jobId, queue);

            // Act
            processingJob.Requeue();

            // Assert
            var record = _dbContext.JobGraph.OfType <JobQueueDto>().Find(new BsonDocument()).ToList().Single();

            Assert.Null(record.FetchedAt);
        }
        public void RemoveFromQueue_ReallyDeletesTheJobFromTheQueue()
        {
            // Arrange
            var queue         = "default";
            var jobId         = ObjectId.GenerateNewId();
            var id            = CreateJobQueueRecord(_dbContext, jobId, queue);
            var processingJob = new MongoFetchedJob(_dbContext, id, jobId, queue);

            // Act
            processingJob.RemoveFromQueue();

            // Assert
            var count = _dbContext.JobGraph.OfType <JobQueueDto>().Count(new BsonDocument());

            Assert.Equal(0, count);
        }
        public void Dispose_SetsFetchedAtValueToNull_IfThereWereNoCallsToComplete()
        {
            UseConnection(sql =>
            {
                // Arrange
                var id            = CreateJobQueueRecord(sql, "1", "default");
                var processingJob = new MongoFetchedJob(sql, id, "1", "default");

                // Act
                processingJob.Dispose();

                // Assert
                var record = sql.JobQueue.FindAll().Single();
                Assert.Null(record.FetchedAt);
            });
        }
		public void RemoveFromQueue_ReallyDeletesTheJobFromTheQueue()
		{
			UseConnection(connection =>
			{
				// Arrange
				var id = CreateJobQueueRecord(connection, "1", "default");
				var processingJob = new MongoFetchedJob(connection, id, "1", "default");

				// Act
				processingJob.RemoveFromQueue();

				// Assert
				var count = connection.JobQueue.Count();
				Assert.Equal(0, count);
			});
		}
        public void Requeue_SetsFetchedAtValueToNull()
        {
            UseConnection(connection =>
            {
                // Arrange
                var id            = CreateJobQueueRecord(connection, "1", "default");
                var processingJob = new MongoFetchedJob(connection, id, "1", "default");

                // Act
                processingJob.Requeue();

                // Assert
                var record = connection.JobQueue.FindAll().Single();
                Assert.Null(record.FetchedAt);
            });
        }
        public void Dispose_SetsFetchedAtValueToNull_IfThereWereNoCallsToComplete()
        {
            UseConnection(connection =>
            {
                // Arrange
                var id            = CreateJobQueueRecord(connection, "1", "default");
                var processingJob = new MongoFetchedJob(connection, id, "1", "default");

                // Act
                processingJob.Dispose();

                // Assert
                var record = connection.JobQueue.Find(new BsonDocument()).ToList().Single();
                Assert.Null(record.FetchedAt);
            });
        }
        public void RemoveFromQueue_ReallyDeletesTheJobFromTheQueue()
        {
            UseConnection(connection =>
            {
                // Arrange
                var id            = CreateJobQueueRecord(connection, "1", "default");
                var processingJob = new MongoFetchedJob(connection, id, "1", "default");

                // Act
                processingJob.RemoveFromQueue();

                // Assert
                var count = connection.JobQueue.Count(new BsonDocument());
                Assert.Equal(0, count);
            });
        }
        public void Requeue_SetsFetchedAtValueToNull()
        {
            UseConnection(connection =>
            {
                // Arrange
                var id            = CreateJobQueueRecord(connection, "1", "default");
                var processingJob = new MongoFetchedJob(connection, id, "1", "default");

                // Act
                processingJob.Requeue();

                // Assert
                var record = AsyncHelper.RunSync(() => connection.JobQueue.Find(new BsonDocument()).ToListAsync()).Single();
                Assert.Null(record.FetchedAt);
            });
        }
        public void RemoveFromQueue_DoesNotDelete_UnrelatedJobs()
        {
            // Arrange
            CreateJobQueueRecord(_dbContext, ObjectId.GenerateNewId(1), "default");
            CreateJobQueueRecord(_dbContext, ObjectId.GenerateNewId(2), "critical");
            CreateJobQueueRecord(_dbContext, ObjectId.GenerateNewId(3), "default");

            var fetchedJob = new MongoFetchedJob(_dbContext, ObjectId.GenerateNewId(), ObjectId.GenerateNewId(999), "default");

            // Act
            fetchedJob.RemoveFromQueue();

            // Assert
            var count = _dbContext.JobGraph.OfType <JobQueueDto>().Count(new BsonDocument());

            Assert.Equal(3, count);
        }
        public void RemoveFromQueue_ReallyDeletesTheJobFromTheQueue()
        {
            ConnectionUtils.UseConnection(database =>
            {
                // Arrange
                var queue         = "default";
                var jobId         = ObjectId.GenerateNewId();
                var id            = CreateJobQueueRecord(database, jobId, queue);
                var processingJob = new MongoFetchedJob(database, id, jobId, queue);

                // Act
                processingJob.RemoveFromQueue();

                // Assert
                var count = database.JobQueue.Count(new BsonDocument());
                Assert.Equal(0, count);
            });
        }
        public void Dispose_SetsFetchedAtValueToNull_IfThereWereNoCallsToComplete()
        {
            UseConnection(connection =>
            {
                // Arrange
                var queue         = "default";
                var jobId         = ObjectId.GenerateNewId();
                var id            = CreateJobQueueRecord(connection, jobId, queue);
                var processingJob = new MongoFetchedJob(connection, id, jobId, queue);

                // Act
                processingJob.Dispose();

                // Assert
                var record = connection.JobGraph.OfType <JobQueueDto>().Find(new BsonDocument()).ToList().Single();
                Assert.Null(record.FetchedAt);
            });
        }
        public void Requeue_SetsFetchedAtValueToNull()
        {
            ConnectionUtils.UseConnection(database =>
            {
                // Arrange
                var queue         = "default";
                var jobId         = ObjectId.GenerateNewId();
                var id            = CreateJobQueueRecord(database, jobId, queue);
                var processingJob = new MongoFetchedJob(database, id, jobId, queue);

                // Act
                processingJob.Requeue();

                // Assert
                var record = database.JobQueue.Find(new BsonDocument()).ToList().Single();
                Assert.Null(record.FetchedAt);
            });
        }
        public void RemoveFromQueue_DoesNotDelete_UnrelatedJobs()
        {
            UseConnection(connection =>
            {
                // Arrange
                CreateJobQueueRecord(connection, "1", "default");
                CreateJobQueueRecord(connection, "1", "critical");
                CreateJobQueueRecord(connection, "2", "default");

                var fetchedJob = new MongoFetchedJob(connection, 999, "1", "default");

                // Act
                fetchedJob.RemoveFromQueue();

                // Assert
                var count = connection.JobQueue.Count(new BsonDocument());
                Assert.Equal(3, count);
            });
        }
        public void RemoveFromQueue_DoesNotDelete_UnrelatedJobs()
        {
            ConnectionUtils.UseConnection(database =>
            {
                // Arrange
                CreateJobQueueRecord(database, ObjectId.GenerateNewId(1), "default");
                CreateJobQueueRecord(database, ObjectId.GenerateNewId(2), "critical");
                CreateJobQueueRecord(database, ObjectId.GenerateNewId(3), "default");

                var fetchedJob = new MongoFetchedJob(database, ObjectId.GenerateNewId(), ObjectId.GenerateNewId(999), "default");

                // Act
                fetchedJob.RemoveFromQueue();

                // Assert
                var count = database.JobQueue.Count(new BsonDocument());
                Assert.Equal(3, count);
            });
        }
        public void Dequeue_ShouldFetchAJob_FromTheSpecifiedQueue()
        {
            // Arrange
            ConnectionUtils.UseConnection(database =>
            {
                var jobQueue = new JobQueueDto
                {
                    JobId = 1.ToString(),
                    Queue = "default"
                };

                database.JobQueue.InsertOne(jobQueue);

                var queue = CreateJobQueue(database);

                // Act
                MongoFetchedJob payload = (MongoFetchedJob)queue.Dequeue(DefaultQueues, CreateTimingOutCancellationToken());

                // Assert
                Assert.Equal("1", payload.JobId);
                Assert.Equal("default", payload.Queue);
            });
        }
Exemple #21
0
        public void Dequeue_ShouldFetchAJob_FromTheSpecifiedQueue()
        {
            // Arrange
            UseConnection(connection =>
            {
                var jobQueue = new JobQueueDto
                {
                    JobId = ObjectId.GenerateNewId(),
                    Queue = "default"
                };

                connection.JobGraph.InsertOne(jobQueue);
                var token = CreateTimingOutCancellationToken();
                var queue = CreateJobQueue(connection);

                // Act
                MongoFetchedJob payload = (MongoFetchedJob)queue.Dequeue(DefaultQueues, token);

                // Assert
                Assert.Equal(jobQueue.JobId.ToString(), payload.JobId);
                Assert.Equal("default", payload.Queue);
            });
        }
Exemple #22
0
        public void Dequeue_ShouldFetchAJob_FromTheSpecifiedQueue()
        {
            // Arrange
            var jobQueue = new JobQueueDto
            {
                JobId = ObjectId.GenerateNewId(),
                Queue = "default"
            };

            _hangfireDbContext.JobGraph.InsertOne(jobQueue);
            var token = CreateTimingOutCancellationToken();
            var queue = new MongoJobFetcher(_hangfireDbContext, new MongoStorageOptions(), _jobQueueSemaphoreMock.Object);

            _jobQueueSemaphoreMock.Setup(m => m.WaitNonBlock("default")).Returns(true);

            // Act
            MongoFetchedJob payload = (MongoFetchedJob)queue.FetchNextJob(DefaultQueues, token);

            // Assert
            Assert.Equal(jobQueue.JobId.ToString(), payload.JobId);
            Assert.Equal("default", payload.Queue);

            _jobQueueSemaphoreMock.Verify(m => m.WaitNonBlock("default"), Times.Once);
        }
		public void Dispose_SetsFetchedAtValueToNull_IfThereWereNoCallsToComplete()
		{
			UseConnection(sql =>
			{
				// Arrange
				var id = CreateJobQueueRecord(sql, "1", "default");
				var processingJob = new MongoFetchedJob(sql, id, "1", "default");

				// Act
				processingJob.Dispose();

				// Assert
				var record = sql.JobQueue.FindAll().Single();
				Assert.Null(record.FetchedAt);
			});
		}
        public void Dispose_SetsFetchedAtValueToNull_IfThereWereNoCallsToComplete()
        {
            UseConnection(connection =>
            {
                // Arrange
                var id = CreateJobQueueRecord(connection, "1", "default");
                var processingJob = new MongoFetchedJob(connection, id, "1", "default");

                // Act
                processingJob.Dispose();

                // Assert
                var record = AsyncHelper.RunSync(() => connection.JobQueue.Find(new BsonDocument()).ToListAsync()).Single();
                Assert.Null(record.FetchedAt);
            });
        }
		public void RemoveFromQueue_DoesNotDelete_UnrelatedJobs()
		{
			UseConnection(connection =>
			{
				// Arrange
				CreateJobQueueRecord(connection, "1", "default");
				CreateJobQueueRecord(connection, "1", "critical");
				CreateJobQueueRecord(connection, "2", "default");

				var fetchedJob = new MongoFetchedJob(connection, 999, "1", "default");

				// Act
				fetchedJob.RemoveFromQueue();

				// Assert
				var count = connection.JobQueue.Count();
				Assert.Equal(3, count);
			});
		}
		public void Requeue_SetsFetchedAtValueToNull()
		{
			UseConnection(connection =>
			{
				// Arrange
				var id = CreateJobQueueRecord(connection, "1", "default");
				var processingJob = new MongoFetchedJob(connection, id, "1", "default");

				// Act
				processingJob.Requeue();

				// Assert
				var record = connection.JobQueue.FindAll().Single();
				Assert.Null(record.FetchedAt);
			});
		}