tests_worksheet_07.R

library(testthat)
library(digest)

test_0.1 <- function(){
test_that('Solution is incorrect', {
    expect_that(exists('answer1'), is_true())
    expect_equal(digest(answer1), '475bf9280aab63a82af60791302736f6') # we hid the answer to the test here so you can't see it, but we can still run the test
    
})
print("Success!")
    }

test_1.0 <- function(){
test_that('Did not create an object named fruit_data', {
    expect_true(exists("fruit_data")) 
})
test_that('fruit_data does not contain the correct number of rows and/or columns.', {
    expect_equal(dim(fruit_data), c(59, 7))
})
test_that('The fruit_name column in fruit_data should be of class factor.', {
    expect_true(is.factor(fruit_data$fruit_name))
})
test_that('Columns in fruit_data contain incorrect values.', {
    expect_equal(digest(as.numeric(sum(fruit_data$mass, na.rm = TRUE))), '351bee4c830e886e0f3a17749569fb33') # we hid the answer to the test here so you can't see it, but we can still run the test  
})
print("Success!")
    }

test_1.1 <- function(){
test_that('Solution is incorrect', {
    expect_that(exists('answer1.1'), is_true())
    expect_equal(digest(answer1.1), '75f1160e72554f4270c809f041c7a776') # we hid the answer to the test here so you can't see it, but we can still run the test
    
})
print("Success!")
    }

test_1.2 <- function(){
test_that('Did not create an object named fruit_dist_2', {
    expect_true(exists("fruit_dist_2")) 
})
test_that('fruit_dist_2 is incorrect.', {
    expect_equal(digest(round(as.numeric(fruit_dist_2), digits = 2)), '4b66dfae2026bef9f4f46d590d07821d')
    })
print("Success!")
    }

test_1.3 <- function(){
test_that('Did not create an object named fruit_dist_44', {
    expect_true(exists("fruit_dist_44")) 
})
test_that('fruit_dist_44 is incorrect.', {
    expect_equal(digest(round(as.numeric(fruit_dist_44),2)), '2b97a3d3feaca3cc5e50cfc6bbd6414f')
    })
print("Success!")
    }

test_1.4 <- function(){
test_that('Solution is incorrect', {
    expect_that(exists('answer1.4'), is_true())
    expect_equal(digest(answer1.4), 'c1f86f7430df7ddb256980ea6a3b57a4') # we hid the answer to the test here so you can't see it, but we can still run the test
})
print("Success!")
    }

test_1.5 <- function(){
test_that('Did not create an object named fruit_data_scaled', {
    expect_true(exists("fruit_data_scaled")) 
})
test_that('fruit_data_scaled does not contain the correct number of rows and/or columns.', {
    expect_equal(dim(fruit_data_scaled), c(59, 11))
})
test_that('The fruit_name column in fruit_data_scaled should be of class factor.', {
    expect_true(is.factor(fruit_data_scaled$fruit_name))
})
test_that('Columns in fruit_data_scaled contain incorrect values.', {
    expect_equal(digest(as.numeric(sum(fruit_data_scaled$mass, na.rm = TRUE))), '351bee4c830e886e0f3a17749569fb33') # we hid the answer to the test here so you can't see it, but we can still run the test  
})
test_that('The mass, height, color score, and width columns in fruit_data should be scaled.', {
    expect_equal(fruit_data_scaled$scaled_mass, scale(fruit_data_scaled$mass, center = TRUE))
    expect_equal(fruit_data_scaled$scaled_color_score, scale(fruit_data_scaled$color_score, center = TRUE))
    expect_equal(fruit_data_scaled$scaled_height, scale(fruit_data_scaled$height, center = TRUE))
    expect_equal(fruit_data_scaled$scaled_width, scale(fruit_data_scaled$width, center = TRUE))
})
print("Success!")
    }

test_1.6 <- function(){
test_that('Did not create an object named distance_44', {
    expect_true(exists("distance_44")) 
})
test_that('Did not create an object named distance_2', {
    expect_true(exists("distance_2")) 
})
test_that('distance_44 should be a distance.', {
    expect_true('dist' %in% class(distance_44))
})
test_that('distance_2 should be a distance.', {
    expect_true('dist' %in% class(distance_2))
})
test_that('distance_44 is incorrect.', {
    expect_equal(digest(distance_44), '8b4aad1050358e59d907ad361c4eb9fb')
})
test_that('distance_2 is incorrect.', {
    expect_equal(digest(distance_2), '5c276c2a08b1d63009a6574aefd55212')
})
print("Success!")
    }

test_2.0 <- function(){
test_that('Did not create an object named training_rows', {
    expect_true(exists("training_rows")) 
})
test_that('training_rows does not contain the correct number of rows and/or columns.', {
    expect_equal(dim(training_rows), c(46, 1))
})
test_that('training_rows should only contain fruit names and should be a matrix', {
    expect_true(is.matrix(training_rows))
})
print("Success!")
    }


test_2.1.0 <- function(){
test_that('Did not create an object named training_set', {
    expect_true(exists("training_set")) 
})
test_that('training_set should contain all the columns in fruit_data and only the rows in training_rows.', {
    expect_equal(dim(training_set), c(46, 7))
})
test_that('Did not create an object named testing_set', {
    expect_true(exists("testing_set")) 
})
test_that('testing_set should contain all the columns in fruit_data and the rows not in training_rows.', {
    expect_equal(dim(testing_set), c(13, 7))
})
print("Success!")
    }


test_2.1.1 <- function(){
test_that('Did not create an object named scale_transformer', {
    expect_true(exists("scale_transformer")) 
})
test_that('Preprocess method should be scale', {
    expect_true("scale" %in% names(scale_transformer$method))
})    
test_that('Did not create an object named training_set', {
    expect_true(exists("training_set")) 
})
test_that('training_set should contain all the columns in fruit_data and only the rows in training_rows.', {
    expect_equal(dim(training_set), c(46, 7))
})
test_that('training_set columns should contain be standardized', {
    expect_equal(digest(round(mean(training_set$mass))),'908d1fd10b357ed0ceaaec823abf81bc')
    expect_equal(digest(sd(training_set$mass)),'6717f2823d3202449301145073ab8719')
    expect_equal(digest(round(sd(training_set$color_score))),'6717f2823d3202449301145073ab8719')
})        
test_that('Did not create an object named testing_set', {
    expect_true(exists("testing_set")) 
})
test_that('testing_set should contain all the columns in fruit_data and the rows not in training_rows.', {
    expect_equal(dim(testing_set), c(13, 7))
})
test_that('testing_set columns should contain be standardized', {
    expect_equal(digest(round(sd(testing_set$mass))),'908d1fd10b357ed0ceaaec823abf81bc')
    expect_equal(digest(as.numeric(round(mean(testing_set$color_score)))),'908d1fd10b357ed0ceaaec823abf81bc')
    expect_equal(digest(as.numeric(round(sd(testing_set$color_score)))),'6717f2823d3202449301145073ab8719')
})    
print("Success!")
    }

test_2.2 <- function(){
test_that('Did not create an object named X_simple', {
    expect_true(exists("X_simple")) 
    })
test_that('X_simple should be a data frame.', {
    expect_true('data.frame' %in% class(X_simple))
    })
test_that('X_simple does not contain the correct number of rows and/or columns.', {
    expect_equal(dim(X_simple), c(46, 2))
    })
test_that('X_simple does not contain the column(s) color_score and/or mass', {
    expect_true('color_score' %in% colnames(X_simple))
    expect_true('mass' %in% colnames(X_simple))
    })
test_that('Did not create an object named Y_fruit', {
    expect_true(exists("Y_fruit")) 
    })
test_that('Y_fruit should be a factor', {
    expect_true('factor' %in% class(Y_fruit))
    })
test_that('Y_fruit is not the correct length.', {
    expect_equal(length(Y_fruit), 46)
    })
print("Success!")
    }



test_2.3 <- function(){
test_that('Did not create an object named ks', {
    expect_true(exists("ks")) 
    })
test_that('ks should be a data frame.', {
    expect_true('data.frame' %in% class(ks))
    })
test_that('ks should contain a vector containing all the odd numbers from 1 to 11.', {
    expect_equal(as.numeric(sum(ks)), 36)
    })
print("Success!")
    }

test_2.4 <- function(){
test_that('Did not create an object named train_control', {
    expect_true(exists("train_control")) 
    })
test_that('method should be cv (for cross-validation)', {
    expect_equal(train_control$method, 'cv')
    })
test_that('train_control should be set up for a 10-fold cross-validation (number should be 10))', {
    expect_equal(train_control$number, 10)
    })
print("Success!")
    }

test_2.5 <- function(){
test_that('Did not create an object named choose_k', {
    expect_true(exists("choose_k")) 
    })
test_that('method should be knn', {
    expect_equal(as.character(choose_k$method), 'knn')
    })
test_that('k should be chosen from ks', {
    expect_equal(as.numeric(sum(choose_k$results$k)), 36)
    })
test_that('choose_k should use 10 fold cross-validation.', {
    expect_equal(choose_k$control$method, 'cv')
    expect_equal(choose_k$control$number, 10)
    })
print("Success!")
    }


test_2.6 <- function(){
    properties <- c(choose_k_plot$layers[[1]]$mapping, choose_k_plot$layers[[2]]$mapping, choose_k_plot$mapping)
    labels <- choose_k_plot$labels
test_that('Did not create a plot named choose_k_plot', {
    expect_true(exists("choose_k_plot")) 
})
test_that('choose_k_plot is not using information from k_accuracies', {
    expect_equal(choose_k_plot$data, k_accuracies) 
})
test_that('k should be on the x-axis.', {
    expect_that("k" == rlang::get_expr(properties$x), is_true())
    })
test_that('Accuracy should be on the y-axis.', {
    expect_that("Accuracy" == rlang::get_expr(properties$y), is_true())
    })
test_that('choose_k_plot should have both a line geometric object and point geometric object.', {
    expect_that('GeomPoint' %in% c(class(rlang::get_expr(choose_k_plot$layers[[1]]$geom)), class(rlang::get_expr(choose_k_plot$layers[[2]]$geom))), is_true())
    expect_that('GeomLine' %in% c(class(rlang::get_expr(choose_k_plot$layers[[1]]$geom)), class(rlang::get_expr(choose_k_plot$layers[[2]]$geom))), is_true())
    })
print("Success!")
    }

test_2.7 <- function(){
test_that('Solution is incorrect', {    
    expect_true(answer2.7 == 3) 
})
print("Success!")
    }

test_2.8 <- function(){
test_that('Solution is incorrect', {    
    expect_true(answer2.8 > 0.9)
    expect_true(answer2.8 < 0.95)
})
print("Success!")
    }

test_3.0 <- function(){
test_that('method should be knn', {
    expect_equal(as.character(simple$method), 'knn')
    })
test_that('k should be 3', {
    expect_equal(as.numeric(simple$results$k), 3)
    })
test_that('simple should not use cross-validation.', {
    expect_equal(simple$control$method, 'boot')
    expect_equal(simple$control$number, 25)
    })
print("Success!")
    }

test_3.1 <- function(){
test_that('training_pred prediction is incorrect.', {
    expect_equal(length(training_pred), 46)
    expect_equal(class(training_pred), 'factor')
    expect_equal(c("apple", "lemon", "mandarin", "orange") %in% levels(training_pred), c(TRUE, TRUE, TRUE, TRUE))
    expect_equal(length(training_pred[training_pred == "apple"]), 15)
    expect_equal(length(training_pred[training_pred == "mandarin"]), 4)
    expect_equal(length(training_pred[training_pred == "orange"]), 14)
    expect_equal(length(training_pred[training_pred == "lemon"]), 13)
})
print("Success!")
    }

test_3.2 <- function(){
test_that('Solution is incorrect', {
    expect_equal(class(training_results), 'confusionMatrix')
    expect_equal(c("apple", "lemon", "mandarin", "orange") %in% colnames(training_results$table), c(TRUE, TRUE, TRUE, TRUE))
    expect_equal(round(training_results$overall[[1]], 2), 0.93)
})
print("Success!")
    }

test_3.3 <- function(){
test_that('Solution is incorrect', {
    expect_true(answer3.3 > 0.92)
    expect_true(answer3.3 < 0.94)
})
print("Success!")
    }



test_4.0 <- function(){
test_that('Did not create an object named X_complex', {
    expect_true(exists("X_complex")) 
    })
test_that('X_complex should be a data frame.', {
    expect_true('data.frame' %in% class(X_complex))
})
test_that('X_complex does not contain the correct columns.', {
    expect_that("height" %in% colnames(X_complex), is_true())
    expect_that("width" %in% colnames(X_complex), is_true())
    expect_that("mass" %in% colnames(X_complex), is_true())
    expect_that("color_score" %in% colnames(X_complex), is_true())
})
test_that('Did not create an object named complex', {
    expect_true(exists("complex")) 
    })
test_that('x in complex should be X_complex', {
    expect_equal(as.character(complex$call$x), 'X_complex')
    })
test_that('method should be knn', {
    expect_equal(as.character(complex$method), 'knn')
    })
test_that('k should be chosen from ks', {
    expect_equal(as.numeric(sum(complex$results$k)), 36)
    })
test_that('complex should use 10 fold cross-validation.', {
    expect_equal(complex$control$method, 'cv')
    expect_equal(complex$control$number, 10)
    })
print("Success!")
    }

test_4.1 <- function(){
test_that('Did not create an object named k_accuracies_again', {
    expect_true(exists("k_accuracies_again")) 
})
test_that('k_accuracies_again contains incorrect information.', {
    expect_equal(k_accuracies_again, complex$results %>% select(k, Accuracy))
})
test_that('Did not create a plot named choose_k_again_plot', {
    expect_true(exists("choose_k_again_plot")) 
})
test_that('choose_k_again_plot is not using information from k_accuracies_again', {
    expect_equal(choose_k_again_plot$data, k_accuracies_again) 
})
test_that('k should be on the x-axis.', {
    expect_that("k" %in% c(rlang::get_expr(choose_k_again_plot$mapping$x),rlang::get_expr(choose_k_again_plot$layers[[1]]$mapping$x)), is_true())
    })
test_that('Accuracy should be on the y-axis.', {
    expect_that("Accuracy" %in% c(rlang::get_expr(choose_k_again_plot$mapping$y), rlang::get_expr(choose_k_again_plot$layers[[1]]$mapping$y)) , is_true())
    })
test_that('choose_k_again_plot should be a scatter plot and a line plot.', {
    expect_that('GeomPoint' %in% c(class(rlang::get_expr(choose_k_again_plot$layers[[1]]$geom)), class(rlang::get_expr(choose_k_again_plot$layers[[2]]$geom))), is_true())
    expect_that('GeomLine' %in% c(class(rlang::get_expr(choose_k_again_plot$layers[[1]]$geom)), class(rlang::get_expr(choose_k_again_plot$layers[[2]]$geom))), is_true())
    })
print("Success!")
    }

test_4.2 <- function(){
test_that('Solution is incorrect', {
    expect_equal(answer4.2, 5)
})
print("Success!")
    }

test_4.3 <- function(){
test_that('Solution is incorrect', {
    expect_true(answer4.3 > 0.97)
    expect_true(answer4.3 < 1)
})
print("Success!")
    }

test_4.4 <- function(){
test_that('Solution is incorrect', {
    expect_equal(digest(answer4.4), '96c24a598c808db5ff9c1aa505c6aa15')
})
print("Success!")
    }


test_5.0 <- function(){
test_that('Did not create an object named final_k', {
    expect_true(exists("final_k")) 
    })
test_that('final_k should be a data frame.', {
    expect_true('data.frame' %in% class(final_k))
})
test_that('Did not create an object named final_classifier', {
    expect_true(exists("final_classifier")) 
    })
test_that('x in the final_classifier should be X_complex', {
    expect_equal(as.character(final_classifier$call$x), 'X_complex')
    })
test_that('method should be knn', {
    expect_equal(as.character(final_classifier$method), 'knn')
})
test_that('k should be 5', {
    expect_equal(as.numeric(sum(final_classifier$results$k)), 5)
})
test_that('final_classifier should not be using cross-validation.', {
    expect_equal(final_classifier$control$method, 'boot')
    expect_equal(final_classifier$control$number, 25)
})
print("Success!")
    }

test_5.1 <- function(){
test_that('Did not create an object named X_test', {
    expect_true(exists("X_test")) 
    })
test_that('X_test should be a data frame.', {
    expect_true('data.frame' %in% class(X_test))
    })
test_that('X_test does not contain the correct number of rows and/or columns.', {
    expect_equal(dim(X_test), c(13, 4))
    })
test_that('X_test does not contain the column(s) mass, width, height, and/or color_score', {
    expect_true('color_score' %in% colnames(X_test))
    expect_true('mass' %in% colnames(X_test))
    expect_true('width' %in% colnames(X_test))
    expect_true('height' %in% colnames(X_test))
    })
test_that('Did not create an object named Y_test', {
    expect_true(exists("Y_test")) 
    })
test_that('Y_fruit should be a factor', {
    expect_true('factor' %in% class(Y_fruit))
    })
test_that('Y_fruit is not the correct length.', {
    expect_equal(length(Y_test), 13)
    })
test_that('test_results should be a confusion matrix.', {
    expect_equal(class(test_results), 'confusionMatrix')
    })
test_that('test_results does not contain correct information.', {
    expect_equal(c("apple", "lemon", "mandarin", "orange") %in% colnames(test_results$table), c(TRUE, TRUE, TRUE, TRUE))
    }) 
test_that('prediction accuracy is not correct', {
    expect_equal(round(test_results$overall[[1]], digits=2), 1.)
    })
print("Success!")
    }

test_5.2 <- function(){
test_that('Solution is incorrect', {
    expect_true(answer5.2 > .95)
    expect_true(answer5.2 < 1.05)
})
print("Success!")
    }