public static void Build_GivenNoProviders_ReturnsEmptyRuleSet()
        {
            var dbConnection = Mock.Of <IDbConnectionFactory>();
            var dialect      = Mock.Of <IDatabaseDialect>();
            var connection   = new SchematicConnection(dbConnection, dialect);

            var ruleProvider = new RuleProviderBuilder().Build();
            var rules        = ruleProvider.GetRules(connection, RuleLevel.Error);

            Assert.That(rules, Is.Empty);
        }
        public static void Build_GivenDefaultProviderViaGeneric_ReturnsNonEmptyRuleSet()
        {
            var dbConnection = Mock.Of <IDbConnectionFactory>();
            var dialect      = Mock.Of <IDatabaseDialect>();
            var connection   = new SchematicConnection(dbConnection, dialect);

            var ruleProvider = new RuleProviderBuilder()
                               .AddRuleProvider <DefaultRuleProvider>()
                               .Build();
            var rules = ruleProvider.GetRules(connection, RuleLevel.Error);

            Assert.That(rules, Is.Not.Empty);
        }
        /// <summary>
        /// Retrieves the set of rules used to analyze database objects for reporting.
        /// </summary>
        /// <param name="connection">A schematic connection.</param>
        /// <param name="level">The level used for reporting.</param>
        /// <returns>Rules used for analyzing database objects.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="connection"/> is <c>null</c>.</exception>
        /// <exception cref="ArgumentException"><paramref name="level"/> does not have a valid enum value.</exception>
        public IEnumerable <IRule> GetRules(ISchematicConnection connection, RuleLevel level)
        {
            if (connection == null)
            {
                throw new ArgumentNullException(nameof(connection));
            }
            if (!level.IsValid())
            {
                throw new ArgumentException($"The { nameof(RuleLevel) } provided must be a valid enum.", nameof(level));
            }

            var ruleProvider = new RuleProviderBuilder()
                               .AddRuleProvider <DefaultHtmlRuleProvider>()
                               .AddRuleProvider <PluginProvider>()
                               .Build();

            return(ruleProvider.GetRules(connection, level));
        }
        public static void Build_GivenMultipleProviders_ReturnsExpectedRuleCount()
        {
            var dbConnection = Mock.Of <IDbConnectionFactory>();
            var dialect      = Mock.Of <IDatabaseDialect>();
            var connection   = new SchematicConnection(dbConnection, dialect);

            var defaultProvider = new DefaultRuleProvider();
            var defaultRules    = defaultProvider.GetRules(connection, RuleLevel.Error).ToList();
            var expectedCount   = defaultRules.Count * 2;

            var ruleProvider = new RuleProviderBuilder()
                               .AddRuleProvider(defaultProvider)
                               .AddRuleProvider(defaultProvider)
                               .Build();

            var builderRules = ruleProvider.GetRules(connection, RuleLevel.Error);

            Assert.That(builderRules, Has.Exactly(expectedCount).Items);
        }