C# IIntegrationResult类代码示例

        public override void GetSource(IIntegrationResult result)
        {
            if (!_shim.AutoGetSource) return;
            Debug.Assert(_folderVersion > 0, "_folderVersion <= 0 when attempting to get source.  This shouldn't happen.");

            if (_shim.CleanCopy)
            {
                string cleanCopyWorkingFolder = null;
                if (StringUtil.IsBlank(_shim.WorkingDirectory))
                {
                    cleanCopyWorkingFolder = GetVaultWorkingFolder(result);
                    if (StringUtil.IsBlank(cleanCopyWorkingFolder))
                        throw new VaultException(
                            string.Format("Vault user {0} has no working folder set for {1} in repository {2} and no working directory has been specified.",
                                          _shim.Username, _shim.Folder, _shim.Repository));
                }
                else
                    cleanCopyWorkingFolder = result.BaseFromWorkingDirectory(_shim.WorkingDirectory);

                Log.Debug("Cleaning out source folder: " + cleanCopyWorkingFolder);
                new IoService().EmptyDirectoryIncludingReadOnlyObjects(cleanCopyWorkingFolder);
            }

            Log.Info("Getting source from Vault");
            Execute(GetSourceProcessInfo(result));
        }

 public override void GetSource(IIntegrationResult result)
 {
     if (AutoGetSource && !UseHistory)
     {
         UpdateSource(result, null);
     }
 }

 public void GetSource(IIntegrationResult result)
 {
     if (FailGetSource)
     {
         throw new System.Exception("Failing getting the source");
     }
 }

        public void Setup()
        {
            this.mocks = new MockRepository();

            mockery = new Mockery();
            targetMock = mockery.NewDynamicMock(typeof(IIntegrationRunnerTarget));
            resultManagerMock = mockery.NewDynamicMock(typeof(IIntegrationResultManager));
            quietPeriodMock = mockery.NewDynamicMock(typeof(IQuietPeriod));

            runner = new IntegrationRunner((IIntegrationResultManager)resultManagerMock.MockInstance,
                                           (IIntegrationRunnerTarget)targetMock.MockInstance,
                                           (IQuietPeriod)quietPeriodMock.MockInstance);


            request = ModificationExistRequest();
            endTime = new DateTime(2005, 2, 1);
            modifications = new Modification[] { new Modification() };

            resultMock = mockery.NewDynamicMock(typeof(IIntegrationResult));
            resultMock.SetupResult("WorkingDirectory", TempFileUtil.GetTempPath("workingDir"));
            resultMock.SetupResult("ArtifactDirectory", TempFileUtil.GetTempPath("artifactDir"));
            resultMock.SetupResult("BuildProgressInformation", new ThoughtWorks.CruiseControl.Core.Util.BuildProgressInformation("",string.Empty));
            resultMock.SetupResult("IntegrationProperties", new Dictionary<string, string>());
            result = (IIntegrationResult)resultMock.MockInstance;

            lastResultMock = mockery.NewDynamicMock(typeof(IIntegrationResult));
            lastResult = (IIntegrationResult)lastResultMock.MockInstance;
        }

 public void Run(IIntegrationResult result)
 {
     foreach (string mergeFile in MergeFiles)
     {
         string fullMergeFile = mergeFile;
         if (!Path.IsPathRooted(mergeFile))
         {
             fullMergeFile = Path.Combine(result.WorkingDirectory, mergeFile);
         }
         WildCardPath path = new WildCardPath(fullMergeFile);
         FileInfo[] files = path.GetFiles();
         foreach (FileInfo fileInfo in files)
         {
             Log.Info("Merging file: " + fileInfo);
             if (fileInfo.Exists)
             {
                 result.AddTaskResult((new FileTaskResult(fileInfo)));
             }
             else
             {
                 Log.Warning("File not Found: " + fileInfo);
             }
         }
     }
 }

 public void Run(IIntegrationResult result)
 {
     XmlSerializer serializer = new XmlSerializer(typeof (Modification[]));
     StringWriter writer = new Utf8StringWriter();
     serializer.Serialize(writer, result.Modifications);
     fileSystem.Save(ModificationFile(result), writer.ToString());
 }

 public void LabelSourceControl(IIntegrationResult result)
 {
     var fileName = Path.Combine(
         Path.GetDirectoryName(this.FileName),
         DateTime.Now.ToString("yyyyMMddHHmmss") + ".label");
     File.WriteAllText(fileName, result.Label);
 }

 public void LabelSourceControl(IIntegrationResult result)
 {
     foreach (ISourceControl sourceControl in SourceControls)
     {
         sourceControl.LabelSourceControl(result);
     }
 }

 public void GetSource(IIntegrationResult result)
 {
     foreach (ISourceControl sourceControl in SourceControls)
     {
         sourceControl.GetSource(result);
     }
 }

        public override void GetSource(IIntegrationResult result)
        {
            if (!_shim.AutoGetSource) return;

            _labelApplied = false;

            if (StringUtil.IsBlank(_shim.WorkingDirectory) && !(!_shim.ApplyLabel && _shim.UseVaultWorkingDirectory && !_shim.CleanCopy))
            {
                _shim.WorkingDirectory = GetVaultWorkingFolder(result);
                if (StringUtil.IsBlank(_shim.WorkingDirectory))
                    throw new VaultException(
                        string.Format("Vault user {0} has no working folder set for {1} in repository {2} and no working directory has been specified.",
                                      _shim.Username, _shim.Folder, _shim.Repository));
            }

            if (_shim.ApplyLabel)
            {
                Log.Info(string.Format("Applying label \"{0}\" to {1} in repository {2}.", result.Label, _shim.Folder, _shim.Repository));
                Execute(LabelProcessInfo(result));
                _labelApplied = true;
            }

            if (_shim.CleanCopy && !StringUtil.IsBlank(this._shim.WorkingDirectory))
            {
                Log.Debug("Cleaning out source folder: " + result.BaseFromWorkingDirectory(_shim.WorkingDirectory));
                new IoService().EmptyDirectoryIncludingReadOnlyObjects(result.BaseFromWorkingDirectory(_shim.WorkingDirectory));
            }

            Log.Info("Getting source from Vault");
            Execute(GetSourceProcessInfo(result, _shim.ApplyLabel));
        }

 public override void GetSource(IIntegrationResult result)
 {
     if (!AutoGetSource) return;
     git_clean(result);
     if (git_log_local_hash(result) != null) git_reset(result);
     git_merge(result);
 }

 /// <summary>
 ///     Appends a text string to the task_description attribute to each task in
 ///     the current selection set.
 /// </summary>
 /// <param name="connection">CM Synergy connection parameters.</param>
 /// <param name="project">Properties of the integration testing project.</param>
 /// <param name="result">The change set for the current integration run</param>
 /// <returns>A non-null initialized process structure.</returns>
 public static ProcessInfo AddLabelToTaskComment(SynergyConnectionInfo connection, SynergyProjectInfo project, IIntegrationResult result)
 {
     const string template = @"task /modify /description ""Integrated Successfully with CruiseControl.NET project '{0}' build '{1}' on {2}"" ""{3}""";
     string tasks = GetTaskList(result.Modifications);
     string arguments = String.Format(template, result.ProjectName, result.Label, result.StartTime, tasks);
     return CreateProcessInfo(connection, arguments);
 }

        public void Run(IIntegrationResult result)
        {
            if (IntegrationStatus != result.Status) return;

            ICruiseManager manager = (ICruiseManager) remotingService.Connect(typeof(ICruiseManager), ServerUri);
            manager.ForceBuild(Project);
        }

 public override Modification[] GetModifications(IIntegrationResult from, IIntegrationResult to)
 {
     _labelApplied = false;
     Log.Info(string.Format("Checking for modifications to {0} in Vault Repository \"{1}\" between {2} and {3}", _shim.Folder, _shim.Repository, from.StartTime, to.StartTime));
     ProcessResult result = ExecuteWithRetries(ForHistoryProcessInfo(from, to));
     return ParseModifications(result, from.StartTime, to.StartTime);
 }

        public override void GetSource(IIntegrationResult result)
        {
            result.BuildProgressInformation.SignalStartRunTask("Getting source from Vault");

            if (!_shim.AutoGetSource) return;
            if (_folderVersion <= 0)
            {
                throw new CruiseControlException("_folderVersion <= 0 when attempting to get source.  This shouldn't happen.");
            }

            if (_shim.CleanCopy)
            {
                string cleanCopyWorkingFolder = null;
                if (string.IsNullOrEmpty(_shim.WorkingDirectory))
                {
                    cleanCopyWorkingFolder = GetVaultWorkingFolder(result);
                    if (string.IsNullOrEmpty(cleanCopyWorkingFolder))
                        throw new VaultException(
                            string.Format("Vault user {0} has no working folder set for {1} in repository {2} and no working directory has been specified.",
                                          _shim.Username, _shim.Folder, _shim.Repository));
                }
                else
                    cleanCopyWorkingFolder = result.BaseFromWorkingDirectory(_shim.WorkingDirectory);

                Log.Debug("Cleaning out source folder: " + cleanCopyWorkingFolder);
                fileDirectoryDeleter.DeleteIncludingReadOnlyObjects(cleanCopyWorkingFolder);
            }

            Log.Info("Getting source from Vault");
            Execute(GetSourceProcessInfo(result));
        }