private async Task IsModulus(object modulusOf, string modulusAsString, object isAModulus, object notAModulus)
        {
            var config = new EventRuleDto
            {
                Type   = EventRuleType.Modulus,
                Source = EventRuleSource.EventParameter,
                EventParameterNumber = 1,
                Value = modulusAsString
            };

            var rule = new EventRule(_mockEventSubscription.Object, 1, config);

            var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi);

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = modulusOf;
            Assert.True(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = isAModulus;
            Assert.True(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null;
            Assert.False(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = notAModulus;
            Assert.False(await rule.HandleAsync(decodedEvent));
        }
        private async Task IsLessOrEqual(object maxValue, string maxValueAsString, object higherValue, object lesserValue)
        {
            var config = new EventRuleDto
            {
                Type   = EventRuleType.LessThanOrEqualTo,
                Source = EventRuleSource.EventParameter,
                EventParameterNumber = 1,
                Value = maxValueAsString
            };

            var rule = new EventRule(_mockEventSubscription.Object, 1, config);

            var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi);

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = maxValue;
            Assert.True(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = lesserValue;
            Assert.True(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null;
            Assert.False(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = higherValue;
            Assert.False(await rule.HandleAsync(decodedEvent));
        }
        public async Task IsEmpty()
        {
            var config = new EventRuleDto
            {
                Type   = EventRuleType.Empty,
                Source = EventRuleSource.EventParameter,
                EventParameterNumber = 1
            };

            var rule = new EventRule(_mockEventSubscription.Object, 1, config);

            var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi);

            Assert.False(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null;
            Assert.True(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = string.Empty;
            Assert.True(await rule.HandleAsync(decodedEvent));
        }
        private async Task IsEqual(object val, string valAsString, object differentValue)
        {
            var config = new EventRuleDto
            {
                Type   = EventRuleType.Equals,
                Source = EventRuleSource.EventParameter,
                EventParameterNumber = 1,
                Value = valAsString
            };

            var rule = new EventRule(_mockEventSubscription.Object, 1, config);

            var decodedEvent = _sampleTransferLog.ToDecodedEvent(_transferEventAbi);

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = val;
            Assert.True(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = null;
            Assert.False(await rule.HandleAsync(decodedEvent));

            decodedEvent.Event.First(p => p.Parameter.Order == config.EventParameterNumber).Result = differentValue;
            Assert.False(await rule.HandleAsync(decodedEvent));
        }
Exemplo n.º 5
0
        public async Task EventRules()
        {
            var dto1 = new EventRuleDto {
                EventHandlerId       = 900,
                EventParameterNumber = 1,
                InputName            = "From",
                Source = EventRuleSource.EventParameter,
                Type   = EventRuleType.GreaterOrEqualTo,
                Value  = "10"
            };

            var dto2 = new EventRuleDto
            {
                EventHandlerId = 901,
                InputName      = "RunningTotal",
                Source         = EventRuleSource.EventState,
                Type           = EventRuleType.LessThanOrEqualTo,
                Value          = "10"
            };

            await Fixture.ConfigRepo.EventRules.UpsertAsync(dto1);

            await Fixture.ConfigRepo.EventRules.UpsertAsync(dto2);

            var fromRepo1 = await Fixture.ConfigRepo.EventRules.GetAsync(dto1.EventHandlerId);

            var fromRepo2 = await Fixture.ConfigRepo.EventRules.GetAsync(dto2.EventHandlerId);

            Assert.Equal(dto1.EventHandlerId, fromRepo1.EventHandlerId);
            Assert.Equal(dto1.EventParameterNumber, fromRepo1.EventParameterNumber);
            Assert.Equal(dto1.InputName, fromRepo1.InputName);
            Assert.Equal(dto1.Source, fromRepo1.Source);
            Assert.Equal(dto1.Type, fromRepo1.Type);
            Assert.Equal(dto1.Value, fromRepo1.Value);

            Assert.Equal(dto2.EventHandlerId, fromRepo2.EventHandlerId);
        }