#include <fstream>
#include <saml/exceptions.h>
-#include <saml/SAMLConfig.h>
#include <saml/util/SAMLConstants.h>
#include <xmltooling/XMLObject.h>
#include <xmltooling/XMLObjectBuilder.h>
+#include <xmltooling/XMLToolingConfig.h>
+#include <xmltooling/validation/Validator.h>
using namespace opensaml;
using namespace xmltooling;
}
}
- void assertEquals(const char* failMessage, DOMDocument* expectedDOM, XMLObject* xmlObject) {
- DOMElement* generatedDOM = xmlObject->marshall();
+ void assertEquals(const char* failMessage, DOMDocument* expectedDOM, XMLObject* xmlObject, bool canMarshall=true) {
+ DOMElement* generatedDOM = xmlObject->getDOM();
+ if (!generatedDOM) {
+ if (!canMarshall) {
+ TSM_ASSERT("DOM not available", false);
+ }
+ else {
+ generatedDOM = xmlObject->marshall();
+ }
+ }
if (!generatedDOM->isEqualNode(expectedDOM->getDocumentElement())) {
string buf;
XMLHelper::serialize(generatedDOM, buf);
}
}
- void assertEquals(DOMDocument* expectedDOM, XMLObject* xmlObject) {
- assertEquals("Marshalled DOM was not the same as the expected DOM", expectedDOM, xmlObject);
+ void assertEquals(DOMDocument* expectedDOM, XMLObject* xmlObject, bool canMarshall=true) {
+ assertEquals("Marshalled DOM was not the same as the expected DOM", expectedDOM, xmlObject, canMarshall);
delete xmlObject;
}
+ void assertEquals(const char* failMessage, const XMLCh* expectedString, const XMLCh* testString) {
+ char* buf = NULL;
+ if (!XMLString::equals(expectedString, testString)) {
+ buf = XMLString::transcode(testString);
+ TS_TRACE(buf ? buf : "(NULL)");
+ XMLString::release(&buf);
+ buf = XMLString::transcode(expectedString);
+ TS_TRACE(buf ? buf : "(NULL)");
+ XMLString::release(&buf);
+ TSM_ASSERT(failMessage, false);
+ }
+ }
+
public:
void setUp() {
ParserPool& p=XMLToolingConfig::getConfig().getParser();
if (expectedChildElementsDOM) expectedChildElementsDOM->release();
}
};
+
+class SAMLObjectValidatorBaseTestCase : virtual public SAMLObjectBaseTestCase {
+
+ public:
+ SAMLObjectValidatorBaseTestCase() : target(NULL), targetQName(NULL), builder(NULL), validator(NULL) {}
+
+ virtual ~SAMLObjectValidatorBaseTestCase() {
+ delete validator;
+ }
+
+ protected:
+ /** The primary XMLObject which will be the target of a given test run */
+ XMLObject* target;
+
+ /** QName of the object to be tested */
+ QName targetQName;
+
+ /** Builder for XMLObjects of type targetQName */
+ const XMLObjectBuilder* builder;
+
+ /** Validator for the type corresponding to the test target */
+ Validator* validator;
+
+ /** Subclasses should override to populate required elements and attributes */
+ virtual void populateRequiredData() { }
+
+ /**
+ * Asserts that the validation of default test XMLObject target
+ * was successful, as expected.
+ *
+ * @param message
+ */
+ void assertValidationPass(const char* message) {
+ assertValidationPass(message, target);
+ }
+
+ /**
+ * Asserts that the validation of the specified XMLObject target
+ * was successful, as expected.
+ *
+ * @param message
+ * @param validateTarget
+ */
+ void assertValidationPass(const char* message, XMLObject* validateTarget) {
+ try {
+ validator->validate(validateTarget);
+ } catch (ValidationException &e) {
+ TS_TRACE(message);
+ TS_TRACE("Expected success, but validation failure raised following ValidationException: ");
+ TS_FAIL(e.getMessage());
+ }
+ }
+
+ /**
+ * Asserts that the validation of the default test XMLObject target
+ * failed, as expected.
+ *
+ * @param message
+ */
+ void assertValidationFail(const char* message) {
+ assertValidationFail(message, target);
+ }
+
+ /**
+ * Asserts that the validation of the specified XMLObject target
+ * failed, as expected.
+ *
+ * @param message
+ * @param validateTarget
+ */
+ void assertValidationFail(const char* message, XMLObject* validateTarget) {
+ try {
+ validator->validate(validateTarget);
+ TS_TRACE(message);
+ TS_FAIL("Validation success, expected failure to raise ValidationException");
+ } catch (ValidationException&) {
+ }
+ }
+
+ /**
+ * Build an XMLObject based on the specified QName
+ *
+ * @param targetQName QName of the type of object to build
+ * @returns new XMLObject of type targetQName
+ */
+ XMLObject* buildXMLObject(QName &targetQName) {
+ // Create the builder on the first request only, for efficiency
+ if (builder == NULL) {
+ builder = XMLObjectBuilder::getBuilder(targetQName);
+ TSM_ASSERT("Unable to retrieve builder for object QName: " + targetQName.toString(), builder!=NULL);
+ }
+ return builder->buildObject(targetQName.getNamespaceURI(), targetQName.getLocalPart(), targetQName.getPrefix());
+
+ }
+
+ public:
+
+ void setUp() {
+ SAMLObjectBaseTestCase::setUp();
+
+ TSM_ASSERT("targetQName was empty", targetQName.hasLocalPart());
+
+ TSM_ASSERT("validator was null", validator!=NULL);
+
+ target = buildXMLObject(targetQName);
+ TSM_ASSERT("XMLObject target was NULL", target!=NULL);
+ populateRequiredData();
+ }
+
+ void tearDown() {
+ delete target;
+ target=NULL;
+ SAMLObjectBaseTestCase::tearDown();
+ }
+
+};
+