Working exceptions for tested group operations

bootstrap/core_algorithm.alc

@@ -2185,7 +2185,7 @@ String function cmd_group_owner_add(group_name : String, other_user_name : Strin
 				else:
 					return "User is already the owner!"!
 			else:
-				return "User not found: " + other_user_name!
+				return "Unknown user: " + other_user_name!
 		else:
 			return "Group permission denied to: " + group_name!
 	else:
@@ -2212,7 +2212,7 @@ String function cmd_group_owner_delete(group_name : String, other_user_name : St
 				else:
 					return "User is not a member of the group!"!
 			else:
-				return "User not found: " + other_user_name!
+				return "Unknown user: " + other_user_name!
 		else:
 			return "Group permission denied to: " + group_name!
 	else:
@@ -2234,7 +2234,7 @@ String function cmd_group_join(group_name : String, other_user_name : String):
 				else:
 					return "User is already a member of the group!"!
 			else:
-				return "User not found: " + other_user_name!
+				return "Unknown user: " + other_user_name!
 		else:
 			return "Group permission denied to: " + group_name!
 	else:

unit/test_all.py

@@ -529,11 +529,7 @@ class TestModelverse(unittest.TestCase):
             pass
 
         # Switch to admin for now
-        user_logout()
-        login("admin", "admin")
-        admin_promote("user")
-        user_logout()
-        login("user", "user")
+        self.do_as_user("admin", admin_promote, ["user"])
 
         # Verify that we can do admin operations
         assert len(element_list("administration/core")) > 0
@@ -2403,20 +2399,12 @@ class TestModelverse(unittest.TestCase):
         assert group_list() == set([(group_name_1, True), (group_name_2, True)])
 
         # Test other groups
-        user_logout()
-        login("user2", "user2")
-        group_create(group_name_3)
-        group_create(group_name_4)
-        user_logout()
-        login("user", "user")
+        self.do_as_user("user2", group_create, [group_name_3])
+        self.do_as_user("user2", group_create, [group_name_4])
         assert group_list() == set([(group_name_1, True), (group_name_2, True)])
 
         # Test non-admin groups
-        user_logout()
-        login("user2", "user2")
-        group_join(group_name_3, "user")
-        user_logout()
-        login("user", "user")
+        self.do_as_user("user2", group_join, [group_name_3, "user"])
         assert group_list() == set([(group_name_1, True), (group_name_2, True), (group_name_3, False)])
 
         # Test create of existing group (member)
@@ -2436,14 +2424,10 @@ class TestModelverse(unittest.TestCase):
             assert group_list() == before
 
         # Delete all groups again
-        user_logout()
-        login("admin", "admin")
-        group_delete(group_name_1)
-        group_delete(group_name_2)
-        group_delete(group_name_3)
-        group_delete(group_name_4)
-        user_logout()
-        login("user", "user")
+        self.do_as_user("admin", group_delete, [group_name_1])
+        self.do_as_user("admin", group_delete, [group_name_2])
+        self.do_as_user("admin", group_delete, [group_name_3])
+        self.do_as_user("admin", group_delete, [group_name_4])
 
     def test_op_group_delete(self):
         group_name_1 = "new_group"      # Group with admin permissions
@@ -2451,20 +2435,14 @@ class TestModelverse(unittest.TestCase):
         group_name_3 = "other_group"    # No member
         group_name_4 = "second_group"   # Non-existing group
 
-        user_logout()
-        login("user2", "user2")
-        user_logout()
-        login("user", "user")
+        # Ensure user2 exists
+        self.do_as_user("user2", lambda : 1, [])
 
         # Create some groups first
         group_create(group_name_1)
-        user_logout()
-        login("admin", "admin")
-        group_create(group_name_2)
-        group_join(group_name_2, "user")
-        group_create(group_name_3)
-        user_logout()
-        login("user", "user")
+        self.do_as_user("admin", group_create, [group_name_2])
+        self.do_as_user("admin", group_join, [group_name_2, "user"])
+        self.do_as_user("admin", group_create, [group_name_3])
 
         # Try to delete all 
         assert group_list() == set([(group_name_1, True), (group_name_2, False)])
@@ -2494,25 +2472,14 @@ class TestModelverse(unittest.TestCase):
         # Test if other users can no longer see removed groups
         group_create(group_name_1)
         group_join(group_name_1, "user2")
-        user_logout()
-        login("user2", "user2")
-        assert group_list() == set([(group_name_1, False)])
-        user_logout()
-        login("user", "user")
+        assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
+
         group_delete(group_name_1)
-        user_logout()
-        login("user2", "user2")
-        assert group_list() == set([])
-        user_logout()
-        login("user", "user")
+        assert self.do_as_user("user2", group_list, []) == set([])
 
         # Delete all groups again
-        user_logout()
-        login("admin", "admin")
-        group_delete(group_name_2)
-        group_delete(group_name_3)
-        user_logout()
-        login("user", "user")
+        self.do_as_user("admin", group_delete, [group_name_2])
+        self.do_as_user("admin", group_delete, [group_name_3])
 
     def test_op_group_list(self):
         group_name_1 = "new_group"      # Group with admin permissions
@@ -2520,57 +2487,87 @@ class TestModelverse(unittest.TestCase):
         group_name_3 = "other_group"    # No member
         group_name_4 = "second_group"   # Non-existing group
 
-        user_logout()
-        login("user2", "user2")
-        user_logout()
-        login("user", "user")
+        # Ensure user2 exists
+        self.do_as_user("user2", lambda : 1, [])
 
         # Create some groups first
         group_create(group_name_1)
-        user_logout()
-        login("admin", "admin")
-        group_create(group_name_2)
-        group_join(group_name_2, "user")
-        group_create(group_name_3)
-        user_logout()
-        login("user", "user")
+        self.do_as_user("admin", group_create, [group_name_2])
+        self.do_as_user("admin", group_join, [group_name_2, "user"])
+        self.do_as_user("admin", group_create, [group_name_3])
 
         # Assure that groups of all users are correct
-        user_logout()
-        login("user", "user")
         assert group_list() == set([(group_name_1, True), (group_name_2, False)])
-        user_logout()
-        login("user2", "user2")
-        assert group_list() == set([])
-        user_logout()
-        login("admin", "admin")
-        assert group_list() == set([("admin", False), (group_name_2, True), (group_name_3, True)])
-        user_logout()
-        login("user", "user")
+
+        assert self.do_as_user("user2", group_list, []) == set([])
+        assert self.do_as_user("admin", group_list, []) == set([("admin", False), (group_name_2, True), (group_name_3, True)])
 
         # Delete a group to check that everything is correctly listed afterwards
-        user_logout()
-        login("admin", "admin")
-        group_delete(group_name_2)
-        user_logout()
-        login("user", "user")
+        self.do_as_user("admin", group_delete, [group_name_2])
         assert group_list() == set([(group_name_1, True)])
-        user_logout()
-        login("user2", "user2")
-        assert group_list() == set([])
-        user_logout()
-        login("admin", "admin")
-        assert group_list() == set([("admin", False), (group_name_3, True)])
-        user_logout()
-        login("user", "user")
+        assert self.do_as_user("user2", group_list, []) == set([])
+        assert self.do_as_user("admin", group_list, []) == set([("admin", False), (group_name_3, True)])
 
         # Delete all groups again
+        self.do_as_user("admin", group_delete, [group_name_1])
+        self.do_as_user("admin", group_delete, [group_name_3])
+
+    def do_as_user(self, username, operation, args):
         user_logout()
-        login("admin", "admin")
-        group_delete(group_name_1)
-        group_delete(group_name_3)
+        login(username, username)
+        result = operation(*args)
         user_logout()
         login("user", "user")
+        return result
+
+    def test_op_group_join(self):
+        group_name_1 = "new_group"      # Group with admin permissions
+        group_name_2 = "group2"         # Group without permissions
+        group_name_3 = "other_group"    # No member
+        group_name_4 = "second_group"   # Non-existing group
+
+        # Ensure user2 exists
+        self.do_as_user("user2", lambda : 1, [])
+
+        # Create some groups first
+        group_create(group_name_1)
+        self.do_as_user("admin", group_create, [group_name_2])
+        self.do_as_user("admin", group_join, [group_name_2, "user"])
+        self.do_as_user("admin", group_create, [group_name_3])
+
+        # Test for group join basic use, of group where we are admin
+        assert group_join(group_name_1, "user2") == None
+        assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
+
+        # Test for group join of group where we are no admin
+        try:
+            group_join(group_name_2, "user2") == None
+        except GroupPermissionDenied:
+            assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
+
+        # Test for group join of group where we are not even a member
+        try:
+            group_join(group_name_3, "user2") == None
+        except GroupPermissionDenied:
+            assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
+
+        # Test for group join of group that already has user as member
+        try:
+            group_join(group_name_1, "user2") == None
+        except UserExists:
+            assert self.do_as_user("user2", group_list, []) == set([(group_name_1, False)])
+
+        # Test for group join of non-existing user
+        try:
+            group_join(group_name_1, "user123") == None
+        except UnknownUser:
+            pass
+
+        # Test for group join of non-existing group
+        try:
+            group_join(group_name_4, "user2") == None
+        except UnknownGroup:
+            pass
 
     """
     def do_create_user(self, name):
@@ -2616,7 +2613,6 @@ class TestModelverse(unittest.TestCase):
     def test_op_permission_owner(self):
     def test_op_group_owner_add(self):
     def test_op_group_owner_delete(self):
-    def test_op_group_join(self):
     def test_op_group_kick(self):
     def test_op_conformance_delete(self):
     def test_op_conformance_add(self):

wrappers/classes/modelverse.xml

@@ -1377,6 +1377,13 @@
                         </raise>
                     </transition>
 
+                    <transition cond="self.expect_response_partial('User exists: ', pop=False)" target="../wait_for_action/history">
+                        <raise event="exception">
+                            <parameter expr="'UserExists'"/>
+                            <parameter expr="self.split_response(self.responses.pop(0))[0]"/>
+                        </raise>
+                    </transition>
+
                     <transition cond="self.expect_response_partial('Model exists: ', pop=False)" target="../wait_for_action/history">
                         <raise event="exception">
                             <parameter expr="'ModelExists'"/>

wrappers/modelverse.py

@@ -75,6 +75,9 @@ class FolderExists(ExistsError):
 class GroupExists(ExistsError):
     pass
 
+class UserExists(ExistsError):
+    pass
+
 class PermissionDenied(ModelverseException):
     pass
 

wrappers/modelverse_SCCD.py

@@ -1804,6 +1804,11 @@ class Modelverse(RuntimeClassBase):
         _initialized_behaviour_operations_25.setTrigger(None)
         _initialized_behaviour_operations_25.setGuard(self._initialized_behaviour_operations_25_guard)
         self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_25)
+        _initialized_behaviour_operations_26 = Transition(self, self.states["/initialized/behaviour/operations"], [self.states["/initialized/behaviour/wait_for_action/history"]])
+        _initialized_behaviour_operations_26.setAction(self._initialized_behaviour_operations_26_exec)
+        _initialized_behaviour_operations_26.setTrigger(None)
+        _initialized_behaviour_operations_26.setGuard(self._initialized_behaviour_operations_26_guard)
+        self.states["/initialized/behaviour/operations"].addTransition(_initialized_behaviour_operations_26)
         
         # transition /initialized/behaviour/wait_for_action
         _initialized_behaviour_wait_for_action_0 = Transition(self, self.states["/initialized/behaviour/wait_for_action"], [self.states["/initialized/behaviour/wait_for_action/history"]])
@@ -2218,119 +2223,125 @@ class Modelverse(RuntimeClassBase):
         return self.expect_response_partial('Not an association: ', pop=False)
     
     def _initialized_behaviour_operations_7_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ModelExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UserExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_7_guard(self, parameters):
-        return self.expect_response_partial('Model exists: ', pop=False)
+        return self.expect_response_partial('User exists: ', pop=False)
     
     def _initialized_behaviour_operations_8_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ModelExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_8_guard(self, parameters):
-        return self.expect_response_partial('Group exists: ', pop=False)
+        return self.expect_response_partial('Model exists: ', pop=False)
     
     def _initialized_behaviour_operations_9_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['FolderExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['GroupExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_9_guard(self, parameters):
-        return self.expect_response_partial('Folder exists: ', pop=False)
+        return self.expect_response_partial('Group exists: ', pop=False)
     
     def _initialized_behaviour_operations_10_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AttributeExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['FolderExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_10_guard(self, parameters):
-        return self.expect_response_partial('Attribute exists: ', pop=False)
+        return self.expect_response_partial('Folder exists: ', pop=False)
     
     def _initialized_behaviour_operations_11_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['AttributeExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_11_guard(self, parameters):
-        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
+        return self.expect_response_partial('Attribute exists: ', pop=False)
     
     def _initialized_behaviour_operations_12_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ElementExists', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownM3', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_12_guard(self, parameters):
-        return self.expect_response_partial('Element exists: ', pop=False)
+        return self.expect_response_partial('Type cannot be typed as formalisms/SimpleClassDiagrams: ', pop=False)
     
     def _initialized_behaviour_operations_13_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ElementExists', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_13_guard(self, parameters):
-        return self.expect_response_partial('Read permission denied to: ', pop=False)
+        return self.expect_response_partial('Element exists: ', pop=False)
     
     def _initialized_behaviour_operations_14_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ReadPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_14_guard(self, parameters):
-        return self.expect_response_partial('Write permission denied to: ', pop=False)
+        return self.expect_response_partial('Read permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_15_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_15_guard(self, parameters):
-        return self.expect_response('Write permission denied', pop=True)
+        return self.expect_response_partial('Write permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_16_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['NoSimpleClassDiagramsModel', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
+        self.raiseInternalEvent(Event("exception", None, ['WritePermissionDenied', self.current_model]))
     
     def _initialized_behaviour_operations_16_guard(self, parameters):
-        return self.expect_response_partial('Not a SimpleClassDiagrams model!', pop=True)
+        return self.expect_response('Write permission denied', pop=True)
     
     def _initialized_behaviour_operations_17_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['ExecutePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['NoSimpleClassDiagramsModel', 'Model is not a Simple Class Diagrams model and has no notion of defined attributes']))
     
     def _initialized_behaviour_operations_17_guard(self, parameters):
-        return self.expect_response_partial('Execute permission denied to: ', pop=False)
+        return self.expect_response_partial('Not a SimpleClassDiagrams model!', pop=True)
     
     def _initialized_behaviour_operations_18_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['ExecutePermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_18_guard(self, parameters):
-        return self.expect_response_partial('Group permission denied to: ', pop=False)
+        return self.expect_response_partial('Execute permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_19_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['GroupPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_19_guard(self, parameters):
-        return self.expect_response_partial('User permission denied to: ', pop=False)
+        return self.expect_response_partial('Group permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_20_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['AdminPermissionDenied', 'Admin permissions are required for this operation!']))
+        self.raiseInternalEvent(Event("exception", None, ['UserPermissionDenied', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_20_guard(self, parameters):
-        return self.expect_response_partial('Admin permission denied', pop=True)
+        return self.expect_response_partial('User permission denied to: ', pop=False)
     
     def _initialized_behaviour_operations_21_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['InterfaceMismatch', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['AdminPermissionDenied', 'Admin permissions are required for this operation!']))
     
     def _initialized_behaviour_operations_21_guard(self, parameters):
-        return self.expect_response_partial('Incorrect format: ', pop=False)
+        return self.expect_response_partial('Admin permission denied', pop=True)
     
     def _initialized_behaviour_operations_22_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['InterfaceMismatch', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_22_guard(self, parameters):
-        return self.expect_response_partial('Element not found: ', pop=False)
+        return self.expect_response_partial('Incorrect format: ', pop=False)
     
     def _initialized_behaviour_operations_23_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownElement', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_23_guard(self, parameters):
-        return self.expect_response_partial('Model not found: ', pop=False)
+        return self.expect_response_partial('Element not found: ', pop=False)
     
     def _initialized_behaviour_operations_24_exec(self, parameters):
-        self.raiseInternalEvent(Event("exception", None, ['UnknownMetamodellingHierarchy', 'Metamodelling hierarchy could not be resolved or automatically inferred: there is no typing relation between your specified model and metamodel (%s)' % self.responses.pop(0)]))
+        self.raiseInternalEvent(Event("exception", None, ['UnknownModel', self.split_response(self.responses.pop(0))[0]]))
     
     def _initialized_behaviour_operations_24_guard(self, parameters):
-        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+        return self.expect_response_partial('Model not found: ', pop=False)
     
     def _initialized_behaviour_operations_25_exec(self, parameters):
+        self.raiseInternalEvent(Event("exception", None, ['UnknownMetamodellingHierarchy', 'Metamodelling hierarchy could not be resolved or automatically inferred: there is no typing relation between your specified model and metamodel (%s)' % self.responses.pop(0)]))
+    
+    def _initialized_behaviour_operations_25_guard(self, parameters):
+        return self.expect_response_partial('Conformance hierarchy unknown for: ', pop=False)
+    
+    def _initialized_behaviour_operations_26_exec(self, parameters):
         print("Unknown Error: " + self.responses[0])
         pass
         self.raiseInternalEvent(Event("exception", None, ['UnknownError', 'Error: %s' % self.responses.pop(0)]))
     
-    def _initialized_behaviour_operations_25_guard(self, parameters):
+    def _initialized_behaviour_operations_26_guard(self, parameters):
         return self.expect_response_partial('', pop=False)
     
     def _initialized_behaviour_wait_for_action_0_exec(self, parameters):