diff --git a/test/api-legacy/party.coffee b/test/api-legacy/party.coffee
index 3e46328991..83adc7df0c 100644
--- a/test/api-legacy/party.coffee
+++ b/test/api-legacy/party.coffee
@@ -6,124 +6,6 @@ Group = require("../../website/src/models/group").model
 app = require("../../website/src/server")
 
 describe "Party", ->
-  context "creating a party", ->
-    it "creates a party", (done) ->
-      async.waterfall [
-        (cb) ->
-          registerNewUser(cb, true)
-
-        (user, cb) ->
-          request.post(baseURL + "/groups").send(
-            name: "TestGroup"
-            type: "party"
-          ).end (err, res) ->
-            expectCode res, 200
-            group = res.body
-            expect(group.members.length).to.equal 1
-            expect(group.leader).to.equal user._id
-            cb()
-      ], done
-
-    it "prevents user from creating a second party", (done) ->
-      request.post(baseURL + "/groups").send(
-        name: "TestGroup"
-        type: "party"
-      ).end (err, res) ->
-        expectCode res, 400
-        expect(res.body.err).to.equal "Already in a party, try refreshing."
-        done()
-
-  context "Searching for a party", ->
-    group = undefined
-    beforeEach (done) ->
-      async.waterfall [
-        (cb) ->
-          registerNewUser(cb, true)
-
-        (user, cb) ->
-          request.post(baseURL + "/groups").send(
-            name: "TestGroup"
-            type: "party"
-          ).end (err, res) ->
-            expectCode res, 200
-            group = res.body
-            expect(group.members.length).to.equal 1
-            expect(group.leader).to.equal user._id
-            cb()
-      ], done
-
-    it "can be found by querying for group type party", (done) ->
-      request.get(baseURL + "/groups/").send(
-        type: "party"
-      ).end (err, res) ->
-        expectCode res, 200
-        party = _.find res.body, (g) -> return g._id == group._id
-        expect(party._id).to.equal group._id
-        expect(party.leader).to.equal user._id
-        expect(party.name).to.equal group.name
-        expect(party.quest).to.deep.equal { progress: {} }
-        expect(party.memberCount).to.equal group.memberCount
-        done()
-
-  context "joining a party", ->
-    group = undefined
-    beforeEach (done) ->
-      async.waterfall [
-        (cb) ->
-          registerNewUser(cb, true)
-
-        (user, cb) ->
-          request.post(baseURL + "/groups").send(
-            name: "TestGroup"
-            type: "party"
-          ).end (err, res) ->
-            expectCode res, 200
-            group = res.body
-            expect(group.members.length).to.equal 1
-            expect(group.leader).to.equal user._id
-            cb()
-      ], done
-
-    it "prevents user from joining a party when they haven't been invited", (done) ->
-      registerNewUser (err, user) ->
-        request.post(baseURL + "/groups/" + group._id + "/join").send()
-        .set("X-API-User", user._id)
-        .set("X-API-Key", user.apiToken)
-        .end (err, res) ->
-          expectCode res, 401
-          expect(res.body.err).to.equal "Can't join a group you're not invited to."
-          done()
-      , false
-
-    it "allows users to join a party when they have been invited", (done) ->
-      tmpUser = undefined
-      async.waterfall [
-        (cb) ->
-          registerNewUser(cb, false)
-
-        (user, cb) ->
-          tmpUser = user
-          inviteURL = baseURL + "/groups/" + group._id + "/invite"
-          request.post(inviteURL).send(
-            uuids: [tmpUser._id]
-          )
-          .end ->
-            cb()
-
-        (cb) ->
-          request.post(baseURL + "/groups/" + group._id + "/join")
-          .set("X-API-User", tmpUser._id)
-          .set("X-API-Key", tmpUser.apiToken)
-          .end (err, res) ->
-            expectCode res, 200
-            cb()
-
-        (cb) ->
-          Group.findById group._id, (err, grp) ->
-            expect(grp.members).to.include(tmpUser._id)
-            cb()
-      ], done
-
   context "Quests", ->
     party = undefined
     group = undefined
diff --git a/test/api/groups/POST-groups_id_join.test.js b/test/api/groups/POST-groups_id_join.test.js
index c9cb438498..38587ee235 100644
--- a/test/api/groups/POST-groups_id_join.test.js
+++ b/test/api/groups/POST-groups_id_join.test.js
@@ -3,6 +3,7 @@ import {
   generateUser,
   requester,
 } from '../../helpers/api.helper';
+import { each, find } from 'lodash';
 
 describe('POST /groups/:id/join', () => {
 
@@ -10,6 +11,108 @@ describe('POST /groups/:id/join', () => {
     it('returns an error');
   });
 
+  each({
+    'public guild': {type: 'guild', privacy: 'public'},
+    'private guild': {type: 'guild', privacy: 'private'},
+    'party': {type: 'party', privacy: 'private'},
+  }, (data, groupType) => {
+    context(`user has invitation to a ${groupType}`, () => {
+      let api, group, invitee;
+
+      beforeEach(() => {
+        return createAndPopulateGroup({
+          groupDetails: {
+            type: data.type,
+            privacy: data.privacy,
+          },
+          invites: 1,
+        }).then((res) => {
+          group = res.group;
+          invitee = res.invitees[0];
+          api = requester(invitee);
+        });
+      });
+
+      it(`allows user to join a ${groupType}`, () => {
+        return api.post(`/groups/${group._id}/join`).then((res) => {
+          return api.get(`/groups/${group._id}`);
+        }).then((_group) => {
+          let members = _group.members;
+          let userInGroup = find(members, (user) => {
+            return user._id === invitee._id;
+          });
+
+          expect(userInGroup).to.exist;
+        });
+      });
+    });
+  });
+
+  each({
+    'private guild': {type: 'guild', privacy: 'private'},
+    'party': {type: 'party', privacy: 'private'},
+  }, (data, groupType) => {
+    context(`user does not have an invitation to a ${groupType}`, () => {
+      let api, group, user;
+
+      beforeEach(() => {
+        return createAndPopulateGroup({
+          groupDetails: {
+            type: data.type,
+            privacy: data.privacy,
+          },
+        }).then((res) => {
+          group = res.group;
+          return generateUser();
+        }).then((generatedUser) => {
+          user = generatedUser;
+          api = requester(user);
+        });
+      });
+
+      it(`does not allow user to join a ${groupType}`, () => {
+        return expect(api.post(`/groups/${group._id}/join`).then((res) => {
+          return api.get(`/groups/${group._id}`);
+        })).to.eventually.be.rejected.and.eql({
+          code: 401,
+          text: 'Can\'t join a group you\'re not invited to.',
+        });
+      });
+    });
+  });
+
+  context('user does not have an invitation to a public group', () => {
+    let api, group, user;
+
+    beforeEach(() => {
+      return createAndPopulateGroup({
+        groupDetails: {
+          type: 'guild',
+          privacy: 'public',
+        },
+      }).then((res) => {
+        group = res.group;
+        return generateUser();
+      }).then((generatedUser) => {
+        user = generatedUser;
+        api = requester(user);
+      });
+    });
+
+    it('allows user to join a public guild', () => {
+      return api.post(`/groups/${group._id}/join`).then((res) => {
+        return api.get(`/groups/${group._id}`);
+      }).then((_group) => {
+        let members = _group.members;
+        let userInGroup = find(members, (member) => {
+          return user._id === user._id;
+        });
+
+        expect(userInGroup).to.exist;
+      });
+    });
+  });
+
   context('public guild has no leader', () => {
     let user, group;