Esempio n. 1
0
        public async Task TestConcurrencyLimit()
        {
            JobHandler.jobFactory = new MockJobFactory();

            var jobSchedulerService = new JobSchedulerService();

            var jobs = new List <IJobQueue>();

            for (int i = 0; i < 3; i++)
            {
                var job = new WebScrapeJob();
                await jobSchedulerService.ScheduleJobAsync(job);

                jobs.Add(job);
                Console.WriteLine(job.RequestId);
            }

            Thread.Sleep(TimeSpan.FromSeconds(2));

            foreach (IJobQueue job in jobs)
            {
                var jobStatus = await jobSchedulerService.GetJobAsync(job.RequestId);

                Console.WriteLine("{0} {1}", job.RequestId, jobStatus.Status);
                if (jobs.IndexOf(job) == jobs.Count - 1)
                {
                    Assert.AreEqual(JobStatus.QUEUED, jobStatus.Status);
                }
                else
                {
                    Assert.AreEqual(JobStatus.RUNNING, jobStatus.Status);
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Returns an IJobQueue specific to the job type sent in the request
        /// </summary>
        /// <param name="request">contains JobType</param>
        /// <returns></returns>
        private IJobQueue JobCreationFactory(JobCreationRequest request)
        {
            //NOTE:Only SCRAPE job has been implemented. Can be changed to a switch for more jobs
            //This factory can definitetly be enhanced.
            //IJobQueue implementations can also be modified to have a constructor that accepts a job request,
            //and be reponsible for their own validation.

            if (request.Type == JobType.SCRAPE)
            {
                if (request.Data != null)
                {
                    var job = new WebScrapeJob();
                    Uri uri;
                    var uriCreated = Uri.TryCreate(request.Data["url"], UriKind.Absolute, out uri);
                    if (uriCreated)
                    {
                        job.Url = uri;
                    }
                    else
                    {
                        throw new JobCreationException("Url request parameter invalid.");
                    }
                    job.Selector = request.Data["selector"];
                    return(job);
                }
                else
                {
                    throw new JobCreationException("Insufficient request parameters.");
                }
            }

            throw new JobCreationException("Type request parameter not supported.");
        }
        public void TestGetJob_JobNotFound()
        {
            var jobSchedulerService = new Mock <IJobSchedulerService>();

            var webScrapeJob = new WebScrapeJob();

            jobSchedulerService.Setup(jbs => jbs.GetJobAsync(It.IsAny <Guid>()))
            .Returns(Task.FromResult <IJobQueue>(null));

            var jobController = new JobController(jobSchedulerService.Object);

            jobController.Request = new HttpRequestMessage();
            jobController.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
            var controllerResponse = jobController.Get(webScrapeJob.RequestId);

            Assert.AreEqual(HttpStatusCode.NotFound, controllerResponse.Result.StatusCode);
            Assert.AreEqual(null, controllerResponse.Result.Content);
        }