Skip to content

Commit

Permalink
Merge pull request #8 from travistrue2008/ocaml-to-reason
Browse files Browse the repository at this point in the history 
Converted to Reason syntax.
  • Loading branch information
@scull7
scull7 committed May 3, 2018
2 parents b906872 + 3a3316c commit 2347cc3
Show file tree
Hide file tree
Showing 13 changed files with 486 additions and 415 deletions.
99 changes: 52 additions & 47 deletions __tests__/error.re
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,66 +5,71 @@ let connect = () =>

describe("MySql2 Error Handling", () => {
let conn = connect();

afterAll(() => MySql2.close(conn));

let accessDeniedTest = "Should respond with an access denied error";
testAsync(accessDeniedTest, finish => {
let c = MySql2.connect(~password="s0m3 g@rb@g3 pw", ());
let sql = "SELECT 1+1 AS result";
MySql2.execute(c, sql, None, res => {
switch res {
| `Select(_,_) => fail("unexpected_select_result") |> finish
| `Mutation(_,_) => fail("unexpected_mutation_result") |> finish
| `Error(e) => {
Expect.expect(() => raise(e))
testAsync(
accessDeniedTest,
finish => {
let c = MySql2.connect(~password="s0m3 g@rb@g3 pw", ());
let sql = "SELECT 1+1 AS result";
MySql2.execute(c, sql, None, res =>
switch (res) {
| `Select(_, _) => fail("unexpected_select_result") |> finish
| `Mutation(_, _) => fail("unexpected_mutation_result") |> finish
| `Error(e) =>
Expect.expect(() =>
raise(e)
)
|> Expect.toThrowMessage("ER_ACCESS_DENIED_ERROR")
|> finish
}
}
})
});

);
},
);
let syntaxErrorTest = "Should respond with an error on invalid SQL syntax.";
testAsync(syntaxErrorTest, finish => {
let sql = "SELECT invalid, AS result";
MySql2.execute(conn, sql, None, res => {
switch res {
| `Select(_,_) => fail("unexpected_select_result") |> finish
| `Mutation(_,_) => fail("unexpected_mutation_result") |> finish
| `Error(e) => {
Expect.expect(() => raise(e))
testAsync(
syntaxErrorTest,
finish => {
let sql = "SELECT invalid, AS result";
MySql2.execute(conn, sql, None, res =>
switch (res) {
| `Select(_, _) => fail("unexpected_select_result") |> finish
| `Mutation(_, _) => fail("unexpected_mutation_result") |> finish
| `Error(e) =>
Expect.expect(() =>
raise(e)
)
|> Expect.toThrowMessage("ER_PARSE_ERROR")
|> finish
}
}
})
});

);
},
);
let emptyErrorTest = "Should parse out an empty error with defaults";
test(emptyErrorTest, () => {
try (
Js.Exn.raiseError("IDKWTM")
) {
| Js.Exn.Error(e) => {
let exn = MySql2.Error.from_js(e);
Expect.expect(() => raise(exn))
|> Expect.toThrowMessage("99999 (99999) - IDKWTM")
}
test(emptyErrorTest, () =>
try (Js.Exn.raiseError("IDKWTM")) {
| Js.Exn.Error(e) =>
let exn = MySql2.Error.from_js(e);
Expect.expect(() =>
raise(exn)
)
|> Expect.toThrowMessage("99999 (99999) - IDKWTM");
}
});

);
let nonErrorObjectTest = "Should return a defaulted error";
test(nonErrorObjectTest, () => {
test(nonErrorObjectTest, () =>
try (
/* Use raw JS here to throw a garbage exception object */
[%raw {|(function () { throw {} })()|}]
[%raw
/* Use raw JS here to throw a garbage exception object */
{|(function () { throw {} })()|}
]
) {
| Js.Exn.Error(e) => {
let exn = MySql2.Error.from_js(e);
Expect.expect(()=> raise(exn))
|> Expect.toThrowMessage("UNKNOWN - 99999 (99999) - EMPTY_MESSAGE")
}
| Js.Exn.Error(e) =>
let exn = MySql2.Error.from_js(e);
Expect.expect(() =>
raise(exn)
)
|> Expect.toThrowMessage("UNKNOWN - 99999 (99999) - EMPTY_MESSAGE");
}
});
);
});
18 changes: 11 additions & 7 deletions __tests__/parse_response.re
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,25 +2,29 @@ open Jest;

describe("MySql2.parse_response", () => {
test("Should return an error when given an unexpected boolean.", () => {
let invalid = Js.Json.boolean(Js.true_);
let invalid = Js.Json.boolean(true);
let message =
switch (MySql2.parse_response(invalid, [||])) {
| `Select(_,_) => Failure("invalid_select_result")
| `Mutation(_,_) => Failure("invalid_mutation_result")
| `Select(_, _) => Failure("invalid_select_result")
| `Mutation(_, _) => Failure("invalid_mutation_result")
| `Error(e) => e
};
Expect.expect(() => raise(message))
Expect.expect(() =>
raise(message)
)
|> Expect.toThrowMessage("invalid_driver_result");
});
test("Should return an error when given an unexpected string", () => {
let invalid = Js.Json.string("invalid");
let message =
switch (MySql2.parse_response(invalid, [||])) {
| `Select(_,_) => Failure("invalid_select_result")
| `Mutation(_,_) => Failure("invalid_mutation_result")
| `Select(_, _) => Failure("invalid_select_result")
| `Mutation(_, _) => Failure("invalid_mutation_result")
| `Error(e) => e
};
Expect.expect(() => raise(message))
Expect.expect(() =>
raise(message)
)
|> Expect.toThrowMessage("invalid_driver_result");
});
});
140 changes: 86 additions & 54 deletions __tests__/query.re
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,26 +5,26 @@ let connect = () =>

type insert = {
affected_rows: int,
insert_id: option(int)
insert_id: option(int),
};

type thing = {
id: int,
code: string
code: string,
};

let raiseError = (exn) => exn |> raise;
let raiseError = exn => exn |> raise;

let onSelect = (next, fn, res) =>
switch res {
| `Error(e) => raise(e);
switch (res) {
| `Error(e) => raise(e)
| `Mutation(_) => fail("unexpected_mutation_result") |> next
| `Select(rows, meta) => fn(rows, meta, next)
};
};

let onMutation = (next, fn, res) =>
switch res {
| `Error(e) => raise(e);
switch (res) {
| `Error(e) => raise(e)
| `Mutation(count, id) => fn(count, id, next)
| `Select(_, _) => fail("unexpected_select_result") |> next
};
Expand All @@ -33,14 +33,19 @@ describe("Raw SQL Query Test", () => {
let conn = connect();
afterAll(() => MySql2.close(conn));
testAsync("Expect a test database to be listed", finish =>
MySql2.execute(conn, "SHOW DATABASES", None, onSelect(finish, (rows, _, next) =>
rows
|> Js.Array.map(Json.Decode.dict(Json.Decode.string))
|> Js.Array.map(x => Js.Dict.unsafeGet(x, "Database"))
|> Expect.expect
|> Expect.toContain("test")
|> next
))
MySql2.execute(
conn,
"SHOW DATABASES",
None,
onSelect(finish, (rows, _, next) =>
rows
|> Js.Array.map(Json.Decode.dict(Json.Decode.string))
|> Js.Array.map(x => Js.Dict.unsafeGet(x, "Database"))
|> Expect.expect
|> Expect.toContain("test")
|> next
),
)
);
});

Expand All @@ -54,70 +59,97 @@ describe("Raw SQL Query Test Sequence", () => {
)
|};
let drop = next =>
MySql2.execute(conn, "DROP TABLE IF EXISTS `test`.`simple`", None, (res) =>
MySql2.execute(conn, "DROP TABLE IF EXISTS `test`.`simple`", None, res =>
switch (res) {
| `Error(e) => raiseError(e)
| `Mutation(_,_) => next()
| `Select(_,_) => failwith("unexpected_select_result")
| `Mutation(_, _) => next()
| `Select(_, _) => failwith("unexpected_select_result")
}
);
let create = next =>
MySql2.execute(conn, table_sql, None, (res) =>
MySql2.execute(conn, table_sql, None, res =>
switch (res) {
| `Error(e) => raiseError(e)
| `Mutation(_,_) => next()
| `Select(_,_) => failwith("unexpected_select_result")
| `Mutation(_, _) => next()
| `Select(_, _) => failwith("unexpected_select_result")
}
);
beforeAllAsync(finish => drop(() => create(finish)));
afterAll(() => MySql2.close(conn));
testAsync("Expect a mutation result for an INSERT query", finish => {
let sql = "INSERT INTO `test`.`simple` (`code`) VALUES ('foo')";
MySql2.execute(conn, sql, None, onMutation(finish, (count, id, next) => {
let countIsOne = count == 1;
let idIsOne = id == 1;
Expect.expect([|countIsOne, idIsOne|])
|> Expect.toBeSupersetOf([|true, true|])
|> next
}))
MySql2.execute(
conn,
sql,
None,
onMutation(
finish,
(count, id, next) => {
let countIsOne = count == 1;
let idIsOne = id == 1;
Expect.expect([|countIsOne, idIsOne|])
|> Expect.toBeSupersetOf([|true, true|])
|> next;
},
),
);
});
testAsync("Expect a mutation result for an UPDATE query", finish => {
let sql = "UPDATE `test`.`simple` SET `code`='foo2' WHERE code='foo'";
MySql2.execute(conn, sql, None, onMutation(finish, (count, id, next) => {
let countIsOne = count == 1;
let idIsZero = id == 0;
Expect.expect([|countIsOne, idIsZero|])
|> Expect.toBeSupersetOf([|true, true|])
|> next
}))
MySql2.execute(
conn,
sql,
None,
onMutation(
finish,
(count, id, next) => {
let countIsOne = count == 1;
let idIsZero = id == 0;
Expect.expect([|countIsOne, idIsZero|])
|> Expect.toBeSupersetOf([|true, true|])
|> next;
},
),
);
});
testAsync("Expect a SELECT NULL to return an empty array", finish => {
let sql = "SELECT NULL FROM `test`.`simple` WHERE false";
let decoder = Json.Decode.dict(Json.Decode.nullable(Json.Decode.string));
MySql2.execute(conn, sql, None, onSelect(finish, (rows, _, next) => {
Belt_Array.map(rows, decoder)
|> Expect.expect
|> Expect.toHaveLength(0)
|> next
}))
MySql2.execute(
conn,
sql,
None,
onSelect(finish, (rows, _, next) =>
Belt_Array.map(rows, decoder)
|> Expect.expect
|> Expect.toHaveLength(0)
|> next
),
);
});
testAsync("Expect a SELECT * to respond with all the columns", finish =>{
testAsync("Expect a SELECT * to respond with all the columns", finish => {
let sql = "SELECT * FROM `test`.`simple`";
let decoder = json => Json.Decode.({
id: json |> field("id", int),
code: json |> field("code", string)
});
let decoder = json =>
Json.Decode.{
id: json |> field("id", int),
code: json |> field("code", string),
};
let first_row = x => {
let idIsOne = x[0].id == 1;
let codeIsFoo = x[0].code == "foo";
[|idIsOne, codeIsFoo|];
};
MySql2.execute(conn, sql, None, onSelect(finish, (rows, _, next) => {
Belt_Array.map(rows, decoder)
|> first_row
|> Expect.expect
|> Expect.toBeSupersetOf([|true, true|])
|> next
}))
MySql2.execute(
conn,
sql,
None,
onSelect(finish, (rows, _, next) =>
Belt_Array.map(rows, decoder)
|> first_row
|> Expect.expect
|> Expect.toBeSupersetOf([|true, true|])
|> next
),
);
});
});
Loading

0 comments on commit 2347cc3

Please sign in to comment.