move everything to subfolder to merge into react-sdk

test/end-to-end-tests/src/scenarios/README.md

@@ -0,0 +1 @@
+scenarios contains the high-level playbook for the test suite

test/end-to-end-tests/src/scenarios/directory.js

@@ -0,0 +1,36 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+const join = require('../usecases/join');
+const sendMessage = require('../usecases/send-message');
+const {receiveMessage} = require('../usecases/timeline');
+const {createRoom} = require('../usecases/create-room');
+const changeRoomSettings = require('../usecases/room-settings');
+
+module.exports = async function roomDirectoryScenarios(alice, bob) {
+    console.log(" creating a public room and join through directory:");
+    const room = 'test';
+    await createRoom(alice, room);
+    await changeRoomSettings(alice, {directory: true, visibility: "public_no_guests", alias: "#test"});
+    await join(bob, room); //looks up room in directory
+    const bobMessage = "hi Alice!";
+    await sendMessage(bob, bobMessage);
+    await receiveMessage(alice, {sender: "bob", body: bobMessage});
+    const aliceMessage = "hi Bob, welcome!"
+    await sendMessage(alice, aliceMessage);
+    await receiveMessage(bob, {sender: "alice", body: aliceMessage});
+}

test/end-to-end-tests/src/scenarios/e2e-encryption.js

@@ -0,0 +1,52 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+const {delay} = require('../util');
+const {acceptDialogMaybe} = require('../usecases/dialog');
+const join = require('../usecases/join');
+const sendMessage = require('../usecases/send-message');
+const acceptInvite = require('../usecases/accept-invite');
+const invite = require('../usecases/invite');
+const {receiveMessage} = require('../usecases/timeline');
+const {createRoom} = require('../usecases/create-room');
+const changeRoomSettings = require('../usecases/room-settings');
+const {startSasVerifcation, acceptSasVerification} = require('../usecases/verify');
+const assert = require('assert');
+
+module.exports = async function e2eEncryptionScenarios(alice, bob) {
+    console.log(" creating an e2e encrypted room and join through invite:");
+    const room = "secrets";
+    await createRoom(bob, room);
+    await changeRoomSettings(bob, {encryption: true});
+    // await cancelKeyBackup(bob);
+    await invite(bob, "@alice:localhost");
+    await acceptInvite(alice, room);
+    // do sas verifcation
+    bob.log.step(`starts SAS verification with ${alice.username}`);
+    const bobSasPromise = startSasVerifcation(bob, alice.username);
+    const aliceSasPromise = acceptSasVerification(alice, bob.username);
+    // wait in parallel, so they don't deadlock on each other
+    const [bobSas, aliceSas] = await Promise.all([bobSasPromise, aliceSasPromise]);
+    assert.deepEqual(bobSas, aliceSas);
+    bob.log.done(`done (match for ${bobSas.join(", ")})`);
+    const aliceMessage = "Guess what I just heard?!"
+    await sendMessage(alice, aliceMessage);
+    await receiveMessage(bob, {sender: "alice", body: aliceMessage, encrypted: true});
+    const bobMessage = "You've got to tell me!";
+    await sendMessage(bob, bobMessage);
+    await receiveMessage(alice, {sender: "bob", body: bobMessage, encrypted: true});
+}

test/end-to-end-tests/src/scenarios/lazy-loading.js

@@ -0,0 +1,123 @@
+/*
+Copyright 2018 New Vector Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+
+const {delay} = require('../util');
+const join = require('../usecases/join');
+const sendMessage = require('../usecases/send-message');
+const {
+    checkTimelineContains,
+    scrollToTimelineTop
+} = require('../usecases/timeline');
+const {createRoom} = require('../usecases/create-room');
+const {getMembersInMemberlist} = require('../usecases/memberlist');
+const changeRoomSettings = require('../usecases/room-settings');
+const {enableLazyLoading} = require('../usecases/settings');
+const assert = require('assert');
+
+module.exports = async function lazyLoadingScenarios(alice, bob, charlies) {
+    console.log(" creating a room for lazy loading member scenarios:");
+    const charly1to5 = charlies.slice("charly-1..5", 0, 5);
+    const charly6to10 = charlies.slice("charly-6..10", 5);
+    assert(charly1to5.sessions.length, 5);
+    assert(charly6to10.sessions.length, 5);
+    await setupRoomWithBobAliceAndCharlies(alice, bob, charly1to5);
+    await checkPaginatedDisplayNames(alice, charly1to5);
+    await checkMemberList(alice, charly1to5);
+    await joinCharliesWhileAliceIsOffline(alice, charly6to10);
+    await checkMemberList(alice, charly6to10);
+    await charlies.room(alias).leave();
+    await delay(1000);
+    await checkMemberListLacksCharlies(alice, charlies);
+    await checkMemberListLacksCharlies(bob, charlies);
+}
+
+const room = "Lazy Loading Test";
+const alias = "#lltest:localhost";
+const charlyMsg1 = "hi bob!";
+const charlyMsg2 = "how's it going??";
+
+async function setupRoomWithBobAliceAndCharlies(alice, bob, charlies) {
+    await createRoom(bob, room);
+    await changeRoomSettings(bob, {directory: true, visibility: "public_no_guests", alias});
+    // wait for alias to be set by server after clicking "save"
+    // so the charlies can join it.
+    await bob.delay(500);
+    const charlyMembers = await charlies.join(alias);
+    await charlyMembers.talk(charlyMsg1);
+    await charlyMembers.talk(charlyMsg2);
+    bob.log.step("sends 20 messages").mute();
+    for(let i = 20; i >= 1; --i) {
+        await sendMessage(bob, `I will only say this ${i} time(s)!`);
+    }
+    bob.log.unmute().done();
+    await join(alice, alias);
+}
+
+async function checkPaginatedDisplayNames(alice, charlies) {
+    await scrollToTimelineTop(alice);
+    //alice should see 2 messages from every charly with
+    //the correct display name
+    const expectedMessages = [charlyMsg1, charlyMsg2].reduce((messages, msgText) => {
+        return charlies.sessions.reduce((messages, charly) => {
+            return messages.concat({
+                sender: charly.displayName(),
+                body: msgText,
+            });
+        }, messages);
+    }, []);
+    await checkTimelineContains(alice, expectedMessages, charlies.log.username);
+}
+
+async function checkMemberList(alice, charlies) {
+    alice.log.step(`checks the memberlist contains herself, bob and ${charlies.log.username}`);
+    const displayNames = (await getMembersInMemberlist(alice)).map((m) => m.displayName);
+    assert(displayNames.includes("alice"));
+    assert(displayNames.includes("bob"));
+    charlies.sessions.forEach((charly) => {
+        assert(displayNames.includes(charly.displayName()),
+            `${charly.displayName()} should be in the member list, ` +
+            `only have ${displayNames}`);
+    });
+    alice.log.done();
+}
+
+async function checkMemberListLacksCharlies(session, charlies) {
+    session.log.step(`checks the memberlist doesn't contain ${charlies.log.username}`);
+    const displayNames = (await getMembersInMemberlist(session)).map((m) => m.displayName);
+    charlies.sessions.forEach((charly) => {
+        assert(!displayNames.includes(charly.displayName()),
+            `${charly.displayName()} should not be in the member list, ` +
+            `only have ${displayNames}`);
+    });
+    session.log.done();
+}
+
+async function joinCharliesWhileAliceIsOffline(alice, charly6to10) {
+    await alice.setOffline(true);
+    await delay(1000);
+    const members6to10 = await charly6to10.join(alias);
+    const member6 = members6to10.rooms[0];
+    member6.log.step("sends 20 messages").mute();
+    for(let i = 20; i >= 1; --i) {
+        await member6.talk("where is charly?");
+    }
+    member6.log.unmute().done();
+    const catchupPromise = alice.waitForNextSuccessfulSync();
+    await alice.setOffline(false);
+    await catchupPromise;
+    await delay(2000);
+}