Error Handling of public Set functions (#88)

What are we trying to achieve ?

++ Currently all the major public set functions is panic prone and does not handle and return error. This PR tries to address to all those functions.

What major errors that could happen in these functions ?

++ All the functions which are being made as error safe is being tested against invalid sheet, row and column values, which could given by user

What are the list of functions whose return type has been altered ?

**base/src/model.rs**
1. update_cell_with_text
2. update_cell_with_bool
3. update_cell_with_number
4. set_user_input
5. get_cell_style_index
6. get_style_for_cell
7. set_cell_with_string

++> New functions being added

1. set_cell_with_boolean
2. set_cell_with_number

**base/src/styles.rs**

1. get_style_with_quote_prefix
3. get_style_with_format
4. get_style_without_quote_prefix
5. get_style

**base/src/worksheet.rs**

1. update_cell
2. set_cell_style
3. set_cell_with_formula
4. set_cell_with_number
6. set_cell_with_string
8. set_cell_with_boolean
9. set_cell_with_error
10. cell_clear_contents
11. cell_clear_contents_with_style

++> Above is the comprehensive list of all functions being ( most are public, some are private ) altered for better error handling. As a side effect of changing function signature, there are many changes being done to other functions ( mostly adding "?" to enable to error propagation further )

base/src/test/test_set_functions_error_handling.rs

@@ -0,0 +1,449 @@
+use crate::{expressions::token, test::util::new_empty_model, types::Cell};
+
+#[test]
+fn test_update_cell_with_text() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.set_user_input(0, 1, 1, "Hello".to_string()).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_text(1, 1, 1, "new value");
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_text(0, 0, 1, "new value");
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_text(0, 1, 1048579, "new value");
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_number() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_number(1, 1, 1, 20.0);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_number(0, 0, 1, 20.0);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_number(0, 1, 1048579, 20.0);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_bool() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_bool(0, 1, 1, true).unwrap();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_bool(1, 1, 1, false);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_bool(0, 0, 1, false);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_bool(0, 1, 1048579, false);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_update_cell_with_formula() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model
+        .update_cell_with_formula(0, 1, 2, "=A1*2".to_string())
+        .unwrap();
+
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.update_cell_with_formula(1, 1, 2, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.update_cell_with_formula(0, 0, 2, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.update_cell_with_formula(0, 1, 1048579, "=A1*2".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_set_user_input() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.set_user_input(1, 1, 2, "20.0".to_string());
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // Case2 : Invalid Row
+    let update_result = model.set_user_input(0, 0, 2, "20.0".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Invalid Column
+    let update_result = model.set_user_input(0, 1, 1048579, "20.0".to_string());
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_get_style_for_cell() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.get_style_for_cell(1, 1, 2);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // ATTENTION : get_cell_style_index tries to get cell using row and col
+    // if we invalid row or column is given, it will return index 0.
+
+    // Case2 : Invalid Row
+    let update_result = model.get_style_for_cell(0, 0, 2);
+    assert_eq!(update_result.is_ok(), true);
+
+    // Case3 : Invalid Column
+    let update_result = model.get_style_for_cell(0, 1, 1048579);
+    assert_eq!(update_result.is_ok(), true);
+}
+
+#[test]
+fn test_get_cell_style_index() {
+    let mut model = new_empty_model();
+
+    // Below are safe inputs
+    model.update_cell_with_number(0, 1, 1, 10.0).unwrap();
+    model.evaluate();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid sheet
+    let update_result = model.get_cell_style_index(1, 1, 2);
+    assert_eq!(update_result, Err("Invalid sheet index".to_string()));
+
+    // ATTENTION : get_cell_style_index tries to get cell using row and col
+    // if we invalid row or column is given, it will return index 0.
+
+    // Case2 : Invalid Row
+    let update_result = model.get_cell_style_index(0, 0, 2);
+    assert_eq!(update_result, Ok(0));
+
+    // Case3 : Invalid Column
+    let update_result = model.get_cell_style_index(0, 1, 1048579);
+    assert_eq!(update_result, Ok(0));
+}
+
+#[test]
+fn test_worksheet_update_cell() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result =
+        model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .update_cell(0, 1, Cell::new_number(10.0, 1));
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result =
+        model
+            .workbook
+            .worksheet_mut(0)
+            .unwrap()
+            .update_cell(1, 1048579, Cell::new_number(10.0, 1));
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_style() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_style(0, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_style(1, 1048579, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_formula() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_formula(0, 1, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_formula(1, 1048579, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_number() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_number(0, 1, 1.0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_number(1, 1048579, 1.0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_string() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_string(0, 1, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_string(1, 1048579, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_boolean() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_boolean(0, 1, true, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_boolean(1, 1048579, true, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_set_cell_with_error() {
+    let mut model = new_empty_model();
+
+    // Now testing all the possible error scenarios
+
+    // Case1: Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_error(0, 1, token::Error::ERROR, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .set_cell_with_error(1, 1048579, token::Error::ERROR, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+}
+
+#[test]
+fn test_worksheet_cell_clear_contents() {
+    let mut model = new_empty_model();
+
+    model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .update_cell(1, 1, Cell::new_number(10.0, 1))
+        .unwrap();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(0, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(1, 1048579);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Valid case
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents(1, 1);
+    assert_eq!(update_result, Ok(()))
+}
+
+#[test]
+fn test_worksheet_cell_clear_contents_with_style() {
+    let mut model = new_empty_model();
+
+    model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .update_cell(1, 1, Cell::new_number(10.0, 1))
+        .unwrap();
+    // Now testing all the possible error scenarios
+
+    // Case1 : Invalid Row
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(0, 1, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case2 : Invalid Column
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(1, 1048579, 1);
+    assert_eq!(update_result, Err("Incorrect row or column".to_string()));
+
+    // Case3 : Valid case
+    let update_result = model
+        .workbook
+        .worksheet_mut(0)
+        .unwrap()
+        .cell_clear_contents_with_style(1, 1, 1);
+    assert_eq!(update_result, Ok(()))
+}
+
+#[test]
+fn workbook_styles_get_style_error_handling() {
+    let model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style(15),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_without_quote_prefix_error_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style_without_quote_prefix(15),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_with_format_error_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model
+            .workbook
+            .styles
+            .get_style_with_format(15, "dummy_num_format"),
+        Err("Invalid index provided".to_string())
+    );
+}
+
+#[test]
+fn workbook_styles_get_style_with_quote_prefix_handling() {
+    let mut model = new_empty_model();
+
+    // case 1 : Invalid index
+    assert_eq!(
+        model.workbook.styles.get_style_with_quote_prefix(15),
+        Err("Invalid index provided".to_string())
+    );
+}