earthengine-api 1.5.13rc0__py3-none-any.whl → 1.7.4__py3-none-any.whl

ee/tests/oauth_test.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python3
 """Test for the oauth module."""
 
+import http.client
+import io
 import json
 import sys
 import tempfile
@@ -8,6 +10,7 @@ from unittest import mock
 import urllib.parse
 
 import unittest
+from ee import ee_exception
 from ee import oauth
 
 
@@ -17,7 +20,7 @@ class OAuthTest(unittest.TestCase):
     super().setUp()
     self.test_tmpdir = tempfile.mkdtemp()
 
-  def testRequestToken(self):
+  def test_request_token(self):
 
     class MockResponse:
 
@@ -33,20 +36,33 @@ class OAuthTest(unittest.TestCase):
       self.assertEqual('xyz', parsed[b'code_verifier'][0].decode())
       return MockResponse(parsed[b'code'][0])
 
-    with mock.patch('urllib.request.urlopen', new=mock_urlopen):
+    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 testWriteToken(self):
+  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 self.test_tmpdir + '/tempfile'
+      return f'{self.test_tmpdir}/tempfile'
 
-    oauth_pkg = 'ee.oauth'
-    with mock.patch(
-        oauth_pkg + '.get_credentials_path', new=mock_credentials_path):
+    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)
 
@@ -54,6 +70,46 @@ class OAuthTest(unittest.TestCase):
       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())
@@ -77,5 +133,131 @@ class OAuthTest(unittest.TestCase):
         )
     )
 
+  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()

ee/tests/pixeltype_test.py

@@ -3,7 +3,7 @@
 
 import enum
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -25,15 +25,15 @@ PIXELTYPE = 'PixelType'
 
 
 def make_expression_graph(
-    function_invocation_value: Dict[str, Any]
-) -> Dict[str, Any]:
+    function_invocation_value: dict[str, Any]
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {'0': {'functionInvocationValue': function_invocation_value}},
   }
 
 
-def pixeltype_function_expr(value: Type) -> Dict[str, Any]:
+def pixeltype_function_expr(value: Type) -> dict[str, Any]:
   return {
       'functionInvocationValue': {
           'functionName': 'PixelType',
@@ -42,7 +42,7 @@ def pixeltype_function_expr(value: Type) -> Dict[str, Any]:
   }
 
 
-def pixeltype_noargs_expr(type_name: str) -> Dict[str, Any]:
+def pixeltype_noargs_expr(type_name: str) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {
@@ -78,7 +78,7 @@ class PixelTypeTest(apitestcase.ApiTestCase):
 
     self.assertFalse(pixeltype.isVariable())
     self.assertEqual(
-        set([DIMENSIONS_KEY, MAX_VALUE_KEY, MIN_VALUE_KEY, PRECISION_KEY]),
+        {DIMENSIONS_KEY, MAX_VALUE_KEY, MIN_VALUE_KEY, PRECISION_KEY},
         set(pixeltype.args),
     )
     expected_dimensions = {'result': '0', 'values': {'0': {'constantValue': 2}}}
@@ -294,7 +294,6 @@ class PixelTypeTest(apitestcase.ApiTestCase):
     expect = pixeltype_noargs_expr('int16')
     expression = ee.PixelType.int16()
     result = json.loads(expression.serialize())
-    print(json.dumps(result, indent=2))
     self.assertEqual(expect, result)
 
   def test_int32(self):

ee/tests/projection_test.py

@@ -2,7 +2,7 @@
 """Tests for the ee.Projection module."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -24,8 +24,8 @@ PROJECTION_EPSG_4326 = {
 
 
 def make_expression_graph(
-    function_invocation_value: Dict[str, Any],
-) -> Dict[str, Any]:
+    function_invocation_value: dict[str, Any],
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {'0': {'functionInvocationValue': function_invocation_value}},
@@ -44,7 +44,7 @@ class ProjectionTest(apitestcase.ApiTestCase):
     projection_func = ee.ApiFunction.lookup('Projection')
     self.assertEqual(projection_func, projection.func)
     self.assertFalse(projection.isVariable())
-    self.assertEqual(set(['crs', 'transform']), set(projection.args))
+    self.assertEqual({'crs', 'transform'}, set(projection.args))
     self.assertEqual(EPSG_4326, projection.args['crs'])
     expected_transform = {
         'result': '0',
@@ -71,7 +71,7 @@ class ProjectionTest(apitestcase.ApiTestCase):
 
     projection_func = ee.ApiFunction.lookup('Projection')
     self.assertEqual(projection_func, projection.func)
-    self.assertEqual(set(['crs', 'transformWkt']), set(projection.args))
+    self.assertEqual({'crs', 'transformWkt'}, set(projection.args))
     self.assertEqual(EPSG_4326, projection.args['crs'])
     expected_transform_wkt = {
         'result': '0',
@@ -169,7 +169,6 @@ class ProjectionTest(apitestcase.ApiTestCase):
     })
     expression = ee.Projection(EPSG_4326).nominalScale()
     result = json.loads(expression.serialize())
-    print(result)
     self.assertEqual(expect, result)
 
   def test_scale(self):

ee/tests/reducer_test.py

@@ -2,7 +2,7 @@
 """Tests for ee.Reducer module."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -12,8 +12,8 @@ TO_LIST = 'Reducer.toList'
 
 
 def make_expression_graph(
-    function_invocation_value: Dict[str, Any],
-) -> Dict[str, Any]:
+    function_invocation_value: dict[str, Any],
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {'0': {'functionInvocationValue': function_invocation_value}},
@@ -809,6 +809,19 @@ class ReducerTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
+  def test_ridge_regression_kwargs_with_lambda(self):
+    with self.assertRaisesRegex(
+        ValueError, 'lambda_ cannot be set when providing kwargs.'
+    ):
+      ee.Reducer.ridgeRegression(1, lambda_=3, **{'lambda': 4})
+
+  def test_ridge_regression_unexpected_kwargs(self):
+    with self.assertRaisesRegex(
+        ValueError,
+        r"Unexpected arguments: \['unexpected'\]\. Expected: lambda.",
+    ):
+      ee.Reducer.ridgeRegression(1, unexpected=4)
+
   def test_robust_linear_regression(self):
     num_x = 1
     num_y = 2

ee/tests/serializer_test.py

@@ -1,9 +1,10 @@
 #!/usr/bin/env python3
 """Test for the ee.serializer module."""
 
+from collections.abc import Callable
 import datetime
 import json
-from typing import Any, Callable, Dict, List, Union
+from typing import Any
 
 import unittest
 import ee
@@ -11,7 +12,7 @@ from ee import apitestcase
 from ee import serializer
 
 
-def _max_depth(x: Union[Dict[str, Any], List[Any], str]) -> int:
+def _max_depth(x: dict[str, Any] | list[Any] | str) -> int:
   """Computes the maximum nesting level of some dict, list, or str."""
   if isinstance(x, dict):
     return 1 + max(_max_depth(v) for v in x.values())
@@ -23,7 +24,7 @@ def _max_depth(x: Union[Dict[str, Any], List[Any], str]) -> int:
 
 class DatetimeToMicrosecondsTest(unittest.TestCase):
 
-  def testDatetimeToMicrosecondsNaive(self):
+  def test_datetime_to_microseconds_naive(self):
     self.assertEqual(
         0,
         serializer.DatetimeToMicroseconds(
@@ -51,7 +52,7 @@ class DatetimeToMicrosecondsTest(unittest.TestCase):
         serializer.DatetimeToMicroseconds(datetime.datetime(1906, 4, 18)),
     )
 
-  def testDatetimeToMicroseconds(self):
+  def test_datetime_to_microseconds(self):
     self.assertEqual(
         0,
         serializer.DatetimeToMicroseconds(
@@ -88,7 +89,7 @@ class DatetimeToMicrosecondsTest(unittest.TestCase):
 
 class SerializerTest(apitestcase.ApiTestCase):
 
-  def testSerialization(self):
+  def test_serialization(self):
     """Verifies a complex serialization case."""
 
     class ByteString(ee.Encodable):
@@ -103,13 +104,13 @@ class SerializerTest(apitestcase.ApiTestCase):
         self._value = value
 
       # pylint: disable-next=g-bad-name
-      def encode(self, encoder: Callable[[Any], Any]) -> Dict[str, Any]:
+      def encode(self, encoder: Callable[[Any], Any]) -> dict[str, Any]:
         del encoder  # Unused.
         return {'type': 'Bytes', 'value': self._value}
 
       def encode_cloud_value(
           self, encoder: Callable[[Any], Any]
-      ) -> Dict[str, str]:
+      ) -> dict[str, str]:
         del encoder  # Unused.
         # Proto3 JSON embedding of "bytes" values uses base64 encoding, which
         # this already is.
@@ -160,7 +161,7 @@ class SerializerTest(apitestcase.ApiTestCase):
     decoded_encoded_json = json.loads(encoded_json)
     self.assertEqual(encoded, decoded_encoded_json)
 
-  def testRepeats(self):
+  def test_repeats(self):
     """Verifies serialization finds and removes repeated values."""
     # pylint: disable-next=no-member
     test1 = ee.Image(5).mask(ee.Image(5))
@@ -257,7 +258,7 @@ class SerializerTest(apitestcase.ApiTestCase):
         expected_cloud_pretty,
         serializer.encode(test1, is_compound=False, for_cloud_api=True))
 
-  def testDepthLimit_withAlgorithms(self):
+  def test_depth_limit_with_algorithms(self):
     x = ee.Number(0)
     for i in range(100):
       x = x.add(ee.Number(i))
@@ -266,24 +267,50 @@ class SerializerTest(apitestcase.ApiTestCase):
     # on the test.
     self.assertLess(_max_depth(encoded), 60)
 
-  def testDepthLimit_withLists(self):
+  def test_depth_limit_with_lists(self):
     x = ee.List([0])
     for i in range(100):
       x = ee.List([i, x])
     encoded = serializer.encode(x, for_cloud_api=True)
     self.assertLess(_max_depth(encoded), 60)
 
-  def testDepthLimit_withDictionaries(self):
+  def test_depth_limit_with_dictionaries(self):
     x = ee.Dictionary({0: 0})
     for i in range(100):
       x = ee.Dictionary({i: x})
     encoded = serializer.encode(x, for_cloud_api=True)
     self.assertLess(_max_depth(encoded), 60)
 
-  def testToJsonOptParams(self):
+  def test_to_json_opt_params(self):
     self.assertIn('\n', serializer.toJSON(ee.Image(0), opt_pretty=True))
     self.assertNotIn('\n', serializer.toJSON(ee.Image(0), opt_pretty=False))
 
+  def test_datetime_serialization_legacy(self):
+    a_date = datetime.datetime(2014, 8, 10, tzinfo=datetime.timezone.utc)
+    # 1407628800000000 microseconds.
+    expected = {
+        'type': 'CompoundValue',
+        'scope': [],
+        'value': {
+            'type': 'Invocation',
+            'functionName': 'Date',
+            'arguments': {'value': 1407628800000.0},
+        },
+    }
+    self.assertEqual(expected, serializer.encode(a_date, for_cloud_api=False))
+
+  def test_single_value_no_compound(self):
+    """Verifies serialization of a single non-primitive value."""
+    self.assertEqual([1], serializer.encode([1], for_cloud_api=False))
+
+  def test_unencodable_object(self):
+    class Unencodable:
+      pass
+    with self.assertRaisesRegex(ee.EEException, 'Cannot encode object: .*'):
+      serializer.encode(Unencodable(), for_cloud_api=False)
+    with self.assertRaisesRegex(ee.EEException, 'Cannot encode object: .*'):
+      serializer.encode(Unencodable(), for_cloud_api=True)
+
 
 if __name__ == '__main__':
   unittest.main()

ee/tests/table_converter_test.py

@@ -1,7 +1,9 @@
 #!/usr/bin/env python3
 """Tests for the table_converter module."""
 
-from typing import Any, Dict, Optional, Type
+import builtins
+from typing import Any
+from unittest import mock
 
 from absl.testing import parameterized
 import geopandas
@@ -15,8 +17,8 @@ from ee import table_converter
 class TableConverterTest(parameterized.TestCase):
 
   def _make_feature(
-      self, geometry: Dict[str, Any], properties: Dict[str, Any]
-  ) -> Dict[str, Any]:
+      self, geometry: dict[str, Any], properties: dict[str, Any]
+  ) -> dict[str, Any]:
     return {'type': 'Feature', 'geometry': geometry, 'properties': properties}
 
   @parameterized.named_parameters(
@@ -28,8 +30,8 @@ class TableConverterTest(parameterized.TestCase):
   def test_from_file_format(
       self,
       data_format: str,
-      expected: Optional[Type[table_converter.TableConverter]],
-  ) -> None:
+      expected: type[table_converter.TableConverter] | None,
+  ):
     """Verifies `from_file_format` returns the correct converter class."""
     if expected is None:
       self.assertIsNone(table_converter.from_file_format(data_format))
@@ -38,7 +40,17 @@ class TableConverterTest(parameterized.TestCase):
           table_converter.from_file_format(data_format), expected
       )
 
-  def test_pandas_converter(self) -> None:
+  def test_from_file_format_instance(self):
+    """Verifies `from_file_format` returns the same instance."""
+    converter = table_converter.PandasConverter()
+    self.assertIs(table_converter.from_file_format(converter), converter)
+
+  def test_table_converter_fails(self):
+    """Verifies `TableConverter` cannot be used for conversion."""
+    with self.assertRaises(NotImplementedError):
+      table_converter.TableConverter().do_conversion(iter([]))
+
+  def test_pandas_converter(self):
     """Verifies `PandasConverter` does the correct conversion."""
     converter = table_converter.PandasConverter()
 
@@ -69,7 +81,23 @@ class TableConverterTest(parameterized.TestCase):
         ]),
     )
 
-  def test_geopandas_converter(self) -> None:
+  def test_pandas_converter_importerror(self):
+    """Ensures ImportError is raised when pandas is not available."""
+    real_import = builtins.__import__
+
+    def mock_import(name, globals=None, locals=None, fromlist=(), level=0):
+      if name == 'pandas':
+        raise ImportError
+      return real_import(name, globals, locals, fromlist, level)
+
+    with mock.patch('builtins.__import__', mock_import):
+      converter = table_converter.PandasConverter()
+      with self.assertRaisesRegex(
+          ImportError, 'Using format PANDAS_DATAFRAME requires pandas.'
+      ):
+        converter.do_conversion(iter([]))
+
+  def test_geopandas_converter(self):
     """Verifies `GeoPandasConverter` does the correct conversion."""
     converter = table_converter.GeoPandasConverter()
 
@@ -105,6 +133,22 @@ class TableConverterTest(parameterized.TestCase):
         geopandas.GeoDataFrame.from_features(feature_coll),
     )
 
+  def test_geopandas_converter_importerror(self):
+    """Ensures ImportError is raised when geopandas is not available."""
+    real_import = builtins.__import__
+
+    def mock_import(name, globals=None, locals=None, fromlist=(), level=0):
+      if name == 'geopandas':
+        raise ImportError
+      return real_import(name, globals, locals, fromlist, level)
+
+    with mock.patch('builtins.__import__', mock_import):
+      converter = table_converter.GeoPandasConverter()
+      with self.assertRaisesRegex(
+          ImportError, 'Using format GEOPANDAS_GEODATAFRAME requires geopandas.'
+      ):
+        converter.do_conversion(iter([]))
+
 
 if __name__ == '__main__':
   unittest.main()

ee/tests/terrain_test.py

@@ -2,7 +2,7 @@
 """Tests for the ee.Terrain module."""
 
 import json
-from typing import Any, Dict
+from typing import Any
 
 import unittest
 import ee
@@ -19,8 +19,8 @@ IMAGE_EXPRESSION_1 = {
 
 
 def make_expression_graph(
-    function_invocation_value: Dict[str, Any],
-) -> Dict[str, Any]:
+    function_invocation_value: dict[str, Any],
+) -> dict[str, Any]:
   return {
       'result': '0',
       'values': {'0': {'functionInvocationValue': function_invocation_value}},
@@ -141,6 +141,14 @@ class TerrainTest(apitestcase.ApiTestCase):
     result = json.loads(expression.serialize())
     self.assertEqual(expect, result)
 
+  def test_init(self):
+    message = r'Terrain should not be used as an object.*'
+    with self.assertRaisesRegex(RuntimeError, message):
+      ee.Terrain()
+
+  def test_name(self):
+    self.assertEqual('Terrain', ee.Terrain.name())
+
 
 if __name__ == '__main__':
   unittest.main()