Adapted tests for dev

Author: djonathascardoso

packages/opencensus-core/test/test-root-span.ts

@@ -0,0 +1,96 @@
+/**
+* Copyright 2017 Google Inc. All Rights Reserved.
+*
+* 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 { RootSpan } from '../src/trace/model/rootspan';
+import { Span } from '../src/trace/model/span';
+import { Tracer } from '../src/trace/model/tracer';
+import { SpanBaseModel } from '../src/trace/types/tracetypes';
+
+let assert = require('assert');
+let tracer = new Tracer();
+
+describe('RootSpan', function () {
+    describe('new RootSpan()', function () {
+        it('should create a RootSpan instance', function () {
+            let root = new RootSpan(tracer);
+            assert.ok(root instanceof SpanBaseModel);
+        });
+    });
+
+    describe('start()', function () {
+
+        it('should start a RootSpan instance', function () {
+            let root = new RootSpan(tracer);
+            root.start();
+            assert.ok(root.started);
+        });
+
+    });
+
+    describe('startSpan()', function () {
+
+        let root, span;
+
+        before(function () {
+            root = new RootSpan(tracer);
+            root.start();
+            span = root.startSpan('spanName', 'spanType');
+        });
+
+        it('should check span instance type', function () {
+            assert.ok(span instanceof Span);
+        });
+
+        it('should check if a new span was started', function () {
+            assert.ok(span.started);
+        });
+    });
+
+    describe('end()', function () {
+        it('should end the trace', function () {
+            let root = new RootSpan(tracer);
+            root.start();
+            root.end();
+            assert.ok(root.ended);
+        });
+    });
+
+    describe('end() before trace started', function () {
+        it('should not end trace', function () {
+            let root = new RootSpan(tracer);
+            root.end();
+            assert.ok(!root.ended);
+        });
+    });
+
+    describe('startSpan() before trace started', function () {
+        it('should not create span', function () {
+            let root = new RootSpan(tracer);
+            let span = root.startSpan('spanName', 'spanType');
+            assert.ok(span == null);
+        });
+    });
+
+    describe('startSpan() after trace ended', function () {
+        it('should not create span', function () {
+            let root = new RootSpan(tracer);
+            root.start();
+            root.end();
+            let span = root.startSpan('spanName', 'spanType');
+            assert.ok(span == null);
+        });
+    });
+});

packages/opencensus-core/test/test-span.ts

@@ -24,59 +24,58 @@ var assert = require('assert');
 
 let tracer = new Tracer()
 
-describe('Span creation', function () {
+describe('Span', function () {
 
-    let root;
-    let span;
+describe('startSpan()', function () {
 
-    before(function () {
-        root = new RootSpan(tracer);
-        span = root.startSpan('spanName', 'typeSpan');
-    });
+    it('should create an span', function () {
+        const rootSpan = new RootSpan(tracer);
+        assert.ok(rootSpan instanceof SpanBaseModel);
 
-    it('should create an span on the trace', function () {
-        assert.ok(root instanceof SpanBaseModel);
-        span = root.startSpan('spanName', 'typeSpan');
+        rootSpan.start();
+        const span = rootSpan.startSpan('spanName', 'typeSpan');
         assert.ok(span instanceof Span);
         assert.ok(span.id);
     });
 
     it('should start a span', function () {
+        const rootSpan = new RootSpan(tracer);
+        rootSpan.start();
+        const span = rootSpan.startSpan('spanName', 'typeSpan');
         span.start();
         assert.ok(span.started);
     });
 
     it('should end a span', function () {
+        const rootSpan = new RootSpan(tracer);
+        rootSpan.start();
+        const span = rootSpan.startSpan('spanName', 'typeSpan');
+        span.start();
         span.end();
         assert.ok(span.ended);
     });
 });
 
-describe('Span checking creation', function () {
-
-    let root;
-    let span;
-
-    before(function () {
-        root = new RootSpan(tracer);
-        span = root.startSpan('spanName', 'typeSpan');
-    });
+describe('Span checking after creation', function () {
 
     it('should not start span after it ended', function () {
+        const root = new RootSpan(tracer);
+        root.start();
+        const span = root.startSpan('spanName', 'typeSpan');
+        span.start();
         span.end();
+
+        span.start();
         assert.equal(span.ended, true);
     });
 });
 
 describe('Span data', function () {
 
-    let root;
-
-    before(function () {
-        root = new RootSpan(tracer);
-    });
+    it('should create an unique numeric span ID strings', function () {
+        const root = new RootSpan(tracer);
+        root.start();
 
-    it('generates unique numeric span ID strings', function () {
         var numberOfSpansToCheck = 5;
         for (var i = 0; i < numberOfSpansToCheck; i++) {
             var span = root.startSpan('spanName' + i, 'typeSpan' + i);
@@ -89,8 +88,9 @@ describe('Span data', function () {
     });
 
     // TODO
-    it('truncates namespace', function(){
+    it('should truncate namespace', function () {
         this.skip();
     });
 });
 
+});