public static async Task AnalyseViews_GivenViewWithColumnNameContainingWhitespace_ProducesMessages()
        {
            var rule     = new WhitespaceNameRule(RuleLevel.Error);
            var viewName = new Identifier("test");

            var testColumn = new DatabaseColumn(
                "   test_column   ",
                Mock.Of <IDbType>(),
                false,
                null,
                null
                );

            var view = new DatabaseView(
                viewName,
                "select 1",
                new List <IDatabaseColumn> {
                testColumn
            }
                );
            var views = new[] { view };

            var hasMessages = await rule.AnalyseViews(views).AnyAsync().ConfigureAwait(false);

            Assert.That(hasMessages, Is.True);
        }
        public static async Task AnalyseTables_GivenTableWithColumnNameContainingWhitespace_ProducesMessages()
        {
            var rule = new WhitespaceNameRule(RuleLevel.Error);

            var testColumn = new DatabaseColumn(
                "   test_column ",
                Mock.Of <IDbType>(),
                false,
                null,
                null
                );

            var table = new RelationalDatabaseTable(
                "test",
                new List <IDatabaseColumn> {
                testColumn
            },
                null,
                Array.Empty <IDatabaseKey>(),
                Array.Empty <IDatabaseRelationalKey>(),
                Array.Empty <IDatabaseRelationalKey>(),
                Array.Empty <IDatabaseIndex>(),
                Array.Empty <IDatabaseCheckConstraint>(),
                Array.Empty <IDatabaseTrigger>()
                );
            var tables = new[] { table };

            var hasMessages = await rule.AnalyseTables(tables).AnyAsync().ConfigureAwait(false);

            Assert.That(hasMessages, Is.True);
        }
        public static async Task AnalyseRoutines_GivenRoutineWithNameContainingWhitespace_ProducesMessages()
        {
            var rule        = new WhitespaceNameRule(RuleLevel.Error);
            var routineName = new Identifier("   test   ");

            var routine  = new DatabaseRoutine(routineName, "routine_definition");
            var routines = new[] { routine };

            var hasMessages = await rule.AnalyseRoutines(routines).AnyAsync().ConfigureAwait(false);

            Assert.That(hasMessages, Is.True);
        }
        public static async Task AnalyseSynonyms_GivenSynonymWithNameContainingWhitespace_ProducesMessages()
        {
            var rule        = new WhitespaceNameRule(RuleLevel.Error);
            var synonymName = new Identifier("   test   ");

            var synonym  = new DatabaseSynonym(synonymName, "target");
            var synonyms = new[] { synonym };

            var hasMessages = await rule.AnalyseSynonyms(synonyms).AnyAsync().ConfigureAwait(false);

            Assert.That(hasMessages, Is.True);
        }
        public static async Task AnalyseViews_GivenViewWithRegularName_ProducesNoMessages()
        {
            var rule     = new WhitespaceNameRule(RuleLevel.Error);
            var viewName = new Identifier("test");

            var view = new DatabaseView(
                viewName,
                "select 1",
                new List <IDatabaseColumn>()
                );
            var views = new[] { view };

            var hasMessages = await rule.AnalyseViews(views).AnyAsync().ConfigureAwait(false);

            Assert.That(hasMessages, Is.False);
        }
        public static async Task AnalyseSequences_GivenSequenceWithNameContainingWhitespace_ProducesMessages()
        {
            var rule         = new WhitespaceNameRule(RuleLevel.Error);
            var sequenceName = new Identifier("   test   ");

            var sequence = new DatabaseSequence(
                sequenceName,
                1,
                1,
                1,
                100,
                true,
                10
                );
            var sequences = new[] { sequence };

            var hasMessages = await rule.AnalyseSequences(sequences).AnyAsync().ConfigureAwait(false);

            Assert.That(hasMessages, Is.True);
        }
        public static async Task AnalyseTables_GivenTableWithRegularName_ProducesNoMessages()
        {
            var rule      = new WhitespaceNameRule(RuleLevel.Error);
            var tableName = new Identifier("test");

            var table = new RelationalDatabaseTable(
                tableName,
                new List <IDatabaseColumn>(),
                null,
                Array.Empty <IDatabaseKey>(),
                Array.Empty <IDatabaseRelationalKey>(),
                Array.Empty <IDatabaseRelationalKey>(),
                Array.Empty <IDatabaseIndex>(),
                Array.Empty <IDatabaseCheckConstraint>(),
                Array.Empty <IDatabaseTrigger>()
                );
            var tables = new[] { table };

            var hasMessages = await rule.AnalyseTables(tables).AnyAsync().ConfigureAwait(false);

            Assert.That(hasMessages, Is.False);
        }
        public static void AnalyseRoutines_GivenNullRoutines_ThrowsArgumentNullException()
        {
            var rule = new WhitespaceNameRule(RuleLevel.Error);

            Assert.That(() => rule.AnalyseRoutines(null), Throws.ArgumentNullException);
        }