Fix #27.

* Change firstName and lastName keys to firstname and lastname on create and update.
* Fix test_mode network calls to return result as expected.

Author: brotskydotcom

setup.py

@@ -21,7 +21,7 @@
 from setuptools import setup, find_packages
 
 setup(name='umapi-client',
-      version='2.0',
+      version='2.0.1',
       description='Client for the User Management API (UMAPI) from Adobe - see https://adobe.ly/2h1pHgV',
       long_description=('The User Management API (aka the UMAPI) is an Adobe-hosted network service '
                         'which provides Adobe Enterprise customers the ability to manage their users.  This '

tests/test_connections.py

@@ -60,13 +60,27 @@ def test_get_success():
         assert conn.make_call("").json() == ["test", "body"]
 
 
+def test_get_success_test_mode():
+    with mock.patch("umapi_client.connection.requests.get") as mock_get:
+        mock_get.return_value = MockResponse(200, body=["test", "body"])
+        conn = Connection(test_mode=True, **mock_connection_params)
+        assert conn.make_call("").json() == ["test", "body"]
+
+
 def test_post_success():
     with mock.patch("umapi_client.connection.requests.post") as mock_post:
         mock_post.return_value = MockResponse(200, body=["test", "body"])
         conn = Connection(**mock_connection_params)
         assert conn.make_call("", [3, 5]).json() == ["test", "body"]
 
 
+def test_post_success_test_mode():
+    with mock.patch("umapi_client.connection.requests.post") as mock_post:
+        mock_post.return_value = MockResponse(200, body=["test", "body"])
+        conn = Connection(test_mode=True, **mock_connection_params)
+        assert conn.make_call("", [3, 5]).json() == ["test", "body"]
+
+
 def test_get_timeout():
     with mock.patch("umapi_client.connection.requests.get") as mock_get:
         mock_get.side_effect = requests.Timeout

tests/test_functional.py

@@ -74,7 +74,7 @@ def test_create_user_enterpriseid():
     user = UserAction(id_type=IdentityTypes.enterpriseID, email="[email protected]")
     user.create(first_name="Daniel", last_name="Brotsky")
     assert user.wire_dict() == {"do": [{"createEnterpriseID": {"email": "[email protected]",
-                                                               "firstName": "Daniel", "lastName": "Brotsky",
+                                                               "firstname": "Daniel", "lastname": "Brotsky",
                                                                "country": "UD"}}],
                                 "user": "[email protected]"}
 
@@ -83,7 +83,7 @@ def test_create_user_federatedid():
     user = UserAction(id_type=IdentityTypes.federatedID, email="[email protected]")
     user.create(first_name="Daniel", last_name="Brotsky", country="US")
     assert user.wire_dict() == {"do": [{"createFederatedID": {"email": "[email protected]",
-                                                              "firstName": "Daniel", "lastName": "Brotsky",
+                                                              "firstname": "Daniel", "lastname": "Brotsky",
                                                               "country": "US"}}],
                                 "user": "[email protected]"}
 
@@ -92,7 +92,7 @@ def test_create_user_federatedid_username():
     user = UserAction(id_type=IdentityTypes.federatedID, username="dbrotsky", domain="k.on-the-side.net")
     user.create(first_name="Daniel", last_name="Brotsky", country="US", email="[email protected]")
     assert user.wire_dict() == {"do": [{"createFederatedID": {"email": "[email protected]",
-                                                              "firstName": "Daniel", "lastName": "Brotsky",
+                                                              "firstname": "Daniel", "lastname": "Brotsky",
                                                               "country": "US"}}],
                                 "user": "dbrotsky", "domain": "k.on-the-side.net"}
 
@@ -102,7 +102,7 @@ def test_create_user_federatedid_username_email():
                       email="[email protected]")
     user.create(first_name="Daniel", last_name="Brotsky", country="US")
     assert user.wire_dict() == {"do": [{"createFederatedID": {"email": "[email protected]",
-                                                              "firstName": "Daniel", "lastName": "Brotsky",
+                                                              "firstname": "Daniel", "lastname": "Brotsky",
                                                               "country": "US"}}],
                                 "user": "dbrotsky", "domain": "k.on-the-side.net"}
 
@@ -117,7 +117,7 @@ def test_create_user_federatedid_username_mismatch():
 def test_update_user_federatedid():
     user = UserAction(id_type=IdentityTypes.federatedID, email="[email protected]")
     user.update(first_name="Johnny", last_name="Danger")
-    assert user.wire_dict() == {"do": [{"update": {"firstName": "Johnny", "lastName": "Danger"}}],
+    assert user.wire_dict() == {"do": [{"update": {"firstname": "Johnny", "lastname": "Danger"}}],
                                 "user": "[email protected]"}
 
 

tests/test_live.py

@@ -73,11 +73,19 @@ def test_list_groups(config):
             assert name in params["big_groups"]
     logging.info("Found %d groups.", len(groups.all_results()))
 
-
 def test_get_user(config):
     conn, params = config
     user_query = umapi_client.UserQuery(conn, params["test_user"]["email"])
     user = user_query.result()
     logging.info("User: %s", user)
     for k, v in six.iteritems(params["test_user"]):
         assert user[k].lower() == v.lower()
+
+def test_rename_user(config):
+    conn, params = config
+    user = umapi_client.UserAction(id_type=params["test_user"]["type"],
+                                   email=params["test_user"]["email"],
+                                   username=params["test_user"]["username"])
+    user.update(first_name="Rodney", last_name="Danger")
+    user.update(first_name=params["test_user"]["firstname"], last_name=params["test_user"]["lastname"])
+    assert (0, 1, 1) == conn.execute_single(user, immediate=True)

umapi_client/connection.py

@@ -327,7 +327,7 @@ def _execute_batch(self, actions):
         """
         wire_form = [a.wire_dict() for a in actions]
         if self.test_mode:
-            result = self.make_call("/action/%s?testOnly=true" % self.org_id, wire_form).json()
+            result = self.make_call("/action/%s?testOnly=true" % self.org_id, wire_form)
         else:
             result = self.make_call("/action/%s" % self.org_id, wire_form)
         body = result.json()

umapi_client/functional.py

@@ -71,11 +71,22 @@ def _validate(email=None, username=None, domain=None):
     def __init__(self, id_type=IdentityTypes.adobeID, email=None, username=None, domain=None, **kwargs):
         """
         Create an Action for a user identified either by email or by username and domain.
-        You can specify email and username in which case the email provides the domain and is remembered
-        for use in later commands associated with this user.
+        You should pretty much always use just email, unless the user has a Federated ID and his
+        username is different from his email.  In that case you can give either username and email
+        (and we'll get the domain from his email) or the username and domain (in case you don't
+        know or don't care about the user's email).
+        Note that the identity type determines what you can do with this user.  For example,
+        create will create a user of the specified identity type.  Similarly, each identity type restricts
+        what fields can be updated.  If you are specifying an existing user by email, and you are not
+        sure what identity type the existing user is, and you are doing something (such as add_to_groups)
+        that can be done with any identity type, then you can specify any type, and the type you specify
+        will be used to break ties if there is both an AdobeID and an EnterpriseID or FederatedID user
+        with that same email.  Normally, we choose Enterprise ID or Federated ID *over* Adobe ID, but
+        if you specify the type as Adobe ID then we will act on the Adobe ID user instead.
         :param id_type: IdentityTypes enum value (or the name of one), defaults to adobeID
-        :param username: string, username in the Adobe domain (might be email)
-        :param domain: string, required if the username is not an email address
+        :param email: The user's email.  Typically this is also the user's username.
+        :param username: The username on the Adobe side.  If it's the same as email, it's ignored.
+        :param domain: string, needed only if you specified a username but NOT an email.
         :param kwargs: other key/value pairs for the action, such as requestID
         """
         if str(id_type) in IdentityTypes.__members__:
@@ -150,8 +161,8 @@ def create(self, first_name=None, last_name=None, country=None, email=None,
             return self.insert(addAdobeID=dict(email=str(email), **create_params))
         else:
             # Federated and Enterprise allow specifying the name
-            if first_name: create_params["firstName"] = str(first_name)
-            if last_name: create_params["lastName"] = str(last_name)
+            if first_name: create_params["firstname"] = str(first_name)
+            if last_name: create_params["lastname"] = str(last_name)
             if self.id_type == IdentityTypes.enterpriseID:
                 # Enterprise ID can default country, already has email on create
                 create_params["country"] = str(country) if country else "UD"
@@ -181,7 +192,7 @@ def update(self, email=None, username=None, first_name=None, last_name=None, cou
             self._validate(email=username)
         updates = {}
         for k, v in six.iteritems(dict(email=email, username=username,
-                                       firstName=first_name, lastName=last_name,
+                                       firstname=first_name, lastname=last_name,
                                        country=country)):
             if v: updates[k] = str(v)
         return self.append(update=updates)