Adjusted test to conform to new form

2026-07-29 11:28:24 +08:00 · 2017-04-17 16:05:44 -06:00
parent e729a673a3
commit fd6282077f
3 changed files with 17 additions and 14 deletions
@@ -170,7 +170,10 @@ describe('graph.mutations.createComment', () => {
          const context = new Context({user: new UserModel({status: 'ACTIVE'})});

          return graphql(schema, query, {}, context, {
-            body
+            comment: {
+              asset_id: '123',
+              body
+            }
          })
          .then(({data, errors}) => {
            expect(errors).to.be.undefined;
@@ -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);
+  });
+
+});