public void SubdirectoryMustBeNestedWithinOriginalDirectory()
{
var sodDir1 = @"\\dummyPath\SharedOpaqueDir1";
var root = @"\\dummyPath";
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath sodPath1 = env.Paths.CreateAbsolutePath(sodDir1);
var pip1 = CreatePipBuilderWithTag(env, "test");
pip1.AddOutputDirectory(sodPath1, SealDirectoryKind.SharedOpaque);
var outputs1 = env.PipConstructionHelper.AddProcess(pip1);
outputs1.TryGetOutputDirectory(sodPath1, out var sharedOpaqueDirectory1);
var result = env.PipConstructionHelper.TryComposeSharedOpaqueDirectory(
env.Paths.CreateAbsolutePath(root),
new[] { sharedOpaqueDirectory1.Root },
actionKind: SealDirectoryCompositionActionKind.NarrowDirectoryCone,
contentFilter: null,
description: null,
tags: new string[] { },
out var composedSharedOpaque);
XAssert.IsFalse(result);
AssertErrorEventLogged(LogEventId.ScheduleFailAddPipInvalidComposedSealDirectoryDoesNotContainRoot);
IgnoreWarnings();
}
}
public void Given_exisiting_github_repo()
{
var env = new TestEnv();
env.GitHubClient.FileNames["https://github.com/foo/bar/"] = new List<string>
{
"File1.md",
"File2.md"
}.AsReadOnly();
env.GitHubClient.Users["https://api.github.com/users/faa"] = new UserInfo
{
Name = "Faa"
};
env.GitHubClient.Repositories["https://api.github.com/repos/foo/bar"] = new RepositoryInfo
{
Name = "Bar",
HtmlUrl = "https://github.com/foo/bar/",
Owner = new UserRefInfo
{
Url = "https://api.github.com/users/faa"
}
};
var manager = env.CreateSubmissionGitHubGrabber();
var feedback = new List<string>();
_submission = manager.RetrieveGitHubModule("https://github.com/foo/bar/", feedback);
}
public void OpaqueAndSharedOpaqueShouldNotOverlap(string pod, string od)
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath sodPath = env.Paths.CreateAbsolutePath(pod);
AbsolutePath odPath = env.Paths.CreateAbsolutePath(od);
var pip1 = CreatePipBuilderWithTag(env, "test");
pip1.AddOutputDirectory(odPath);
pip1.AddOutputDirectory(sodPath, SealDirectoryKind.SharedOpaque);
if (sodPath.IsWithin(env.PathTable, odPath))
{
// If the shared opaque is in the cone of an opaque, we will discover that when adding the pip
var success = env.PipConstructionHelper.TryAddProcess(pip1);
Assert.False(success, "Finish should fail, since overlapping opaque and shared opaque directories is not allowed.");
}
else
{
// Otherwise, when building the graph
env.PipConstructionHelper.AddProcess(pip1);
AssertFailedGraphBuilding(env);
}
}
}
public void Connect(TestEnv env)
{
SetEnv(env);
var factory = new DefaultWampChannelFactory();
var channel =
factory.CreateJsonChannel(_serverAddress, "mtcrossbar");
while (!channel.RealmProxy.Monitor.IsConnected)
{
try
{
Console.WriteLine($"Trying to connect to server {_serverAddress}...");
channel.Open().Wait();
}
catch
{
Console.WriteLine("Retrying in 5 sec...");
Thread.Sleep(5000);
}
}
Console.WriteLine($"Connected to server {_serverAddress}");
_realmProxy = channel.RealmProxy;
_service = _realmProxy.Services.GetCalleeProxy <IRpcMtFrontend>();
}
public void PartialSealedDirectoriesAreAllowedUnderSharedOpaqueDirectories(string sharedOpaqueRoot, string partialSealDirectoryRoot)
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
// Pip2 writes a dummy output under partialSealDirectoryRoot
var partialSealDirectoryPath = env.Paths.CreateAbsolutePath(partialSealDirectoryRoot);
var pip2 = CreatePipBuilderWithTag(env, "test");
pip2.AddOutputFile(partialSealDirectoryPath.Combine(env.PathTable, "dummy.txt"));
var outputs2 = env.PipConstructionHelper.AddProcess(pip2);
var partialSeal = env.PipConstructionHelper.SealDirectoryPartial(
partialSealDirectoryPath,
new [] { outputs2.GetOutputFiles().First() });
// Pip1 declares a shared opaque and a dependency on the partial seal (which is nested to the shared opaque)
var sodPath = env.Paths.CreateAbsolutePath(sharedOpaqueRoot);
var pip1 = CreatePipBuilderWithTag(env, "test");
pip1.AddOutputDirectory(sodPath, SealDirectoryKind.SharedOpaque);
pip1.AddInputDirectory(partialSeal);
env.PipConstructionHelper.AddProcess(pip1);
AssertSuccessGraphBuilding(env);
}
}
public async Task TestGraphQLClient_StrongTypes()
{
TestEnv.LogTestMethodStart();
ServerResponse resp;
string query;
var vars = new TDict()
{
{ "id", 3 }
};
// Post requests
TestEnv.LogTestDescr("Basic test for strongly-typed return value.");
query = @"
query ($id: Int) {
thing: getThing(id: $id) {
id, name, kind, theFlags, randoms(count: 5), __typename
}
}";
resp = await TestEnv.Client.PostAsync(query, vars);
resp.EnsureNoErrors();
var thing = resp.GetTopField <Thing_>("thing");
Assert.IsNotNull(thing);
Assert.AreEqual("Name3", thing.Name, "thing name mismatch");
Assert.AreEqual(ThingKind.KindThree, thing.Kind, "Kind mismatch");
Assert.AreEqual(TheFlags.FlagOne | TheFlags.FlagTwo, thing.TheFlags, "Flags mismatch");
Assert.IsNotNull(thing.Randoms, "Expected randoms array");
Assert.AreEqual(5, thing.Randoms.Length, "expected 5 randoms");
// Check unmapped introspection field - to be implemented
// string typeName = resp.GetUnmappedFieldValue<string>(thing, "__typename");
// Assert.AreEqual("Thing", typeName, "type name does not match");
}
/// <summary>
/// Returns the final contents of a directory that was sealed.
/// </summary>
private static FileArtifact[] GetSealedDirectoryContents(TestEnv env, DirectoryArtifact directory)
{
Contract.Requires(env != null);
Contract.Requires(directory.IsValid);
return(((PipGraph.Builder)env.PipGraph).ListSealedDirectoryContents(directory).ToArray());
}
private static void ScheduleConsumeSourceFile(TestEnv env, AbsolutePath directory, string relativePath)
{
FileArtifact source = FileArtifact.CreateSourceFile(env.Paths.CreateAbsolutePath(directory, env.Paths.CreateRelativePath(relativePath)));
AbsolutePath output = env.Paths.CreateAbsolutePath(env.ObjectRoot, Guid.NewGuid().ToString());
env.PipConstructionHelper.TryCopyFile(source, output, CopyFile.Options.None, null, "Pretend a source file is used", out _);
}
public void TestFailedWritesToPartiallySealedDirectoryInsideFullySealedDirectory()
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath outerPath = env.Paths.CreateAbsolutePath(env.ObjectRoot, "outer");
AbsolutePath innerPath = env.Paths.CreateAbsolutePath(outerPath, "inner");
FileArtifact partiallySealedFile = ScheduleWriteOutputFileUnderDirectory(env, innerPath, "existing");
ScheduleSealPartialDirectory(env, innerPath, partiallySealedFile);
FileArtifact nextFile = ScheduleWriteOutputFileUnderDirectory(env, innerPath, "newer");
// Can't write partiallySealedFile
AssertCannotScheduleRewrite(env, nextFile, partiallySealedFile);
AssertErrorEventLogged(LogEventId.InvalidOutputSinceFileHasBeenPartiallySealed);
// But can do the reverse (haven't sealed the sibling)
FileArtifact rewrittenNextFile = ScheduleRewrite(env, partiallySealedFile, nextFile);
AssertCannotScheduleSealDirectory(env, outerPath, partiallySealedFile, nextFile);
AssertErrorEventLogged(LogEventId.InvalidInputSinceInputIsRewritten);
ScheduleSealDirectory(env, outerPath, partiallySealedFile, rewrittenNextFile);
// Now both are sealed, and no new files can be added.
AssertCannotScheduleRewrite(env, partiallySealedFile, rewrittenNextFile);
AssertErrorEventLogged(LogEventId.InvalidOutputSinceDirectoryHasBeenSealed);
// What would be a double-write normally is now a seal-related error.
AssertCannotScheduleWriteOutputFileUnderDirectory(env, innerPath, "newer");
AssertErrorEventLogged(LogEventId.InvalidOutputSinceDirectoryHasBeenSealed);
AssertCannotScheduleWriteOutputFileUnderDirectory(env, innerPath, "newest");
AssertErrorEventLogged(LogEventId.InvalidOutputSinceDirectoryHasBeenSealed);
}
}
private static bool TryScheduleSealDirectory(TestEnv env, AbsolutePath path, SealDirectoryKind partial, FileArtifact[] contents)
{
var pip = new SealDirectory(
path,
SortedReadOnlyArray <FileArtifact, OrdinalFileArtifactComparer> .CloneAndSort(contents, OrdinalFileArtifactComparer.Instance),
kind: partial,
provenance: env.CreatePipProvenance(StringId.Invalid),
tags: ReadOnlyArray <StringId> .Empty,
patterns: ReadOnlyArray <StringId> .Empty);
DirectoryArtifact artifact = env.PipGraph.AddSealDirectory(pip, PipId.Invalid);
bool succeeded = artifact.IsValid;
if (succeeded)
{
FileArtifact[] actualContents = GetSealedDirectoryContents(env, artifact);
XAssert.AreEqual(contents.Length, actualContents.Length, "Wrong number of contents sealed");
for (int i = 0; i < contents.Length; i++)
{
XAssert.IsTrue(contents[i] == actualContents[i], "Content artifact at position {0} mismatched", i);
}
}
return(succeeded);
}
public void TrustedAccessesAreBlockedIfPipDependsOnSourceSeal()
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
var sourceSealedDirectory = new SealDirectory(
env.SourceRoot,
CollectionUtilities.EmptySortedReadOnlyArray <FileArtifact, OrdinalFileArtifactComparer>(OrdinalFileArtifactComparer.Instance),
outputDirectoryContents: CollectionUtilities.EmptySortedReadOnlyArray <DirectoryArtifact, OrdinalDirectoryArtifactComparer>(OrdinalDirectoryArtifactComparer.Instance),
kind: SealDirectoryKind.SourceAllDirectories,
provenance: env.CreatePipProvenance(StringId.Invalid),
tags: ReadOnlyArray <StringId> .Empty,
patterns: ReadOnlyArray <StringId> .Empty);
DirectoryArtifact artifact = env.PipGraph.AddSealDirectory(sourceSealedDirectory, PipId.Invalid);
Assert.True(artifact.IsValid);
var pip = CreatePipBuilderWithTag(env, "test");
pip.AddInputDirectory(artifact);
pip.Options |= Process.Options.TrustStaticallyDeclaredAccesses;
var success = env.PipConstructionHelper.TryAddProcess(pip);
Assert.False(success, "Finish should fail, a process depending on a source sealed directory is not allowed to trust declared accesses");
}
}
/// <summary>
/// Builds the <see cref="TestEnv.PipGraph"/> and asserts failure
/// </summary>
internal static void AssertFailedGraphBuilding(TestEnv env)
{
var builder = env.PipGraph as PipGraph.Builder;
XAssert.IsNotNull(builder);
XAssert.IsNull(builder.Build());
}
public void AllContainedDirectoriesMustBeSharedOpaques()
{
var sodDir1 = @"\\dummyPath\SharedOpaqueDir1";
var sourceSealDir2 = @"\\dummyPath\SourceSeal";
var root = @"\\dummyPath";
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath sodPath1 = env.Paths.CreateAbsolutePath(sodDir1);
var pip1 = CreatePipBuilderWithTag(env, "test");
pip1.AddOutputDirectory(sodPath1, SealDirectoryKind.SharedOpaque);
var outputs1 = env.PipConstructionHelper.AddProcess(pip1);
outputs1.TryGetOutputDirectory(sodPath1, out var sharedOpaqueDirectory1);
var sourceSealDirectory = env.PipConstructionHelper.SealDirectoryPartial(
env.Paths.CreateAbsolutePath(sourceSealDir2),
new FileArtifact[0]);
var result = env.PipConstructionHelper.TryComposeSharedOpaqueDirectory(
env.Paths.CreateAbsolutePath(root),
new[] { sharedOpaqueDirectory1.Root, sourceSealDirectory },
description: null,
tags: new string[] { },
out var composedSharedOpaque);
XAssert.IsFalse(result);
AssertErrorEventLogged(LogEventId.ScheduleFailAddPipInvalidComposedSealDirectoryIsNotSharedOpaque);
}
}
public void TestNoExplicitInputsAreAllowedInOpaqueDirectory()
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath odPath = env.Paths.CreateAbsolutePath(@"\\dummyPath\OpaqueDir1");
var pip1 = CreatePipBuilderWithTag(env, "test");
pip1.AddOutputDirectory(odPath, SealDirectoryKind.Opaque);
var outputs1 = env.PipConstructionHelper.AddProcess(pip1);
outputs1.TryGetOutputDirectory(odPath, out var pip1OutputOd);
var pip2 = CreatePipBuilderWithTag(env, "test");
// Pip2 is consuming OD produced by pip1.
pip2.AddInputDirectory(pip1OutputOd.Root);
AbsolutePath artifactInOdPath = env.Paths.CreateAbsolutePath(@"\\dummyPath\OpaqueDir1\in1.dll");
XAssert.IsTrue(artifactInOdPath.IsWithin(env.PathTable, odPath));
// and trying to add input, defined in OD. this is not allowed.
pip2.AddInputFile(artifactInOdPath);
// process has to produce something, adding a dummy output.
AbsolutePath dummyOut = env.Paths.CreateAbsolutePath(@"\\dummyPath\output.dll");
pip2.AddOutputFile(dummyOut);
var success = env.PipConstructionHelper.TryAddProcess(pip2);
Assert.False(success, "Finish should fail, since no explicit inputs are allowed in opaque directory path.");
}
}
private static void AssertCannotScheduleSealDirectory(TestEnv env, AbsolutePath path, params FileArtifact[] contents)
{
bool result = TryScheduleSealDirectory(env, path, SealDirectoryKind.Full, contents: contents,
outputDirectoryContents: CollectionUtilities.EmptyArray <DirectoryArtifact>(), out _);
XAssert.IsFalse(result, "Unexpectedly succedeeded at sealing the directory " + env.Paths.Expand(path));
}
public void OpaqueAndSharedOpaqueShouldNotOverlapOnDifferentPips(string pod, string od, bool failOnFinish)
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath sodPath = env.Paths.CreateAbsolutePath(pod);
AbsolutePath odPath = env.Paths.CreateAbsolutePath(od);
var pip1 = CreatePipBuilderWithTag(env, "test");
pip1.AddOutputDirectory(odPath);
env.PipConstructionHelper.AddProcess(pip1);
var pip2 = CreatePipBuilderWithTag(env, "test");
pip2.AddOutputDirectory(sodPath, SealDirectoryKind.SharedOpaque);
if (failOnFinish)
{
var success = env.PipConstructionHelper.TryAddProcess(pip2);
Assert.False(success, "Finish should fail, since overlapping opaque and shared opaque directories is not allowed.");
}
else
{
env.PipConstructionHelper.AddProcess(pip2);
AssertFailedGraphBuilding(env);
}
}
}
public void SetEnv(TestEnv env)
{
switch (env)
{
case TestEnv.Local:
_clientId = "";
_serverAddress = "";
break;
case TestEnv.Dev:
_clientId = "";
_serverAddress = "";
break;
case TestEnv.Test:
_clientId = "";
_serverAddress = "";
break;
default:
throw new ArgumentOutOfRangeException();
}
var session = _sessionService.ApiSessionGetByClientPost(new ClientSessionGetByClientRequest(_clientId)).Sessions.FirstOrDefault();
_token = session.SessionToken;
}
private ContentFingerprint CreateFingerprintForCompositeSharedOpaque(
string composedSharedOpaqueRoot, string[] sharedOpaqueMembers, SealDirectoryContentFilter?contentFilter)
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
var sharedOpaqueDirectoryArtifactMembers = new DirectoryArtifact[sharedOpaqueMembers.Length];
for (int i = 0; i < sharedOpaqueMembers.Length; i++)
{
sharedOpaqueDirectoryArtifactMembers[i] = CreateSharedOpaque(env, env.Paths.CreateAbsolutePath(sharedOpaqueMembers[i]));
}
var success = env.PipConstructionHelper.TryComposeSharedOpaqueDirectory(
env.Paths.CreateAbsolutePath(composedSharedOpaqueRoot),
sharedOpaqueDirectoryArtifactMembers,
actionKind: SealDirectoryCompositionActionKind.WidenDirectoryCone,
contentFilter: contentFilter,
description: null,
tags: new string[0],
out var sharedOpaqueDirectory);
XAssert.IsTrue(success);
var graph = AssertSuccessGraphBuilding(env);
var fingerprint = CreateFingerprintForSharedOpaque(sharedOpaqueDirectory, graph);
return(fingerprint);
}
}
public async Task TestGraphQLClient_Introspection()
{
TestEnv.LogTestMethodStart();
ServerResponse resp;
string query;
// Post requests
TestEnv.LogTestDescr("Querying type object for Thing type.");
query = @"
query {
thingType: __type(name: ""Thing"") {
name
fields {
name
type {
name
displayName # NGraphQL extension
}
}
}
}";
resp = await TestEnv.Client.PostAsync(query);
resp.EnsureNoErrors();
var type = resp.GetTopField <__Type>("thingType");
Assert.IsNotNull(type);
Assert.AreEqual("Thing", type.Name, "thing name mismatch");
Assert.IsTrue(type.Fields.Count > 5, "Expected fields");
}
private ContentFingerprint CreateFingerprintForPartialSealWithMember(string fileName)
{
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath root = env.Paths.CreateAbsolutePath(@"\\dummyPath\Root");
FileArtifact member = FileArtifact.CreateSourceFile(root.Combine(env.PathTable, fileName));
var staticDirectory = env.PipConstructionHelper.SealDirectoryPartial(
root,
new[] { member });
var pipBuilder = CreatePipBuilderWithTag(env, nameof(TestPartialSealDirectoryMembersAffectFingerprints));
var outputPath = env.Paths.CreateAbsolutePath(@"\\dummyPath\out");
pipBuilder.AddOutputFile(outputPath);
pipBuilder.AddInputDirectory(staticDirectory);
env.PipConstructionHelper.AddProcess(pipBuilder);
var graph = AssertSuccessGraphBuilding(env);
var producerId = graph.TryGetProducer(FileArtifact.CreateOutputFile(outputPath));
XAssert.IsTrue(producerId.IsValid);
XAssert.IsTrue(graph.TryGetPipFingerprint(producerId, out ContentFingerprint fingerprint));
return(fingerprint);
}
}
public void AllContainedDirectoriesMustBeUnderACommonRoot()
{
var sodDir1 = @"\\dummyPath\SharedOpaqueDir1";
var sodDir2 = @"\\outOfRoot\SharedOpaqueDir2";
var root = @"\\dummyPath";
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath sodPath1 = env.Paths.CreateAbsolutePath(sodDir1);
AbsolutePath sodPath2 = env.Paths.CreateAbsolutePath(sodDir2);
var pip1 = CreatePipBuilderWithTag(env, "test");
pip1.AddOutputDirectory(sodPath1, SealDirectoryKind.SharedOpaque);
var outputs1 = env.PipConstructionHelper.AddProcess(pip1);
outputs1.TryGetOutputDirectory(sodPath1, out var sharedOpaqueDirectory1);
var pip2 = CreatePipBuilderWithTag(env, "test");
pip2.AddOutputDirectory(sodPath2, SealDirectoryKind.SharedOpaque);
var outputs2 = env.PipConstructionHelper.AddProcess(pip2);
outputs2.TryGetOutputDirectory(sodPath2, out var sharedOpaqueDirectory2);
var result = env.PipConstructionHelper.TryComposeSharedOpaqueDirectory(
env.Paths.CreateAbsolutePath(root),
new[] { sharedOpaqueDirectory1.Root, sharedOpaqueDirectory2.Root },
description: null,
tags: new string[] { },
out var composedSharedOpaque);
XAssert.IsFalse(result);
AssertErrorEventLogged(EventId.ScheduleFailAddPipInvalidComposedSealDirectoryNotUnderRoot);
}
}
public void Interpreter_Typedef_Union()
{
// Arrange
string expOutput =
"Size: 4" + Environment.NewLine +
"Offset1: 0" + Environment.NewLine +
"Offset2: 0";
string src = @"
<typedef name='my_union' kind='union'>
<uint name='Foo'/>
<uint name='Bar'/>
</typedef>
<my_union name='Foobar'/>
<echo message='Size: $SizeOf(Foobar)'/>
<echo message='Offset1: $OffsetOf(Foobar.Foo)'/>
<echo message='Offset2: $OffsetOf(Foobar.Bar)'/>
";
string script = BuildXmlLayoutScript(src);
TestEnv test = new TestEnv(script);
// Act
test.Run();
// Assert
Assert.Equal(expOutput, test.Output);
}
public void Interpreter_Echo_StructureMembers()
{
// Arrange
ulong val = 0xDEADBEEF00000000;
byte[] data = BitConverter.GetBytes(val);
string expOutput = string.Format(
"Value1: {0}" + Environment.NewLine +
"Value2: {1}" + Environment.NewLine +
"Offset1: 0" + Environment.NewLine +
"Offset2: 4",
(val & 0xFFFFFFFF).ToString(), (val >> 32).ToString());
string src = @"
<struct name='MyStruct'>
<uint name='Zero'/>
<uint name='Beef'/>
</struct>
<echo message='Value1: ${MyStruct.Zero}'/>
<echo message='Value2: ${MyStruct.Beef}'/>
<echo message='Offset1: $OffsetOf(MyStruct.Zero)'/>
<echo message='Offset2: $OffsetOf(MyStruct.Beef)'/>
";
string script = BuildXmlLayoutScript(src);
TestEnv test = new TestEnv(script, data);
// Act
test.Run();
// Assert
Assert.Equal(expOutput, test.Output);
}
public void Interpreter_Echo_UnionMembers()
{
// Arrange
ulong val = 0xDEADBEEF;
byte[] data = BitConverter.GetBytes(val);
string expOutput = string.Format(
"Value1: {0}" + Environment.NewLine +
"Value2: {1}" + Environment.NewLine +
"Offset1: 0" + Environment.NewLine +
"Offset2: 0",
val.ToString(), val.ToString());
string src = @"
<union name='MyUnion'>
<uint name='Beef1'/>
<uint name='Beef2'/>
</union>
<echo message='Value1: ${MyUnion.Beef1}'/>
<echo message='Value2: ${MyUnion.Beef2}'/>
<echo message='Offset1: $OffsetOf(MyUnion.Beef1)'/>
<echo message='Offset2: $OffsetOf(MyUnion.Beef2)'/>
";
string script = BuildXmlLayoutScript(src);
TestEnv test = new TestEnv(script, data);
// Act
test.Run();
// Assert
Assert.Equal(expOutput, test.Output);
}
public void TestOpaqueDirectorySemistableHashUniqueness(AddDirectory addDirectory)
{
// Create a relationship where pip2 uses the output of pip1
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath path1 = env.Paths.CreateAbsolutePath(@"\\dummyPath\Dir1");
AbsolutePath path2 = env.Paths.CreateAbsolutePath(@"\\dummyPath\Dir2");
var pip1 = CreatePipBuilderWithTag(env, "test");
addDirectory(pip1, path1);
addDirectory(pip1, path2);
var outputs1 = env.PipConstructionHelper.AddProcess(pip1);
outputs1.TryGetOutputDirectory(path1, out var pip1OutputDir1);
outputs1.TryGetOutputDirectory(path2, out var pip1OutputDir2);
var pipGraph = AssertSuccessGraphBuilding(env);
var pip1SemistableHash = pipGraph.PipTable.GetPipSemiStableHash(pipGraph.GetProducer(pip1OutputDir1.Root));
var od1SemistableHash = pipGraph.PipTable.GetPipSemiStableHash(pipGraph.GetSealedDirectoryNode(pip1OutputDir1.Root).ToPipId());
var od2SemistableHash = pipGraph.PipTable.GetPipSemiStableHash(pipGraph.GetSealedDirectoryNode(pip1OutputDir2.Root).ToPipId());
Assert.NotEqual(pip1SemistableHash, od1SemistableHash);
Assert.NotEqual(pip1SemistableHash, od2SemistableHash);
Assert.NotEqual(od1SemistableHash, od2SemistableHash);
}
}
public virtual void SimpleDirectoryProduceConsume(AddDirectory addDirectory)
{
// Create a relationship where pip2 depends on a shared opaque directory of pip1
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler())
{
AbsolutePath path = env.Paths.CreateAbsolutePath(@"\\dummyPath\Dir1");
var pip1 = CreatePipBuilderWithTag(env, "test");
addDirectory(pip1, path);
var outputs1 = env.PipConstructionHelper.AddProcess(pip1);
outputs1.TryGetOutputDirectory(path, out var pip1OutputDirectory);
var pip2 = CreatePipBuilderWithTag(env, "test");
// Pip2 is consuming the directory produced by pip1.
pip2.AddInputDirectory(pip1OutputDirectory.Root);
// process has to produce something, adding a dummy output.
AbsolutePath dummyOut = env.Paths.CreateAbsolutePath(@"\\dummyPath\output.dll");
pip2.AddOutputFile(dummyOut);
env.PipConstructionHelper.AddProcess(pip2);
AssertSuccessGraphBuilding(env);
}
}
public void TestOutputDirectoriesCannotBeCreatedUnderANonWritableMount(AddDirectory addDirectory, string nonWritableMountRoot, string directory)
{
var pathTable = new PathTable();
var nonWritableMount = new Mount
{
Name = PathAtom.Create(pathTable.StringTable, "NonWritableRoot"),
Path = AbsolutePath.Create(pathTable, nonWritableMountRoot),
IsReadable = true,
IsWritable = false,
TrackSourceFileChanges = true,
Location = default(LocationData)
};
using (TestEnv env = TestEnv.CreateTestEnvWithPausedScheduler(mounts: new List <IMount> {
nonWritableMount
}, pathTable: pathTable))
{
var directoryPath = AbsolutePath.Create(pathTable, directory);
var pip1 = CreatePipBuilderWithTag(env, "test");
addDirectory(pip1, directoryPath);
var result = env.PipConstructionHelper.TryAddProcess(pip1);
Assert.False(result, "Should fail");
}
}
public async Task TestGraphQLClient()
{
TestEnv.LogTestMethodStart();
ServerResponse resp;
string thingName;
var query1 = "query ($id: Int) { getThing(id: $id) {name kind theFlags} }";
var queryM = "query { things {name} }";
var vars = new TDict()
{
{ "id", 3 }
};
// Post requests
TestEnv.LogTestDescr("Testing Post requests");
// single thing with query parameter
resp = await TestEnv.Client.PostAsync(query1, vars);
resp.EnsureNoErrors();
var thing = resp.data.getThing;
thingName = thing.name;
Assert.AreEqual("Name3", thingName);
var thingKind = ResponseHelper.ToEnum <ThingKind>(thing.kind);
Assert.AreEqual(ThingKind.KindThree, thingKind, "Invalid kind field value.");
var flags = ResponseHelper.ToEnum <TheFlags>(thing.theFlags);
Assert.AreEqual(TheFlags.FlagOne | TheFlags.FlagTwo, flags, "Invalid flags field value");
// list of things
resp = await TestEnv.Client.PostAsync(queryM, vars);
resp.EnsureNoErrors();
thingName = resp.data.things[1].name;
Assert.AreEqual("Name2", thingName);
TestEnv.LogTestDescr("Testing Get requests");
// single thing with query parameter
resp = await TestEnv.Client.GetAsync(query1, vars);
resp.EnsureNoErrors();
thingName = resp.data.getThing.name;
Assert.AreEqual("Name3", thingName);
// list of things
resp = await TestEnv.Client.GetAsync(queryM, vars);
resp.EnsureNoErrors();
thingName = resp.data.things[1].name;
Assert.AreEqual("Name2", thingName);
TestEnv.LogTestDescr("Testing queries with errors");
resp = await TestEnv.Client.PostAsync(query1 + " ABCD ", vars);
var errs = resp.Errors;
Assert.IsTrue(errs.Count > 0, "Expected syntax error");
}
private static DirectoryArtifact ScheduleSealPartialDirectory(TestEnv env, AbsolutePath path, params FileArtifact[] contents)
{
bool result = TryScheduleSealDirectory(env, path, SealDirectoryKind.Partial, contents: contents,
outputDirectoryContents: CollectionUtilities.EmptyArray <DirectoryArtifact>(), out var directoryArtifact);
XAssert.IsTrue(result, "Unexpectedly failed to seal a partial directory at " + env.Paths.Expand(path));
return(directoryArtifact);
}
private static DirectoryArtifact ScheduleSealDirectory(TestEnv env, AbsolutePath path, FileArtifact[] contents, DirectoryArtifact[] outputDirectoryContent)
{
bool result = TryScheduleSealDirectory(env, path, SealDirectoryKind.Full, contents: contents,
outputDirectoryContents: outputDirectoryContent, out var directoryArtifact);
XAssert.IsTrue(result, "Unexpectedly failed to seal the directory at " + env.Paths.Expand(path));
return(directoryArtifact);
}
private PipGraph AssertSuccessGraphBuilding(TestEnv env)
{
var builder = env.PipGraph as PipGraph.Builder;
XAssert.IsNotNull(builder);
var pipGraph = builder.Build();
XAssert.IsNotNull(pipGraph);
return(pipGraph);
}
void InitializeObjects()
{
captureDevice.Init( GraphicsDevice );
testEnv = new TestEnv( GraphicsDevice );
}
