[ibm] Make IBM _wait_for_instance_start timeout configurable (#487)

<!--
Thank you for submitting a PR to Pycloudlib! 

                              ____
     ________________________/ O  \___/
    <_O_O_O_O_O_O_O_O_O_O_O_O_____/   \

-->

## PR Checklist

To ease the process of reviewing your PR, do make sure to complete the
following checklist **before** submitting a pull
request.

- [X] I have added unit tests to cover the new behavior under
``tests/unit_tests/```
- [X] I have run `tox -e format` locally to automatically format my code
before submitting
- [X] I have run `tox` locally ensuring that it passes before submitting
- [X] (if applicable) I have added a reference to issues that this PR
relates to in the PR message (Refs GH-1234, Fixes GH-1234)
- [X] My commits are atomic and follow the convetional commit message
format (https://www.conventionalcommits.org/en/v1.0.0/)

Otherwise, please leave the PR as a draft to indicate that it is still a
work in progress.


## Description
<!-- 
Describe the changes in this PR, and reference issues that this PR
relates to.
If referencing an issue, say "Fixes #1234" to automatically close the
issue when the PR is merged.
-->

IBM `_wait_for_instance_start` has a hardcoded timeout value of 900s.
This change keeps that as the default value but allows it to be
configurable. The motivation for it came from bare metal servers which
sometimes can take longer than 900s to get to "running" state.

## Additional Context and Relevant Issues
<!-- Add any other context about the PR here. -->
<!-- If not relevant, leave "N/A" -->
N/A

## Test Steps
<!-- Please provide steps to test the changes in this PR, if applicable
-->
<!-- If not relevant, leave "N/A" -->
* Added unit tests.
* The change can be manually tested by creating an instance and calling
`wait` on it:
```instance.wait(start_timeout=123)```

Author: Gisaldjo

VERSION

@@ -1 +1 @@
-1!10.13.2
+1!10.13.3

pycloudlib/ibm/instance.py

@@ -919,12 +919,12 @@ def _check_instance_failed_status(self) -> None:
                 f"{self._instance['status_reasons'][0]['message']}"
             )
 
-    def _wait_for_instance_start(self, **kwargs):
+    def _wait_for_instance_start(self, start_timeout=900, **kwargs):
         """Wait for the cloud instance to be up."""
         self._log.info("Waiting for instance to finish provisioning.")
         self._wait_for_status(
             _Status.RUNNING,
-            sleep_seconds=900,
+            sleep_seconds=start_timeout,
             side_effect_fn=self._check_instance_failed_status,
         )
 

tests/unit_tests/ibm/test_instance.py

@@ -3,7 +3,7 @@
 import pytest
 from unittest import mock
 
-from pycloudlib.ibm.instance import IBMInstance, _IBMInstanceType
+from pycloudlib.ibm.instance import IBMInstance, _IBMInstanceType, _Status
 
 SAMPLE_RAW_INSTANCE = {
     "id": "ibm1",
@@ -39,6 +39,7 @@ def test_type_from_raw_instance(self, client, raw_instance, inst_id, zone_id, in
         assert zone_id == inst.zone
         assert inst_type == inst._ibm_instance_type
 
+
     @mock.patch("time.sleep")  # bypass the time.sleep call in _attach_floating_ip()
     @mock.patch(M_PATH + "VpcV1", autospec=True)
     def test_attach_floating_ip(self, m_sleep, client, caplog):
@@ -94,3 +95,55 @@ def test_attach_floating_ip(self, m_sleep, client, caplog):
 
         assert inst._floating_ip["id"] == fi_id
         assert inst._floating_ip["name"] == fi_name
+
+
+    @pytest.mark.parametrize(
+        "kwargs, expected_timeout",
+        [
+            pytest.param({}, 900, id="default_timeout"),
+            pytest.param({"start_timeout": 123}, 123, id="custom_timeout"),
+        ],
+    )
+    @mock.patch(M_PATH + "VpcV1", autospec=True)
+    def test_wait_for_instance_start(self, m_client, kwargs, expected_timeout, caplog):
+        """Test _wait_for_instance_start calls _wait_for_status correctly."""
+        inst = IBMInstance.from_raw_instance(
+            key_pair=None,
+            client=m_client,
+            instance=SAMPLE_RAW_INSTANCE,
+        )
+
+        with mock.patch.object(inst, "_wait_for_status") as m_wait_for_status:
+            inst._wait_for_instance_start(**kwargs)
+            assert "Waiting for instance to finish provisioning." in caplog.text
+
+            m_wait_for_status.assert_called_once_with(
+                _Status.RUNNING,
+                sleep_seconds=expected_timeout,
+                side_effect_fn=inst._check_instance_failed_status,
+            )
+
+
+    @mock.patch(M_PATH + "VpcV1", autospec=True)
+    def test_wait_passes_kwargs(self, m_client):
+        """Test that wait() correctly passes kwargs to internal methods."""
+        inst = IBMInstance.from_raw_instance(
+            key_pair=None,
+            client=m_client,
+            instance=SAMPLE_RAW_INSTANCE,
+        )
+        custom_timeout = 123
+
+        with mock.patch.multiple(
+            inst,
+            _wait_for_instance_start=mock.DEFAULT,
+            _wait_for_execute=mock.DEFAULT,
+            _wait_for_cloudinit=mock.DEFAULT,
+        ) as mocks:
+            inst.wait(start_timeout=custom_timeout)
+
+            mocks["_wait_for_instance_start"].assert_called_once_with(
+                start_timeout=custom_timeout
+            )
+            mocks["_wait_for_execute"].assert_called_once()
+            mocks["_wait_for_cloudinit"].assert_called_once()