Coinbase QA Engineer Interview Questions

In the context of the rapidly changing environments of cryptocurrencies, validating API responses is essential. This requires implementing a utility that verifies response hierarchies and correctness in tests.
Problem statement: You need to create a function that performs a depth-first traversal on a response structure that is represented as a graph to validate if a given response satisfies a specific hierarchy. This function should return all valid nodes that meet the criteria within the API response hierarchy.
- Method Signature: def validate_api_response(node: Dict[str, Any], criteria: Callable[[Dict[str, Any]], bool]) -> List[Dict[str, Any]]
Example 1:
Input: {'node': {'valid': true, 'level': 1}, 'children': [{'valid': true, 'level': 2}]}, criteria = (node) => node['valid']
Output: [{'valid': true, 'level': 1}, {'valid': true, 'level': 2}]
Explanation: Both nodes are valid according to the criteria.
Example 2:
Input: {'node': {'valid': false}, 'children': [{'valid': false}, {'valid': true}]}, criteria = (node) => node['valid']
Output: [{'valid': true}]
Explanation: Only the last node meets the criteria.Constraints:
- 1 <= len(node) <= 1000
- Each node has structure {'valid': bool, 'level': int}

Coinbase handles thousands of transactions per second, so testing the transaction handling process efficiently is crucial. You need to develop a method to validate a stream of transactions for valid timestamps within a certain window.
Problem statement: Implement a function that verifies whether there are any duplicate timestamps in a stream of transactions that occur within a specified windowSize (in seconds). Your method should return true if a duplicate exists within that window, and false otherwise.
- Method Signature: def has_duplicate_transactions(transactions: List[Tuple[int, int]], window_size: int) -> bool
Example 1:
Input: [(1, 100), (2, 101), (3, 103), (4, 104), (5, 106)], window_size = 5
Output: False
Explanation: No duplicates within 5 seconds.
Example 2:
Input: [(1, 100), (2, 101), (3, 102), (4, 103), (5, 106), (6, 102)], window_size = 5
Output: True
Explanation: Duplicate timestamp 102 found within 5 seconds.Constraints:
- 1 <= len(transactions) <= 10000
- 0 <= transactions[i][0] <= 1000000
- 1 <= window_size <= 1000

Coinbase's testing framework needs to identify flaky tests that may produce inconsistent results. Building such a detection mechanism is integral for ensuring high test reliability.
Problem statement: Design a class called FlakyTestDetector that will track test runs. It must be able to record test run results, particularly monitoring those tests that have varied results across different runs. The class should also provide a method to check if a test is considered flaky after a certain threshold of inconsistency.
- Class Specification:
- Method Signature: def record_run(self, test_case: str, result: bool) -> None
- Method Signature: def is_flaky(self, test_case: str, threshold: int) -> bool
- Method Signature: def get_flaky_tests(self) -> List[str]
Example 1:
Input: detector.record_run('TestCase1', True)
Output: None
Input: detector.record_run('TestCase1', False)
Output: None
Input: detector.is_flaky('TestCase1', 1)
Output: True
Example 2:
Input: detector.record_run('TestCase2', True)
Output: None
Input: detector.get_flaky_tests()
Output: ['TestCase1']Constraints:
- 1 <= test_case.length <= 100
- 1 <= len(runs) <= 1000

As Coinbase implements various test scenarios for its functionalities, aggregating test results is essential for efficient reporting and analysis.
Problem statement: Design a TestResultAggregator class that handles the storage and computation of results from multiple test cases run on their framework. This class must have the ability to add test results, get all results, and compute the percentage of passed tests.
- Class Specification:
- Method Signature: def add_result(self, test_case: str, passed: bool) -> None
- Method Signature: def get_results(self) -> List[Tuple[str, bool]]
- Method Signature: def get_pass_percentage(self) -> float
Example 1:
Input: aggregator.add_result('TestCase1', True)
Output: None
Input: aggregator.get_results()
Output: [('TestCase1', True)]
Input: aggregator.get_pass_percentage()
Output: 100.0
Example 2:
Input: aggregator.add_result('TestCase2', False)
Output: None
Input: aggregator.get_pass_percentage()
Output: 50.0Constraints:
- 1 <= test_case.length <= 100
- 1 <= len(results) <= 1000