public ResultSetColumnMapping(IResultSetColumnMapping other, IListener listener, IPolicies policies, ICompilerMessageBuilder messageProvider) { if(ReferenceEquals(other, null)) throw new ArgumentNullException(nameof(other)); this.ColumnName = other.ColumnName; this.PropertyName = other.PropertyName; }
/// <summary> /// Initializes a new instance of the <see cref="SendHeartBeatPolicyDecorator" /> class. /// </summary> /// <param name="handler">The handler.</param> /// <param name="policies">The policies.</param> public SendHeartBeatPolicyDecorator( ISendHeartBeat handler, IPolicies policies) { _policies = policies; _handler = handler; }
private static InjectBehaviourPolicy CreateRetryChaos(IPolicies policies) { return(MonkeyPolicy.InjectBehaviour((context) => throw new SqliteException( "Policy chaos testing", Convert.ToInt32(ChaosPolicyShared.GetRandomEnum <RetryableSqlErrors>())), (context) => ChaosPolicyShared.InjectionRate(context, RetryConstants.RetryCount, RetryAttempts), (context) => policies.EnableChaos)); }
private static AsyncInjectOutcomePolicy CreateRetryChaosAsync(IPolicies policies) { return(MonkeyPolicy.InjectExceptionAsync(with => with.Fault(Behaviour()) .InjectionRate((context, token) => ChaosPolicyShared.InjectionRateAsync(context, RetryConstants.RetryCount, RetryAttempts)) .Enabled(policies.EnableChaos) )); }
/// <summary> /// Initializes a new instance of the <see cref="RetryCommandHandlerOutputDecorator{TCommand,TOutput}" /> class. /// </summary> /// <param name="decorated">The decorated.</param> /// <param name="policies">The policies.</param> public RetryCommandHandlerOutputDecorator(ICommandHandlerWithOutput <TCommand, TOutput> decorated, IPolicies policies) { Guard.NotNull(() => decorated, decorated); Guard.NotNull(() => policies, policies); _decorated = decorated; _policies = policies; }
/// <summary> /// Initializes a new instance of the <see cref="RetryCommandHandlerDecorator{TCommand}" /> class. /// </summary> /// <param name="decorated">The decorated handler.</param> /// <param name="policies">The policies.</param> public RetryCommandHandlerDecorator(ICommandHandler <TCommand> decorated, IPolicies policies) { Guard.NotNull(() => decorated, decorated); Guard.NotNull(() => policies, policies); _decorated = decorated; _policies = policies; }
public BlobProperty( IProperty other, IListener listener, IPolicies policies, ICompilerMessageBuilder messageProvider, int propertyIndex) : base(other, listener, policies, messageProvider, propertyIndex) { }
/// <summary> /// Initializes a new instance of the <see cref="RetryQueryHandlerDecorator{TQuery,TResult}" /> class. /// </summary> /// <param name="decorated">The decorated.</param> /// <param name="policies">The policies.</param> public RetryQueryHandlerDecorator(IQueryHandler <TQuery, TResult> decorated, IPolicies policies) { Guard.NotNull(() => decorated, decorated); Guard.NotNull(() => policies, policies); _decorated = decorated; _policies = policies; }
private static InjectBehaviourPolicy CreateRetryChaos(IPolicies policies) { return(MonkeyPolicy.InjectBehaviour( (context) => throw new PostgresException { SqlState = ChaosPolicyShared.GetRandomString(RetryablePostGreErrors.Errors.ToList()) }, (context) => ChaosPolicyShared.InjectionRate(context, RetryConstants.RetryCount, RetryAttempts), (context) => policies.EnableChaos)); }
public Users( IServicesConfig config, ILogger log, IPolicies policies) { this.config = config; this.log = log; this.policies = policies; this.rolesKey = this.config.JwtRolesFrom.ToLowerInvariant(); }
public PoliciesControllerTest() { mockPoliciesRepository = new Moq.Mock <IPolicies>(); mockPoliciesController = new PoliciesController(mockPoliciesRepository.Object); policiesRepository = new ER.PoliciesRepository(iChildrenAndExtraBedPoliciesConnectionLibrary, iMaxChildAndExtraBedPerRoomConnectionLibrary, iCancellationChargesConnectionLibrary, iCancellationPolicyConnectionLibrary, iCancellationPolicyClausesConnectionLibrary, iCancellationPolicyTypeConnectionLibrary, iRoomConnectionLibrary); policiesController = new PoliciesController(policiesRepository); }
public PropertySet( IPropertySet other, IListener listener, IPolicies policies, ICompilerMessageBuilder messageProvider, int interfaceIndex) { if(ReferenceEquals(other, null)) throw new ArgumentNullException(nameof(other)); if (ReferenceEquals(listener, null)) throw new ArgumentNullException(nameof(listener)); if (ReferenceEquals(policies, null)) throw new ArgumentNullException(nameof(policies)); if (ReferenceEquals(messageProvider, null)) throw new ArgumentNullException(nameof(messageProvider)); this.InterfaceName = other.InterfaceName ?? policies.GenerateSurrogateInterfaceName(interfaceIndex); if (ReferenceEquals(other.InterfaceName, null)) listener.Error(messageProvider.MissingInterfaceName(this.InterfaceName, interfaceIndex)); if (false == policies.IsValidInterfaceName(this.InterfaceName)) listener.Error(messageProvider.InvalidInterfaceName(this.InterfaceName, interfaceIndex)); if (ReferenceEquals(other.Properties, null)) { listener.Error(messageProvider.EmptyPropertiesList(this.InterfaceName, interfaceIndex)); return; } int propertyIndex = 0; foreach (var property in other.Properties.OfType<IBasicProperty>()) { this.Properties.Add( new BasicProperty(property, listener, policies, messageProvider, propertyIndex++)); } propertyIndex = 0; foreach (var property in other.Properties.OfType<IBlobProperty>()) { this.Properties.Add( new BlobProperty(property, listener, policies, messageProvider, propertyIndex++)); } propertyIndex = 0; foreach (var property in other.Properties.OfType<ITableValueProperty>()) { this.Properties.Add( new TableValueProperty(property, listener, policies, messageProvider, propertyIndex++)); } this.m_ixPropertyByName = this.Properties.ToDictionary( p => p.PropertyName, StringComparer.OrdinalIgnoreCase); }
public void should_not_add_tagging_ability_if_graph_is_a_fixture() { IFixtureGraph fixture = MockRepository.GenerateMock <IFixtureGraph>(); IPolicies policies = MockRepository.GenerateMock <IPolicies>(); IEnumerable <GrammarStructure> grammars = new List <GrammarStructure>(); fixture.Stub(x => x.IsAFixture()).Return(true); fixture.Stub(x => x.Policies).Return(policies); fixture.Stub(x => x.PossibleGrammarsFor(null)).IgnoreArguments().Return(grammars); new GrammarSelector(fixture).Build().ToString().ShouldNotContain(GrammarConstants.TAGS_LABEL); }
public DataRowMapping(IDataRowMapping mapping, IListener listener, IPolicies policies, ICompilerMessageBuilder compilerMessageBuilder) { InterfaceName = mapping.InterfaceName; foreach (var columnMapping in mapping.ColumnMappings) { var item = new ResultSetColumnMapping(columnMapping, listener, policies, compilerMessageBuilder); this.Mappings.Add(item); this.m_ixColumnMappingByColumnName.Add(item.ColumnName, item); } }
private static AsyncInjectOutcomePolicy CreateRetryChaosAsync(IPolicies policies) { var fault = new PostgresException(string.Empty, string.Empty, string.Empty, ChaosPolicyShared.GetRandomString(RetryablePostGreErrors.Errors.ToList())); return(MonkeyPolicy.InjectExceptionAsync(with => with.Fault(fault) .InjectionRate((context, token) => ChaosPolicyShared.InjectionRateAsync(context, RetryConstants.RetryCount, RetryAttempts)) .Enabled(policies.EnableChaos) )); }
public PoliciesRepositoryTest() { iChildrenAndExtraBedPoliciesConnectionLibrary = new Mock <IConnection <ChildrenAndExtraBedPolicies> >(); iMaxChildAndExtraBedPerRoomConnectionLibrary = new Mock <IConnection <MaxChildAndExtraBedPerRoom> >(); iCancellationChargesConnectionLibrary = new Mock <IConnection <CancellationCharges> >(); iCancellationPolicyConnectionLibrary = new Mock <IConnection <CancellationPolicy> >(); iCancellationPolicyClausesConnectionLibrary = new Mock <IConnection <CancellationPolicyClauses> >(); iCancellationPolicyTypeConnectionLibrary = new Mock <IConnection <CancellationPolicyType> >(); iRoomConnectionLibrary = new Mock <IConnection <Room> >(); policiesRepository = new ER.PoliciesRepository(iChildrenAndExtraBedPoliciesConnectionLibrary.Object, iMaxChildAndExtraBedPerRoomConnectionLibrary.Object, iCancellationChargesConnectionLibrary.Object, iCancellationPolicyConnectionLibrary.Object, iCancellationPolicyClausesConnectionLibrary.Object, iCancellationPolicyTypeConnectionLibrary.Object, iRoomConnectionLibrary.Object); }
private static InjectOutcomePolicy CreateRetryChaos(IPolicies policies) { var fault = new SQLiteException( (SQLiteErrorCode)ChaosPolicyShared.GetRandomEnum <RetryableSqlErrors>(), "Policy chaos testing"); return(MonkeyPolicy.InjectException(with => with.Fault(fault) .InjectionRate((context, token) => ChaosPolicyShared.InjectionRate(context, RetryConstants.RetryCount, RetryAttempts)) .Enabled(policies.EnableChaos) )); }
public TableValueProperty( ITableValueProperty other, IListener listener, IPolicies policies, ICompilerMessageBuilder messageProvider, int propertyIndex) : base(other, listener, policies, messageProvider, propertyIndex) { this.DataRowInterfaceName = other.DataRowInterfaceName ?? typeof(object).FullName; if (ReferenceEquals(other.DataRowInterfaceName, null)) listener.Error(messageProvider.MissingDataRowInterfaceName(propertyIndex)); else if(false == policies.IsValidInterfaceName(this.DataRowInterfaceName)) listener.Error(messageProvider.InvalidDataRowInterfaceName(this.DataRowInterfaceName, propertyIndex)); }
public BasicProperty( IBasicProperty other, IListener listener, IPolicies policies, ICompilerMessageBuilder messageProvider, int propertyIndex) : base(other, listener, policies, messageProvider, propertyIndex) { messageProvider = messageProvider ?? new CompilerMessageBuilder(); this.PropertyTypeName = other.PropertyTypeName ?? typeof(object).FullName; if(false == policies.IsValidBasicPropertyTypeName(other.PropertyTypeName)) listener.Error(messageProvider.InvalidBasicPropertyTypeName(this.PropertyName, other.PropertyTypeName)); }
public XArgs( IListener listener, IPolicies policies, ICompilerMessageBuilder messageBuilder) { if(ReferenceEquals(listener, null)) throw new ArgumentNullException(nameof(listener)); if (ReferenceEquals(policies, null)) throw new ArgumentNullException(nameof(policies)); if (ReferenceEquals(messageBuilder, null)) throw new ArgumentNullException(nameof(messageBuilder)); this.Listener = listener; this.Policies = policies; this.MessageBuilder = messageBuilder; }
public MyPolicesRepository() { MyPolicies = new List <IPolicy>(); using (var context = new ZZContext()) { var permissaoTelaRep = new Repository <PermissaoTela>(context); var tipoPermissaoRep = new Repository <TipoPermissao>(context); var allTelas = permissaoTelaRep.Get().Result; var allPermissoes = tipoPermissaoRep.Get().Result; foreach (var tela in allTelas) { foreach (var permissao in allPermissoes) { MyPolicies.Add(new Policy(tela, permissao)); } } } _instance = this; }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='id'> /// </param> /// <param name='options'> /// </param> public static PolicyDTO SetPolicyOption(this IPolicies operations, long?id, PolicyOptionDTO options) { return(Task.Factory.StartNew(s => ((IPolicies)s).SetPolicyOptionAsync(id, options), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
/// <summary> /// Initializes a new instance of the <see cref="SendMessagesPolicyDecorator" /> class. /// </summary> /// <param name="policies">The policies.</param> /// <param name="handler">The handle.</param> public SendMessagesPolicyDecorator(IPolicies policies, ISendMessages handler) { _policies = policies; _handler = handler; }
public void ReadFrom(IFixture fixture, FixtureLibrary library) { FixtureClassName = fixture.GetType().FullName; FixtureNamespace = fixture.GetType().Namespace; Policies = fixture.Policies; Description = fixture.Description; Label = fixture.Title.IsEmpty() ? Name : fixture.Title; fixture.Errors.Each(x => { x.Node = this; LogError(x); }); fixture.ForEachGrammar((key, grammar) => readGrammar(grammar, key, library)); }
private static async Task <bool> Enabled(Context arg, IPolicies policy) { return(await ChaosPolicyShared.RunAsync(() => policy.EnableChaos)); }
/// <param name='operations'> /// The operations group for this extension method. /// </param> public static long?Create(this IPolicies operations) { return(Task.Factory.StartNew(s => ((IPolicies)s).CreateAsync(), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
private static InjectBehaviourPolicy CreateRetryChaos(IPolicies policies) { return(MonkeyPolicy.InjectBehaviour(Behaviour, (context) => ChaosPolicyShared.InjectionRate(context, RetryConstants.RetryCount, RetryAttempts), (context) => policies.EnableChaos)); }
private static AsyncInjectBehaviourPolicy CreateRetryChaosAsync(IPolicies policies) { return(MonkeyPolicy.InjectBehaviourAsync(Behaviour, (context) => InjectionRate(context, RetryConstants.RetryCount, RetryAttempts), (context) => Enabled(context, policies))); }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <long?> CreateAsync(this IPolicies operations, CancellationToken cancellationToken = default(CancellationToken)) { HttpOperationResponse <long?> result = await operations.CreateWithHttpMessagesAsync(null, cancellationToken).ConfigureAwait(false); return(result.Body); }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='id'> /// </param> /// <param name='options'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <PolicyDTO> SetPolicyOptionAsync(this IPolicies operations, long?id, PolicyOptionDTO options, CancellationToken cancellationToken = default(CancellationToken)) { HttpOperationResponse <PolicyDTO> result = await operations.SetPolicyOptionWithHttpMessagesAsync(id, options, null, cancellationToken).ConfigureAwait(false); return(result.Body); }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='transactionId'> /// </param> public static object MarkAsPaid(this IPolicies operations, string transactionId) { return(Task.Factory.StartNew(s => ((IPolicies)s).MarkAsPaidAsync(transactionId), operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
public PoliciesController(IPolicies iPolicies) { this.iPolicies = iPolicies; }
/// <param name='operations'> /// The operations group for this extension method. /// </param> /// <param name='transactionId'> /// </param> /// <param name='cancellationToken'> /// The cancellation token. /// </param> public static async Task <object> MarkAsPaidAsync(this IPolicies operations, string transactionId, CancellationToken cancellationToken = default(CancellationToken)) { HttpOperationResponse <object> result = await operations.MarkAsPaidWithHttpMessagesAsync(transactionId, null, cancellationToken).ConfigureAwait(false); return(result.Body); }