public void ConstructorSetsProperties() { var message = new Response(); var args = new CommunicationsEventArgs("action", message); Assert.AreEqual("action", args.Action); Assert.AreSame(message, args.Message); }
/// <summary> /// Fires the <see cref="ResponseReceived"/> event. /// </summary> /// <param name="action">The action that the response is for.</param> /// <param name="response">The response that was received.</param> protected virtual void FireResponseReceived(string action, Response response) { if (ResponseReceived != null) { ResponseReceived(this, new CommunicationsEventArgs(action, response)); } }
public void InitialiseNewResponseSetsTheDefaultValues() { DateTime now = DateTime.Now; Response response = new Response(); Assert.AreEqual(ResponseResult.Unknown, response.Result, "Result wasn't set to failure"); Assert.IsTrue((now <= response.Timestamp), "Timestamp was not set"); }
/// <summary> /// Initialise a new instance of <see cref="Response"/> from a response. /// </summary> /// <param name="response">The response to use.</param> public Response(Response response) { errorMessages = response.errorMessages; requestIdentifier = response.requestIdentifier; result = response.result; Timestamp = response.Timestamp; }
public void EqualsMatchesResponseWithTheSameIdentifierAndTimestamp() { Response response1 = new Response(); Response response2 = new Response(); response1.RequestIdentifier = response2.RequestIdentifier; response1.Timestamp = response2.Timestamp; Assert.IsTrue(response1.Equals(response2)); }
public void EqualsDoesNotMatchesResponseWithDifferentTimestamp() { Response response1 = new Response(); Response response2 = new Response(); response1.Timestamp = DateTime.Now.AddMilliseconds(-1); response2.Timestamp = DateTime.Now; Assert.IsFalse(response1.Equals(response2)); }
public void EqualsDoesNotMatchesResponseWithDifferentIdentifier() { Response response1 = new Response(); Response response2 = new Response(); response1.RequestIdentifier = "response1"; response2.RequestIdentifier = "response2"; Assert.IsFalse(response1.Equals(response2)); }
public void InitialiseResponseFromRequestSetsTheDefaultValues() { DateTime now = DateTime.Now; ServerRequest request = new ServerRequest(); Response response = new Response(request); Assert.AreEqual(ResponseResult.Unknown, response.Result, "Result wasn't set to failure"); Assert.AreEqual(request.Identifier, response.RequestIdentifier, "RequestIdentifier wasn't set to the identifier of the request"); Assert.IsTrue((now <= response.Timestamp), "Timestamp was not set"); }
public void GetSetAllPropertiesWorks() { Response response = new Response(); response.RequestIdentifier = "new id"; Assert.AreEqual("new id", response.RequestIdentifier, "RequestIdentifier fails the get/set test"); response.Result = ResponseResult.Success; Assert.AreEqual(ResponseResult.Success, response.Result, "Result fails the get/set test"); DateTime now = DateTime.Now; response.Timestamp = now; Assert.AreEqual(now, response.Timestamp, "Timestamp fails the get/set test"); }
public void InitialiseResponseFromResponseSetsTheDefaultValues() { DateTime now = DateTime.Now; Response response1 = new Response(); response1.Result = ResponseResult.Success; response1.RequestIdentifier = "original id"; response1.Timestamp = DateTime.Now.AddMinutes(-1); Response response2 = new Response(response1); Assert.AreEqual(ResponseResult.Success, response2.Result, "Result wasn't set to failure"); Assert.AreEqual("original id", response2.RequestIdentifier, "RequestIdentifier wasn't set to the identifier of the request"); Assert.IsTrue((response1.Timestamp == response2.Timestamp), "Timestamp was not set"); }
public void SendMessageEncryptsMessage() { var innerConnection = new TestConnection(); var outerConnection = new EncryptingConnection(innerConnection); var request = new ServerRequest(); var expectedResponse = new Response(request); var actionName = "DoSomething"; string iv = null; string key = null; innerConnection.SendMessageAction = (a, r) => { Response sendResponse = null; if (a == "RetrievePublicKey") { sendResponse = this.GenerateKeyResponse(r); } else if (a == "InitialiseSecureConnection") { Assert.IsInstanceOf<LoginRequest>(r); sendResponse = this.GenerateConnectioResponse(r as LoginRequest, out iv, out key); } else if (a == "ProcessSecureRequest") { Assert.IsInstanceOf<EncryptedRequest>(r); var actualRequest = r as EncryptedRequest; Assert.AreEqual(actionName, actualRequest.Action); var crypto = new RijndaelManaged(); crypto.Key = Convert.FromBase64String(key); crypto.IV = Convert.FromBase64String(iv); var requestData = DecryptMessage(crypto, actualRequest.EncryptedData); Assert.AreEqual(request.ToString(), requestData); var encryptedResponse = new EncryptedResponse(); encryptedResponse.Result = ResponseResult.Success; encryptedResponse.EncryptedData = EncryptMessage(crypto, expectedResponse.ToString()); sendResponse = encryptedResponse; } else { Assert.Fail("Unknown action: " + a); } return sendResponse; }; var response = outerConnection.SendMessage(actionName, request); Assert.IsNotNull(response); Assert.AreEqual(expectedResponse.RequestIdentifier, response.RequestIdentifier); }
public void ProcessMessageCorrectlyHandlesAValidMessage() { // Setup the messages ProjectRequest request = new ProjectRequest("123-45", "A test project"); Response response = new Response(request); response.Result = ResponseResult.Success; // Initialises the mocks ICruiseServer server = mocks.DynamicMock<ICruiseServer>(); Expect.Call(server.ForceBuild(request)).Return(response); mocks.ReplayAll(); // Run the actual test var manager = new ThoughtWorks.CruiseControl.Core.CruiseServerClient(server); string responseText = manager.ProcessMessage("ForceBuild", request.ToString()); Assert.AreEqual(response.ToString(), responseText); mocks.VerifyAll(); }
/// <summary> /// Validates the response from the server. /// </summary> /// <param name="response"></param> private Response ValidateResponse(Response response) { // If the result has not been set (i.e is Unknown) then assume we have a failure if ((response.Result == ResponseResult.Failure) || (response.Result == ResponseResult.Unknown)) { string message = "Request processing has failed on the remote server:" + Environment.NewLine + response.ConcatenateErrors(); var errorType = response.ErrorMessages.Count == 1 ? response.ErrorMessages[0].Type : null; throw new CommunicationsException(message, errorType); } return response; }
/// <summary> /// Initialise a new instance of <see cref="SnapshotResponse"/> from a response. /// </summary> /// <param name="response">The response to use.</param> public SnapshotResponse(Response response) : base(response) { }
/// <summary> /// Processes a message. /// </summary> /// <param name="action">The action to use.</param> /// <param name="message">The request message in an XML format.</param> /// <returns>The response message in an XML format.</returns> public override string ProcessMessage(string action, string message) { Response response = new Response(); try { // Find the type of message var messageXml = new XmlDocument(); messageXml.LoadXml(message); var messageType = XmlConversionUtil.FindMessageType(messageXml.DocumentElement.Name); if (messageType == null) { response.Result = ResponseResult.Failure; response.ErrorMessages.Add( new ErrorMessage( string.Format( "Unable to translate message: '{0}' is unknown", messageXml.DocumentElement.Name))); } // Convert the message and invoke the action var request = XmlConversionUtil.ConvertXmlToObject(messageType, message); response = connection.SendMessage(action, request as ServerRequest); } catch (Exception error) { response.Result = ResponseResult.Failure; response.ErrorMessages.Add( new ErrorMessage("Unable to process error: " + error.Message)); } return response.ToString(); }
public ServerStub(string action, Type message, string projectName, Response response) { this.action = action; this.message = message; this.projectName = projectName; this.response = response; }
public Response SendMessage(string action, ServerRequest request) { Assert.AreEqual(this.action, action); Assert.AreEqual(this.message, request.GetType()); if (!string.IsNullOrEmpty(projectName) && (request is ProjectRequest)) { Assert.AreEqual(this.projectName, (request as ProjectRequest).ProjectName); } if (response == null) { Response result = new Response(request); result.Result = ResponseResult.Success; return result; } else { return response; } }
public void ToStringSerialisesAllValues() { Response response = new Response(); response.ErrorMessages.Add(new ErrorMessage("Error 1")); response.ErrorMessages.Add(new ErrorMessage("Error 2")); response.RequestIdentifier = "request"; response.Result = ResponseResult.Success; response.Timestamp = DateTime.Now; string actual = response.ToString(); string expected = string.Format("<response xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\" " + "timestamp=\"{2:yyyy-MM-ddTHH:mm:ss.FFFFFFFzzz}\" identifier=\"{0}\" result=\"{1}\">" + "<error>Error 1</error>" + "<error>Error 2</error>" + "</response>", response.RequestIdentifier, response.Result, response.Timestamp); Assert.AreEqual(expected, actual); }
public ServerStub(string action, Type message, Response response) : this(action, message, null, response) { }
/// <summary> /// Terminate a secure communications connection. /// </summary> /// <param name="request"></param> /// <returns></returns> public Response TerminateSecureConnection(ServerRequest request) { // Remove the connection details if (connections.ContainsKey(request.SourceName)) { connections.Remove(request.SourceName); } // Generate a response var response = new Response(request); response.Result = ResponseResult.Success; return response; }
/// <summary> /// Initialise a new <see cref="MessageReceivedEventArgs"/>. /// </summary> /// <param name="response"></param> /// <param name="error"></param> /// <param name="cancelled"></param> /// <param name="userState"></param> public MessageReceivedEventArgs(Response response, Exception error, bool cancelled, object userState) : base(error, cancelled, userState) { this.response = response; }
/// <summary> /// Processes a message. /// </summary> /// <param name="action">The action to use.</param> /// <param name="message">The request message.</param> /// <returns>The response message.</returns> public virtual Response ProcessMessage(string action, ServerRequest message) { Response response = new Response(); try { // Find the action Type cruiseType = this.GetType(); MethodInfo actionMethod = cruiseType.GetMethod(action, BindingFlags.IgnoreCase | BindingFlags.Instance | BindingFlags.InvokeMethod | BindingFlags.Public); if (actionMethod == null) { throw new CruiseControlException( string.Format( CultureInfo.CurrentCulture, "Unable to locate action '{0}'", action)); } // Invoke the action message.ChannelInformation = new RemotingChannelSecurityInformation(); response = actionMethod.Invoke(this, new object[] { message }) as Response; } catch (Exception error) { response.Result = ResponseResult.Failure; if ((error is TargetInvocationException) && (error.InnerException != null)) { error = error.InnerException; } response.ErrorMessages.Add( new ErrorMessage("Unable to process: " + error.Message)); } return response; }
/// <summary> /// Initialise a secure communications connection. /// </summary> /// <param name="request"></param> /// <returns></returns> public Response InitialiseSecureConnection(LoginRequest request) { // Decrypt the password var cp = new CspParameters(); cp.KeyContainerName = "CruiseControl.NET Server"; var provider = new RSACryptoServiceProvider(cp); var originalKey = request.FindCredential(LoginRequest.UserNameCredential).Value; var decryptedKey = UTF8Encoding.UTF8.GetString( provider.Decrypt(Convert.FromBase64String(originalKey), false)); var originalIv = request.FindCredential(LoginRequest.PasswordCredential).Value; var decryptedIv = UTF8Encoding.UTF8.GetString( provider.Decrypt(Convert.FromBase64String(originalIv), false)); // Generate the connection details var connection = new SecureConnection { Expiry = DateTime.Now.AddMinutes(15), IV = Convert.FromBase64String(decryptedIv), Key = Convert.FromBase64String(decryptedKey) }; connections[request.SourceName] = connection; // Generate a response var response = new Response(request); response.Result = ResponseResult.Success; return response; }
/// <summary> /// Initialise a new instance of <see cref="ProjectStatusResponse"/> from a response. /// </summary> /// <param name="response">The response to use.</param> public ProjectStatusResponse(Response response) : base(response) { }
/// <summary> /// Initialise a new instance of <see cref="ExternalLinksListResponse"/> from a response. /// </summary> /// <param name="response">The response to use.</param> public ExternalLinksListResponse(Response response) : base(response) { }
/// <summary> /// Encapsulates the code to process a request. /// </summary> /// <param name="request"></param> /// <param name="permission"></param> /// <param name="eventType"></param> /// <param name="action"></param> /// <returns></returns> private Response RunServerRequest(ServerRequest request, SecurityPermission? permission, SecurityEvent? eventType, Action<ServerRequest> action) { Response response = new Response(request); try { // Validate the request and check the security token ValidateRequest(request); if (permission.HasValue) { CheckSecurity(request.SessionToken, null, permission.Value, eventType); } // Perform the actual action action(request); response.Result = ResponseResult.Success; } catch (Exception error) { // Security exceptions have already been logged, just need to log any other exception if (!(error is SecurityException)) { Log.Warning(error); } // Tell the caller the request failed and include the error message (but not the stack trace!) response.Result = ResponseResult.Failure; response.ErrorMessages.Add( new ErrorMessage( error.Message, error.GetType().Name)); } return response; }
/// <summary> /// Encapsulates the code to process a request. /// </summary> /// <param name="request"></param> /// <param name="permission"></param> /// <param name="eventType"></param> /// <param name="action"></param> /// <returns></returns> private Response RunProjectRequest(ProjectRequest request, SecurityPermission? permission, SecurityEvent? eventType, ProjectRequestAction action) { var response = new Response(request); try { // Validate the request and check the security token ValidateRequest(request); if (permission.HasValue) { CheckSecurity(request.SessionToken, request.ProjectName, permission.Value, eventType); } // Perform the actual action action(request, response); if (response.Result == ResponseResult.Unknown) { response.Result = ResponseResult.Success; } } catch (Exception error) { // Log any errors to help diagnosing issues Log.Warning(error); response.Result = ResponseResult.Failure; response.ErrorMessages.Add( new ErrorMessage( error.Message, error.GetType().Name)); } return response; }
/// <summary> /// Initializes a new instance of the <see cref="ListBuildSummaryResponse"/> class. /// </summary> /// <param name="response">The response.</param> /// <param name="summaries">The summaries.</param> public ListBuildSummaryResponse(Response response, IList<BuildSummary> summaries) : base(response) { this.summaries = new List<BuildSummary>(summaries); }
/// <summary> /// Validate the response from the server. /// </summary> /// <param name="response"></param> private void ValidateResponse(Response response) { if (response.Result == ResponseResult.Failure) { string message = "Request request has failed on the remote server:" + Environment.NewLine + response.ConcatenateErrors(); throw new CruiseControlException(message); } }
/// <summary> /// Processes a message. /// </summary> /// <param name="action">The action to use.</param> /// <param name="message">The request message in an XML format.</param> /// <returns>The response message in an XML format.</returns> public virtual string ProcessMessage(string action, string message) { var response = new Response(); try { // Find the action and message type, extract the message and invoke the method response = ExtractAndInvokeMessage(message, action, new RemotingChannelSecurityInformation()); } catch (Exception error) { response.Result = ResponseResult.Failure; response.ErrorMessages.Add( new ErrorMessage("Unable to process: " + error.Message)); } var responseText = response.ToString(); return responseText; }