protected override void Context()
 {
     _report         = new DiffReport();
     _commonAncestor = new Container();
     _settings       = new ComparerSettings();
     CreateSut();
 }
Beispiel #2
0
        public void GenerateDiffReport(DiffReport diffReport)
        {
            var path     = Path.Combine(ReportFolderPath, $"report_{DateTime.Now.ToString(DateFormat)}.xlsx");
            var fileInfo = new FileInfo(path);

            fileInfo.Directory.Create();//creating a dir if does not exist

            using (var excelPackage = new ExcelPackage(fileInfo))
            {
                var worksheet = excelPackage.Workbook.Worksheets.Add("report");

                InitializeTableHeaders(worksheet);
                var lastRow = GenerateMismatchPart(worksheet, diffReport.Mismatches);
                SetFilterForTable(worksheet, lastRow - 1);//filtering only mismatches

                SetSeparator(worksheet.Cells[lastRow, ExcelReport.ColumnOffset, lastRow, ExcelReport.DataEndColumn - 1]);
                SetMissingFromEipHeader(worksheet, ++lastRow, diffReport.CheckedRange);
                lastRow = GenerateMissingEipProductPart(worksheet, diffReport.ProductsMissingFromEip, ++lastRow);

                SetSeparator(worksheet.Cells[lastRow, ExcelReport.ColumnOffset, lastRow, ExcelReport.DataEndColumn - 1]);
                SetEipHeader(worksheet, lastRow, ExcelReport.ProductsMissingFromExcel, diffReport.CheckedRange);
                lastRow = GenerateMissingExcelProductPart(worksheet, diffReport.ProductsMissingFromExcel, ++lastRow);

                SetSeparator(worksheet.Cells[++lastRow, ExcelReport.ColumnOffset, lastRow, ExcelReport.DataEndColumn - 1]);
                SetOutOfRangeEiplHeader(worksheet, lastRow, diffReport.CheckedRange);
                lastRow = GenerateOutOfRangeProductPart(worksheet, diffReport.ProductsOutOfSelectedRange, ++lastRow);

                excelPackage.Save();
            }
        }
Beispiel #3
0
 public Comparison(TObject object1, TObject object2, ComparerSettings settings, DiffReport report, object commonAncestor)
 {
     Object1        = object1;
     Object2        = object2;
     Settings       = settings;
     Report         = report;
     CommonAncestor = commonAncestor;
 }
Beispiel #4
0
 private Task GenerateExcelReportAsync(DiffReport diffReport)
 {
     return(Task.Run(() =>
     {
         _logService.Information("Start generating excel report");
         _lifetimeService.ExecuteInLifetime <IReportGenerator>(generator => generator.GenerateDiffReport(diffReport));
     }));
 }
Beispiel #5
0
            protected internal virtual void CompareWith(PropertiesRep other, DiffReport diff)
            {
                bool equals = Props.Equals(other.Props);

                if (!equals)
                {
                    diff.Add("Properties diff for " + EntityToString + " mine:" + Props + ", other:" + other.Props);
                }
            }
Beispiel #6
0
        private void ReportDiff(GeneratedDaoAssemblyInfo info, TypeSchema typeSchema)
        {
            OldInfoString = info.TypeSchemaInfo ?? string.Empty;
            NewInfoString = typeSchema.ToString();
            DiffReport diff = DiffReport.Create(OldInfoString, NewInfoString);
            ConsoleDiffReportFormatter diffFormatter = new ConsoleDiffReportFormatter(diff);

            diffFormatter.Format(); // outputs to console
            FireEvent(SchemaDifferenceDetected, new SchemaDifferenceEventArgs {
                GeneratedDaoAssemblyInfo = info, TypeSchema = typeSchema, DiffReport = diff
            });
        }
Beispiel #7
0
 internal virtual void CompareWith(NodeRep other, DiffReport diff)
 {
     if (other.Id != Id)
     {
         diff.Add("Id differs mine:" + Id + ", other:" + other.Id);
     }
     Properties.compareWith(other.Properties, diff);
     if (Index != null && other.Index != null)
     {
         CompareIndex(other, diff);
     }
     CompareRelationships(other, diff);
 }
            public void Its_possible_to_exclude_by_member_path()
            {
                var diff = new DiffReport();
                diff.ReportDiff("Id", 1, 2);
                diff.ReportDiff("Name", "Gøran", "Torkild");
                diff.ReportDiff("Age", 30, 40);

                diff.SetFilter(
                    new RegexMemberPathExcludeFilter("Id"),
                    new RegexMemberPathExcludeFilter("Age"));

                Assert.AreEqual(1, diff.Table.Rows.Count());
                Assert.AreEqual("Name", diff.Table[0].MemberPath);
            }
            public void Its_possible_to_filter_by_member_path_and_values()
            {
                var diff = new DiffReport();
                diff.ReportDiff("Name", "Gøran", "Torkild");
                diff.ReportDiff("Age", 30, 42);
                diff.ReportDiff("Weight", 230, 460);

                diff.SetFilter(new ValueInspectionFilter<int>("Age",
                    (leftValue, rightValue) => leftValue > 30));

                Assert.AreEqual(2, diff.Table.Rows.Count());
                Assert.AreEqual("Name", diff.Table[0].MemberPath);
                Assert.AreEqual("Weight", diff.Table[1].MemberPath);
            }
Beispiel #10
0
        protected override void Context()
        {
            _view = A.Fake <IComparisonView>();
            _diffItemDTOMapper = A.Fake <IDiffItemToDiffItemDTOMapper>();
            _objectComparer    = A.Fake <IObjectComparer>();
            _dataTableMapper   = A.Fake <IDiffItemDTOsToDataTableMapper>();
            sut = new ComparisonPresenter(_view, _objectComparer, _diffItemDTOMapper, _dataTableMapper);

            _settings = new ComparerSettings();
            _object1  = A.Fake <IObjectBase>();
            _object2  = A.Fake <IObjectBase>();
            _report   = new DiffReport();

            A.CallTo(() => _objectComparer.Compare(_object1, _object2, _settings)).Returns(_report);
        }
        /// <summary>
        /// デフォルトコンストラクタ
        /// </summary>
        /// <param name="report">比較結果</param>
        public MargeDialog(DiffReport report)
            : base()
        {
            InitializeComponent();


            if (DesignMode)
                return;

            // コンボボックスのアイテムを積む
            actionColumn.Items.Clear();
            actionColumn.Items.AddRange(SOURCE, DESTINATION, EMPTY, DELETE);

            DiffReport = report;
        }
Beispiel #12
0
 private void ConstraintDiff(DbRepresentation other, DiffReport diff)
 {
     foreach (ConstraintDefinition constraint in _constraints)
     {
         if (!other._constraints.Contains(constraint))
         {
             diff.Add("I have constraint " + constraint + " which other doesn't");
         }
     }
     foreach (ConstraintDefinition otherConstraint in other._constraints)
     {
         if (!_constraints.Contains(otherConstraint))
         {
             diff.Add("Other has constraint " + otherConstraint + " which I don't");
         }
     }
 }
Beispiel #13
0
 private void IndexDiff(DbRepresentation other, DiffReport diff)
 {
     foreach (IndexDefinition schemaIndex in _schemaIndexes)
     {
         if (!other._schemaIndexes.Contains(schemaIndex))
         {
             diff.Add("I have schema index " + schemaIndex + " which other doesn't");
         }
     }
     foreach (IndexDefinition otherSchemaIndex in other._schemaIndexes)
     {
         if (!_schemaIndexes.Contains(otherSchemaIndex))
         {
             diff.Add("Other has schema index " + otherSchemaIndex + " which I don't");
         }
     }
 }
Beispiel #14
0
            /*
             * Yes, this is not the best way to do it - hash map does a deep equals. However,
             * if things go wrong, this way give the ability to check where the inequality
             * happened. If you feel strongly about this, feel free to change.
             * Admittedly, the implementation could use some cleanup.
             */
            internal virtual void CompareIndex(NodeRep other, DiffReport diff)
            {
                if (other.Index == Index)
                {
                    return;
                }
                ICollection <string> allIndexes = new HashSet <string>();

                allIndexes.addAll(Index.Keys);
                allIndexes.addAll(other.Index.Keys);
                foreach (string indexName in allIndexes)
                {
                    if (!Index.ContainsKey(indexName))
                    {
                        diff.Add(this + " isn't indexed in " + indexName + " for mine");
                        continue;
                    }
                    if (!other.Index.ContainsKey(indexName))
                    {
                        diff.Add(this + " isn't indexed in " + indexName + " for other");
                        continue;
                    }

                    IDictionary <string, Serializable> thisIndex  = Index[indexName];
                    IDictionary <string, Serializable> otherIndex = other.Index[indexName];

                    if (thisIndex.Count != otherIndex.Count)
                    {
                        diff.Add("other index had a different mapping count than me for node " + this + " mine:" + thisIndex + ", other:" + otherIndex);
                        continue;
                    }

                    foreach (KeyValuePair <string, Serializable> indexEntry in thisIndex.SetOfKeyValuePairs())
                    {
                        if (!indexEntry.Value.Equals(otherIndex[indexEntry.Key]))
                        {
                            diff.Add("other index had a different value indexed for " + indexEntry.Key + "=" + indexEntry.Value + ", namely " + otherIndex[indexEntry.Key] + " for " + this);
                        }
                    }
                }
            }
Beispiel #15
0
        private void NodeDiff(DbRepresentation other, DiffReport diff)
        {
            foreach (NodeRep node in _nodes.Values)
            {
                NodeRep otherNode = other._nodes[node.Id];
                if (otherNode == null)
                {
                    diff.Add("I have node " + node.Id + " which other doesn't");
                    continue;
                }
                node.CompareWith(otherNode, diff);
            }

            foreach (long?id in other._nodes.Keys)
            {
                if (!_nodes.ContainsKey(id))
                {
                    diff.Add("Other has node " + id + " which I don't");
                }
            }
        }
Beispiel #16
0
            internal virtual void CompareRelationships(NodeRep other, DiffReport diff)
            {
                foreach (PropertiesRep rel in OutRelationships.Values)
                {
                    PropertiesRep otherRel = other.OutRelationships[rel.EntityId];
                    if (otherRel == null)
                    {
                        diff.Add("I have relationship " + rel.EntityId + " which other don't");
                        continue;
                    }
                    rel.CompareWith(otherRel, diff);
                }

                foreach (long?id in other.OutRelationships.Keys)
                {
                    if (!OutRelationships.ContainsKey(id))
                    {
                        diff.Add("Other has relationship " + id + " which I don't");
                    }
                }
            }
Beispiel #17
0
            public void It_is_possible_to_exclude_many_diffs_using_filters()
            {
                var diff = new DiffReport();
                diff.ReportDiff("StatusLog.LogItems[0].Timestamp", "", "");
                diff.ReportDiff("StatusLog.LogItems[1].Timestamp", "", "");
                diff.ReportDiff("JobIds[0]", 277540, 277906);
                diff.ReportDiff("JobIds[1]", 277541, 277907);
                diff.ReportDiff("JobIds[2]", 277542, 277908);
                diff.ReportDiff("CreatedBy", "toinds", "gohans");

                diff.SetFilter(new RegexMemberPathExcludeFilter(
                    "^MathModelCaseId$|" +
                    @"^CaseSnapshot\.MetaData\.Name$|" +
                    @"^CaseSnapshot\.MetaData\.Category$|" +
                    @"^Id$|\.Id$|" +
                    @"^StatusLog\.LogItems\[\d*\]\.Timestamp$|" +
                    @"^JobIds\[\d*\]$|" +
                    @"^CopyProperties.Name$|" +
                    @"^Timestamp$|" +
                    @"^CreatedBy$|" +
                    @"^CreatedWhen$"));

                Assert.AreEqual(0, diff.Table.Rows.Count());
            }
Beispiel #18
0
        // Public methods
        public async Task CheckServiceForApiChanges(string webServiceName, string previousApiDocumentJSON, string freshApiDocumentJSON)
        {
            // Convert serialized JSON swagger definition into instances of OpenApiDocuments
            OpenApiDocument previousApiDocument = GetDeserializedJsonAsOpenApiDocument(previousApiDocumentJSON);
            OpenApiDocument freshApiDocument    = GetDeserializedJsonAsOpenApiDocument(freshApiDocumentJSON);

            // Create instance of DiffReport class to store API changes
            DiffReport diffReport = new DiffReport(webServiceName);

            // Create array of tasks
            Task[] tasks = new Task[] {
                Task.Run(() => CheckForApiRouteAndHttpMethodAdditions(previousApiDocument, freshApiDocument, diffReport)),
                Task.Run(() => CheckForApiRouteAndHttpMethodRemovals(previousApiDocument, freshApiDocument, diffReport))
            };

            // Run all tasks in parallell
            await Task.WhenAll(tasks);

            // Get slack message JSON from diff report
            JObject slackMessage = diffReport.GenerateSlackMessageContent();

            // Make Client request to post slack message
            _clientRequestService.SendSlackMessage(diffReport.WebServiceName, slackMessage);
        }
 public ConsoleDiffReportFormatter(DiffReport report) : base(report)
 {
 }
 protected override void Because()
 {
     _oneObject = new ARootContainer();
     _report1   = sut.Compare(null, _oneObject);
     _report2   = sut.Compare(_oneObject, null);
 }
 protected override void Because()
 {
     _report = sut.Compare(_object1, _object2, _comparerSettings);
 }
Beispiel #22
0
        /*** API document comparison checks ***/

        private void CheckForApiRouteAndHttpMethodAdditions(OpenApiDocument previousApiDocument, OpenApiDocument freshApiDocument, DiffReport diffReport)
        {
            // Get information for all routes in previous API documentation
            OpenApiPaths previousApiDocumentRoutes = previousApiDocument.Paths;

            // Get information for all routes in fresh API documentation
            OpenApiPaths freshApiDocumentRoutes = freshApiDocument.Paths;

            // Iterate over all routes in freshly downloaded API documentation
            foreach (KeyValuePair <string, OpenApiPathItem> route in freshApiDocumentRoutes)
            {
                // Find current API route as string
                string currentApiRoute = route.Key;

                // Check if this route in the fresh API documentation in a new addition
                if (!previousApiDocumentRoutes.ContainsKey(currentApiRoute))
                {
                    // NOTE: New route detected, therefore all HTTP methods associated with this route are new

                    // Find all HTTP methods associated with this route (HTTP methods represented as enum type OpenApi.Models.OperationType)
                    OpenApiPathItem newApiRouteValue = route.Value;
                    IDictionary <OperationType, OpenApiOperation> newApiRouteHttpMethodsDict = newApiRouteValue.Operations;

                    // Verify route has associated HTTP methods
                    if (newApiRouteHttpMethodsDict.Count > 0)
                    {
                        // Get list of all HTTP methods associated with this new route
                        IList <OperationType> newApiRouteHttpMethodTypes = new List <OperationType>(newApiRouteHttpMethodsDict.Keys);

                        // Iterate through the new route's HTTP methods
                        foreach (OperationType newApiRouteHttpMethod in newApiRouteHttpMethodTypes)
                        {
                            // Save added route/HTTP method information for API diff report
                            diffReport.RecordAddedRouteInformation(currentApiRoute, newApiRouteHttpMethod);
                        }
                    }
                }
                else
                {
                    // Previous API documentation already has this API route, check if there are any new HTTP methods for the existing route

                    // Get dictionary of HTTP methods for current route from fresh API documentation
                    OpenApiPathItem freshApiDocumentRouteValue = route.Value;
                    IDictionary <OperationType, OpenApiOperation> freshApiDocumentRouteInfo = freshApiDocumentRouteValue.Operations;

                    // Get dictionary of HTTP methods for current route from previous API documentation
                    OpenApiPathItem previousApiDocumentRouteValue = previousApiDocumentRoutes[currentApiRoute];
                    IDictionary <OperationType, OpenApiOperation> previousApiDocumentRouteInfo = previousApiDocumentRouteValue.Operations;

                    // Verify that fresh API documentation for this route contains HTTP methods
                    if (freshApiDocumentRouteInfo.Count > 0)
                    {
                        // For this route, get list of HTTP methods in fresh API documentation
                        IList <OperationType> freshApiRouteHttpMethods = new List <OperationType>(freshApiDocumentRouteInfo.Keys);

                        // For this route, get list of HTTP methods in previous API documentation
                        IList <OperationType> previousApiRouteHttpMethods = new List <OperationType>(previousApiDocumentRouteInfo.Keys);

                        // Iterate over all HTTP methods listed in fresh API documentation for this route
                        foreach (OperationType freshHttpMethod in freshApiRouteHttpMethods)
                        {
                            // For this route, if an HTTP method exists in fresh API documentation but not previous API documentation,
                            // We have found a new API endpoint
                            if (!previousApiRouteHttpMethods.Contains(freshHttpMethod))
                            {
                                // Record newly detected API endpoint in diff report object
                                diffReport.RecordAddedRouteInformation(currentApiRoute, freshHttpMethod);
                            }
                        }
                    }
                }
            }
        }
Beispiel #23
0
        private void CheckForApiRouteAndHttpMethodRemovals(OpenApiDocument previousApiDocument, OpenApiDocument freshApiDocument, DiffReport diffReport)
        {
            // Get information for all routes in previous API documentation
            OpenApiPaths previousApiDocumentRoutes = previousApiDocument.Paths;

            // Get information for all routes in fresh API documentation
            OpenApiPaths freshApiDocumentRoutes = freshApiDocument.Paths;

            // Iterate over all routes in previously stored API documentation
            foreach (KeyValuePair <string, OpenApiPathItem> route in previousApiDocumentRoutes)
            {
                // Find current API route as string
                string currentApiRoute = route.Key;

                // Check if this route in the previously downloaded API documentation has been removed
                if (!freshApiDocumentRoutes.ContainsKey(currentApiRoute))
                {
                    // NOTE: This route has been removed, therefore all HTTP methods associated with this route have been removed

                    // Find all HTTP methods associated with this route (HTTP methods represented as enum type OpenApi.Models.OperationType)
                    OpenApiPathItem removedApiRouteValue = route.Value;
                    IDictionary <OperationType, OpenApiOperation> removedApiRouteHttpMethodsDict = removedApiRouteValue.Operations;

                    // Verify route has associated HTTP methods
                    if (removedApiRouteHttpMethodsDict.Count > 0)
                    {
                        // Get list of all HTTP methods associated with this removed route
                        IList <OperationType> removedApiRouteHttpMethodTypes = new List <OperationType>(removedApiRouteHttpMethodsDict.Keys);

                        // Iterate through the removed route's HTTP methods
                        foreach (OperationType removedApiRouteHttpMethod in removedApiRouteHttpMethodTypes)
                        {
                            // Save removed route/HTTP method information for API diff report
                            diffReport.RecordRemovedRouteInformation(currentApiRoute, removedApiRouteHttpMethod);
                        }
                    }
                }
                else
                {
                    // New API documentation has this route, check if any HTTP methods have been removed

                    // Get dictionary of HTTP methods for current route from previous API documentation
                    OpenApiPathItem previousApiDocumentRouteValue = route.Value;
                    IDictionary <OperationType, OpenApiOperation> previousApiDocumentRouteInfo = previousApiDocumentRouteValue.Operations;

                    // Get dictionary of HTTP methods for current API route from fresh API documentation
                    OpenApiPathItem freshApiRouteValue = freshApiDocumentRoutes[currentApiRoute];
                    IDictionary <OperationType, OpenApiOperation> freshApiDocumentRouteInfo = freshApiRouteValue.Operations;

                    // Verify that previous API documentation for this route contains HTTP methods
                    if (previousApiDocumentRouteInfo.Count > 0)
                    {
                        // For this route, get list of HTTP methods in previous API documentation
                        IList <OperationType> previousApiRouteHttpMethods = new List <OperationType>(previousApiDocumentRouteInfo.Keys);

                        // For this route, get list of HTTP methods in fresh API documentation
                        IList <OperationType> freshApiRouteHttpMethods = new List <OperationType>(freshApiDocumentRouteInfo.Keys);

                        // Iterate over all HTTP methods listted in previous API documentation for this route
                        foreach (OperationType previousHttpMethod in previousApiRouteHttpMethods)
                        {
                            // For this route, if an HTTP method exists in previous API documentation but not fresh API documentation,
                            // We have detected the removal of an API endpoint
                            if (!freshApiRouteHttpMethods.Contains(previousHttpMethod))
                            {
                                // Record removal of API endpoint in diff report object
                                diffReport.RecordRemovedRouteInformation(currentApiRoute, previousHttpMethod);
                            }
                        }
                    }
                }
            }
        }
Beispiel #24
0
        public DiffReport GetDiffReport()
        {
            var report = new DiffReport();

            if (TablesAdded.Any() || TablesDeleted.Any() || TablesDiff.Any()) {
                var tables = report.AddCategory("Tables");

                foreach (var addedTable in TablesAdded) {
                    tables.AddEntry(addedTable.Name, DiffEntryType.Added, addedTable.ScriptCreate());
                }

                foreach (var deletedTable in TablesDeleted) {
                    tables.AddEntry(deletedTable.Name, DiffEntryType.Deleted, deletedTable.ScriptDrop());
                }

                foreach (var tableDiff in TablesDiff) {
                    var diffEntry = tables.AddEntry(tableDiff.Name, DiffEntryType.Changed, tableDiff.Script() );

                    if (tableDiff.ColumnsAdded.Any() || tableDiff.ColumnsDroped.Any() || tableDiff.ColumnsDiff.Any()) {
                        var columns = diffEntry.AddCategory("Columns");

                        foreach (var column in tableDiff.ColumnsAdded) {
                            columns.AddEntry(column.Name, DiffEntryType.Added);
                        }

                        foreach (var column in tableDiff.ColumnsDroped) {
                            columns.AddEntry(column.Name, DiffEntryType.Deleted);
                        }

                        foreach (var columnDiff in tableDiff.ColumnsDiff) {
                            columns.AddEntry(columnDiff.Source.Name, DiffEntryType.Changed);
                        }
                    }

                    if (tableDiff.ConstraintsAdded.Any() || tableDiff.ConstraintsDeleted.Any() || tableDiff.ConstraintsChanged.Any()) {
                        var constraints = diffEntry.AddCategory("Constraints");

                        foreach (var constraint in tableDiff.ConstraintsAdded) {
                            constraints.AddEntry(constraint.Name, DiffEntryType.Added);
                        }

                        foreach (var constraint in tableDiff.ConstraintsDeleted) {
                            constraints.AddEntry(constraint.Name, DiffEntryType.Deleted);
                        }

                        foreach (var constraint in tableDiff.ConstraintsChanged) {
                            constraints.AddEntry(constraint.Name, DiffEntryType.Changed);
                        }
                    }
                }
            }

            if (ForeignKeysAdded.Any() || ForeignKeysDeleted.Any() || ForeignKeysDiff.Any()) {
                var foreignKeys = report.AddCategory("Foreign Keys");

                foreach (var foreignKey in ForeignKeysAdded) {
                    foreignKeys.AddEntry(foreignKey.Name, DiffEntryType.Added, foreignKey.ScriptCreate());
                }

                foreach (var foreignKey in ForeignKeysDeleted) {
                    foreignKeys.AddEntry(foreignKey.Name, DiffEntryType.Deleted, foreignKey.ScriptDrop());
                }

                foreach (var foreignKey in ForeignKeysDiff) {
                    var details = new StringBuilder();
                    details.AppendLine(foreignKey.ScriptDrop());
                    details.AppendLine("GO");
                    details.Append(foreignKey.ScriptCreate());
                    foreignKeys.AddEntry(foreignKey.Name, DiffEntryType.Changed, details.ToString());
                }
            }

            if (RoutinesAdded.Any() || RoutinesDeleted.Any() || RoutinesDiff.Any()) {
                var routines = report.AddCategory("Routines");

                foreach (var routine in RoutinesAdded) {
                    routines.AddEntry(routine.Name, DiffEntryType.Added, routine.ScriptCreate(Db));
                }

                foreach (var routine in RoutinesDeleted) {
                    routines.AddEntry(routine.Name, DiffEntryType.Deleted, routine.ScriptDrop());
                }

                foreach (var routine in RoutinesDiff) {
                    var details = new StringBuilder();
                    details.AppendLine(routine.ScriptDrop());
                    details.AppendLine("GO");
                    details.Append(routine.ScriptCreate(Db));
                    routines.AddEntry(routine.Name, DiffEntryType.Changed, details.ToString());
                }
            }

            if (PropsChanged.Any()) {
                var props = report.AddCategory("Properties");

                foreach (var dbProp in PropsChanged) {
                    props.AddEntry(dbProp.Name, DiffEntryType.Changed, dbProp.Script());
                }
            }

            return report;
        }