Merge pull request #8 from keroxp/deno-v0.3

fix: bump deno version v0.3

Author: keroxp

.gitignore

@@ -1,3 +1,4 @@
 deno.d.ts
 .idea
 commands
+tsconfig.json

.travis.yml

@@ -1,7 +1,7 @@
 language: python
 
 install:
-- curl -L https://deno.land/x/install/install.py | python - v0.2.6
+- curl -fsSL https://deno.land/x/install/install.sh | sh -s -- v0.3.0
 - export PATH="$HOME/.deno/bin:$PATH"
 
 services:

Makefile

@@ -1,6 +1,4 @@
 redis:
 	docker run -p 6379:6379 -d -t redis:5
 test:
-	deno redis_test.ts --allow-net
-	deno pubsub_test.ts --allow-net
-	deno pipeline_test.ts --allow-net
+	deno --allow-net test.ts

io.ts

@@ -1,5 +1,5 @@
-import {BufReader, BufWriter} from "https://deno.land/x/[email protected].6/bufio.ts";
-import {Buffer} from "deno";
+import {BufReader, BufWriter} from "https://deno.land/x/[email protected].11/bufio.ts";
+import Buffer = Deno.Buffer;
 import {ErrorReplyError} from "./errors.ts";
 
 export type RedisRawReply =

pipeline.ts

@@ -1,4 +1,4 @@
-import {BufReader, BufWriter} from "https://deno.land/x/[email protected].6/bufio.ts";
+import {BufReader, BufWriter} from "https://deno.land/x/[email protected].11/bufio.ts";
 import {createRequest, readReply, RedisRawReply} from "./io.ts";
 import {ErrorReplyError} from "./errors.ts";
 import {create, Redis} from "./redis.ts";

pipeline_test.ts

@@ -1,5 +1,4 @@
-import {test} from "https://deno.land/x/[email protected]/mod.ts";
-import {assertEqual} from "https://deno.land/x/[email protected]/mod.ts";
+import {test, assert} from "https://deno.land/x/[email protected]/testing/mod.ts";
 import {connect} from "./redis.ts";
 
 const addr = "127.0.0.1:6379";
@@ -16,7 +15,7 @@ test(async function testPipeline() {
         pl.del("set2")
     ]);
     const ret = await pl.flush();
-    assertEqual(ret, [
+    assert.equal(ret, [
         ["status", "PONG"],
         ["status", "PONG"],
         ["status", "OK"],
@@ -56,7 +55,7 @@ test(async function testTx() {
     const rep2 = await tx2.flush();
     const rep3 = await tx3.flush();
     console.log(rep1);
-    assertEqual(parseInt(rep1[4][1] as string), parseInt(rep1[0][1] as string) + 3);
-    assertEqual(parseInt(rep2[4][1] as string), parseInt(rep2[0][1] as string) + 3);
-    assertEqual(parseInt(rep3[4][1] as string), parseInt(rep3[0][1] as string) + 3);
+    assert.equal(parseInt(rep1[4][1] as string), parseInt(rep1[0][1] as string) + 3);
+    assert.equal(parseInt(rep2[4][1] as string), parseInt(rep2[0][1] as string) + 3);
+    assert.equal(parseInt(rep3[4][1] as string), parseInt(rep3[0][1] as string) + 3);
 });

pubsub.ts

@@ -1,4 +1,4 @@
-import {BufReader, BufWriter} from "https://deno.land/x/[email protected].6/bufio.ts";
+import {BufReader, BufWriter} from "https://deno.land/x/[email protected].11/bufio.ts";
 import {readArrayReply, sendCommand} from "./io.ts";
 
 export type RedisSubscription = {

pubsub_test.ts

@@ -1,5 +1,4 @@
-import {test} from "https://deno.land/x/[email protected]/mod.ts";
-import {assertEqual} from "https://deno.land/x/[email protected]/mod.ts"
+import {test, assert} from "https://deno.land/x/[email protected]/testing/mod.ts";
 import {connect} from "./redis.ts";
 import {RedisPubSubMessage} from "./pubsub.ts";
 
@@ -17,7 +16,7 @@ test(async function testSubscribe() {
     //const hoge = await redis.get("hoge");
     const unsub = await sub.unsubscribe("subsc");
     await sub.close();
-    assertEqual(sub.isClosed, true);
+    assert.equal(sub.isClosed, true);
     redis.close()
 });
 
@@ -33,12 +32,12 @@ test(async function testSubscribe2() {
     await pub.publish("subsc2", "wayway");
     await sub.close();
     await wait(100);
-    assertEqual(message, {
+    assert.equal(message, {
         channel: "subsc2",
         message: "wayway"
     });
     const a = await redis.get("aaa");
-    assertEqual(a, void 0);
+    assert.equal(a, void 0);
     pub.close();
     redis.close()
 });
@@ -58,12 +57,12 @@ test(async function testPsubscribe() {
     await pub.publish("psubs", "heyhey");
     await sub.close();
     await wait(100);
-    assertEqual(message1, {
+    assert.equal(message1, {
         pattern: "ps*",
         channel: "psub",
         message: "wayway"
     });
-    assertEqual(message2, {
+    assert.equal(message2, {
         pattern: "ps*",
         channel: "psubs",
         message: "heyhey"

redis.ts

@@ -1,5 +1,7 @@
-import {Closer, Conn, dial, Reader, Writer} from "deno"
-import {BufReader, BufWriter} from "https://deno.land/x/[email protected]/bufio.ts";
+type Reader = Deno.Reader;
+type Writer = Deno.Writer;
+type Closer = Deno.Closer;
+import {BufReader, BufWriter} from "https://deno.land/x/[email protected]/bufio.ts";
 import {ConnectionClosedError} from "./errors.ts";
 import {psubscribe, RedisSubscription, subscribe} from "./pubsub.ts";
 import {RedisRawReply, sendCommand} from "./io.ts";
@@ -1375,7 +1377,7 @@ class RedisImpl implements Redis, CommandExecutor {
 }
 
 export async function connect(addr: string): Promise<Redis> {
-    const conn = await dial("tcp", addr);
+    const conn = await Deno.dial("tcp", addr);
     return create(
         conn,
         conn,

redis_test.ts

@@ -1,11 +1,5 @@
 import {connect} from "./redis.ts";
-import {setFilter, test} from "https://deno.land/x/[email protected]/mod.ts"
-import {assertEqual} from "https://deno.land/x/[email protected]/mod.ts"
-import {args} from "deno";
-
-if (args.length > 1) {
-    setFilter(args[1])
-}
+import {test, assert} from "https://deno.land/x/[email protected]/testing/mod.ts";
 // can be substituted with env variable
 const addr = "127.0.0.1:6379";
 
@@ -17,33 +11,33 @@ test(async function beforeAll() {
 test(async function testExists() {
     const redis = await connect(addr);
     const none = await redis.exists("none", "none2");
-    assertEqual(none, 0);
+    assert.equal(none, 0);
     await redis.set("exists", "aaa");
     const exists = await redis.exists("exists", "none");
-    assertEqual(exists, 1);
+    assert.equal(exists, 1);
     redis.close()
 });
 
 test(async function testGetWhenNil() {
     const redis = await connect(addr);
     const hoge = await redis.get("none");
-    assertEqual(hoge, void 0);
+    assert.equal(hoge, void 0);
     redis.close();
 });
 test(async function testSet() {
     const redis = await connect(addr);
     const s = await redis.set("get", "fuga");
-    assertEqual(s, "OK");
+    assert.equal(s, "OK");
     const fuga = await redis.get("get");
-    assertEqual(fuga, "fuga");
+    assert.equal(fuga, "fuga");
     redis.close();
 });
 test(async function testGetSet() {
     const redis = await connect(addr);
     await redis.set("getset", "val");
     const v = await redis.getset("getset", "lav");
-    assertEqual(v, "val");
-    assertEqual(await redis.get("getset"), "lav");
+    assert.equal(v, "val");
+    assert.equal(await redis.get("getset"), "lav");
     redis.close();
 });
 test(async function testMget() {
@@ -52,48 +46,48 @@ test(async function testMget() {
     await redis.set("mget2", "val2");
     await redis.set("mget3", "val3");
     const v = await redis.mget("mget1", "mget2", "mget3");
-    assertEqual(v, ["val1", "val2", "val3"]);
+    assert.equal(v, ["val1", "val2", "val3"]);
     redis.close();
 });
 test(async function testDel() {
     const redis = await connect(addr);
     let s = await redis.set("del1", "fuga");
-    assertEqual(s, "OK");
+    assert.equal(s, "OK");
     s = await redis.set("del2", "fugaaa");
-    assertEqual(s, "OK");
+    assert.equal(s, "OK");
     const deleted = await redis.del("del1", "del2");
-    assertEqual(deleted, 2);
+    assert.equal(deleted, 2);
     redis.close();
 });
 
 test(async function testIncr() {
     const redis = await connect(addr);
     const rep = await redis.incr("incr");
-    assertEqual(rep, 1);
-    assertEqual(await redis.get("incr"), "1");
+    assert.equal(rep, 1);
+    assert.equal(await redis.get("incr"), "1");
     redis.close();
 });
 
 test(async function testIncrby() {
     const redis = await connect(addr);
     const rep = await redis.incrby("incrby", 101);
-    assertEqual(rep, 101);
-    assertEqual(await redis.get("incrby"), "101");
+    assert.equal(rep, 101);
+    assert.equal(await redis.get("incrby"), "101");
     redis.close();
 });
 
 test(async function testDecr() {
     const redis = await connect(addr);
     const rep = await redis.decr("decr");
-    assertEqual(rep, -1);
-    assertEqual(await redis.get("decr"), "-1");
+    assert.equal(rep, -1);
+    assert.equal(await redis.get("decr"), "-1");
     redis.close();
 });
 
 test(async function testDecrby() {
     const redis = await connect(addr);
     const rep = await redis.decrby("decryby", 101);
-    assertEqual(rep, -101);
-    assertEqual(await redis.get("decryby"), "-101");
+    assert.equal(rep, -101);
+    assert.equal(await redis.get("decryby"), "-101");
     redis.close();
 });

test.ts

@@ -0,0 +1,5 @@
+import "./redis_test.ts"
+import "./pubsub_test.ts"
+import "./pipeline_test.ts"
+import {runTests} from "https://deno.land/x/[email protected]/testing/mod.ts";
+runTests();

tsconfig.json

@@ -1,14 +1,13 @@
 {
   "compilerOptions": {
     "target": "es2018",
-    "baseUrl": ".",
+    "baseUrl": "/Users/keroxp/Library/Caches",
     "paths": {
-      "deno": ["./deno.d.ts"],
       "https://*": [
-        "../../.deno/deps/https/*"
+        "./deno/deps/https/*"
       ],
       "http://*": [
-        "../../.deno/deps/http/*"
+        "./deno/deps/http/*"
       ]
     }
   }