earthengine-api 1.7.1rc0__tar.gz → 1.7.2rc0__tar.gz

{earthengine_api-1.7.1rc0/earthengine_api.egg-info → earthengine_api-1.7.2rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: earthengine-api
-Version: 1.7.1rc0
+Version: 1.7.2rc0
 Summary: Earth Engine Python API
 Author-email: Google LLC <noreply@google.com>
 License: Apache-2.0

{earthengine_api-1.7.1rc0 → earthengine_api-1.7.2rc0/earthengine_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: earthengine-api
-Version: 1.7.1rc0
+Version: 1.7.2rc0
 Summary: Earth Engine Python API
 Author-email: Google LLC <noreply@google.com>
 License: Apache-2.0

{earthengine_api-1.7.1rc0 → earthengine_api-1.7.2rc0}/ee/__init__.py

@@ -1,6 +1,6 @@
 """The EE Python library."""
 
-__version__ = '1.7.1rc0'
+__version__ = '1.7.2rc0'
 
 # Using lowercase function naming to match the JavaScript names.
 # pylint: disable=g-bad-name

{earthengine_api-1.7.1rc0 → earthengine_api-1.7.2rc0}/ee/data.py

@@ -2161,6 +2161,7 @@ def setIamPolicy(asset_id: str, policy: Any) -> None:
       .setIamPolicy(resource=name, body={'policy': policy}, prettyPrint=False)
   )
 
+
 @deprecation.Deprecated('Use ee.data.updateAsset().')
 def setAssetProperties(assetId: str, properties: dict[str, Any]) -> None:
   """Sets metadata properties of the asset with the given ID.

{earthengine_api-1.7.1rc0 → earthengine_api-1.7.2rc0}/ee/oauth.py

@@ -226,7 +226,7 @@ def _in_jupyter_shell() -> bool:
   """Tests if the code is being executed within Jupyter."""
   try:
     import ipykernel.zmqshell
-    return isinstance(IPython.get_ipython(),
+    return isinstance(IPython.get_ipython(),  # pylint: disable=undefined-variable
                       ipykernel.zmqshell.ZMQInteractiveShell)
   except ImportError:
     return False
@@ -329,7 +329,7 @@ def _display_auth_instructions_with_html(
 ) -> None:
   """Displays instructions for authenticating using HTML code."""
   try:
-    IPython.display.display(IPython.display.HTML(
+    IPython.display.display(IPython.display.HTML(  # pylint: disable=undefined-variable
         """<p>To authorize access needed by Earth Engine, open the following
         URL in a web browser and follow the instructions:</p>
         <p><a href={0}>{0}</a></p>

{earthengine_api-1.7.1rc0 → earthengine_api-1.7.2rc0}/ee/tests/data_test.py

@@ -87,6 +87,26 @@ class DataTest(unittest.TestCase):
         _state.get_state().cloud_api_user_project, 'earthengine-legacy'
     )
 
+  @mock.patch.object(ee.data, '_install_cloud_api_resource', return_value=None)
+  def test_initialize_with_credentials(
+      self, unused_mock_install_cloud_api_resource
+  ):
+    creds = mock.MagicMock()
+    ee.data.initialize(credentials=creds)
+
+    self.assertTrue(ee.data.is_initialized())
+    self.assertEqual(creds, _state.get_state().credentials)
+
+  @mock.patch.object(ee.data, '_install_cloud_api_resource', return_value=None)
+  def test_initialize_with_cloud_api_key(
+      self, unused_mock_install_cloud_api_resource
+  ):
+    cloud_api_key = 'a cloud api key'
+    ee.data.initialize(cloud_api_key=cloud_api_key)
+
+    self.assertTrue(ee.data.is_initialized())
+    self.assertEqual(cloud_api_key, _state.get_state().cloud_api_key)
+
   def test_set_max_retries_bad_values(self):
     with self.assertRaises(ValueError):
       ee.data.setMaxRetries(-1)
@@ -110,6 +130,46 @@ class DataTest(unittest.TestCase):
           .execute.call_args.kwargs['num_retries'],
       )
 
+  def test_set_cloud_api_key(self):
+    cloud_api_key = 'a cloud api key'
+    with mock.patch.object(
+        ee.data, '_install_cloud_api_resource', return_value=None
+    ) as mock_install_cloud_api_resource:
+      ee.data.setCloudApiKey(cloud_api_key)
+      self.assertEqual(cloud_api_key, _state.get_state().cloud_api_key)
+      mock_install_cloud_api_resource.assert_called_once()
+
+  def test_set_deadline(self):
+    deadline_ms = 12345
+    with mock.patch.object(
+        ee.data, '_install_cloud_api_resource', return_value=None
+    ) as mock_install_cloud_api_resource:
+      ee.data.setDeadline(deadline_ms)
+      self.assertEqual(deadline_ms, _state.get_state().deadline_ms)
+      mock_install_cloud_api_resource.assert_called_once()
+
+  def test_get_set_user_agent(self):
+    self.assertIsNone(ee.data.getUserAgent())
+    user_agent = 'user-agent'
+    ee.data.setUserAgent(user_agent)
+    self.assertEqual(user_agent, ee.data.getUserAgent())
+
+  def test_authorize_http_no_credentials(self):
+    self.assertIsNone(ee.data._get_state().credentials)
+    http = mock.MagicMock()
+    self.assertEqual(http, ee.data.authorizeHttp(http))
+
+  def test_authorize_http_with_credentials(self):
+    creds = mock.MagicMock()
+    ee.data._get_state().credentials = creds
+    http = mock.MagicMock()
+    with mock.patch.object(
+        ee.data.google_auth_httplib2, 'AuthorizedHttp'
+    ) as mock_authorized_http:
+      result = ee.data.authorizeHttp(http)
+      self.assertEqual(mock_authorized_http.return_value, result)
+      mock_authorized_http.assert_called_once_with(creds)
+
   def test_list_operations(self):
     mock_http = mock.MagicMock(httplib2.Http)
     # Return in three groups.
@@ -342,6 +402,14 @@ class DataTest(unittest.TestCase):
       asset = mock_create_asset.call_args.kwargs['body']
       self.assertEqual(asset, {'type': 'FOLDER'})
 
+  @mock.patch.object(ee.data, 'createAsset')
+  def test_create_asset_home(self, mock_create_asset):
+    ee.data.createAssetHome('users/test')
+    mock_create_asset.assert_called_once_with({
+        'name': 'projects/earthengine-legacy/assets/users/test',
+        'type': 'FOLDER',
+    })
+
   def test_create_assets(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
@@ -432,6 +500,68 @@ class DataTest(unittest.TestCase):
       )
       self.assertTrue(import_args['overwrite'])
 
+  def test_start_table_ingestion(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      mock_result = {'name': 'operations/ingestion', 'done': False}
+      cloud_api_resource.projects().table().import_.return_value.execute.return_value = (
+          mock_result
+      )
+      params = {
+          'id': 'users/test/table',
+          'sources': [{'uris': ['gs://bucket/file.shp'], 'charset': 'UTF-8'}],
+      }
+      result = ee.data.startTableIngestion('request_id', params, True)
+      self.assertEqual(result['id'], 'ingestion')
+      self.assertEqual(result['name'], 'operations/ingestion')
+
+      mock_import = cloud_api_resource.projects().table().import_
+      mock_import.assert_called_once()
+      call_kwargs = mock_import.call_args.kwargs
+      self.assertEqual(call_kwargs['project'], 'projects/earthengine-legacy')
+      body = call_kwargs['body']
+      self.assertEqual(
+          body['tableManifest'],
+          {
+              'name': 'projects/earthengine-legacy/assets/users/test/table',
+              'sources': [
+                  {'uris': ['gs://bucket/file.shp'], 'charset': 'UTF-8'}
+              ],
+          },
+      )
+      self.assertEqual(body['requestId'], 'request_id')
+      self.assertTrue(body['overwrite'])
+
+  def test_start_external_image_ingestion(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      cloud_api_resource.projects().image().importExternal.return_value.execute.return_value = (
+          {}
+      )
+      manifest = {
+          'id': 'users/test/image',
+          'tilesets': [{'sources': [{'uris': ['gs://bucket/file.tif']}]}],
+      }
+      result = ee.data.startExternalImageIngestion(manifest, True)
+      expected_name = 'projects/earthengine-legacy/assets/users/test/image'
+      self.assertEqual(result['name'], expected_name)
+
+      mock_import_external = (
+          cloud_api_resource.projects().image().importExternal
+      )
+      mock_import_external.assert_called_once()
+      call_kwargs = mock_import_external.call_args.kwargs
+      self.assertEqual(call_kwargs['project'], 'projects/earthengine-legacy')
+      body = call_kwargs['body']
+      self.assertEqual(
+          body['imageManifest'],
+          {
+              'name': expected_name,
+              'tilesets': [{'sources': [{'uris': ['gs://bucket/file.tif']}]}],
+          },
+      )
+      self.assertTrue(body['overwrite'])
+
   def test_set_asset_properties(self):
     mock_http = mock.MagicMock(httplib2.Http)
     with apitestcase.UsingCloudApi(mock_http=mock_http), mock.patch.object(
@@ -453,6 +583,18 @@ class DataTest(unittest.TestCase):
           {'properties.\"mYPropErTy\"',
                'properties.\"system:time_start\"'})
 
+  def test_update_asset(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      asset = {'properties': {'foo': 'bar'}}
+      update_mask = ['properties.foo']
+      ee.data.updateAsset(asset_id, asset, update_mask)
+      cloud_api_resource.projects().assets().patch.assert_called_once_with(
+          name='projects/earthengine-legacy/assets/users/test/asset',
+          body={'updateMask': {'paths': update_mask}, 'asset': asset},
+      )
+
   def test_list_assets(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
@@ -576,6 +718,16 @@ class DataTest(unittest.TestCase):
     cloud_api_resource.projects().listAssets().execute.assert_called_once()
     self.assertEqual(mock_result, actual_result)
 
+  def test_get_asset_roots(self):
+    with mock.patch.object(
+        ee.data,
+        'listBuckets',
+        return_value={'assets': [{'name': 'id1', 'type': 'FOLDER'}]},
+    ) as mock_list_buckets:
+      result = ee.data.getAssetRoots()
+      mock_list_buckets.assert_called_once()
+      self.assertEqual([{'id': 'id1', 'type': 'Folder'}], result)
+
   def test_simple_get_list_via_cloud_api(self):
     cloud_api_resource = mock.MagicMock()
     with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
@@ -881,6 +1033,50 @@ class DataTest(unittest.TestCase):
       ).execute.assert_called_once()
       self.assertEqual(mock_result, actual_result)
 
+  def test_get_pixels(self):
+    cloud_api_resource_raw = mock.MagicMock()
+    with apitestcase.UsingCloudApi(
+        cloud_api_resource_raw=cloud_api_resource_raw
+    ):
+      assets = cloud_api_resource_raw.projects().assets()
+      mock_result = b'pixel data'
+      assets.getPixels.return_value.execute.return_value = mock_result
+      asset_id = 'users/foo/bar'
+      params = {'assetId': asset_id}
+      result = ee.data.getPixels(params)
+      self.assertEqual(mock_result, result)
+      assets.getPixels.assert_called_once_with(
+          name='projects/earthengine-legacy/assets/users/foo/bar',
+          body={'fileFormat': 'AUTO_JPEG_PNG'},
+      )
+
+  def test_compute_pixels(self):
+    cloud_api_resource_raw = mock.MagicMock()
+    with apitestcase.UsingCloudApi(
+        cloud_api_resource_raw=cloud_api_resource_raw
+    ):
+      mock_result = b'pixel data'
+      (
+          cloud_api_resource_raw.projects()
+          .image()
+          .computePixels.return_value.execute.return_value
+      ) = mock_result
+      expression = ee.Image(1)
+      params = {'expression': expression}
+      result = ee.data.computePixels(params)
+      self.assertEqual(mock_result, result)
+      (
+          cloud_api_resource_raw.projects()
+          .image()
+          .computePixels.assert_called_once_with(
+              project='projects/earthengine-legacy',
+              body={
+                  'expression': ee.serializer.encode(expression),
+                  'fileFormat': 'AUTO_JPEG_PNG',
+              },
+          )
+      )
+
   def test_get_feature_view_tiles_key(self):
     cloud_api_resource = mock.MagicMock()
     _state.get_state().tile_base_url = 'base_url'
@@ -922,8 +1118,31 @@ class DataTest(unittest.TestCase):
       cloud_api_resource.projects().updateConfig().execute.return_value = (
           mock_result
       )
+      project_config = {'maxConcurrentExports': 2}
       actual_result = ee.data.updateProjectConfig(
-          {'maxConcurrentExports': 2}, ['max_concurrent_exports']
+          project_config, ['max_concurrent_exports']
+      )
+      cloud_api_resource.projects().updateConfig.assert_called_with(
+          name='projects/earthengine-legacy/config',
+          body=project_config,
+          updateMask='max_concurrent_exports',
+      )
+      cloud_api_resource.projects().updateConfig().execute.assert_called_once()
+      self.assertEqual(mock_result, actual_result)
+
+  def test_update_project_config_no_mask(self) -> None:
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      mock_result = {'fake-project-config-value': 1}
+      cloud_api_resource.projects().updateConfig().execute.return_value = (
+          mock_result
+      )
+      project_config = {'maxConcurrentExports': 2}
+      actual_result = ee.data.updateProjectConfig(project_config)
+      cloud_api_resource.projects().updateConfig.assert_called_with(
+          name='projects/earthengine-legacy/config',
+          body=project_config,
+          updateMask='max_concurrent_exports',
       )
       cloud_api_resource.projects().updateConfig().execute.assert_called_once()
       self.assertEqual(mock_result, actual_result)
@@ -1040,6 +1259,81 @@ class DataTest(unittest.TestCase):
       }
       self.assertEqual(expected, quota)
 
+  def test_get_asset_root_quota_not_root(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      fake_asset = {
+          'type': 'IMAGE',
+          'name': 'projects/earthengine-legacy/assets/users/test/asset',
+      }
+      cloud_api_resource.projects().assets().get().execute.return_value = (
+          fake_asset
+      )
+      with self.assertRaisesRegex(
+          ee.ee_exception.EEException, f'{asset_id} is not a root folder.'
+      ):
+        ee.data.getAssetRootQuota(asset_id)
+
+  def test_get_iam_policy(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      ee.data.getIamPolicy(asset_id)
+      cloud_api_resource.projects().assets().getIamPolicy.assert_called_once_with(
+          resource='projects/earthengine-legacy/assets/users/test/asset',
+          body={},
+          prettyPrint=False,
+      )
+
+  def test_get_asset_acl(self):
+    asset_id = 'users/test/asset'
+    policy = {'bindings': [{'role': 'roles/viewer', 'members': ['allUsers']}]}
+    acl = {'readers': ['allUsers']}
+    with mock.patch.object(
+        ee.data, 'getIamPolicy', return_value=policy
+    ) as mock_get_iam_policy, mock.patch.object(
+        ee.data._cloud_api_utils, 'convert_iam_policy_to_acl', return_value=acl
+    ) as mock_convert:
+      result = ee.data.getAssetAcl(asset_id)
+      mock_get_iam_policy.assert_called_once_with(asset_id)
+      mock_convert.assert_called_once_with(policy)
+      self.assertEqual(acl, result)
+
+  def test_set_asset_acl(self):
+    asset_id = 'users/test/asset'
+    acl_update_dict = {'readers': ['allUsers']}
+    acl_update_str = '{"readers": ["allUsers"]}'
+    policy = {'bindings': [{'role': 'roles/viewer', 'members': ['allUsers']}]}
+    with mock.patch.object(
+        ee.data._cloud_api_utils,
+        'convert_acl_to_iam_policy',
+        return_value=policy,
+    ) as mock_convert, mock.patch.object(
+        ee.data, 'setIamPolicy'
+    ) as mock_set_iam_policy:
+      ee.data.setAssetAcl(asset_id, acl_update_dict)
+      mock_convert.assert_called_once_with(acl_update_dict)
+      mock_set_iam_policy.assert_called_once_with(asset_id, policy)
+
+      mock_convert.reset_mock()
+      mock_set_iam_policy.reset_mock()
+      ee.data.setAssetAcl(asset_id, acl_update_str)
+      mock_convert.assert_called_once_with(acl_update_dict)
+      mock_set_iam_policy.assert_called_once_with(asset_id, policy)
+
+  def test_set_iam_policy(self):
+    cloud_api_resource = mock.MagicMock()
+    with apitestcase.UsingCloudApi(cloud_api_resource=cloud_api_resource):
+      asset_id = 'users/test/asset'
+      policy = {'bindings': [{'role': 'roles/viewer', 'members': ['allUsers']}]}
+      ee.data.setIamPolicy(asset_id, policy)
+      cloud_api_resource.projects().assets().setIamPolicy.assert_called_once_with(
+          resource='projects/earthengine-legacy/assets/users/test/asset',
+          body={'policy': policy},
+          prettyPrint=False,
+      )
+
 
 def DoCloudProfileStubHttp(test, expect_profiling):
 

earthengine_api-1.7.2rc0/ee/tests/oauth_test.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Test for the oauth module."""
+
+import http.client
+import io
+import json
+import sys
+import tempfile
+from unittest import mock
+import urllib.parse
+
+import unittest
+from ee import ee_exception
+from ee import oauth
+
+
+class OAuthTest(unittest.TestCase):
+
+  def setUp(self):
+    super().setUp()
+    self.test_tmpdir = tempfile.mkdtemp()
+
+  def test_request_token(self):
+
+    class MockResponse:
+
+      def __init__(self, code):
+        self.code = code.decode()
+
+      def read(self):
+        return ('{"refresh_token": "' + self.code + '456"}').encode()
+
+    def mock_urlopen(url, param):
+      del url  # Unused.
+      parsed = urllib.parse.parse_qs(param)
+      self.assertEqual('xyz', parsed[b'code_verifier'][0].decode())
+      return MockResponse(parsed[b'code'][0])
+
+    with mock.patch.object(urllib.request, 'urlopen', new=mock_urlopen):
+      auth_code = '123'
+      verifier = 'xyz'
+      refresh_token = oauth.request_token(auth_code, verifier)
+      self.assertEqual('123456', refresh_token)
+
+  def test_request_token_http_error(self):
+    mock_fp = io.BytesIO(b'error details')
+    http_error = urllib.error.HTTPError(
+        'url', 400, 'message', hdrs=http.client.HTTPMessage(), fp=mock_fp
+    )
+    with mock.patch.object(urllib.request, 'urlopen', side_effect=http_error):
+      with self.assertRaisesRegex(
+          Exception,
+          r"Problem requesting tokens.*HTTP Error 400: message.*b'error"
+          r" details'",
+      ):
+        oauth.request_token('auth_code', 'code_verifier')
+
+  def test_write_token(self):
+
+    def mock_credentials_path():
+      return f'{self.test_tmpdir}/tempfile'
+
+    with mock.patch.object(
+        oauth, 'get_credentials_path', new=mock_credentials_path
+    ):
+      client_info = dict(refresh_token='123')
+      oauth.write_private_json(oauth.get_credentials_path(), client_info)
+
+    with open(mock_credentials_path()) as f:
+      token = json.load(f)
+      self.assertEqual({'refresh_token': '123'}, token)
+
+  def test_get_credentials_arguments(self):
+    credentials_path = f'{self.test_tmpdir}/temp_creds'
+
+    creds = {
+        'refresh_token': 'REFRESH_TOKEN',
+        'client_id': 'CLIENT_ID',
+        'project': 'PROJECT',
+    }
+    with open(credentials_path, 'w') as f:
+      json.dump(creds, f)
+
+    with mock.patch.object(
+        oauth, 'get_credentials_path', return_value=credentials_path
+    ):
+      args = oauth.get_credentials_arguments()
+
+    expected_args = {
+        'token_uri': oauth.TOKEN_URI,
+        'refresh_token': 'REFRESH_TOKEN',
+        'client_id': 'CLIENT_ID',
+        'client_secret': oauth.CLIENT_SECRET,
+        'scopes': oauth.SCOPES,
+        'quota_project_id': 'PROJECT',
+    }
+    self.assertEqual(expected_args, args)
+
+  def test_is_valid_credentials(self):
+    self.assertFalse(oauth.is_valid_credentials(None))
+
+    mock_credentials_valid = mock.MagicMock()
+    self.assertTrue(oauth.is_valid_credentials(mock_credentials_valid))
+    mock_credentials_valid.refresh.assert_called_once()
+
+    mock_credentials_invalid = mock.MagicMock()
+    mock_credentials_invalid.refresh.side_effect = (
+        oauth.google.auth.exceptions.RefreshError()
+    )
+    self.assertFalse(oauth.is_valid_credentials(mock_credentials_invalid))
+    mock_credentials_invalid.refresh.assert_called_once()
+
+  def test_in_colab_shell(self):
+    with mock.patch.dict(sys.modules, {'google.colab': None}):
+      self.assertFalse(oauth.in_colab_shell())
+
+    with mock.patch.dict(sys.modules, {'google.colab': mock.MagicMock()}):
+      self.assertTrue(oauth.in_colab_shell())
+
+  def test_is_sdk_credentials(self):
+    sdk_project = oauth.SDK_PROJECTS[0]
+    self.assertFalse(oauth.is_sdk_credentials(None))
+    self.assertFalse(oauth.is_sdk_credentials(mock.MagicMock()))
+    self.assertFalse(
+        oauth.is_sdk_credentials(mock.MagicMock(client_id='123'))
+    )
+    self.assertTrue(
+        oauth.is_sdk_credentials(mock.MagicMock(client_id=sdk_project))
+    )
+    self.assertTrue(
+        oauth.is_sdk_credentials(
+            mock.MagicMock(client_id=f'{sdk_project}-somethingelse')
+        )
+    )
+
+  def test_colab_mode_with_nonstandard_scopes_raises_exception(self):
+    with self.assertRaisesRegex(
+        ee_exception.EEException,
+        'Scopes cannot be customized when auth_mode is "colab".'
+    ):
+      oauth.authenticate(
+          auth_mode='colab',
+          scopes=['https://www.googleapis.com/auth/earthengine.readonly']
+      )
+
+  def test_colab_auth_mode_with_standard_scopes_succeeds(self):
+    # Should not raise an exception if the scopes are not narrowed.
+    with mock.patch.dict(sys.modules, {'google.colab': mock.MagicMock()}):
+      try:
+        oauth.authenticate(auth_mode='colab', scopes=oauth.SCOPES)
+      except ee_exception.EEException:
+        self.fail('authenticate raised an exception unexpectedly.')
+
+  def test_authenticate_appdefault(self):
+    with mock.patch.object(
+        oauth,
+        '_valid_credentials_exist',
+        return_value=False,
+    ), mock.patch.object(
+        sys, 'stderr', new_callable=io.StringIO
+    ) as mock_stderr:
+      oauth.authenticate(auth_mode='appdefault')
+      self.assertIn('appdefault no longer necessary', mock_stderr.getvalue())
+
+  @mock.patch.object(oauth, '_load_gcloud_credentials')
+  @mock.patch.object(oauth, '_valid_credentials_exist', return_value=False)
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=False)
+  @mock.patch.object(oauth, '_in_jupyter_shell', return_value=False)
+  @mock.patch.object(oauth, '_localhost_is_viable', return_value=False)
+  def test_authenticate_default_gcloud(
+      self,
+      mock_localhost_viable,
+      mock_jupyter,
+      mock_colab,
+      mock_valid_creds,
+      mock_load_gcloud,
+  ):
+    del (
+        mock_localhost_viable,
+        mock_jupyter,
+        mock_colab,
+        mock_valid_creds,
+    )  # Unused
+    oauth.authenticate()
+    mock_load_gcloud.assert_called_once_with(None, None, False)
+
+  def test_localhost_fetch_code(self):
+    mock_server = mock.MagicMock()
+    mock_server.url = 'http://localhost:8085'
+    mock_server.fetch_code.return_value = 'FETCHED_CODE'
+    with mock.patch.object(
+        oauth, '_start_server', return_value=mock_server
+    ), mock.patch.object(oauth, '_obtain_and_write_token') as mock_obtain:
+      flow = oauth.Flow(auth_mode='localhost')
+      flow.save_code()
+      mock_server.fetch_code.assert_called_once()
+      mock_obtain.assert_called_once_with(
+          'FETCHED_CODE',
+          flow.code_verifier,
+          flow.scopes,
+          'http://localhost:8085',
+      )
+
+  @mock.patch.object(oauth, '_display_auth_instructions_for_noninteractive')
+  def test_display_instructions_quiet(self, mock_display):
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions(quiet=True))
+    mock_display.assert_called_once_with(flow.auth_url, flow.code_verifier)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_print')
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=True)
+  def test_display_instructions_colab(self, mock_in_colab, mock_display_print):
+    del mock_in_colab  # Unused
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions())
+    mock_display_print.assert_called_once_with(flow.auth_url, None)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_html')
+  @mock.patch.object(oauth, '_in_jupyter_shell', return_value=True)
+  def test_display_instructions_jupyter(
+      self, mock_in_jupyter, mock_display_html
+  ):
+    del mock_in_jupyter  # Unused
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions())
+    mock_display_html.assert_called_once_with(flow.auth_url, None)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_print')
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=False)
+  @mock.patch.object(oauth, '_in_jupyter_shell', return_value=False)
+  def test_display_instructions_print(
+      self, mock_in_jupyter, mock_in_colab, mock_display_print
+  ):
+    del mock_in_jupyter, mock_in_colab  # Unused
+    flow = oauth.Flow(auth_mode='notebook')
+    self.assertTrue(flow.display_instructions())
+    mock_display_print.assert_called_once_with(flow.auth_url, None)
+
+  @mock.patch.object(oauth, '_display_auth_instructions_with_print')
+  @mock.patch.object(oauth, 'in_colab_shell', return_value=True)
+  @mock.patch.object(oauth.http.server, 'HTTPServer')
+  def test_display_instructions_localhost_colab(
+      self, mock_http_server, mock_in_colab, mock_display_print
+  ):
+    del mock_http_server, mock_in_colab  # Unused
+    flow = oauth.Flow(auth_mode='localhost')
+    self.assertTrue(flow.display_instructions())
+    mock_display_print.assert_called_once_with(
+        flow.auth_url, oauth.WAITING_CODA
+    )
+
+  def test_flow_unknown_auth_mode(self):
+    with self.assertRaisesRegex(ee_exception.EEException, 'Unknown auth_mode'):
+      oauth.Flow(auth_mode='unknown')
+
+  def test_flow_localhost_with_port(self):
+    with mock.patch.object(oauth, '_start_server') as mock_start_server:
+      oauth.Flow(auth_mode='localhost:1234')
+      mock_start_server.assert_called_once_with(1234)
+
+
+if __name__ == '__main__':
+  unittest.main()