adding mocha/chai and few unit tests

Author: Ashish Aggarwal

Makefile

@@ -12,7 +12,14 @@ check-node-version:
 	@$(MIN_NODE_VER_FOUND) || echo Build requires minimum Node $(MIN_NODE_VER).x
 
 .PHONY: build
-build: check-node-version npm_install idl_codegen tslint
+build: check-node-version npm_install idl_codegen tslint compile test
+
+.PHONY: test
+test:
+	./node_modules/mocha/bin/mocha -r ./node_modules/ts-node/register src/tests/**/*.ts
+
+.PHONY: compile
+compile:
 	rm -rf ./dist/
 	tsc -p tsconfig.json
 	cp package.json dist/

package.json

@@ -22,13 +22,18 @@
   "dependencies": {
     "google-protobuf": "^3.0.0",
     "grpc": "^1.9.0",
-    "uuid": "^3.2.1",
-    "opentracing": "^0.13.0"
+    "opentracing": "^0.13.0",
+    "uuid": "^3.2.1"
   },
   "devDependencies": {
-    "@types/node": "^10.3.4",
-    "typescript": "2.9.2",
+    "@types/node": "7.0.12",
+    "@types/chai": "3.4.35",
+    "@types/mocha": "2.2.40",
+    "chai": "^3.5.0",
     "grpc-tools": "1.6.6",
-    "tslint": "^5.0.0"
+    "mocha": "^2.5.3",
+    "ts-node": "^7.0.0",
+    "tslint": "^5.0.0",
+    "typescript": "2.9.2"
   }
 }

src/dispatchers/in_memory.ts

@@ -40,4 +40,8 @@ export default class InMemoryDispatcher implements Dispatcher {
             callback();
         }
     }
+
+    spans(): Span[] {
+        return this._spans;
+    }
 }

src/start_span_fields.ts

@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+// startSpanFields is used for type-checking the Trace.startSpan().
+import SpanContext from './span_context';
+import * as opentracing from 'opentracing';
+
+export default class StartSpanFields {
+    childOf?: SpanContext;
+    references?: opentracing.Reference[];
+    tags?: any;
+    startTime?: number;
+    callerSpanContext?: SpanContext;
+}

src/tests/tracer.spec.ts

@@ -0,0 +1,85 @@
+/*
+ *  Copyright 2018 Expedia, Inc.
+ *
+ *       Licensed under the Apache License, Version 2.0 (the "License");
+ *       you may not use this file except in compliance with the License.
+ *      You may obtain a copy of the License at
+ *
+ *           http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *       Unless required by applicable law or agreed to in writing, software
+ *       distributed under the License is distributed on an "AS IS" BASIS,
+ *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *       See the License for the specific language governing permissions and
+ *       limitations under the License.
+ */
+
+import { expect } from 'chai';
+import Tracer from '../tracer';
+import InMemoryDispatcher from '../dispatchers/in_memory';
+import StartSpanFields from '../start_span_fields';
+import {isUndefined} from 'util';
+
+describe('Tracer tests', () => {
+    const dummyServiceName = 'my-service';
+    const dummyOperation = 'my-service-operation';
+    const downstreamOperation = 'downstream';
+    const commonTags = {
+      version: '1.1'
+    };
+
+    describe('Tracer#startSpan', () => {
+        it('should start a span and dispatch when finished', () => {
+            const inMemSpanStore = new InMemoryDispatcher();
+            const tracer = new Tracer(dummyServiceName, inMemSpanStore, commonTags);
+            expect(tracer.serviceName()).equal(dummyServiceName);
+            const span = tracer.startSpan(dummyOperation);
+            expect(span.isFinished()).eq(false);
+            expect(inMemSpanStore.spans().length).equal(0);
+            span.finish();
+            expect(inMemSpanStore.spans().length).equal(1);
+            const receivedSpan = inMemSpanStore.spans()[0];
+            expect(receivedSpan.isFinished()).eq(true);
+            expect(receivedSpan.serviceName()).eq(dummyServiceName);
+            expect(receivedSpan.operationName()).eq(dummyOperation);
+            expect(isUndefined(receivedSpan.context().traceId())).eq(false);
+            expect(isUndefined(receivedSpan.context().spanId())).eq(false);
+            expect(isUndefined(receivedSpan.context().parentSpanId())).eq(true);
+            const receivedSpanTag = receivedSpan.tags()[0];
+            expect(receivedSpanTag.key).eq('version');
+            expect(receivedSpanTag.value).eq('1.1');
+        });
+
+        it('should start and dispatch server and client spans', () => {
+            const inMemSpanStore = new InMemoryDispatcher();
+            const tracer = new Tracer(dummyServiceName, inMemSpanStore, commonTags);
+            expect(tracer.serviceName()).equal(dummyServiceName);
+            const serverSpan = tracer.startSpan(dummyOperation);
+            const startSpanFields = new StartSpanFields();
+            startSpanFields.childOf = serverSpan.context();
+            startSpanFields.tags = { 'span.kind': 'client' };
+            const clientSpan = tracer.startSpan(downstreamOperation, startSpanFields);
+
+            expect(serverSpan.isFinished()).eq(false);
+            expect(inMemSpanStore.spans().length).equal(0);
+            serverSpan.finish();
+            clientSpan.finish();
+
+            expect(inMemSpanStore.spans().length).equal(2);
+            inMemSpanStore.spans().forEach(receivedSpan => {
+                expect(receivedSpan.isFinished()).eq(true);
+                const receivedSpanTag = receivedSpan.tags()[0];
+                expect(receivedSpanTag.key).eq('version');
+                expect(receivedSpanTag.value).eq('1.1');
+                expect(receivedSpan.serviceName()).eq(dummyServiceName);
+            });
+            expect(inMemSpanStore.spans().map(span => span.operationName())).includes(downstreamOperation);
+            expect(inMemSpanStore.spans().map(span => span.operationName())).includes(dummyOperation);
+            const receivedClientSpan = inMemSpanStore.spans().filter(span => span.tags().filter(tag => tag.key === 'span.kind' && tag.value === 'client').length > 0)[0];
+            const receivedServerSpan = inMemSpanStore.spans().filter(span => span.tags().filter(tag => tag.key === 'span.kind').length <= 0)[0];
+            expect(receivedClientSpan.context().parentSpanId()).eq(receivedServerSpan.context().spanId());
+            expect(isUndefined(receivedServerSpan.context().parentSpanId())).eq(true);
+            expect(receivedServerSpan.context().traceId()).eq(receivedClientSpan.context().traceId());
+        });
+    });
+});

src/tracer.ts

@@ -26,15 +26,7 @@ import Utils from './utils';
 import PropagationRegistry from './propagators/propagation_registry';
 import TextMapPropagator from './propagators/textmap_propagator';
 import URLCodex from './propagators/url_codex';
-
-// startSpanFields is used for type-checking the Trace.startSpan().
-declare interface StartSpanFields {
-    childOf?: SpanContext;
-    references?: opentracing.Reference[];
-    tags?: any;
-    startTime?: number;
-    callerSpanContext?: SpanContext;
-}
+import StartSpanFields from './start_span_fields';
 
 export default class Tracer {
     _serviceName: string;