cp dines

Author: dines-rl

tests/sdk/test_async_benchmark.py

@@ -84,7 +84,7 @@ async def test_list_runs_single(
     ) -> None:
         """Test list_runs method with single result."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_async_client.benchmarks.runs.list = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list = AsyncMock(return_value=page)
 
         benchmark = AsyncBenchmark(mock_async_client, "bmd_123")
         result = await benchmark.list_runs()
@@ -93,14 +93,14 @@ async def test_list_runs_single(
         assert isinstance(result[0], AsyncBenchmarkRun)
         assert result[0].id == benchmark_run_view.id
         assert result[0].benchmark_id == benchmark_run_view.benchmark_id
-        mock_async_client.benchmarks.runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
+        mock_async_client.benchmark_runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
 
     async def test_list_runs_multiple(self, mock_async_client: AsyncMock) -> None:
         """Test list_runs method with multiple results."""
         run_view1 = MockBenchmarkRunView(id="bmr_001")
         run_view2 = MockBenchmarkRunView(id="bmr_002")
         page = SimpleNamespace(runs=[run_view1, run_view2])
-        mock_async_client.benchmarks.runs.list = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list = AsyncMock(return_value=page)
 
         benchmark = AsyncBenchmark(mock_async_client, "bmd_123")
         result = await benchmark.list_runs()
@@ -112,19 +112,19 @@ async def test_list_runs_multiple(self, mock_async_client: AsyncMock) -> None:
         assert result[0].benchmark_id == run_view1.benchmark_id
         assert result[1].id == run_view2.id
         assert result[1].benchmark_id == run_view2.benchmark_id
-        mock_async_client.benchmarks.runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
+        mock_async_client.benchmark_runs.list.assert_awaited_once_with(benchmark_id="bmd_123")
 
     async def test_list_runs_with_params(
         self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView
     ) -> None:
         """Test list_runs method with filtering parameters."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_async_client.benchmarks.runs.list = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list = AsyncMock(return_value=page)
 
         benchmark = AsyncBenchmark(mock_async_client, "bmd_123")
         result = await benchmark.list_runs(limit=10, name="test-run")
 
         assert len(result) == 1
-        mock_async_client.benchmarks.runs.list.assert_awaited_once_with(
+        mock_async_client.benchmark_runs.list.assert_awaited_once_with(
             benchmark_id="bmd_123", limit=10, name="test-run"
         )

tests/sdk/test_async_benchmark_run.py

@@ -26,55 +26,55 @@ def test_repr(self, mock_async_client: AsyncMock) -> None:
 
     async def test_get_info(self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test get_info method."""
-        mock_async_client.benchmarks.runs.retrieve = AsyncMock(return_value=benchmark_run_view)
+        mock_async_client.benchmark_runs.retrieve = AsyncMock(return_value=benchmark_run_view)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.get_info()
 
         assert result == benchmark_run_view
-        mock_async_client.benchmarks.runs.retrieve.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.retrieve.assert_awaited_once_with("bmr_123")
 
     async def test_cancel(self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test cancel method."""
         benchmark_run_view.state = "canceled"
-        mock_async_client.benchmarks.runs.cancel = AsyncMock(return_value=benchmark_run_view)
+        mock_async_client.benchmark_runs.cancel = AsyncMock(return_value=benchmark_run_view)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.cancel()
 
         assert result == benchmark_run_view
         assert result.state == "canceled"
-        mock_async_client.benchmarks.runs.cancel.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.cancel.assert_awaited_once_with("bmr_123")
 
     async def test_complete(self, mock_async_client: AsyncMock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test complete method."""
         benchmark_run_view.state = "completed"
-        mock_async_client.benchmarks.runs.complete = AsyncMock(return_value=benchmark_run_view)
+        mock_async_client.benchmark_runs.complete = AsyncMock(return_value=benchmark_run_view)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.complete()
 
         assert result == benchmark_run_view
         assert result.state == "completed"
-        mock_async_client.benchmarks.runs.complete.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.complete.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_empty(self, mock_async_client: AsyncMock) -> None:
         """Test list_scenario_runs method with empty results."""
         page = SimpleNamespace(runs=[])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs()
 
         assert len(result) == 0
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_single(
         self, mock_async_client: AsyncMock, scenario_run_view: MockScenarioRunView
     ) -> None:
         """Test list_scenario_runs method with single result."""
         page = SimpleNamespace(runs=[scenario_run_view])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs()
@@ -83,14 +83,14 @@ async def test_list_scenario_runs_single(
         assert isinstance(result[0], AsyncScenarioRun)
         assert result[0].id == scenario_run_view.id
         assert result[0].devbox_id == scenario_run_view.devbox_id
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_multiple(self, mock_async_client: AsyncMock) -> None:
         """Test list_scenario_runs method with multiple results."""
         scenario_run_view1 = MockScenarioRunView(id="scr_001", devbox_id="dev_001")
         scenario_run_view2 = MockScenarioRunView(id="scr_002", devbox_id="dev_002")
         page = SimpleNamespace(runs=[scenario_run_view1, scenario_run_view2])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs()
@@ -100,21 +100,21 @@ async def test_list_scenario_runs_multiple(self, mock_async_client: AsyncMock) -
         assert isinstance(result[1], AsyncScenarioRun)
         assert result[0].id == "scr_001"
         assert result[1].id == "scr_002"
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with("bmr_123")
 
     async def test_list_scenario_runs_with_params(
         self, mock_async_client: AsyncMock, scenario_run_view: MockScenarioRunView
     ) -> None:
         """Test list_scenario_runs method with filtering parameters."""
         page = SimpleNamespace(runs=[scenario_run_view])
-        mock_async_client.benchmarks.runs.list_scenario_runs = AsyncMock(return_value=page)
+        mock_async_client.benchmark_runs.list_scenario_runs = AsyncMock(return_value=page)
 
         run = AsyncBenchmarkRun(mock_async_client, "bmr_123", "bmd_123")
         result = await run.list_scenario_runs(limit=10, state="completed")
 
         assert len(result) == 1
         assert isinstance(result[0], AsyncScenarioRun)
         assert result[0].id == scenario_run_view.id
-        mock_async_client.benchmarks.runs.list_scenario_runs.assert_awaited_once_with(
+        mock_async_client.benchmark_runs.list_scenario_runs.assert_awaited_once_with(
             "bmr_123", limit=10, state="completed"
         )

tests/sdk/test_benchmark.py

@@ -80,7 +80,7 @@ def test_remove_scenarios(self, mock_client: Mock, benchmark_view: MockBenchmark
     def test_list_runs_single(self, mock_client: Mock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test list_runs method with single result."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_client.benchmarks.runs.list.return_value = page
+        mock_client.benchmark_runs.list.return_value = page
 
         benchmark = Benchmark(mock_client, "bmd_123")
         result = benchmark.list_runs()
@@ -89,14 +89,14 @@ def test_list_runs_single(self, mock_client: Mock, benchmark_run_view: MockBench
         assert isinstance(result[0], BenchmarkRun)
         assert result[0].id == benchmark_run_view.id
         assert result[0].benchmark_id == benchmark_run_view.benchmark_id
-        mock_client.benchmarks.runs.list.assert_called_once_with(benchmark_id="bmd_123")
+        mock_client.benchmark_runs.list.assert_called_once_with(benchmark_id="bmd_123")
 
     def test_list_runs_multiple(self, mock_client: Mock) -> None:
         """Test list_runs method with multiple results."""
         run_view1 = MockBenchmarkRunView(id="bmr_001")
         run_view2 = MockBenchmarkRunView(id="bmr_002")
         page = SimpleNamespace(runs=[run_view1, run_view2])
-        mock_client.benchmarks.runs.list.return_value = page
+        mock_client.benchmark_runs.list.return_value = page
 
         benchmark = Benchmark(mock_client, "bmd_123")
         result = benchmark.list_runs()
@@ -108,15 +108,15 @@ def test_list_runs_multiple(self, mock_client: Mock) -> None:
         assert result[0].benchmark_id == run_view1.benchmark_id
         assert result[1].id == run_view2.id
         assert result[1].benchmark_id == run_view2.benchmark_id
-        mock_client.benchmarks.runs.list.assert_called_once_with(benchmark_id="bmd_123")
+        mock_client.benchmark_runs.list.assert_called_once_with(benchmark_id="bmd_123")
 
     def test_list_runs_with_params(self, mock_client: Mock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test list_runs method with filtering parameters."""
         page = SimpleNamespace(runs=[benchmark_run_view])
-        mock_client.benchmarks.runs.list.return_value = page
+        mock_client.benchmark_runs.list.return_value = page
 
         benchmark = Benchmark(mock_client, "bmd_123")
         result = benchmark.list_runs(limit=10, name="test-run")
 
         assert len(result) == 1
-        mock_client.benchmarks.runs.list.assert_called_once_with(benchmark_id="bmd_123", limit=10, name="test-run")
+        mock_client.benchmark_runs.list.assert_called_once_with(benchmark_id="bmd_123", limit=10, name="test-run")

tests/sdk/test_benchmark_run.py

@@ -26,53 +26,53 @@ def test_repr(self, mock_client: Mock) -> None:
 
     def test_get_info(self, mock_client: Mock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test get_info method."""
-        mock_client.benchmarks.runs.retrieve.return_value = benchmark_run_view
+        mock_client.benchmark_runs.retrieve.return_value = benchmark_run_view
 
         run = BenchmarkRun(mock_client, "bmr_123", "bmd_123")
         result = run.get_info()
 
         assert result == benchmark_run_view
-        mock_client.benchmarks.runs.retrieve.assert_called_once_with("bmr_123")
+        mock_client.benchmark_runs.retrieve.assert_called_once_with("bmr_123")
 
     def test_cancel(self, mock_client: Mock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test cancel method."""
         benchmark_run_view.state = "canceled"
-        mock_client.benchmarks.runs.cancel.return_value = benchmark_run_view
+        mock_client.benchmark_runs.cancel.return_value = benchmark_run_view
 
         run = BenchmarkRun(mock_client, "bmr_123", "bmd_123")
         result = run.cancel()
 
         assert result == benchmark_run_view
         assert result.state == "canceled"
-        mock_client.benchmarks.runs.cancel.assert_called_once_with("bmr_123")
+        mock_client.benchmark_runs.cancel.assert_called_once_with("bmr_123")
 
     def test_complete(self, mock_client: Mock, benchmark_run_view: MockBenchmarkRunView) -> None:
         """Test complete method."""
         benchmark_run_view.state = "completed"
-        mock_client.benchmarks.runs.complete.return_value = benchmark_run_view
+        mock_client.benchmark_runs.complete.return_value = benchmark_run_view
 
         run = BenchmarkRun(mock_client, "bmr_123", "bmd_123")
         result = run.complete()
 
         assert result == benchmark_run_view
         assert result.state == "completed"
-        mock_client.benchmarks.runs.complete.assert_called_once_with("bmr_123")
+        mock_client.benchmark_runs.complete.assert_called_once_with("bmr_123")
 
     def test_list_scenario_runs_empty(self, mock_client: Mock) -> None:
         """Test list_scenario_runs method with empty results."""
         page = SimpleNamespace(runs=[])
-        mock_client.benchmarks.runs.list_scenario_runs.return_value = page
+        mock_client.benchmark_runs.list_scenario_runs.return_value = page
 
         run = BenchmarkRun(mock_client, "bmr_123", "bmd_123")
         result = run.list_scenario_runs()
 
         assert len(result) == 0
-        mock_client.benchmarks.runs.list_scenario_runs.assert_called_once_with("bmr_123")
+        mock_client.benchmark_runs.list_scenario_runs.assert_called_once_with("bmr_123")
 
     def test_list_scenario_runs_single(self, mock_client: Mock, scenario_run_view: MockScenarioRunView) -> None:
         """Test list_scenario_runs method with single result."""
         page = SimpleNamespace(runs=[scenario_run_view])
-        mock_client.benchmarks.runs.list_scenario_runs.return_value = page
+        mock_client.benchmark_runs.list_scenario_runs.return_value = page
 
         run = BenchmarkRun(mock_client, "bmr_123", "bmd_123")
         result = run.list_scenario_runs()
@@ -81,14 +81,14 @@ def test_list_scenario_runs_single(self, mock_client: Mock, scenario_run_view: M
         assert isinstance(result[0], ScenarioRun)
         assert result[0].id == scenario_run_view.id
         assert result[0].devbox_id == scenario_run_view.devbox_id
-        mock_client.benchmarks.runs.list_scenario_runs.assert_called_once_with("bmr_123")
+        mock_client.benchmark_runs.list_scenario_runs.assert_called_once_with("bmr_123")
 
     def test_list_scenario_runs_multiple(self, mock_client: Mock) -> None:
         """Test list_scenario_runs method with multiple results."""
         scenario_run_view1 = MockScenarioRunView(id="scr_001", devbox_id="dev_001")
         scenario_run_view2 = MockScenarioRunView(id="scr_002", devbox_id="dev_002")
         page = SimpleNamespace(runs=[scenario_run_view1, scenario_run_view2])
-        mock_client.benchmarks.runs.list_scenario_runs.return_value = page
+        mock_client.benchmark_runs.list_scenario_runs.return_value = page
 
         run = BenchmarkRun(mock_client, "bmr_123", "bmd_123")
         result = run.list_scenario_runs()
@@ -98,17 +98,17 @@ def test_list_scenario_runs_multiple(self, mock_client: Mock) -> None:
         assert isinstance(result[1], ScenarioRun)
         assert result[0].id == "scr_001"
         assert result[1].id == "scr_002"
-        mock_client.benchmarks.runs.list_scenario_runs.assert_called_once_with("bmr_123")
+        mock_client.benchmark_runs.list_scenario_runs.assert_called_once_with("bmr_123")
 
     def test_list_scenario_runs_with_params(self, mock_client: Mock, scenario_run_view: MockScenarioRunView) -> None:
         """Test list_scenario_runs method with filtering parameters."""
         page = SimpleNamespace(runs=[scenario_run_view])
-        mock_client.benchmarks.runs.list_scenario_runs.return_value = page
+        mock_client.benchmark_runs.list_scenario_runs.return_value = page
 
         run = BenchmarkRun(mock_client, "bmr_123", "bmd_123")
         result = run.list_scenario_runs(limit=10, state="completed")
 
         assert len(result) == 1
         assert isinstance(result[0], ScenarioRun)
         assert result[0].id == scenario_run_view.id
-        mock_client.benchmarks.runs.list_scenario_runs.assert_called_once_with("bmr_123", limit=10, state="completed")
+        mock_client.benchmark_runs.list_scenario_runs.assert_called_once_with("bmr_123", limit=10, state="completed")