public override void SetUp()
{
base.SetUp();
_project = Mocker.DynamicMock <ICalidusProject>();
_manager = Mocker.DynamicMock <ICalidusProjectManager>();
_provider = Mocker.DynamicMock <IRuleConfigurationFactoryProvider>();
_configFactory = new CalidusRuleConfigurationFactory(_project, _manager, _provider);
}
/// <summary>
/// Writes the calidus project to its own location
/// </summary>
/// <param name="project">The project</param>
public void Write(ICalidusProject project)
{
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
settings.Indent = true;
XmlWriter writer = XmlTextWriter.Create(project.GetProjectFile(), settings);
WriteTo(project, writer);
writer.Flush();
writer.Close();
}
public void WriteShouldOnlyAllowWritersWithWriterSettings()
{
ICalidusProject project = Mocker.StrictMock <ICalidusProject>();
Stream destination = new MemoryStream();
XmlWriter writer = new XmlTextWriter(destination, null);
Assert.Throws <CalidusException>(delegate
{
_manager.WriteTo(project, writer);
},
"The target XmlWriter must be set to write to UTF8");
}
public void WriteToShouldWriteXmlToDestination()
{
IRule rule = Mocker.StrictMock <IRule>();
StringBuilder bldr = new StringBuilder();
bldr.Append(@"<?xml version=""1.0"" encoding=""utf-8""?>");
bldr.Append(@"<calidusproject>");
bldr.Append("<settings>");
bldr.Append(@"<IgnoreAssemblyFiles>true</IgnoreAssemblyFiles>");
bldr.Append(@"<IgnoreDesignerFiles>false</IgnoreDesignerFiles>");
bldr.Append(@"<IgnoreProgramFiles>true</IgnoreProgramFiles>");
bldr.Append("</settings>");
bldr.Append("<ignore>");
bldr.Append(@"<file path=""main\file1.cs"" />");
bldr.Append(@"<file path=""test\testfile.cs"" />");
bldr.Append("</ignore>");
bldr.Append("</calidusproject>");
IList <String> fileList = new List <String>();
fileList.Add(@"main\file1.cs");
fileList.Add(@"test\testfile.cs");
ICalidusProject project = Mocker.StrictMock <ICalidusProject>();
Expect.Call(project.IgnoreAssemblyFiles).Return(true).Repeat.Once();
Expect.Call(project.IgnoreDesignerFiles).Return(false).Repeat.Once();
Expect.Call(project.IgnoreProgramFiles).Return(true).Repeat.Once();
Expect.Call(project.IgnoredFiles).Return(fileList).Repeat.Once();
Expect.Call(project.GetProjectRuleConfigurationOverrides()).Return(new IRuleConfigurationOverride[] {}).Repeat.Once();
Mocker.ReplayAll();
Stream destination = new MemoryStream();
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = Encoding.UTF8;
XmlWriter writer = XmlTextWriter.Create(destination, settings);
_manager.WriteTo(project, writer);
destination.Position = 0;
StreamReader reader = new StreamReader(destination);
Assert.AreEqual(bldr.ToString(), reader.ReadToEnd());
Mocker.VerifyAll();
}
public void ReadShouldReadProjectFromXml()
{
StringBuilder bldr = new StringBuilder();
bldr.Append(@"<?xml version=""1.0"" encoding=""utf-8""?>");
bldr.Append(@"<calidusproject>");
bldr.Append("<settings>");
bldr.Append(@"<IgnoreAssemblyFiles>true</IgnoreAssemblyFiles>");
bldr.Append(@"<IgnoreDesignerFiles>false</IgnoreDesignerFiles>");
bldr.Append(@"<IgnoreProgramFiles>true</IgnoreProgramFiles>");
bldr.Append("</settings>");
bldr.Append("<ignore>");
bldr.Append(@"<file path=""main\file1.cs"" />");
bldr.Append(@"<file path=""test\testfile.cs"" />");
bldr.Append("</ignore>");
bldr.Append("</calidusproject>");
IList <String> fileList = new List <String>();
fileList.Add(@"main\file1.cs");
fileList.Add(@"test\testfile.cs");
ICalidusProject expected = Mocker.StrictMock <ICalidusProject>();
Expect.Call(expected.IgnoreAssemblyFiles).Return(true).Repeat.Once();
Expect.Call(expected.IgnoreDesignerFiles).Return(false).Repeat.Once();
Expect.Call(expected.IgnoreProgramFiles).Return(true).Repeat.Once();
Expect.Call(expected.IgnoredFiles).Return(fileList).Repeat.Once();
Expect.Call(_rulesSectionManager.ReadFrom(null)).IgnoreArguments().Return(new IRuleConfigurationOverride[] {}).Repeat.Once();
Mocker.ReplayAll();
Stream source = new MemoryStream();
StreamWriter writer = new StreamWriter(source);
writer.Write(bldr.ToString());
writer.Flush();
source.Position = 0;
ICalidusProject actual = _manager.ReadFrom("test", new XmlTextReader(source));
Assert.AreEqual(expected.IgnoreAssemblyFiles, actual.IgnoreAssemblyFiles);
Assert.AreEqual(expected.IgnoreDesignerFiles, actual.IgnoreDesignerFiles);
Assert.AreEqual(expected.IgnoreProgramFiles, actual.IgnoreProgramFiles);
CollectionAssert.AreEquivalent(expected.IgnoredFiles, actual.IgnoredFiles);
Mocker.VerifyAll();
}
public void MainControllerShouldSetViewProjectHasChangesToFalseOnViewOpen()
{
ICalidusProject theProject = Mocker.DynamicMock <ICalidusProject>();
Expect.Call(_projectModel.GetProjectFile()).Return(@"c:\test.calidus").Repeat.Times(1);
Expect.Call(_view.OpenProjectFile()).Return(new FileBrowseResult(true, @"c:\test.calidus")).Repeat.Once();
Expect.Call(delegate { _view.ProjectHasChanges(false); }).Repeat.Once();
Mocker.ReplayAll();
_controller = new MainController(_view, _projectModel, true, _projectManager, _ruleRunner, _violationList);
_view.Raise(x => x.Open += null, this, EventArgs.Empty);
Mocker.VerifyAll();
}
public void WriteShouldCallRulesSectionManagerToWriteRuleOverrides()
{
ICalidusProject project = Mocker.DynamicMock <ICalidusProject>();
IRuleConfigurationOverride config = Mocker.DynamicMock <IRuleConfigurationOverride>();
Expect.Call(project.IgnoredFiles).Return(new String[] {}).Repeat.Once();
Expect.Call(project.GetProjectRuleConfigurationOverrides()).Return(new[] { config }).Repeat.Once();
Expect.Call(() => _rulesSectionManager.WriteTo(new[] { config }, null)).IgnoreArguments().Repeat.Once();
Mocker.ReplayAll();
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlTextWriter.Create(stream);
_manager.WriteTo(project, writer);
Mocker.VerifyAll();
}
/// <summary>
/// Writes the calidus project to the specified xml writer
/// </summary>
/// <param name="project">The project to write</param>
/// <param name="writer">The writer to write to</param>
public void WriteTo(ICalidusProject project, XmlWriter writer)
{
if (writer.Settings == null || writer.Settings.Encoding != Encoding.UTF8)
{
throw new CalidusException("The target XmlWriter must be set to write to UTF8");
}
XDocument doc = new XDocument();
//write root element
XElement root = new XElement("calidusproject");
//write settings
XElement ignoreAssemblyFiles = new XElement("IgnoreAssemblyFiles", project.IgnoreAssemblyFiles);
XElement ignoreDesignerFiles = new XElement("IgnoreDesignerFiles", project.IgnoreDesignerFiles);
XElement ignoreProgramFiles = new XElement("IgnoreProgramFiles", project.IgnoreProgramFiles);
XElement settings = new XElement("settings");
settings.Add(ignoreAssemblyFiles);
settings.Add(ignoreDesignerFiles);
settings.Add(ignoreProgramFiles);
root.Add(settings);
//write full-file ignores
XElement ignores = new XElement("ignore");
foreach (String aFile in project.IgnoredFiles)
{
XElement file = new XElement("file", new XAttribute("path", aFile));
ignores.Add(file);
}
root.Add(ignores);
_rulesSectionManager.WriteTo(project.GetProjectRuleConfigurationOverrides(), root);
//write document to file
doc.Add(root);
doc.WriteTo(writer);
writer.Flush();
}
/// <summary>
/// Sets the project in the model
/// </summary>
/// <param name="project">The project</param>
public void SetProject(ICalidusProject project)
{
ICalidusProject originalProject = _project;
_project = project;
OnProjectSet();
if (originalProject.IgnoreAssemblyFiles != project.IgnoreAssemblyFiles)
{
OnIgnoreAssemblyFilesChanged(new CheckedEventArgs(project.IgnoreAssemblyFiles));
}
if (originalProject.IgnoreDesignerFiles != project.IgnoreDesignerFiles)
{
OnIgnoreDesignerFilesChanged(new CheckedEventArgs(project.IgnoreDesignerFiles));
}
if (originalProject.IgnoreProgramFiles != project.IgnoreProgramFiles)
{
OnIgnoreProgramFilesChanged(new CheckedEventArgs(project.IgnoreProgramFiles));
}
}
/// <summary>
/// Starts the runner
/// </summary>
/// <param name="configFactory">The configuration factory</param>
/// <param name="project">The project to run against</param>
public void Run(ICalidusRuleConfigurationFactory configFactory, ICalidusProject project)
{
//raise started
if (Started != null)
{
Started(this, new EventArgs());
}
IList <RuleViolation> violations = new List <RuleViolation>();
CalidusTokenParser parser = new CalidusTokenParser();
CalidusStatementParser statementParser = new CalidusStatementParser();
CalidusBlockParser blockParser = new CalidusBlockParser();
CalidusLineParser lineParser = new CalidusLineParser();
CalidusRuleProvider ruleProvider = new CalidusRuleProvider();
IEnumerable <String> filesToCheck = project.GetSourceFilesToValidate();
int currentFile = 0;
int totalFiles = filesToCheck.Count();
foreach (String aFile in filesToCheck)
{
currentFile++;
IEnumerable <TokenBase> parsedTokens = parser.Parse(File.ReadAllText(aFile));
IEnumerable <StatementBase> parsedStatements = statementParser.Parse(parsedTokens);
IEnumerable <BlockBase> parsedBlocks = blockParser.Parse(parsedStatements);
IEnumerable <LineBase> parsedLines = lineParser.Parse(parsedTokens);
IList <RuleViolation> currentFileViolations = new List <RuleViolation>();
foreach (StatementRuleBase aStatementRule in ruleProvider.GetStatementRules(configFactory))
{
foreach (StatementBase aStatement in parsedStatements)
{
if (aStatementRule.Validates(aStatement))
{
if (aStatementRule.IsValidFor(aStatement) == false)
{
currentFileViolations.Add(new RuleViolation(aFile, aStatementRule, aStatement));
}
}
}
}
foreach (BlockRuleBase aBlockRule in ruleProvider.GetBlockRules(configFactory))
{
foreach (BlockBase aBlock in parsedBlocks)
{
if (aBlockRule.Validates(aBlock))
{
if (aBlockRule.IsValidFor(aBlock) == false)
{
currentFileViolations.Add(new RuleViolation(aFile, aBlockRule, aBlock.Statements.ElementAt(0)));
}
}
}
}
foreach (LineRuleBase aLineRule in ruleProvider.GetLineRules(configFactory))
{
foreach (LineBase aLine in parsedLines)
{
if (aLineRule.Validates(aLine))
{
if (aLineRule.IsValidFor(aLine) == false)
{
currentFileViolations.Add(new RuleViolation(aFile, aLineRule, aLine.Tokens));
}
}
}
}
//raise file completed
FileCompletedEventArgs args = new FileCompletedEventArgs(aFile, currentFile, totalFiles, currentFileViolations);
if (FileCompleted != null)
{
FileCompleted(this, args);
}
//add violations to whole list
foreach (RuleViolation aViolation in currentFileViolations)
{
violations.Add(aViolation);
}
}
//raise completed
if (Completed != null)
{
Completed(this, new RuleRunnerEventArgs(violations));
}
}
/// <summary>
/// Create a new instance of this class
/// </summary>
/// <param name="project">The project to get overrides from</param>
/// <param name="manager">The project manager to use</param>
/// <param name="provider">The provider to use to get rules</param>
public CalidusRuleConfigurationFactory(ICalidusProject project, ICalidusProjectManager manager, IRuleConfigurationFactoryProvider provider)
{
_provider = provider;
_project = project;
_manager = manager;
}
/// <summary>
/// Create a new instance of this class
/// </summary>
/// <param name="project">The project to get overrides from</param>
/// <param name="manager">The project manager to use</param>
public CalidusRuleConfigurationFactory(ICalidusProject project, ICalidusProjectManager manager)
: this(project, manager, ObjectFactory.Get <IRuleConfigurationFactoryProvider>())
{
}
public CalidusProjectModel(ICalidusProject project)
{
_project = project;
}