public DependenciesInfo BuildDependenciesInfo(DependenciesSection configSection, int osBuild)
{
bool supported = TryGetOsBuildNumber(configSection, ref osBuild);
if (!supported)
{
throw new NotSupportedOperatingSystemException(osBuild);
}
var info = new DependenciesInfo
{
CompatibleOsBuild = osBuild,
EvaluationContext = new EvaluationContext(),
Dependencies = new List <Dependency>()
};
// Add common checks & dependencies
this.AddDependencyChecks(info, configSection.CommonChecks);
this.AddDependencies(info, configSection.MinimumRequirements.Dependencies);
// Add OS checks & dependencies
DependencyGroup osDependencyGroup = configSection.DependencyGroups.GetDependencyGroupByOsBuild(osBuild);
if (osDependencyGroup != null)
{
this.AddDependencyChecks(info, osDependencyGroup.Checks);
this.AddDependencies(info, osDependencyGroup.Dependencies);
}
// Add evaluators
this.AddCheckEvaluators((EvaluationContext)info.EvaluationContext, configSection.CheckEvaluators);
return(info);
}
ArrayList BuildDependencies(string infile)
{
FileStream fs = null;
try
{
ArrayList dependencies = new ArrayList();
RecursivelyAddDependencies(infile, dependencies);
DependencyGroup depgroup = new DependencyGroup();
depgroup.dependencies = dependencies;
// save the data
XmlSerializer ser = new XmlSerializer(typeof(DependencyGroup));
string depFileName = DependencyFileName(infile);
fs = new FileStream(depFileName, FileMode.Create);
ser.Serialize(fs, depgroup);
return(dependencies);
}
finally
{
if (fs != null)
{
fs.Close();
}
}
}
private void groups(XElement document, Solution solution)
{
var groups = document.Element("Groups");
if (groups == null)
{
return;
}
var dependencyGroups = new List <DependencyGroup>();
foreach (var groupElement in groups.Elements("Group"))
{
var group = new DependencyGroup();
var dependencies = new List <GroupedDependency>();
foreach (var depElement in groupElement.Descendants())
{
var dep = new GroupedDependency();
fillProperties(depElement, dep);
dependencies.Add(dep);
}
group.GroupedDependencies = dependencies;
dependencyGroups.Add(group);
}
solution.Groups = dependencyGroups;
}
public void persists_and_retrieves_the_solution()
{
var solution = new Solution
{
Name = "Test",
BuildCommand = "rake",
FastBuildCommand = "rake compile",
Feeds = new[] { Feed.NuGetV2, Feed.NuGetV1 },
Nugets = new[] { new Dependency("FubuCore", "1.0.1.0") }
};
var group = new DependencyGroup();
group.Dependencies.Add(new GroupedDependency("FubuCore"));
solution.Groups.Add(group);
var constrainedDependency = new Dependency("Bottles", "1.0.0.0")
{
VersionConstraint = VersionConstraint.DefaultFloat
};
solution.AddDependency(constrainedDependency);
solution.Nuspecs.Add(new NuspecMap {
File = "Temp", Project = "Test"
});
CheckXmlPersistence.For(solution);
}
private void groups(XElement document, Solution solution)
{
var groups = document.Element("Groups");
if (groups == null) return;
var dependencyGroups = new List<DependencyGroup>();
foreach (var groupElement in groups.Elements("Group"))
{
var group = new DependencyGroup();
var dependencies = new List<GroupedDependency>();
foreach (var depElement in groupElement.Descendants())
{
var dep = new GroupedDependency();
fillProperties(depElement, dep);
dependencies.Add(dep);
}
group.GroupedDependencies = dependencies;
dependencyGroups.Add(group);
}
solution.Groups = dependencyGroups;
}
public void requests_for_a_single_dependency_in_multiple_groups()
{
var g1 = new DependencyGroup();
g1.Add(new GroupedDependency("FubuCore"));
g1.Add(new GroupedDependency("FubuLocalization"));
theSolution.AddGroup(g1);
var g2 = new DependencyGroup();
g2.Add(new GroupedDependency("FubuLocalization"));
g2.Add(new GroupedDependency("Bottles"));
theSolution.AddGroup(g2);
theInput.NugetFlag = "FubuCore";
var requests = theInput.Requests(theSolution).ToArray();
requests[0].Dependency.ShouldEqual(new Dependency("FubuCore"));
requests[0].Batched.ShouldBeFalse();
requests[1].Dependency.ShouldEqual(new Dependency("FubuLocalization"));
requests[1].Batched.ShouldBeFalse();
requests[2].Dependency.ShouldEqual(new Dependency("Bottles"));
requests[2].Batched.ShouldBeFalse();
}
private List <DependencyGroup> CreateDependencyGroups(IEnumerable <ProjectContext> projectContexts)
{
var libraryNameDependencyGroupMap = new Dictionary <string, DependencyGroup>();
foreach (var projectContext in projectContexts)
{
var libraries = projectContext.LibraryManager.GetLibraries();
foreach (var library in libraries)
{
var dependencyInfo = DependencyInfo.Create(projectContext, library);
if (libraryNameDependencyGroupMap.ContainsKey(dependencyInfo.Name))
{
var dependencyGroup = libraryNameDependencyGroupMap[dependencyInfo.Name];
dependencyGroup.AddEntry(dependencyInfo);
}
else
{
var dependencyGroup = DependencyGroup.CreateWithEntry(dependencyInfo);
libraryNameDependencyGroupMap[dependencyInfo.Name] = dependencyGroup;
}
}
}
return(libraryNameDependencyGroupMap.Values.ToList());
}
public void has_dependency_negative()
{
var group = new DependencyGroup();
group.Add(new GroupedDependency("FubuCore"));
group.Has("Bottles").ShouldBeFalse();
}
/// <summary>
/// Generates a nuget package spec package from a given mod configuration file.
/// </summary>
private static Package FromModConfig(IModConfig modConfig)
{
var dependencies = modConfig.ModDependencies.Select(x => new Structures.Dependency(x, "0.0.0")).ToArray();
var dependencyGroup = new DependencyGroup(dependencies);
var metadata = new Metadata(modConfig.ModName, modConfig.ModId, modConfig.ModVersion, modConfig.ModAuthor, modConfig.ModDescription, dependencyGroup);
return(new Package(metadata));
}
public void has_dependency_positive()
{
var group = new DependencyGroup();
group.Dependencies.Add(new GroupedDependency("FubuCore"));
group.Has("FubuCore").ShouldBeTrue();
}
public void has_dependency_case_insensitive()
{
var group = new DependencyGroup();
group.Add(new GroupedDependency("FubuCore"));
group.Has("fubuCore").ShouldBeTrue();
}
public List <DependencyGroup> Sort(HashSet <State> states)
{
HashSet <Node> leafs;
Collapse(states, out leafs);
var ret = new List <DependencyGroup>();
var q = new Queue();
// Add all leaf nodes (nothing depends on them) to the initial set
foreach (var n in leafs)
{
q.Enqueue(n);
}
while (!q.Empty)
{
var n = q.Dequeue();
// Append the node to the last group if it has the same
// embedding
if (ret.Count != 0 && ret[ret.Count - 1].Embedding == n.Embedding && ret[ret.Count - 1].EventStateGroup == n.EventStateGroup)
{
ret[ret.Count - 1].Add(n.State);
}
else
{
// Otherwise create a new group for it and append the group
// to the resulting set
DependencyGroup g = new DependencyGroup(n.Embedding, n.EventStateGroup);
g.Add(n.State);
ret.Add(g);
}
// Iterate over all the nodes (dep) that depend on (n)
foreach (var dep in n.DependencyFor)
{
// Remove the node from its dependencies (it has been
// processed)
dep.Dependencies.Remove(n);
// If this list is now 0, then (dep) does not have any
// dependencies left and can be added to our queue to be
// inserted in the result
if (dep.Dependencies.Count == 0 && dep.State != null)
{
q.Enqueue(dep);
}
}
}
// TODO: check for cyclic dependencies
return(ret);
}
public IActionResult DeleteConfirmed(int id)
{
DependencyGroup dependencyGroup = _context.DependencyGroup.Single(m => m.DependencyGroupID == id);
_context.DependencyGroup.Remove(dependencyGroup);
_context.SaveChanges();
HttpContext.Session.SetString("Message", "Dependency Group: " + dependencyGroup.Name + " successfully deleted");
return(RedirectToAction("Index"));
}
public void GroupDependencies(params string[] dependencies)
{
Modify(solution =>
{
var group = new DependencyGroup();
dependencies.Each(x => group.Dependencies.Add(new GroupedDependency(x)));
solution.Groups.Add(group);
});
}
public IActionResult Edit(DependencyGroup dependencyGroup)
{
if (ModelState.IsValid)
{
_context.Update(dependencyGroup);
_context.SaveChanges();
HttpContext.Session.SetString("Message", "Dependency Group: " + dependencyGroup.Name + " successfully edited");
return(RedirectToAction("Index"));
}
return(View(dependencyGroup));
}
/// <summary>
/// Create object to display the dependency grouping from the parsed code data
/// </summary>
/// <returns></returns>
public DependencyGroup BuildDependencyGroup(ParsedData data)
{
if (data == null)
{
throw new ArgumentNullException(nameof(data));
}
var result = new DependencyGroup
{
name = "",
datemodified = DateTime.UtcNow.ToString("s") + "Z",
children = new List <Children>()
};
var blackList = new List <string> {
"jersey", "jackson", "versioncheck", "web", "metrics", "audit", "configuration", "grok", "gettingstarted", "utilities", "timeranges",
"rules", "bootstrap", "buffers", "bindings", "savedsearches", "shared", "log4j"
};
foreach (var t in data.packageNames)
{
result.children.Add(new Children
{
name = t.Trim(),
size = null,
datemodified = RandomDateTime(),
children = new List <Children>()
});
}
foreach (var child in result.children)
{
var matching = data.connectorsArray.Where(x => x[0].ToLower() == child.name.ToLower());
foreach (var match in matching)
{
if (blackList.Contains(match[1].ToLower()))
{
continue;
}
child.children.Add(new Children
{
children = null,
datemodified = RandomDateTime(),
name = match[1],
size = 1
});
}
}
return(result);
}
public void GroupDependencies(params string[] dependencies)
{
Modify(solution =>
{
var group = new DependencyGroup {
Name = dependencies.First()
};
dependencies.Each(x => group.Add(new GroupedDependency(x)));
solution.AddGroup(group);
});
}
// GET: DependencyGroups/Edit/5
public IActionResult Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
DependencyGroup dependencyGroup = _context.DependencyGroup.Single(m => m.DependencyGroupID == id);
if (dependencyGroup == null)
{
return(HttpNotFound());
}
return(View(dependencyGroup));
}
public void persists_and_retrieves_the_solution()
{
var solution = new Solution
{
Name = "Test",
Feeds = new[] { Feed.NuGetV2, Feed.NuGetV1 },
Nugets = new[] { new Dependency("FubuCore", "1.0.1.0") }
};
var group = new DependencyGroup {
Name = "Test"
};
group.Add(new GroupedDependency("FubuCore"));
solution.AddGroup(group);
solution.AddDependency(new Dependency("Bottles", "1.0.0.0")
{
VersionConstraint = VersionConstraint.DefaultFloat
});
solution.AddNuspec(new NuspecMap {
PackageId = "Temp", PublishedBy = "Test"
});
solution.Ignore("Rhino.ServiceBus.dll", "Esent.Interop.dll");
var registry = new RippleBlockRegistry();
var solutionSettings = registry.SettingsFor(typeof(Solution));
CheckObjectBlockPersistence
.ForSolution(solution)
.VerifyProperties(property =>
{
if (!property.CanWrite)
{
return(false);
}
if (solutionSettings.ShouldIgnore(solution, new SingleProperty(property)))
{
return(false);
}
return(true);
});
}
public void requests_for_a_single_dependency_in_a_group()
{
var group = new DependencyGroup();
group.Add(new GroupedDependency("FubuCore"));
group.Add(new GroupedDependency("FubuLocalization"));
theSolution.AddGroup(group);
theInput.NugetFlag = "FubuCore";
var requests = theInput.Requests(theSolution).ToArray();
requests[0].Dependency.ShouldEqual(new Dependency("FubuCore"));
requests[0].Batched.ShouldBeFalse();
requests[1].Dependency.ShouldEqual(new Dependency("FubuLocalization"));
requests[1].Batched.ShouldBeFalse();
}
public IActionResult Create(IFormCollection form)
{
var DependencyGroupID = Convert.ToInt32(form["id"]);
List <string> usersListOfTestRuns = form["TestRunID"].ToList();
string CreationMessage = "Dependencies created for" + System.Environment.NewLine;
foreach (var TestRunID in usersListOfTestRuns)
{
Dependency dependency = new Dependency();
DependencyGroup dependencyGroup = _context.DependencyGroup.SingleOrDefault
(t => t.DependencyGroupID == DependencyGroupID);
dependency.DependencyGroupID = DependencyGroupID;
dependency.TestRunID = Convert.ToInt32(TestRunID);
CreationMessage = CreationMessage + "Dependency Group: " + dependencyGroup.Name + " & TestRunID: "
+ TestRunID;
_context.Dependency.Add(dependency);
}
_context.SaveChanges();
if (ModelState.IsValid)
{
HttpContext.Session.SetString("Message", CreationMessage);
return(RedirectToAction("Details", new RouteValueDictionary(new
{
controller = "DependencyGroups",
action = "Details",
ID = DependencyGroupID
})));
}
return(RedirectToAction("Details", new RouteValueDictionary(new
{
controller = "DependencyGroups",
action = "Details",
ID = DependencyGroupID
})));
}
private string GetDependencyGroupConflictMessage(DependencyGroup dependencyGroup)
{
StringBuilder sb = new StringBuilder();
sb.Append($"Conflict for {dependencyGroup.DependencyName} in projects:{Environment.NewLine}");
foreach (var version in dependencyGroup.VersionDependencyInfoMap.Keys)
{
var dependencyInfoList = dependencyGroup.VersionDependencyInfoMap[version];
foreach (var dependencyInfo in dependencyInfoList)
{
sb.Append($"Version: {dependencyInfo.Version} Path: {dependencyInfo.ProjectPath} {Environment.NewLine}");
}
}
sb.Append(Environment.NewLine);
return(sb.ToString());
}
protected void LoadDependencyGroup(DependencyGroup core)
{
switch (core)
{
case DependencyGroup.Core:
this.LoadCoreDependencies();
break;
case DependencyGroup.Deal:
this.LoadDealDependencies();
break;
case DependencyGroup.Facility:
this.LoadFacilityDependencies();
break;
default:
break;
}
}
ArrayList LoadDependencies(string infile)
{
FileStream fs = null;
try
{
XmlSerializer ser = new XmlSerializer(typeof(DependencyGroup));
string depFileName = DependencyFileName(infile);
fs = new FileStream(depFileName, FileMode.Open);
DependencyGroup depgroup = (DependencyGroup)ser.Deserialize(fs);
ArrayList dependencies = depgroup.dependencies;
// if any files are newer than the dependency file, it
// is stale
DateTime depdate = File.GetLastWriteTime(depFileName);
for (int i = 0; i < dependencies.Count; i++)
{
Dependency dep = dependencies[i] as Dependency;
if (!File.Exists(dep.Filename))
{
return(null);
}
dep.Modified = File.GetLastWriteTime(dep.Filename);
if (dep.Modified > depdate)
{
return(null);
}
}
return(dependencies);
}
catch (System.IO.FileNotFoundException)
{
return(null);
}
finally
{
if (fs != null)
{
fs.Close();
}
}
}
ArrayList BuildDependencies(string infile)
{
FileStream fs = null;
try
{
ArrayList dependencies = new ArrayList();
RecursivelyAddDependencies(infile, dependencies);
DependencyGroup depgroup = new DependencyGroup();
depgroup.dependencies = dependencies;
// save the data
XmlSerializer ser = new XmlSerializer(typeof(DependencyGroup));
string depFileName = DependencyFileName(infile);
fs = new FileStream(depFileName, FileMode.Create);
ser.Serialize(fs, depgroup);
return dependencies;
}
finally
{
if (fs != null) fs.Close();
}
}
private void PatchGroup(ICommonAssembly assembly, ICommonType frameworkElementType, DependencyGroup group)
{
RemoveDefaultField(frameworkElementType, group.Property.Name);
var field = group.Field?.MonoCecil ?? CreateField(assembly, frameworkElementType, group.Property);
GenerateGetMethodBody(assembly, frameworkElementType, group.Property.MonoCecil, field);
GenerateSetMethodBody(assembly, frameworkElementType, group.Property.MonoCecil, field);
}
// GET: Runs/Details/5
public IActionResult Details(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
ViewData["Message"] = HttpContext.Session.GetString("Message");
HttpContext.Session.Remove("Message");
ProjectAndFolderAndGroupAndRunAndTestsAndTestRun viewModel = new ProjectAndFolderAndGroupAndRunAndTestsAndTestRun();
viewModel.Run = _context.Run.Single(m => m.RunID == id);
if (viewModel.Run == null)
{
return(HttpNotFound());
}
viewModel.Run.TestRuns = _context.TestRun.Where(m => m.RunID == id).ToList();
var dependencyGroup = new DependencyGroup();
foreach (TestRun testRun in viewModel.Run.TestRuns)
{
testRun.Test = _context.Test.Single(t => t.TestID == testRun.TestID);
testRun.TestEnvironment = _context.TestEnvironment.SingleOrDefault(t => t.TestEnvironmentID == testRun.TestEnvironmentID);
var Results = _context.Result.Where(t => t.TestRunID == testRun.TestRunID);
if (Results.Any())
{
testRun.Result = Results.OrderBy(t => t.ResultID).First();
}
if (testRun.TestRunnerGroupID != null)
{
testRun.TestRunnerGroup = _context.TestRunnerGroup.Single(t => t.TestRunnerGroupID == testRun.TestRunnerGroupID);
}
if (testRun.DependencyGroupID == null)
{
var InvalidDependencyGroupIDsList = _context.Dependency.Where(t => t.TestRunID == testRun.TestRunID)
.Select(t => t.DependencyGroupID).ToList();
testRun.ValidDependencyGroups = _context.DependencyGroup.Where
(i => !InvalidDependencyGroupIDsList.Contains(i.DependencyGroupID)).ToList();
}
if (testRun.DependencyGroupID != null)
{
dependencyGroup = _context.DependencyGroup.Single(t => t.DependencyGroupID == testRun.DependencyGroupID);
testRun.DependencyGroup = dependencyGroup;
var Dependencies = _context.Dependency.Where(t => t.DependencyGroupID == dependencyGroup.DependencyGroupID);
foreach (var dependency in Dependencies)
{
dependency.TestRun = _context.TestRun.SingleOrDefault(t => t.TestRunID == dependency.TestRunID);
testRun.DependencyGroup.Dependencies.Add(dependency);
var Run = _context.Run.SingleOrDefault(t => t.RunID == testRun.RunID);
var Group = _context.Group.SingleOrDefault(t => t.GroupID == Run.GroupID);
var Folder = _context.Folder.SingleOrDefault(t => t.FolderID == Group.FolderID);
var Project = _context.Project.SingleOrDefault(t => t.ID == Folder.ProjectID);
List <NavigationLink> NavLinkList = new List <NavigationLink>
{
new NavigationLink
{
Text = "Project: " + Project.Name,
Controller = "Projects",
Action = "Details",
RouteID = Project.ID
},
new NavigationLink
{
Text = "Folder: " + Folder.Name,
Controller = "Folders",
Action = "Details",
RouteID = Folder.FolderID
},
new NavigationLink
{
Text = "Group: " + Group.Name,
Controller = "Groups",
Action = "Details",
RouteID = Group.GroupID
},
new NavigationLink
{
Text = "Run: " + Run.Name,
Controller = "Runs",
Action = "Details",
RouteID = Run.RunID
}
};
ViewData["DependencyNavLinkList" + dependency.DependencyID] = NavLinkList;
}
}
}
viewModel.Run.TestRunnerGroup = _context.TestRunnerGroup.SingleOrDefault
(t => t.TestRunnerGroupID == viewModel.Run.TestRunnerGroupID);
viewModel.Group =
_context.Group.Single(m => m.GroupID == viewModel.Run.GroupID);
viewModel.Folder =
_context.Folder.Single(m => m.FolderID == viewModel.Group.FolderID);
viewModel.Project =
_context.Project.Single(m => m.ID == viewModel.Folder.ProjectID);
string strTestRunnerGroupDescription, strTestRunnerGroupName;
if (viewModel.Run.TestRunnerGroupID != null)
{
strTestRunnerGroupDescription = "Taken from Run";
strTestRunnerGroupName = _context.TestRunnerGroup.Single
(t => t.TestRunnerGroupID == viewModel.Run.TestRunnerGroupID).Name;
}
else if (viewModel.Group.TestRunnerGroupID != null)
{
strTestRunnerGroupDescription = "Taken from Group";
strTestRunnerGroupName = _context.TestRunnerGroup.Single
(t => t.TestRunnerGroupID == viewModel.Group.TestRunnerGroupID).Name;
}
else if (viewModel.Folder.TestRunnerGroupID != null)
{
strTestRunnerGroupDescription = "Taken from Folder";
strTestRunnerGroupName = _context.TestRunnerGroup.Single
(t => t.TestRunnerGroupID == viewModel.Folder.TestRunnerGroupID).Name;
}
else if (viewModel.Project.TestRunnerGroupID != null)
{
strTestRunnerGroupDescription = "Taken from Project";
strTestRunnerGroupName = _context.TestRunnerGroup.Single
(t => t.TestRunnerGroupID == viewModel.Project.TestRunnerGroupID).Name;
}
else
{
strTestRunnerGroupDescription = "No Test Runner Group assigned";
strTestRunnerGroupName = "No Test Runner Group assigned";
}
ViewBag.TestRunnerGroupDescription = strTestRunnerGroupDescription;
ViewBag.TestRunnerGroupName = strTestRunnerGroupName;
var alltestrunIDs = _context.TestRun.Where(m => m.RunID == id).Select(t => t.TestRunID);
ViewData["AllTestRunIDs"] = string.Join(",", alltestrunIDs);
ViewBag.tests = new SelectList(_context.Test, "TestID", "Name");
ViewBag.testEnvironments = new SelectList(_context.TestEnvironment, "TestEnvironmentID", "Name");
ViewBag.browsers = new SelectList(new List <string> {
"Chrome", "Firefox", "IE"
});
return(View(viewModel));
}
