Refactoring tests

This makes tests use the tdd instead of the bdd style.

Author: pspeter3

src/component.ts

@@ -1,5 +1,3 @@
-/// <reference path="../typings/react/react.d.ts"/>
-
 import Mixin = require("././mixin");
 import react = require("react");
 

src/create_class.ts

@@ -1,4 +1,3 @@
-/// <reference path="../typings/react/react.d.ts"/>
 import extractPrototype = require("./extract_prototype");
 import Component = require("./component");
 import react = require("react");

src/create_mixin.ts

@@ -1,4 +1,3 @@
-/// <reference path="../typings/react/react.d.ts"/>
 import extractPrototype = require("./extract_prototype");
 import Mixin = require("./mixin");
 import react = require("react");

src/mixin.ts

@@ -1,4 +1,3 @@
-/// <reference path="../typings/react/react.d.ts"/>
 import NotImplementedError = require("./not_implemented_error");
 import react = require("react");
 

test/component_spec.ts test/component_test.tstest/component_spec.ts renamed to test/component_test.ts

@@ -4,27 +4,27 @@ import TypedReact = require("../src/index");
 
 var assert = chai.assert;
 
-describe("Component", () => {
+suite("Component", () => {
     var component: TypedReact.Component<any, any>;
 
-    beforeEach(() => {
+    suiteSetup(() => {
         component = new TypedReact.Component<any, any>();
     });
 
-    it("should not have refs", () => {
+    test("should not have refs", () => {
         assert.isUndefined(component.refs);
     });
 
-    it("should not have props", () => {
+    test("should not have props", () => {
         assert.isUndefined(component.props);
     });
 
-    it("should not have state", () => {
+    test("should not have state", () => {
         assert.isUndefined(component.state);
     });
 
     var testNotImplemented = (methodName: string, fn: () => void): void => {
-        it("should throw for " + methodName, () => {
+        test("should throw for " + methodName, () => {
             assert.throws(fn, TypedReact.NotImplementedError, methodName + " should be implemented by React");
         });
     };
@@ -57,7 +57,7 @@ describe("Component", () => {
         component.replaceProps(null);
     });
 
-    it("should return null from render", () => {
+    test("should return null from render", () => {
         assert.isNull(component.render());
     });
 });

test/create_class_spec.ts test/create_class_test.tstest/create_class_spec.ts renamed to test/create_class_test.ts

@@ -52,32 +52,32 @@ class MixinTest extends FactoryTest implements HelperMixin {
     }
 }
 
-describe("createFactory", () => {
+suite("createFactory", () => {
     var clazz: React.ComponentClass<FactoryProps>;
     var factory: React.Factory<FactoryProps>;
     var element: React.ReactElement<FactoryProps>;
     var name = "test";
 
-    beforeEach(() => {
+    suiteSetup(() => {
         clazz = TypedReact.createClass(FactoryTest);
         factory = React.createFactory<FactoryProps>(clazz);
         element = factory({
             name: name
         });
     });
 
-    it("should produce a valid element", () => {
+    test("should produce a valid element", () => {
         assert.isTrue(React.isValidElement(element));
         assert.equal(element.props.name, name);
     });
 
-    it("should keep class properties", () => {
+    test("should keep class properties", () => {
         assert.equal(React.renderToStaticMarkup(factory({
             name: "Asana"
         })), "<h1>Greetings, Asana</h1>");
     });
 
-    it("should keep componentWillMount code", () => {
+    test("should keep componentWillMount code", () => {
         var willMountClazz = TypedReact.createClass(ComponentWillMountTest);
         var willMountFactory = React.createFactory(willMountClazz);
         var wasCalled = false;
@@ -90,15 +90,15 @@ describe("createFactory", () => {
         assert.isTrue(wasCalled);
     });
 
-    it("should keep inherited methods and props", () => {
+    test("should keep inherited methods and props", () => {
         var inheritedClazz = TypedReact.createClass(InheritanceTest);
         var inheritedFactory = React.createFactory(inheritedClazz);
         assert.equal(React.renderToStaticMarkup(inheritedFactory({
             name: "Asana"
         })), "<h1>Greetings, Asana</h1>");
     });
 
-    it("should handle life cycle mixins", () => {
+    test("should handle life cycle mixins", () => {
         var willMountClazz = TypedReact.createClass(ComponentWillMountTest, [
             TypedReact.createMixin(LifeCycleMixin)
         ]);
@@ -113,7 +113,7 @@ describe("createFactory", () => {
         assert.equal(callCount, 2);
     });
 
-    it("should handle normal mixins", () => {
+    test("should handle normal mixins", () => {
         var mixinClazz = TypedReact.createClass(MixinTest, [
             TypedReact.createMixin(HelperMixin)
         ]);

test/not_implemented_error_spec.ts test/not_implemented_error_test.tstest/not_implemented_error_spec.ts renamed to test/not_implemented_error_test.ts

@@ -4,19 +4,19 @@ import TypedReact = require("../src/index");
 
 var assert = chai.assert;
 
-describe("NotImplementedError", () => {
+suite("NotImplementedError", () => {
     var err: TypedReact.NotImplementedError;
     var methodName = "chai";
 
-    beforeEach(() => {
+    suiteSetup(() => {
         err = new TypedReact.NotImplementedError(methodName);
     });
 
-    it("should have a name", () => {
+    test("should have a name", () => {
         assert.equal(err.name, "NotImplementedError");
     });
 
-    it("should have a message", () => {
+    test("should have a message", () => {
         assert.equal(err.message, methodName + " should be implemented by React");
     });
 });