Instance name support unittests

tests/integration/bots_service.py

@@ -18,7 +18,6 @@
 # pylint: disable=redefined-outer-name
 
 import copy
-import uuid
 from unittest import mock
 
 import grpc
@@ -27,7 +26,7 @@ import pytest
 
 from buildgrid._protos.build.bazel.remote.execution.v2 import remote_execution_pb2
 from buildgrid._protos.google.devtools.remoteworkers.v1test2 import bots_pb2
-from buildgrid.server import scheduler, job
+from buildgrid.server import job, buildgrid_instance
 from buildgrid.server.job import LeaseState
 from buildgrid.server.worker import bots_interface, bots_service
 
@@ -53,8 +52,8 @@ def bot_session():
 
 
 @pytest.fixture
-def schedule():
-    yield scheduler.Scheduler()
+def buildgrid():
+    yield buildgrid_instance.BuildGridInstance()
 
 
 @pytest.fixture
@@ -64,19 +63,17 @@ def bots(schedule):
 
 # Instance to test
 @pytest.fixture
-def instance(bots):
-    yield bots_service.BotsService(bots)
+def instance(buildgrid):
+    instances = {"": buildgrid}
+    yield bots_service.BotsService(instances)
 
 
 def test_create_bot_session(bot_session, context, instance):
-    parent = 'rach'
-    request = bots_pb2.CreateBotSessionRequest(parent=parent,
-                                               bot_session=bot_session)
+    request = bots_pb2.CreateBotSessionRequest(bot_session=bot_session)
 
     response = instance.CreateBotSession(request, context)
 
     assert isinstance(response, bots_pb2.BotSession)
-    assert uuid.UUID(response.name, version=4)
     assert bot_session.bot_id == response.bot_id
 
 
@@ -92,8 +89,7 @@ def test_create_bot_session_bot_id_fail(context, instance):
 
 
 def test_update_bot_session(bot_session, context, instance):
-    request = bots_pb2.CreateBotSessionRequest(parent='',
-                                               bot_session=bot_session)
+    request = bots_pb2.CreateBotSessionRequest(bot_session=bot_session)
     bot = instance.CreateBotSession(request, context)
 
     request = bots_pb2.UpdateBotSessionRequest(name=bot.name,
@@ -106,8 +102,7 @@ def test_update_bot_session(bot_session, context, instance):
 
 
 def test_update_bot_session_zombie(bot_session, context, instance):
-    request = bots_pb2.CreateBotSessionRequest(parent='',
-                                               bot_session=bot_session)
+    request = bots_pb2.CreateBotSessionRequest(bot_session=bot_session)
     bot = instance.CreateBotSession(request, context)
     # Update server with incorrect UUID by rotating it
     bot.name = bot.name[len(bot.name): 0]
@@ -121,8 +116,7 @@ def test_update_bot_session_zombie(bot_session, context, instance):
 
 
 def test_update_bot_session_bot_id_fail(bot_session, context, instance):
-    request = bots_pb2.UpdateBotSessionRequest(name='ana',
-                                               bot_session=bot_session)
+    request = bots_pb2.UpdateBotSessionRequest(bot_session=bot_session)
 
     instance.UpdateBotSession(request, context)
 
@@ -131,17 +125,15 @@ def test_update_bot_session_bot_id_fail(bot_session, context, instance):
 
 @pytest.mark.parametrize("number_of_jobs", [0, 1, 3, 500])
 def test_number_of_leases(number_of_jobs, bot_session, context, instance):
-    request = bots_pb2.CreateBotSessionRequest(parent='',
-                                               bot_session=bot_session)
+    request = bots_pb2.CreateBotSessionRequest(bot_session=bot_session)
     # Inject work
     for _ in range(0, number_of_jobs):
         action_digest = remote_execution_pb2.Digest()
-        instance._instance._scheduler.append_job(job.Job(action_digest))
+        instance._instances[""].execute(action_digest, True)
 
     response = instance.CreateBotSession(request, context)
 
     assert len(response.leases) == number_of_jobs
-    assert isinstance(response, bots_pb2.BotSession)
 
 
 def test_update_leases_with_work(bot_session, context, instance):
@@ -149,7 +141,7 @@ def test_update_leases_with_work(bot_session, context, instance):
                                                bot_session=bot_session)
     # Inject work
     action_digest = remote_execution_pb2.Digest(hash='gaff')
-    instance._instance._scheduler.append_job(job.Job(action_digest))
+    instance._instances[""].execute(action_digest, True)
 
     response = instance.CreateBotSession(request, context)
 
@@ -159,7 +151,6 @@ def test_update_leases_with_work(bot_session, context, instance):
 
     assert isinstance(response, bots_pb2.BotSession)
     assert response.leases[0].state == LeaseState.PENDING.value
-    assert uuid.UUID(response.leases[0].id, version=4)
     assert response_action == action_digest
 
 
@@ -172,7 +163,7 @@ def test_update_leases_work_complete(bot_session, context, instance):
 
     # Inject work
     action_digest = remote_execution_pb2.Digest(hash='gaff')
-    instance._instance._scheduler.append_job(job.Job(action_digest))
+    instance._instances[""].execute(action_digest, True)
 
     request = bots_pb2.UpdateBotSessionRequest(name=response.name,
                                                bot_session=response)
@@ -200,7 +191,7 @@ def test_work_rejected_by_bot(bot_session, context, instance):
                                                bot_session=bot_session)
     # Inject work
     action_digest = remote_execution_pb2.Digest(hash='gaff')
-    instance._instance._scheduler.append_job(job.Job(action_digest))
+    instance._instances[""].execute(action_digest, True)
 
     # Simulated the severed binding between client and server
     response = copy.deepcopy(instance.CreateBotSession(request, context))
@@ -222,7 +213,8 @@ def test_work_out_of_sync_from_pending(state, bot_session, context, instance):
                                                bot_session=bot_session)
     # Inject work
     action_digest = remote_execution_pb2.Digest(hash='gaff')
-    instance._instance._scheduler.append_job(job.Job(action_digest))
+    instance._instances[""].execute(action_digest, True)
+
     # Simulated the severed binding between client and server
     response = copy.deepcopy(instance.CreateBotSession(request, context))
 
@@ -242,7 +234,8 @@ def test_work_out_of_sync_from_active(state, bot_session, context, instance):
                                                bot_session=bot_session)
     # Inject work
     action_digest = remote_execution_pb2.Digest(hash='gaff')
-    instance._instance._scheduler.append_job(job.Job(action_digest))
+    instance._instances[""].execute(action_digest, True)
+
     # Simulated the severed binding between client and server
     response = copy.deepcopy(instance.CreateBotSession(request, context))
 
@@ -268,7 +261,8 @@ def test_work_active_to_active(bot_session, context, instance):
                                                bot_session=bot_session)
     # Inject work
     action_digest = remote_execution_pb2.Digest(hash='gaff')
-    instance._instance._scheduler.append_job(job.Job(action_digest))
+    instance._instances[""].execute(action_digest, True)
+
     # Simulated the severed binding between client and server
     response = copy.deepcopy(instance.CreateBotSession(request, context))
 

tests/integration/execution_service.py

@@ -20,15 +20,17 @@
 import uuid
 from unittest import mock
 
-from grpc._server import _Context
 import pytest
+import grpc
+from grpc._server import _Context
+from google.protobuf import any_pb2
 
 from buildgrid._protos.build.bazel.remote.execution.v2 import remote_execution_pb2
 from buildgrid._protos.google.longrunning import operations_pb2
 
-from buildgrid.server import scheduler, job
+from buildgrid.server import job, buildgrid_instance
 from buildgrid.server.cas.storage import lru_memory_cache
-from buildgrid.server.execution import action_cache, execution_instance, execution_service
+from buildgrid.server.execution import action_cache, execution_service
 
 
 @pytest.fixture
@@ -38,19 +40,21 @@ def context():
 
 
 @pytest.fixture(params=["action-cache", "no-action-cache"])
-def execution(request):
+def buildgrid(request):
     if request.param == "action-cache":
         storage = lru_memory_cache.LRUMemoryCache(1024 * 1024)
         cache = action_cache.ActionCache(storage, 50)
-        schedule = scheduler.Scheduler(cache)
-        return execution_instance.ExecutionInstance(schedule, storage)
-    return execution_instance.ExecutionInstance(scheduler.Scheduler())
+
+        return buildgrid_instance.BuildGridInstance(action_cache=cache,
+                                                    cas_storage=storage)
+    return buildgrid_instance.BuildGridInstance()
 
 
 # Instance to test
 @pytest.fixture
-def instance(execution):
-    yield execution_service.ExecutionService(execution)
+def instance(buildgrid):
+    instances = {"": buildgrid}
+    yield execution_service.ExecutionService(instances)
 
 
 @pytest.mark.parametrize("skip_cache_lookup", [True, False])
@@ -72,23 +76,45 @@ def test_execute(skip_cache_lookup, instance, context):
     assert result.done is False
 
 
-# def test_wait_execution(instance, context):
-    # TODO: Figure out why next(response) hangs on the .get()
-    # method when running in pytest.
-#     action_digest = remote_execution_pb2.Digest()
-#     action_digest.hash = 'zhora'
+def test_wrong_execute_instance(instance, context):
+    request = remote_execution_pb2.ExecuteRequest(instance_name='blade')
+    response = instance.Execute(request, context)
+
+    next(response)
+    context.set_code.assert_called_once_with(grpc.StatusCode.INVALID_ARGUMENT)
+
+
+def test_wait_execution(instance, buildgrid, context):
+    action_digest = remote_execution_pb2.Digest()
+    action_digest.hash = 'zhora'
+
+    j = job.Job(action_digest, None)
+    j._operation.done = True
 
-#     j = job.Job(action_digest, None)
-#     j._operation.done = True
+    request = remote_execution_pb2.WaitExecutionRequest(name="{}/{}".format('', j.name))
 
-#     request = remote_execution_pb2.WaitExecutionRequest(name=j.name)
+    buildgrid._scheduler.jobs[j.name] = j
 
-#     instance._instance._scheduler.jobs[j.name] = j
+    action_result_any = any_pb2.Any()
+    action_result = remote_execution_pb2.ActionResult()
+    action_result_any.Pack(action_result)
+
+    j.update_execute_stage(job.ExecuteStage.COMPLETED)
+
+    response = instance.WaitExecution(request, context)
+
+    result = next(response)
+
+    assert isinstance(result, operations_pb2.Operation)
+    metadata = remote_execution_pb2.ExecuteOperationMetadata()
+    result.metadata.Unpack(metadata)
+    assert metadata.stage == job.ExecuteStage.COMPLETED.value
+    assert uuid.UUID(result.name, version=4)
+    assert result.done is True
 
-#     action_result_any = any_pb2.Any()
-#     action_result = remote_execution_pb2.ActionResult()
-#     action_result_any.Pack(action_result)
 
-#     instance._instance._scheduler._update_execute_stage(j, job.ExecuteStage.COMPLETED)
+def test_wrong_instance_wait_execution(instance, buildgrid, context):
+    request = remote_execution_pb2.WaitExecutionRequest(name="blade")
+    next(instance.WaitExecution(request, context))
 
-#     response = instance.WaitExecution(request, context)
+    context.set_code.assert_called_once_with(grpc.StatusCode.INVALID_ARGUMENT)

tests/integration/operations_service.py

@@ -28,10 +28,13 @@ from google.protobuf import any_pb2
 from buildgrid._protos.build.bazel.remote.execution.v2 import remote_execution_pb2
 from buildgrid._protos.google.longrunning import operations_pb2
 
-from buildgrid.server import scheduler
+from buildgrid.server import buildgrid_instance
 from buildgrid.server._exceptions import InvalidArgumentError
 
-from buildgrid.server.execution import execution_instance, operations_service
+from buildgrid.server.execution import operations_service
+
+
+instance_name = "blade"
 
 
 # Can mock this
@@ -52,29 +55,25 @@ def execute_request():
 
 
 @pytest.fixture
-def schedule():
-    yield scheduler.Scheduler()
-
-
-@pytest.fixture
-def execution(schedule):
-    yield execution_instance.ExecutionInstance(schedule)
+def buildgrid():
+    yield buildgrid_instance.BuildGridInstance()
 
 
 # Instance to test
 @pytest.fixture
-def instance(execution):
-    yield operations_service.OperationsService(execution)
+def instance(buildgrid):
+    instances = {instance_name: buildgrid}
+    yield operations_service.OperationsService(instances)
 
 
 # Queue an execution, get operation corresponding to that request
-def test_get_operation(instance, execute_request, context):
-    response_execute = instance._instance.execute(execute_request.action_digest,
-                                                  execute_request.skip_cache_lookup)
+def test_get_operation(instance, buildgrid, execute_request, context):
+    response_execute = buildgrid.execute(execute_request.action_digest,
+                                         execute_request.skip_cache_lookup)
 
     request = operations_pb2.GetOperationRequest()
 
-    request.name = response_execute.name
+    request.name = "{}/{}".format(instance_name, response_execute.name)
 
     response = instance.GetOperation(request, context)
     assert response is response_execute
@@ -87,30 +86,31 @@ def test_get_operation_fail(instance, context):
     context.set_code.assert_called_once_with(grpc.StatusCode.INVALID_ARGUMENT)
 
 
-def test_list_operations(instance, execute_request, context):
-    response_execute = instance._instance.execute(execute_request.action_digest,
-                                                  execute_request.skip_cache_lookup)
+def test_list_operations(instance, buildgrid, execute_request, context):
+    response_execute = buildgrid.execute(execute_request.action_digest,
+                                         execute_request.skip_cache_lookup)
 
-    request = operations_pb2.ListOperationsRequest()
+    request = operations_pb2.ListOperationsRequest(name=instance_name)
     response = instance.ListOperations(request, context)
 
-    assert response.operations[0].name == response_execute.name
+    assert response.operations[0].name.split('/')[-1] == response_execute.name
 
 
-def test_list_operations_with_result(instance, execute_request, context):
-    response_execute = instance._instance.execute(execute_request.action_digest,
-                                                  execute_request.skip_cache_lookup)
+def test_list_operations_with_result(instance, buildgrid, execute_request, context):
+    response_execute = buildgrid.execute(execute_request.action_digest,
+                                         execute_request.skip_cache_lookup)
 
     action_result = remote_execution_pb2.ActionResult()
     output_file = remote_execution_pb2.OutputFile(path='unicorn')
     action_result.output_files.extend([output_file])
 
-    instance._instance._scheduler.job_complete(response_execute.name, _pack_any(action_result))
+    buildgrid._scheduler.job_complete(response_execute.name,
+                                      _pack_any(action_result))
 
-    request = operations_pb2.ListOperationsRequest()
+    request = operations_pb2.ListOperationsRequest(name=instance_name)
     response = instance.ListOperations(request, context)
 
-    assert response.operations[0].name == response_execute.name
+    assert response.operations[0].name.split('/')[-1] == response_execute.name
 
     execute_response = remote_execution_pb2.ExecuteResponse()
     response.operations[0].response.Unpack(execute_response)
@@ -118,7 +118,7 @@ def test_list_operations_with_result(instance, execute_request, context):
 
 
 def test_list_operations_empty(instance, context):
-    request = operations_pb2.ListOperationsRequest()
+    request = operations_pb2.ListOperationsRequest(name=instance_name)
 
     response = instance.ListOperations(request, context)
 
@@ -126,33 +126,28 @@ def test_list_operations_empty(instance, context):
 
 
 # Send execution off, delete, try to find operation should fail
-def test_delete_operation(instance, execute_request, context):
-    response_execute = instance._instance.execute(execute_request.action_digest,
-                                                  execute_request.skip_cache_lookup)
+def test_delete_operation(instance, buildgrid, execute_request, context):
+    response_execute = buildgrid.execute(execute_request.action_digest,
+                                         execute_request.skip_cache_lookup)
     request = operations_pb2.DeleteOperationRequest()
-    request.name = response_execute.name
+    request.name = "{}/{}".format(instance_name, response_execute.name)
     instance.DeleteOperation(request, context)
 
     request = operations_pb2.GetOperationRequest()
-    request.name = response_execute.name
+    request.name = "{}/{}".format(instance_name, response_execute.name)
+
     with pytest.raises(InvalidArgumentError):
-        instance._instance.get_operation(response_execute.name)
+        buildgrid.get_operation(response_execute.name)
 
 
 def test_delete_operation_fail(instance, execute_request, context):
     request = operations_pb2.DeleteOperationRequest()
+    request.name = "{}/{}".format(instance_name, "runner")
     instance.DeleteOperation(request, context)
 
     context.set_code.assert_called_once_with(grpc.StatusCode.INVALID_ARGUMENT)
 
 
-def test_cancel_operation(instance, context):
-    request = operations_pb2.CancelOperationRequest()
-    instance.CancelOperation(request, context)
-
-    context.set_code.assert_called_once_with(grpc.StatusCode.UNIMPLEMENTED)
-
-
 def _pack_any(pack):
     some_any = any_pb2.Any()
     some_any.Pack(pack)