diff options
Diffstat (limited to 'vendor/opentracing/opentracing/tests/OpenTracing/Mock')
4 files changed, 308 insertions, 0 deletions
diff --git a/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockScopeManagerTest.php b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockScopeManagerTest.php new file mode 100644 index 000000000..eeca24497 --- /dev/null +++ b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockScopeManagerTest.php @@ -0,0 +1,63 @@ +<?php + +declare(strict_types=1); + +namespace OpenTracing\Tests\Mock; + +use OpenTracing\Mock\MockScopeManager; +use OpenTracing\Mock\MockTracer; +use PHPUnit\Framework\TestCase; + +final class MockScopeManagerTest extends TestCase +{ + private const OPERATION_NAME = 'test_name'; + + public function testGetActiveFailsWithNoActiveSpans() + { + $scopeManager = new MockScopeManager(); + + $this->assertNull($scopeManager->getActive()); + } + + public function testActivateSuccess() + { + $tracer = new MockTracer(); + $span = $tracer->startSpan(self::OPERATION_NAME); + $scopeManager = new MockScopeManager(); + $scopeManager->activate($span); + + $this->assertSame($span, $scopeManager->getActive()->getSpan()); + } + + public function testGetScopeReturnsNull() + { + $tracer = new MockTracer(); + $tracer->startSpan(self::OPERATION_NAME); + $scopeManager = new MockScopeManager(); + + $this->assertNull($scopeManager->getActive()); + } + + public function testGetScopeSuccess() + { + $tracer = new MockTracer(); + $span = $tracer->startSpan(self::OPERATION_NAME); + $scopeManager = new MockScopeManager(); + $scopeManager->activate($span); + $scope = $scopeManager->getActive(); + + $this->assertSame($span, $scope->getSpan()); + } + + public function testDeactivateSuccess() + { + $tracer = new MockTracer(); + $span = $tracer->startSpan(self::OPERATION_NAME); + $scopeManager = new MockScopeManager(); + $scopeManager->activate($span); + $scope = $scopeManager->getActive(); + $scopeManager->deactivate($scope); + + $this->assertNull($scopeManager->getActive()); + } +} diff --git a/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockSpanContextTest.php b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockSpanContextTest.php new file mode 100644 index 000000000..501450b24 --- /dev/null +++ b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockSpanContextTest.php @@ -0,0 +1,54 @@ +<?php + +declare(strict_types=1); + +namespace OpenTracing\Tests\Mock; + +use OpenTracing\Mock\MockSpanContext; +use PHPUnit\Framework\TestCase; + +final class MockSpanContextTest extends TestCase +{ + private const TRACE_ID = 123987; + private const SPAN_ID = 555632; + private const IS_SAMPLED = true; + private const BAGGAGE_ITEM_KEY = 'test_key'; + private const BAGGAGE_ITEM_VALUE = 'test_value'; + + public function testCreateAsRootSuccess() + { + $parentContext = MockSpanContext::createAsRoot(); + $childContext = MockSpanContext::createAsChildOf($parentContext); + + $this->assertEquals($parentContext->getTraceId(), $childContext->getTraceId()); + } + + public function testCreateMockSpanContextSuccess() + { + $spanContext = MockSpanContext::create( + self::TRACE_ID, + self::SPAN_ID, + self::IS_SAMPLED, + [self::BAGGAGE_ITEM_KEY => self::BAGGAGE_ITEM_VALUE] + ); + + $this->assertEquals($spanContext->getTraceId(), self::TRACE_ID); + $this->assertEquals($spanContext->getSpanId(), self::SPAN_ID); + $this->assertEquals($spanContext->isSampled(), self::IS_SAMPLED); + $this->assertEquals([self::BAGGAGE_ITEM_KEY => self::BAGGAGE_ITEM_VALUE], iterator_to_array($spanContext)); + $this->assertEquals(self::BAGGAGE_ITEM_VALUE, $spanContext->getBaggageItem(self::BAGGAGE_ITEM_KEY)); + } + + public function testAddBaggageItemSuccess() + { + $spanContext = MockSpanContext::create( + self::TRACE_ID, + self::SPAN_ID, + self::IS_SAMPLED + ); + $this->assertEmpty(iterator_to_array($spanContext)); + + $spanContext = $spanContext->withBaggageItem(self::BAGGAGE_ITEM_KEY, self::BAGGAGE_ITEM_VALUE); + $this->assertEquals([self::BAGGAGE_ITEM_KEY => self::BAGGAGE_ITEM_VALUE], iterator_to_array($spanContext)); + } +} diff --git a/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockSpanTest.php b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockSpanTest.php new file mode 100644 index 000000000..51e4b66f8 --- /dev/null +++ b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockSpanTest.php @@ -0,0 +1,52 @@ +<?php + +declare(strict_types=1); + +namespace OpenTracing\Tests\Mock; + +use OpenTracing\Mock\MockSpan; +use OpenTracing\Mock\MockSpanContext; +use PHPUnit\Framework\TestCase; + +/** + * @covers MockSpan + */ +final class MockSpanTest extends TestCase +{ + private const OPERATION_NAME = 'test'; + private const DURATION = 10; + private const TAG_KEY = 'test_key'; + private const TAG_VALUE = 'test_value'; + private const LOG_FIELD = 'test_log'; + + public function testCreateSpanSuccess() + { + $startTime = time(); + $span = new MockSpan(self::OPERATION_NAME, MockSpanContext::createAsRoot(), $startTime); + + $this->assertEquals($startTime, $span->getStartTime()); + $this->assertEmpty($span->getTags()); + $this->assertEmpty($span->getLogs()); + } + + public function testAddTagsAndLogsToSpanSuccess() + { + $span = new MockSpan(self::OPERATION_NAME, MockSpanContext::createAsRoot()); + + $span->setTag(self::TAG_KEY, self::TAG_VALUE); + $span->log([self::LOG_FIELD]); + + $this->assertEquals([self::TAG_KEY => self::TAG_VALUE], $span->getTags()); + $this->assertEquals(self::LOG_FIELD, $span->getLogs()[0]['fields'][0]); + } + + public function testSpanIsFinished() + { + $startTime = time(); + $span = new MockSpan(self::OPERATION_NAME, MockSpanContext::createAsRoot(), $startTime); + $span->finish($startTime + self::DURATION); + + $this->assertTrue($span->isFinished()); + $this->assertEquals(self::DURATION, $span->getDuration()); + } +} diff --git a/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockTracerTest.php b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockTracerTest.php new file mode 100644 index 000000000..ab2faf159 --- /dev/null +++ b/vendor/opentracing/opentracing/tests/OpenTracing/Mock/MockTracerTest.php @@ -0,0 +1,139 @@ +<?php + +declare(strict_types=1); + +namespace OpenTracing\Tests\Mock; + +use OpenTracing\InvalidReferenceArgumentException; +use OpenTracing\UnsupportedFormatException; +use OpenTracing\Mock\MockTracer; +use OpenTracing\NoopSpanContext; +use OpenTracing\Reference; +use OpenTracing\Span; +use OpenTracing\SpanContext; +use PHPUnit\Framework\TestCase; + +/** + * @covers MockTracer + */ +final class MockTracerTest extends TestCase +{ + private const OPERATION_NAME = 'test_name'; + private const FORMAT = 'test_format'; + + public function testStartActiveSpanSuccess() + { + $tracer = new MockTracer(); + $scope = $tracer->startActiveSpan(self::OPERATION_NAME); + $activeSpan = $tracer->getActiveSpan(); + + $this->assertEquals($scope->getSpan(), $activeSpan); + } + + public function testStartSpanSuccess() + { + $tracer = new MockTracer(); + $tracer->startSpan(self::OPERATION_NAME); + $activeSpan = $tracer->getActiveSpan(); + + $this->assertNull($activeSpan); + } + + public function testStartSpanWithReference(): void + { + $tracer = new MockTracer(); + $tracer->startSpan('parent_name'); + /** @var Span $parentSpan */ + $parentSpan = $tracer->getSpans()[0]; + $tracer->startSpan( + self::OPERATION_NAME, + ['references' => [Reference::createForSpan(Reference::CHILD_OF, $parentSpan)]] + ); + $activeSpan = $tracer->getActiveSpan(); + + self::assertNull($activeSpan); + } + + public function testStartSpanWithReferenceWithoutExpectedContextType(): void + { + $tracer = new MockTracer(); + $notAMockContext = new NoopSpanContext(); + + $this->expectException(InvalidReferenceArgumentException::class); + + $tracer->startSpan( + self::OPERATION_NAME, + ['references' => [new Reference(Reference::CHILD_OF, $notAMockContext)]] + ); + } + + public function testInjectWithNoInjectorsFails() + { + $tracer = new MockTracer(); + $span = $tracer->startSpan(self::OPERATION_NAME); + $carrier = []; + + $this->expectException(UnsupportedFormatException::class); + $tracer->inject($span->getContext(), self::FORMAT, $carrier); + } + + public function testInjectSuccess() + { + $actualSpanContext = null; + $actualCarrier = null; + + $injector = function ($spanContext, &$carrier) use (&$actualSpanContext, &$actualCarrier) { + $actualSpanContext = $spanContext; + $actualCarrier = $carrier; + }; + + $tracer = new MockTracer([self::FORMAT => $injector]); + $span = $tracer->startSpan(self::OPERATION_NAME); + $carrier = []; + $tracer->inject($span->getContext(), self::FORMAT, $carrier); + + $this->assertSame($span->getContext(), $actualSpanContext); + $this->assertSame($carrier, $actualCarrier); + } + + public function testExtractWithNoExtractorsFails() + { + $tracer = new MockTracer(); + $carrier = []; + + $this->expectException(UnsupportedFormatException::class); + $tracer->extract(self::FORMAT, $carrier); + } + + public function testExtractSuccess() + { + $actualSpanContext = null; + $actualCarrier = null; + + $extractor = function ($carrier) use (&$actualCarrier) { + $actualCarrier = $carrier; + return new NoopSpanContext(); + }; + + $tracer = new MockTracer([], [self::FORMAT => $extractor]); + $carrier = [ + 'TRACE_ID' => 'trace_id' + ]; + + $spanContext = $tracer->extract(self::FORMAT, $carrier); + + $this->assertInstanceOf(SpanContext::class, $spanContext); + } + + public function testFlushSuccess() + { + $tracer = new MockTracer(); + $tracer->startSpan(self::OPERATION_NAME); + + $this->assertCount(1, $tracer->getSpans()); + + $tracer->flush(); + + $this->assertCount(0, $tracer->getSpans()); + } +} |