public virtual void Send(ICommonDataItem item)
        {
            // TODO: add an error handler
            var url = UrlList.TestData_Root + "/" + ClientSettings.Instance.CurrentClient.TestRunId + UrlList.TestData_CommonData_forClient_relPath;

            // 20141211
            // TODO: AOP
            Trace.TraceInformation("Send(ICommonDataItem item): testRun id = {0}, url = {1}", ClientSettings.Instance.CurrentClient.TestRunId, url);

            var dataItemSendingResponse = _restTemplate.PostForMessage(url, item);

            Trace.TraceInformation("dataItemSendingResponse is null? {0}", null == dataItemSendingResponse);

            // 20150316
            if (null == dataItemSendingResponse)
            {
                throw new SendingCommonDataItemException("Failed to send data item.");
            }

            if (HttpStatusCode.Created == dataItemSendingResponse.StatusCode)
            {
                return;
            }

            Trace.TraceInformation("HttpStatusCode.Created != dataItemSendingResponse.StatusCode");

            throw new SendingCommonDataItemException("Failed to send data item. " + dataItemSendingResponse.StatusCode);
        }
Exemple #2
0
        bool SendSingleFile(string sourceFolderPath, string sourceFilePath, string destinationPath, bool force)
        {
            var fileContentAndPaths = new Dictionary <string, object> {
                { "file", new HttpEntity(new FileInfo(sourceFilePath)) },
                { "relativePath", new HttpEntity(sourceFilePath.Substring(sourceFolderPath.Length)) },
                { "destinationPath", new HttpEntity(destinationPath) }
            };
            var fileUploadResponse = _restTemplate.PostForMessage(UrlList.ExternalFiles_Root + UrlList.ExternalFilesUploadPoint_relPath, fileContentAndPaths);

            return(HttpStatusCode.Created == fileUploadResponse.StatusCode);
        }
        public virtual bool SendTestResults()
        {
            Trace.TraceInformation("SendTestResults().1");

            var testResultsExporter = new TestResultsExporter();

            Trace.TraceInformation("SendTestResults().2");

            var xDoc = testResultsExporter.GetTestResultsAsXdocument(
                new SearchCmdletBaseDataObject {
                FilterAll = true
            },
                TestData.TestSuites,
                TestData.TestPlatforms);

            Trace.TraceInformation("SendTestResults().3");

            var dataObject = new TestResultsDataObject {
                Data = xDoc.ToString()
            };

            Trace.TraceInformation("SendTestResults().4");

            try {
                var url = UrlList.TestResults_Root + "/" + ClientSettings.Instance.CurrentClient.TestRunId + UrlList.TestResultsPostingPoint_forClient_relPath;


                // 20141211
                // TODO: AOP
                Trace.TraceInformation("SendTestResults().5: testRun id = {0}, url = {1}", ClientSettings.Instance.CurrentClient.TestRunId, url);


                var sendingResultsResponse = _restTemplate.PostForMessage(url, dataObject);

                Trace.TraceInformation("SendTestResults().6 sendingResultsResponse is null? {0}", null == sendingResultsResponse);
                // 20150316
                if (null == sendingResultsResponse)
                {
                    throw  new Exception("Failed to send test results.");
                }

                return(HttpStatusCode.Created == sendingResultsResponse.StatusCode);
            }
            catch (RestClientException eSendingTestResults) {
                // TODO: AOP
                Trace.TraceError("SendTestResults()");
                Trace.TraceError(eSendingTestResults.Message);
                throw new SendingTestResultsException("Failed to send test results. " + eSendingTestResults.Message);
            }
        }
Exemple #4
0
        public virtual Guid SendRegistrationInfoAndGetClientId(string customClientString)
        {
            Trace.TraceInformation("SendRegistrationInfoAndGetClientId(string customClientString).1");

            var registrationResponse = _restTemplate.PostForMessage <TestClient>(UrlList.TestClientRegistrationPoint_absPath, GetNewTestClient(customClientString));

            Trace.TraceInformation("registrationResponse is null {0}", null == registrationResponse);

            if (null == registrationResponse)
            {
                throw new Exception("Failed to register a client.");
            }

            Trace.TraceInformation("registrationResponse.Body is null {0}", null == registrationResponse.Body);

            if (null == registrationResponse.Body)
            {
                throw new Exception("Failed to register a client.");
            }

            if (HttpStatusCode.Created == registrationResponse.StatusCode)
            {
                ClientSettings.Instance.CurrentClient = registrationResponse.Body;
            }

            Trace.TraceInformation("ClientSettings.Instance.CurrentClient = registrationResponse.Body");

            if (HttpStatusCode.Created == registrationResponse.StatusCode)
            {
                return(registrationResponse.Body.Id);
            }

            Trace.TraceInformation("registrationResponse.Body.Id = {0}", registrationResponse.Body.Id);

            // TODO: AOP
            Trace.TraceWarning("SendRegistrationInfoAndGetClientId(string customClientString).2");
            Trace.TraceWarning("Failed to register a client. " + registrationResponse.StatusCode);
            throw new Exception("Failed to register a client. " + registrationResponse.StatusCode); // TODO: new type!
        }
Exemple #5
0
        public virtual bool CreateTestRun(string workflowName, TestRunStatuses status, string name)
        {
            Trace.TraceInformation("CreateTestRun(string workflowName, TestRunStatuses status, string name).1");

            var testRunCommand = new TestRunCommand {
                TestRunName  = name,
                Status       = status,
                WorkflowName = workflowName
            };

            Trace.TraceInformation("CreateTestRun(string workflowName, TestRunStatuses status, string name).2");

            var creatingTestRunResponse = _restTemplate.PostForMessage(UrlList.TestRunsControlPoint_absPath, testRunCommand);

            Trace.TraceInformation("CreateTestRun(string workflowName, TestRunStatuses status, string name).3 creatingTestRunResponse is null? {0}", null == creatingTestRunResponse);

            if (null == creatingTestRunResponse)
            {
                throw  new Exception("Failed to create a test run.");
            }

            return(HttpStatusCode.Created == creatingTestRunResponse.StatusCode);
        }