Still working on getting database to store session key.

This commit is contained in:
Jeff Baskin 2022-07-20 09:31:21 -04:00
parent 620e5593e0
commit ca64717cea
2 changed files with 202 additions and 9 deletions

View File

@ -0,0 +1,50 @@
use std::fmt;
#[derive(Clone, PartialEq)]
pub enum FieldType {
StaticString(StaticString),
}
impl fmt::Display for FieldType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
FieldType::StaticString(data) => write!(f, "{}", data),
}
}
}
#[derive(Clone, PartialEq)]
pub struct StaticString {
data: String,
}
impl StaticString {
pub fn new(data: &str) -> FieldType {
FieldType::StaticString(Self {
data: data.to_string(),
})
}
}
impl fmt::Display for StaticString {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", &self.data)
}
}
#[cfg(test)]
mod staticstrings {
use super::*;
#[test]
fn create_static_string() {
let data = "fred";
let field = StaticString::new(data);
assert!(
field.to_string() == data,
"\n\nGot: {}\nWant: {}\n\n",
field.to_string(),
data
);
}
}

View File

@ -1,3 +1,4 @@
/*
use async_std::sync::{Arc, RwLock}; use async_std::sync::{Arc, RwLock};
use std::{collections::HashMap, error::Error, fmt, str::FromStr}; use std::{collections::HashMap, error::Error, fmt, str::FromStr};
@ -66,7 +67,7 @@ impl Table {
} }
} }
pub async fn add_field(&self, name: &str, ftype: &str) -> Result<(), Box<dyn Error>> { pub async fn update_field(&self, name: &str, ftype: &str) -> Result<(), Box<dyn Error>> {
let ftype = match FieldType::from_str(ftype) { let ftype = match FieldType::from_str(ftype) {
Ok(field) => field, Ok(field) => field,
Err(err) => { Err(err) => {
@ -93,6 +94,13 @@ impl Table {
fmap.clone() fmap.clone()
} }
} }
*/
use async_std::sync::{Arc, RwLock};
use std::collections::HashMap;
mod fieldtype;
use fieldtype::{FieldType, StaticString};
#[derive(Clone)] #[derive(Clone)]
pub struct MoreThanText; pub struct MoreThanText;
@ -102,11 +110,145 @@ impl MoreThanText {
Self {} Self {}
} }
pub async fn add_table(&self, _name: String) -> Table { pub async fn add_table(&self, name: &str) -> Table {
Table::new().await Table::new()
}
pub async fn get_table(&self, name: &str) -> Table {
Table::new()
} }
} }
#[derive(Clone, PartialEq)]
struct FieldDef;
pub struct Table {
fields: Arc<RwLock<HashMap<String, FieldDef>>>,
}
impl Table {
fn new() -> Self {
Self {
fields: Arc::new(RwLock::new(HashMap::new())),
}
}
async fn add_field(&self, name: &str) {
let mut field_defs = self.fields.write().await;
field_defs.insert(name.to_string(), FieldDef {});
}
async fn get_field(&self, name: &str) -> Option<FieldDef> {
let field_defs = self.fields.read().await;
match field_defs.get(name) {
Some(def) => Some(def.clone()),
None => None,
}
}
}
struct Record {
data: Arc<RwLock<HashMap<String, FieldType>>>,
}
impl Record {
fn new() -> Self {
Self {
data: Arc::new(RwLock::new(HashMap::new())),
}
}
async fn update_field(&self, name: String, data: FieldType) {
let mut map = self.data.write().await;
map.insert(name, data);
}
async fn get_field(&self, name: &str) -> Option<FieldType> {
let map = self.data.read().await;
match map.get(name) {
Some(field) => Some(field.clone()),
None => None,
}
}
}
#[cfg(test)]
mod databases {
use super::*;
#[async_std::test]
async fn new_database() {
MoreThanText::new().await;
}
async fn add_table() {
let db = MoreThanText::new().await;
let name = "table";
db.add_table(name).await;
db.get_table(name).await;
}
}
#[cfg(test)]
mod tables {
use super::*;
#[test]
fn new_table() {
Table::new();
}
#[async_std::test]
async fn add_field_definition() {
let tbl = Table::new();
let name = "field";
let expected = FieldDef {};
tbl.add_field(name).await;
let output = tbl.get_field(name).await.unwrap();
assert!(output == expected, "Did not return a field definition.");
}
#[async_std::test]
async fn missing_field_definition() {
let tbl = Table::new();
let output = tbl.get_field("missing").await;
assert!(
output == None,
"Should return None if field does not exist."
);
}
}
#[cfg(test)]
mod records {
use super::*;
#[async_std::test]
async fn update_fields() {
let rec = Record::new();
let name = "elephant";
let data = "Something to remember.";
let sstr = StaticString::new(data);
rec.update_field(name.to_string(), sstr).await;
let output = rec.get_field(name).await.unwrap();
assert!(
output.to_string() == data,
"\n\nGot: {}\nWant: {}\n\n",
output.to_string(),
data
)
}
#[async_std::test]
async fn empty_field() {
let rec = Record::new();
let name = "mull";
let output = rec.get_field(name).await;
assert!(output == None, "Should return an option.");
}
}
/*
#[cfg(test)] #[cfg(test)]
mod tables { mod tables {
use super::*; use super::*;
@ -117,13 +259,13 @@ mod tables {
} }
#[async_std::test] #[async_std::test]
async fn add_field() { async fn update_field() {
let table = Table::new().await; let table = Table::new().await;
let mut expected: HashMap<String, FieldType> = HashMap::new(); let mut expected: HashMap<String, FieldType> = HashMap::new();
expected.insert("stan".to_string(), FieldType::Table); expected.insert("stan".to_string(), FieldType::Table);
expected.insert("lee".to_string(), FieldType::Table); expected.insert("lee".to_string(), FieldType::Table);
table.add_field("stan", "table").await.unwrap(); table.update_field("stan", "table").await.unwrap();
table.add_field("lee", "table").await.unwrap(); table.update_field("lee", "table").await.unwrap();
let output = table.fields().await; let output = table.fields().await;
assert!(output == expected, "Table did not get the fields added."); assert!(output == expected, "Table did not get the fields added.");
} }
@ -135,7 +277,7 @@ mod tables {
let bad_type = "ljksdbtt"; let bad_type = "ljksdbtt";
let expected = format!("failed to add field {}", name); let expected = format!("failed to add field {}", name);
let source = format!("field type {} does not exist", bad_type); let source = format!("field type {} does not exist", bad_type);
match table.add_field(name, bad_type).await { match table.update_field(name, bad_type).await {
Ok(_) => Err("A bad field type should not return successfully".to_string()), Ok(_) => Err("A bad field type should not return successfully".to_string()),
Err(err) => { Err(err) => {
if format!("{}", err) != expected { if format!("{}", err) != expected {
@ -158,8 +300,8 @@ mod tables {
let table = Table::new().await; let table = Table::new().await;
let name = "twice"; let name = "twice";
let expected = format!("field {} already exists", name); let expected = format!("field {} already exists", name);
table.add_field(name, "table").await.unwrap(); table.update_field(name, "table").await.unwrap();
match table.add_field(name, "table").await { match table.update_field(name, "table").await {
Ok(_) => Err(format!("Cannot have two fields with named '{}'", name)), Ok(_) => Err(format!("Cannot have two fields with named '{}'", name)),
Err(err) => { Err(err) => {
if format!("{}", err) == expected { if format!("{}", err) == expected {
@ -237,3 +379,4 @@ mod fieldtypes {
} }
} }
} }
*/