Beispiel #1
0
        public async stt::Task GetTraceRequestObjectAsync()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            GetTraceRequest request = new GetTraceRequest
            {
                ProjectId = "project_id43ad98b0",
                TraceId   = "trace_id105c890f",
            };
            Trace expectedResponse = new Trace
            {
                ProjectId = "project_id43ad98b0",
                TraceId   = "trace_id105c890f",
                Spans     = { new TraceSpan(), },
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
        public async Task CreateSpanAsync()
        {
            Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict);
            apis::Span request = new apis::Span
            {
                SpanName    = new SpanName("[PROJECT]", "[TRACE]", "[SPAN]"),
                SpanId      = "spanId-2011840976",
                DisplayName = new TruncatableString(),
                StartTime   = new Timestamp(),
                EndTime     = new Timestamp(),
            };
            apis::Span expectedResponse = new apis::Span
            {
                SpanName     = new SpanName("[PROJECT]", "[TRACE]", "[SPAN]"),
                SpanId       = "spanId2-643891741",
                ParentSpanId = "parentSpanId-1757797477",
            };

            mockGrpcClient.Setup(x => x.CreateSpanAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <apis::Span>(Task.FromResult(expectedResponse), null, null, null, null));
            TraceServiceClient client   = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            apis::Span         response = await client.CreateSpanAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async stt::Task CreateSpanRequestObjectAsync()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            Span request = new Span
            {
                SpanName                = SpanName.FromProjectTraceSpan("[PROJECT]", "[TRACE]", "[SPAN]"),
                SpanId                  = "span_id47c232d3",
                ParentSpanId            = "parent_span_ide637f6a2",
                DisplayName             = new TruncatableString(),
                StartTime               = new wkt::Timestamp(),
                EndTime                 = new wkt::Timestamp(),
                Attributes              = new Span.Types.Attributes(),
                StackTrace              = new StackTrace(),
                TimeEvents              = new Span.Types.TimeEvents(),
                Links                   = new Span.Types.Links(),
                Status                  = new gr::Status(),
                SameProcessAsParentSpan = false,
                ChildSpanCount          = -1491694397,
                SpanKind                = Span.Types.SpanKind.Consumer,
            };
            Span expectedResponse = new Span
            {
                SpanName                = SpanName.FromProjectTraceSpan("[PROJECT]", "[TRACE]", "[SPAN]"),
                SpanId                  = "span_id47c232d3",
                ParentSpanId            = "parent_span_ide637f6a2",
                DisplayName             = new TruncatableString(),
                StartTime               = new wkt::Timestamp(),
                EndTime                 = new wkt::Timestamp(),
                Attributes              = new Span.Types.Attributes(),
                StackTrace              = new StackTrace(),
                TimeEvents              = new Span.Types.TimeEvents(),
                Links                   = new Span.Types.Links(),
                Status                  = new gr::Status(),
                SameProcessAsParentSpan = false,
                ChildSpanCount          = -1491694397,
                SpanKind                = Span.Types.SpanKind.Consumer,
            };

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

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

            xunit::Assert.Same(expectedResponse, responseCancellationToken);
            mockGrpcClient.VerifyAll();
        }
Beispiel #4
0
        public void PatchTraces()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            PatchTracesRequest request = new PatchTracesRequest
            {
                ProjectId = "project_id43ad98b0",
                Traces    = new Traces(),
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

            mockGrpcClient.Setup(x => x.PatchTraces(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);

            client.PatchTraces(request.ProjectId, request.Traces);
            mockGrpcClient.VerifyAll();
        }
        public void BatchWriteSpans()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            BatchWriteSpansRequest request = new BatchWriteSpansRequest
            {
                ProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
                Spans       = { new Span(), },
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

            mockGrpcClient.Setup(x => x.BatchWriteSpans(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);

            client.BatchWriteSpans(request.Name, request.Spans);
            mockGrpcClient.VerifyAll();
        }
        public async Task BatchWriteSpansAsync2()
        {
            Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict);
            BatchWriteSpansRequest request = new BatchWriteSpansRequest
            {
                ProjectName = new ProjectName("[PROJECT]"),
                Spans       = { },
            };
            Empty expectedResponse = new Empty();

            mockGrpcClient.Setup(x => x.BatchWriteSpansAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            await client.BatchWriteSpansAsync(request);

            mockGrpcClient.VerifyAll();
        }
        public void BatchWriteSpans2()
        {
            Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict);
            BatchWriteSpansRequest request = new BatchWriteSpansRequest
            {
                ProjectName = new ProjectName("[PROJECT]"),
                Spans       = { },
            };
            Empty expectedResponse = new Empty();

            mockGrpcClient.Setup(x => x.BatchWriteSpans(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);

            client.BatchWriteSpans(request);
            mockGrpcClient.VerifyAll();
        }
        public async Task PatchTracesAsync2()
        {
            Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict);
            PatchTracesRequest request = new PatchTracesRequest
            {
                ProjectId = "projectId-1969970175",
                Traces    = new Traces(),
            };
            Empty expectedResponse = new Empty();

            mockGrpcClient.Setup(x => x.PatchTracesAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Empty>(Task.FromResult(expectedResponse), null, null, null, null));
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            await client.PatchTracesAsync(request);

            mockGrpcClient.VerifyAll();
        }
        public void PatchTraces2()
        {
            Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict);
            PatchTracesRequest request = new PatchTracesRequest
            {
                ProjectId = "projectId-1969970175",
                Traces    = new Traces(),
            };
            Empty expectedResponse = new Empty();

            mockGrpcClient.Setup(x => x.PatchTraces(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);

            client.PatchTraces(request);
            mockGrpcClient.VerifyAll();
        }
Beispiel #10
0
        public async stt::Task PatchTracesAsync()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            PatchTracesRequest request = new PatchTracesRequest
            {
                ProjectId = "project_id43ad98b0",
                Traces    = new Traces(),
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

            mockGrpcClient.Setup(x => x.PatchTracesAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            await client.PatchTracesAsync(request.ProjectId, request.Traces, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            await client.PatchTracesAsync(request.ProjectId, request.Traces, st::CancellationToken.None);

            mockGrpcClient.VerifyAll();
        }
        public async stt::Task BatchWriteSpansAsync()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            BatchWriteSpansRequest request = new BatchWriteSpansRequest
            {
                ProjectName = gagr::ProjectName.FromProject("[PROJECT]"),
                Spans       = { new Span(), },
            };
            wkt::Empty expectedResponse = new wkt::Empty {
            };

            mockGrpcClient.Setup(x => x.BatchWriteSpansAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <wkt::Empty>(stt::Task.FromResult(expectedResponse), null, null, null, null));
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            await client.BatchWriteSpansAsync(request.Name, request.Spans, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));

            await client.BatchWriteSpansAsync(request.Name, request.Spans, st::CancellationToken.None);

            mockGrpcClient.VerifyAll();
        }
Beispiel #12
0
        public void CreateSpanRequestObject()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            Span request = new Span
            {
                SpanName                = SpanName.FromProjectTraceSpan("[PROJECT]", "[TRACE]", "[SPAN]"),
                SpanId                  = "span_id47c232d3",
                ParentSpanId            = "parent_span_ide637f6a2",
                DisplayName             = new TruncatableString(),
                StartTime               = new wkt::Timestamp(),
                EndTime                 = new wkt::Timestamp(),
                Attributes              = new Span.Types.Attributes(),
                StackTrace              = new StackTrace(),
                TimeEvents              = new Span.Types.TimeEvents(),
                Links                   = new Span.Types.Links(),
                Status                  = new gr::Status(),
                SameProcessAsParentSpan = new bool?(),
                ChildSpanCount          = new int?(),
            };
            Span expectedResponse = new Span
            {
                SpanName                = SpanName.FromProjectTraceSpan("[PROJECT]", "[TRACE]", "[SPAN]"),
                SpanId                  = "span_id47c232d3",
                ParentSpanId            = "parent_span_ide637f6a2",
                DisplayName             = new TruncatableString(),
                StartTime               = new wkt::Timestamp(),
                EndTime                 = new wkt::Timestamp(),
                Attributes              = new Span.Types.Attributes(),
                StackTrace              = new StackTrace(),
                TimeEvents              = new Span.Types.TimeEvents(),
                Links                   = new Span.Types.Links(),
                Status                  = new gr::Status(),
                SameProcessAsParentSpan = new bool?(),
                ChildSpanCount          = new int?(),
            };

            mockGrpcClient.Setup(x => x.CreateSpan(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            Span response             = client.CreateSpan(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
Beispiel #13
0
        public void GetTrace()
        {
            moq::Mock <TraceService.TraceServiceClient> mockGrpcClient = new moq::Mock <TraceService.TraceServiceClient>(moq::MockBehavior.Strict);
            GetTraceRequest request = new GetTraceRequest
            {
                ProjectId = "project_id43ad98b0",
                TraceId   = "trace_id105c890f",
            };
            Trace expectedResponse = new Trace
            {
                ProjectId = "project_id43ad98b0",
                TraceId   = "trace_id105c890f",
                Spans     = { new TraceSpan(), },
            };

            mockGrpcClient.Setup(x => x.GetTrace(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            Trace response            = client.GetTrace(request.ProjectId, request.TraceId);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public async Task GetTraceAsync2()
        {
            Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict);
            GetTraceRequest request = new GetTraceRequest
            {
                ProjectId = "projectId-1969970175",
                TraceId   = "traceId1270300245",
            };
            Trace expectedResponse = new Trace
            {
                ProjectId = "projectId2939242356",
                TraceId   = "traceId2987826376",
            };

            mockGrpcClient.Setup(x => x.GetTraceAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <Trace>(Task.FromResult(expectedResponse), null, null, null, null));
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            Trace response            = await client.GetTraceAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        public void GetTrace2()
        {
            Mock <TraceService.TraceServiceClient> mockGrpcClient = new Mock <TraceService.TraceServiceClient>(MockBehavior.Strict);
            GetTraceRequest request = new GetTraceRequest
            {
                ProjectId = "projectId-1969970175",
                TraceId   = "traceId1270300245",
            };
            Trace expectedResponse = new Trace
            {
                ProjectId = "projectId2939242356",
                TraceId   = "traceId2987826376",
            };

            mockGrpcClient.Setup(x => x.GetTrace(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            TraceServiceClient client = new TraceServiceClientImpl(mockGrpcClient.Object, null);
            Trace response            = client.GetTrace(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }