def test_len(self) -> None:
self.assertEqual(len(get_tokens()), 3)
for _ in range(10):
add_token("admin", "asdf")
self.assertEqual(len(get_tokens()), 13)
def test_all(self) -> None:
add_token("server", "desc")
for i in range(10):
add_server("ip", i, "ssh-rsa data comment", 1)
servers = get_servers()
self.assertEqual(len(servers), 10)
def test_invalid_id(self) -> None:
with self.assertRaises(TokenError):
delete_token(0)
add_token("admin", "desc")
with self.assertRaises(TokenError):
delete_token(0)
def test_strip_key(self) -> None:
add_token("server", "desc")
add_server("ip", 1234, " ssh-rsa data comment \n\n\n", 1)
servers = get_servers()
self.assertEqual(servers[0].key_type, "ssh-rsa")
self.assertEqual(servers[0].key_data, "data")
self.assertEqual(servers[0].key_comment, "comment")
def test_invalid_token(self) -> None:
first = add_token("admin", "desc1")
second = add_token("server", "desc2")
add_token("none", "desc3")
invalid = first[:int(len(first) / 2)] + second[int(len(second) / 2):]
self.assertFalse(verify_token(invalid))
self.assertEqual(g.get("token"), None)
def test_ip(self) -> None:
add_token("server", "desc")
add_server("ip1", 1111, "ssh-rsa data comment", 1)
add_server("ip2", 2222, "ssh-ed25519 data comment", 1)
servers = get_servers(ip="ip1")
self.assertEqual(len(servers), 1)
self.assertEqual(servers[0].ip, "ip1")
def test_sha256(self, mock: MagicMock) -> None:
data = b"abcd"
sha256sum = sha256(data)
mock.return_value = data
add_token("admin", "")
tokens = Token.query.filter_by(token=sha256sum).all()
self.assertEqual(len(tokens), 1)
def test_success(self) -> None:
add_token("server", "desc")
add_server("ip", 1234, "ssh-rsa data comment", 1)
servers = get_servers()
self.assertEqual(len(servers), 1)
self.assertEqual(servers[0].ip, "ip")
self.assertEqual(servers[0].port, 1234)
self.assertEqual(servers[0].key_type, "ssh-rsa")
self.assertEqual(servers[0].key_data, "data")
self.assertEqual(servers[0].key_comment, "comment")
self.assertEqual(servers[0].token_id, 1)
def test_invalid_id(self) -> None:
with self.assertRaises(ServerError):
delete_server(0)
add_token("admin", "desc")
add_server("10.0.0.1", 1234, "ssh-rsa data", 1)
add_server("10.0.0.2", 4321, "ssh-rsa data", 1)
with self.assertRaises(ServerError):
delete_server(0)
self.assertEqual(len(get_servers()), 2)
def test_success(self) -> None:
add_token("admin", "desc0")
add_server("10.0.0.1", 11, "ssh-rsa data", 1)
add_server("10.0.0.2", 22, "ecdsa-sha2-nistp521 data", 1)
add_server("10.0.0.3", 33, "ssh-ed25519 data", 1)
self.assertEqual(len(get_servers()), 3)
delete_server(2)
servers = get_servers()
self.assertEqual(len(servers), 2)
self.assertEqual(servers[0].ip, "10.0.0.1")
self.assertEqual(servers[1].ip, "10.0.0.3")
def test_no_filter(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc1")),
}
add_server(ip="1", port=1, public_key="ssh-rsa ...", token_id=1)
add_server(ip="2", port=2, public_key="ssh-ed25519 ...", token_id=1)
res = self.client.get("/api/v1/server", headers=headers)
data = json.loads(res.data.decode("utf-8"))
servers = data["servers"]
self.assertEqual(len(servers), 2)
self.assertEqual(servers[0]["id"], 1)
self.assertEqual(servers[0]["ip"], "1")
self.assertEqual(servers[0]["port"], 1)
self.assertEqual(servers[0]["key_type"], "ssh-rsa")
self.assertEqual(servers[0]["key_data"], "...")
self.assertEqual(servers[0]["key_comment"], "")
self.assertEqual(servers[1]["id"], 2)
self.assertEqual(servers[1]["ip"], "2")
self.assertEqual(servers[1]["port"], 2)
self.assertEqual(servers[1]["key_type"], "ssh-ed25519")
self.assertEqual(servers[1]["key_data"], "...")
self.assertEqual(servers[1]["key_comment"], "")
def test_missing_public_key(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("server", "desc")),
}
res = self.client.post("/api/v1/server", headers=headers)
obj = json.loads(res.data.decode("utf-8"))
self.assertTrue("public_key" in obj["message"].keys())
self.assertEqual(res.status_code, 400)
def test_unauthorized(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("server", "desc")),
}
res = self.client.post("/api/v1/token", headers=headers)
data = json.loads(res.data.decode("utf-8"))
self.assertEqual(data["message"], "Permission denied")
self.assertEqual(res.status_code, 401)
def test_success(self) -> None:
add_token("server", "desc")
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
data = {"id": 1}
res = self.client.delete("/api/v1/token", headers=headers, data=data)
data = json.loads(res.data.decode("utf-8"))
self.assertEqual(data["message"], "deleted")
self.assertEqual(res.status_code, 200)
res = self.client.get("/api/v1/token", headers=headers)
tokens = json.loads(res.data.decode("utf-8"))["tokens"]
self.assertEqual(len(tokens), 1)
def test_missing_role(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
res = self.client.post("/api/v1/token", headers=headers)
data = json.loads(res.data.decode("utf-8"))
self.assertIsInstance(data["message"]["role"], str)
self.assertEqual(res.status_code, 400)
def test_missing_id(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
res = self.client.delete("/api/v1/token", headers=headers)
data = json.loads(res.data.decode("utf-8"))
self.assertTrue("Missing required parameter" in data["message"]["id"])
self.assertEqual(res.status_code, 400)
def test_invalid_id(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
data = {"id": 2}
res = self.client.delete("/api/v1/token", headers=headers, data=data)
data = json.loads(res.data.decode("utf-8"))
self.assertEqual(data["message"], "invalid token id 2")
self.assertEqual(res.status_code, 400)
def test_invalid_role(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
data = {"role": "x"}
res = self.client.post("/api/v1/token", headers=headers, data=data)
data = json.loads(res.data.decode("utf-8"))
self.assertEqual(data["message"], "x is not a valid role")
self.assertEqual(res.status_code, 400)
def test_success(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
data = {"role": "server"}
res = self.client.post("/api/v1/token", headers=headers, data=data)
data = json.loads(res.data.decode("utf-8"))
self.assertIsInstance(data.get("token"), str)
self.assertEqual(res.status_code, 200)
def test_wildcard(self) -> None:
add_token("admin", "desc1")
add_token("server", "desc2")
add_token("none", "desc3")
self.assertFalse(verify_token("*"))
self.assertEqual(g.get("token"), None)
def test_invalid_public_key(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("server", "desc")),
}
data = {
"public_key": "",
}
res = self.client.post("/api/v1/server", headers=headers, data=data)
obj = json.loads(res.data.decode("utf-8"))
self.assertEqual(obj["message"], "invalid public key")
self.assertEqual(res.status_code, 400)
def test_success(self) -> None:
add_token("server", "desc")
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
data = {
"id": 1,
}
add_server("10.0.0.1", 11, "ssh-rsa data", 1)
add_server("10.0.0.2", 22, "ssh-rsa data", 1)
add_server("10.0.0.2", 33, "ssh-rsa data", 1)
res = self.client.delete("/api/v1/server", headers=headers, data=data)
data = json.loads(res.data.decode("utf-8"))
self.assertEqual(data["message"], "deleted")
self.assertEqual(res.status_code, 200)
res = self.client.get("/api/v1/server", headers=headers)
servers = json.loads(res.data.decode("utf-8"))["servers"]
self.assertEqual(len(servers), 2)
def setUp(self) -> None:
super().setUp()
self.admin0 = add_token("admin", "admin1 desc")
self.admin1 = add_token("admin", "admin1 desc")
self.server0 = add_token("server", "server1 desc")
self.server1 = add_token("server", "server2 desc")
self.none0 = add_token("none", "none1 desc")
self.none1 = add_token("none", "none2 desc")
def test_unauthorized_server(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("server", "desc")),
}
data = {
"id": 1,
}
add_server("10.0.0.1", 11, "ssh-rsa data", 1)
res = self.client.delete("/api/v1/server", headers=headers, data=data)
data = json.loads(res.data.decode("utf-8"))
self.assertEqual(data["message"], "Permission denied")
self.assertEqual(res.status_code, 401)
def test_success(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc1")),
}
add_token("server", "desc2")
add_token("admin", "desc3")
res = self.client.get("/api/v1/token", headers=headers)
data = json.loads(res.data.decode("utf-8"))
tokens = data["tokens"]
self.assertEqual(len(tokens), 3)
self.assertEqual(tokens[0]["id"], 1)
self.assertEqual(tokens[0]["role"], "admin")
self.assertEqual(tokens[0]["description"], "desc1")
self.assertEqual(tokens[1]["id"], 2)
self.assertEqual(tokens[1]["role"], "server")
self.assertEqual(tokens[1]["description"], "desc2")
self.assertEqual(tokens[2]["id"], 3)
self.assertEqual(tokens[2]["role"], "admin")
self.assertEqual(tokens[2]["description"], "desc3")
def test_success(self) -> None:
add_token("admin", "desc0")
add_token("server", "desc1")
add_token("none", "desc2")
delete_token(2)
tokens = get_tokens()
self.assertEqual(len(tokens), 2)
self.assertEqual(tokens[0].role, "admin")
self.assertEqual(tokens[1].role, "none")
def test_success_admin(self) -> None:
headers = {
"Authorization": "Bearer {}".format(add_token("admin", "desc")),
}
data = {
"public_key": "ecdsa-sha2-nistp384 data1234 comment321",
}
res = self.client.post("/api/v1/server", headers=headers, data=data)
obj = json.loads(res.data.decode("utf-8"))
self.assertEqual(obj["message"], "added")
self.assertEqual(res.status_code, 200)
servers = get_servers()
self.assertEqual(len(servers), 1)
self.assertEqual(servers[0].key_type, "ecdsa-sha2-nistp384")
self.assertEqual(servers[0].key_data, "data1234")
self.assertEqual(servers[0].key_comment, "comment321")
def test_invalid_role(self) -> None:
with self.assertRaises(TokenError):
add_token("abcd", "")
def test_success_none(self) -> None:
add_token("admin", "admin1 desc")
add_token("admin", "admin2 desc")
add_token("server", "server1 desc")
add_token("server", "server2 desc")
token = add_token("none", "none1 desc")
add_token("none", "none2 desc")
self.assertTrue(verify_token(token))
self.assertEqual(g.token.id, 5)
self.assertEqual(g.token.role, "none")
self.assertEqual(g.token.description, "none1 desc")
def setUp(self) -> None:
super().setUp()
self.first = add_token("admin", "desc1")
self.second = add_token("server", "desc2")
self.third = add_token("none", "desc3")
