public override void BeforeAddOrUpdate(
ITargetFramework targetFramework,
IDependency dependency,
IReadOnlyDictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviderByProviderType,
IImmutableSet <string>?projectItemSpecs,
IAddDependencyContext context)
{
// The check for SharedProjectDependency is needed because a SharedProject is not a dependency reference
if (!dependency.TopLevel ||
dependency.Implicit ||
!dependency.Resolved ||
!dependency.Flags.Contains(DependencyTreeFlags.GenericDependencyFlags) ||
dependency.Flags.Contains(DependencyTreeFlags.SharedProjectFlags))
{
context.Accept(dependency);
return;
}
if (projectItemSpecs == null)
{
// No data, so don't update
context.Accept(dependency);
return;
}
if (!projectItemSpecs.Contains(dependency.OriginalItemSpec))
{
// It is an implicit dependency
if (subTreeProviderByProviderType.TryGetValue(dependency.ProviderType, out IProjectDependenciesSubTreeProvider provider) &&
provider is IProjectDependenciesSubTreeProviderInternal internalProvider)
{
ImageMoniker implicitIcon = internalProvider.GetImplicitIcon();
DependencyIconSet implicitIconSet = DependencyIconSetCache.Instance.GetOrAddIconSet(
implicitIcon,
implicitIcon,
dependency.IconSet.UnresolvedIcon,
dependency.IconSet.UnresolvedExpandedIcon);
context.Accept(dependency.SetProperties(
iconSet: implicitIconSet,
isImplicit: true));
return;
}
}
context.Accept(dependency);
}
public IDependency SetProperties(
string caption = null,
bool?resolved = null,
ProjectTreeFlags?flags = null,
string schemaName = null,
IImmutableList <string> dependencyIDs = null,
DependencyIconSet iconSet = null,
bool?isImplicit = null)
{
var clone = new Dependency(this, _modelId);
if (caption != null)
{
clone.Caption = caption;
}
if (resolved != null)
{
clone.Resolved = resolved.Value;
}
if (flags != null)
{
clone.Flags = flags.Value;
}
if (schemaName != null)
{
clone.SchemaName = schemaName;
}
if (dependencyIDs != null)
{
clone.DependencyIDs = dependencyIDs;
}
if (iconSet != null)
{
clone.IconSet = s_iconSetCache.GetOrAddIconSet(iconSet);
}
if (isImplicit != null)
{
clone.Implicit = isImplicit.Value;
}
return(clone);
}
public SubTreeRootDependencyModel(
string providerType,
string name,
DependencyIconSet iconSet,
ProjectTreeFlags flags)
: base(
name,
originalItemSpec: name,
flags: flags + s_flagCache.Get(isResolved: true, isImplicit: false),
isResolved: true,
isImplicit: false,
properties: null)
{
ProviderType = providerType;
IconSet = iconSet;
}
public DependencyGroupModel(
string providerType,
string name,
DependencyIconSet iconSet,
ProjectTreeFlags flags)
: base(
name,
originalItemSpec: name,
flags: flags + ProjectTreeFlags.VirtualFolder + DependencyTreeFlags.DependencyGroup,
isResolved: true,
isImplicit: false,
properties: null)
{
ProviderType = providerType;
IconSet = iconSet;
}
public override IDependency BeforeAdd(
string projectPath,
ITargetFramework targetFramework,
IDependency dependency,
ImmutableDictionary <string, IDependency> .Builder worldBuilder,
IReadOnlyDictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviderByProviderType,
IImmutableSet <string> projectItemSpecs,
out bool filterAnyChanges)
{
filterAnyChanges = false;
if (!dependency.TopLevel ||
dependency.Implicit ||
!dependency.Resolved ||
!dependency.Flags.Contains(DependencyTreeFlags.GenericDependencyFlags))
{
return(dependency);
}
if (projectItemSpecs == null)
{
// No data, so don't update
return(dependency);
}
if (!projectItemSpecs.Contains(dependency.OriginalItemSpec))
{
// It is an implicit dependency
if (subTreeProviderByProviderType.TryGetValue(dependency.ProviderType, out IProjectDependenciesSubTreeProvider provider) &&
provider is IProjectDependenciesSubTreeProviderInternal internalProvider)
{
DependencyIconSet implicitIconSet = dependency.IconSet
.WithIcon(internalProvider.GetImplicitIcon())
.WithExpandedIcon(internalProvider.GetImplicitIcon());
filterAnyChanges = true;
return(dependency.SetProperties(
iconSet: implicitIconSet,
isImplicit: true));
}
}
return(dependency);
}
public static IDependency FromJson(
string jsonString,
ProjectTreeFlags?flags = null,
DependencyIconSet iconSet = null,
Dictionary <string, string> properties = null,
IEnumerable <string> dependenciesIds = null,
ITargetFramework targetFramework = null)
{
if (string.IsNullOrEmpty(jsonString))
{
return(null);
}
var json = JObject.Parse(jsonString);
var data = json.ToObject <TestDependency>();
if (flags.HasValue)
{
data.Flags = data.Flags.Union(flags.Value);
}
if (iconSet != null)
{
data.IconSet = iconSet;
}
if (properties != null)
{
data.Properties = ImmutableStringDictionary <string> .EmptyOrdinal.AddRange(properties);
}
if (dependenciesIds != null)
{
data.DependencyIDs = ImmutableArray.CreateRange(dependenciesIds);
}
if (targetFramework != null)
{
data.TargetFramework = targetFramework;
}
return(data);
}
public override void BeforeAddOrUpdate(
IDependency dependency,
IReadOnlyDictionary <string, IProjectDependenciesSubTreeProvider> subTreeProviderByProviderType,
IImmutableSet <string>?projectItemSpecs,
AddDependencyContext context)
{
if (projectItemSpecs != null && // must have data
!Strings.IsNullOrEmpty(dependency.OriginalItemSpec) &&
!dependency.Implicit && // explicit
dependency.Resolved && // resolved
dependency.Flags.Contains(DependencyTreeFlags.GenericDependency) && // generic dependency
!dependency.Flags.Contains(DependencyTreeFlags.SharedProjectDependency) && // except for shared projects
!projectItemSpecs.Contains(dependency.OriginalItemSpec) && // is not a known item spec
subTreeProviderByProviderType.TryGetValue(dependency.ProviderType, out IProjectDependenciesSubTreeProvider provider) &&
provider is IProjectDependenciesSubTreeProviderInternal internalProvider)
{
// Obtain custom implicit icon
ImageMoniker implicitIcon = internalProvider.ImplicitIcon;
// Obtain a pooled icon set with this implicit icon
DependencyIconSet implicitIconSet = DependencyIconSetCache.Instance.GetOrAddIconSet(
implicitIcon,
implicitIcon,
dependency.IconSet.UnresolvedIcon,
dependency.IconSet.UnresolvedExpandedIcon);
context.Accept(
dependency.SetProperties(
iconSet: implicitIconSet,
isImplicit: true,
flags: dependency.Flags.Except(DependencyTreeFlags.SupportsRemove)));
return;
}
context.Accept(dependency);
}
public IDependency SetProperties(
string caption = null,
bool?resolved = null,
ProjectTreeFlags?flags = null,
string schemaName = null,
ImmutableArray <string> dependencyIDs = default,
DependencyIconSet iconSet = null,
bool?isImplicit = null)
{
return(new TestDependency
{
// Copy all properties from this instance
ClonePropertiesFrom = this,
// Override specific properties as needed
Caption = caption ?? Caption,
Resolved = resolved ?? Resolved,
Flags = flags ?? Flags,
SchemaName = schemaName ?? SchemaName,
DependencyIDs = dependencyIDs.IsDefault ? DependencyIDs : dependencyIDs,
IconSet = iconSet ?? IconSet,
Implicit = isImplicit ?? Implicit
});
}
public TestableDependencyModel(string path, string originalItemSpec, DependencyIconSet iconSet)
: base(path, originalItemSpec, ProjectTreeFlags.Empty, isResolved: false, isImplicit: false, properties: null)
{
IconSet = iconSet;
}
public void ToViewModel()
{
var iconSet = new DependencyIconSet(
KnownMonikers.Uninstall,
KnownMonikers.AbsolutePosition,
KnownMonikers.AboutBox,
KnownMonikers.Abbreviation);
var dependencyResolved = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Yyy"",
""Id"": ""tfm1\\yyy\\dependencyExisting"",
""Name"":""dependencyExisting"",
""Caption"":""DependencyExisting"",
""HasUnresolvedDependency"":""false"",
""SchemaName"":""MySchema"",
""SchemaItemType"":""MySchemaItemType"",
""Priority"":""1"",
""Resolved"":""true""
}", iconSet: iconSet);
var dependencyUnresolved = IDependencyFactory.FromJson(@"
{
""ProviderType"": ""Yyy"",
""Id"": ""tfm1\\yyy\\dependencyExisting"",
""Name"":""dependencyExisting"",
""Caption"":""DependencyExisting"",
""HasUnresolvedDependency"":""false"",
""SchemaName"":""MySchema"",
""SchemaItemType"":""MySchemaItemType"",
""Priority"":""1"",
""Resolved"":""false""
}", iconSet: iconSet);
var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementMock(checkForUnresolvedDependencies: false).Object;
var mockSnapshotUnresolvedDependency = ITargetedDependenciesSnapshotFactory.ImplementMock(checkForUnresolvedDependencies: true).Object;
var viewModelResolved = dependencyResolved.ToViewModel(mockSnapshot);
Assert.Equal(dependencyResolved.Caption, viewModelResolved.Caption);
Assert.Equal(dependencyResolved.Flags, viewModelResolved.Flags);
Assert.Equal(dependencyResolved.Id, viewModelResolved.FilePath);
Assert.Equal(dependencyResolved.SchemaName, viewModelResolved.SchemaName);
Assert.Equal(dependencyResolved.SchemaItemType, viewModelResolved.SchemaItemType);
Assert.Equal(dependencyResolved.Priority, viewModelResolved.Priority);
Assert.Equal(iconSet.Icon, viewModelResolved.Icon);
Assert.Equal(iconSet.ExpandedIcon, viewModelResolved.ExpandedIcon);
var viewModelUnresolved = dependencyUnresolved.ToViewModel(mockSnapshot);
Assert.Equal(dependencyUnresolved.Caption, viewModelUnresolved.Caption);
Assert.Equal(dependencyUnresolved.Flags, viewModelUnresolved.Flags);
Assert.Equal(dependencyUnresolved.Id, viewModelUnresolved.FilePath);
Assert.Equal(dependencyUnresolved.SchemaName, viewModelUnresolved.SchemaName);
Assert.Equal(dependencyUnresolved.SchemaItemType, viewModelUnresolved.SchemaItemType);
Assert.Equal(dependencyUnresolved.Priority, viewModelUnresolved.Priority);
Assert.Equal(iconSet.UnresolvedIcon, viewModelUnresolved.Icon);
Assert.Equal(iconSet.UnresolvedExpandedIcon, viewModelUnresolved.ExpandedIcon);
var viewModelUnresolvedDependency = dependencyResolved.ToViewModel(mockSnapshotUnresolvedDependency);
Assert.Equal(dependencyUnresolved.Caption, viewModelUnresolvedDependency.Caption);
Assert.Equal(dependencyUnresolved.Flags, viewModelUnresolvedDependency.Flags);
Assert.Equal(dependencyUnresolved.Id, viewModelUnresolvedDependency.FilePath);
Assert.Equal(dependencyUnresolved.SchemaName, viewModelUnresolvedDependency.SchemaName);
Assert.Equal(dependencyUnresolved.SchemaItemType, viewModelUnresolvedDependency.SchemaItemType);
Assert.Equal(dependencyUnresolved.Priority, viewModelUnresolvedDependency.Priority);
Assert.Equal(iconSet.UnresolvedIcon, viewModelUnresolvedDependency.Icon);
Assert.Equal(iconSet.UnresolvedExpandedIcon, viewModelUnresolvedDependency.ExpandedIcon);
}
public void ToViewModel()
{
var iconSet = new DependencyIconSet(
KnownMonikers.Uninstall,
KnownMonikers.AbsolutePosition,
KnownMonikers.AboutBox,
KnownMonikers.Abbreviation);
var dependencyResolved = new TestDependency
{
ProviderType = "Yyy",
Id = "tfm1\\yyy\\dependencyExisting",
Name = "dependencyExisting",
Caption = "DependencyExisting",
SchemaName = "MySchema",
SchemaItemType = "MySchemaItemType",
Priority = 1,
Resolved = true,
IconSet = iconSet
};
var dependencyUnresolved = new TestDependency
{
ProviderType = "Yyy",
Id = "tfm1\\yyy\\dependencyExisting",
Name = "dependencyExisting",
Caption = "DependencyExisting",
SchemaName = "MySchema",
SchemaItemType = "MySchemaItemType",
Priority = 1,
Resolved = false,
IconSet = iconSet
};
var mockSnapshot = ITargetedDependenciesSnapshotFactory.ImplementMock(checkForUnresolvedDependencies: false).Object;
var mockSnapshotUnresolvedDependency = ITargetedDependenciesSnapshotFactory.ImplementMock(checkForUnresolvedDependencies: true).Object;
var viewModelResolved = dependencyResolved.ToViewModel(mockSnapshot);
Assert.Equal(dependencyResolved.Caption, viewModelResolved.Caption);
Assert.Equal(dependencyResolved.Flags, viewModelResolved.Flags);
Assert.Equal(dependencyResolved.Id, viewModelResolved.FilePath);
Assert.Equal(dependencyResolved.SchemaName, viewModelResolved.SchemaName);
Assert.Equal(dependencyResolved.SchemaItemType, viewModelResolved.SchemaItemType);
Assert.Equal(dependencyResolved.Priority, viewModelResolved.Priority);
Assert.Equal(iconSet.Icon, viewModelResolved.Icon);
Assert.Equal(iconSet.ExpandedIcon, viewModelResolved.ExpandedIcon);
var viewModelUnresolved = dependencyUnresolved.ToViewModel(mockSnapshot);
Assert.Equal(dependencyUnresolved.Caption, viewModelUnresolved.Caption);
Assert.Equal(dependencyUnresolved.Flags, viewModelUnresolved.Flags);
Assert.Equal(dependencyUnresolved.Id, viewModelUnresolved.FilePath);
Assert.Equal(dependencyUnresolved.SchemaName, viewModelUnresolved.SchemaName);
Assert.Equal(dependencyUnresolved.SchemaItemType, viewModelUnresolved.SchemaItemType);
Assert.Equal(dependencyUnresolved.Priority, viewModelUnresolved.Priority);
Assert.Equal(iconSet.UnresolvedIcon, viewModelUnresolved.Icon);
Assert.Equal(iconSet.UnresolvedExpandedIcon, viewModelUnresolved.ExpandedIcon);
var viewModelUnresolvedDependency = dependencyResolved.ToViewModel(mockSnapshotUnresolvedDependency);
Assert.Equal(dependencyUnresolved.Caption, viewModelUnresolvedDependency.Caption);
Assert.Equal(dependencyUnresolved.Flags, viewModelUnresolvedDependency.Flags);
Assert.Equal(dependencyUnresolved.Id, viewModelUnresolvedDependency.FilePath);
Assert.Equal(dependencyUnresolved.SchemaName, viewModelUnresolvedDependency.SchemaName);
Assert.Equal(dependencyUnresolved.SchemaItemType, viewModelUnresolvedDependency.SchemaItemType);
Assert.Equal(dependencyUnresolved.Priority, viewModelUnresolvedDependency.Priority);
Assert.Equal(iconSet.UnresolvedIcon, viewModelUnresolvedDependency.Icon);
Assert.Equal(iconSet.UnresolvedExpandedIcon, viewModelUnresolvedDependency.ExpandedIcon);
}
public static Mock <IDependency> Implement(string providerType = null,
string id = null,
string originalItemSpec = null,
string path = null,
string fullPath = null,
string name = null,
string caption = null,
string alias = null,
IEnumerable <string> dependencyIDs = null,
bool?resolved = null,
bool?topLevel = null,
bool?isImplicit = null,
ProjectTreeFlags?flags = null,
string setPropertiesCaption = null,
bool?setPropertiesResolved = null,
ProjectTreeFlags?setPropertiesFlags = null,
bool?setPropertiesImplicit = null,
IDependency setPropertiesReturn = null,
bool?equals = null,
ImmutableArray <string> setPropertiesDependencyIDs = default,
string setPropertiesSchemaName = null,
ITargetFramework targetFramework = null,
DependencyIconSet iconSet = null,
DependencyIconSet setPropertiesIconSet = null,
MockBehavior mockBehavior = MockBehavior.Strict)
{
var mock = new Mock <IDependency>(mockBehavior);
if (providerType != null)
{
mock.Setup(x => x.ProviderType).Returns(providerType);
}
if (id != null)
{
mock.Setup(x => x.Id).Returns(id);
}
if (originalItemSpec != null)
{
mock.Setup(x => x.OriginalItemSpec).Returns(originalItemSpec);
}
if (fullPath != null)
{
mock.Setup(x => x.FullPath).Returns(fullPath);
}
if (path != null)
{
mock.Setup(x => x.Path).Returns(path);
}
if (name != null)
{
mock.Setup(x => x.Name).Returns(name);
}
if (caption != null)
{
mock.Setup(x => x.Caption).Returns(caption);
}
if (alias != null)
{
mock.Setup(x => x.Alias).Returns(alias);
}
if (dependencyIDs != null)
{
mock.Setup(x => x.DependencyIDs).Returns(ImmutableArray.CreateRange(dependencyIDs));
}
if (resolved.HasValue)
{
mock.Setup(x => x.Resolved).Returns(resolved.Value);
}
if (topLevel.HasValue)
{
mock.Setup(x => x.TopLevel).Returns(topLevel.Value);
}
if (isImplicit.HasValue)
{
mock.Setup(x => x.Implicit).Returns(isImplicit.Value);
}
if (flags.HasValue)
{
mock.Setup(x => x.Flags).Returns(flags.Value);
}
if (targetFramework != null)
{
mock.Setup(x => x.TargetFramework).Returns(targetFramework);
}
if (iconSet != null)
{
mock.Setup(x => x.IconSet).Returns(iconSet);
}
if (setPropertiesCaption != null ||
!setPropertiesDependencyIDs.IsDefault ||
setPropertiesResolved != null ||
setPropertiesFlags != null ||
setPropertiesImplicit != null ||
setPropertiesIconSet != null)
{
mock.Setup(x => x.SetProperties(
setPropertiesCaption,
setPropertiesResolved,
setPropertiesFlags,
setPropertiesSchemaName,
setPropertiesDependencyIDs,
setPropertiesIconSet,
setPropertiesImplicit))
.Returns(setPropertiesReturn ?? mock.Object);
}
if (equals == true)
{
mock.Setup(x => x.Equals(It.IsAny <IDependency>())).Returns(true);
}
return(mock);
}
public void ToViewModel()
{
var iconSet = new DependencyIconSet(
KnownMonikers.Uninstall,
KnownMonikers.AbsolutePosition,
KnownMonikers.AboutBox,
KnownMonikers.Abbreviation);
// This is a resolved dependency
var dependencyResolved = new TestDependency
{
ProviderType = "Yyy",
Id = "tfm1\\yyy\\dependencyResolved",
Name = "dependencyResolved",
Caption = "DependencyResolved",
SchemaName = "MySchema",
SchemaItemType = "MySchemaItemType",
Priority = 1,
Resolved = true,
TopLevel = true,
IconSet = iconSet
};
// This is an unresolved dependency
var dependencyUnresolved = new TestDependency
{
ProviderType = "Yyy",
Id = "tfm1\\yyy\\dependencyUnresolved",
Name = "dependencyUnresolved",
Caption = "DependencyUnresolved",
SchemaName = "MySchema",
SchemaItemType = "MySchemaItemType",
Priority = 1,
Resolved = false,
TopLevel = true,
IconSet = iconSet
};
// This is a resolved dependency with an unresolved child dependency
var dependencyUnresolvedChild = new TestDependency
{
ProviderType = "Yyy",
Id = "tfm1\\yyy\\dependencyUnresolvedChild",
Name = "dependencyUnresolvedChild",
Caption = "DependencyUnresolvedChild",
SchemaName = "MySchema",
SchemaItemType = "MySchemaItemType",
Priority = 1,
Resolved = true,
TopLevel = true,
IconSet = iconSet,
DependencyIDs = ImmutableArray.Create(dependencyUnresolved.Id)
};
var snapshotResolved = TargetedDependenciesSnapshotFactory.ImplementFromDependencies(new[] { dependencyResolved });
var snapshotUnresolved = TargetedDependenciesSnapshotFactory.ImplementFromDependencies(new[] { dependencyUnresolved });
var snapshotUnresolvedChild = TargetedDependenciesSnapshotFactory.ImplementFromDependencies(new[] { dependencyUnresolved, dependencyUnresolvedChild });
Assert.False(snapshotResolved.ShouldAppearUnresolved(dependencyResolved));
Assert.True(snapshotUnresolved.ShouldAppearUnresolved(dependencyUnresolved));
Assert.True(snapshotUnresolvedChild.ShouldAppearUnresolved(dependencyUnresolvedChild));
var viewModelResolved = dependencyResolved.ToViewModel(snapshotResolved);
Assert.Equal(dependencyResolved.Caption, viewModelResolved.Caption);
Assert.Equal(dependencyResolved.Flags, viewModelResolved.Flags);
Assert.Equal(dependencyResolved.Id, viewModelResolved.FilePath);
Assert.Equal(dependencyResolved.SchemaName, viewModelResolved.SchemaName);
Assert.Equal(dependencyResolved.SchemaItemType, viewModelResolved.SchemaItemType);
Assert.Equal(dependencyResolved.Priority, viewModelResolved.Priority);
Assert.Equal(iconSet.Icon, viewModelResolved.Icon);
Assert.Equal(iconSet.ExpandedIcon, viewModelResolved.ExpandedIcon);
var viewModelUnresolved = dependencyUnresolved.ToViewModel(snapshotResolved);
Assert.Equal(dependencyUnresolved.Caption, viewModelUnresolved.Caption);
Assert.Equal(dependencyUnresolved.Flags, viewModelUnresolved.Flags);
Assert.Equal(dependencyUnresolved.Id, viewModelUnresolved.FilePath);
Assert.Equal(dependencyUnresolved.SchemaName, viewModelUnresolved.SchemaName);
Assert.Equal(dependencyUnresolved.SchemaItemType, viewModelUnresolved.SchemaItemType);
Assert.Equal(dependencyUnresolved.Priority, viewModelUnresolved.Priority);
Assert.Equal(iconSet.UnresolvedIcon, viewModelUnresolved.Icon);
Assert.Equal(iconSet.UnresolvedExpandedIcon, viewModelUnresolved.ExpandedIcon);
var viewModelUnresolvedChild = dependencyUnresolvedChild.ToViewModel(snapshotUnresolvedChild);
Assert.Equal(dependencyUnresolvedChild.Caption, viewModelUnresolvedChild.Caption);
Assert.Equal(dependencyUnresolvedChild.Flags, viewModelUnresolvedChild.Flags);
Assert.Equal(dependencyUnresolvedChild.Id, viewModelUnresolvedChild.FilePath);
Assert.Equal(dependencyUnresolvedChild.SchemaName, viewModelUnresolvedChild.SchemaName);
Assert.Equal(dependencyUnresolvedChild.SchemaItemType, viewModelUnresolvedChild.SchemaItemType);
Assert.Equal(dependencyUnresolvedChild.Priority, viewModelUnresolvedChild.Priority);
Assert.Equal(iconSet.UnresolvedIcon, viewModelUnresolvedChild.Icon);
Assert.Equal(iconSet.UnresolvedExpandedIcon, viewModelUnresolvedChild.ExpandedIcon);
}
