106 lines
3.6 KiB
C++
106 lines
3.6 KiB
C++
#include <gmock/gmock.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include <numeric>
|
|
#include <set>
|
|
|
|
#include "gtest_matchers.hpp"
|
|
#include "http_mock.hpp"
|
|
#include <rublon/core_handler.hpp>
|
|
|
|
using namespace rublon;
|
|
class CoreHandlerTestable : public CoreHandler<HttpHandlerMock> {
|
|
public:
|
|
CoreHandlerTestable(rublon::Configuration _conf = conf)
|
|
: CoreHandler<HttpHandlerMock>{_conf} {}
|
|
auto &_http() { return http; }
|
|
|
|
tl::expected<Document, Error> request(std::string_view path,
|
|
const Document &body) {
|
|
static auto mr = std::pmr::get_default_resource();
|
|
static RapidJSONPMRAlloc alloc{mr};
|
|
return CoreHandler<HttpHandlerMock>::request(alloc, path, body);
|
|
}
|
|
};
|
|
|
|
class CoreHandlerTests : public testing::Test {
|
|
public:
|
|
CoreHandlerTests() : http{sut._http()} { doc.SetObject(); }
|
|
|
|
CoreHandlerTestable sut;
|
|
HttpHandlerMock &http;
|
|
rublon::Response _res{std::pmr::get_default_resource()};
|
|
|
|
Document doc;
|
|
};
|
|
|
|
using namespace testing;
|
|
|
|
TEST_F(CoreHandlerTests, coreShouldSetConnectionErrorOnBrokenConnection) {
|
|
EXPECT_CALL(http, request(_, _))
|
|
.WillOnce(Return(RawHttpResponse{_res}.withTimeoutError()));
|
|
EXPECT_THAT(sut.request("", doc), //
|
|
AllOf(Not(HasValue()), Unexpected(HttpError{})));
|
|
}
|
|
|
|
TEST_F(CoreHandlerTests,
|
|
coreShouldCheckSignatureAndReturnBadSignatureBeforeAnythingElse) {
|
|
EXPECT_CALL(http, request(_, _))
|
|
.WillOnce(Return(RawHttpResponse{_res}
|
|
.initMessage()
|
|
.withBrokenBody()
|
|
.withBrokenSignature()));
|
|
EXPECT_THAT(sut.request("", doc), //
|
|
AllOf(Not(HasValue()), Unexpected(CoreHandlerError{
|
|
CoreHandlerError::BadSigature})));
|
|
}
|
|
|
|
TEST_F(CoreHandlerTests, coreShouldSetBrokenDataWhenResultIsNotAvailable) {
|
|
EXPECT_CALL(http, request(_, _))
|
|
.WillOnce(Return(RawHttpResponse{_res}.initMessage().withBrokenBody()));
|
|
EXPECT_THAT(sut.request("", doc), //
|
|
AllOf(Not(HasValue()), Unexpected(CoreHandlerError{
|
|
CoreHandlerError::BrokenData})));
|
|
}
|
|
|
|
TEST_F(CoreHandlerTests, coreSignatureIsBeingChecked) {
|
|
EXPECT_CALL(http, request(Eq(conf.parameters.apiServer + "/path"), _))
|
|
.WillOnce(Return(RawHttpResponse{_res}.initMessage()));
|
|
EXPECT_THAT(sut.request("/path", doc), //
|
|
AllOf(HasValue(), IsObject(), HasKey("/result/tid")));
|
|
}
|
|
|
|
TEST_F(CoreHandlerTests, onHttpProblemsAccessShouldBeDeniedByDefault) {
|
|
EXPECT_CALL(http, request(_, _))
|
|
.WillOnce(Return(
|
|
RawHttpResponse{_res}.initMessage().withServiceUnavailableError()));
|
|
EXPECT_THAT(sut.request("/path", doc), //
|
|
AllOf(Not(HasValue()), Unexpected(PamDeny{})));
|
|
}
|
|
|
|
TEST_F(CoreHandlerTests, onSuccessfullMessageCoreShouldByFine) {
|
|
EXPECT_CALL(http, request(_, _))
|
|
.WillOnce(
|
|
Return(RawHttpResponse{_res}.authenticationSuccessfullMessage()));
|
|
EXPECT_THAT(sut.request("/path", doc), //
|
|
AllOf(HasValue()));
|
|
}
|
|
|
|
class CoreHandlerWithBypassTests : public testing::Test {
|
|
public:
|
|
CoreHandlerWithBypassTests() : sut{confBypass}, http{sut._http()} {}
|
|
|
|
CoreHandlerTestable sut;
|
|
rublon::Response _res{memory::default_resource()};
|
|
HttpHandlerMock &http;
|
|
};
|
|
|
|
TEST_F(CoreHandlerWithBypassTests,
|
|
onHttpProblemsAccessShouldBeBypassedWhenEnabled) {
|
|
EXPECT_CALL(http, request(_, _))
|
|
.WillOnce(Return(
|
|
RawHttpResponse{_res}.initMessage().withServiceUnavailableError()));
|
|
EXPECT_THAT(sut.request("/path", Document{}), //
|
|
AllOf(Not(HasValue()), Unexpected(PamBaypass{})));
|
|
}
|