public ProjectItem(ProjectItemIdentifier id)
{
if (id == null)
throw new ArgumentNullException(nameof(id));
Identifier = id;
}
public ProjectItem(string identifier, string kind)
{
if (string.IsNullOrEmpty(identifier))
throw new ArgumentNullException(nameof(identifier));
if (kind == null)
throw new ArgumentNullException(nameof(kind));
Identifier = new ProjectItemIdentifier(identifier, kind);
}
public BuildTaskResult(ProjectItemIdentifier identifier, IProjectItemContent content)
{
if (identifier == null)
throw new ArgumentNullException(nameof(identifier));
if (content == null)
throw new ArgumentNullException(nameof(content));
Identifier = identifier;
Content = content;
}
public async Task<HttpResponseMessage> Index(string id, string projectKind, string app)
{
var project = this.ResolveForApp<Project>(string.Empty);
var pId = new ProjectItemIdentifier(id, projectKind);
ProjectItem item;
if (!project.TryGetItemById(pId, out item))
return new HttpResponseMessage(HttpStatusCode.NotFound);
var message = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StreamContent(await item.OpenRead().ConfigureAwait(false)) };
message.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
return message;
}
public async Task TestBuilderSingleItemOnAddWithBuildInBackgroundOption()
{
var kind = "test";
var projectItem = new ProjectItem("p1", kind);
var project = new Project();
var target = new Mock<IBuildTask>();
const string targetName = "test";
target.SetupGet(t => t.Name).Returns(targetName);
target.SetupGet(t => t.DependsOn).Returns(BuildQuery.SingleFromKind(kind));
target.SetupGet(t => t.Options).Returns(BuildOptions.BuildInBackground);
var id = new ProjectItemIdentifier("gugus", "created");
const string contentString = "test";
var source = new BuildTaskResult(id, new ProjectItemContentFromAction(() => GenerateStreamFromString(contentString)));
SetupProceed(target, projectItem).Returns(new [] { source });
var underTest = new Builder(project);
underTest.AddTask(target.Object);
project.AddItem(new ProjectItem("p2"));
project.AddItem(projectItem);
var generatedItem = project.GetItemById(id);
Assert.NotNull(generatedItem);
Assert.Equal(id, generatedItem.Identifier);
var stream = await generatedItem.OpenRead();
//Second Stream
var stream2 = await generatedItem.OpenRead();
AssertStream(stream, contentString);
AssertStream(stream2, contentString);
var links = projectItem.GetLinkedItems();
Assert.NotNull(links);
var linkList = links.ToList();
Assert.Equal(1, linkList.Count);
Assert.Equal(generatedItem, linkList[0].ProjectItem);
Assert.Equal(targetName, linkList[0].Description.Name);
}
public static TerrificNetApplication RegisterForApplication(IUnityContainer childContainer, string hostPath, string basePath, string applicationName, string section)
{
try
{
var fileSystem = childContainer.Resolve<FileSystemProvider>().GetFileSystem(hostPath, basePath, out basePath);
childContainer.RegisterInstance(fileSystem);
var config = ConfigurationLoader.LoadTerrificConfiguration(basePath, fileSystem);
var application = new TerrificNetApplication(applicationName, section, config, childContainer);
var projectPath = PathInfo.Create("terrific.json");
if (fileSystem.FileExists(projectPath))
{
var project = Project.FromFile(new StreamReader(fileSystem.OpenRead(projectPath)).ReadToEnd(), fileSystem);
childContainer.RegisterInstance(project);
var builder = new Builder(project);
var pId = new ProjectItemIdentifier("app.js", "javascript_bundle");
builder.AddTask(new BundleTask("app.js", pId));
builder.AddTask(new CompileJavascriptTask(pId, "app.min.js"));
builder.AddTask(new BuildViewTask(project));
builder.AddTask(new BuildThtmlTask(project));
}
childContainer.RegisterInstance(application);
RegisterForConfiguration(childContainer, config);
return application;
}
catch (ConfigurationException ex)
{
throw new InvalidApplicationException(
$"Could not load the configuration for application '{applicationName}'.", ex);
}
}
public CompileJavascriptTask(ProjectItemIdentifier inputItem, string output)
{
_output = output;
this.DependsOn = BuildQuery.Exact(inputItem);
}
public static BuildQuery Exact(ProjectItemIdentifier inputItem)
{
return new BuildQueryPredicate(p => p.Identifier.Equals(inputItem), true);
}
public InMemoryProjectItem(ProjectItemIdentifier identifier, byte[] content) : base(identifier)
{
_content = content;
}
public void TestManyToOne()
{
var kind = "test";
var project = new Project();
AddAndCreateItem(kind, project, "p1");
AddAndCreateItem(kind, project, "p2");
AddAndCreateItem(kind, project, "p3");
var task = new Mock<IBuildTask>();
task.SetupGet(p => p.DependsOn).Returns(BuildQuery.AllFromKind(kind));
var id = new ProjectItemIdentifier("created", "created");
task.Setup(p => p.Proceed(It.Is<IEnumerable<ProjectItem>>(list => list.SequenceEqual(project.GetItems()))))
.Returns(new [] { new BuildTaskResult(id, NullProjectItemContent.Instance) });
var builder = new Builder(project);
builder.AddTask(task.Object);
task.Verify(p => p.Proceed(It.IsAny<IEnumerable<ProjectItem>>()), Times.Once());
var result = project.GetItemById(id);
Assert.NotNull(result);
var linkedItems = result.GetLinkedItems();
Assert.NotNull(linkedItems);
var linkedItemsList = linkedItems.ToList();
Assert.Equal(3, linkedItemsList.Count);
}
public void TestOneToMany()
{
var kind = "test";
var project = new Project();
var p1 = AddAndCreateItem(kind, project, "p1");
AddAndCreateItem(kind, project, "p2");
AddAndCreateItem(kind, project, "p3");
var task = new Mock<IBuildTask>();
task.SetupGet(p => p.DependsOn).Returns(BuildQuery.SingleFromKind(kind));
var id1 = new ProjectItemIdentifier("created", "created");
var id2 = new ProjectItemIdentifier("created2", "created");
var s1 = new BuildTaskResult(id1, NullProjectItemContent.Instance);
var s2 = new BuildTaskResult(id2, NullProjectItemContent.Instance);
SetupProceed(task, p1).Returns(new [] { s1, s2 });
var builder = new Builder(project);
builder.AddTask(task.Object);
var result = project.GetItemById(id1);
Assert.NotNull(result);
var linkedItems = result.GetLinkedItems();
Assert.NotNull(linkedItems);
var linkedItemsList = linkedItems.ToList();
Assert.Equal(1, linkedItemsList.Count);
var otherItem = linkedItemsList[0].ProjectItem.GetLinkedItems();
Assert.NotNull(otherItem);
var otherItemList = otherItem.ToList();
Assert.Equal(2, otherItemList.Count);
}
public bool TryGetItemById(ProjectItemIdentifier identifier, out ProjectItem item)
{
return _items.TryGetValue(identifier, out item);
}
public void Test_Many_RemoveItemTouchesGeneratedItems()
{
var kind = "test";
var project = new Project();
var p1 = AddAndCreateItem(kind, project, "p1");
var p2 = AddAndCreateItem(kind, project, "p2");
var task = new Mock<IBuildTask>();
task.SetupGet(p => p.DependsOn).Returns(BuildQuery.AllFromKind(kind));
var id1 = new ProjectItemIdentifier("created", "created");
var s1 = new BuildTaskResult(id1, NullProjectItemContent.Instance);
task.Setup(p => p.Proceed(It.Is<IEnumerable<ProjectItem>>(list => list.SequenceEqual(new [] {p1, p2}))))
.Returns(new [] { s1 });
task.Setup(p => p.Proceed(It.Is<IEnumerable<ProjectItem>>(list => list.SequenceEqual(new [] { p2 }))))
.Returns(new[] { s1 });
var builder = new Builder(project);
builder.AddTask(task.Object);
project.RemoveItem(p1);
task.VerifyAll();
}
private bool Contains(ProjectItemIdentifier identifier)
{
return _items.ContainsKey(identifier);
}
public void TestBuilderSingleItemOnAddWithBuildOnRequestOption()
{
var kind = "test";
var projectItem = new ProjectItem("p1", kind);
var project = new Project();
var id = new ProjectItemIdentifier("gugus", "created");
var content = new Mock<IProjectItemContent>();
content.Setup(s => s.ReadAsync()).Returns(GenerateStreamFromString("test"));
var target = new Mock<IBuildTask>();
const string targetName = "test";
target.SetupGet(t => t.Name).Returns(targetName);
target.SetupGet(t => t.DependsOn).Returns(BuildQuery.SingleFromKind(kind));
target.SetupGet(t => t.Options).Returns(BuildOptions.BuildOnRequest);
SetupProceed(target, projectItem).Returns(new [] { new BuildTaskResult(id, content.Object)});
var underTest = new Builder(project);
underTest.AddTask(target.Object);
project.AddItem(new ProjectItem("p2"));
project.AddItem(projectItem);
content.Verify(t => t.ReadAsync(), Times.Never());
var generatedItem = project.GetItemById(id);
Assert.NotNull(generatedItem);
Assert.Equal(id, generatedItem.Identifier);
generatedItem.OpenRead();
content.Verify(t => t.ReadAsync(), Times.Once());
generatedItem.OpenRead();
content.Verify(t => t.ReadAsync(), Times.Once());
}
public BundleTask(string projectItemKind, ProjectItemIdentifier outputItemId)
{
this.DependsOn = BuildQuery.AllFromKind(projectItemKind);
_outputItemId = outputItemId;
}
private static IBuildTask CreateBuildTarget(string inKind, string outKind)
{
var id = new ProjectItemIdentifier("gugus", outKind);
var target1 = new Mock<IBuildTask>();
const string targetName = "test";
target1.SetupGet(t => t.Name).Returns(targetName);
target1.SetupGet(t => t.DependsOn).Returns(BuildQuery.SingleFromKind(inKind));
target1.SetupGet(t => t.Options).Returns(BuildOptions.BuildOnRequest);
target1.Setup(t => t.Proceed(It.IsAny<IEnumerable<ProjectItem>>()))
.Returns(new [] { new BuildTaskResult(id, NullProjectItemContent.Instance) });
var buildTarget = target1.Object;
return buildTarget;
}
//[Fact]
public void Test_BuilderAddedLinks_CalledOnChange()
{
var kind = "test";
var project = new Project();
var observerMock = new Mock<IProjectObserver>();
project.AddObserver(observerMock.Object);
var p1 = AddAndCreateItem(kind, project, "p1");
var p2 = AddAndCreateItem("related", project, "p2");
var id1 = new ProjectItemIdentifier("created", "created");
var task = new Mock<IBuildTask>();
task.SetupGet(p => p.DependsOn).Returns(BuildQuery.SingleFromKind(kind).Or(BuildQuery.Exact(p2.Identifier)));
var s1 = new BuildTaskResult(id1, NullProjectItemContent.Instance);
SetupProceed(task, p1).Returns(new[] { s1 });
var builder = new Builder(project);
builder.AddTask(task.Object);
project.Touch(p2);
observerMock.Verify(s => s.NotifyItemChanged(project, It.Is<ProjectItem>(i => i.Identifier.Kind == kind)), Times.Once());
}
public ProjectItem GetItemById(ProjectItemIdentifier identifier)
{
return _items[identifier];
}
public DefferedProjectItem(ProjectItemIdentifier identifier, IProjectItemContent content) : base(identifier)
{
_content = content;
}
public void Test_OneToMany_RemoveItemRemovesGeneratedItems()
{
var kind = "test";
var project = new Project();
var p1 = AddAndCreateItem(kind, project, "p1");
var task = new Mock<IBuildTask>();
task.SetupGet(p => p.DependsOn).Returns(BuildQuery.SingleFromKind(kind));
var id1 = new ProjectItemIdentifier("created", "created");
var id2 = new ProjectItemIdentifier("created2", "created");
var s1 = new BuildTaskResult(id1, NullProjectItemContent.Instance);
var s2 = new BuildTaskResult(id2, NullProjectItemContent.Instance);
SetupProceed(task, p1).Returns(new[] { s1, s2 });
var builder = new Builder(project);
builder.AddTask(task.Object);
project.RemoveItem(p1);
var result = project.GetItems();
Assert.NotNull(result);
Assert.Empty(result);
}
