Add tests for MSC2716 and backfilling history

README.md

@@ -1,7 +1,19 @@
+[![Complement Dev](https://img.shields.io/matrix/complement:matrix.org.svg?label=%23complement%3Amatrix.org&logo=matrix&server_fqdn=matrix.org)](https://matrix.to/#/#complement:matrix.org)
+
 ### Complement
 
 Complement is a black box integration testing framework for Matrix homeservers.
 
+
+## adsf
+
+To get started developing, see https://github.com/matrix-org/complement/blob/master/ONBOARDING.md
+
+If you're looking to run Complement against a local dev instance of Synapse, see [`matrix-org/synapse` -> `scripts-dev/complement.sh`](https://github.com/matrix-org/synapse/blob/develop/scripts-dev/complement.sh)
+
+If you want to develop Complement tests while working on a local dev instance of Synapse, edit `scripts-dev/complement.sh` to point to your local Complement checkout.
+
+
 #### Running
 
 You need to have Go and Docker installed. Then:

internal/b/blueprints.go

@@ -69,10 +69,12 @@ type Room struct {
 }
 
 type Event struct {
-	Type     string
-	Sender   string
-	StateKey *string
-	Content  map[string]interface{}
+	Type           string
+	Sender         string
+	OriginServerTS uint64
+	StateKey       *string
+	PrevEvents     []string
+	Content        map[string]interface{}
 	// This field is ignored in blueprints as clients are unable to set it. Used with federation.Server
 	Unsigned map[string]interface{}
 }

internal/client/client.go

@@ -84,18 +84,40 @@ func (c *CSAPI) JoinRoom(t *testing.T, roomIDOrAlias string, serverNames []strin
 	return GetJSONFieldStr(t, body, "room_id")
 }
 
-// SendEventSynced sends `e` into the room and waits for its event ID to come down /sync.
-// Returns the event ID of the sent event.
-func (c *CSAPI) SendEventSynced(t *testing.T, roomID string, e b.Event) string {
+func (c *CSAPI) SendEvent(t *testing.T, roomID string, e b.Event) string {
 	t.Helper()
 	c.txnID++
 	paths := []string{"_matrix", "client", "r0", "rooms", roomID, "send", e.Type, strconv.Itoa(c.txnID)}
 	if e.StateKey != nil {
 		paths = []string{"_matrix", "client", "r0", "rooms", roomID, "state", e.Type, *e.StateKey}
 	}
-	res := c.MustDo(t, "PUT", paths, e.Content)
+
+	query := make(url.Values, len(e.PrevEvents))
+	for _, prevEvent := range e.PrevEvents {
+		query.Add("prev_event", prevEvent)
+	}
+
+	if e.OriginServerTS != 0 {
+		query.Add("ts", strconv.FormatUint(e.OriginServerTS, 10))
+	}
+
+	b, err := json.Marshal(e.Content)
+	if err != nil {
+		t.Fatalf("CSAPI.Do failed to marshal JSON body: %s", err)
+	}
+
+	res := c.MustDoRaw(t, "PUT", paths, b, "application/json", query)
 	body := ParseJSON(t, res)
 	eventID := GetJSONFieldStr(t, body, "event_id")
+
+	return eventID
+}
+
+// SendEventSynced sends `e` into the room and waits for its event ID to come down /sync.
+// Returns the event ID of the sent event.
+func (c *CSAPI) SendEventSynced(t *testing.T, roomID string, e b.Event) string {
+	t.Helper()
+	eventID := c.SendEvent(t, roomID, e)
 	t.Logf("SendEventSynced waiting for event ID %s", eventID)
 	c.SyncUntilTimelineHas(t, roomID, func(r gjson.Result) bool {
 		return r.Get("event_id").Str == eventID

internal/docker/deployment.go

@@ -30,7 +30,12 @@ type HomeserverDeployment struct {
 // will print container logs before killing the container.
 func (d *Deployment) Destroy(t *testing.T) {
 	t.Helper()
-	d.Deployer.Destroy(d, t.Failed())
+	d.Deployer.Destroy(
+		d,
+		// TODO: Revert this back to `t.Failed()`.
+		// I did this so I can always see the homersever logs regardless of outcome
+		true,
+	)
 }
 
 // Client returns a CSAPI client targeting the given hsName, using the access token for the given userID.

tests/msc2716_test.go

@@ -0,0 +1,148 @@
+// +build msc2716
+
+// This file contains tests for incrementally importing history to an existing room,
+// a currently experimental feature defined by MSC2716, which you can read here:
+// https://github.com/matrix-org/matrix-doc/pull/2716
+
+package tests
+
+import (
+	"net/url"
+	"testing"
+	"time"
+
+	"github.com/matrix-org/complement/internal/b"
+	"github.com/matrix-org/complement/internal/client"
+	"github.com/matrix-org/complement/internal/must"
+	"github.com/sirupsen/logrus"
+	"github.com/tidwall/gjson"
+)
+
+// Test that the m.room.create and m.room.member events for a room we created comes down /sync
+func TestBackfillingHistory(t *testing.T) {
+	deployment := Deploy(t, "rooms_state", b.BlueprintAlice)
+	defer deployment.Destroy(t)
+
+	userID := "@alice:hs1"
+	alice := deployment.Client(t, "hs1", userID)
+	roomID := alice.CreateRoom(t, struct{}{})
+
+	// eventA
+	eventA := alice.SendEventSynced(t, roomID, b.Event{
+		Type: "m.room.message",
+		Content: map[string]interface{}{
+			"msgtype": "m.text",
+			"body":    "Message A",
+		},
+	})
+
+	insertTime := time.Now()
+	insertOriginServerTs := uint64(insertTime.UnixNano() / 1000000)
+
+	// wait 3ms to ensure that the timestamp changes enough intervals for each message we try to insert later
+	time.Sleep(3 * time.Millisecond)
+
+	// eventB
+	alice.SendEventSynced(t, roomID, b.Event{
+		Type: "m.room.message",
+		Content: map[string]interface{}{
+			"msgtype": "m.text",
+			"body":    "Message B",
+		},
+	})
+	// eventC
+	alice.SendEventSynced(t, roomID, b.Event{
+		Type: "m.room.message",
+		Content: map[string]interface{}{
+			"msgtype": "m.text",
+			"body":    "Message C",
+		},
+	})
+
+	// event1
+	event1 := alice.SendEvent(t, roomID, b.Event{
+		Type: "m.room.message",
+		PrevEvents: []string{
+			eventA,
+		},
+		OriginServerTS: insertOriginServerTs,
+		Content: map[string]interface{}{
+			"msgtype": "m.text",
+			"body":    "Message 1",
+		},
+	})
+
+	// event2
+	event2 := alice.SendEvent(t, roomID, b.Event{
+		Type: "m.room.message",
+		PrevEvents: []string{
+			event1,
+		},
+		OriginServerTS: insertOriginServerTs + 1,
+		Content: map[string]interface{}{
+			"msgtype": "m.text",
+			"body":    "Message 2",
+		},
+	})
+
+	// event3
+	alice.SendEvent(t, roomID, b.Event{
+		Type: "m.room.message",
+		PrevEvents: []string{
+			event2,
+		},
+		OriginServerTS: insertOriginServerTs + 2,
+		Content: map[string]interface{}{
+			"msgtype": "m.text",
+			"body":    "Message 3",
+		},
+	})
+
+	// eventStar
+	eventStar := alice.SendEventSynced(t, roomID, b.Event{
+		Type: "m.room.message",
+		Content: map[string]interface{}{
+			"msgtype": "m.text",
+			"body":    "Message *",
+		},
+	})
+
+	res := alice.MustDoRaw(t, "GET", []string{"_matrix", "client", "r0", "rooms", roomID, "messages"}, nil, "application/json", url.Values{
+		"dir":   []string{"b"},
+		"limit": []string{"100"},
+	})
+
+	t.Logf("aweawfeefwaweafeafw")
+	body := client.ParseJSON(t, res)
+	logrus.WithFields(logrus.Fields{
+		"insertOriginServerTs": insertOriginServerTs,
+		"res":                  res,
+		"body":                 string(body),
+	}).Error("messages res")
+
+	contextRes := alice.MustDoRaw(t, "GET", []string{"_matrix", "client", "r0", "rooms", roomID, "context", eventStar}, nil, "application/json", url.Values{
+		"limit": []string{"100"},
+	})
+	contextResBody := client.ParseJSON(t, contextRes)
+	logrus.WithFields(logrus.Fields{
+		"contextResBody": string(contextResBody),
+	}).Error("context res")
+
+	t.Run("parallel", func(t *testing.T) {
+		// sytest: Room creation reports m.room.create to myself
+		t.Run("Room creation reports m.room.create to myself", func(t *testing.T) {
+			t.Parallel()
+
+			alice := deployment.Client(t, "hs1", userID)
+
+			alice.SyncUntilTimelineHas(t, roomID, func(ev gjson.Result) bool {
+				if ev.Get("type").Str != "m.room.create" {
+					return false
+				}
+				must.EqualStr(t, ev.Get("sender").Str, userID, "wrong sender")
+				must.EqualStr(t, ev.Get("content").Get("creator").Str, userID, "wrong content.creator")
+				return true
+			})
+		})
+	})
+}