Merge branch 'master' of github.com:coralproject/talk into plugin_examples

2026-07-09 09:20:38 +08:00 · 2017-04-17 14:17:42 -03:00
parent 7969985f59 404301bd43
commit e729a673a3
52 changed files with 1380 additions and 272 deletions
@@ -0,0 +1,129 @@
+const expect = require('chai').expect;
+const {graphql} = require('graphql');
+
+const schema = require('../../../graph/schema');
+const Context = require('../../../graph/context');
+const UsersService = require('../../../services/users');
+const SettingsService = require('../../../services/settings');
+
+const ignoreUserMutation = `
+  mutation ignoreUser ($id: ID!) {
+    ignoreUser(id:$id) {
+      errors {
+        translation_key
+      }
+    }
+  }
+`;
+
+const getMyIgnoredUsersQuery = `
+  query myIgnoredUsers {
+    myIgnoredUsers {
+      id,
+      username
+    }
+  }
+`;
+
+describe('graph.mutations.ignoreUser', () => {
+  beforeEach(async () => {
+    await SettingsService.init();
+  });
+
+  // @TODO (bengo) - test a user can't ignore themselves
+  it('users can ignoreUser', async () => {
+    const user = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
+    const userToIgnore = await UsersService.createLocalUser('usernameB@example.com', 'password', 'usernameB');
+    const context = new Context({user});
+    const ignoreUserResponse = await graphql(schema, ignoreUserMutation, {}, context, {id: userToIgnore.id});
+    if (ignoreUserResponse.errors && ignoreUserResponse.errors.length) {
+      console.error(ignoreUserResponse.errors);
+    }
+    expect(ignoreUserResponse.errors).to.be.empty;
+
+    // now check my ignored users
+    const myIgnoredUsersResponse = await graphql(schema, getMyIgnoredUsersQuery, {}, context, {});
+    if (myIgnoredUsersResponse.errors && myIgnoredUsersResponse.errors.length) {
+      console.error(myIgnoredUsersResponse.errors);
+    }
+    expect(myIgnoredUsersResponse.errors).to.be.empty;
+    const myIgnoredUsers = myIgnoredUsersResponse.data.myIgnoredUsers;
+    expect(myIgnoredUsers.length).to.equal(1);
+    expect(myIgnoredUsers[0].id).to.equal(userToIgnore.id);
+    expect(myIgnoredUsers[0].username).to.equal(userToIgnore.username);
+  });
+
+  it('users cannot ignore themselves', async () => {
+    const user = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
+    const context = new Context({user});
+    const ignoreUserResponse = await graphql(schema, ignoreUserMutation, {}, context, {id: user.id});
+    expect(ignoreUserResponse.errors).to.not.be.empty;
+
+    // now check my ignored users
+    const myIgnoredUsersResponse = await graphql(schema, getMyIgnoredUsersQuery, {}, context, {});
+    if (myIgnoredUsersResponse.errors && myIgnoredUsersResponse.errors.length) {
+      console.error(myIgnoredUsersResponse.errors);
+    }
+    expect(myIgnoredUsersResponse.errors).to.be.empty;
+    const myIgnoredUsers = myIgnoredUsersResponse.data.myIgnoredUsers;
+    expect(myIgnoredUsers.length).to.equal(0);
+  });
+
+});
+
+describe('graph.mutations.stopIgnoringUser', () => {
+  beforeEach(async () => {
+    await SettingsService.init();
+  });
+
+  it('users can stop ignoring another user they ignore', async () => {
+
+    // We're going to ignore 2 users,
+    // then stopIgnoring 1 of them
+    // then assert myIgnoredUsers only lists the one remaining
+    const user = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
+    const usersToIgnore = await Promise.all([
+      UsersService.createLocalUser('usernameB@example.com', 'password', 'usernameB'),
+      UsersService.createLocalUser('usernameC@example.com', 'password', 'usernameC'),
+    ]);
+    const context = new Context({user});
+
+    // ignore two users
+    const ignoreUserResponses = await Promise.all(usersToIgnore.map(u => graphql(schema, ignoreUserMutation, {}, context, {id: u.id})));
+    ignoreUserResponses.forEach(response => {
+      if (response.errors && response.errors.length) {
+        console.error(response.errors);
+      }
+      expect(response.errors).to.be.empty;      
+    });
+
+    const stopIgnoringUserMutation = `
+      mutation stopIgnoringUser ($id: ID!) {
+        stopIgnoringUser(id:$id) {
+          errors {
+            translation_key
+          }
+        }
+      }
+    `;
+
+    // stop ignoring one user
+    const stopIgnoringUserResponse = await graphql(schema, stopIgnoringUserMutation, {}, context, {id: usersToIgnore[0].id});
+    if (stopIgnoringUserResponse.errors && stopIgnoringUserResponse.errors.length) {
+      console.error(stopIgnoringUserResponse.errors);
+    }
+    expect(stopIgnoringUserResponse.errors).to.be.empty;     
+
+    // now check my ignored users
+    const myIgnoredUsersResponse = await graphql(schema, getMyIgnoredUsersQuery, {}, context, {});
+    if (myIgnoredUsersResponse.errors && myIgnoredUsersResponse.errors.length) {
+      console.error(myIgnoredUsersResponse.errors);
+    }
+    expect(myIgnoredUsersResponse.errors).to.be.empty;
+    const myIgnoredUsers = myIgnoredUsersResponse.data.myIgnoredUsers;
+    expect(myIgnoredUsers.length).to.equal(1);
+    expect(myIgnoredUsers[0].id).to.equal(usersToIgnore[1].id);
+    expect(myIgnoredUsers[0].username).to.equal(usersToIgnore[1].username);
+  });
+
+});
@@ -0,0 +1,93 @@
+const expect = require('chai').expect;
+const {graphql} = require('graphql');
+
+const schema = require('../../../graph/schema');
+const Context = require('../../../graph/context');
+const UsersService = require('../../../services/users');
+const SettingsService = require('../../../services/settings');
+const Asset = require('../../../models/asset');
+const CommentsService = require('../../../services/comments');
+
+describe('graph.queries.asset', () => {
+  beforeEach(async () => {
+    await SettingsService.init();
+  });
+
+  it('can get comments edge', async () => {
+    const assetId = 'fakeAssetId';
+    const assetUrl = 'https://bengo.is';
+    await Asset.create({id: assetId, url: assetUrl});
+
+    const user = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
+    const context = new Context({user});
+
+    await CommentsService.publicCreate([1, 2].map(() => ({
+      author_id: user.id,
+      asset_id: assetId,
+      body: `hello there! ${  String(Math.random()).slice(2)}`,
+    })));
+
+    const assetCommentsQuery = `
+      query assetCommentsQuery($assetId: ID!, $assetUrl: String!) {
+        asset(id: $assetId, url: $assetUrl) {
+          comments(limit: 10) {
+            id,
+            body,
+          }
+        }
+      }
+    `;
+    const assetCommentsResponse = await graphql(schema, assetCommentsQuery, {}, context, {assetId, assetUrl});
+    const comments = assetCommentsResponse.data.asset.comments;
+    expect(comments.length).to.equal(2);
+  });
+
+  it('can query comments edge to exclude comments ignored by user', async () => {
+    const assetId = 'fakeAssetId1';
+    const assetUrl = 'https://bengo.is/1';
+    await Asset.create({id: assetId, url: assetUrl});
+
+    const userA = await UsersService.createLocalUser('usernameA@example.com', 'password', 'usernameA');
+    const userB = await UsersService.createLocalUser('usernameB@example.com', 'password', 'usernameB');
+    const userC = await UsersService.createLocalUser('usernameC@example.com', 'password', 'usernameC');
+    const context = new Context({user: userA});
+
+    // create 2 comments each for userB, userC
+    await Promise.all([userB, userC].map(user => CommentsService.publicCreate([1, 2].map(() => ({
+      author_id: user.id,
+      asset_id: assetId,
+      body: `hello there! ${  String(Math.random()).slice(2)}`,
+    })))));
+
+    // ignore userB
+    const ignoreUserMutation = `
+      mutation ignoreUser ($id: ID!) {
+        ignoreUser(id:$id) {
+          errors {
+            translation_key
+          }
+        }
+      }
+    `;
+    const ignoreUserResponse = await graphql(schema, ignoreUserMutation, {}, context, {id: userB.id});
+    if (ignoreUserResponse.errors && ignoreUserResponse.errors.length) {
+      console.error(ignoreUserResponse.errors);
+    }
+    expect(ignoreUserResponse.errors).to.be.empty;
+
+    const assetCommentsWithoutIgnoredQuery = `
+      query assetCommentsQuery($assetId: ID!, $assetUrl: String!, $excludeIgnored: Boolean!) {
+        asset(id: $assetId, url: $assetUrl) {
+          comments(limit: 10, excludeIgnored: $excludeIgnored) {
+            id,
+            body,
+          }
+        }
+      }
+    `;
+    const assetCommentsResponse = await graphql(schema, assetCommentsWithoutIgnoredQuery, {}, context, {assetId, assetUrl, excludeIgnored: true});
+    const comments = assetCommentsResponse.data.asset.comments;
+    expect(comments.length).to.equal(2);    
+  });
+
+});
@@ -169,6 +169,24 @@ describe('services.UsersService', () => {
    });
  });

+  describe('#ignoreUser', () => {
+
+    // @TODO: assert cannot ignore yourself
+    
+    it('should add user id to ignoredUsers set', async () => {
+      const user = mockUsers[0];
+      const usersToIgnore = [mockUsers[1], mockUsers[2]];
+      await UsersService.ignoreUsers(user.id, usersToIgnore.map(u => u.id));
+      const userAfterIgnoring = await UsersService.findById(user.id);
+      expect(userAfterIgnoring.ignoresUsers.length).to.equal(2);
+
+      // ignore same user another time, make sure it's not added to the list.
+      await UsersService.ignoreUsers(user.id, usersToIgnore.slice(0, 1).map(u => u.id));
+      const userAfterIgnoring2 = await UsersService.findById(user.id);
+      expect(userAfterIgnoring2.ignoresUsers.length).to.equal(2);
+    });
+  });
+
  describe('#ban', () => {
    it('should set the status to banned', () => {
      return UsersService