示例#1
0
        public void RemoveFromQueue()
        {
            Logger.DebugFormat("RemoveFromQueue JobId={0}", JobId);
            _storage.UseStatelessSession(session =>
            {
                session.Query <_JobQueue>().Where(i => i.Id == _id).Delete();
            });

            _removedFromQueue = true;
        }
        public IEnumerable <string> GetQueues()
        {
            lock (Mutex)
            {
                if (_queuesCache.Count == 0 || _cacheUpdated.Add(QueuesCacheTimeout) < _storage.UtcNow)
                {
                    var result = _storage.UseStatelessSession(
                        session => { return(session.Query <_JobQueue>().Select(i => i.Queue).Distinct().ToList()); });

                    _queuesCache  = result;
                    _cacheUpdated = _storage.UtcNow;
                }

                return(_queuesCache.ToList());
            }
        }
        public void GetEnqueuedAndFetchedCount_ReturnsEqueuedCount_WhenExists()
        {
            EnqueuedAndFetchedCountDto result = null;

            _storage.UseStatelessSession(session =>
            {
                var newJob = FluentNHibernateWriteOnlyTransactionTests.InsertNewJob(session);
                session.Insert(new _JobQueue {
                    Job = newJob, Queue = _queue
                });

                result = _sut.GetEnqueuedAndFetchedCount(_queue);

                session.DeleteAll <_JobQueue>();
            });

            Assert.Equal(1, result.EnqueuedCount);
        }
        public void GetStatistics_ShouldReturnDeletedCount()
        {
            const int expectedStatsDeletedCount = 7;

            StatisticsDto result = null;

            _storage.UseStatelessSession(connection =>
            {
                connection.Insert(new _AggregatedCounter {
                    Key = "stats:deleted", Value = 5
                });
                connection.Insert(new _Counter {
                    Key = "stats:deleted", Value = 1
                });
                connection.Insert(new _Counter {
                    Key = "stats:deleted", Value = 1
                });

                result = _sut.GetStatistics();
            });

            Assert.Equal(expectedStatsDeletedCount, result.Deleted);
        }
        public void Dequeue_ShouldDeleteAJob()
        {
            // Arrange
            _storage.UseStatelessSession(session =>
            {
                session.DeleteAll <_JobQueue>();
                session.DeleteAll <_Job>();
                var newjob = FluentNHibernateWriteOnlyTransactionTests.InsertNewJob(session);
                session.Insert(new _JobQueue {
                    Job = newjob, Queue = "default"
                });
                //does nothing
                var queue = CreateJobQueue(_storage);

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

                payload.RemoveFromQueue();

                // Assert
                Assert.NotNull(payload);

                var jobInQueue = session.Query <_JobQueue>().SingleOrDefault();
                Assert.Null(jobInQueue);
            });
        }