public void Execute(Entity dataModel, ChangeObservable observable)
{
ProjectEntity project = ProjectEntity.Decorate(dataModel.Root);
IEnumerable <Entity> targets = project.Targets.ToArray();
if (!targets.Any())
{
throw new FormattableException("Please use --target to specify for which targets the library shall be generated.");
}
foreach (Entity target in targets)
{
VirtualDirectory deployRoot = DeployEntity.Decorate(target).DeployDirectory;
VirtualDirectory deployDirectory = deployRoot.Directory("lib", project.Name);
BuildEntity buildEntity = BuildEntity.Decorate(target);
if (!buildEntity.HasBuildSystem)
{
TargetEntity targetEntity = TargetEntity.Decorate(target);
executionContext.WriteWarning(new CMakeBuildSystemNotFoundException(targetEntity.FullName, buildEntity.BuildType).Message);
return;
}
foreach (string externalLibrary in buildEntity.BuildSystem.ExternalLibraries)
{
VirtualFile newFile = fileSystem.GetFile(externalLibrary).CopyTo(deployDirectory);
executionContext.Observable.OnNext(new Change(() => newFile.Delete(), $"Copied {externalLibrary} to {newFile.FullName}."));
}
}
}
public override Entity Resolve(Entity owner, string key, bool fallback = false)
{
if (key == EntityKeys.InternalDeployPathKey)
{
TargetEntity targetEntity = TargetEntity.Decorate(owner);
BuildEntity buildEntity = BuildEntity.Decorate(owner);
Entity project = owner.Root;
CommandEntity commandOrigin = CommandEntity.Decorate(owner.Origin);
VirtualDirectory outputRoot = fileSystem.GetDirectory(commandOrigin.Output, project.Path);
VirtualDirectory deployRoot = outputRoot.Directory(targetEntity.FullName.Replace(',', '_'),
buildEntity.BuildType);
return(owner.Create(key, deployRoot.FullName, deployRoot));
}
CommandEntity command = CommandEntity.Decorate(owner);
FileEntity projectFileEntity = FileEntity.Decorate(owner.Root);
string outputDirectory = command.GetSingleValueArgument(Constants.OutputArgumentName);
if (string.IsNullOrEmpty(outputDirectory))
{
outputDirectory = projectFileEntity.Directory
.Directory(Constants.LibraryFolderName)
.FullName;
}
return(owner.Create(key, outputDirectory));
}
protected override void WritePreExecutableScript(StreamWriter scriptWriter)
{
base.WritePreExecutableScript(scriptWriter);
foreach (var shellLine in BuildEntity.GetShellLines())
{
scriptWriter.WriteLine(shellLine);
}
}
public BuildEntity Delete(int BuildId)
{
BuildEntity dbEntry = context.BuildEntities.Find(BuildId);
if (dbEntry != null)
{
context.BuildEntities.Remove(dbEntry);
context.SaveChanges();
}
return(dbEntry);
}
public void DeleteBuild_DeleteBuild_RepositoryMehtodWasCalled()
{
//Arrange
BuildEntity entity = new BuildEntity();
BuildRepository.Setup(x => x.FindById(It.IsAny <Guid>())).Returns(entity);
//Act
buildService.DeleteBuild(new Guid());
//Assert
BuildRepository.Verify(x => x.Delete(entity));
}
private double ComputeBuildCoverage(BuildEntity build)
{
if (build.CoverageCollection == null)
{
return(0);
}
var covered = build.CoverageCollection.Sum(i => i.BlocksCovered);
var notCovered = build.CoverageCollection.Sum(i => i.BlocksNotCovered);
return(((Double)covered * 100) / (notCovered + covered));
}
public void GetProductManagerTest()
{
// Arrange
var mock = new Mock <IHostRepository>();
BuildEntity build = new BuildEntity();
//mock.Setup(a => build.NewProductEntity(a.Entity<Product>(product => product.Id != System.Guid.Parse("f5a73537-d0ba-434e-9b08-02ff55465562"))));
ProductManager productManager = new ProductManager();
// Act
var result = productManager.GetProduct(System.Guid.Parse("f5a73537-d0ba-434e-9b08-02ff55465562"));
// Assert
Assert.IsNotNull(result);
}
public void GetAllProductManagerTest()
{
// Arrange
var mock = new Mock <IHostRepository>();
BuildEntity build = new BuildEntity();
mock.Setup(a => a.Set <Product, Store.Models.Product>(x => build.NewProductEntity(x))).Returns(new List <Store.Models.Product>());
ProductManager productManager = new ProductManager();
// Act
var result = productManager.GetAllProducts().Result.ToList();
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(mock.Object.Set <Product, Store.Models.Product>(x => build.NewProductEntity(x)));
Assert.AreEqual(result, mock.Object.Set <Product, Store.Models.Product>(x => build.NewProductEntity(x)));
}
public void SaveBuild(BuildEntity build)
{
if (build.BuildEntityGuid == null)
{
context.BuildEntities.Add(build);
}
else
{
BuildEntity dbEntry = context.BuildEntities.Find(build.BuildEntityGuid);
if (dbEntry != null)
{
dbEntry.CPU = build.CPU;
dbEntry.GPU = build.GPU;
dbEntry.CPUID = build.CPUID;
dbEntry.GPUID = build.GPUID;
//doubtful
dbEntry.UserID = build.UserID;
//
}
}
context.SaveChanges();
}
private double ComputeRatio(BuildEntity buildEntity, ReportingContext context)
{
var currentProject = context.Projects.FirstOrDefault(i => i.Name == buildEntity.Definition);
if (currentProject == null)
{
currentProject = new ProjectEntity {
Name = buildEntity.Definition
};
context.Projects.Add(currentProject);
}
if (!buildEntity.CoverageCollection.Any())
{
return(0);
}
var currentProjectBlock = buildEntity.CoverageCollection.Sum(i => i.BlocksCovered + i.BlocksNotCovered);
currentProject.Blocks = currentProjectBlock;
if (!context.Projects.Any())
{
return(1);
}
var maxBlock = context.Projects.Max(i => i.Blocks);
var maxProject = context.Projects.FirstOrDefault(i => i.Blocks == maxBlock);
if (maxProject == null || maxBlock == 0)
{
return(1); // Ratio = 1 : no project to be compared.
}
if (maxProject.Id == currentProject.Id)
{
return(1); // current projet is the bigest project.
}
return((double)currentProjectBlock / maxBlock);
}
public async Task <IHttpActionResult> Post([FromBody] HttpHookBuild build)
{
var knowDefinitionsBuilds = ConfigurationManager.AppSettings["ExpectedBuilds"].Split('|').Where(i => !string.IsNullOrEmpty(i)).ToArray();
if (knowDefinitionsBuilds.Any() && !knowDefinitionsBuilds.Contains(build.resource.definition.name))
{
return(Ok());
}
try
{
using (var context = new ReportingContext())
{
var request = build.resource.requests.FirstOrDefault();
var buildEntity = new BuildEntity
{
BuildName = build.resource.buildNumber,
Definition = build.resource.definition.name,
Date = build.resource.finishTime,
Status = build.resource.status,
Reason = build.resource.reason,
Link = build.message.html,
User = request != null ? request.requestedFor.uniqueName : "Unknown user",
CoverageCollection = new Collection <CoverageEntity>()
};
if (buildEntity.User == "Project Collection Service Accounts")
{
buildEntity.User = "******";
}
if (buildEntity.User == ConfigurationManager.AppSettings["VsoUsername"])
{
return(Ok());
}
if (string.IsNullOrEmpty(ConfigurationManager.AppSettings["VSO.OrganisationName"]) || string.IsNullOrEmpty(ConfigurationManager.AppSettings["VSO.ProjectName"]))
{
throw new ApplicationException("Please configuration VSO.OrganisationName and VSO.ProjectName first.");
}
var api = new ApiWrapper(ConfigurationManager.AppSettings["VSO.OrganisationName"], ConfigurationManager.AppSettings["VSO.ProjectName"]);
var coverage = await api.GetBuildCoverageAsync(build);
if (coverage != null)
{
foreach (var moduleCoverage in coverage)
{
buildEntity.CoverageCollection.Add(new CoverageEntity
{
Name = moduleCoverage.Name,
ComputedAverage = moduleCoverage.ComputedAverage,
BlocksCovered = moduleCoverage.BlocksCovered,
BlocksNotCovered = moduleCoverage.BlocksNotCovered,
Build = buildEntity
});
}
}
double currentRatio = ComputeRatio(buildEntity, context);
var challenge = ComputeCoverageChanges(buildEntity, context, currentRatio);
if (challenge != null)
{
context.Challenges.Add(challenge);
}
context.Builds.Add(buildEntity);
context.SaveChanges();
}
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private ChallengeEntity ComputeCoverageChanges(BuildEntity buildEntity, ReportingContext context, double currentRatio)
{
if (buildEntity.Status != "succeeded")
{
return(null);
}
var previousBuild = context.Builds
.OrderByDescending(i => i.Date)
.FirstOrDefault(i => i.Definition == buildEntity.Definition && i.Status == "succeeded" && i.CoverageCollection.Any());
if (previousBuild == null)
{
return(null);
}
var challenge = new ChallengeEntity
{
User = buildEntity.User,
Build = buildEntity,
ModuleCoverages = new List <ModuleChallengeCoverage>()
};
var allModules = previousBuild.CoverageCollection.Select(i => i.Name).Union(buildEntity.CoverageCollection.Select(i => i.Name));
foreach (var moduleName in allModules)
{
var currentModuleName = moduleName;
var previousModule = previousBuild.CoverageCollection.FirstOrDefault(i => i.Name == currentModuleName);
var currentModule = buildEntity.CoverageCollection.FirstOrDefault(i => i.Name == currentModuleName);
if (currentModule != null && previousModule != null && (previousModule.BlocksCovered == currentModule.BlocksCovered && previousModule.BlocksNotCovered == currentModule.BlocksNotCovered))
{
continue; // Ignore if no change in the module.
}
if (currentModule == null)
{
continue;
}
var previousModuleCoverage = ComputeBuildCoverage(previousModule);
var currentModuleCoverage = ComputeBuildCoverage(currentModule);
var deltaCoverage = currentModuleCoverage - previousModuleCoverage;
var allBlocks = currentModule.BlocksCovered + currentModule.BlocksNotCovered;
challenge.ModuleCoverages.Add(new ModuleChallengeCoverage {
Module = currentModuleName, DeltaCoverage = deltaCoverage, Blocks = allBlocks
});
}
var previousProjectCoverage = ComputeBuildCoverage(previousBuild);
var currentProjectCoverage = ComputeBuildCoverage(buildEntity);
challenge.Points = (currentProjectCoverage - previousProjectCoverage) * 100 * currentRatio;
if (double.IsNaN(challenge.Points))
{
challenge.Points = 0;
}
return(challenge);
}
public override IEnumerable <string> GetExecutableArguments()
{
return(BuildEntity.GetCommandLineArgs());
}
