public void DependsOnTargetTest()
        {
            Mock <ITarget>         target1 = new Mock <ITarget>();
            ITargetFluentInterface t       = _fluent.DependsOn(target1.Object);

            Assert.NotNull(t);
            _target.Verify(i => i.DependsOn(target1.Object), Times.Once);
        }
        public void DependsOnStringTest()
        {
            ITargetFluentInterface t = _fluent.DependsOn("target1");

            Assert.NotNull(t);

            _target.Verify(i => i.DependsOn("target1"), Times.Once);
        }
        public ITaskExtensionsFluentInterface GetTaskExtensionsFluentInterface(ITargetFluentInterface target, ITaskContextInternal taskContext)
        {
            var t = _sp.GetRequiredService <ITaskExtensionsFluentInterface>();
            TaskExtensionsFluentInterface taskExtensions = (TaskExtensionsFluentInterface)t;

            taskExtensions.Target  = (TargetFluentInterface)target;
            taskExtensions.Context = taskContext;
            return(taskExtensions);
        }
        public ITargetFluentInterface GetTargetFluentInterface(ITarget target, ITaskContextInternal taskContext)
        {
            ITargetFluentInterface t            = _sp.GetRequiredService <ITargetFluentInterface>();
            TargetFluentInterface  targetFluent = (TargetFluentInterface)t;

            targetFluent.Target                   = target;
            targetFluent.Context                  = taskContext;
            targetFluent.CoreTaskFluent           = GetCoreTaskFluentInterface(taskContext);
            targetFluent.TaskExtensionsFluent     = GetTaskExtensionsFluentInterface(t, taskContext);
            targetFluent.CoreTaskExtensionsFluent = GetCoreTaskExtensionsFluentInterface(t, taskContext);
            targetFluent.TaskFluent               = GetTaskFluentInterface(taskContext);

            return(targetFluent);
        }
        protected override void ConfigureTargets(ITaskContext session)
        {
            ITargetFluentInterface test = session.CreateTarget("test")
                                          .AddTask(s => s.CopyFileTask("t1", "t2", false));

            ITargetFluentInterface test1 = session.CreateTarget("test1")
                                           .DependsOn(test);

            session.CreateTarget("extensions")
            .CoreTaskExtensions()
            .DotnetPublish("33")
            .CreateZipPackageFromProjects("aa", "netcoreapp1.1", "fdf");

            var restore = session
                          .CreateTarget("restore")
                          .AddCoreTask(s => s.Restore());

            var init = session
                       .CreateTarget("init")
                       .AddTask(s => s.FetchBuildVersionFromFileTask())
                       .AddTask(s => s.FetchVersionFromExternalSourceTask())
                       .AddCoreTask(s => s.UpdateNetCoreVersionTask("a"));

            var package = session
                          .CreateTarget("package")
                          .DependsOn(init, restore);

            session.CreateTarget("Linux")
            .AddCoreTask(x => x.LinuxTasks().SystemCtlTask("a", "b"))
            .AddCoreTask(x => x.LinuxTasks().SystemCtlTask("a", "b"));

            session.CreateTarget("IIS")
            .AddTask(x => x.IisTasks().CreateWebsiteTask())
            .AddTask(x => x.IisTasks().DeleteAppPoolTask("test"));

            session.CreateTarget("Do").Do(DoExample, "test");

            package
            .CoreTaskExtensions()
            .DotnetPublish("a", "b", "c")
            .CreateZipPackageFromProjects("8d", "netcoreapp1.1", "a", "b", "c", task =>
            {
                task.AddDirectoryToPackage("configuration", "configuration", true)
                .AddFileToPackage("DeployScript.cs", string.Empty)
                .AddFileToPackage("project.json", string.Empty)
                .AddFileToPackage("NuGet.config", string.Empty);
            });
        }