C# Context.ReadConfigAsString方法代码示例

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(System.Xml.XmlNode testConfig, Context context)
		{
			// read test config...
			string path = context.ReadConfigAsString( testConfig, "Path" );
			string fileFilter = context.ReadConfigAsString( testConfig, "FileFilter" );
			int timeOut = context.ReadConfigAsInt32( testConfig, "TimeOut" );
			
			var watcher = new FileSystemWatcher
			                  {
			                      Path = path,
			                      Filter = fileFilter,
			                      NotifyFilter = NotifyFilters.LastWrite,
			                      EnableRaisingEvents = true,
			                      IncludeSubdirectories = false
			                  };
		    watcher.Changed += OnCreated;
			_mre = new ManualResetEvent(false);

			if(!_mre.WaitOne(timeOut, false))
			{
				throw new Exception(string.Format("WaitOnFileStep timed out after {0} milisecs watching path:{1}, filter{2}", timeOut, path, fileFilter));
			}

            context.LogInfo(string.Format("WaitOnFileStep found the file: {0}", _newFilePath));
            context.Add("waitedForFileName", _newFilePath);
		}

        /// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
		{
			_directory = context.ReadConfigAsString( testConfig, "Directory" );
			_searchPattern = context.ReadConfigAsString( testConfig, "SearchPattern" );

            Execute(context);
		}

        /// <summary>
        /// ITestStep.Execute() implementation
        /// </summary>
        /// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
        /// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
        public void Execute(XmlNode testConfig, Context context)
        {
            _sourcePath = context.ReadConfigAsString(testConfig, "SourcePath");
            _creationPath = context.ReadConfigAsString(testConfig, "CreationPath");

            Execute(context);
        }

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
		{
			var rawListOfMachines = context.ReadConfigAsString(testConfig, "Machine", true);
            
            var listOfMachines = new List<string>();

            if (string.IsNullOrEmpty(rawListOfMachines))
            {
                listOfMachines.Add(Environment.MachineName);
            }
            else
            {
                listOfMachines.AddRange(rawListOfMachines.Split(','));
            }

            foreach (var machine in listOfMachines)
            {
                var eventLog = context.ReadConfigAsString(testConfig, "EventLog");

                using (var log = new EventLog(eventLog, machine))
                {
                    context.LogInfo("About to clear the '{0}' event log on machine '{1}'of all entries.", eventLog,
                                    machine);
                    log.Clear();
                }
            }
		}

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
        {
			string sourcePath = context.ReadConfigAsString(testConfig, "SourcePath");
			string destinationPath = context.ReadConfigAsString(testConfig, "DestinationPath");

			File.Move( sourcePath, destinationPath ) ;

			context.LogInfo( "FileMoveStep has moved file: \"{0}\" to \"{1}\"", sourcePath, destinationPath ) ;
		}

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
		{
			string srcDirectory = context.ReadConfigAsString( testConfig, "SourceDirectory");
			string dstDirectory = context.ReadConfigAsString( testConfig, "DestinationDirectory");

			context.LogInfo("About to renme the directory \"{0}\" to \"{1}\"", srcDirectory, dstDirectory);

			var di = new DirectoryInfo(srcDirectory);
			di.MoveTo(dstDirectory);
		}

        /// <summary>
        /// ITestStep.Execute() implementation
        /// </summary>
        /// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
        /// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
        public void Execute(XmlNode testConfig, Context context)
        {
            var destinationPath = context.ReadConfigAsString(testConfig, "DestinationPath");
            var rawListOfServers = context.ReadConfigAsString(testConfig, "Server");
            
            var listOfServers = new List<string>();
            listOfServers.AddRange(rawListOfServers.Split(','));

            foreach (var server in listOfServers)
            {
                context.LogInfo("About to save the event on server: {0} to the following directory: {1}", server,
                                destinationPath);

                ManagementScope scope;

                if ((server.ToUpper() != Environment.MachineName.ToUpper()))
                {
                    var options = new ConnectionOptions
                                      {
                                          Impersonation = ImpersonationLevel.Impersonate,
                                          EnablePrivileges = true
                                      };
                    scope = new ManagementScope(string.Format(@"\\{0}\root\cimv2", server), options);
                }
                else
                {
                    var options = new ConnectionOptions
                                      {
                                          Impersonation = ImpersonationLevel.Impersonate,
                                          EnablePrivileges = true
                                      };
                    scope = new ManagementScope(@"root\cimv2", options);
                }

                var query = new SelectQuery("Select * from Win32_NTEventLogFile");
                var searcher = new ManagementObjectSearcher(scope, query);

                foreach (var logFileObject in searcher.Get())
                {
                    var methodArgs = new object[] { destinationPath + @"\" + server + ".evt" };

                    try
                    {
                        ((ManagementObject)logFileObject).InvokeMethod("BackupEventLog", methodArgs);
                    }
                    catch (Exception e1)
                    {
                        //access denied on method call if scope path referes to the same  
                        context.LogException(e1);

                        throw;
                    }
                }
            }
        }

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
		{
			string queueManager = context.ReadConfigAsString(testConfig, "QueueManager");
			string queue = context.ReadConfigAsString(testConfig, "Queue");
			int waitTimeout = context.ReadConfigAsInt32(testConfig, "WaitTimeout");
			XmlNode validationConfig = testConfig.SelectSingleNode("ValidationStep");

		    string message = MQSeriesHelper.ReadMessage(queueManager, queue, waitTimeout, context);

            context.LogData("MQSeries output message:", message);

            context.ExecuteValidator(StreamHelper.LoadMemoryStream(message), validationConfig);
		}

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
        {
			string sourcePath = context.ReadConfigAsString(testConfig, "SourceDirectory");
			string pattern = context.ReadConfigAsString(testConfig, "SearchPattern");
			string destinationPath = context.ReadConfigAsString(testConfig, "DestinationDirectory");
			string [] filelist = Directory.GetFiles( sourcePath, pattern ) ;

			foreach( string file in filelist)
			{
				File.Move( file, destinationPath + @"\" + Path.GetFileName( file ) ) ;

				context.LogInfo( "FilesMoveStep has moved file: \"{0}\" to \"{1}\"", file, destinationPath ) ;
			}
		}

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
        {
            string connectionString = context.ReadConfigAsString(testConfig, "ConnectionString" );
            string table = context.ReadConfigAsString(testConfig, "Table" );
            string condition = context.ReadConfigAsString(testConfig, "Condition" );

            // Build the SQL statement
            string sqlStatement = "delete from " + table + " where " + condition ;

            context.LogInfo( "DatabaseDeleteStep connecting to \"{0}\", executing statement \"{1}\"", connectionString, sqlStatement ) ;

            // Execute command against specified database
            DatabaseHelper.ExecuteNonQuery( connectionString, sqlStatement ) ;
        }

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
		{
			MemoryStream request = null;
			MemoryStream response = null;

			try
			{
				// read test config...
				string sourcePath = context.ReadConfigAsString( testConfig, "SourcePath" );
				string destinationUrl = context.ReadConfigAsString( testConfig, "DestinationUrl" );
				int requestTimeout = context.ReadConfigAsInt32( testConfig, "RequestTimeout" );
				XmlNode validationConfig = testConfig.SelectSingleNode("ValidationStep");

				context.LogInfo("HttpRequestResponseStep about to post data from File: {0} to the Url: {1}", sourcePath, destinationUrl );

				// Get the data to post...
				request = StreamHelper.LoadFileToStream(sourcePath);
				byte[] data = request.GetBuffer();

				// Post the data...
				response = HttpHelper.SendRequestData(destinationUrl, data, requestTimeout, context);

				// Dump the respons to the console...
				StreamHelper.WriteStreamToConsole("HttpRequestResponseStep response data", response, context);

				// Validate the response...
				try
				{
					response.Seek(0, SeekOrigin.Begin);
					context.ExecuteValidator( response, validationConfig );
				}
				catch(Exception e)
				{
					throw new ApplicationException("HttpRequestResponseStep response stream was not correct!", e);
				}
			}
			finally
			{
				if ( null != response )
				{
					response.Close();
				}

				if ( null != request )
				{
					request.Close();
				}
			}
		}

        /// <summary>
		/// IValidationStep.ExecuteValidation() implementation
		/// </summary>
		/// <param name='data'>The stream cintaining the data to be validated.</param>
		/// <param name='validatorConfig'>The Xml fragment containing the configuration for the test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void ExecuteValidation(Stream data, XmlNode validatorConfig, Context context)
		{
			_comparisonDataPath = context.ReadConfigAsString( validatorConfig, "ComparisonDataPath" );
			_compareAsUtf8 = context.ReadConfigAsBool( validatorConfig, "CompareAsUTF8", true);

            ExecuteValidation(data, context);
		}

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
		public void Execute(XmlNode testConfig, Context context)
		{
			// Rread test config...
			var typeName = context.ReadConfigAsString( testConfig, "TypeName" );
			var assemblyPath = context.ReadConfigAsString( testConfig, "AssemblyPath" );
			var methodToInvoke = context.ReadConfigAsString( testConfig, "MethodToInvoke" );
            var parameters = testConfig.SelectNodes("Parameter");
			var returnParameter = context.ReadConfigAsXml( testConfig, "ReturnParameter", true );
			
			var obj = CreateObject(typeName, assemblyPath, context);

			var mi = obj.GetType().GetMethod(methodToInvoke);
			var pi = mi.GetParameters();
			
			var parameterArray = new ArrayList();

			for( int c = 0; c < pi.Length; c++)
			{
				var t = pi[c].ParameterType;
				var xs = new XmlSerializer(t);
                parameterArray.Add(xs.Deserialize(new XmlTextReader(StreamHelper.LoadMemoryStream(context.GetInnerXml(parameters[c])))));
			}

			var paramsForCall = new object[parameterArray.Count];
			for( int c = 0; c < parameterArray.Count; c++ )
			{
				paramsForCall[c] = parameterArray[c];
			}

			context.LogInfo("About to call the method: {0}() on the type {1}", methodToInvoke, typeName );
			// Call the .Net Object...
			var returnValue = mi.Invoke(obj, paramsForCall);
			context.LogInfo("Return value: {0}", returnValue);

            if (!string.IsNullOrEmpty(returnParameter))
			{
				var xsRet = new XmlSerializer(returnValue.GetType());

				var rs = new MemoryStream();
				xsRet.Serialize( new StreamWriter(rs), returnValue );
				var es = StreamHelper.LoadMemoryStream(returnParameter);

				rs.Seek(0, SeekOrigin.Begin);
				es.Seek(0, SeekOrigin.Begin);
				StreamHelper.CompareXmlDocs(rs, es, context);
			}
		}

        /// <summary>
        /// ITestStep.Execute() implementation
        /// </summary>
        /// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
        /// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
        public void Execute(XmlNode testConfig, Context context)
		{
			var delayBeforeCheck = context.ReadConfigAsInt32( testConfig, "DelayBeforeExecution" );			
			var connectionString = context.ReadConfigAsString( testConfig, "ConnectionString" );

			var datasetWriteXmlSchemaPath = context.ReadConfigAsString(testConfig, "DatasetWriteXmlSchemaPath");
			var datasetWriteXmlPath = context.ReadConfigAsString(testConfig, "DatasetWriteXmlPath");
			var tableNames = context.ReadConfigAsString(testConfig, "TableNames");

			// Sleep for delay seconds...
			System.Threading.Thread.Sleep(delayBeforeCheck);

			var ds = GetDataSet(connectionString, tableNames);

			ds.WriteXml(datasetWriteXmlPath);
			ds.WriteXmlSchema(datasetWriteXmlSchemaPath);
		}

		/// <summary>
		/// ITestStep.Execute() implementation
		/// </summary>
		/// <param name='testConfig'>The Xml fragment containing the configuration for this test step</param>
		/// <param name='context'>The context for the test, this holds state that is passed beteen tests</param>
        
        public void Execute(XmlNode testConfig, Context context)
        {
            string directoryName = context.ReadConfigAsString(testConfig, "DirectoryName");

            context.LogInfo("About to create the directory: {0}", directoryName);
		    
            System.IO.Directory.CreateDirectory(directoryName);
        }