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;
 }
Ejemplo n.º 2
0
 /// <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));
 }
Ejemplo n.º 4
0
 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;
        }
Ejemplo n.º 6
0
        /// <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;
        }
Ejemplo n.º 7
0
 public BlobProperty(
         IProperty other,
         IListener listener,
         IPolicies policies,
         ICompilerMessageBuilder messageProvider,
         int propertyIndex)
     : base(other, listener, policies, messageProvider, propertyIndex)
 {
 }
Ejemplo n.º 8
0
        /// <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;
        }
Ejemplo n.º 9
0
 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));
 }
Ejemplo n.º 10
0
 public Users(
     IServicesConfig config,
     ILogger log,
     IPolicies policies)
 {
     this.config   = config;
     this.log      = log;
     this.policies = policies;
     this.rolesKey = this.config.JwtRolesFrom.ToLowerInvariant();
 }
Ejemplo n.º 11
0
        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);
        }
Ejemplo n.º 12
0
        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);
        }
Ejemplo n.º 13
0
        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);
        }
Ejemplo n.º 14
0
        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);
            }
        }
Ejemplo n.º 15
0
        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)
                                                     ));
        }
Ejemplo n.º 16
0
 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)
                                                ));
        }
Ejemplo n.º 18
0
 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));
 }
Ejemplo n.º 19
0
        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));
        }
Ejemplo n.º 20
0
        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;
        }
Ejemplo n.º 21
0
        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;
        }
Ejemplo n.º 22
0
 /// <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;
 }
Ejemplo n.º 24
0
        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));
 }
Ejemplo n.º 26
0
 /// <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)));
 }
Ejemplo n.º 29
0
        /// <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);
        }
Ejemplo n.º 30
0
        /// <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);
        }
Ejemplo n.º 31
0
 /// <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());
 }
Ejemplo n.º 32
0
 public PoliciesController(IPolicies iPolicies)
 {
     this.iPolicies = iPolicies;
 }
Ejemplo n.º 33
0
        /// <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);
        }