Merge ppa-dev-tools:fix-lp1990244-create-for-owner into ppa-dev-tools:main

[Bryce Harrington]

This adds the ability to create PPAs against other teams that your LP user account has access to, fixing LP: #1990244. You can specify the team by a command line argument, config file variable, or the ppa address.
For example:

$ ./scripts/ppa create --team ppa-dev-tools-devs foobar
PPA 'foobar' created for the following architectures:

  i386, amd64, armhf, ppc64el, s390x, arm64, powerpc

The PPA can be viewed at:

  https://launchpad.net/~ppa-dev-tools-devs/+archive/ubuntu/foobar

...

$ ./scripts/ppa create ppa-dev-tools-devs/example
PPA 'example' created for the following architectures:

  i386, amd64, armhf, ppc64el, s390x, arm64, powerpc

The PPA can be viewed at:

  https://launchpad.net/~ppa-dev-tools-devs/+archive/ubuntu/example

...

[Christian Ehrhardt  (paelzer)]

I like this, I do not feel I was able to do a full review - but for whatever it is worth it LGTM.
Furthermore I have left a few small comments inline for you to think about.

[Lena Voytek (lvoytek)]

LGTM, added a few comments below for formatting/descriptions

review: Approve

[Bryce Harrington (bryce)]

Thanks, I've updated with the changes as suggested and landed:

Total 0 (delta 0), reused 0 (delta 0), pack-reused 0
To git+ssh://git.launchpad.net/ppa-dev-tools
   2a8e2ef..9dbaa6f main -> main

diff --git a/NEWS.md b/NEWS.md
index 61c117e..e6bdaeb 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -9,6 +9,15 @@ jobs that it is monitoring are failed builds.  These options are aimed
 to facilitate CI/CD integration, but can also improve performance of the
 waiting operation on larger PPAs.
 
+It is now possible to create PPAs under a different team's ownership via
+the --owner option:
+
+    $ ppa create --owner foobar my-ppa
+
+As a convenience, this can also be specified in ppa address form, i.e.:
+
+    $ ppa create ppa:foobar/my-ppa
+
 
 # 0.4.0 #
 
diff --git a/ppa/ppa.py b/ppa/ppa.py
index 6e3a071..0cccb10 100755
--- a/ppa/ppa.py
+++ b/ppa/ppa.py
@@ -36,14 +36,15 @@ class PendingReason(enum.Enum):
 class PpaDoesNotExist(BaseException):
     """Exception indicating a requested PPA could not be found."""
 
-    def __init__(self, ppa_name, team_name, message=None):
+    def __init__(self, ppa_name, owner_name, message=None):
         """Initializes the exception object.
 
         :param str ppa_name: The name of the missing PPA.
+        :param str owner_name: The person or team the PPA belongs to.
         :param str message: An error message.
         """
         self.ppa_name = ppa_name
-        self.team_name = team_name
+        self.owner_name = owner_name
         self.message = message
 
     def __str__(self):
@@ -54,7 +55,7 @@ class PpaDoesNotExist(BaseException):
         """
         if self.message:
             return self.message
-        return f"The PPA '{self.ppa_name}' does not exist for team or user '{self.team_name}'"
+        return f"The PPA '{self.ppa_name}' does not exist for person or team '{self.owner_name}'"
 
 
 class Ppa:
@@ -70,25 +71,27 @@ class Ppa:
         "    + Launchpad Build Page: {build_page}\n"
     )
 
-    def __init__(self, ppa_name, team_name, ppa_description=None, service=None):
+    def __init__(self, ppa_name, owner_name, ppa_description=None, service=None):
         """Initializes a new Ppa object for a given PPA.
 
         This creates only the local representation of the PPA, it does
         not cause a new PPA to be created in Launchpad.  For that, see
         PpaGroup.create()
 
-        :param str ppa_name: The name of the PPA within the team's namespace.
-        :param str team_name: The name of the team or user that owns the PPA.
+        :param str ppa_name: The name of the PPA within the owning
+            person or team's namespace.
+        :param str owner_name: The name of the person or team the PPA
+            belongs to.
         :param str ppa_description: Optional description text for the PPA.
         :param launchpadlib.service service: The Launchpad service object.
         """
         if not ppa_name:
             raise ValueError("undefined ppa_name.")
-        if not team_name:
-            raise ValueError("undefined team_name.")
+        if not owner_name:
+            raise ValueError("undefined owner_name.")
 
         self.ppa_name = ppa_name
-        self.team_name = team_name
+        self.owner_name = owner_name
         if ppa_description is None:
             self.ppa_description = ''
         else:
@@ -102,7 +105,7 @@ class Ppa:
         :returns: Official string representation of the object.
         """
         return (f'{self.__class__.__name__}('
-                f'ppa_name={self.ppa_name!r}, team_name={self.team_name!r})')
+                f'ppa_name={self.ppa_name!r}, owner_name={self.owner_name!r})')
 
     def __str__(self) -> str:
         """Returns a displayable string identifying the PPA.
@@ -110,7 +113,7 @@ class Ppa:
         :rtype: str
         :returns: Displayable representation of the PPA.
         """
-        return f"{self.team_name}/{self.name}"
+        return f"{self.owner_name}/{self.name}"
 
     @property
     @lru_cache
@@ -124,10 +127,10 @@ class Ppa:
         if not self._service:
             raise AttributeError("Ppa object not connected to the Launchpad service")
         try:
-            owner = self._service.people[self.team_name]
+            owner = self._service.people[self.owner_name]
             return owner.getPPAByName(name=self.ppa_name)
         except NotFound:
-            raise PpaDoesNotExist(self.ppa_name, self.team_name)
+            raise PpaDoesNotExist(self.ppa_name, self.owner_name)
 
     @lru_cache
     def exists(self) -> bool:
@@ -146,7 +149,7 @@ class Ppa:
         :rtype: str
         :returns: The full identification string for the PPA.
         """
-        return "ppa:{}/{}".format(self.team_name, self.ppa_name)
+        return "ppa:{}/{}".format(self.owner_name, self.ppa_name)
 
     @property
     def name(self):
@@ -269,8 +272,8 @@ class Ppa:
         base = self._service.API_ROOT_URL.rstrip('/')
         new_ppa_deps = []
         for ppa_address in ppa_addresses:
-            team_name, ppa_name = ppa_address_split(ppa_address)
-            new_ppa_dep = f'{base}/~{team_name}/+archive/ubuntu/{ppa_name}'
+            owner_name, ppa_name = ppa_address_split(ppa_address)
+            new_ppa_dep = f'{base}/~{owner_name}/+archive/ubuntu/{ppa_name}'
             new_ppa_deps.append(new_ppa_dep)
 
         # TODO: Remove all existing dependencies
@@ -529,44 +532,47 @@ class Ppa:
         return []
 
 
-def ppa_address_split(ppa_address, default_team=None):
-    """Parse an address for a PPA into its team and name components.
+def ppa_address_split(ppa_address):
+    """Parse an address for a PPA into its owner and name components.
 
     :param str ppa_address: A ppa name or address.
-    :param str default_team: (Optional) name of team to use if missing.
     :rtype: tuple(str, str)
-    :returns: The team name and ppa name as a tuple, or (None, None) on error.
+    :returns: The owner name and ppa name as a tuple, or (None, None) on error.
     """
+    owner_name = None
+
     if not ppa_address or len(ppa_address) < 2:
         return (None, None)
     if ppa_address.startswith('ppa:'):
         if '/' not in ppa_address:
             return (None, None)
         rem = ppa_address.split('ppa:', 1)[1]
-        team_name = rem.split('/', 1)[0]
+        owner_name = rem.split('/', 1)[0]
         ppa_name = rem.split('/', 1)[1]
     elif ppa_address.startswith('http'):
         # Only launchpad PPA urls are supported
         m = re.search(r'https:\/\/launchpad\.net\/~([^/]+)\/\+archive\/ubuntu\/(.+)$', ppa_address)
         if not m:
             return (None, None)
-        team_name = m.group(1)
+        owner_name = m.group(1)
         ppa_name = m.group(2)
     elif '/' in ppa_address:
-        team_name = ppa_address.split('/', 1)[0]
+        owner_name = ppa_address.split('/', 1)[0]
         ppa_name = ppa_address.split('/', 1)[1]
     else:
-        team_name = default_team
         ppa_name = ppa_address
 
-    if (team_name
-        and ppa_name
-        and not (any(x.isupper() for x in team_name))
+    if owner_name is not None:
+        if len(owner_name) < 1:
+            return (None, None)
+        owner_name = owner_name.lower()
+
+    if (ppa_name
         and not (any(x.isupper() for x in ppa_name))
         and ppa_name.isascii()
         and '/' not in ppa_name
         and len(ppa_name) > 1):
-        return (team_name, ppa_name)
+        return (owner_name, ppa_name)
 
     return (None, None)
 
@@ -600,7 +606,7 @@ def get_ppa(lp, config):
     """
     return Ppa(
         ppa_name=config.get('ppa_name', None),
-        team_name=config.get('team_name', None),
+        owner_name=config.get('owner_name', None),
         service=lp)
 
 
diff --git a/ppa/ppa_group.py b/ppa/ppa_group.py
index 59011ea..c9747a5 100755
--- a/ppa/ppa_group.py
+++ b/ppa/ppa_group.py
@@ -8,7 +8,7 @@
 # Released under GNU GPLv2 or later, read the file 'LICENSE.GPLv2+' for
 # more information.
 
-"""A team or person that owns one or more PPAs in Launchpad."""
+"""A person or team that owns one or more PPAs in Launchpad."""
 
 from functools import lru_cache
 from lazr.restfulclient.errors import BadRequest
@@ -42,7 +42,7 @@ class PpaAlreadyExists(BaseException):
 
 
 class PpaGroup:
-    """Represents a team or person that owns one or more PPAs.
+    """Represents a person or team that owns one or more PPAs.
 
     This class provides a proxy object for interacting with collections
     of PPA.
@@ -51,7 +51,7 @@ class PpaGroup:
         """Initializes a new PpaGroup object for a named person or team.
 
         :param launchpadlib.service service: The Launchpad service object.
-        :param str name: Launchpad username or team name.
+        :param str name: Launchpad username for a person or team.
         """
         if not service:
             raise ValueError("undefined service.")
@@ -80,8 +80,8 @@ class PpaGroup:
 
     @property
     @lru_cache
-    def team(self):
-        """The team that owns this collection of PPAs.
+    def owner(self):
+        """The person or team that owns this collection of PPAs.
 
         :rtype: launchpadlib.person
         :returns: Launchpad person object that owns this PPA.
@@ -106,11 +106,11 @@ class PpaGroup:
         }
 
         try:
-            self.team.createPPA(
+            self.owner.createPPA(
                 name=ppa_name,
                 **ppa_settings
             )
-            self.team.lp_save()
+            self.owner.lp_save()
         except BadRequest as e:
             if "You already have a PPA" in o2str(e.content):
                 raise PpaAlreadyExists(ppa_name, e.content)
@@ -127,7 +127,7 @@ class PpaGroup:
         :rtype: Iterator[ppa.Ppa]
         :returns: Each PPA in the group as a ppa.Ppa object.
         """
-        for lp_ppa in self.team.ppas:
+        for lp_ppa in self.owner.ppas:
             if '-deletedppa' in lp_ppa.name:
                 continue
             yield Ppa(lp_ppa.name, self.name,
@@ -140,7 +140,7 @@ class PpaGroup:
         :rtype: ppa.Ppa
         :returns: A Ppa object describing the named ppa.
         """
-        lp_ppa = self.team.getPPAByName(name=ppa_name)
+        lp_ppa = self.owner.getPPAByName(name=ppa_name)
         if not lp_ppa:
             return None
         return Ppa(lp_ppa.name, self.name,
diff --git a/scripts/ppa b/scripts/ppa
index b6aebbb..ee97f4d 100755
--- a/scripts/ppa
+++ b/scripts/ppa
@@ -254,6 +254,10 @@ def create_arg_parser() -> argparse.ArgumentParser:
     create_parser.add_argument('ppa_name', metavar='ppa-name',
                                action='store',
                                help="Name of the PPA to be created")
+    create_parser.add_argument('--owner-name', '--owner', '--team-name', '--team', metavar='NAME',
+                               action='store',
+                               default=None,
+                               help="Person or team to create PPA under, if not specified via the ppa address (defaults to current LP user)")
     add_basic_config_options(create_parser)
 
     # Desc Command
@@ -395,7 +399,7 @@ def create_arg_parser() -> argparse.ArgumentParser:
 DEFAULT_CONFIG = {
     'debug': False,
     'ppa_name': None,
-    'team_name': None,
+    'owner_name': None,
     'wait_seconds': 10.0
     }
 
@@ -430,16 +434,32 @@ def create_config(lp: Lp, args: argparse.Namespace) -> dict[str, Any]:
     for k, v in DEFAULT_CONFIG.items():
         config.setdefault(k, v)
 
-    lp_username = None
-    if lp.me:
-        lp_username = lp.me.name
     if not hasattr(args, 'ppa_name'):
         warn("No ppa name given")
         return None
 
-    config['team_name'], config['ppa_name'] = ppa_address_split(args.ppa_name, lp_username)
-    if not config['team_name'] or not config['ppa_name']:
+    owner_name, ppa_name = ppa_address_split(args.ppa_name)
+    if owner_name:
+        # First use the owner if present in the PPA address itself,
+        # overriding any configured defaults or specified arguments.
+        config['owner_name'] = owner_name
+    elif config.get('owner_name'):
+        # Next use any owner name from config file or cli args.
+        pass
+    elif config.get('team_name'):
+        # Support legacy config term 'team_name' as alias for 'owner_name'
+        config['owner_name'] = config['team_name']
+        del config['team_name']
+    elif lp.me:
+        # Lastly, fallback to the current Launchpad username, if available.
+        config['owner_name'] = lp.me.name
+    else:
+        warn("No owning person or team identified for the PPA")
+        return None
+
+    if not ppa_name:
         raise ValueError("Invalid ppa name '{}'".format(args.ppa_name))
+    config['ppa_name'] = ppa_name
 
     if args.dry_run:
         config['dry_run'] = True
@@ -472,9 +492,9 @@ def command_create(lp: Lp, config: dict[str, str]) -> int:
         warn("Could not determine PPA name")
         return os.EX_USAGE
 
-    team_name = config.get('team_name')
-    if not team_name:
-        warn("Could not determine team name")
+    owner_name = config.get('owner_name')
+    if not owner_name:
+        warn("Could not determine owning person or team LP username")
         return os.EX_USAGE
 
     publish = config.get('publish', None)
@@ -485,7 +505,7 @@ def command_create(lp: Lp, config: dict[str, str]) -> int:
 
     try:
         if not config.get('dry_run', False):
-            ppa_group = PpaGroup(service=lp, name=team_name)
+            ppa_group = PpaGroup(service=lp, name=owner_name)
             the_ppa = ppa_group.create(ppa_name, ppa_description=description)
             the_ppa.set_publish(publish)
             if architectures:
@@ -498,7 +518,7 @@ def command_create(lp: Lp, config: dict[str, str]) -> int:
                 the_ppa.set_dependencies(ppa_addresses)
 
         else:
-            the_ppa = Ppa(ppa_name, team_name, description)
+            the_ppa = Ppa(ppa_name, owner_name, description)
             arch_str = ', '.join(architectures)
         if not config.get('quiet', False):
             print("PPA '{}' created for the following architectures:\n".format(the_ppa.ppa_name))
@@ -590,16 +610,16 @@ def command_list(lp: Lp, config: dict[str, str], filter_func=None) -> int:
     if not lp:
         return 1
 
-    team_name = config.get('team_name')
-    if not team_name:
+    owner_name = config.get('owner_name')
+    if not owner_name:
         if lp.me:
-            team_name = lp.me.name
+            owner_name = lp.me.name
         else:
-            warn("Could not determine team name")
+            warn("Could not determine owning person or team name")
             return os.EX_USAGE
 
     try:
-        ppa_group = PpaGroup(service=lp, name=team_name)
+        ppa_group = PpaGroup(service=lp, name=owner_name)
         for p in ppa_group.ppas:
             print(p.address)
         return os.EX_OK
@@ -826,7 +846,7 @@ def command_tests(lp: Lp, config: dict[str, str]) -> int:
 
     the_ppa = get_ppa(lp, config)
     if not the_ppa.exists():
-        error(f"PPA {the_ppa.name} does not exist for user {the_ppa.team_name}")
+        error(f"PPA {the_ppa.name} does not exist for user {the_ppa.owner_name}")
         return 1
 
     architectures = config.get('architectures', ARCHES_AUTOPKGTEST)
@@ -909,7 +929,7 @@ def command_tests(lp: Lp, config: dict[str, str]) -> int:
         results = []
         for release in releases:
             base_results_fmt = f"{URL_AUTOPKGTEST}/results/autopkgtest-%s-%s-%s/"
-            base_results_url = base_results_fmt % (release, the_ppa.team_name, the_ppa.name)
+            base_results_url = base_results_fmt % (release, the_ppa.owner_name, the_ppa.name)
             url = f"{base_results_url}?format=plain"
             response = open_url(url)
             if response:
diff --git a/tests/helpers.py b/tests/helpers.py
index 72a965e..c607d3c 100644
--- a/tests/helpers.py
+++ b/tests/helpers.py
@@ -40,9 +40,10 @@ class ProcessorMock:
 
 class ArchiveMock:
     """A stand-in for a Launchpad Archive object."""
-    def __init__(self, name, description):
+    def __init__(self, name, description, owner):
         self.displayname = name
         self.description = description
+        self.owner = owner
         self.publish = True
         self.processors = [ProcessorMock(proc_name) for proc_name in ARCHES_PPA_DEFAULT]
         self.published_sources = []
@@ -68,7 +69,7 @@ class PersonMock:
             if ppa.name == name:
                 raise PpaAlreadyExists(name)
         ppa = Ppa(name, self.name, description)
-        Ppa.archive = ArchiveMock(ppa.name, ppa.description)
+        Ppa.archive = ArchiveMock(ppa.name, ppa.description, self)
         self._ppas.append(ppa)
         return True
 
diff --git a/tests/test_ppa.py b/tests/test_ppa.py
index 2410f83..9bb76e9 100644
--- a/tests/test_ppa.py
+++ b/tests/test_ppa.py
@@ -21,59 +21,59 @@ from ppa.ppa import Ppa, ppa_address_split, get_ppa
 
 def test_object():
     """Check that PPA objects can be instantiated."""
-    ppa = Ppa('test-ppa-name', 'test-team-name')
+    ppa = Ppa('test-ppa-name', 'test-owner-name')
     assert ppa
 
 
 def test_description():
     """Check specifying a description when creating a PPA."""
-    ppa = Ppa('test-ppa-name', 'test-team-name', 'test-description')
+    ppa = Ppa('test-ppa-name', 'test-owner-name', 'test-description')
 
     assert 'test-description' in ppa.ppa_description
 
 
 def test_address():
     """Check getting the PPA address."""
-    ppa = Ppa('test', 'team')
-    assert ppa.address == "ppa:team/test"
+    ppa = Ppa('test', 'owner')
+    assert ppa.address == "ppa:owner/test"
 
 
[e-mail]('address, default_team, expected', [
[e-mail]('address, expected', [
     # Successful cases
-    ('bb', 'me', ('me', 'bb')),
-    ('123', 'me', ('me', '123')),
-    ('a/123', 'me', ('a', '123')),
-    ('ppa:a/bb', None, ('a', 'bb')),
-    ('ppa:ç/bb', None, ('ç', 'bb')),
-    ('https://launchpad.net/~a/+archive/ubuntu/bb', None, ('a', 'bb')),
+    ('bb', (None, 'bb')),
+    ('123', (None, '123')),
+    ('a/123', ('a', '123')),
+    ('ppa:A/bb', ('a', 'bb')),
+    ('ppa:a/bb', ('a', 'bb')),
+    ('ppa:ç/bb', ('ç', 'bb')),
+    ('https://launchpad.net/~a/+archive/ubuntu/bb', ('a', 'bb')),
 
     # Expected failure cases
-    ('ppa:', None, (None, None)),
-    (None, None, (None, None)),
-    ('', None, (None, None)),
-    ('/', None, (None, None)),
-    (':/', None, (None, None)),
-    ('////', None, (None, None)),
-    ('ppa:/', None, (None, None)),
-    ('ppa:a/', None, (None, None)),
-    ('ppa:/bb', None, (None, None)),
-    ('ppa:a/bç', None, (None, None)),
-    ('ppa:A/bb', None, (None, None)),
-    ('ppa/a/bb', None, (None, None)),
-    ('ppa:a/bb/c', None, (None, None)),
-    ('ppa:a/bB', None, (None, None)),
-    ('http://launchpad.net/~a/+archive/ubuntu/bb', None, (None, None)),
-    ('https://example.com/~a/+archive/ubuntu/bb', None, (None, None)),
-    ('https://launchpad.net/~a/+archive/nobuntu/bb', None, (None, None)),
+    ('ppa:', (None, None)),
+    (None, (None, None)),
+    ('', (None, None)),
+    ('/', (None, None)),
+    (':/', (None, None)),
+    ('////', (None, None)),
+    ('ppa:/', (None, None)),
+    ('ppa:a/', (None, None)),
+    ('ppa:/bb', (None, None)),
+    ('ppa:a/bç', (None, None)),
+    ('ppa/a/bb', (None, None)),
+    ('ppa:a/bb/c', (None, None)),
+    ('ppa:a/bB', (None, None)),
+    ('http://launchpad.net/~a/+archive/ubuntu/bb', (None, None)),
+    ('https://example.com/~a/+archive/ubuntu/bb', (None, None)),
+    ('https://launchpad.net/~a/+archive/nobuntu/bb', (None, None)),
 ])
-def test_ppa_address_split(address, default_team, expected):
+def test_ppa_address_split(address, expected):
     """Check ppa address input strings can be parsed properly."""
-    result = ppa_address_split(address, default_team=default_team)
+    result = ppa_address_split(address)
     assert result == expected
 
 
 def test_get_ppa():
-    ppa = get_ppa(None, {'team_name': 'a', 'ppa_name': 'bb'})
+    ppa = get_ppa(None, {'owner_name': 'a', 'ppa_name': 'bb'})
     assert type(ppa) is Ppa
-    assert ppa.team_name == 'a'
+    assert ppa.owner_name == 'a'
     assert ppa.ppa_name == 'bb'
diff --git a/tests/test_ppa_group.py b/tests/test_ppa_group.py
index d9d83de..f53799f 100644
--- a/tests/test_ppa_group.py
+++ b/tests/test_ppa_group.py
@@ -59,14 +59,14 @@ def test_create_with_description():
     assert ppa.description == description
 
 
-def test_create_with_team():
-    """Check creating a PPA for a particular team."""
+def test_create_with_owner():
+    """Check creating a PPA for a particular owner."""
     lp = LpServiceMock()
-    lp.launchpad.add_person('test_team_name')
-    ppa_group = PpaGroup(service=lp, name='test_team_name')
+    lp.launchpad.add_person('test_owner_name')
+    ppa_group = PpaGroup(service=lp, name='test_owner_name')
     ppa = ppa_group.create('ppa_test_name')
     assert ppa is not None
-    assert ppa.address == 'ppa:test_team_name/ppa_test_name'
+    assert ppa.address == 'ppa:test_owner_name/ppa_test_name'
 
 
 def test_list_ppas():
diff --git a/tests/test_scripts_ppa.py b/tests/test_scripts_ppa.py
index 80347ba..f82a9e4 100644
--- a/tests/test_scripts_ppa.py
+++ b/tests/test_scripts_ppa.py
@@ -53,7 +53,7 @@ loader.exec_module(script)
 def fake_config():
     return {
         'ppa_name': 'testing',
-        'team_name': 'me',
+        'owner_name': 'me',
         'wait_seconds': 0.1,
         'quiet': True
     }
@@ -257,6 +257,39 @@ def test_create_arg_parser_basic_config(command):
     args.publish = None
 
 
+def test_create_arg_parser_create():
+    """Checks argument parsing for the 'create' command.
+
+    Most of the create command's args are covered by
+    test_create_arg_parser_basic_config(), this just verifies
+    the few that aren't.
+    """
+    parser = script.create_arg_parser()
+    command = 'create'
+
+    # Check ppa_name
+    args = parser.parse_args([command, 'test-ppa'])
+    assert args.ppa_name == 'test-ppa'
+    args = parser.parse_args([command, 'my-team/test-ppa'])
+    assert args.ppa_name == 'my-team/test-ppa'
+    args = parser.parse_args([command, 'ppa:my-team/test-ppa'])
+    assert args.ppa_name == 'ppa:my-team/test-ppa'
+
+    # Check --owner, --owner-name, --team, --team-name
+    args = parser.parse_args([command, 'test-ppa', '--owner', 'x'])
+    assert args.owner_name == 'x'
+    args.owner_name = None
+    args = parser.parse_args([command, 'test-ppa', '--owner-name', 'x'])
+    assert args.owner_name == 'x'
+    args.owner_name = None
+    args = parser.parse_args([command, 'test-ppa', '--team', 'x'])
+    assert args.owner_name == 'x'
+    args.owner_name = None
+    args = parser.parse_args([command, 'test-ppa', '--team-name', 'x'])
+    assert args.owner_name == 'x'
+    args.owner_name = None
+
+
 def test_create_arg_parser_show():
     """Checks argument parsing for the 'show' command."""
     parser = script.create_arg_parser()
@@ -387,13 +420,19 @@ def test_create_arg_parser_tests():
 
 @pytest.mark.parametrize('command_line_options, expected_config', [
     pytest.param([], {}),
-    (['status', 'ppa:aa/bb'], {'command': 'status', 'team_name': 'aa', 'ppa_name': 'bb'}),
-    (['status', 'aa/bb'], {'team_name': 'aa', 'ppa_name': 'bb'}),
-    (['status', 'bb'], {'team_name': 'me', 'ppa_name': 'bb'}),
+    (['status', 'ppa:aa/bb'], {'command': 'status', 'owner_name': 'aa', 'ppa_name': 'bb'}),
+    (['status', 'aa/bb'], {'owner_name': 'aa', 'ppa_name': 'bb'}),
+    (['status', 'bb'], {'owner_name': 'me', 'ppa_name': 'bb'}),
     (['--debug', 'status', 'ppa:aa/bb'], {'debug': True}),
     (['--dry-run', 'status', 'ppa:aa/bb'], {'dry_run': True}),
     (['--verbose', 'status', 'ppa:aa/bb'], {'verbose': True}),
     (['--quiet', 'status', 'ppa:aa/bb'], {'quiet': True}),
+    (['create', 'ppa:aa/bb'], {'command': 'create', 'owner_name': 'aa', 'ppa_name': 'bb'}),
+    (['create', 'aa/bb'], {'command': 'create', 'owner_name': 'aa', 'ppa_name': 'bb'}),
+    (['create', 'bb', '--owner', 'aa'], {'command': 'create', 'owner_name': 'aa', 'ppa_name': 'bb'}),
+    (['create', 'bb', '--owner-name', 'aa'], {'command': 'create', 'owner_name': 'aa', 'ppa_name': 'bb'}),
+    (['create', 'bb', '--team', 'aa'], {'command': 'create', 'owner_name': 'aa', 'ppa_name': 'bb'}),
+    (['create', 'bb', '--team-name', 'aa'], {'command': 'create', 'owner_name': 'aa', 'ppa_name': 'bb'}),
     ])
 def test_create_config_from_args(command_line_options, expected_config):
     '''Checks creation of a config object from an argparser object.
@@ -462,8 +501,8 @@ def test_command_create(fake_config, monkeypatch, stdin, params, expected_ppa_co
     assert script.command_create(lp, config) == 0
 
     # Retrieve the newly created PPA
-    team = lp.people[config['team_name']]
-    lp_ppa = team.getPPAByName(config['ppa_name'])
+    owner = lp.people[config['owner_name']]
+    lp_ppa = owner.getPPAByName(config['ppa_name'])
     assert lp_ppa
 
     # Verify the expected items are present in the new PPA
@@ -471,6 +510,27 @@ def test_command_create(fake_config, monkeypatch, stdin, params, expected_ppa_co
         assert getattr(lp_ppa, key) == value
 
 
[e-mail]('params, owner_name', [
+    # Defaults
+    ({'owner_name': 'a', 'ppa_name': 'x'}, 'a'),
+])
+def test_command_create_with_owner(fake_config, monkeypatch, params, owner_name):
+    '''Checks create command produces a PPA for a specified owner.'''
+    lp = LpServiceMock()
+    lp.launchpad.add_person(owner_name)
+    monkeypatch.setattr("sys.stdin", io.StringIO('x'))
+
+    # Check success of the create command
+    config = {**fake_config, **params}
+    print(config)
+    assert script.command_create(lp, config) == 0
+
+    # Retrieve the newly created PPA
+    owner = lp.people[owner_name]
+    lp_ppa = owner.getPPAByName(config['ppa_name'])
+    assert lp_ppa
+
+
 @pytest.mark.parametrize('architectures, expected_processors', [
     (None, ARCHES_PPA_DEFAULT),
     ('a', ['a']),
@@ -487,8 +547,8 @@ def test_command_create_with_architectures(monkeypatch, fake_config, architectur
     assert script.command_create(lp, config) == 0
 
     # Retrieve the newly created PPA
-    team = lp.people[config['team_name']]
-    lp_ppa = team.getPPAByName(config['ppa_name'])
+    owner = lp.people[config['owner_name']]
+    lp_ppa = owner.getPPAByName(config['ppa_name'])
 
     # Check processor architectures
     assert lp_ppa.processors
@@ -549,15 +609,15 @@ def test_command_set(fake_config, params, expected_ppa_config):
     lp = LpServiceMock()
 
     # Create a default PPA, for modification later
-    team = lp.people[fake_config['team_name']]
-    team.createPPA(fake_config['ppa_name'], 'x', 'y')
+    owner = lp.people[fake_config['owner_name']]
+    owner.createPPA(fake_config['ppa_name'], 'x', 'y')
 
     # Check success of the set command
     config = {**fake_config, **params}
     assert script.command_set(lp, config)
 
     # Retrieve the PPA we created earlier
-    lp_ppa = team.getPPAByName(fake_config['ppa_name'])
+    lp_ppa = owner.getPPAByName(fake_config['ppa_name'])
 
     # Verify the expected items are present in the updated PPA
     for key, value in expected_ppa_config.items():
@@ -577,15 +637,15 @@ def test_command_set_architectures(fake_config, architectures, expected_processo
     lp = LpServiceMock()
 
     # Create a default PPA, for modification later
-    team = lp.people[fake_config['team_name']]
-    team.createPPA(fake_config['ppa_name'], 'x', 'y')
+    owner = lp.people[fake_config['owner_name']]
+    owner.createPPA(fake_config['ppa_name'], 'x', 'y')
 
     # Check success of the set command
     config = {**fake_config, **{'architectures': architectures}}
     assert script.command_set(lp, config)
 
     # Retrieve the PPA we created earlier
-    lp_ppa = team.getPPAByName(fake_config['ppa_name'])
+    lp_ppa = owner.getPPAByName(fake_config['ppa_name'])
 
     # Check processor architectures
     assert lp_ppa.processors
@@ -629,8 +689,8 @@ def test_command_tests(urlopen_mock,
     Ppa.get_autopkgtest_waiting = lambda x, y: []
 
     # Create a default PPA, for modification later
-    team = lp.people[fake_config['team_name']]
-    team.createPPA(fake_config['ppa_name'], 'x', 'y')
+    owner = lp.people[fake_config['owner_name']]
+    owner.createPPA(fake_config['ppa_name'], 'x', 'y')
     the_ppa = lp.me.getPPAByName(fake_config['ppa_name'])
 
     # Add some fake publications