Rust rocket removed tests

frameworks/Rust/rocket/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "rocket_benchmark"
+name = "rocket_techempower"
 version = "0.2.0"
 authors = ["Marcelo Barbosa <[email protected]>", "Brendan Hansknecht <[email protected]>", "Dragos Varovici <[email protected]>"]
 edition = "2018"

frameworks/Rust/rocket/rocket.dockerfile

@@ -6,13 +6,11 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
     libpq-dev \
 && rm -rf /var/lib/apt/lists/*
 
-RUN rustup toolchain install nightly-2021-09-15 -t x86_64-unknown-linux-gnu --no-self-update --profile minimal
-
 ADD ./ /rocket
 WORKDIR /rocket
 
-RUN RUSTFLAGS="-C target-cpu=native" cargo +nightly-2021-09-15 build --release
+RUN RUSTFLAGS="-C target-cpu=native" cargo build --release
 
 EXPOSE 8000
 
-CMD ./target/release/rocket_benchmark
+CMD ./target/release/rocket_techempower

frameworks/Rust/rocket/src/database.rs

@@ -2,10 +2,4 @@ use rocket_db_pools::{sqlx, Database};
 
 #[derive(Database)]
 #[database("hello_world")]
-#[cfg(not(test))]
-pub struct HelloWorld(sqlx::PgPool);
-
-#[derive(Database)]
-#[database("hello_world")]
-#[cfg(test)]
-pub struct HelloWorld(sqlx::SqlitePool);
+pub struct HelloWorld(sqlx::PgPool);

frameworks/Rust/rocket/src/main.rs

@@ -1,4 +1,3 @@
-#![feature(proc_macro_hygiene, decl_macro)]
 #[macro_use]
 extern crate lazy_static;
 #[macro_use]
@@ -9,7 +8,6 @@ extern crate dotenv;
 mod models;
 mod random;
 mod database;
-mod request;
 
 use dotenv::dotenv;
 use std::net::{IpAddr, Ipv4Addr};
@@ -26,7 +24,6 @@ use figment::Figment;
 use models::{World, Fortune, Message};
 use database::HelloWorld;
 use random::random_number;
-use request::RequestId;
 
 #[get("/plaintext")]
 async fn plaintext() -> &'static str {
@@ -42,8 +39,8 @@ async fn json() -> Json<models::Message> {
 }
 
 #[get("/db")]
-async fn db(mut db: Connection<HelloWorld>, id: RequestId) -> Json<World> {
-    let number = random_number(&id);
+async fn db(mut db: Connection<HelloWorld>) -> Json<World> {
+    let number = random_number();
 
     let result : World = sqlx::query_as("SELECT id, randomnumber FROM World WHERE id = $1").bind(number)
         .fetch_one(&mut *db).await.ok().expect("error loading world");
@@ -52,12 +49,12 @@ async fn db(mut db: Connection<HelloWorld>, id: RequestId) -> Json<World> {
 }
 
 #[get("/queries")]
-async fn queries_empty(db: Connection<HelloWorld>, id: RequestId) -> Json<Vec<World>> {
-    queries(db, id,1).await
+async fn queries_empty(db: Connection<HelloWorld>) -> Json<Vec<World>> {
+    queries(db,1).await
 }
 
 #[get("/queries?<q>")]
-async fn queries(mut db: Connection<HelloWorld>, id: RequestId, q: u16) -> Json<Vec<World>> {
+async fn queries(mut db: Connection<HelloWorld>, q: u16) -> Json<Vec<World>> {
     let q = if q == 0 {
         1
     } else if q > 500 {
@@ -69,7 +66,7 @@ async fn queries(mut db: Connection<HelloWorld>, id: RequestId, q: u16) -> Json<
     let mut results = Vec::with_capacity(q as usize);
 
     for _ in 0..q {
-        let query_id = random_number(&id);
+        let query_id = random_number();
 
         let result :World = sqlx::query_as("SELECT * FROM World WHERE id = $1").bind(query_id)
             .fetch_one(&mut *db).await.ok().expect("error loading world");
@@ -108,12 +105,12 @@ async fn fortunes(mut db: Connection<HelloWorld>) -> RawHtml<String> {
 }
 
 #[get("/updates")]
-async fn updates_empty(db: Connection<HelloWorld>, id: RequestId) -> Json<Vec<World>> {
-    updates(db, id,1).await
+async fn updates_empty(db: Connection<HelloWorld>) -> Json<Vec<World>> {
+    updates(db,1).await
 }
 
 #[get("/updates?<q>")]
-async fn updates(mut db: Connection<HelloWorld>, id: RequestId, q: u16) -> Json<Vec<World>> {
+async fn updates(mut db: Connection<HelloWorld>, q: u16) -> Json<Vec<World>> {
     let q = if q == 0 {
         1
     } else if q > 500 {
@@ -125,11 +122,11 @@ async fn updates(mut db: Connection<HelloWorld>, id: RequestId, q: u16) -> Json<
     let mut results = Vec::with_capacity(q as usize);
 
     for _ in 0..q {
-        let query_id = random_number(&id);
+        let query_id = random_number();
         let mut result :World = sqlx::query_as("SELECT * FROM World WHERE id = $1").bind(query_id)
             .fetch_one(&mut *db).await.ok().expect("World was not found");
 
-        result.random_number = random_number(&id);
+        result.random_number = random_number();
         results.push(result);
     }
 
@@ -192,104 +189,3 @@ pub fn launch() -> Rocket<Build> {
         .attach(HelloWorld::init())
 }
 
-#[cfg(test)]
-mod tests
-{
-    use std::env;
-    use rocket::{Rocket, Build};
-    use rocket::{local::blocking::Client};
-    use crate::database::HelloWorld;
-    use rocket::fairing::{self, AdHoc};
-    use rocket_db_pools::Database;
-
-    #[test]
-    fn plaintext() {
-        let client = create_client();
-
-        let response = client.get("/plaintext").dispatch();
-        assert_eq!(response.into_string().unwrap(), "Hello, World!");
-    }
-
-    #[test]
-    fn json() {
-        let client = create_client();
-
-        let response = client.get("/json").dispatch();
-        assert_eq!(response.into_string().unwrap(), "{\"message\":\"Hello, World!\"}");
-    }
-
-    #[test]
-    fn db() {
-        let client = create_client();
-
-        let response = client.get("/db").dispatch();
-        assert_eq!(response.into_string().unwrap(), "{\"id\":1,\"randomNumber\":101}");
-    }
-
-    #[test]
-    fn queries_empty() {
-        let client = create_client();
-
-        let response = client.get("/queries").dispatch();
-        assert_eq!(response.into_string().unwrap(), "[{\"id\":1,\"randomNumber\":101}]");
-    }
-
-    #[test]
-    fn queries_non_empty() {
-        let client = create_client();
-
-        let response = client.get("/queries?q=3").dispatch();
-        assert_eq!(response.into_string().unwrap(), "[{\"id\":1,\"randomNumber\":101},{\"id\":2,\"randomNumber\":102},{\"id\":3,\"randomNumber\":103}]");
-    }
-
-    #[test]
-    fn fortunes() {
-        let client = create_client();
-
-        let response = client.get("/fortunes").dispatch();
-        assert_eq!(response.into_string().unwrap(), "<!DOCTYPE html><html><head><title>Fortunes</title></head><body><table><tr><th>id</th><th>message</th></tr><tr><td>11</td><td>&lt;script&gt;alert(&quot;This should not be displayed in a browser alert box.&quot;);&lt;&#x2f;script&gt;</td></tr><tr><td>4</td><td>A bad random number generator: 1, 1, 1, 1, 1, 4.33e+67, 1, 1, 1</td></tr><tr><td>5</td><td>A computer program does what you tell it to do, not what you want it to do.</td></tr><tr><td>2</td><td>A computer scientist is someone who fixes things that aren&#x27;t broken.</td></tr><tr><td>8</td><td>A list is only as strong as its weakest link. — Donald Knuth</td></tr><tr><td>0</td><td>Additional fortune added at request time.</td></tr><tr><td>3</td><td>After enough decimal places, nobody gives a damn.</td></tr><tr><td>7</td><td>Any program that runs right is obsolete.</td></tr><tr><td>10</td><td>Computers make very fast, very accurate mistakes.</td></tr><tr><td>6</td><td>Emacs is a nice operating system, but I prefer UNIX. — Tom Christaensen</td></tr><tr><td>9</td><td>Feature: A bug with seniority.</td></tr><tr><td>1</td><td>fortune: No such file or directory</td></tr><tr><td>12</td><td>フレームワークのベンチマーク</td></tr></table></body></html>");
-    }
-
-    #[test]
-    fn updates_empty() {
-        let client = create_client();
-
-        let response = client.get("/updates").dispatch();
-        assert_eq!(response.into_string().unwrap(), "[{\"id\":1,\"randomNumber\":2}]");
-    }
-
-    #[test]
-    fn updates_non_empty() {
-        let client = create_client();
-
-        let response = client.get("/updates?q=3").dispatch();
-        assert_eq!(response.into_string().unwrap(), "[{\"id\":1,\"randomNumber\":2},{\"id\":3,\"randomNumber\":4},{\"id\":5,\"randomNumber\":6}]");
-    }
-
-    fn create_client() -> Client {
-        env::set_var("ROCKET_BENCHMARK_DATABASE_URL", "sqlite::memory:");
-
-        let rocket = create_rocket();
-        let client = Client::debug(rocket).unwrap();
-        client
-    }
-
-    fn create_rocket() -> Rocket<Build> {
-        super::launch().attach(AdHoc::try_on_ignite("SQLx Migrations", run_migrations))
-    }
-
-    async fn run_migrations(rocket: Rocket<Build>) -> fairing::Result {
-        match HelloWorld::fetch(&rocket) {
-            Some(db) => match sqlx::migrate!("db/migrations").run(&**db).await {
-                Ok(_) => Ok(rocket),
-                Err(e) => {
-                    error!("Failed to initialize HelloWorld database: {}", e);
-                    Err(rocket)
-                }
-            }
-            None => Err(rocket),
-        }
-    }
-}
-
-

frameworks/Rust/rocket/src/random.rs

@@ -1,53 +1,27 @@
 extern crate lazy_static;
 extern crate rand;
 
-#[cfg(test)]
-use std::collections::HashMap;
-use crate::request::RequestId;
-#[cfg(not(test))]
 use rand::seq::SliceRandom;
-#[cfg(not(test))]
 use rand::thread_rng;
 use std::sync::Mutex;
-#[cfg(test)]
-use std::sync::atomic::{AtomicI32, Ordering};
 
-#[cfg(not(test))]
 lazy_static! {
     static ref RANDOM_ARRAY: Mutex<RandomArray> = Mutex::new(RandomArray::new(10000));
 }
 
-#[cfg(test)]
-lazy_static! {
-    static ref COUNTER_MAP: Mutex<HashMap<RequestId, AtomicI32>> = Mutex::new(HashMap::new());
-}
-
-#[cfg(not(test))]
-pub fn random_number(_request_id: &RequestId) -> i32 {
+pub fn random_number() -> i32 {
     RANDOM_ARRAY
         .lock()
         .expect("Failed to lock RANDOM_ARRAY")
         .next()
 }
 
-#[cfg(test)]
-pub fn random_number(request_id: &RequestId) -> i32 {
-    if !COUNTER_MAP.lock().expect("Failed to lock COUNTER_MAP").contains_key(&request_id) {
-        COUNTER_MAP.lock().expect("Failed to lock COUNTER_MAP").insert(*request_id, AtomicI32::new(1));
-    }
-
-    COUNTER_MAP.lock().expect("Failed to lock COUNTER_MAP").get_key_value(request_id).expect("Could not get RequestId")
-        .1.fetch_add(1, Ordering::Relaxed)
-}
-
-#[cfg(not(test))]
 struct RandomArray {
     pointer: usize,
     size: i32,
     data: Vec<i32>,
 }
 
-#[cfg(not(test))]
 impl RandomArray {
     fn new(size: i32) -> Self {
         let mut data: Vec<i32> = (1..=size).collect();

frameworks/Rust/rocket/src/request.rs

@@ -1,24 +0,0 @@
-use rocket::request::{self, Request, FromRequest, Outcome};
-use std::sync::atomic::{AtomicI32, Ordering};
-
-/// A global atomic counter for generating IDs.
-static ID_COUNTER: AtomicI32 = AtomicI32::new(0);
-
-/// A type that represents a request's ID.
-#[derive(Hash, Eq, PartialEq, Copy, Clone)]
-pub struct RequestId(pub i32);
-
-/// Returns the current request's ID, assigning one only as necessary.
-#[rocket::async_trait]
-impl<'r> FromRequest<'r> for RequestId {
-    type Error = ();
-
-    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
-        // The closure passed to `local_cache` will be executed at most once per
-             // request: the first time the `RequestId` guard is used. If it is
-             // requested again, `local_cache` will return the same value.
-             request::Outcome::Success(*request.local_cache(|| {
-                 RequestId(ID_COUNTER.fetch_add(1, Ordering::Relaxed))
-             }))
-    }
-}