/// <summary>Snippet for RerunConnectivityTestAsync</summary>
        public async Task RerunConnectivityTestRequestObjectAsync()
        {
            // Snippet: RerunConnectivityTestAsync(RerunConnectivityTestRequest, CallSettings)
            // Additional: RerunConnectivityTestAsync(RerunConnectivityTestRequest, CancellationToken)
            // Create client
            ReachabilityServiceClient reachabilityServiceClient = await ReachabilityServiceClient.CreateAsync();

            // Initialize request argument(s)
            RerunConnectivityTestRequest request = new RerunConnectivityTestRequest {
                Name = "",
            };
            // Make the request
            Operation <ConnectivityTest, OperationMetadata> response = await reachabilityServiceClient.RerunConnectivityTestAsync(request);

            // Poll until the returned long-running operation is complete
            Operation <ConnectivityTest, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();

            // Retrieve the operation result
            ConnectivityTest result = completedResponse.Result;

            // Or get the name of the operation
            string operationName = response.Name;
            // This name can be stored, then the long-running operation retrieved later by name
            Operation <ConnectivityTest, OperationMetadata> retrievedResponse = await reachabilityServiceClient.PollOnceRerunConnectivityTestAsync(operationName);

            // Check if the retrieved long-running operation has completed
            if (retrievedResponse.IsCompleted)
            {
                // If it has completed, then access the result
                ConnectivityTest retrievedResult = retrievedResponse.Result;
            }
            // End snippet
        }
        /// <summary>Snippet for UpdateConnectivityTest</summary>
        public void UpdateConnectivityTest()
        {
            // Snippet: UpdateConnectivityTest(FieldMask, ConnectivityTest, CallSettings)
            // Create client
            ReachabilityServiceClient reachabilityServiceClient = ReachabilityServiceClient.Create();
            // Initialize request argument(s)
            FieldMask        updateMask = new FieldMask();
            ConnectivityTest resource   = new ConnectivityTest();
            // Make the request
            Operation <ConnectivityTest, OperationMetadata> response = reachabilityServiceClient.UpdateConnectivityTest(updateMask, resource);

            // Poll until the returned long-running operation is complete
            Operation <ConnectivityTest, OperationMetadata> completedResponse = response.PollUntilCompleted();
            // Retrieve the operation result
            ConnectivityTest result = completedResponse.Result;

            // Or get the name of the operation
            string operationName = response.Name;
            // This name can be stored, then the long-running operation retrieved later by name
            Operation <ConnectivityTest, OperationMetadata> retrievedResponse = reachabilityServiceClient.PollOnceUpdateConnectivityTest(operationName);

            // Check if the retrieved long-running operation has completed
            if (retrievedResponse.IsCompleted)
            {
                // If it has completed, then access the result
                ConnectivityTest retrievedResult = retrievedResponse.Result;
            }
            // End snippet
        }
Пример #3
0
        public void basicTest()
        {
            NimbiClient      client           = new NimbiClient(Environments.QA, "[some_api_id]", "[some_api_key]");
            ConnectivityTest connectivityTest = new ConnectivityTest();
            IRestResponse    response         = connectivityTest.testConnectivity(client);

            Assert.IsTrue($"{{\"Errors\":[\"Invalid API Key. ([some_api_key])\"],\"StatusCode\":400}}".Equals(response.Content));
        }
 /// <summary>Snippet for GetConnectivityTest</summary>
 public void GetConnectivityTest()
 {
     // Snippet: GetConnectivityTest(string, CallSettings)
     // Create client
     ReachabilityServiceClient reachabilityServiceClient = ReachabilityServiceClient.Create();
     // Initialize request argument(s)
     string name = "";
     // Make the request
     ConnectivityTest response = reachabilityServiceClient.GetConnectivityTest(name);
     // End snippet
 }
Пример #5
0
        public ItemsPage()
        {
            InitializeComponent();

            connectivityTest = new ConnectivityTest();
            if (connectivityTest.CheckInternet())
            {
                Toast.MakeText(Android.App.Application.Context, "Internet connection Available", ToastLength.Long).Show();
                BindingContext = viewModel = new ItemsViewModel();
            }
        }
 /// <summary>Snippet for GetConnectivityTest</summary>
 public void GetConnectivityTestRequestObject()
 {
     // Snippet: GetConnectivityTest(GetConnectivityTestRequest, CallSettings)
     // Create client
     ReachabilityServiceClient reachabilityServiceClient = ReachabilityServiceClient.Create();
     // Initialize request argument(s)
     GetConnectivityTestRequest request = new GetConnectivityTestRequest {
         Name = "",
     };
     // Make the request
     ConnectivityTest response = reachabilityServiceClient.GetConnectivityTest(request);
     // End snippet
 }
        /// <summary>Snippet for GetConnectivityTestAsync</summary>
        public async Task GetConnectivityTestAsync()
        {
            // Snippet: GetConnectivityTestAsync(string, CallSettings)
            // Additional: GetConnectivityTestAsync(string, CancellationToken)
            // Create client
            ReachabilityServiceClient reachabilityServiceClient = await ReachabilityServiceClient.CreateAsync();

            // Initialize request argument(s)
            string name = "";
            // Make the request
            ConnectivityTest response = await reachabilityServiceClient.GetConnectivityTestAsync(name);

            // End snippet
        }
        public async stt::Task GetConnectivityTestRequestObjectAsync()
        {
            moq::Mock <ReachabilityService.ReachabilityServiceClient> mockGrpcClient = new moq::Mock <ReachabilityService.ReachabilityServiceClient>(moq::MockBehavior.Strict);

            mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
            GetConnectivityTestRequest request = new GetConnectivityTestRequest
            {
                Name = "name1c9368b0",
            };
            ConnectivityTest expectedResponse = new ConnectivityTest
            {
                ConnectivityTestName = ConnectivityTestName.FromProjectTest("[PROJECT]", "[TEST]"),
                Description          = "description2cf9da67",
                Source          = new Endpoint(),
                Destination     = new Endpoint(),
                Protocol        = "protocola08b7881",
                RelatedProjects =
                {
                    "related_projectsf33be6e8",
                },
                DisplayName = "display_name137f65c2",
                Labels      =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                CreateTime          = new wkt::Timestamp(),
                UpdateTime          = new wkt::Timestamp(),
                ReachabilityDetails = new ReachabilityDetails(),
            };

            mockGrpcClient.Setup(x => x.GetConnectivityTestAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <ConnectivityTest>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            ReachabilityServiceClient client = new ReachabilityServiceClientImpl(mockGrpcClient.Object, null);
            ConnectivityTest          responseCallSettings = await client.GetConnectivityTestAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            xunit::Assert.Same(expectedResponse, responseCallSettings);
            ConnectivityTest responseCancellationToken = await client.GetConnectivityTestAsync(request, st::CancellationToken.None);

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }