protected override TAsset CreateEntity(Type?assetType, int id, IComponent[]?components)
{
var asset = assetType == null
? _assetFactory.Create(id, components)
: _assetFactory.Create(assetType, id, components);
return((TAsset)asset);
}
private static void AddTargetAssets(IUnitTestGeneratorOptions options, KeyValuePair <Project, Tuple <HashSet <TargetAsset>, HashSet <IReferencedAssembly> > > pair)
{
ThreadHelper.ThrowIfNotOnUIThread();
foreach (var targetAsset in pair.Value.Item1)
{
var asset = AssetFactory.Create(targetAsset);
if (asset != null)
{
var targetProjectFileName = pair.Key.FileName;
var targetProjectPath = Path.GetDirectoryName(targetProjectFileName);
if (string.IsNullOrWhiteSpace(targetProjectPath))
{
continue;
}
#pragma warning disable VSTHRD010
if (!pair.Key.ProjectItems.OfType <ProjectItem>().Any(x => string.Equals(x.Name, asset.AssetFileName, StringComparison.OrdinalIgnoreCase)))
#pragma warning restore VSTHRD010
{
var nameSpace = VsProjectHelper.GetProjectRootNamespace(pair.Key);
var fileName = Path.Combine(targetProjectPath, asset.AssetFileName);
File.WriteAllText(fileName, asset.Content(nameSpace, options.GenerationOptions.FrameworkType));
pair.Key.ProjectItems.AddFromFile(fileName);
}
}
}
}
public static void CanCallCreate()
{
var assetType = TargetAsset.PropertyTester;
var result = AssetFactory.Create(assetType);
Assert.That(result, Is.InstanceOf <IAsset>());
}
public ICommandResult Create(AssetCommand command)
{
try
{
if (command.IsValid())
{
var brandResult = this.brandRepository.GetById(new Guid(command.BrandId));
if (brandResult is null)
{
AddNotification("BrandID", "Brand not found");
return(new UnsuccessfulCommandResult(StatusCodeResult.NotFound,
"Please, check the properties before creating the user", this.Notifications));
}
var brand = BrandFactory.Create(brandResult);
var asset = AssetFactory.Create(command, brand);
this.assetRepository.Save(asset);
return(new SuccessfulCommandResult("Asset was saved with successful", new
{
id = asset.Id,
Name = asset.Name,
Description = asset.Description,
Registry = asset.Registry,
Brand = new
{
id = asset.Brand.Id,
Name = asset.Brand.Name,
}
}));
}
return(new UnsuccessfulCommandResult(StatusCodeResult.BadRequest,
"Please, check the properties before creating the asset", command.Notifications));
}
catch (Exception ex)
{
return(new UnsuccessfulCommandResult(StatusCodeResult.InternalServerError,
"There was an error saving the user, please contact your system administrator.",
ex.Message));
}
}
public static async Task AssertTestGeneration(string resourceName, TestFrameworkTypes testFrameworkTypes, MockingFrameworkType mockingFrameworkType)
{
var classAsText = TestClasses.ResourceManager.GetString(resourceName, TestClasses.Culture);
var tree = CSharpSyntaxTree.ParseText(classAsText, new CSharpParseOptions(LanguageVersion.Latest));
var assemblyPath = Path.GetDirectoryName(typeof(object).Assembly.Location);
var references = new List <MetadataReference>
{
MetadataReference.CreateFromFile(typeof(object).Assembly.Location),
MetadataReference.CreateFromFile(typeof(INotifyPropertyChanged).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Expression).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Brush).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Stream).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Form).Assembly.Location),
MetadataReference.CreateFromFile(typeof(SqlConnection).Assembly.Location),
MetadataReference.CreateFromFile(typeof(Window).Assembly.Location),
MetadataReference.CreateFromFile(typeof(UIElement).Assembly.Location),
MetadataReference.CreateFromFile(typeof(DependencyObject).Assembly.Location),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Core.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Runtime.dll")),
MetadataReference.CreateFromFile(Path.Combine(assemblyPath, "System.Threading.Tasks.dll")),
};
references.AddRange(GetReferences(mockingFrameworkType));
references.AddRange(GetReferences(testFrameworkTypes));
var compilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: new[] { tree },
references: references);
var semanticModel = compilation.GetSemanticModel(tree);
IUnitTestGeneratorOptions options = Substitute.For <IUnitTestGeneratorOptions>();
options.GenerationOptions.FrameworkType.Returns(testFrameworkTypes);
options.GenerationOptions.MockingFrameworkType.Returns(mockingFrameworkType);
options.GenerationOptions.TestFileNaming.Returns("{0}Tests");
options.GenerationOptions.TestTypeNaming.Returns("{0}Tests");
options.GenerationOptions.TestProjectNaming.Returns("{0}.Tests");
var core = await CoreGenerator.Generate(semanticModel, null, null, false, options, x => "Tests").ConfigureAwait(true);
Assert.IsNotNull(core);
Console.WriteLine(core.FileContent);
Assert.IsNotNull(core.FileContent);
var generatedTree = CSharpSyntaxTree.ParseText(core.FileContent, new CSharpParseOptions(LanguageVersion.Latest));
var syntaxTrees = new List <SyntaxTree> {
tree, generatedTree
};
if (core.RequiredAssets.Any(x => x == TargetAsset.PropertyTester))
{
var testerAsset = AssetFactory.Create(TargetAsset.PropertyTester);
var propertyTester = testerAsset.Content("Tests", testFrameworkTypes);
syntaxTrees.Add(CSharpSyntaxTree.ParseText(propertyTester, new CSharpParseOptions(LanguageVersion.Latest)));
}
var validateCompilation = CSharpCompilation.Create(
"MyTest",
syntaxTrees: syntaxTrees,
references: references,
options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
var stream = new MemoryStream();
var result = validateCompilation.Emit(stream);
var streamLength = stream.Length;
stream.Dispose();
Assert.IsTrue(result.Success, string.Join(",", result.Diagnostics.Select(x => x.Location.GetLineSpan().StartLinePosition.Line + ": " + x.GetMessage())));
Assert.That(streamLength, Is.GreaterThan(0));
}