Cleanup tests, ignore tests from npm

.npmignore

@@ -1,4 +1,5 @@
-src/
 .vscode/
+src/
+out/tests/
 tsconfig.json
 tslint.json

gulpfile.js

@@ -30,7 +30,7 @@ gulp.task("ts", cb => {
 
 gulp.task("mocha", () => {
 	const mocha = requireCache("gulp-mocha");
-	gulp.src("out/TestMagic.js", { read: false })
+	gulp.src("out/tests/Main.js", { read: false })
 		.pipe(mocha({ reporter: "min" }));
 });
 

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "mtgsdk-ts",
-	"version": "1.0.2",
+	"version": "1.1.0",
 
 	"dependencies": {
 		"request-promise": "4.2.1",
@@ -9,11 +9,14 @@
 	"main": "./out/Magic.js",
 
 	"description": "An sdk for https://magicthegathering.io/ written in Typescript. Works for JavaScript and TypeScript development.",
+	"keywords": [
+
+	],
+	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/aarilight/mtg-sdk-typescript"
 	},
-	"license": "MIT",
 
 	"devDependencies": {
 		"gulp": "3.9.1",

src/TestMagic.ts → src/tests/Main.ts

@@ -4,44 +4,44 @@ import chai = require("chai");
 chai.use(require("chai-as-promised"));
 const expect = chai.expect;
 
-import Magic = require("./Magic");
+import Magic = require("../Magic");
 
 
 describe("Cards", () => {
 	it("find", async () => {
 		const card = await Magic.Cards.find("08618f8d5ebdc0c4d381ad11f0563dfebb21f4ee");
-		expect(card.name).to.equal("Blood Scrivener");
+		expect(card.name).eq("Blood Scrivener");
 	});
 	it("where", async () => {
 		const cards = await Magic.Cards.where({
 			name: `"Murder"`
 		});
-		expect(cards.length).to.be.gte(3);
+		expect(cards.length).gte(3);
 		for (const card of cards) {
-			expect(card.name).to.equal("Murder");
+			expect(card.name).eq("Murder");
 		}
 	});
 	it("all", (done) => {
 		const results: Magic.Card[] = [];
 		Magic.Cards.all({ name: "Doom Blade", pageSize: 3 }).on("data", (card) => {
-			expect(card.name).to.equal("Doom Blade");
+			expect(card.name).eq("Doom Blade");
 			results.push(card);
 		}).on("end", () => {
-			expect(results.length).to.be.gte(8);
+			expect(results.length).gte(8);
 			done();
 		});
 	});
 	it("all-cancel", (done) => {
 		const results: Magic.Card[] = [];
 		const emitter = Magic.Cards.all({ name: "Doom Blade", pageSize: 3 });
 		emitter.on("data", (card) => {
-			expect(card.name).to.equal("Doom Blade");
+			expect(card.name).eq("Doom Blade");
 			results.push(card);
 			if (results.length == 5) emitter.cancel();
 		}).on("end", () => {
 			throw new Error("Did not expect to reach this point");
 		}).on("cancel", () => {
-			expect(results.length).to.be.eq(5);
+			expect(results.length).eq(5);
 			done();
 		});
 	});
@@ -50,48 +50,48 @@ describe("Cards", () => {
 describe("Sets", () => {
 	it("find", async () => {
 		const set = await Magic.Sets.find("HOU");
-		expect(set.name).to.equal("Hour of Devastation");
+		expect(set.name).eq("Hour of Devastation");
 	});
 	it("where", async () => {
 		const sets = await Magic.Sets.where({
 			block: `Kaladesh`
 		});
-		expect(sets.length).to.be.eq(2);
+		expect(sets.length).eq(2);
 		for (const set of sets) {
-			expect(set.block).to.equal("Kaladesh");
+			expect(set.block).eq("Kaladesh");
 		}
 	});
 	it("all", (done) => {
 		let count = 0;
 		Magic.Sets.all({}).on("data", () => count++).on("end", () => {
-			expect(count).to.be.gte(210);
+			expect(count).eq(210);
 			done();
 		});
 	});
 	it("booster", async () => {
 		const booster = await Magic.Sets.generateBooster("HOU");
-		expect(booster.length).to.be.gte(10).and.lt(30); // might as well be vague
+		expect(booster.length).gte(10).lt(30); // might as well be vague
 		for (const card of booster) {
-			expect(card.set).to.equal("HOU");
+			expect(card.set).eq("HOU");
 		}
 	});
 });
 
 describe("Archive", () => {
 	it("types", async () => {
 		const types = await Magic.Types.all();
-		expect(types.length).to.be.gte(13);
+		expect(types.length).gte(13);
 	});
 	it("subtypes", async () => {
 		const types = await Magic.Subtypes.all();
-		expect(types.length).to.be.gte(348);
+		expect(types.length).gte(348);
 	});
 	it("supertypes", async () => {
 		const types = await Magic.Supertypes.all();
-		expect(types.length).to.be.gte(5);
+		expect(types.length).gte(5);
 	});
 	it("formats", async () => {
 		const formats = await Magic.Formats.all();
-		expect(formats.length).to.be.gte(36);
+		expect(formats.length).gte(36);
 	});
 });