InternetHelperTest.h

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//     NScD Oak Ridge National Laboratory, European Spallation Source
//     & Institut Laue - Langevin
// SPDX - License - Identifier: GPL - 3.0 +
#ifndef MANTID_KERNEL_INTERNETSERVICETEST_H_
#define MANTID_KERNEL_INTERNETSERVICETEST_H_

#include <cxxtest/TestSuite.h>

#include "MantidKernel/ConfigService.h"
#include "MantidKernel/InternetHelper.h"
#include "MantidKernel/NetworkProxy.h"
#include "MantidKernel/ProxyInfo.h"

#include "Poco/Net/PartSource.h"
#include "Poco/Net/StringPartSource.h"
#include <Poco/Net/HTMLForm.h>
#include <Poco/TemporaryFile.h>

#include <fstream>
#include <sstream>

using Mantid::Kernel::InternetHelper;
using namespace Mantid::Kernel;

namespace {
/**
 * Mock out the internet calls of this algorithm
 */
class MockedInternetHelper : public InternetHelper {
protected:
  int sendHTTPSRequest(const std::string &url,
                       std::ostream &responseStream) override {
    UNUSED_ARG(url);

    responseStream << "HTTPS request succeeded";
    return 200;
  }
  int sendHTTPRequest(const std::string &url,
                      std::ostream &responseStream) override {
    UNUSED_ARG(url);
    responseStream << "HTTP request succeeded";
    return 200;
  }
};
} // namespace

class InternetHelperTest : public CxxTest::TestSuite {
public:
  // This pair of boilerplate methods prevent the suite being created statically
  // This means the constructor isn't called when running other tests
  static InternetHelperTest *createSuite() { return new InternetHelperTest(); }
  static void destroySuite(InternetHelperTest *suite) { delete suite; }

  void test_sendRequest_HTTP() {
    MockedInternetHelper internetHelper;
    std::string url = "http://www.google.com";

    std::stringstream ss;
    int response = 0;
    TS_ASSERT_THROWS_NOTHING(response = internetHelper.sendRequest(url, ss);)
    TS_ASSERT_EQUALS(200, response);
    TS_ASSERT_EQUALS("HTTP request succeeded", ss.str());
  }

  void test_sendRequest_HTTPS() {
    MockedInternetHelper internetHelper;
    std::string httpsUrl =
        "https://api.github.com/repos/mantidproject/mantid/contents";

    std::stringstream ss;
    int response = 0;
    TS_ASSERT_THROWS_NOTHING(response =
                                 internetHelper.sendRequest(httpsUrl, ss);)
    TS_ASSERT_EQUALS(200, response);
    TS_ASSERT_EQUALS("HTTPS request succeeded", ss.str());
  }

  void test_DownloadFile_HTTP() {
    MockedInternetHelper internetHelper;
    std::string url = "http://www.google.com";
    Poco::TemporaryFile tmpFile;
    int response = internetHelper.downloadFile(url, tmpFile.path());
    TS_ASSERT_EQUALS(200, response);
    TSM_ASSERT("File has not been created.", tmpFile.exists());
    TSM_ASSERT("File is not a file.", tmpFile.isFile());
    std::fstream fs;
    TS_ASSERT_THROWS_NOTHING(fs.open(tmpFile.path().c_str(), std::fstream::in));

    TSM_ASSERT("Cannot open file.", fs.is_open());

    std::stringstream ss;
    ss << fs.rdbuf(); // read the file
    fs.close();

    TS_ASSERT_EQUALS("HTTP request succeeded", ss.str());
  }

  void test_DownloadFile_HTTPS() {
    MockedInternetHelper internetHelper;
    std::string httpsUrl =
        "https://api.github.com/repos/mantidproject/mantid/contents";
    Poco::TemporaryFile tmpFile;
    int response = internetHelper.downloadFile(httpsUrl, tmpFile.path());
    TS_ASSERT_EQUALS(200, response);
    TSM_ASSERT("File has not been created.", tmpFile.exists());
    TSM_ASSERT("File is not a file.", tmpFile.isFile());
    std::fstream fs;
    TS_ASSERT_THROWS_NOTHING(fs.open(tmpFile.path().c_str(), std::fstream::in));

    TSM_ASSERT("Cannot open file.", fs.is_open());

    std::stringstream ss;
    ss << fs.rdbuf(); // read the file
    fs.close();

    TS_ASSERT_EQUALS("HTTPS request succeeded", ss.str());
  }

  void test_ContentType_GetSet() {
    MockedInternetHelper internetHelper;
    TSM_ASSERT_EQUALS("Default content type is not application/json",
                      internetHelper.getContentType(), "application/json");
    internetHelper.setContentType("test value");
    TSM_ASSERT_EQUALS("setContentType failed", internetHelper.getContentType(),
                      "test value");
  }

  void test_Method_GetSet() {
    MockedInternetHelper internetHelper;
    TSM_ASSERT_EQUALS("Default method is not GET", internetHelper.getMethod(),
                      "GET");
    internetHelper.setMethod("POST");
    TSM_ASSERT_EQUALS("setMethod failed", internetHelper.getMethod(), "POST");
  }

  void test_Timeout_GetSet() {
    MockedInternetHelper internetHelper;
    TSM_ASSERT_EQUALS("Default timeout is not 30", internetHelper.getTimeout(),
                      30);
    internetHelper.setTimeout(1);
    TSM_ASSERT_EQUALS("setTimeout failed", internetHelper.getTimeout(), 1);
  }

  void test_Body_GetSet() {
    MockedInternetHelper internetHelper;
    TSM_ASSERT_EQUALS("Default body is not empty", internetHelper.getBody(),
                      "");
    internetHelper.setBody("Test string");
    TSM_ASSERT_EQUALS("setBody failed", internetHelper.getBody(),
                      "Test string");
    TSM_ASSERT_EQUALS("method is not POST", internetHelper.getMethod(), "POST");
    TSM_ASSERT_EQUALS("Contentlength is wrong",
                      internetHelper.getContentLength(), 11);
    internetHelper.setBody("");
    TSM_ASSERT_EQUALS("setBody failed", internetHelper.getBody(), "");
    TSM_ASSERT_EQUALS("method is not GET", internetHelper.getMethod(), "GET");
    TSM_ASSERT_EQUALS("Contentlength is wrong",
                      internetHelper.getContentLength(), 0);
  }

  void test_BodyStream_GetSet() {
    MockedInternetHelper internetHelper;
    std::ostringstream ss;
    ss << "Test string";
    TSM_ASSERT_EQUALS("Default body is not empty", internetHelper.getBody(),
                      "");
    internetHelper.setBody(ss);
    TSM_ASSERT_EQUALS("setBody failed", internetHelper.getBody(), ss.str());
    TSM_ASSERT_EQUALS("method is not POST", internetHelper.getMethod(), "POST");
    TSM_ASSERT_EQUALS("Contentlength is wrong",
                      internetHelper.getContentLength(), 11);
    ss.str("");
    internetHelper.setBody(ss);
    TSM_ASSERT_EQUALS("setBody failed", internetHelper.getBody(), "");
    TSM_ASSERT_EQUALS("method is not GET", internetHelper.getMethod(), "GET");
    TSM_ASSERT_EQUALS("Contentlength is wrong",
                      internetHelper.getContentLength(), 0);
  }

  void test_BodyForm_GetSet() {
    MockedInternetHelper internetHelper;
    Poco::Net::HTMLForm form(Poco::Net::HTMLForm::ENCODING_MULTIPART);
    form.set("field1", "value1");
    form.set("field2", "value 2");
    form.set("field3", "value=3");
    form.set("field4", "value&4");

    form.addPart("attachment1",
                 new Poco::Net::StringPartSource("This is an attachment"));
    Poco::Net::StringPartSource *pSPS = new Poco::Net::StringPartSource(
        "This is another attachment", "text/plain", "att2.txt");
    pSPS->headers().set("Content-ID", "1234abcd");
    form.addPart("attachment2", pSPS);
    TSM_ASSERT_EQUALS("Default body is not empty", internetHelper.getBody(),
                      "");
    TSM_ASSERT_EQUALS("method is not GET", internetHelper.getMethod(), "GET");
    internetHelper.setBody(form);
    std::string body = internetHelper.getBody();
    TSM_ASSERT_DIFFERS("setBody failed \"--MIME_boundary\"",
                       body.find("--MIME_boundary"), std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"This is an attachment\"",
                       body.find("This is an attachment"), std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"This is another attachment\"",
                       body.find("This is another attachment"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"field1\"", body.find("field1"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"field2\"", body.find("field2"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"field3\"", body.find("field3"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"field4\"", body.find("field4"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"value1\"", body.find("value1"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"value 2\"", body.find("value 2"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"value=3\"", body.find("value=3"),
                       std::string::npos);
    TSM_ASSERT_DIFFERS("setBody failed \"value&4\"", body.find("value&4"),
                       std::string::npos);
    TSM_ASSERT_EQUALS("method is not POST", internetHelper.getMethod(), "POST");
    TSM_ASSERT_LESS_THAN("Contentlength is wrong", 700,
                         internetHelper.getContentLength());
  }

  void test_Headers_GetSet() {
    MockedInternetHelper internetHelper;
    TSM_ASSERT_EQUALS("Default headers are not empty",
                      internetHelper.headers().size(), 0);
    internetHelper.addHeader("Test", "value");
    internetHelper.addHeader("Test2", "value2");
    TSM_ASSERT_EQUALS("addHeader failed", internetHelper.getHeader("Test"),
                      "value");
    TSM_ASSERT_EQUALS("addHeader failed", internetHelper.getHeader("Test2"),
                      "value2");
    internetHelper.removeHeader("Test");
    TSM_ASSERT_EQUALS("Remove failed", internetHelper.headers().size(), 1);
    internetHelper.clearHeaders();
    TSM_ASSERT_EQUALS("Clear failed", internetHelper.headers().size(), 0);
  }
};

#endif /* MANTID_KERNEL_INTERNETSERVICETEST_H_ */