public void DefinitionMetadataProjectSetViaMetadata()
{
Project project = GetProject();
ProjectMetadata metadata = GetOverridableMetadata(project);
metadata.UnevaluatedValue = NewValue;
Assert.Equal(NewValue, metadata.EvaluatedValue);
Assert.True(project.IsDirty); // "Project was not marked dirty."
}
public void CodeGenerate_Test()
{
ProjectMetadata projectMetadata = new ProjectMetadata();
projectMetadata.Company = "大黄瓜科技有限公司";
projectMetadata.SiteUrl = "http://admin.destinycore.club";
projectMetadata.Creator = "大黄瓜18cm";
projectMetadata.Copyright = "大黄瓜18cm";
projectMetadata.Namespace = "Destiny.Core.Flow";
projectMetadata.SaveFilePath = @"C:\Users\Admin\Desktop\Code";
List <PropertyMetadata> propertyMetadatas = new List <PropertyMetadata>();
propertyMetadatas.Add(new PropertyMetadata()
{
IsNullable = false,
IsPrimaryKey = false,
CSharpType = "string",
DisplayName = "名字",
PropertyName = "Name",
IsPageDto = true,
});
propertyMetadatas.Add(new PropertyMetadata()
{
IsNullable = false,
IsPrimaryKey = false,
CSharpType = "string",
DisplayName = "名字1",
PropertyName = "Name1"
});
propertyMetadatas.Add(new PropertyMetadata()
{
IsNullable = false,
IsPrimaryKey = false,
CSharpType = "int",
DisplayName = "价格",
PropertyName = "Price",
IsPageDto = false
});
projectMetadata.EntityMetadata = new EntityMetadata()
{
EntityName = "TestCode",
DisplayName = "代码生成",
PrimaryKeyType = "Guid",
PrimaryKeyName = "Id",
Properties = propertyMetadatas,
IsCreation = true,
IsModification = true,
IsSoftDelete = true,
AuditedUserKeyType = "Guid",
IsAutoMap = true,
};
ICodeGenerator codeGenerator = ServiceProvider.GetService <ICodeGenerator>();
codeGenerator.GenerateCode(projectMetadata);
}
private async Task ScanBucket(List <MigrationJob> migrationJobs, string bucketKeyOld)
{
OssBucket bucketOld = _bucketFactory.CreateBucket(bucketKeyOld);
OssBucket bucketNew = _bucketFactory.CreateBucket(_bucketProvider.GetBucketKeyFromOld(bucketKeyOld));
List <string> projectNamesNew = new List <string>();
try
{
List <string> projectNamesNewFromOss = (List <string>) await _projectService.GetProjectNamesAsync(bucketNew);
foreach (string projectName in projectNamesNewFromOss)
{
var ossAttributes = new OssAttributes(projectName);
string metadataFile = ossAttributes.Metadata;
// if metadata file is missing for project we consider that project not migrated
if (await bucketNew.ObjectExistsAsync(metadataFile))
{
projectNamesNew.Add(projectName);
}
}
}
catch (ApiException e) when(e.ErrorCode == StatusCodes.Status404NotFound)
{
// swallow non existing item
}
List <string> projectNamesOld = (List <string>) await _projectService.GetProjectNamesAsync(bucketOld);
foreach (string projectName in projectNamesOld)
{
if (!projectNamesNew.Contains(projectName))
{
// new project list does not contain old project => lets copy and adopt
var ossAttributes = new OssAttributes(projectName);
string metadataFile = ossAttributes.Metadata;
ProjectMetadata projectMetadata = await bucketOld.DeserializeAsync <ProjectMetadata>(metadataFile);
ProjectInfo projectInfo = new ProjectInfo();
projectInfo.Name = projectName;
projectInfo.TopLevelAssembly = projectMetadata.TLA;
migrationJobs.Add(new MigrationJob(JobType.CopyAndAdopt, bucketOld, projectInfo, ONC.ProjectUrl(projectName)));
}
}
// check if any of migrated projects were deleted in old bucket
// (user deleted them after migration started)
foreach (string projectName in projectNamesNew)
{
if (!projectNamesOld.Contains(projectName))
{
migrationJobs.Add(new MigrationJob(JobType.RemoveNew, bucketNew, new ProjectInfo(projectName), null));
}
}
}
// ==========================================================================================
/// <summary>
/// Extract input and output properties from MSBuild.
/// </summary>
private void GatherNativeInputsAndOutputs()
{
m_extension = this.GetPropertyValue("TargetExt");
//Debug.Assert(String.IsNullOrEmpty(m_extension) == false);
m_output_binary = (this.GetPropertyValue("TargetName") + m_extension).ToLower();
//Debug.Assert(String.IsNullOrEmpty(m_extension) == false);
m_output_binary_path = this.GetPropertyValue("TargetPath");
ProjectItemDefinition LinkDef = null;
if (String.Compare(".lib", m_extension, true) == 0)
{
LinkDef = this.ItemDefinitions["Lib"];
}
else
{
LinkDef = this.ItemDefinitions["Link"];
}
//Debug.Assert(LinkDef != null);
if (LinkDef != null)
{
String importLibPath = LinkDef.GetMetadataValue("ImportLibrary");
//Debug.Assert(importLibPath != null);
if (String.IsNullOrEmpty(importLibPath) == false)
{
m_Import_Library_FullPath = importLibPath.ToLower();
}
m_import_library = Path.GetFileName(importLibPath).ToLower();
if (String.Compare(".lib", m_extension, true) == 0)
{
m_import_library = m_output_binary;
}
String additionalDependencies = LinkDef.GetMetadataValue("AdditionalDependencies");
//Debug.Assert(additionalDependencies != null);
ResolveInputLibraries(additionalDependencies);
String PDB = LinkDef.GetMetadataValue("ProgramDatabaseFile");
//Debug.Assert(PDB != null);
m_pdb_filename = Path.GetFileName(PDB).ToLower();
}
ProjectItemDefinition MidlDef = this.ItemDefinitions["Midl"];
if (MidlDef != null)
{
ProjectMetadata metaTypeLibraryName = MidlDef.GetMetadata("TypeLibraryName");
if (metaTypeLibraryName.IsImported == false)
{
String typeLibrary = metaTypeLibraryName.EvaluatedValue;
String tname = Path.GetFileName(this.ExpandString(typeLibrary)).ToLower();
m_typelibrary = tname;
}
}
}
/// <inheritdoc />
public ProjectMetadata ReadProject(string projectFilePath)
{
// prepare necessary files and directories
string projectRoot = Path.GetDirectoryName(projectFilePath);
string projectFile = Path.GetFileName(projectFilePath);
string objDir = Path.Combine(projectRoot, "obj");
string targetFilePath = Path.Combine(objDir, projectFile + ".TTGetMetadata.targets");
Directory.CreateDirectory(objDir);
string projectName = Assembly.GetExecutingAssembly().GetName().Name;
using (var targets = typeof(MsBuildProjectMetadataResolver).Assembly.GetManifestResourceStream($"{projectName}.Resources.TTGetMetadata.targets"))
using (var outputFile = File.OpenWrite(targetFilePath))
{
targets.CopyTo(outputFile);
}
string metadataFile = Path.Combine(objDir, $"{projectFile}metadata");
// build with TTGetMetadata.targets
// dotnet msbuild /t:TTGetMetadata /p:TTProjectMetadataFile="pathToResult"
var args = new List <string>
{
"msbuild",
"/t:TTGetMetadata",
$"/p:TTProjectMetadataFile=\"{metadataFile}\"",
"/verbosity:quiet",
"/nologo"
};
var processStartInfo = new ProcessStartInfo("dotnet", string.Join(' ', args))
{
WorkingDirectory = projectRoot,
UseShellExecute = false
};
var process = Process.Start(processStartInfo);
process.WaitForExit();
// reading generated metadata file
var metadatas = File.ReadAllLines(metadataFile)
.Select(line => line.Split(": "))
.Where(segs => segs.Length == 2)
.Select(segments => new KeyValuePair <string, string>(segments[0], segments[1]));
File.Delete(metadataFile);
var projectMetadata = new ProjectMetadata
{
Metadatas = new Dictionary <string, string>(metadatas)
};
projectMetadata.ProjectFile = projectFile;
ProjectMetadata = projectMetadata;
return(projectMetadata);
}
public async Task <TProjectConfig> AddOrUpdateProject <TProjectConfig>(ProjectMetadata projectMetadata, TProjectConfig project)
where TProjectConfig : ProjectConfig
{
await _projectsMetadataRepo.AddOrUpdate(projectMetadata);
await _projectRepo.AddOrUpdate(projectMetadata, project);
_memoryCache.Remove(ProjectsMetaCacheKey);
return(project);
}
public void CodeGenerate_Test()
{
ProjectMetadata projectMetadata = new ProjectMetadata();
projectMetadata.Company = "XXXX开车公司";
projectMetadata.SiteUrl = "http://admin.destinycore.club";
projectMetadata.Creator = "王莫某";
projectMetadata.Copyright = "王莫某";
projectMetadata.Namespace = "Sukt.Core.Domain.Models";
List <PropertyMetadata> propertyMetadatas = new List <PropertyMetadata>();
propertyMetadatas.Add(new PropertyMetadata()
{
IsNullable = false,
IsPrimaryKey = false,
CSharpType = "string",
DisplayName = "名字",
PropertyName = "Name",
IsPageDto = true,
});
propertyMetadatas.Add(new PropertyMetadata()
{
IsNullable = false,
IsPrimaryKey = false,
CSharpType = "string",
DisplayName = "名字1",
PropertyName = "Name1"
});
propertyMetadatas.Add(new PropertyMetadata()
{
IsNullable = false,
IsPrimaryKey = false,
CSharpType = "int",
DisplayName = "价格",
PropertyName = "Price",
IsPageDto = false
});
projectMetadata.EntityMetadata = new EntityMetadata()
{
EntityName = "TestCode",
DisplayName = "代码生成",
PrimaryKeyType = "Guid",
PrimaryKeyName = "Id",
Properties = propertyMetadatas,
IsCreation = true,
IsModification = true,
IsSoftDelete = false,
AuditedUserKeyType = "Guid",
};
var savePath = @"E:\TestCodeGenerator";
ICodeGenerator codeGenerator = ServiceProvider.GetService <ICodeGenerator>();
codeGenerator.GenerateCode(projectMetadata, savePath);
}
public virtual IProjectMetadataBuilder AddProjectMetadata(ProjectMetadata metadata)
{
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
AllMetadata.Add(metadata);
return(this);
}
public void Change()
{
try
{
if (Project == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(Configuration))
{
Project.SetProperty("Configuration", Configuration);
Project.Save();
}
if (PrebuildEvent)
{
Project.SetProperty("PreBuildEvent", string.Empty);
}
if (PostbuildEvent)
{
Project.SetProperty("PostBuildEvent", string.Empty);
}
if (!string.IsNullOrWhiteSpace(PlatformTarget))
{
Project.SetProperty("PlatformTarget", PlatformTarget);
}
ProjectProperty outputPath = Project.GetProperty("OutputPath");
if (outputPath == null || string.IsNullOrWhiteSpace(outputPath.EvaluatedValue))
{
Project.SetProperty("OutputPath", "bin\\" + Configuration);
}
if (UpdateReferences)
{
foreach (ProjectItem item in Project.GetItems("Reference"))
{
if (item == null)
{
continue;
}
ProjectMetadata hintPath = item.GetMetadata("HintPath");
if (hintPath != null && !string.IsNullOrWhiteSpace(hintPath.EvaluatedValue))
{
item.SetMetadataValue("HintPath",
Path.Combine(ReferencesPath, Path.GetFileName(hintPath.EvaluatedValue)));
}
}
}
Project.Save();
Utility.Log(LogStatus.Ok, string.Format("File Updated - {0}", Project.FullPath), _log);
}
catch (Exception ex)
{
Utility.Log(LogStatus.Error, ex.Message, _log);
}
}
public static void MapFromProject_ReturnsExpectedResult()
{
var project = Helpers.CreateTestProject();
var pm = ProjectMetadata.MapFromProject(project);
Assert.That(pm, Is.Not.Null);
pm.Should().BeEquivalentTo(
project,
options => options.ExcludingMissingMembers());
}
public void MetadataProjectSetViaMetadata()
{
Project project = GetProject();
ProjectMetadata metadata = GetProjectMetadata(project);
string newValue = "NewProjectMetadataValue";
metadata.UnevaluatedValue = newValue;
Assert.Equal(newValue, metadata.EvaluatedValue);
Assert.True(project.IsDirty); // "Project was not marked dirty."
}
public void DefinitionMetadataImportSetViaMetadata()
{
Assert.Throws <InvalidOperationException>(() =>
{
Project project = GetProject();
ProjectMetadata metadata = GetNonOverridableMetadata(project);
// This should throw
metadata.UnevaluatedValue = NewValue;
}
);
}
public void DefinitionMetadataProjectRemove()
{
Project project = GetProject();
ProjectItem item = GetProjectItem(project);
item.RemoveMetadata(OverridableMetadataName);
ProjectMetadata metadata = item.GetMetadata(OverridableMetadataName);
Assert.NotNull(metadata); // "Imported metadata not found after the project's one was removed."
Assert.True(metadata.IsImported); // "IsImported property is not set."
}
public static ProjectMetadata SetMetadata(string projectFilePath)
{
var metadata = new ProjectMetadata
{
ProjectFullPath = projectFilePath,
ProjectFileName = FileUtil.GetFileName(projectFilePath),
ProjectType = SolutionProjectElement.CSharpProject,
ProjectName = FileUtil.GetFileNameWithoutExtension(projectFilePath)
};
return(metadata);
}
public RazorCodeGeneratorTests()
{
_generator = new RazorCodeGenerator();
ProjectMetadata project = new ProjectMetadata()
{
Name = "XXX系统",
Company = "Kira Yoshikage",
Copyright = "Copyright (c) 2014-2019 OSharp. All rights reserved.",
Creator = "郭明锋",
SiteUrl = "https://www.66soft.net",
NamespacePrefix = "Liuliu.Site"
};
_module = new ModuleMetadata()
{
Name = "Infos",
Display = "信息",
Project = project
};
_entity = new EntityMetadata()
{
Name = "Article",
Display = "文章",
Module = _module,
IsDataAuth = true,
PrimaryKeyTypeFullName = typeof(int).FullName,
Properties = new List <PropertyMetadata>()
{
new PropertyMetadata()
{
Name = "Title", Display = "标题", TypeName = typeof(string).FullName
},
new PropertyMetadata()
{
Name = "Content", Display = "正文", TypeName = typeof(string).FullName
},
new PropertyMetadata()
{
Name = "IsHot", Display = "是否热点", TypeName = typeof(bool).FullName
},
new PropertyMetadata()
{
Name = "IsLocked", Display = "是否锁定", TypeName = typeof(bool).FullName
},
new PropertyMetadata()
{
Name = "IsDeleted", Display = "是否删除", TypeName = typeof(bool).FullName, IsInputDto = false, IsOutputDto = false
}
}
};
}
/// <summary>
/// Gets the test metadata from the project.
/// </summary>
/// <param name="project">The project.</param>
/// <returns>The metadata.</returns>
private ProjectMetadata GetProjectMetadata(Project project)
{
ProjectItem item = GetProjectItem(project);
IEnumerable <ProjectMetadata> metadatum = item.Metadata.Where(m => m.Name == ProjectMetadataName);
Assert.Equal(1, metadatum.Count()); // "Incorrect number of imported metadata found."
ProjectMetadata metadata = metadatum.First();
Assert.False(metadata.IsImported); // "IsImport property is set."
return(metadata);
}
/// <summary>
/// Gets the test templetized metadata from the project.
/// </summary>
/// <param name="project">The project.</param>
/// <returns>The metadata.</returns>
private ProjectMetadata GetOverridableMetadata(Project project)
{
ProjectItem item = GetProjectItem(project);
IEnumerable <ProjectMetadata> metadatum = item.Metadata.Where(m => m.Name == OverridableMetadataName);
Assert.IsTrue(metadatum.Count() == 1, "Incorrect number of imported metadata found.");
ProjectMetadata metadata = metadatum.First();
Assert.IsFalse(metadata.IsImported, "IsImport property is set.");
return(metadata);
}
/// <summary>
/// Gets the test templetized metadata from the import.
/// </summary>
/// <param name="project">The project.</param>
/// <returns>The metadata.</returns>
private ProjectMetadata GetNonOverridableMetadata(Project project)
{
ProjectItem item = GetProjectItem(project);
IEnumerable <ProjectMetadata> metadatum = item.Metadata.Where(m => m.Name == NonOverridableMetadataName);
Assert.Single(metadatum); // "Incorrect number of imported metadata found."
ProjectMetadata metadata = metadatum.First();
Assert.True(metadata.IsImported); // "IsImport property is not set."
return(metadata);
}
public JsonEditor(string projectIn)
{
_projectLocation = projectIn;
if (File.Exists(Path.Combine(_projectLocation, "package.json")))
{
var importFile = File.ReadAllText(Path.Combine(_projectLocation, "package.json"));
ProjectMetadata = JsonSerializer.Deserialize(importFile, ProjectMetadataSerializer.Default.ProjectMetadata);
}
else
{
ProjectMetadata = new();
}
InitializeComponent();
}
public void SetValueWithItemExpression()
{
Project project = new Project();
project.AddItem("i", "i1");
ProjectItem item = project.AddItem("j", "j1")[0];
ProjectMetadata metadatum = item.SetMetadataValue("m", "@(i)");
project.ReevaluateIfNecessary();
metadatum.UnevaluatedValue = "@(i)";
Assert.Equal("@(i)", metadatum.UnevaluatedValue);
Assert.Equal("i1", metadatum.EvaluatedValue);
}
private Project ConvertM(ProjectMetadata objProjectMetada)
{
Project ObjectProject = new Project();
ObjectProject.CodProject = objProjectMetada.CodProject;
ObjectProject.NameProject = objProjectMetada.NameProject;
ObjectProject.IdRepresent = objProjectMetada.IdRepresent;
ObjectProject.DateCreate = objProjectMetada.DateCreate;
ObjectProject.UseProject = objProjectMetada.UseProject;
ObjectProject.Active = objProjectMetada.Active;
ObjectProject.Avance = objProjectMetada.Avance;
return ObjectProject;
}
public void SetValueWithPropertyExpression()
{
Project project = new Project();
project.SetProperty("p", "p0");
ProjectItem item = project.AddItem("i", "i1")[0];
ProjectMetadata metadatum = item.SetMetadataValue("m", "m1");
project.ReevaluateIfNecessary();
metadatum.UnevaluatedValue = "$(p)";
Assert.Equal("$(p)", metadatum.UnevaluatedValue);
Assert.Equal("p0", metadatum.EvaluatedValue);
}
//
// GET: /Agancies/
public ActionResult Index()
{
CreateOstanSelectListData();
using (var de = new DatisEntities())
{
var project = new Project();
de.Projects.Add(project);
de.SaveChanges();
var meta = new ProjectMetadata()
{
Id = project.Id
};
return(View(meta));
}
}
public void SetMetadata()
{
ProjectRootElement xml = ProjectRootElement.Create();
xml.AddProperty("p", "v");
xml.AddItemDefinitionGroup().AddItemDefinition("i").AddMetadata("m", "m0");
xml.AddItem("i", "i1");
Project project = new Project(xml);
ProjectMetadata metadatum = project.ItemDefinitions["i"].GetMetadata("m");
metadatum.UnevaluatedValue = "$(p)";
Assert.Equal("v", Helpers.GetFirst(project.GetItems("i")).GetMetadataValue("m"));
}
private void ProcessConfigFiles(ProjectMetadata projectMetadata, SourceInformation projectSourceInformation)
{
_logger.Trace("Entering");
var configFiles = _allItems
.Where(
x =>
x.SourcePath.StartsWith(
projectSourceInformation.SourcePath,
StringComparison.CurrentCultureIgnoreCase) &&
x.SourcePath.ToLower().EndsWith(".config", StringComparison.CurrentCultureIgnoreCase) &&
!x.SourcePath.ContainsInsensitive("packages.config")
);
var exceptions = new ConcurrentQueue <Exception>();
foreach (var configFile in configFiles)
{
try
{
var filename = Path.GetFileName(configFile.SourcePath);
var extension = Path.GetExtension(configFile.SourcePath);
var sourceTool = GetSourceTool();
var sw = Stopwatch.StartNew();
var content = sourceTool.GetItemContent(configFile);
sw.Stop();
_logger.Trace($"GetItemContent took {sw.Elapsed}");
ProcessConfigFile(projectMetadata, filename, extension, content);
}
catch (Exception e)
{
OnExceptionThrown(new ExceptionEventArgs(configFile, e));
exceptions.Enqueue(e);
}
}
if (exceptions.Any())
{
throw new AggregateException(
$"Some config file processing failed for {projectSourceInformation}.",
exceptions);
}
}
public async Task AddOrUpdate <TProjectConfig>(ProjectMetadata metadata, TProjectConfig projectConfig)
where TProjectConfig : ProjectConfig
{
if (metadata?.Path == null)
{
return;
}
// Atm, update simply overrides current data.
string path = ProjectContainer.StorageKey(metadata.Path);
ProjectStorageItem storageItem = new()
{
ProjectType = projectConfig.ProjectType,
JsonPayload = JsonSerializer.Serialize(projectConfig),
};
await _localStorage.SetItemAsync(path, new ProjectContainer(path, storageItem));
}
public static String GetEvaluatedMetadata(Microsoft.Build.Evaluation.Project project, String type, String name)
{
ProjectItemDefinition item = null;
ProjectMetadata metadata = null;
if (project.ItemDefinitions.TryGetValue("IceBuilder", out item))
{
metadata = item.Metadata.FirstOrDefault(m => m.Name.Equals(name));
}
else
{
metadata =
project.AllEvaluatedItemDefinitionMetadata.FirstOrDefault(
m => m.ItemType.Equals("IceBuilder") && m.Name.Equals(name));
}
return(metadata == null ? String.Empty : metadata.EvaluatedValue);
}
public ActionResult GetProjectMetadata(string projectName, string environmentName)
{
if (string.IsNullOrEmpty(projectName))
{
return(BadRequest());
}
if (string.IsNullOrEmpty(environmentName))
{
return(BadRequest());
}
try
{
ProjectMetadata projectMetadata =
_agentService.GetProjectMetadata(projectName, environmentName);
var projectMetadataViewModel =
new ProjectMetadataViewModel
{
ProjectName = projectMetadata.ProjectName,
EnvironmentName = projectMetadata.EnvironmentName,
ProjectVersions =
projectMetadata.ProjectVersions
.Select(
pv =>
new MachineSpecificProjectVersionViewModel
{
MachineName = pv.MachineName,
ProjectVersion = pv.ProjectVersion,
}).ToList(),
};
projectMetadataViewModel.Status = "OK";
return
(Json(
projectMetadataViewModel,
JsonRequestBehavior.AllowGet));
}
catch (Exception exc)
{
return(HandleAjaxError(exc));
}
}
public void WriteProjectJson(string directory, ProjectMetadata projectMetadata, IReadOnlyList <PackageEntry> packages)
{
var doc = new JObject
{
["version"] = "0.0.0-*",
["dependencies"] = new JObject()
};
foreach (var package in packages)
{
doc["dependencies"][package.Id] = package.Version;
}
foreach (var reference in projectMetadata.ProjectReferences)
{
doc["dependencies"][reference] = "*";
}
var framework = "net" + projectMetadata.TargetFrameworkVersion.Replace("v", "").Replace(".", "");
var frameworkElement = new JObject();
doc["frameworks"] = new JObject {
[framework] = frameworkElement
};
if (projectMetadata.FrameworkReferences.Any())
{
frameworkElement["frameworkAssemblies"] = new JObject();
foreach (var reference in projectMetadata.FrameworkReferences)
{
frameworkElement["frameworkAssemblies"][reference] = "*";
}
}
if (projectMetadata.OutputType.Equals("Exe", StringComparison.CurrentCultureIgnoreCase))
{
doc["buildOptions"] = new JObject {
["emitEntryPoint"] = true
};
}
var json = JsonConvert.SerializeObject(doc, Formatting.Indented);
_fileSystem.WriteAllText(Path.Combine(directory, "project.json"), json);
}
public void Update_ReturnsExpectedResult()
{
// Original Item
var sourceInformation1 = new SourceInformation(SourceType.Filesystem, @"c:\git", true);
var project1 = Helpers.CreateTestProject();
var pm1 =
new ProjectMetadata(sourceInformation1, project1)
{
AppSettings = new List <ApplicationSetting>(),
ConnectionStrings = new List <ConnectionStringSetting>
{
new ConnectionStringSetting {
Name = "test1"
}
},
DatabaseInstances = new List <DatabaseInstance>(),
DatabaseTypes = new List <DatabaseType>()
};
// pm1 will be updated with information from pm2
var sourceInformation2 = new SourceInformation(SourceType.Filesystem, @"c:\git\dir2", true);
var project2 = Helpers.CreateTestProject();
// ReSharper disable once StringLiteralTypo
project2.Frameworks = new List <string> {
"netcoreapp1.0"
};
var pm2 = new ProjectMetadata(sourceInformation2, project2)
{
AppSettings = new List <ApplicationSetting>
{
new ApplicationSetting("name", "value")
},
ConnectionStrings = new List <ConnectionStringSetting>(),
DatabaseInstances = new List <DatabaseInstance>(),
DatabaseTypes = new List <DatabaseType>()
};
pm1.Update(pm2);
Assert.That(pm1, Is.Not.Null);
pm1.Should().BeEquivalentTo(pm2);
}
