diff --git a/rocketc/rocketc.py b/rocketc/rocketc.py
index ed4de9d5..8fdc2d92 100644
--- a/rocketc/rocketc.py
+++ b/rocketc/rocketc.py
@@ -30,6 +30,39 @@
 CACHE_TIMEOUT = 86400
 
 
+def generate_custom_fields(course, team=None, specific_team=False):
+
+    team_name, topic = generate_team_variables(team)
+    return {
+        "customFields": {
+            "course": course,
+            "team": team_name,
+            "topic": topic,
+            "specificTeam": specific_team,
+        }
+    }
+
+
+def generate_query_dict(course, team=None, specific_team=False):
+
+    team_name, topic = generate_team_variables(team)
+    query = {
+        "customFields.course": course,
+        "customFields.team": team_name,
+        "customFields.topic": topic,
+        "customFields.specificTeam": specific_team,
+    }
+    return {"query": json.dumps(query)}
+
+
+def generate_team_variables(team):
+    if isinstance(team, dict):
+        topic_id = re.sub(r'\W+', '', team.get("topic_id", None))
+        team_name = re.sub(r'\W+', '', team.get("name", None))
+        return team_name, topic_id
+    return None, None
+
+
 @XBlock.wants("user")  # pylint: disable=too-many-ancestors, too-many-instance-attributes
 @XBlock.wants("settings")
 class RocketChatXBlock(XBlock, XBlockWithSettingsMixin, StudioEditableXBlockMixin):
@@ -133,6 +166,8 @@ class RocketChatXBlock(XBlock, XBlockWithSettingsMixin, StudioEditableXBlockMixi
 
     has_score = graded_activity
     team_view = True
+    _api_teams = None
+    _api_rocket_chat = None
 
     VIEWS = ["Main View", "Team Discussion", "Specific Channel"]
 
@@ -161,7 +196,6 @@ def student_view(self, context=None):
         The primary view of the RocketChatXBlock, shown to students
         when viewing courses.
         """
-        self.api_rocket_chat = self._api_rocket_chat()  # pylint: disable=attribute-defined-outside-init
         in_studio_runtime = hasattr(
             self.xmodule_runtime, 'is_author_mode')  # pylint: disable=no-member
 
@@ -187,7 +221,6 @@ def student_view(self, context=None):
     def author_view(self, context=None):
         """  Returns author view fragment on Studio """
         # pylint: disable=unused-argument
-        self.api_rocket_chat.convert_to_private_channel("general")
         frag = Fragment(u"Studio Runtime RocketChatXBlock")
         frag.add_javascript(self.resource_string("static/js/src/rocketc.js"))
         frag.initialize_js('RocketChatXBlock')
@@ -222,39 +255,52 @@ def workbench_scenarios():
              """),
         ]
 
-    def _api_rocket_chat(self):
+    @property
+    def api_rocket_chat(self):
         """
         Creates an ApiRocketChat object
         """
-        try:
-            user = self.xblock_settings["admin_user"]
-            password = self.xblock_settings["admin_pass"]
-        except KeyError:
-            LOG.exception("The admin's settings has not been found")
-            raise
-        api = ApiRocketChat(user, password, self.server_data["private_url_service"])
+        if not self._api_rocket_chat:
+            try:
+                user = self.xblock_settings["admin_user"]
+                password = self.xblock_settings["admin_pass"]
+            except KeyError:
+                LOG.exception("The admin's settings has not been found")
+                raise
+            self._api_rocket_chat = ApiRocketChat(  # pylint: disable=attribute-defined-outside-init
+                user,
+                password,
+                self.server_data["private_url_service"]
+            )
 
-        LOG.info("Api rocketChat initialize: %s ", api)
+            LOG.info("Api rocketChat initialize: %s ", self._api_rocket_chat)
 
-        return api
+        return self._api_rocket_chat
 
-    def _api_teams(self):
+    @property
+    def api_teams(self):
         """
         Creates an ApiTeams object
         """
-        try:
-            client_id = self.xblock_settings["client_id"]
-            client_secret = self.xblock_settings["client_secret"]
-        except KeyError:
-            raise
-
-        server_url = settings.LMS_ROOT_URL
-
-        api = ApiTeams(client_id, client_secret, server_url)
+        if not self._api_teams:
+            try:
+                client_id = self.xblock_settings["client_id"]
+                client_secret = self.xblock_settings["client_secret"]
+            except KeyError, xblock_settings_error:
+                LOG.error('Get rocketchat xblock settings error: %s', xblock_settings_error)
+                raise
+
+            server_url = settings.LMS_ROOT_URL
+
+            self._api_teams = ApiTeams(  # pylint: disable=attribute-defined-outside-init
+                client_id,
+                client_secret,
+                server_url
+            )
 
-        LOG.info("Api Teams initialize: %s ", api)
+            LOG.info("Api Teams initialize: %s ", self._api_teams)
 
-        return api
+        return self._api_teams
 
     @property
     def server_data(self):
@@ -272,13 +318,12 @@ def user_data(self):
         """
         This method initializes the user's parameters
         """
-        runtime = self.xmodule_runtime  # pylint: disable=no-member
+        runtime = self.runtime  # pylint: disable=no-member
         user = runtime.service(self, 'user').get_current_user()
         user_data = {}
         user_data["email"] = user.emails[0]
         user_data["role"] = runtime.get_user_role()
         user_data["course_id"] = runtime.course_id
-        user_data["course"] = re.sub('[^A-Za-z0-9]+', '', runtime.course_id.to_deprecated_string()) # pylint: disable=protected-access
         user_data["username"] = user.opt_attrs['edx-platform.username']
         user_data["anonymous_student_id"] = runtime.anonymous_student_id
         return user_data
@@ -290,6 +335,17 @@ def xblock_settings(self):
         """
         return self.get_xblock_settings()
 
+    @property
+    def course_id(self):
+        """
+        This method allows to get the course_id
+        """
+        try:
+            return re.sub('[^A-Za-z0-9]+', '', unicode(self.xmodule_runtime.course_id))
+        except AttributeError:
+            course_id = unicode(self.runtime.course_id)
+            return re.sub('[^A-Za-z0-9]+', '', course_id.split("+branch", 1)[0])
+
     def channels_enabled(self):
         """
         This method returns a list with the channel options
@@ -304,24 +360,19 @@ def get_groups(self):
         """
         This method lists the existing groups
         """
-        api = self._api_teams()
-        teams = api.get_course_teams(self.runtime.course_id)
-        topics = [re.sub(r'\W+', '', team["topic_id"]) for team in teams]
-
         # the following instructions get all the groups
-        # except the groups with the string of some topic in its name
-        query = {'name': {'$regex': '^(?!.*({topics}).*$)'.format(topics='|'.join(topics))}} if topics else {}
-        kwargs = {"query": json.dumps(query)}
-        groups = self._api_rocket_chat().get_groups(**kwargs)
-
-        # these instructions get all the groups with the customField "specificTeam" set
-        query = {'customFields.specificTeam': {'$regex': '^.*'}}
-        kwargs = {'query': json.dumps(query)}
-        team_groups = self._api_rocket_chat().get_groups(**kwargs)
+        # except the team groups and specific teams
+        course = self.course_id
+        kwargs = generate_query_dict(course)
+        groups = [group.split("__", 1)[0] for group in self.api_rocket_chat.get_groups(**kwargs)]
 
+        kwargs = generate_query_dict(course, specific_team=True)
         # This instruction adds the string "(Team Group)" if the group is in team_groups
-        # pylint: disable=line-too-long
-        groups = ['{}-{}'.format('(Team Group)', group) if group in team_groups else group for group in groups]
+        groups += [
+            '{}-{}'.format("(Team Group)", team_group.split("__", 1)[0])
+            for team_group in self.api_rocket_chat.get_groups(**kwargs)
+        ]
+
         groups.append("")
         return sorted(groups)
 
@@ -333,7 +384,7 @@ def init(self):
 
         user_data = self.user_data
 
-        response = self.login(user_data)
+        response = self._login(user_data)
         if response['success']:
             response = response['data']
             user_id = response['userId']
@@ -342,15 +393,12 @@ def init(self):
             response['default_group'] = self._join_user_to_groups(user_id, user_data, auth_token)
             self._update_user(user_id, user_data)
 
-            if user_data["role"] == "instructor" and self.rocket_chat_role != "bot":
-                self.api_rocket_chat.change_user_role(user_id, "bot")
-
             self._grading_discussions(response['default_group'])
             return response
-        else:
-            return response['errorType']
 
-    def login(self, user_data):
+        return response['errorType']
+
+    def _login(self, user_data):
         """
         This method allows to get the user's authToken and id
         or creates a user to login in RocketChat
@@ -378,60 +426,57 @@ def login(self, user_data):
         cache.set(key, data, CACHE_TIMEOUT)
         return data
 
-    def _add_user_to_course_group(self, group_name, user_id):
+    def _add_user_to_course_group(self, user_id):
         """
         This method add the user to the default course channel
         """
-        api = self.api_rocket_chat
-        rocket_chat_group = api.search_rocket_chat_group(group_name)
-
-        if rocket_chat_group['success']:
-            api.add_user_to_group(user_id, rocket_chat_group['group']['_id'])
-        else:
-            rocket_chat_group = api.create_group(group_name, [self.user_data["username"]])
-
-        self.group = api.search_rocket_chat_group(  # pylint: disable=attribute-defined-outside-init
-            group_name)
+        group_name = "{}__{}".format("General", self.course_id)
+        self._add_user_to_group(
+            user_id,
+            group_name,
+            members=[self.user_data["username"]],
+            custom_fields=generate_custom_fields(course=self.course_id),
+            create=True
+        )
 
-    def _add_user_to_default_group(self, group_name, user_id):
+    def _add_user_to_specific_group(self, group_name, user_id):
         """
+        This method allows to add a user to a given group.
         """
-        api = self.api_rocket_chat
-        group_info = api.search_rocket_chat_group(group_name)
-
-        if group_info["success"]:
-            api.add_user_to_group(user_id, group_info['group']['_id'])
-            return True
-        return False
+        group = "{}__{}".format(group_name, self.course_id)
+        result = self._add_user_to_group(user_id, group)
+        return result, group
 
-    def _add_user_to_team_group(self, user_id, username, course_id, auth_token):
+    def _add_user_to_team_group(self, user_id, username, auth_token):
         """
         Add the user to team's group in rocketChat
         """
-        self.api_teams = self._api_teams()  # pylint: disable=attribute-defined-outside-init
-        team = self._get_team(username, course_id)
+        team = self._get_team(username)
 
         if team is None:
             self._remove_user_from_group(self.team_channel, user_id, auth_token)
             return False
-        topic_id = re.sub(r'\W+', '', team["topic_id"])
-        team_name = re.sub(r'\W+', '', team["name"])
-        group_name = "-".join(["Team", topic_id, team_name])
+        team_name, topic_id = generate_team_variables(team)
+        group_name = "{}__{}__{}".format(team_name, topic_id, self.course_id)
 
         if self.team_channel != group_name:
             self._remove_user_from_group(self.team_channel, user_id, auth_token)
 
         self.team_channel = group_name
 
-        response = self._add_user_to_group(user_id, group_name, username)
-        LOG.info("Add to team group response: %s", response)
-        return response["success"]
+        return self._add_user_to_group(
+            user_id,
+            group_name,
+            members=[username],
+            custom_fields=generate_custom_fields(self.course_id, team),
+            create=True
+        )
 
-    def _get_team(self, username, course_id):
+    def _get_team(self, username):
         """
         This method gets the user's team
         """
-        team = self.api_teams.get_user_team(course_id, username)
+        team = self.api_teams.get_user_team(self.runtime.course_id, username)
         LOG.info("Get Team response: %s", team)
         if team:
             return team[0]
@@ -444,8 +489,7 @@ def _join_user_to_groups(self, user_id, user_data, auth_token):
         default_channel = self.default_channel
 
         if self.selected_view == self.VIEWS[1] and self._teams_is_enabled():
-            self.team_view = self._add_user_to_team_group(
-                user_id, user_data["username"], user_data["course_id"], auth_token)
+            self.team_view = self._add_user_to_team_group(user_id, user_data["username"], auth_token)
             self.ui_is_block = self.team_view
             return self.team_channel
 
@@ -453,35 +497,48 @@ def _join_user_to_groups(self, user_id, user_data, auth_token):
             if default_channel.startswith("(Team Group)"):
                 return self._join_user_to_specific_team_group(user_id, user_data, default_channel)
 
-            self.ui_is_block = self._add_user_to_default_group(default_channel, user_id)
+            self.ui_is_block, default_channel = self._add_user_to_specific_group(default_channel, user_id)
             return default_channel
         else:
             self.ui_is_block = False
-            self._add_user_to_course_group(user_data["course"], user_id)
+            self._add_user_to_course_group(user_id)
         return None
 
-    def _add_user_to_group(self, user_id, group_name, username):
-        group_info = self.api_rocket_chat.search_rocket_chat_group(group_name)
+    def _add_user_to_group(self, user_id, group_name, **kwargs):
+        """
+        This method allows to add a user to any channel, returns True if it's successful
+        """
+        group = self.api_rocket_chat.search_rocket_chat_group(group_name)
+        response = {}
 
-        if group_info["success"]:
-            response = self.api_rocket_chat.add_user_to_group(user_id, group_info['group']['_id'])
-            LOG.info("Add to team group response: %s", response)
-            return response
+        if group["success"]:
+            response = self.api_rocket_chat.add_user_to_group(user_id, group['group']['_id'])
+        elif kwargs.get("create", False):
+            response = self.api_rocket_chat.create_group(
+                group_name,
+                kwargs.get("members", []),
+                **kwargs.get("custom_fields", {})
+            )
 
-        return self.api_rocket_chat.create_group(group_name, [username])
+        return response.get("success", False)
 
     def _join_user_to_specific_team_group(self, user_id, user_data, default_channel):
-        self.api_teams = self._api_teams()  # pylint: disable=attribute-defined-outside-init
-        team = self._get_team(user_data["username"], user_data["course_id"])
+        team = self._get_team(user_data["username"])
         if team is None:
             self.team_view = False
             return None
         default_channel = self._create_team_group_name(
             team,
-            default_channel.replace("(Team Group)-", "")
-            )
-        response = self._add_user_to_group(user_id, default_channel, user_data["username"])
-        self.ui_is_block = response["success"]
+            default_channel.replace("(Team Group)-", ""),
+            self.course_id
+        )
+        self.ui_is_block = self._add_user_to_group(
+            user_id,
+            default_channel,
+            members=[user_data["username"]],
+            custom_fields=generate_custom_fields(self.course_id, team),
+            create=True
+        )
         return default_channel
 
     def _teams_is_enabled(self):
@@ -533,54 +590,45 @@ def create_group(self, data, suffix=""):
         This method allows to create a group
         """
         # pylint: disable=unused-argument
-        self.api_rocket_chat = self._api_rocket_chat()  # pylint: disable=attribute-defined-outside-init
-        self.api_teams = self._api_teams()  # pylint: disable=attribute-defined-outside-init
-
-        group_name = data["groupName"]
-        description = data["description"]
-        topic = data["topic"]
+        group_name = data.get("groupName", None)
 
         if group_name == "" or group_name is None:
             return {"success": False, "error": "Group Name is not valid"}
 
         group_name = re.sub(r'\W+', '', group_name)
+        specific_team = False
+        members = []
+        team = None
+
+        if data.get("asTeam"):
+            group_name = "{}__{}".format(group_name, self.course_id)
+            specific_team = True
 
-        if data.get("asTeam", False):
-            custom_fields = {"customFields": {"specificTeam": group_name}}
-            group = self.api_rocket_chat.create_group(group_name, **custom_fields)
-            if group["success"]:
-                self.default_channel = "{}-{}".format('(Team Group)', group_name)
+        elif data.get("teamGroup"):
+            team = self._get_team(self.user_data["username"])
+            members = list(self.get_team_members(team))
+            group_name = self._create_team_group_name(team, group_name, self.course_id)
 
         else:
-            try:
-                course_id = self.xmodule_runtime.course_id  # pylint: disable=no-member
-                team = self._get_team(self.user_data["username"], course_id)
-                members = list(self.get_team_members(team))
-                group = self.api_rocket_chat.create_group(
-                    self._create_team_group_name(team, group_name),
-                    members
-                    )
-
-            except AttributeError:
-                group = self.api_rocket_chat.create_group(group_name)
-                if group["success"]:
-                    self.default_channel = group_name
+            group_name = "{}__{}".format(group_name, self.course_id)
+
+        custom_fields = generate_custom_fields(self.course_id, team, specific_team)
+        group = self.api_rocket_chat.create_group(group_name, members, **custom_fields)
 
         if "group" in group:
             group_id = group["group"]["_id"]
 
-            self.api_rocket_chat.set_group_description(group_id, description)
-            self.api_rocket_chat.set_group_topic(group_id, topic)
+            self.api_rocket_chat.set_group_description(group_id, data.get("description"))
+            self.api_rocket_chat.set_group_topic(group_id, data.get("topic"))
 
         LOG.info("Method Public Create Group: %s", group)
         return group
 
     @staticmethod
-    def _create_team_group_name(team, group_name):
+    def _create_team_group_name(team, group_name, course):
 
-        team_topic = re.sub(r'\W+', '', team["topic_id"])
-        team_name = re.sub(r'\W+', '', team["name"])
-        return "-".join([team_topic, team_name, group_name])
+        team_name, team_topic = generate_team_variables(team)
+        return "{}__{}__{}__{}".format(group_name, team_name, team_topic, course)
 
     def _remove_user_from_group(self, group_name, user_id, auth_token=None):
         """
@@ -594,21 +642,20 @@ def _remove_user_from_group(self, group_name, user_id, auth_token=None):
             regex = group_name.replace('Team-', '', 1)
             query = {"name": {"$regex": regex}}
             kwargs = {"query": json.dumps(query)}
-            api = self.api_rocket_chat
             groups = api.list_all_groups(user_id, auth_token, **kwargs)
 
             if groups["success"]:
                 groups = groups["groups"]
                 for group in groups:
                     api.kick_user_from_group(user_id, group["_id"])
-                return True
+                return {"success": True}
 
         group = api.search_rocket_chat_group(group_name)
         if group["success"]:
             group = group["group"]
             response = api.kick_user_from_group(user_id, group["_id"])
-            return response.get('success', False)
-        return False
+            return response
+        return {"success": False, "error": "Channel not found"}
 
     def get_team_members(self, team):
         """
@@ -628,7 +675,6 @@ def leave_group(self, data, suffix=""):
         """
         # pylint: disable=unused-argument
 
-        self.api_rocket_chat = self._api_rocket_chat()  # pylint: disable=attribute-defined-outside-init
         username = self.user_data["username"]
         user = self.api_rocket_chat.search_rocket_chat_user(username)
         group_name = data["groupName"]
@@ -639,8 +685,12 @@ def leave_group(self, data, suffix=""):
         if group_name == "" or group_name is None:
             return {"success": False, "error": "Group Name is not valid"}
 
-        if group_name == self.team_channel or group_name == self.user_data["course"]:
+        team = self._get_team(self.user_data["username"])
+        team_name, topic_id = generate_team_variables(team)
+
+        if group_name == team_name or group_name == "General":
             return {"success": False, "error": "You Can Not Leave a Main Group"}
+        group_name = "{}__{}__{}__{}".format(group_name, team_name, topic_id, self.course_id)
 
         return self._remove_user_from_group(group_name, user["user"]["_id"])
 
@@ -650,20 +700,14 @@ def get_list_of_groups(self, data, suffix=""):
         # pylint: disable=unused-argument
         user_id = data.get("userId", None)
         auth_token = data.get("authToken", None)
-        self.api_teams = self._api_teams()  # pylint: disable=attribute-defined-outside-init
 
         if not user_id or not auth_token:
             LOG.warn("Invalid data for method get_list_of_groups: %s", data)
             return None
 
-        course_id = self.xmodule_runtime.course_id  # pylint: disable=no-member
-        team = self._get_team(self.user_data["username"], course_id)
-        topic = re.sub(r'\W+', '', team["topic_id"])
-        team_name = re.sub(r'\W+', '', team["name"])
+        team = self._get_team(self.user_data["username"])
 
-        regex = "-".join([topic, team_name])
-        query = {"name": {"$regex": regex}}
-        kwargs = {"query": json.dumps(query)}
+        kwargs = generate_query_dict(self.course_id, team=team)
 
         groups = list(self._get_list_groups(user_id, auth_token, **kwargs))
         return groups
@@ -672,7 +716,7 @@ def _get_list_groups(self, user_id, auth_token, **kwargs):
         """
         This method allows to get a list of group names
         """
-        api = self._api_rocket_chat()
+        api = self.api_rocket_chat
         groups = api.list_all_groups(user_id, auth_token, **kwargs)
         if groups["success"]:
             groups = groups["groups"]
@@ -704,7 +748,7 @@ def _filter_by_reaction_and_user_role(self, messages, reaction):
         Returns generator with filtered messages by a given reaction
         """
         for message in messages:
-            if not reaction in message.get("reactions", {}):
+            if reaction not in message.get("reactions", {}):
                 continue
             usernames = message["reactions"][reaction]["usernames"]
 
@@ -754,7 +798,7 @@ def logout_user(self, request=None, suffix=None):
         key = request.GET.get("beacon_rc")
         data = cache.get(key)
         if data:
-            api = self._api_rocket_chat()
+            api = self.api_rocket_chat
             user_data = data.get("data")
             login_token = user_data.get("authToken")
             user_id = user_data.get("userId")
diff --git a/rocketc/static/js/src/rocketc.js b/rocketc/static/js/src/rocketc.js
index f90a1a1e..c77585e5 100644
--- a/rocketc/static/js/src/rocketc.js
+++ b/rocketc/static/js/src/rocketc.js
@@ -106,7 +106,8 @@ function RocketChatXBlock(runtime, element) {
         var groupName = $("#group-name-create").val();
         var description = $("#group-description").val();
         var topic = $("#group-topic").val();
-        var data = {groupName, description, topic};
+        var teamGroup = true;
+        var data = {groupName, description, topic, teamGroup};
         $.ajax({
             type: "POST",
             url: createGroup,
@@ -133,9 +134,9 @@ function RocketChatXBlock(runtime, element) {
         $("#select-channel").empty();
         $("#group-names").empty();
         for (var i in data){
-            var item =  $("<option>"+data[i]+"</option>");
+            var item =  $("<option value="+data[i]+">"+data[i].split("__")[0]+"</option>");
             $("#select-channel").append(item);
-            $("#group-names").append($("<option value="+data[i]+">"));
+            $("#group-names").append($("<option value="+data[i].split("__")[0]+">"));
             if(channel == item.val()){
                 $("#select-channel").val(channel);
             }
diff --git a/rocketc/static/js/src/studio_view.js b/rocketc/static/js/src/studio_view.js
index 2daa0865..f2ab870d 100644
--- a/rocketc/static/js/src/studio_view.js
+++ b/rocketc/static/js/src/studio_view.js
@@ -11,7 +11,7 @@ function StudioViewEdit(runtime, element) {
             css("color", "green");
 
             if ($("#as-team").val()==="true"){
-                var name = "(Team Group)-"+ data["group"]["name"];
+                var name = "(Team Group)-"+ data["group"]["name"].split("__")[0];
             }
             else{
                 var name = $("#group-name").val();
diff --git a/rocketc/tests/test_rocketChat.py b/rocketc/tests/test_rocketChat.py
index 4d65a981..36b63d77 100644
--- a/rocketc/tests/test_rocketChat.py
+++ b/rocketc/tests/test_rocketChat.py
@@ -4,7 +4,7 @@
 
 from django.test.utils import override_settings
 from mock import MagicMock, patch, PropertyMock
-from rocketc.rocketc import RocketChatXBlock
+from rocketc.rocketc import RocketChatXBlock, generate_custom_fields
 from rocketc.api_rocket_chat import ApiRocketChat
 from rocketc.api_teams import ApiTeams
 from django.core.cache import cache
@@ -17,12 +17,13 @@ def setUp(self):
         """Set up general variables"""
 
         self.runtime_mock = MagicMock()
+        self.runtime_mock.course_id = "test_course_id"
         scope_ids_mock = MagicMock()
         scope_ids_mock.usage_id = u'0'
         self.block = RocketChatXBlock(
             self.runtime_mock, scope_ids=scope_ids_mock)
         self.block.email = "email"
-        self.block.api_rocket_chat = MagicMock()
+        self.block._api_rocket_chat = MagicMock()
 
         self.modules = {
             'rocketc.openedx_dependencies': MagicMock(),
@@ -31,91 +32,126 @@ def setUp(self):
         self.module_patcher = patch.dict('sys.modules', self.modules)
         self.module_patcher.start()
 
-    def test_add_user_to_course_group(self):
+    @patch('rocketc.rocketc._')
+    @patch('rocketc.rocketc.RocketChatXBlock._add_user_to_group')
+    def test_add_user_to_course_group(self, mock_add_to_group, mock_ugettext):
         """Test for the add course group method"""
-        group_name = "test_group"
+        general = "General"
+        group_name = "{}__{}".format(general, "testcourseid")
+        user_id = "test_user_id"
+        mock_ugettext.return_value = general
+        username = "test_username"
+        with patch('rocketc.rocketc.RocketChatXBlock.user_data', new_callable=PropertyMock) as mock_user_data:
+            mock_user_data.return_value = {"username": username}
+            self.block._add_user_to_course_group(user_id)
+            mock_add_to_group.assert_called_with(
+                user_id,
+                group_name,
+                members=[username],
+                create=True,
+                custom_fields=generate_custom_fields(self.block.course_id)
+            )
+
+    def test_add_user_to_group(self):
+        """Test for the add to group method"""
+        group_name = "test_group_name"
         user_id = "test_user_id"
         data = {'success': True, 'group': {'_id': "test_group_id"}}
+        members = ["test_user_name"]
 
         self.block.api_rocket_chat.search_rocket_chat_group.return_value = data
-        self.block._add_user_to_course_group(group_name, user_id)
+        self.block.api_rocket_chat.add_user_to_group.return_value = data
+        result = self.block._add_user_to_group(user_id, group_name)
         self.block.api_rocket_chat.add_user_to_group.assert_called_with(
-            user_id, data['group']['_id'])
+            user_id,
+            data['group']['_id']
+        )
+
+        self.assertTrue(result)
+
+        custom_fields = generate_custom_fields(self.block.course_id)
+
+        data['success'] = False
+        self.block.api_rocket_chat.search_rocket_chat_group.return_value = data
+        result = self.block._add_user_to_group(
+            user_id,
+            group_name,
+            members=members,
+            create=True,
+            custom_fields=custom_fields
+        )
+        self.block.api_rocket_chat.create_group.assert_called_with(
+            group_name,
+            ["test_user_name"],
+            **custom_fields
+        )
 
-        with patch('rocketc.rocketc.RocketChatXBlock.user_data', new_callable=PropertyMock) as mock_user:
-            mock_user.return_value = {"username": "test_user_name"}
-            data['success'] = False
-            self.block.api_rocket_chat.search_rocket_chat_group.return_value = data
-            self.block._add_user_to_course_group(group_name, user_id)
-            self.block.api_rocket_chat.create_group.assert_called_with(
-                group_name, ["test_user_name"])
+        self.assertTrue(result)
 
-    def test_add_user_to_default_group(self):
+    @patch('rocketc.rocketc.RocketChatXBlock._add_user_to_group')
+    def test_add_user_to_specific_group(self, mock_add_to_group):
         """
         Test the method add to default group
         """
         group_name = "test_group_name"
         user_id = "test_user_id"
+        mock_add_to_group.return_value = True
 
-        self.block.api_rocket_chat.search_rocket_chat_group.return_value = {
-            "success": True, "group": {"_id": "1234"}}
-
-        self.assertTrue(
-            self.block._add_user_to_default_group(group_name, user_id))
-        self.block.api_rocket_chat.add_user_to_group.assert_called_with(user_id, "1234")
-
-        self.block.api_rocket_chat.search_rocket_chat_group.return_value = {
-            "success": False}
+        result, group = self.block._add_user_to_specific_group(group_name, user_id)
+        self.assertTrue(result)
+        self.assertEquals(group, "{}__{}".format(group_name, self.block.course_id))
+        mock_add_to_group.assert_called_with(
+            user_id,
+            "{}__{}".format(group_name, self.block.course_id),
+        )
 
-        self.assertFalse(
-            self.block._add_user_to_default_group(group_name, user_id))
-        self.block.api_rocket_chat.add_user_to_group.assert_called_with(user_id, "1234")
+        mock_add_to_group.return_value = False
+        result, group = self.block._add_user_to_specific_group(group_name, user_id)
+        self.assertFalse(result)
+        self.assertEquals(group, "{}__{}".format(group_name, self.block.course_id))
 
-    @patch('rocketc.rocketc.RocketChatXBlock._api_teams')
+    @patch('rocketc.rocketc.RocketChatXBlock._add_user_to_group')
     @patch('rocketc.rocketc.RocketChatXBlock._remove_user_from_group')
     @patch('rocketc.rocketc.RocketChatXBlock._get_team')
-    def test_add_user_to_team_group(self, mock_get_team, mock_remove_user, mock_teams):
+    def test_add_user_to_team_group(self, mock_get_team, mock_remove_user, mock_add_to_group):
         """
         test method add to team group
         """
         user_id = "test_user_id"
         username = "test_user_name"
-        course_id = "test_course_id"
         auth_token = "test_auth_token"
+        self.block.team_channel = ""
 
         mock_get_team.return_value = None
-        self.block.team_channel = "test_team_channel"
 
         self.assertFalse(self.block._add_user_to_team_group(
             user_id,
             username,
-            course_id,
             auth_token)
         )
+        group_name = "{}__{}__{}".format("name", "test", self.block.course_id)
 
+        team = {"name": "name", "topic_id": "test"}
         mock_get_team.return_value = {"name": "name", "topic_id": "test"}
-        self.block.api_rocket_chat.search_rocket_chat_group.return_value = {
-            "success": True, "group": {"_id": "1234"}}
 
-        self.block._add_user_to_team_group(user_id, username, course_id, auth_token)
-        self.assertEqual(self.block.team_channel, "Team-test-name")
-
-        self.block.api_rocket_chat.add_user_to_group.assert_called_with(user_id, "1234")
-
-        self.block.api_rocket_chat.search_rocket_chat_group.return_value = {
-            "success": False}
-        self.block._add_user_to_team_group(user_id, username, course_id, auth_token)
-
-        self.block.api_rocket_chat.create_group.assert_called_with(
-            "Team-test-name", [username])
+        self.block._add_user_to_team_group(user_id, username, auth_token)
+        self.assertEqual(self.block.team_channel, group_name)
+        mock_add_to_group.assert_called_with(
+            user_id,
+            group_name,
+            members=[username],
+            custom_fields=generate_custom_fields(self.block.course_id, team),
+            create=True
+        )
 
     def test_api_rocket_chat(self):
         """
         Test api rocket chat
         """
+        self.block._api_rocket_chat = None
         with patch('rocketc.rocketc.ApiRocketChat.login'):
             with patch('rocketc.rocketc.RocketChatXBlock.xblock_settings'):
-                self.assertIsInstance(self.block._api_rocket_chat(), ApiRocketChat)
+                self.assertIsInstance(self.block.api_rocket_chat, ApiRocketChat)
 
     @patch('rocketc.rocketc.RocketChatXBlock._teams_is_enabled')
     def test_channels_enabled(self, mock_team):
@@ -132,8 +168,7 @@ def test_channels_enabled(self, mock_team):
 
     @patch('rocketc.rocketc.RocketChatXBlock._create_team_group_name')
     @patch('rocketc.rocketc.RocketChatXBlock._api_teams')
-    @patch('rocketc.rocketc.RocketChatXBlock._api_rocket_chat')
-    def test_create_group(self, mock_api_rocket, mock_teams, mock_create_name):
+    def test_create_group(self, mock_teams, mock_create_name):
         """test create group"""
 
         data = {"groupName": "", "description": "test:description",
@@ -150,38 +185,36 @@ def test_create_group(self, mock_api_rocket, mock_teams, mock_create_name):
                 "description": "test:description", "topic": "test_topic"}
 
         mock_request = MagicMock(method="POST", body=json.dumps(data))
-        mock_api_rocket.return_value.create_group.return_value = {
+        self.block._api_rocket_chat.create_group.return_value = {
             "success": True, "group": {"_id": "1234"}}
         mock_create_name.return_value = data["groupName"]
 
         result = self.block.create_group(mock_request)
 
-        mock_api_rocket.return_value.create_group.assert_called_with(data["groupName"])
-        self.assertEqual(self.block.default_channel, data["groupName"])
-        self.assertEqual(json.loads(result.body), {
-                         "success": True, "group": {"_id": "1234"}})
+        group_name = "{}__{}".format(data["groupName"], self.block.course_id)
 
-        self.block.xmodule_runtime = MagicMock()
-        self.block.xmodule_runtime.course_id.to_deprecated_string.return_value = "test_course_id"
-        result = self.block.create_group(mock_request)
-        mock_api_rocket.return_value.create_group.assert_called_with(data["groupName"], [])
+        self.block._api_rocket_chat.create_group.assert_called_with(
+            group_name,
+            [],
+            **generate_custom_fields(self.block.course_id)
+        )
         self.assertEqual(json.loads(result.body), {
                          "success": True, "group": {"_id": "1234"}})
 
-    @patch('rocketc.rocketc.RocketChatXBlock._api_rocket_chat')
     @patch('rocketc.rocketc.RocketChatXBlock._api_teams')
-    def test_get_groups(self, mock_teams, mock_api_rocket):
+    def test_get_groups(self, mock_teams):
         """
         Test get_groups
         """
-        mock_api_rocket.return_value.get_groups.side_effect = [["Team-group", "group1", "group2"], ["Team-group"]]
-        groups = self.block.get_groups()
-        self.assertEqual(groups, ["", "(Team Group)-Team-group", "group1", "group2"])
+        with patch('rocketc.rocketc.RocketChatXBlock.api_rocket_chat', new_callable=PropertyMock) as mock_api_rocket:
+            mock_api_rocket.return_value.get_groups.side_effect = [["group1", "group2"], ["Team-group"]]
+            groups = self.block.get_groups()
+            self.assertEqual(groups, ["", "(Team Group)-Team-group", "group1", "group2"])
 
     @patch('rocketc.rocketc.RocketChatXBlock._grading_discussions')
     @patch('rocketc.rocketc.RocketChatXBlock._update_user')
     @patch('rocketc.rocketc.RocketChatXBlock._join_user_to_groups')
-    @patch('rocketc.rocketc.RocketChatXBlock.login')
+    @patch('rocketc.rocketc.RocketChatXBlock._login')
     def test_init(self, mock_login, mock_join_user, mock_update_user, mock_grading):
         """
         Test the method to initialize the xblock
@@ -199,7 +232,6 @@ def test_init(self, mock_login, mock_join_user, mock_update_user, mock_grading):
             self.assertEqual(self.block.init(), data)
             mock_join_user.assert_called_with(user_id, user_data, auth_token)
             mock_update_user.assert_called_with(user_id, user_data)
-            self.block.api_rocket_chat.change_user_role.assert_called_with(user_id, "bot")
 
             mock_login.return_value = {
                 "success": False, "errorType": "test_error"}
@@ -218,14 +250,14 @@ def test_login(self):
         self.block.api_rocket_chat.create_token.return_value = {'success': True}
         success = {'success': True}
 
-        result_if = self.block.login(test_data)
+        result_if = self.block._login(test_data)
         self.block.api_rocket_chat.create_token.assert_called_with(test_data['username'])
 
         success['success'] = False
 
         self.block.api_rocket_chat.search_rocket_chat_user.return_value = success
         cache.clear()
-        result_else = self.block.login(test_data)
+        result_else = self.block._login(test_data)
         self.block.api_rocket_chat.create_user.assert_called_with(test_data["anonymous_student_id"], test_data[
             "email"], test_data["username"])
         self.block.api_rocket_chat.create_token.assert_called_with(test_data['username'])
@@ -238,17 +270,15 @@ def test_get_team(self):
         This method gets the user's team
         """
         username = "test_user_name"
-        course_id = " test_course_id"
-        self.block.api_teams = MagicMock()
-        self.block.api_teams.get_user_team.return_value = ["test_team"]
+        self.block._api_teams = MagicMock()
+        self.block._api_teams.get_user_team.return_value = ["test_team"]
 
         with patch('rocketc.rocketc.RocketChatXBlock.xblock_settings', new_callable=PropertyMock) as mock_settings:
             mock_settings.return_value = {"username": "test_user_name", "password": "test_password",
                                           "client_id": "test_id", "client_secret": "test_secret"}
-            self.assertEqual(self.block._get_team(
-                username, course_id), "test_team")
+            self.assertEqual(self.block._get_team(username), "test_team")
             self.block.api_teams.get_user_team.return_value = []
-            self.assertIsNone(self.block._get_team(username, course_id))
+            self.assertIsNone(self.block._get_team(username))
 
     def test_join_user_to_groups(self):
         """
@@ -271,7 +301,7 @@ def test_join_user_to_groups(self):
 
         self.block.selected_view = "Specific Channel"
 
-        with patch('rocketc.rocketc.RocketChatXBlock._add_user_to_default_group', return_value=True):
+        with patch('rocketc.rocketc.RocketChatXBlock._add_user_to_specific_group', return_value=(True, "")):
             self.block._join_user_to_groups(user_id, user_data, auth_token)
             self.assertTrue(self.block.ui_is_block)
 
@@ -295,14 +325,9 @@ def test_update_user(self, mock_url):
         self.block.api_rocket_chat.set_avatar.assert_called_with(
             user_data["username"], "test_url")
 
-    def test_user_data(self):
-
-        mock_runtime = MagicMock()
-        mock_runtime.course_id.to_deprecated_string.return_value = "test_course_id"
-        self.block.xmodule_runtime = mock_runtime
+    def test_course_id(self):
 
-        data = self.block.user_data
-        self.assertEqual(data["course"], "testcourseid")
+        self.assertEqual(self.block.course_id, "testcourseid")
 
     @override_settings(LMS_ROOT_URL="http://127.0.0.1/")
     @patch('rocketc.rocketc.User')