annotation-protocol/server/server-manual.html - external/github.com/web-platform-tests/wpt - Git at Google

 <!doctype html>
 <html>
 <head>
 <title>Annotation Protocol Must Tests</title>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/common/utils.js"></script>
 <script type="application/javascript">
 /* globals header, assert_equals, promise_test, assert_true, uuid, assert_regexp_match */

 /* jshint unused: false, strict: false */

 setup( { explicit_timeout: true, explicit_done: true } );

 // just ld+json here as the full profile'd media type is a SHOULD
 var MEDIA_TYPE = 'application/ld+json';
 var MEDIA_TYPE_REGEX = /application\/ld\+json/;
 // a request timeout if there is not one specified in the parent window

 var myTimeout = 5000;

 function request(method, url, headers, content) {
   if (method === undefined) {
     method = "GET";
   }

   return new Promise(function (resolve, reject) {
     var xhr = new XMLHttpRequest();

     // this gets returned when the request completes
     var resp = {
       xhr: xhr,
       headers: null,
       status: 0,
       body: null,
       text: ""
     };

     xhr.open(method, url);

     // headers?
     if (headers !== undefined) {
       headers.forEach(function(ref, idx) {
         xhr.setRequestHeader(ref[0], ref[1]);
       });
     }

     // xhr.timeout = myTimeout;

     xhr.ontimeout = function() {
       resp.timeout = myTimeout;
       resolve(resp);
     };

     xhr.onerror = function() {
       resolve(resp);
     };

     xhr.onload = function () {
       resp.status = this.status;
       if (this.status >= 200 && this.status < 300) {
         var d = xhr.response;
         resp.text = d;
         // we have it; what is it?
         var type = xhr.getResponseHeader('Content-Type');
         if (type) {
           resp.type = type.split(';')[0];
           if (resp.type === MEDIA_TYPE) {
             try {
               d = JSON.parse(d);
               resp.body = d;
             }
             catch(err) {
               resp.body = null;
             }
           }
         } else {
           resp.type = null;
           resp.body = null;
         }

       }
       resolve(resp);
     };

     if (content !== undefined) {
       if ("object" === typeof(content)) {
         xhr.send(JSON.stringify(content));
       } else if ("function" === typeof(content)) {
         xhr.send(content());
       } else if ("string" === typeof(content)) {
         xhr.send(content);
       }
     } else {
       xhr.send();
     }
   });
 }

 function checkBody(res, pat, isRE) {
   if (isRE === undefined) {
     isRE = true;
   }
   if (!res.body) {
     if (isRE) {
       assert_regexp_match("", pat, header + " not found in body");
     } else {
       assert_equals("", pat, header + " not found in body") ;
     }
   } else {
     if (isRE) {
       assert_regexp_match(res.body, pat, pat + " not found in body ");
     } else {
       assert_equals(res.body, pat, pat + " not found in body");
     }
   }
 }

 function checkHeader(res, header, pat, isRE) {
   if (isRE === undefined) {
     isRE = true;
   }
   if (!res.xhr.getResponseHeader(header)) {
     if (isRE) {
       assert_regexp_match("", pat, header + " not found in response");
     } else {
       assert_equals("", pat, header + " not found in response") ;
     }
   } else {
     var val = res.xhr.getResponseHeader(header) ;
     if (isRE) {
       assert_regexp_match(val, pat, pat + " not found in " + header);
     } else {
       assert_equals(val, pat, pat + " not found in " + header);
     }
   }
 }

 /* makePromiseTests
  *
  * thennable   - Promise that when resolved will send data into the test
  * criteria    - Array of assertions
  */

 function makePromiseTests( thennable, criteria ) {
   // loop over the array of criteria
   //
   // create a promise_test for each one
   criteria.forEach(function(ref) {
     promise_test(function() {
       return thennable.then(function(res) {
         if (ref.header !== undefined) {
         // it is a header check
           if (ref.pat !== undefined) {
             checkHeader(res, ref.header, ref.pat, true);
           } else if (ref.string !== undefined) {
             checkHeader(res, ref.header, ref.string, false);
           } else if (ref.test !== undefined) {
             assert_true(ref.test(res));
           }
         } else {
           if (ref.pat !== undefined) {
             checkBody(res, ref.pat, true);
           } else if (ref.string !== undefined) {
             checkBody(res, ref.string, false);
           } else if (ref.test !== undefined) {
             assert_true(ref.test(res));
           }
         }
       });
     }, ref.assertion);
   });
 }

 function runTests( container_url, annotation_url ) {
   // trim whitespace from incoming variables
   container_url = container_url.trim();
   annotation_url = annotation_url.trim();

   // Section 4 has a requirement that the URL end in a slash, so...
   // ensure the url has a length
   test(function() {
     assert_regexp_match(container_url, /\/$/, 'Container URL did not end in a "/" character');
   }, 'Container MUST end in a "/" character');

   // Container tests
   var theContainer = request("GET", container_url);

   makePromiseTests( theContainer, [
       { header: 'Allow', pat: /GET/, assertion: "Containers MUST support GET (check Allow on GET)" },
       { header: 'Allow', pat: /HEAD/, assertion: "Containers MUST support HEAD (check Allow on GET)" },
       { header: 'Allow', pat: /OPTIONS/, assertion: "Containers MUST support OPTIONS (check Allow on GET)" },
       { header: 'Content-Type', pat: MEDIA_TYPE_REGEX, assertion: 'Containers MUST have a Content-Type header with the application/ld+json media type'},
       { header: 'Content-Type', pat: MEDIA_TYPE_REGEX, assertion: 'Containers MUST response with the JSON-LD representation (by default)'},
       { test: function(res) { return ( 'type' in res.body && res.body.type.indexOf('BasicContainer') > -1 ); }, assertion: 'Containers MUST return a description of the container with BasicContainer' },
       { test: function(res) { return ( 'type' in res.body && res.body.type.indexOf('AnnotationCollection') > -1 ); }, assertion: 'Containers MUST return a description of the container with AnnotationCollection' },
       { header: 'Link', pat: /(.*)/, assertion: 'Containers MUST return a Link header (rfc5988) on all responses' },
       { header: 'ETag', pat: /(.*)/, assertion: 'Containers MUST have an ETag header'},
       { header: 'Vary', pat: /Accept/, assertion: 'Containers MUST have a Vary header with Accept in the value'},
       { header: 'Link', pat: /rel\=\"type\"|\/ns\/ldp#|Container/, assertion: 'Containers MUST advertise its type by including a link where the rel parameter value is type and the target IRI is the appropriate Container Type'},
       { header: 'Link', pat: /rel\=\"type\"|\/ns\/ldp#|Container/,
         assertion: 'Containers MUST advertise that it imposes Annotation protocol specific' +
                    ' constraints by including a link where the target IRI is' +
                    ' http://www.w3.org/TR/annotation-protocol/, and the rel parameter' +
                    ' value is the IRI http://www.w3.org/ns/ldp#constrainedBy'},
   ] );


   promise_test(function() {
       return request("HEAD", container_url).then(function(res) {
           assert_equals(res.status, 200, "HEAD request returned " + res.status);
           });
       }, "Containers MUST support HEAD method");

   promise_test(function() {
       return request("OPTIONS", container_url).then(function(res) {
           assert_equals(res.status, 200, "OPTIONS request returned " + res.status);
           });
       }, "Containers MUST support OPTIONS method");

   // Container representation tests


   makePromiseTests( theContainer, [
       { header: 'Content-Location', pat: /(.*)/, assertion: "Containers MUST include a Content-Location header with the IRI as its value" },
       { header: 'Content-Location', test: function(res) { if (res.xhr.getResponseHeader('content-location') === res.body.id ) { return true; } else { return false;} }, assertion: "Container's Content-Location and `id` MUST match" }
       ]);

   promise_test(function() {
     return theContainer.then(function(res) {
       var f = res.body.first;
       if (f !== undefined && f !== "") {
         request("GET", f).then(function(lres) {
           assert_true(('partOf' in lres.body) || ('id' in lres.body.partOf), "No partOf in response");
           });
       } else {
         assert_true(false, "no 'first' in response from Container");
       }
     });
   }, "Annotation Pages must have a link to the container they are part of, using the partOf property");

   promise_test(function() {
     return theContainer.then(function(res) {
       var l = res.body.last;
       request("GET", l).then(function(lres) {
         assert_true(('prev' in lres.body), "No link to the previous page in response");
         });
     });
   }, "Annotation Pages MUST have a link to the previous page in the sequence, using the prev property (if not the first page)");

   promise_test(function() {
     return theContainer.then(function(res) {
       var f = res.body.first;
       request("GET", f).then(function(lres) {
         assert_true(('next' in lres.body), "No link to the next page in response");
         });
     });
   }, "Annotation Pages MUST have a link to the next page in the sequence, using the next property (if not the last page)");

   // Annotation Tests
   var theRequest = request("GET", annotation_url);

   makePromiseTests( theRequest, [
       { header: 'Allow', pat: /GET/, assertion: "Annotations MUST support GET (check Allow on GET)" },
       { header: 'Allow', pat: /HEAD/, assertion: "Annotations MUST support HEAD (check Allow on GET)" },
       { header: 'Allow', pat: /OPTIONS/, assertion: "Annotations MUST support OPTIONS (check Allow on GET)" },
       { header: 'Content-Type', pat: MEDIA_TYPE_REGEX, assertion: 'Annotations MUST have a Content-Type header with the application/ld+json media type'},
       { header: 'Link', string: '<http://www.w3.org/ns/ldp#Resource>; rel="type"', assertion: 'Annotations MUST have a Link header entry where the target IRI is http://www.w3.org/ns/ldp#Resource and the rel parameter value is type'},
       { header: 'ETag', pat: /(.*)/, assertion: 'Annotations MUST have an ETag header'},
       { header: 'Vary', pat: /Accept/, assertion: 'Annotations MUST have a Vary header with Accept in the value'},
       ] );

   promise_test(function() {
     return request("HEAD", annotation_url).then(function(res) {
       assert_equals(res.status, 200, "HEAD request returned " + res.status);
       });
     }, "Annotations MUST support HEAD method");

   promise_test(function() {
     return request("OPTIONS", annotation_url).then(function(res) {
         assert_equals(res.status, 200, "OPTIONS request returned " + res.status);
       });
     }, "Annotations MUST support OPTIONS method");


   // creation and deletion tests

   var theAnnotation = {
     "@context": "http://www.w3.org/ns/anno.jsonld",
     "type": "Annotation",
     "body": {
       "type": "TextualBody",
       "value": "I like this page!"
     },
     "target": "http://www.example.com/index.html",
     "canonical": 'urn:uuid:' + token()
   };

   var theCreation = request("POST", container_url, [ [ 'Content-Type', MEDIA_TYPE ] ], theAnnotation);

   makePromiseTests( theCreation, [
       { test: function(res) { return ('id' in res.body); }, assertion: "Created Annotation MUST have an id property" },
       { test: function(res) { return (('id' in res.body) && (res.body.id.search(container_url) > -1));}, assertion: "Created Annotation MUST have an id that starts with the Container IRI" },
       { test: function(res) { return ( 'canonical' in res.body && res.body.canonical === theAnnotation.canonical ); }, assertion: "Created Annotation MUST preserve any canonical IRI" },
       { test: function(res) { return ( res.status === 201 ) ; }, assertion: "Annotation Server MUST respond with a 201 Created code if the creation is successful" },
       { header: "Location", test: function(res) { return res.body.id === res.xhr.getResponseHeader('location') ; } , assertion: "Location header SHOULD match the id of the new Annotation" },
       ]);

   promise_test(function() {
     return theCreation.then(function(res) {
       var newAnnotation = res.body ;
       newAnnotation.target = "http://other.example/";
       return request("PUT", res.body.id, [['Content-Type', MEDIA_TYPE]], newAnnotation)
         .then(function(lres) {
           assert_equals(lres.body.target, newAnnotation.target, "Annotation did not update");
         })
         .catch(function(err) {
           assert_true(false, "Update of annotation failed");
         });
     });
   }, "Annotation update must be done with the PUT method");

   promise_test(function() {
     return theCreation.then(function(res) {
       request("DELETE", res.body.id)
         .then(function(lres) {
           assert_equals(lres.status, 204, "DELETE of " + res.body.id + " did not return a 204 Status" );
         });
     });
   }, "Annotation deletion with DELETE method MUST return a 204 status" );

   // SHOULD tests

   test(function() {
     assert_equals(container_url.toLowerCase().substr(0,5), "https", "Server is not using HTTPS");
     }, "Annotation server SHOULD use HTTPS rather than HTTP");

   var thePrefRequest = request("GET", container_url,
       [['Prefer', 'return=representation;include="http://www.w3.org/ns/ldp#PreferMinimalContainer"']]);

   promise_test(function() {
     return thePrefRequest
       .then(function(res) {
         var f = res.body.first;
         request("GET", f).then(function(fres) {
           fres.body.items.forEach(function(item) {
             assert_true('@context' in item, "Annotation does not contain `@context`");
             });
           });
         });
       }, "SHOULD return the full annotation descriptions");


   makePromiseTests( thePrefRequest, [
       { test: function(res) { return ('total' in res.body); }, assertion: "SHOULD include the total property with the total number of annotations in the container" },
       { test: function(res) { return ('first' in res.body); }, assertion: "SHOULD have a link to the first page of its contents using `first`" },
       { test: function(res) { return ('last' in res.body); }, assertion: "SHOULD have a link to the last page of its contents using `last`" },
       { test: function(res) { return (!('items' in res.body)); }, assertion: "Response contains annotations via `items` when it SHOULD NOT"},
       { test: function(res) { return (!('ldp:contains' in res.body)); }, assertion: "Response contains annotations via `ldp:contains` when it SHOULD NOT" },
       { header: 'Vary', pat: /Prefer/, assertion: "SHOULD include Prefer in the Vary header" }
     ]);

   promise_test(function() {
     return thePrefRequest
       .then(function(res) {
         var h = res.xhr.getResponseHeader('Prefer');
         assert_equals(h, null, "Reponse contains the `Prefer` header when it SHOULD NOT");
         });
       }, 'SHOULD NOT [receive] the Prefer header when requesting the page');

 }

 // set up an event handler one the document is loaded that will run the tests once we
 // have a URI to run against
 on_event(document, "DOMContentLoaded", function() {
     var serverURI = document.getElementById("uri") ;
     var annotationURI = document.getElementById("annotation") ;
     var runButton = document.getElementById("endpoint-submit-button") ;
     on_event(runButton, "click", function() {
         // user clicked
         var URI = serverURI.value;
         var ANN = annotationURI.value;
         runButton.disabled = true;

         // okay, they clicked.  run the tests with that URI
         runTests(URI, ANN);
         done();
         });
     });
 </script>
 </head>
 <body>
 <p>The scripts associated with this test will exercise all of the MUST and SHOULD requirements
 for an Annotation Protocol server implementation.  In order to do so, the server must have
 its CORS settings configured such that your test machine can access the annotations and containers
 and such that it can get certain information from the headers.  In particular, the container and
 annotations within the container
 under test must permit access to the Allow, Content-Location, Content-Type, ETag, Link, Location, Prefer, and Vary headers.
 Correct CORS access can be achieved with headers like:</p>
 <pre>
 Access-Control-Allow-Headers: Content-Type, Prefer
 Access-Control-Allow-Methods: GET,HEAD,OPTIONS,DELETE,PUT
 Access-Control-Allow-Origin: *
 Access-Control-Expose-Headers: ETag, Allow, Vary, Link, Content-Type, Location, Content-Location, Prefer
 </pre>
 <p>Provide endpoint and annotation URIs and select "Go" to start testing.</p>
 <form name="endpoint">
   <p><label for="uri">Endpoint URI:</label> <input type="text" size="50" id="uri" name="uri"></p>
   <p><label for="uri">Annotation URI:</label> <input type="text" size="50" id="annotation" name="annotation"></p>
   <input type="button" id="endpoint-submit-button" value="Go">
 </form>
 </body>
 </html>
	<!doctype html>
	<html>
	<head>
	<title>Annotation Protocol Must Tests</title>
	<script src="/resources/testharness.js"></script>
	<script src="/resources/testharnessreport.js"></script>
	<script src="/common/utils.js"></script>
	<script type="application/javascript">
	/* globals header, assert_equals, promise_test, assert_true, uuid, assert_regexp_match */

	/* jshint unused: false, strict: false */

	setup( { explicit_timeout: true, explicit_done: true } );

	// just ld+json here as the full profile'd media type is a SHOULD
	var MEDIA_TYPE = 'application/ld+json';
	var MEDIA_TYPE_REGEX = /application\/ld\+json/;
	// a request timeout if there is not one specified in the parent window

	var myTimeout = 5000;

	function request(method, url, headers, content) {
	if (method === undefined) {
	method = "GET";
	}

	return new Promise(function (resolve, reject) {
	var xhr = new XMLHttpRequest();

	// this gets returned when the request completes
	var resp = {
	xhr: xhr,
	headers: null,
	status: 0,
	body: null,
	text: ""
	};

	xhr.open(method, url);

	// headers?
	if (headers !== undefined) {
	headers.forEach(function(ref, idx) {
	xhr.setRequestHeader(ref[0], ref[1]);
	});
	}

	// xhr.timeout = myTimeout;

	xhr.ontimeout = function() {
	resp.timeout = myTimeout;
	resolve(resp);
	};

	xhr.onerror = function() {
	resolve(resp);
	};

	xhr.onload = function () {
	resp.status = this.status;
	if (this.status >= 200 && this.status < 300) {
	var d = xhr.response;
	resp.text = d;
	// we have it; what is it?
	var type = xhr.getResponseHeader('Content-Type');
	if (type) {
	resp.type = type.split(';')[0];
	if (resp.type === MEDIA_TYPE) {
	try {
	d = JSON.parse(d);
	resp.body = d;
	}
	catch(err) {
	resp.body = null;
	}
	}
	} else {
	resp.type = null;
	resp.body = null;
	}

	}
	resolve(resp);
	};

	if (content !== undefined) {
	if ("object" === typeof(content)) {
	xhr.send(JSON.stringify(content));
	} else if ("function" === typeof(content)) {
	xhr.send(content());
	} else if ("string" === typeof(content)) {
	xhr.send(content);
	}
	} else {
	xhr.send();
	}
	});
	}

	function checkBody(res, pat, isRE) {
	if (isRE === undefined) {
	isRE = true;
	}
	if (!res.body) {
	if (isRE) {
	assert_regexp_match("", pat, header + " not found in body");
	} else {
	assert_equals("", pat, header + " not found in body") ;
	}
	} else {
	if (isRE) {
	assert_regexp_match(res.body, pat, pat + " not found in body ");
	} else {
	assert_equals(res.body, pat, pat + " not found in body");
	}
	}
	}

	function checkHeader(res, header, pat, isRE) {
	if (isRE === undefined) {
	isRE = true;
	}
	if (!res.xhr.getResponseHeader(header)) {
	if (isRE) {
	assert_regexp_match("", pat, header + " not found in response");
	} else {
	assert_equals("", pat, header + " not found in response") ;
	}
	} else {
	var val = res.xhr.getResponseHeader(header) ;
	if (isRE) {
	assert_regexp_match(val, pat, pat + " not found in " + header);
	} else {
	assert_equals(val, pat, pat + " not found in " + header);
	}
	}
	}

	/* makePromiseTests
	*
	* thennable - Promise that when resolved will send data into the test
	* criteria - Array of assertions
	*/

	function makePromiseTests( thennable, criteria ) {
	// loop over the array of criteria
	//
	// create a promise_test for each one
	criteria.forEach(function(ref) {
	promise_test(function() {
	return thennable.then(function(res) {
	if (ref.header !== undefined) {
	// it is a header check
	if (ref.pat !== undefined) {
	checkHeader(res, ref.header, ref.pat, true);
	} else if (ref.string !== undefined) {
	checkHeader(res, ref.header, ref.string, false);
	} else if (ref.test !== undefined) {
	assert_true(ref.test(res));
	}
	} else {
	if (ref.pat !== undefined) {
	checkBody(res, ref.pat, true);
	} else if (ref.string !== undefined) {
	checkBody(res, ref.string, false);
	} else if (ref.test !== undefined) {
	assert_true(ref.test(res));
	}
	}
	});
	}, ref.assertion);
	});
	}

	function runTests( container_url, annotation_url ) {
	// trim whitespace from incoming variables
	container_url = container_url.trim();
	annotation_url = annotation_url.trim();

	// Section 4 has a requirement that the URL end in a slash, so...
	// ensure the url has a length
	test(function() {
	assert_regexp_match(container_url, /\/$/, 'Container URL did not end in a "/" character');
	}, 'Container MUST end in a "/" character');

	// Container tests
	var theContainer = request("GET", container_url);

	makePromiseTests( theContainer, [
	{ header: 'Allow', pat: /GET/, assertion: "Containers MUST support GET (check Allow on GET)" },
	{ header: 'Allow', pat: /HEAD/, assertion: "Containers MUST support HEAD (check Allow on GET)" },
	{ header: 'Allow', pat: /OPTIONS/, assertion: "Containers MUST support OPTIONS (check Allow on GET)" },
	{ header: 'Content-Type', pat: MEDIA_TYPE_REGEX, assertion: 'Containers MUST have a Content-Type header with the application/ld+json media type'},
	{ header: 'Content-Type', pat: MEDIA_TYPE_REGEX, assertion: 'Containers MUST response with the JSON-LD representation (by default)'},
	{ test: function(res) { return ( 'type' in res.body && res.body.type.indexOf('BasicContainer') > -1 ); }, assertion: 'Containers MUST return a description of the container with BasicContainer' },
	{ test: function(res) { return ( 'type' in res.body && res.body.type.indexOf('AnnotationCollection') > -1 ); }, assertion: 'Containers MUST return a description of the container with AnnotationCollection' },
	{ header: 'Link', pat: /(.*)/, assertion: 'Containers MUST return a Link header (rfc5988) on all responses' },
	{ header: 'ETag', pat: /(.*)/, assertion: 'Containers MUST have an ETag header'},
	{ header: 'Vary', pat: /Accept/, assertion: 'Containers MUST have a Vary header with Accept in the value'},
	{ header: 'Link', pat: /rel\=\"type\"\|\/ns\/ldp#\|Container/, assertion: 'Containers MUST advertise its type by including a link where the rel parameter value is type and the target IRI is the appropriate Container Type'},
	{ header: 'Link', pat: /rel\=\"type\"\|\/ns\/ldp#\|Container/,
	assertion: 'Containers MUST advertise that it imposes Annotation protocol specific' +
	' constraints by including a link where the target IRI is' +
	' http://www.w3.org/TR/annotation-protocol/, and the rel parameter' +
	' value is the IRI http://www.w3.org/ns/ldp#constrainedBy'},
	] );


	promise_test(function() {
	return request("HEAD", container_url).then(function(res) {
	assert_equals(res.status, 200, "HEAD request returned " + res.status);
	});
	}, "Containers MUST support HEAD method");

	promise_test(function() {
	return request("OPTIONS", container_url).then(function(res) {
	assert_equals(res.status, 200, "OPTIONS request returned " + res.status);
	});
	}, "Containers MUST support OPTIONS method");

	// Container representation tests


	makePromiseTests( theContainer, [
	{ header: 'Content-Location', pat: /(.*)/, assertion: "Containers MUST include a Content-Location header with the IRI as its value" },
	{ header: 'Content-Location', test: function(res) { if (res.xhr.getResponseHeader('content-location') === res.body.id ) { return true; } else { return false;} }, assertion: "Container's Content-Location and `id` MUST match" }
	]);

	promise_test(function() {
	return theContainer.then(function(res) {
	var f = res.body.first;
	if (f !== undefined && f !== "") {
	request("GET", f).then(function(lres) {
	assert_true(('partOf' in lres.body) \|\| ('id' in lres.body.partOf), "No partOf in response");
	});
	} else {
	assert_true(false, "no 'first' in response from Container");
	}
	});
	}, "Annotation Pages must have a link to the container they are part of, using the partOf property");

	promise_test(function() {
	return theContainer.then(function(res) {
	var l = res.body.last;
	request("GET", l).then(function(lres) {
	assert_true(('prev' in lres.body), "No link to the previous page in response");
	});
	});
	}, "Annotation Pages MUST have a link to the previous page in the sequence, using the prev property (if not the first page)");

	promise_test(function() {
	return theContainer.then(function(res) {
	var f = res.body.first;
	request("GET", f).then(function(lres) {
	assert_true(('next' in lres.body), "No link to the next page in response");
	});
	});
	}, "Annotation Pages MUST have a link to the next page in the sequence, using the next property (if not the last page)");

	// Annotation Tests
	var theRequest = request("GET", annotation_url);

	makePromiseTests( theRequest, [
	{ header: 'Allow', pat: /GET/, assertion: "Annotations MUST support GET (check Allow on GET)" },
	{ header: 'Allow', pat: /HEAD/, assertion: "Annotations MUST support HEAD (check Allow on GET)" },
	{ header: 'Allow', pat: /OPTIONS/, assertion: "Annotations MUST support OPTIONS (check Allow on GET)" },
	{ header: 'Content-Type', pat: MEDIA_TYPE_REGEX, assertion: 'Annotations MUST have a Content-Type header with the application/ld+json media type'},
	{ header: 'Link', string: '<http://www.w3.org/ns/ldp#Resource>; rel="type"', assertion: 'Annotations MUST have a Link header entry where the target IRI is http://www.w3.org/ns/ldp#Resource and the rel parameter value is type'},
	{ header: 'ETag', pat: /(.*)/, assertion: 'Annotations MUST have an ETag header'},
	{ header: 'Vary', pat: /Accept/, assertion: 'Annotations MUST have a Vary header with Accept in the value'},
	] );

	promise_test(function() {
	return request("HEAD", annotation_url).then(function(res) {
	assert_equals(res.status, 200, "HEAD request returned " + res.status);
	});
	}, "Annotations MUST support HEAD method");

	promise_test(function() {
	return request("OPTIONS", annotation_url).then(function(res) {
	assert_equals(res.status, 200, "OPTIONS request returned " + res.status);
	});
	}, "Annotations MUST support OPTIONS method");


	// creation and deletion tests

	var theAnnotation = {
	"@context": "http://www.w3.org/ns/anno.jsonld",
	"type": "Annotation",
	"body": {
	"type": "TextualBody",
	"value": "I like this page!"
	},
	"target": "http://www.example.com/index.html",
	"canonical": 'urn:uuid:' + token()
	};

	var theCreation = request("POST", container_url, [ [ 'Content-Type', MEDIA_TYPE ] ], theAnnotation);

	makePromiseTests( theCreation, [
	{ test: function(res) { return ('id' in res.body); }, assertion: "Created Annotation MUST have an id property" },
	{ test: function(res) { return (('id' in res.body) && (res.body.id.search(container_url) > -1));}, assertion: "Created Annotation MUST have an id that starts with the Container IRI" },
	{ test: function(res) { return ( 'canonical' in res.body && res.body.canonical === theAnnotation.canonical ); }, assertion: "Created Annotation MUST preserve any canonical IRI" },
	{ test: function(res) { return ( res.status === 201 ) ; }, assertion: "Annotation Server MUST respond with a 201 Created code if the creation is successful" },
	{ header: "Location", test: function(res) { return res.body.id === res.xhr.getResponseHeader('location') ; } , assertion: "Location header SHOULD match the id of the new Annotation" },
	]);

	promise_test(function() {
	return theCreation.then(function(res) {
	var newAnnotation = res.body ;
	newAnnotation.target = "http://other.example/";
	return request("PUT", res.body.id, [['Content-Type', MEDIA_TYPE]], newAnnotation)
	.then(function(lres) {
	assert_equals(lres.body.target, newAnnotation.target, "Annotation did not update");
	})
	.catch(function(err) {
	assert_true(false, "Update of annotation failed");
	});
	});
	}, "Annotation update must be done with the PUT method");

	promise_test(function() {
	return theCreation.then(function(res) {
	request("DELETE", res.body.id)
	.then(function(lres) {
	assert_equals(lres.status, 204, "DELETE of " + res.body.id + " did not return a 204 Status" );
	});
	});
	}, "Annotation deletion with DELETE method MUST return a 204 status" );

	// SHOULD tests

	test(function() {
	assert_equals(container_url.toLowerCase().substr(0,5), "https", "Server is not using HTTPS");
	}, "Annotation server SHOULD use HTTPS rather than HTTP");

	var thePrefRequest = request("GET", container_url,
	[['Prefer', 'return=representation;include="http://www.w3.org/ns/ldp#PreferMinimalContainer"']]);

	promise_test(function() {
	return thePrefRequest
	.then(function(res) {
	var f = res.body.first;
	request("GET", f).then(function(fres) {
	fres.body.items.forEach(function(item) {
	assert_true('@context' in item, "Annotation does not contain `@context`");
	});
	});
	});
	}, "SHOULD return the full annotation descriptions");


	makePromiseTests( thePrefRequest, [
	{ test: function(res) { return ('total' in res.body); }, assertion: "SHOULD include the total property with the total number of annotations in the container" },
	{ test: function(res) { return ('first' in res.body); }, assertion: "SHOULD have a link to the first page of its contents using `first`" },
	{ test: function(res) { return ('last' in res.body); }, assertion: "SHOULD have a link to the last page of its contents using `last`" },
	{ test: function(res) { return (!('items' in res.body)); }, assertion: "Response contains annotations via `items` when it SHOULD NOT"},
	{ test: function(res) { return (!('ldp:contains' in res.body)); }, assertion: "Response contains annotations via `ldp:contains` when it SHOULD NOT" },
	{ header: 'Vary', pat: /Prefer/, assertion: "SHOULD include Prefer in the Vary header" }
	]);

	promise_test(function() {
	return thePrefRequest
	.then(function(res) {
	var h = res.xhr.getResponseHeader('Prefer');
	assert_equals(h, null, "Reponse contains the `Prefer` header when it SHOULD NOT");
	});
	}, 'SHOULD NOT [receive] the Prefer header when requesting the page');

	}

	// set up an event handler one the document is loaded that will run the tests once we
	// have a URI to run against
	on_event(document, "DOMContentLoaded", function() {
	var serverURI = document.getElementById("uri") ;
	var annotationURI = document.getElementById("annotation") ;
	var runButton = document.getElementById("endpoint-submit-button") ;
	on_event(runButton, "click", function() {
	// user clicked
	var URI = serverURI.value;
	var ANN = annotationURI.value;
	runButton.disabled = true;

	// okay, they clicked. run the tests with that URI
	runTests(URI, ANN);
	done();
	});
	});
	</script>
	</head>
	<body>
	<p>The scripts associated with this test will exercise all of the MUST and SHOULD requirements
	for an Annotation Protocol server implementation. In order to do so, the server must have
	its CORS settings configured such that your test machine can access the annotations and containers
	and such that it can get certain information from the headers. In particular, the container and
	annotations within the container
	under test must permit access to the Allow, Content-Location, Content-Type, ETag, Link, Location, Prefer, and Vary headers.
	Correct CORS access can be achieved with headers like:</p>
	<pre>
	Access-Control-Allow-Headers: Content-Type, Prefer
	Access-Control-Allow-Methods: GET,HEAD,OPTIONS,DELETE,PUT
	Access-Control-Allow-Origin: *
	Access-Control-Expose-Headers: ETag, Allow, Vary, Link, Content-Type, Location, Content-Location, Prefer
	</pre>
	<p>Provide endpoint and annotation URIs and select "Go" to start testing.</p>
	<form name="endpoint">
	<p><label for="uri">Endpoint URI:</label> <input type="text" size="50" id="uri" name="uri"></p>
	<p><label for="uri">Annotation URI:</label> <input type="text" size="50" id="annotation" name="annotation"></p>
	<input type="button" id="endpoint-submit-button" value="Go">
	</form>
	</body>
	</html>