Add talent-plant TP-201

Author: shuliang

README.org

@@ -41,3 +41,13 @@ Based on examples from [[https://book.douban.com/subject/30312231/][《深入浅
 |  13.2.1 | [[file:mastering-rust/ch13_web/hyperurl/src/main.rs][hyperurl]]    |
 |  13.2.2 | [[file:mastering-rust/ch13_web/shorten/src/main.rs][shorten]]     |
 |    13.4 | [[file:mastering-rust/ch13_web/linksnap/src/main.rs][linksnap]]    |
+
+* talent-plan
+Rust and distributed systems training courses from [[https://github.com/pingcap/talent-plan][PingCAP talent-plan]].
+** Series 2: Rust Programming
+*** TP 201: Practical Networked Applications in Rust
+- [[file:talent-plan/rust/project-1/src/kv.rs][project-1]]
+- [[file:talent-plan/rust/project-2/src/kv.rs][project-2]]
+- [[file:talent-plan/rust/project-3/src/lib.rs][project-3]]
+- [[file:talent-plan/rust/project-4/src/lib.rs][project-4]]
+- [[file:talent-plan/rust/project-5/src/lib.rs][project-5]]

talent-plan/rust/project-1/Cargo.lock

@@ -0,0 +1,11 @@
+[package]
+name = "kvs"
+version = "0.1.0"
+authors = ["ShuLiang <[email protected]>"]
+description = "A key-value store"
+edition = "2018"
+
+[dependencies]
+assert_cmd = "0.11.0"
+predicates = "1.0.0"
+clap = "2.33.0"

talent-plan/rust/project-1/Cargo.toml

@@ -0,0 +1,46 @@
+#[macro_use]
+extern crate clap;
+
+use std::process::exit;
+
+fn main() {
+    let matches = clap_app!(
+        kvs =>
+            (@setting DisableHelpSubcommand)
+            (@setting SubcommandRequiredElseHelp)
+            (@setting VersionlessSubcommands)
+            (version: env!("CARGO_PKG_VERSION"))
+            (author: env!("CARGO_PKG_AUTHORS"))
+            (about: env!("CARGO_PKG_DESCRIPTION"))
+            (@subcommand set =>
+             (about: "Set the value of a string key to a string")
+             (@arg KEY: +required "A string key")
+             (@arg VALUE: +required "The string value of the key")
+            )
+            (@subcommand get =>
+             (about: "Get the string value of a given string key")
+             (@arg KEY: +required "A string key")
+            )
+            (@subcommand rm =>
+             (about: "Remove a given key")
+             (@arg KEY: +required "A string key")
+            )
+    )
+    .get_matches();
+
+    match matches.subcommand() {
+        ("set", Some(_matches)) => {
+            eprintln!("unimplemented");
+            exit(1);
+        }
+        ("get", Some(_matches)) => {
+            eprintln!("unimplemented");
+            exit(1);
+        }
+        ("rm", Some(_matches)) => {
+            eprintln!("unimplemented");
+            exit(1);
+        }
+        _ => unreachable!(),
+    }
+}

talent-plan/rust/project-1/src/bin/kvs.rs

@@ -0,0 +1,47 @@
+use std::collections::HashMap;
+
+/// The `KvStore` stores string key-value pairs.
+///
+/// Key-value paris are stored in a `HashMap` in memory and not persisited to disk.
+///
+/// Example:
+///
+/// ```rust
+/// # use kvs::KvStore;
+/// let mut store = KvStore::new();
+/// store.set("key".to_owned(), "value".to_owned());
+/// let val = store.get("key".to_owned());
+/// assert_eq!(val, Some("value".to_owned()));
+/// ```
+#[derive(Default)]
+pub struct KvStore {
+    store: HashMap<String, String>,
+}
+
+impl KvStore {
+    /// Create a `KvStore`.
+    pub fn new() -> Self {
+        KvStore {
+            store: HashMap::new(),
+        }
+    }
+
+    /// Sets the value of a string key to a string.
+    ///
+    /// Overwrites previous value if the key already exists.
+    pub fn set(&mut self, key: String, value: String) {
+        self.store.insert(key, value);
+    }
+
+    /// Gets the string value of a given string key.
+    ///
+    /// Returns `None` if the given key does not exist.
+    pub fn get(&mut self, key: String) -> Option<String> {
+        self.store.get(&key).cloned()
+    }
+
+    /// Remove a given key
+    pub fn remove(&mut self, key: String) {
+        self.store.remove(&key);
+    }
+}

talent-plan/rust/project-1/src/kv.rs

@@ -0,0 +1,6 @@
+#![deny(missing_docs)]
+//! A simple key/value store.
+
+pub use kv::KvStore;
+
+mod kv;

talent-plan/rust/project-1/src/lib.rs

@@ -0,0 +1,155 @@
+use assert_cmd::prelude::*;
+use kvs::KvStore;
+use predicates::str::contains;
+use std::process::Command;
+
+// `kvs` with no args should exit with a non-zero code.
+#[test]
+fn cli_no_args() {
+    Command::cargo_bin("kvs").unwrap().assert().failure();
+}
+
+// `kvs -V` should print the version
+#[test]
+fn cli_version() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["-V"])
+        .assert()
+        .stdout(contains(env!("CARGO_PKG_VERSION")));
+}
+
+// `kvs get <KEY>` should print "unimplemented" to stderr and exit with non-zero code
+#[test]
+fn cli_get() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["get", "key1"])
+        .assert()
+        .failure()
+        .stderr(contains("unimplemented"));
+}
+
+// `kvs set <KEY> <VALUE>` should print "unimplemented" to stderr and exit with non-zero code
+#[test]
+fn cli_set() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["set", "key1", "value1"])
+        .assert()
+        .failure()
+        .stderr(contains("unimplemented"));
+}
+
+// `kvs rm <KEY>` should print "unimplemented" to stderr and exit with non-zero code
+#[test]
+fn cli_rm() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["rm", "key1"])
+        .assert()
+        .failure()
+        .stderr(contains("unimplemented"));
+}
+
+#[test]
+fn cli_invalid_get() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["get"])
+        .assert()
+        .failure();
+
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["get", "extra", "field"])
+        .assert()
+        .failure();
+}
+
+#[test]
+fn cli_invalid_set() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["set"])
+        .assert()
+        .failure();
+
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["set", "missing_field"])
+        .assert()
+        .failure();
+
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["set", "extra", "extra", "field"])
+        .assert()
+        .failure();
+}
+
+#[test]
+fn cli_invalid_rm() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["rm"])
+        .assert()
+        .failure();
+
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["rm", "extra", "field"])
+        .assert()
+        .failure();
+}
+
+#[test]
+fn cli_invalid_subcommand() {
+    Command::cargo_bin("kvs")
+        .unwrap()
+        .args(&["unknown", "subcommand"])
+        .assert()
+        .failure();
+}
+
+// Should get previously stored value
+#[test]
+fn get_stored_value() {
+    let mut store = KvStore::new();
+
+    store.set("key1".to_owned(), "value1".to_owned());
+    store.set("key2".to_owned(), "value2".to_owned());
+
+    assert_eq!(store.get("key1".to_owned()), Some("value1".to_owned()));
+    assert_eq!(store.get("key2".to_owned()), Some("value2".to_owned()));
+}
+
+// Should overwrite existent value
+#[test]
+fn overwrite_value() {
+    let mut store = KvStore::new();
+
+    store.set("key1".to_owned(), "value1".to_owned());
+    assert_eq!(store.get("key1".to_owned()), Some("value1".to_owned()));
+
+    store.set("key1".to_owned(), "value2".to_owned());
+    assert_eq!(store.get("key1".to_owned()), Some("value2".to_owned()));
+}
+
+// Should get `None` when getting a non-existent key
+#[test]
+fn get_non_existent_value() {
+    let mut store = KvStore::new();
+
+    store.set("key1".to_owned(), "value1".to_owned());
+    assert_eq!(store.get("key2".to_owned()), None);
+}
+
+#[test]
+fn remove_key() {
+    let mut store = KvStore::new();
+
+    store.set("key1".to_owned(), "value1".to_owned());
+    store.remove("key1".to_owned());
+    assert_eq!(store.get("key1".to_owned()), None);
+}