Пример #1
0
        private static void AddTestRules(SqlAssessmentService service)
        {
            const string TestRuleset = @"
            {
                'name': 'Tags & Checks',
                'version': '0.3',
                'schemaVersion': '1.0',
                'rules': [
                    {
                        'id': 'ServerRule',
                        'itemType': 'definition',
                        'tags': [ 'Test' ],
                        'displayName': 'Test server check',
                        'description': 'This check always fails for testing purposes.',
                        'message': 'This check intentionally fails',
                        'target': { 'type': 'Server' }
                    },
                    {
                        'id': 'DatabaseRule',
                        'itemType': 'definition',
                        'tags': [ 'Test' ],
                        'displayName': 'Test server check',
                        'description': 'This check always fails for testing purposes.',
                        'message': 'This check intentionally fails',
                        'target': { 'type': 'Database' }
                    }
                ]
            }
";

            using (var reader = new StringReader(TestRuleset))
            {
                service.Engine.PushRuleFactoryJson(reader);
            }
        }
Пример #2
0
        private static async Task <AssessmentResult <TResult> > CallAssessment <TResult>(
            string methodName,
            SqlObjectType sqlObjectType,
            LiveConnectionHelper.TestConnectionResult liveConnection)
            where TResult : AssessmentItemInfo
        {
            var connInfo = liveConnection.ConnectionInfo;

            AssessmentResult <TResult> response;

            using (var service = new SqlAssessmentService(
                       TestServiceProvider.Instance.ConnectionService,
                       TestServiceProvider.Instance.WorkspaceService))
            {
                AddTestRules(service);

                string           randomUri     = Guid.NewGuid().ToString();
                AssessmentParams requestParams =
                    new AssessmentParams {
                    OwnerUri = randomUri, TargetType = sqlObjectType
                };
                ConnectParams connectParams = new ConnectParams
                {
                    OwnerUri   = requestParams.OwnerUri,
                    Connection = connInfo.ConnectionDetails,
                    Type       = ConnectionType.Default
                };

                var methodInfo = typeof(SqlAssessmentService).GetMethod(
                    methodName,
                    BindingFlags.Instance | BindingFlags.NonPublic);

                Assert.NotNull(methodInfo);

                var func = (AssessmentMethod <TResult>)Delegate.CreateDelegate(
                    typeof(AssessmentMethod <TResult>),
                    service,
                    methodInfo);

                response = await service.CallAssessmentEngine <TResult>(
                    requestParams,
                    connectParams,
                    randomUri,
                    t => func(t));
            }

            Assert.NotNull(response);
            if (response.Success)
            {
                Assert.All(
                    response.Items,
                    i =>
                {
                    Assert.Equal(sqlObjectType, i.TargetType);
                    Assert.Contains(i.Level, AllowedSeverityLevels);
                });
            }

            return(response);
        }