19481929392

Committed 18 Nov 2025 10:05PM UTC coverage: 72.65% (+0.3%) from 72.366%

Build # 19481929392

Build Type

push

github

Committed by

MeindertN

Commit Message

Fixed failing test

Run Details

2217 of 3233 branches covered (68.57%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 1 file covered. (100.0%)

526 existing lines in 15 files now uncovered.

6894 of 9308 relevant lines covered (74.07%)

96.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.48

/RoboClerk.Core/DataSources/CheckpointDataSources.cs

﻿using RoboClerk.Core.Configuration;
using System;
using System.Collections.Generic;
using System.IO.Abstractions;
using System.Text.Json;

namespace RoboClerk
{
    public class CheckpointDataSources : DataSourcesBase
    {
        private CheckpointDataStorage dataStorage = new CheckpointDataStorage();
        private IDataSources? pluginDatasource = null;
        private string checkpointFile = string.Empty;

        public CheckpointDataSources(IConfiguration configuration, IPluginLoader pluginLoader, IFileProviderPlugin fileSystem, string checkpointFile)
            : base(configuration, fileSystem)
        {
            logger.Info($"RoboClerk is using the following checkpoint file in the template directory to read its input data: {checkpointFile}");
            pluginDatasource = new PluginDataSources(configuration, pluginLoader, fileSystem);
            SetFileSource(checkpointFile);
            ChangeUpdatedItems();
        }

        public void SetFileSource(string fileName)
        {
            checkpointFile = fileSystem.Combine(new string[] { configuration.TemplateDir, fileName });
            if (!fileSystem.FileExists(checkpointFile))
            {
                throw new Exception($"Could not find checkpoint file \"{checkpointFile}\". Unable to continue.");
            }
            dataStorage = JsonSerializer.Deserialize<CheckpointDataStorage>(GetFileStreamFromTemplateDir(fileName));
        }

        public override void RefreshDataSources()
        {
            SetFileSource(checkpointFile);
            ChangeUpdatedItems();
        }

        private void ChangeUpdatedItems()
        {
            var checkpointConfig = configuration.CheckpointConfig;
            foreach (var riskID in checkpointConfig.UpdatedRiskIDs)
            {
                var sourceRiskItem = pluginDatasource.GetRisk(riskID);
                if (sourceRiskItem != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateRisk(sourceRiskItem);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveRisk(riskID);
                }
            }
            foreach (var systemRequirementID in checkpointConfig.UpdatedSystemRequirementIDs)
            {
                var systemRequirement = pluginDatasource.GetSystemRequirement(systemRequirementID);
                if (systemRequirement != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateSystemRequirement(systemRequirement);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveSystemRequirement(systemRequirementID);
                }
            }
            foreach (var softwareRequirementID in checkpointConfig.UpdatedSoftwareRequirementIDs)
            {
                var softwareRequirement = pluginDatasource.GetSoftwareRequirement(softwareRequirementID);
                if (softwareRequirement != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateSoftwareRequirement(softwareRequirement);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveSoftwareRequirement(softwareRequirementID);
                }
            }
            foreach (var documentationRequirementID in checkpointConfig.UpdatedDocumentationRequirementIDs)
            {
                var documentationRequirement = pluginDatasource.GetDocumentationRequirement(documentationRequirementID);
                if (documentationRequirement != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateDocumentationRequirement(documentationRequirement);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveDocumentationRequirement(documentationRequirementID);
                }
            }
            foreach (var docContentID in checkpointConfig.UpdatedDocContentIDs)
            {
                var docContent = pluginDatasource.GetDocContent(docContentID);
                if (docContent != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateDocContent(docContent);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveDocContent(docContentID);
                }
            }
            foreach (var softwareSystemTestID in checkpointConfig.UpdatedSoftwareSystemTestIDs)
            {
                var softwareSystemTest = pluginDatasource.GetSoftwareSystemTest(softwareSystemTestID);
                if (softwareSystemTest != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateSoftwareSystemTest(softwareSystemTest);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveSoftwareSystemTest(softwareSystemTestID);
                }
            }
            foreach (var unitTestID in checkpointConfig.UpdatedUnitTestIDs)
            {
                var unitTest = pluginDatasource.GetUnitTest(unitTestID);
                if (unitTest != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateUnitTest(unitTest);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveUnitTest(unitTestID);
                }
            }
            foreach (var anomalyID in checkpointConfig.UpdatedAnomalyIDs)
            {
                var anomaly = pluginDatasource.GetAnomaly(anomalyID);
                if (anomaly != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateAnomaly(anomaly);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveAnomaly(anomalyID);
                }
            }
            foreach (var soupID in checkpointConfig.UpdatedSOUPIDs)
            {
                var soup = pluginDatasource.GetSOUP(soupID);
                if (soup != null)
                {
                    //item still exists, update it
                    dataStorage.UpdateSOUP(soup);
                }
                else
                {
                    //item no longer exists, should remove from checkpoint data
                    dataStorage.RemoveSOUP(soupID);
                }
            }
        }

        public override List<AnomalyItem> GetAllAnomalies()
        {
            return dataStorage.Anomalies;
        }

        public override List<EliminatedAnomalyItem> GetAllEliminatedAnomalies()
        {
            return dataStorage.EliminatedAnomalies;
        }

        public override List<ExternalDependency> GetAllExternalDependencies()
        {
            return pluginDatasource.GetAllExternalDependencies();
        }

        public override List<TestResult> GetAllTestResults()
        {
            return pluginDatasource.GetAllTestResults(); 
        }

        public override List<EliminatedTestResult> GetAllEliminatedTestResults()
        {
            return pluginDatasource.GetAllEliminatedTestResults();
        }

        public override List<RiskItem> GetAllRisks()
        {
            return dataStorage.Risks;
        }

        public override List<EliminatedRiskItem> GetAllEliminatedRisks()
        {
            return dataStorage.EliminatedRisks;
        }

        public override List<RequirementItem> GetAllSoftwareRequirements()
        {
            return dataStorage.SoftwareRequirements;
        }

        public override List<EliminatedRequirementItem> GetAllEliminatedSoftwareRequirements()
        {
            return dataStorage.EliminatedSoftwareRequirements;
        }

        public override List<SoftwareSystemTestItem> GetAllSoftwareSystemTests()
        {
            return dataStorage.SoftwareSystemTests;
        }

        public override List<EliminatedSoftwareSystemTestItem> GetAllEliminatedSoftwareSystemTests()
        {
            return dataStorage.EliminatedSoftwareSystemTests;
        }

        public override List<UnitTestItem> GetAllUnitTests()
        {
            return dataStorage.UnitTests;
        }

        public override List<EliminatedUnitTestItem> GetAllEliminatedUnitTests()
        {
            return pluginDatasource.GetAllEliminatedUnitTests();
        }

        public override List<SOUPItem> GetAllSOUP()
        {
            return dataStorage.SOUPs;
        }

        public override List<EliminatedSOUPItem> GetAllEliminatedSOUP()
        {
            return dataStorage.EliminatedSOUPs;
        }

        public override List<RequirementItem> GetAllSystemRequirements()
        {
            return dataStorage.SystemRequirements;
        }

        public override List<EliminatedRequirementItem> GetAllEliminatedSystemRequirements()
        {
            return dataStorage.EliminatedSystemRequirements;
        }

        public override List<RequirementItem> GetAllDocumentationRequirements()
        {
            return dataStorage.DocumentationRequirements;
        }

        public override List<EliminatedRequirementItem> GetAllEliminatedDocumentationRequirements()
        {
            return dataStorage.EliminatedDocumentationRequirements;
        }

        public override List<DocContentItem> GetAllDocContents()
        {
            return dataStorage.DocContents;
        }

        public override List<EliminatedDocContentItem> GetAllEliminatedDocContents()
        {
            return dataStorage.EliminatedDocContents;
        }
    }
}

1	using RoboClerk.Core.Configuration;
2	using System;
3	using System.Collections.Generic;
4	using System.IO.Abstractions;
5	using System.Text.Json;
6
7	namespace RoboClerk
8	{
9	public class CheckpointDataSources : DataSourcesBase
10	{
11	private CheckpointDataStorage dataStorage = new CheckpointDataStorage();	5✔
12	private IDataSources? pluginDatasource = null;	5✔
13	private string checkpointFile = string.Empty;	5✔
14
15	public CheckpointDataSources(IConfiguration configuration, IPluginLoader pluginLoader, IFileProviderPlugin fileSystem, string checkpointFile)
16	: base(configuration, fileSystem)	5✔
17	{	5✔
18	logger.Info($"RoboClerk is using the following checkpoint file in the template directory to read its input data: {checkpointFile}");	5✔
19	pluginDatasource = new PluginDataSources(configuration, pluginLoader, fileSystem);	5✔
20	SetFileSource(checkpointFile);	5✔
21	ChangeUpdatedItems();	4✔
22	}	4✔
23
24	public void SetFileSource(string fileName)
25	{	5✔
26	checkpointFile = fileSystem.Combine(new string[] { configuration.TemplateDir, fileName });	5✔
27	if (!fileSystem.FileExists(checkpointFile))	5✔
28	{	1✔
29	throw new Exception($"Could not find checkpoint file \"{checkpointFile}\". Unable to continue.");	1✔
30	}
31	dataStorage = JsonSerializer.Deserialize<CheckpointDataStorage>(GetFileStreamFromTemplateDir(fileName));	4✔
32	}	4✔
33
34	public override void RefreshDataSources()
35	{	×
36	SetFileSource(checkpointFile);	×
37	ChangeUpdatedItems();	×
38	}	×
39
40	private void ChangeUpdatedItems()
41	{	4✔
42	var checkpointConfig = configuration.CheckpointConfig;	4✔
43	foreach (var riskID in checkpointConfig.UpdatedRiskIDs)	16✔
44	{	2✔
45	var sourceRiskItem = pluginDatasource.GetRisk(riskID);	2✔
46	if (sourceRiskItem != null)	2✔
47	{	1✔
48	//item still exists, update it
49	dataStorage.UpdateRisk(sourceRiskItem);	1✔
50	}	1✔
51	else
52	{	1✔
53	//item no longer exists, should remove from checkpoint data
54	dataStorage.RemoveRisk(riskID);	1✔
55	}	1✔
56	}	2✔
57	foreach (var systemRequirementID in checkpointConfig.UpdatedSystemRequirementIDs)	16✔
58	{	2✔
59	var systemRequirement = pluginDatasource.GetSystemRequirement(systemRequirementID);	2✔
60	if (systemRequirement != null)	2✔
61	{	1✔
62	//item still exists, update it
63	dataStorage.UpdateSystemRequirement(systemRequirement);	1✔
64	}	1✔
65	else
66	{	1✔
67	//item no longer exists, should remove from checkpoint data
68	dataStorage.RemoveSystemRequirement(systemRequirementID);	1✔
69	}	1✔
70	}	2✔
71	foreach (var softwareRequirementID in checkpointConfig.UpdatedSoftwareRequirementIDs)	16✔
72	{	2✔
73	var softwareRequirement = pluginDatasource.GetSoftwareRequirement(softwareRequirementID);	2✔
74	if (softwareRequirement != null)	2✔
75	{	1✔
76	//item still exists, update it
77	dataStorage.UpdateSoftwareRequirement(softwareRequirement);	1✔
78	}	1✔
79	else
80	{	1✔
81	//item no longer exists, should remove from checkpoint data
82	dataStorage.RemoveSoftwareRequirement(softwareRequirementID);	1✔
83	}	1✔
84	}	2✔
85	foreach (var documentationRequirementID in checkpointConfig.UpdatedDocumentationRequirementIDs)	16✔
86	{	2✔
87	var documentationRequirement = pluginDatasource.GetDocumentationRequirement(documentationRequirementID);	2✔
88	if (documentationRequirement != null)	2✔
89	{	1✔
90	//item still exists, update it
91	dataStorage.UpdateDocumentationRequirement(documentationRequirement);	1✔
92	}	1✔
93	else
94	{	1✔
95	//item no longer exists, should remove from checkpoint data
96	dataStorage.RemoveDocumentationRequirement(documentationRequirementID);	1✔
97	}	1✔
98	}	2✔
99	foreach (var docContentID in checkpointConfig.UpdatedDocContentIDs)	16✔
100	{	2✔
101	var docContent = pluginDatasource.GetDocContent(docContentID);	2✔
102	if (docContent != null)	2✔
103	{	1✔
104	//item still exists, update it
105	dataStorage.UpdateDocContent(docContent);	1✔
106	}	1✔
107	else
108	{	1✔
109	//item no longer exists, should remove from checkpoint data
110	dataStorage.RemoveDocContent(docContentID);	1✔
111	}	1✔
112	}	2✔
113	foreach (var softwareSystemTestID in checkpointConfig.UpdatedSoftwareSystemTestIDs)	16✔
114	{	2✔
115	var softwareSystemTest = pluginDatasource.GetSoftwareSystemTest(softwareSystemTestID);	2✔
116	if (softwareSystemTest != null)	2✔
117	{	1✔
118	//item still exists, update it
119	dataStorage.UpdateSoftwareSystemTest(softwareSystemTest);	1✔
120	}	1✔
121	else
122	{	1✔
123	//item no longer exists, should remove from checkpoint data
124	dataStorage.RemoveSoftwareSystemTest(softwareSystemTestID);	1✔
125	}	1✔
126	}	2✔
127	foreach (var unitTestID in checkpointConfig.UpdatedUnitTestIDs)	16✔
128	{	2✔
129	var unitTest = pluginDatasource.GetUnitTest(unitTestID);	2✔
130	if (unitTest != null)	2✔
131	{	1✔
132	//item still exists, update it
133	dataStorage.UpdateUnitTest(unitTest);	1✔
134	}	1✔
135	else
136	{	1✔
137	//item no longer exists, should remove from checkpoint data
138	dataStorage.RemoveUnitTest(unitTestID);	1✔
139	}	1✔
140	}	2✔
141	foreach (var anomalyID in checkpointConfig.UpdatedAnomalyIDs)	16✔
142	{	2✔
143	var anomaly = pluginDatasource.GetAnomaly(anomalyID);	2✔
144	if (anomaly != null)	2✔
145	{	1✔
146	//item still exists, update it
147	dataStorage.UpdateAnomaly(anomaly);	1✔
148	}	1✔
149	else
150	{	1✔
151	//item no longer exists, should remove from checkpoint data
152	dataStorage.RemoveAnomaly(anomalyID);	1✔
153	}	1✔
154	}	2✔
155	foreach (var soupID in checkpointConfig.UpdatedSOUPIDs)	16✔
156	{	2✔
157	var soup = pluginDatasource.GetSOUP(soupID);	2✔
158	if (soup != null)	2✔
159	{	1✔
160	//item still exists, update it
161	dataStorage.UpdateSOUP(soup);	1✔
162	}	1✔
163	else
164	{	1✔
165	//item no longer exists, should remove from checkpoint data
166	dataStorage.RemoveSOUP(soupID);	1✔
167	}	1✔
168	}	2✔
169	}	4✔
170
171	public override List<AnomalyItem> GetAllAnomalies()
172	{	3✔
173	return dataStorage.Anomalies;	3✔
174	}	3✔
175
176	public override List<EliminatedAnomalyItem> GetAllEliminatedAnomalies()
177	{	×
178	return dataStorage.EliminatedAnomalies;	×
179	}	×
180
181	public override List<ExternalDependency> GetAllExternalDependencies()
182	{	1✔
183	return pluginDatasource.GetAllExternalDependencies();	1✔
184	}	1✔
185
186	public override List<TestResult> GetAllTestResults()
187	{	×
188	return pluginDatasource.GetAllTestResults();	×
189	}	×
190
191	public override List<EliminatedTestResult> GetAllEliminatedTestResults()
UNCOV 192	{	×
UNCOV 193	return pluginDatasource.GetAllEliminatedTestResults();	×
UNCOV 194	}	×
195
196	public override List<RiskItem> GetAllRisks()
197	{	3✔
198	return dataStorage.Risks;	3✔
199	}	3✔
200
201	public override List<EliminatedRiskItem> GetAllEliminatedRisks()
UNCOV 202	{	×
UNCOV 203	return dataStorage.EliminatedRisks;	×
UNCOV 204	}	×
205
206	public override List<RequirementItem> GetAllSoftwareRequirements()
207	{	3✔
208	return dataStorage.SoftwareRequirements;	3✔
209	}	3✔
210
211	public override List<EliminatedRequirementItem> GetAllEliminatedSoftwareRequirements()
UNCOV 212	{	×
UNCOV 213	return dataStorage.EliminatedSoftwareRequirements;	×
UNCOV 214	}	×
215
216	public override List<SoftwareSystemTestItem> GetAllSoftwareSystemTests()
217	{	3✔
218	return dataStorage.SoftwareSystemTests;	3✔
219	}	3✔
220
221	public override List<EliminatedSoftwareSystemTestItem> GetAllEliminatedSoftwareSystemTests()
UNCOV 222	{	×
UNCOV 223	return dataStorage.EliminatedSoftwareSystemTests;	×
UNCOV 224	}	×
225
226	public override List<UnitTestItem> GetAllUnitTests()
227	{	3✔
228	return dataStorage.UnitTests;	3✔
229	}	3✔
230
231	public override List<EliminatedUnitTestItem> GetAllEliminatedUnitTests()
232	{	×
233	return pluginDatasource.GetAllEliminatedUnitTests();	×
234	}	×
235
236	public override List<SOUPItem> GetAllSOUP()
237	{	3✔
238	return dataStorage.SOUPs;	3✔
239	}	3✔
240
241	public override List<EliminatedSOUPItem> GetAllEliminatedSOUP()
242	{	×
243	return dataStorage.EliminatedSOUPs;	×
244	}	×
245
246	public override List<RequirementItem> GetAllSystemRequirements()
247	{	3✔
248	return dataStorage.SystemRequirements;	3✔
249	}	3✔
250
251	public override List<EliminatedRequirementItem> GetAllEliminatedSystemRequirements()
252	{	×
253	return dataStorage.EliminatedSystemRequirements;	×
254	}	×
255
256	public override List<RequirementItem> GetAllDocumentationRequirements()
257	{	3✔
258	return dataStorage.DocumentationRequirements;	3✔
259	}	3✔
260
261	public override List<EliminatedRequirementItem> GetAllEliminatedDocumentationRequirements()
262	{	×
263	return dataStorage.EliminatedDocumentationRequirements;	×
264	}	×
265
266	public override List<DocContentItem> GetAllDocContents()
267	{	3✔
268	return dataStorage.DocContents;	3✔
269	}	3✔
270
271	public override List<EliminatedDocContentItem> GetAllEliminatedDocContents()
UNCOV 272	{	×
UNCOV 273	return dataStorage.EliminatedDocContents;	×
UNCOV 274	}	×
275	}
276	}

MeindertN / RoboClerk / 19481929392

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous