public string Create(Job job, IState state)
        {
            var activator = new AutofacJobActivator(scope);
            job.Perform(activator, new Hangfire.JobCancellationToken(false));

            return new Guid().ToString();
        }
Exemplo n.º 2
0
 public CreateContextFacts()
 {
     _job = Job.FromExpression(() => Method());
     _state = new Mock<IState>();
     _connection = new Mock<IStorageConnection>();
     _storage = new Mock<JobStorage>();
 }
Exemplo n.º 3
0
        public StateMachineFacts()
        {
            _process = new Mock<IStateChangeProcess>();

            _job = Job.FromExpression(() => Console.WriteLine());
            _parameters = new Dictionary<string, string>();
            _state = new Mock<IState>();
            _state.Setup(x => x.Name).Returns(StateName);

            _connection = new Mock<IStorageConnection>();
            _transaction = new Mock<IWriteOnlyTransaction>();

            _connection.Setup(x => x.CreateWriteTransaction()).Returns(_transaction.Object);

            _connection.Setup(x => x.CreateExpiredJob(
                It.IsAny<Job>(),
                It.IsAny<IDictionary<string, string>>(),
                It.IsAny<DateTime>(),
                It.IsAny<TimeSpan>())).Returns(JobId);

            _connection.Setup(x => x.GetJobData(JobId))
                .Returns(new JobData
                {
                    State = OldStateName,
                    Job = _job
                });

            _distributedLock = new Mock<IDisposable>();
            _connection
                .Setup(x => x.AcquireDistributedLock(String.Format("job:{0}:state-lock", JobId), It.IsAny<TimeSpan>()))
                .Returns(_distributedLock.Object);

            _cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
        }
Exemplo n.º 4
0
        public override string CreateExpiredJob(
            Job job,
            IDictionary<string, string> parameters,
            DateTime createdAt,
            TimeSpan expireIn)
        {
            job.ThrowIfNull("job");
            parameters.ThrowIfNull("parameters");

            using (var repository = _storage.Repository.OpenSession()) {
                var invocationData = InvocationData.Serialize(job);

                var guid = Guid.NewGuid().ToString();

                var ravenJob = new RavenJob {
                    Id = Repository.GetId(typeof(RavenJob), guid),
                    InvocationData = invocationData,
                    CreatedAt = createdAt,
                    Parameters = parameters
                };

                repository.Store(ravenJob);
                repository.Advanced.AddExpire(ravenJob, createdAt + expireIn);

                repository.SaveChanges();

                return guid;
            }
        }
        public string CreateExpiredJob(Job job, IDictionary <string, string> parameters, DateTime createdAt,
                                       TimeSpan expireIn)
        {
            // TODO make this a transaction

            var invocationData = InvocationData.Serialize(job);

            var persistedJob = new Entities.Job()
            {
                InvocationData = JsonConvert.SerializeObject(invocationData),
                Arguments      = invocationData.Arguments,
                CreatedAt      = createdAt,
                ExpireAt       = createdAt.Add(expireIn)
            };


            return(UsingDatabase(db =>
            {
                int jobId = Convert.ToInt32(db.InsertWithIdentity(persistedJob));

                foreach (var parameter in parameters)
                {
                    db.Insert(new JobParameter()
                    {
                        JobId = jobId,
                        Name = parameter.Key,
                        Value = parameter.Value
                    });
                }


                return jobId.ToString(CultureInfo.InvariantCulture);
            }));
        }
Exemplo n.º 6
0
    public override string CreateExpiredJob(Job job, IDictionary <string, string?> parameters, DateTime createdAt, TimeSpan expireIn)
    {
        if (job == null)
        {
            throw new ArgumentNullException(nameof(job));
        }
        if (parameters == null)
        {
            throw new ArgumentNullException(nameof(parameters));
        }

        InvocationData invocationData = InvocationData.SerializeJob(job);

        Documents.Job entityJob = new()
        {
            InvocationData = invocationData,
            Arguments      = invocationData.Arguments,
            CreatedOn      = createdAt,
            ExpireOn       = createdAt.Add(expireIn),
            Parameters     = parameters.Select(p => new Parameter
            {
                Name  = p.Key,
                Value = p.Value
            }).ToArray()
        };

        Documents.Job result = Storage.Container.CreateItemWithRetries(entityJob, PartitionKeys.Job);
        return(result.Id);
    }
Exemplo n.º 7
0
 public PerformContextFacts()
 {
     _workerContext = new WorkerContextMock();
     _connection = new Mock<IStorageConnection>();
     _job = Job.FromExpression(() => Method());
     _createdAt = new DateTime(2012, 12, 12);
     _cancellationToken = new Mock<IJobCancellationToken>();
 }
Exemplo n.º 8
0
 public static InvocationData Serialize(Job job)
 {
     return new InvocationData(
         job.Type.AssemblyQualifiedName,
         job.Method.Name,
         JobHelper.ToJson(job.Method.GetParameters().Select(x => x.ParameterType).ToArray()),
         JobHelper.ToJson(job.Arguments));
 }
Exemplo n.º 9
0
        public void Ctor_ShouldInitializeAllProperties()
        {
            var job = new Job(_type, _method, _arguments);

            Assert.Same(_type, job.Type);
            Assert.Same(_method, job.Method);
            Assert.Same(_arguments, job.Arguments);
        }
Exemplo n.º 10
0
        public static NonEscapedString DisplayMethod(Job job)
        {
            if (job == null)
            {
                return new NonEscapedString("<em>Can not find the target method.</em>");
            }

            return new NonEscapedString(DisplayJob(job));
        }
Exemplo n.º 11
0
        public StateContext(string jobId, Job job, DateTime createdAt, IStorageConnection connection)
        {
            if (connection == null) throw new ArgumentNullException("connection");
            if (String.IsNullOrEmpty(jobId)) throw new ArgumentNullException("jobId");
            
            JobId = jobId;
            Job = job;
            CreatedAt = createdAt;

            Connection = connection;
        }
Exemplo n.º 12
0
        public CreateContextFacts()
        {
            _job = Job.FromExpression(() => Method());
            _state = new Mock<IState>();
            _connection = new Mock<IStorageConnection>();
            _stateMachine = new Mock<IStateMachine>();

            _stateMachineFactory = new Mock<IStateMachineFactory>();
            _stateMachineFactory.Setup(x => x.Create(It.IsNotNull<IStorageConnection>()))
                .Returns(_stateMachine.Object);
        }
Exemplo n.º 13
0
        public CreateContext(IStorageConnection connection, Job job, IState initialState)
        {
            if (connection == null) throw new ArgumentNullException("connection");
            if (job == null) throw new ArgumentNullException("job");
            
            Connection = connection;
            Job = job;
            InitialState = initialState;

            Items = new Dictionary<string, object>();
        }
        public virtual IEnumerable<JobFilter> GetFilters(Job job)
        {
            if (job == null) return Enumerable.Empty<JobFilter>();

            var typeFilters = GetTypeAttributes(job)
                .Select(attr => new JobFilter(attr, JobFilterScope.Type, null));

            var methodFilters = GetMethodAttributes(job)
                .Select(attr => new JobFilter(attr, JobFilterScope.Method, null));

            return typeFilters.Union(methodFilters).ToList();
        }
Exemplo n.º 15
0
        public override string CreateExpiredJob(
            Job job,
            IDictionary<string, string> parameters, 
            DateTime createdAt,
            TimeSpan expireIn)
        {
            if (job == null) throw new ArgumentNullException(nameof(job));
            if (parameters == null) throw new ArgumentNullException(nameof(parameters));

            string createJobSql =
$@"insert into [{_storage.SchemaName}].Job (InvocationData, Arguments, CreatedAt, ExpireAt)
values (@invocationData, @arguments, @createdAt, @expireAt);
SELECT CAST(SCOPE_IDENTITY() as int)";

            var invocationData = InvocationData.Serialize(job);

            return _storage.UseConnection(connection =>
            {
                var jobId = connection.Query<int>(
                    createJobSql,
                    new
                    {
                        invocationData = JobHelper.ToJson(invocationData),
                        arguments = invocationData.Arguments,
                        createdAt = createdAt,
                        expireAt = createdAt.Add(expireIn)
                    }).Single().ToString();

                if (parameters.Count > 0)
                {
                    var parameterArray = new object[parameters.Count];
                    int parameterIndex = 0;
                    foreach (var parameter in parameters)
                    {
                        parameterArray[parameterIndex++] = new
                        {
                            jobId = jobId,
                            name = parameter.Key,
                            value = parameter.Value
                        };
                    }

                    string insertParameterSql =
$@"insert into [{_storage.SchemaName}].JobParameter (JobId, Name, Value)
values (@jobId, @name, @value)";

                    connection.Execute(insertParameterSql, parameterArray);
                }

                return jobId;
            });
        }
Exemplo n.º 16
0
        public ApplyStateContextFacts()
        {
            _job = Job.FromExpression(() => Console.WriteLine());

            _stateContext = new StateContextMock
            {
                JobIdValue = JobId, 
                JobValue = _job,
            };

            _newState = new Mock<IState>();
            _newState.Setup(x => x.Name).Returns(NewState);
        }
Exemplo n.º 17
0
 public RecurringJobManagerFacts()
 {
     _id = "recurring-job-id";
     _job = Job.FromExpression(() => Method());
     _cronExpression = Cron.Minutely();
     _storage = new Mock<JobStorage>();
     _factory = new Mock<IBackgroundJobFactory>();
     
     _connection = new Mock<IStorageConnection>();
     _storage.Setup(x => x.GetConnection()).Returns(_connection.Object);
     
     _transaction = new Mock<IWriteOnlyTransaction>();
     _connection.Setup(x => x.CreateWriteTransaction()).Returns(_transaction.Object);
 }
Exemplo n.º 18
0
        public BackgroundJobClientFacts()
        {
            _connection = new Mock<IStorageConnection>();
            _storage = new Mock<JobStorage>();
            _storage.Setup(x => x.GetConnection()).Returns(_connection.Object);

            _stateMachine = new Mock<IStateMachine>();

            _stateMachineFactory = new Mock<IStateMachineFactory>();
            _stateMachineFactory.Setup(x => x.Create(_connection.Object)).Returns(_stateMachine.Object);

            _process = new Mock<IJobCreationProcess>();
            _state = new Mock<IState>();
            _job = Job.FromExpression(() => Method());
        }
Exemplo n.º 19
0
        public BackgroundJobClientFacts()
        {
            var connection = new Mock<IStorageConnection>();
            _storage = new Mock<JobStorage>();
            _storage.Setup(x => x.GetConnection()).Returns(connection.Object);

            _stateChanger = new Mock<IBackgroundJobStateChanger>();
            
            _state = new Mock<IState>();
            _state.Setup(x => x.Name).Returns("Mock");
            _job = Job.FromExpression(() => Method());

            _factory = new Mock<IBackgroundJobFactory>();
            _factory.Setup(x => x.Create(It.IsAny<CreateContext>()))
                .Returns(new BackgroundJob("some-job", _job, DateTime.UtcNow));
        }
        public BackgroundJobStateChangerFacts()
        {
            _stateMachine = new Mock<IStateMachine>();

            _job = Job.FromExpression(() => Console.WriteLine());
            _state = new Mock<IState>();
            _state.Setup(x => x.Name).Returns(StateName);
            
            _connection = new Mock<IStorageConnection>();
            _transaction = new Mock<IWriteOnlyTransaction>();

            _connection.Setup(x => x.CreateWriteTransaction()).Returns(_transaction.Object);

            _connection.Setup(x => x.CreateExpiredJob(
                It.IsAny<Job>(),
                It.IsAny<IDictionary<string, string>>(),
                It.IsAny<DateTime>(),
                It.IsAny<TimeSpan>())).Returns(JobId);

            _connection.Setup(x => x.GetJobData(JobId))
                .Returns(new JobData
                {
                    State = OldStateName,
                    Job = _job
                });

            _distributedLock = new Mock<IDisposable>();
            _connection
                .Setup(x => x.AcquireDistributedLock($"job:{JobId}:state-lock", It.IsAny<TimeSpan>()))
                .Returns(_distributedLock.Object);

            _cts = new CancellationTokenSource(TimeSpan.FromSeconds(1));
            _context = new StateChangeContextMock
            {
                BackgroundJobId = JobId,
                Connection = _connection,
                CancellationToken = _cts.Token,
                NewState = _state,
                ExpectedStates = FromOldState
            };

            _stateMachine.Setup(x => x.ApplyState(It.IsNotNull<ApplyStateContext>()))
                .Returns(_context.NewState.Object);
        }
Exemplo n.º 21
0
        public ApplyStateContextFacts()
        {
            _connection = new Mock<IStorageConnection>();

            _job = Job.FromExpression(() => Console.WriteLine());

            _stateContext = new StateContextMock();
            _stateContext.JobIdValue = JobId;
            _stateContext.JobValue = _job;
            _stateContext.ConnectionValue = _connection;

            _newState = new Mock<IState>();
            _newState.Setup(x => x.Name).Returns(NewState);

            _filters = new List<IApplyStateFilter>();
            _handlers = new StateHandlerCollection();

            _transaction = new Mock<IWriteOnlyTransaction>();
            _connection.Setup(x => x.CreateWriteTransaction()).Returns(_transaction.Object);
        }
Exemplo n.º 22
0
        /// <inheritdoc />
        public string Create(Job job, IState state)
        {
            if (job == null) throw new ArgumentNullException("job");
            if (state == null) throw new ArgumentNullException("state");

            try
            {
                using (var connection = _storage.GetConnection())
                {
                    var context = new CreateContext(connection, _stateMachineFactory, job, state);
                    _process.Run(context);

                    return context.JobId;
                }
            }
            catch (Exception ex)
            {
                throw new CreateJobFailedException("Job creation process has bee failed. See inner exception for details", ex);
            }
        }
Exemplo n.º 23
0
        public string CreateInState(
            Job job,
            IDictionary<string, string> parameters,
            IState state)
        {
            if (job == null) throw new ArgumentNullException("job");
            if (parameters == null) throw new ArgumentNullException("parameters");
            if (state == null) throw new ArgumentNullException("state");

            var createdAt = DateTime.UtcNow;
            var jobId = _connection.CreateExpiredJob(
                job,
                parameters,
                createdAt,
                TimeSpan.FromHours(1));

            var context = new StateContext(jobId, job, createdAt, _connection);
            _stateChangeProcess.ChangeState(context, state, null);

            return jobId;
        }
        public string CreateExpiredJob(Job job, IDictionary<string, string> parameters, DateTime createdAt,
            TimeSpan expireIn)
        {

          
            // TODO make this a transaction

            var invocationData = InvocationData.Serialize(job);

            var persistedJob = new Entities.Job()
            {
                InvocationData = JsonConvert.SerializeObject(invocationData),
                Arguments = invocationData.Arguments,
                CreatedAt = createdAt,
                ExpireAt = createdAt.Add(expireIn)
            };


            return UsingDatabase(db =>
            {


                int jobId = Convert.ToInt32(db.InsertWithIdentity(persistedJob));

                foreach (var parameter in parameters)
                {
                    db.Insert(new JobParameter()
                    {
                        JobId = jobId,
                        Name = parameter.Key,
                        Value = parameter.Value
                    });

                }


                return jobId.ToString(CultureInfo.InvariantCulture);
            });
        }
Exemplo n.º 25
0
        public override string CreateExpiredJob(Job job, IDictionary<string, string> parameters, DateTime createdAt, TimeSpan expireIn)
        {
            if (job == null)
                throw new ArgumentNullException("job");

            if (parameters == null)
                throw new ArgumentNullException("parameters");

            var invocationData = InvocationData.Serialize(job);

            var jobDto = new JobDto
            {
                InvocationData = JobHelper.ToJson(invocationData),
                Arguments = invocationData.Arguments,
                CreatedAt = createdAt,
                ExpireAt = createdAt.Add(expireIn)
            };

            AsyncHelper.RunSync(() => _database.Job.InsertOneAsync(jobDto));

            var jobId = jobDto.Id;

            if (parameters.Count > 0)
            {
                Task.WaitAll(parameters
                    .Select(parameter => _database
                        .JobParameter
                        .InsertOneAsync(new JobParameterDto
                        {
                            JobId = jobId,
                            Name = parameter.Key,
                            Value = parameter.Value
                        }))
                    .ToArray());
            }

            return jobId.ToString();
        }
Exemplo n.º 26
0
		public string CreateExpiredJob(Job job, IDictionary<string, string> parameters, DateTime createdAt, TimeSpan expireIn)
		{
			if (job == null)
				throw new ArgumentNullException("job");

			if (parameters == null)
				throw new ArgumentNullException("parameters");

			var invocationData = InvocationData.Serialize(job);

			var jobDto = new JobDto
			{
				InvocationData = JobHelper.ToJson(invocationData),
				Arguments = invocationData.Arguments,
				CreatedAt = createdAt,
				ExpireAt = createdAt.Add(expireIn)
			};

			_database.Job.Insert(jobDto);

			var jobId = jobDto.Id;

			if (parameters.Count > 0)
			{
				foreach (var parameter in parameters)
				{
					_database.JobParameter.Insert(new JobParameterDto
					{
						JobId = jobId,
						Name = parameter.Key,
						Value = parameter.Value
					});
				}
			}

			return jobId.ToString();
		}
Exemplo n.º 27
0
        public void AddOrUpdate(string recurringJobId, Job job, string cronExpression, RecurringJobOptions options)
        {
            if (recurringJobId == null) throw new ArgumentNullException(nameof(recurringJobId));
            if (job == null) throw new ArgumentNullException(nameof(job));
            if (cronExpression == null) throw new ArgumentNullException(nameof(cronExpression));
            if (options == null) throw new ArgumentNullException(nameof(options));
            
            ValidateCronExpression(cronExpression);

            using (var connection = _storage.GetConnection())
            {
                var recurringJob = new Dictionary<string, string>();
                var invocationData = InvocationData.Serialize(job);

                recurringJob["Job"] = JobHelper.ToJson(invocationData);
                recurringJob["Cron"] = cronExpression;
                recurringJob["TimeZoneId"] = options.TimeZone.Id;
                recurringJob["Queue"] = options.QueueName;

                var existingJob = connection.GetAllEntriesFromHash($"recurring-job:{recurringJobId}");
                if (existingJob == null)
                {
                    recurringJob["CreatedAt"] = JobHelper.SerializeDateTime(DateTime.UtcNow);
                }

                using (var transaction = connection.CreateWriteTransaction())
                {
                    transaction.SetRangeInHash(
                        $"recurring-job:{recurringJobId}",
                        recurringJob);

                    transaction.AddToSet("recurring-jobs", recurringJobId);

                    transaction.Commit();
                }
            }
        }
Exemplo n.º 28
0
        public StateMachineFacts()
        {
            _stateChangeProcess = new Mock<IStateChangeProcess>();

            _job = Job.FromExpression(() => Console.WriteLine());
            _parameters = new Dictionary<string, string>();
            _state = new Mock<IState>();
            _state.Setup(x => x.Name).Returns(StateName);

            _connection = new Mock<IStorageConnection>();

            _connection.Setup(x => x.CreateExpiredJob(
                It.IsAny<Job>(),
                It.IsAny<IDictionary<string, string>>(),
                It.IsAny<DateTime>(),
                It.IsAny<TimeSpan>())).Returns(JobId);

            _connection.Setup(x => x.GetJobData(JobId))
                .Returns(new JobData
                {
                    State = OldStateName,
                    Job = _job
                });

            _distributedLock = new Mock<IDisposable>();
            _connection
                .Setup(x => x.AcquireDistributedLock(String.Format("job:{0}:state-lock", JobId), It.IsAny<TimeSpan>()))
                .Returns(_distributedLock.Object);

            _stateChangeProcess
                .Setup(x => x.ChangeState(
                    It.Is<StateContext>(s => s.JobId == JobId && s.Job == _job && s.Connection == _connection.Object), 
                    _state.Object, 
                    OldStateName))
                .Returns(true);
        }
Exemplo n.º 29
0
        public static string DisplayJob(Job job)
        {
            if (job == null)
            {
                throw new ArgumentNullException("job");
            }

            var displayNameAttribute = Attribute.GetCustomAttribute(job.Method, typeof(DisplayNameAttribute), true) as DisplayNameAttribute;

            if (displayNameAttribute == null || displayNameAttribute.DisplayName == null)
            {
                return String.Format("{0}.{1}", job.Type.Name, job.Method.Name);
            }

            try
            {
                var arguments = job.Arguments.Cast<object>().ToArray();
                return String.Format(displayNameAttribute.DisplayName, arguments);
            }
            catch (FormatException)
            {
                return displayNameAttribute.DisplayName;
            }
        }
Exemplo n.º 30
0
 public Common.Job CreateCommonJob(string scheduleSerializeObject)
 {
     Common.Job _job = null;
     _job = Common.Job.FromExpression(() => CreateJob(scheduleSerializeObject, "21"));
     return(_job);
 }
Exemplo n.º 31
0
        private static string BuildJob(string id, Hangfire.Common.Job job)
        {
            if (job == null)
            {
                return("<em>Can not find the target method.</em>");
            }

            var builder = new StringBuilder();

            builder.Append("<span class=\"comment\">// #Job ID: ");
            builder.Append(id);
            builder.Append("</span>");
            builder.AppendLine();
            builder.AppendLine();
            builder.Append(WrapKeyword("using"));
            builder.Append(" ");
            builder.Append(Encode(job.Type.Namespace));
            builder.Append(";");
            builder.AppendLine();
            builder.AppendLine();

            string serviceName = null;

            if (!job.Method.IsStatic)
            {
                serviceName = GetNameWithoutGenericArity(job.Type);

                if (job.Type.GetTypeInfo().IsInterface&& serviceName[0] == 'I' && Char.IsUpper(serviceName[1]))
                {
                    serviceName = serviceName.Substring(1);
                }

                serviceName = Char.ToLower(serviceName[0]) + serviceName.Substring(1);

                builder.Append(WrapKeyword("var"));
                builder.Append(
                    $" {Encode(serviceName)} = Activate&lt;{WrapType(Encode(job.Type.ToString()))}&gt;();");

                builder.AppendLine();
            }

            if (job.Method.GetCustomAttribute <AsyncStateMachineAttribute>() != null)
            {
                builder.Append($"{WrapKeyword("await")} ");
            }

            builder.Append(!job.Method.IsStatic ? Encode(serviceName) : WrapType(Encode(job.Type.ToString())));

            builder.Append(".");
            builder.Append(Encode(job.Method.Name));

            if (job.Method.IsGenericMethod)
            {
                var genericArgumentTypes = job.Method.GetGenericArguments()
                                           .Select(x => WrapType(x.Name))
                                           .ToArray();

                builder.Append($"&lt;{String.Join(", ", genericArgumentTypes)}&gt;");
            }

            builder.Append("(");

            var parameters                   = job.Method.GetParameters();
            var renderedArguments            = new List <string>(parameters.Length);
            var renderedArgumentsTotalLength = 0;

            const int splitStringMinLength = 100;

            for (var i = 0; i < parameters.Length; i++)
            {
                var parameter = parameters[i];

#pragma warning disable 618
                if (i < job.Arguments.Length)
                {
                    var argument = job.Arguments[i]; // TODO: check bounds
#pragma warning restore 618
                    string renderedArgument;

                    var enumerableArgument = GetIEnumerableGenericArgument(parameter.ParameterType);

                    object argumentValue;
                    bool   isJson = true;

                    try
                    {
                        argumentValue = JobHelper.FromJson(argument, parameter.ParameterType);
                    }
                    catch (Exception)
                    {
                        // If argument value is not encoded as JSON (an old
                        // way using TypeConverter), we should display it as is.
                        argumentValue = argument;
                        isJson        = false;
                    }

                    if (enumerableArgument == null || argumentValue == null)
                    {
                        var argumentRenderer = ArgumentRenderer.GetRenderer(parameter.ParameterType);
                        renderedArgument = argumentRenderer.Render(isJson, argumentValue?.ToString(), argument);
                    }
                    else
                    {
                        var renderedItems = new List <string>();

                        // ReSharper disable once LoopCanBeConvertedToQuery
                        foreach (var item in (IEnumerable)argumentValue)
                        {
                            var argumentRenderer = ArgumentRenderer.GetRenderer(enumerableArgument);
                            renderedItems.Add(argumentRenderer.Render(isJson, item?.ToString(),
                                                                      JobHelper.ToJson(item)));
                        }

                        // ReSharper disable once UseStringInterpolation
                        renderedArgument = String.Format(
                            "{0}{1} {{ {2} }}",
                            WrapKeyword("new"),
                            parameter.ParameterType.IsArray ? " []" : "",
                            String.Join(", ", renderedItems));
                    }

                    renderedArguments.Add(renderedArgument);
                    renderedArgumentsTotalLength += renderedArgument.Length;
                }
                else
                {
                    renderedArguments.Add(Encode("<NO VALUE>"));
                }
            }

            for (int i = 0; i < renderedArguments.Count; i++)
            {
                // TODO: be aware of out of range
                var parameter       = parameters[i];
                var tooltipPosition = "top";

                var renderedArgument = renderedArguments[i];
                if (renderedArgumentsTotalLength > splitStringMinLength)
                {
                    builder.AppendLine();
                    builder.Append("    ");

                    tooltipPosition = "left";
                }
                else if (i > 0)
                {
                    builder.Append(" ");
                }

                builder.Append($"<span title=\"{parameter.Name}\" data-placement=\"{tooltipPosition}\">");
                builder.Append(renderedArgument);
                builder.Append("</span>");

                if (i < renderedArguments.Count - 1)
                {
                    builder.Append(",");
                }
            }

            builder.Append(");");

            return(builder.ToString());
        }
Exemplo n.º 32
0
        public void Perform_PassesCorrectDateTime_IfItWasSerialized_UsingOldFormat()
        {
            // Arrange
            _methodInvoked = false;
            var convertedDate = SomeDateTime.ToString("MM/dd/yyyy HH:mm:ss.ffff");

            var type = typeof(JobFacts);
            var method = type.GetMethod("MethodWithDateTimeArgument");

            var job = new Job(type, method, new[] { convertedDate });

            // Act
            job.Perform(_activator.Object, _token.Object);

            // Assert - see also the `MethodWithDateTimeArgument` method.
            Assert.True(_methodInvoked);
        }
Exemplo n.º 33
0
        public void Perform_PassesCorrectDateTime_IfItWasSerialized_UsingTypeConverter()
        {
            // Arrange
            _methodInvoked = false;
            var typeConverter = TypeDescriptor.GetConverter(typeof (DateTime));
            var convertedDate = typeConverter.ConvertToInvariantString(SomeDateTime);

            var type = typeof (JobFacts);
            var method = type.GetMethod("MethodWithDateTimeArgument");

            var job = new Job(type, method, new[] { convertedDate });

            // Act
            job.Perform(_activator.Object, _token.Object);

            // Assert - see also the `MethodWithDateTimeArgument` method.
            Assert.True(_methodInvoked);
        }
Exemplo n.º 34
0
 private JobFilterInfo GetFilters(Job job)
 {
     return new JobFilterInfo(_filterProvider.GetFilters(job));
 }