def test_is_data_transfer_service_enabled(self):
        # Setup Expected Response
        enabled = False
        reason = 'reason-934964668'
        expected_response = {'enabled': enabled, 'reason': reason}
        expected_response = datatransfer_pb2.IsDataTransferServiceEnabledResponse(
            **expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        name = client.location_path('[PROJECT]', '[LOCATION]')

        response = client.is_data_transfer_service_enabled(name)
        assert expected_response == response

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.IsDataTransferServiceEnabledRequest(
            name=name)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_list_transfer_logs(self):
        # Setup Expected Response
        next_page_token = ''
        transfer_messages_element = {}
        transfer_messages = [transfer_messages_element]
        expected_response = {
            'next_page_token': next_page_token,
            'transfer_messages': transfer_messages
        }
        expected_response = datatransfer_pb2.ListTransferLogsResponse(
            **expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        parent = client.run_path('[PROJECT]', '[LOCATION]',
                                 '[TRANSFER_CONFIG]', '[RUN]')

        paged_list_response = client.list_transfer_logs(parent)
        resources = list(paged_list_response)
        assert len(resources) == 1

        assert expected_response.transfer_messages[0] == resources[0]

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.ListTransferLogsRequest(
            parent=parent)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_check_valid_creds(self):
        # Setup Expected Response
        has_valid_creds = False
        expected_response = {'has_valid_creds': has_valid_creds}
        expected_response = datatransfer_pb2.CheckValidCredsResponse(
            **expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        name = client.data_source_path('[PROJECT]', '[LOCATION]',
                                       '[DATA_SOURCE]')

        response = client.check_valid_creds(name)
        assert expected_response == response

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.CheckValidCredsRequest(name=name)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_start_manual_transfer_runs(self):
        # Setup Expected Response
        expected_response = {}
        expected_response = datatransfer_pb2.StartManualTransferRunsResponse(
            **expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        parent = client.transfer_config_path('[PROJECT]', '[LOCATION]',
                                             '[TRANSFER_CONFIG]')

        response = client.start_manual_transfer_runs(parent)
        assert expected_response == response

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.StartManualTransferRunsRequest(
            parent=parent)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_get_data_source(self):
        # Setup Expected Response
        name_2 = 'name2-1052831874'
        data_source_id = 'dataSourceId-1015796374'
        display_name = 'displayName1615086568'
        description = 'description-1724546052'
        client_id = 'clientId-1904089585'
        supports_multiple_transfers = True
        update_deadline_seconds = 991471694
        default_schedule = 'defaultSchedule-800168235'
        supports_custom_schedule = True
        help_url = 'helpUrl-789431439'
        default_data_refresh_window_days = 1804935157
        manual_runs_disabled = True
        partner_legal_name = 'partnerLegalName-1307326424'
        redirect_url = 'redirectUrl951230092'
        expected_response = {
            'name': name_2,
            'data_source_id': data_source_id,
            'display_name': display_name,
            'description': description,
            'client_id': client_id,
            'supports_multiple_transfers': supports_multiple_transfers,
            'update_deadline_seconds': update_deadline_seconds,
            'default_schedule': default_schedule,
            'supports_custom_schedule': supports_custom_schedule,
            'help_url': help_url,
            'default_data_refresh_window_days':
            default_data_refresh_window_days,
            'manual_runs_disabled': manual_runs_disabled,
            'partner_legal_name': partner_legal_name,
            'redirect_url': redirect_url
        }
        expected_response = datatransfer_pb2.DataSource(**expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        name = client.data_source_path('[PROJECT]', '[LOCATION]',
                                       '[DATA_SOURCE]')

        response = client.get_data_source(name)
        assert expected_response == response

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.GetDataSourceRequest(name=name)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_update_transfer_config(self):
        # Setup Expected Response
        name = 'name3373707'
        destination_dataset_id = 'destinationDatasetId1541564179'
        display_name = 'displayName1615086568'
        data_source_id = 'dataSourceId-1015796374'
        schedule = 'schedule-697920873'
        data_refresh_window_days = 327632845
        disabled = True
        user_id = 147132913
        dataset_region = 'datasetRegion959248539'
        notification_pubsub_topic = 'notificationPubsubTopic1794281191'
        partner_token = 'partnerToken725173186'
        expected_response = {
            'name': name,
            'destination_dataset_id': destination_dataset_id,
            'display_name': display_name,
            'data_source_id': data_source_id,
            'schedule': schedule,
            'data_refresh_window_days': data_refresh_window_days,
            'disabled': disabled,
            'user_id': user_id,
            'dataset_region': dataset_region,
            'notification_pubsub_topic': notification_pubsub_topic,
            'partner_token': partner_token
        }
        expected_response = transfer_pb2.TransferConfig(**expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        transfer_config = {}
        authorization_code = 'authorizationCode1571154419'
        update_mask = {}

        response = client.update_transfer_config(transfer_config,
                                                 authorization_code,
                                                 update_mask)
        assert expected_response == response

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.UpdateTransferConfigRequest(
            transfer_config=transfer_config,
            authorization_code=authorization_code,
            update_mask=update_mask)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_is_data_transfer_service_enabled_exception(self):
        # Mock the API response
        channel = ChannelStub(responses=[CustomException()])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup request
        name = client.location_path('[PROJECT]', '[LOCATION]')

        with pytest.raises(CustomException):
            client.is_data_transfer_service_enabled(name)
    def test_list_data_sources_exception(self):
        channel = ChannelStub(responses=[CustomException()])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup request
        parent = client.location_path('[PROJECT]', '[LOCATION]')

        paged_list_response = client.list_data_sources(parent)
        with pytest.raises(CustomException):
            list(paged_list_response)
    def test_check_valid_creds_exception(self):
        # Mock the API response
        channel = ChannelStub(responses=[CustomException()])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup request
        name = client.data_source_path('[PROJECT]', '[LOCATION]',
                                       '[DATA_SOURCE]')

        with pytest.raises(CustomException):
            client.check_valid_creds(name)
    def test_delete_transfer_run_exception(self):
        # Mock the API response
        channel = ChannelStub(responses=[CustomException()])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup request
        name = client.run_path('[PROJECT]', '[LOCATION]', '[TRANSFER_CONFIG]',
                               '[RUN]')

        with pytest.raises(CustomException):
            client.delete_transfer_run(name)
    def test_update_transfer_config_exception(self):
        # Mock the API response
        channel = ChannelStub(responses=[CustomException()])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup request
        transfer_config = {}
        authorization_code = 'authorizationCode1571154419'
        update_mask = {}

        with pytest.raises(CustomException):
            client.update_transfer_config(transfer_config, authorization_code,
                                          update_mask)
    def test_enable_data_transfer_service(self):
        channel = ChannelStub()
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        name = client.location_path('[PROJECT]', '[LOCATION]')

        client.enable_data_transfer_service(name)

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.EnableDataTransferServiceRequest(
            name=name)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_delete_transfer_run(self):
        channel = ChannelStub()
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        name = client.run_path('[PROJECT]', '[LOCATION]', '[TRANSFER_CONFIG]',
                               '[RUN]')

        client.delete_transfer_run(name)

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.DeleteTransferRunRequest(name=name)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request
    def test_schedule_transfer_runs_exception(self):
        # Mock the API response
        channel = ChannelStub(responses=[CustomException()])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup request
        parent = client.transfer_config_path('[PROJECT]', '[LOCATION]',
                                             '[TRANSFER_CONFIG]')
        labels = {}
        start_time = {}
        end_time = {}

        with pytest.raises(CustomException):
            client.schedule_transfer_runs(parent, labels, start_time, end_time)
    def test_get_transfer_config(self):
        # Setup Expected Response
        name_2 = 'name2-1052831874'
        destination_dataset_id = 'destinationDatasetId1541564179'
        display_name = 'displayName1615086568'
        data_source_id = 'dataSourceId-1015796374'
        schedule = 'schedule-697920873'
        data_refresh_window_days = 327632845
        disabled = True
        user_id = 147132913
        dataset_region = 'datasetRegion959248539'
        notification_pubsub_topic = 'notificationPubsubTopic1794281191'
        partner_token = 'partnerToken725173186'
        expected_response = {
            'name': name_2,
            'destination_dataset_id': destination_dataset_id,
            'display_name': display_name,
            'data_source_id': data_source_id,
            'schedule': schedule,
            'data_refresh_window_days': data_refresh_window_days,
            'disabled': disabled,
            'user_id': user_id,
            'dataset_region': dataset_region,
            'notification_pubsub_topic': notification_pubsub_topic,
            'partner_token': partner_token
        }
        expected_response = transfer_pb2.TransferConfig(**expected_response)

        # Mock the API response
        channel = ChannelStub(responses=[expected_response])
        patch = mock.patch('google.api_core.grpc_helpers.create_channel')
        with patch as create_channel:
            create_channel.return_value = channel
            client = datatransfer_v1.DataTransferServiceClient()

        # Setup Request
        name = client.transfer_config_path('[PROJECT]', '[LOCATION]',
                                           '[TRANSFER_CONFIG]')

        response = client.get_transfer_config(name)
        assert expected_response == response

        assert len(channel.requests) == 1
        expected_request = datatransfer_pb2.GetTransferConfigRequest(name=name)
        actual_request = channel.requests[0][1]
        assert expected_request == actual_request