diff options
Diffstat (limited to 'vendor/opentracing/opentracing/tests')
6 files changed, 482 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()); + } +} diff --git a/vendor/opentracing/opentracing/tests/OpenTracing/ReferenceTest.php b/vendor/opentracing/opentracing/tests/OpenTracing/ReferenceTest.php new file mode 100644 index 000000000..cb971a20c --- /dev/null +++ b/vendor/opentracing/opentracing/tests/OpenTracing/ReferenceTest.php @@ -0,0 +1,45 @@ +<?php + +declare(strict_types=1); + +namespace OpenTracing\Tests; + +use TypeError; +use PHPUnit\Framework\TestCase; +use OpenTracing\Reference; +use OpenTracing\NoopSpanContext; +use OpenTracing\InvalidReferenceArgumentException; + +/** + * @covers Reference + */ +final class ReferenceTest extends TestCase +{ + const REFERENCE_TYPE = 'ref_type'; + + public function testCreateAReferenceFailsOnInvalidContext() + { + $context = 'invalid_context'; + + $this->expectException(TypeError::class); + new Reference('child_of', $context); + } + + public function testCreateAReferenceFailsOnEmptyType() + { + $context = new NoopSpanContext(); + + $this->expectException(InvalidReferenceArgumentException::class); + $this->expectExceptionMessage('Reference type can not be an empty string'); + new Reference('', $context); + } + + public function testAReferenceCanBeCreatedAsACustomType() + { + $context = new NoopSpanContext(); + $reference = new Reference(self::REFERENCE_TYPE, $context); + + $this->assertSame($context, $reference->getSpanContext()); + $this->assertTrue($reference->isType(self::REFERENCE_TYPE)); + } +} diff --git a/vendor/opentracing/opentracing/tests/OpenTracing/StartSpanOptionsTest.php b/vendor/opentracing/opentracing/tests/OpenTracing/StartSpanOptionsTest.php new file mode 100644 index 000000000..d7e1504a8 --- /dev/null +++ b/vendor/opentracing/opentracing/tests/OpenTracing/StartSpanOptionsTest.php @@ -0,0 +1,129 @@ +<?php + +declare(strict_types=1); + +namespace OpenTracing\Tests; + +use DateTime; +use OpenTracing\InvalidSpanOptionException; +use OpenTracing\NoopSpanContext; +use OpenTracing\Reference; +use OpenTracing\StartSpanOptions; +use PHPUnit\Framework\TestCase; + +/** + * @covers StartSpanOptions + */ +final class StartSpanOptionsTest extends TestCase +{ + const REFERENCE_TYPE = 'a_reference_type'; + + public function testSpanOptionsCanNotBeCreatedDueToInvalidOption() + { + $this->expectException(InvalidSpanOptionException::class); + + StartSpanOptions::create([ + 'unknown_option' => 'value' + ]); + } + + public function testSpanOptionsWithInvalidCloseOnFinishOption() + { + $this->expectException(InvalidSpanOptionException::class); + + StartSpanOptions::create([ + 'finish_span_on_close' => 'value' + ]); + } + + public function testSpanOptionsCanNotBeCreatedBecauseInvalidStartTime() + { + $this->expectException(InvalidSpanOptionException::class); + + StartSpanOptions::create([ + 'start_time' => 'abc' + ]); + } + + /** @dataProvider validStartTime */ + public function testSpanOptionsCanBeCreatedBecauseWithValidStartTime($startTime) + { + $spanOptions = StartSpanOptions::create([ + 'start_time' => $startTime + ]); + + $this->assertEquals($spanOptions->getStartTime(), $startTime); + } + + public function validStartTime() + { + return [ + [new DateTime()], + ['1499355363'], + [1499355363], + [1499355363.123456] + ]; + } + + public function testSpanOptionsCanBeCreatedWithValidReference() + { + $context = new NoopSpanContext(); + + $options = [ + 'references' => new Reference(self::REFERENCE_TYPE, $context), + ]; + + $spanOptions = StartSpanOptions::create($options); + $references = $spanOptions->getReferences()[0]; + + $this->assertTrue($references->isType(self::REFERENCE_TYPE)); + $this->assertSame($context, $references->getSpanContext()); + } + + public function testSpanOptionsDefaultCloseOnFinishValue() + { + $options = StartSpanOptions::create([]); + + $this->assertTrue($options->shouldFinishSpanOnClose()); + } + + public function testSpanOptionsWithValidFinishSpanOnClose() + { + $options = StartSpanOptions::create([ + 'finish_span_on_close' => false, + ]); + + $this->assertFalse($options->shouldFinishSpanOnClose()); + } + + public function testSpanOptionsAddsANewReference() + { + $context1 = new NoopSpanContext(); + $spanOptions = StartSpanOptions::create([ + 'child_of' => $context1, + ]); + $this->assertCount(1, $spanOptions->getReferences()); + + $context2 = new NoopSpanContext(); + $spanOptions = $spanOptions->withParent($context2); + + $this->assertCount(1, $spanOptions->getReferences()); + $this->assertSame($context2, $spanOptions->getReferences()[0]->getSpanContext()); + } + + public function testDefaultIgnoreActiveSpan() + { + $options = StartSpanOptions::create([]); + + $this->assertFalse($options->shouldIgnoreActiveSpan()); + } + + public function testSpanOptionsWithValidIgnoreActiveSpan() + { + $options = StartSpanOptions::create([ + 'ignore_active_span' => true, + ]); + + $this->assertTrue($options->shouldIgnoreActiveSpan()); + } +} |