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));
        }
        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));
        }
        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));
        }