Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Добавление функциональности с помощью разработки через тестирование

Теперь, когда у нас есть логика поиска в src/lib.rs отдельно от функции main, писать тесты для основной функциональности нашего кода гораздо проще. Мы можем вызывать функции напрямую с различными аргументами и проверять возвращаемые значения, не вызывая наш бинарный файл из командной строки.

В этом разделе мы добавим логику поиска в программу minigrep, используя процесс разработки через тестирование (TDD) со следующими шагами:

  1. Напишите тест, который терпит неудачу, и запустите его, чтобы убедиться, что он терпит неудачу по той причине, которую вы ожидаете.
  2. Напишите или измените ровно столько кода, сколько нужно, чтобы новый тест прошёл.
  3. Проведите рефакторинг только что добавленного или изменённого кода и убедитесь, что тесты продолжают проходить.
  4. Повторите с шага 1!

Хотя это лишь один из многих способов написания программного обеспечения, TDD может помочь управлять дизайном кода. Написание теста перед написанием кода, который заставляет тест пройти, помогает поддерживать высокое покрытие тестами на протяжении всего процесса.

Мы будем разрабатывать через тестирование реализацию функциональности, которая фактически выполнит поиск строки запроса в содержимом файла и создаст список строк, соответствующих запросу. Мы добавим эту функциональность в функцию с именем search.

Написание терпящего неудачу теста

В src/lib.rs мы добавим модуль tests с тестовой функцией, как мы делали в главе 11. Тестовая функция определяет поведение, которое мы хотим, чтобы имела функция search: она будет принимать запрос и текст для поиска, и она будет возвращать только те строки из текста, которые содержат запрос. Листинг 12-15 показывает этот тест.

Имя файла: src/lib.rs
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    unimplemented!();
}

// --snip--

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn one_result() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";

        assert_eq!(vec!["safe, fast, productive."], search(query, contents));
    }
}
Листинг 12-15: Создание терпящего неудачу теста для функции search на функциональность, которую мы хотели бы иметь

Этот тест ищет строку "duct". Текст, который мы ищем, состоит из трёх строк, только одна из которых содержит "duct" (обратите внимание, что обратная косая черта после открывающей двойной кавычки указывает Rust не помещать символ новой строки в начало содержимого этого строкового литерала). Мы утверждаем, что значение, возвращённое из функции search, содержит только строку, которую мы ожидаем.

Если мы запустим этот тест, он в настоящее время потерпит неудачу, потому что макрос unimplemented! паникует с сообщением «not implemented». В соответствии с принципами TDD мы сделаем небольшой шаг — добавим ровно столько кода, чтобы тест не паниковал при вызове функции, определив функцию search так, чтобы она всегда возвращала пустой вектор, как показано в листинге 12-16. Затем тест должен скомпилироваться и потерпеть неудачу, потому что пустой вектор не соответствует вектору, содержащему строку "safe, fast, productive.".

Имя файла: src/lib.rs
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    vec![]
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn one_result() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";

        assert_eq!(vec!["safe, fast, productive."], search(query, contents));
    }
}
Листинг 12-16: Определение ровно столько search, чтобы её вызов не паниковал

Теперь давайте обсудим, почему нам нужно определить явное время жизни 'a в сигнатуре search и использовать это время жизни с аргументом contents и возвращаемым значением. Напомним из главы 10, что параметры времени жизни определяют, какое время жизни аргумента связано со временем жизни возвращаемого значения. В этом случае мы указываем, что возвращаемый вектор должен содержать срезы строк, которые ссылаются на части аргумента contents (а не аргумента query).

Другими словами, мы сообщаем Rust, что данные, возвращаемые функцией search, будут жить столько же, сколько данные, переданные в функцию search в аргументе contents. Это важно! Данные, на которые ссылается срез, должны быть действительны, чтобы ссылка была действительной; если компилятор предполагает, что мы делаем срезы строк из query, а не из contents, он неправильно выполнит свою проверку безопасности.

Если мы забудем аннотации времени жизни и попытаемся скомпилировать эту функцию, мы получим эту ошибку:

$ cargo build
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
error[E0106]: missing lifetime specifier
 --> src/lib.rs:1:51
  |
1 | pub fn search(query: &str, contents: &str) -> Vec<&str> {
  |                      ----            ----         ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `query` or `contents`
help: consider introducing a named lifetime parameter
  |
1 | pub fn search<'a>(query: &'a str, contents: &'a str) -> Vec<&'a str> {
  |              ++++         ++                 ++              ++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `minigrep` (lib) due to 1 previous error

Rust не может знать, какой из двух параметров нам нужен для вывода, поэтому нам нужно явно указать ему. Обратите внимание, что справочный текст предлагает указать один и тот же параметр времени жизни для всех параметров и типа вывода, что неверно! Поскольку contents — это параметр, который содержит весь наш текст, и мы хотим вернуть части этого текста, которые совпадают, мы знаем, что contents — единственный параметр, который должен быть связан с возвращаемым значением с использованием синтаксиса времени жизни.

Другие языки программирования не требуют от вас связывать аргументы с возвращаемыми значениями в сигнатуре, но эта практика станет легче со временем. Вы можете сравнить этот пример с примерами в разделе «Проверка ссылок с помощью времён жизни» главы 10.

Написание кода для прохождения теста

В настоящее время наш тест терпит неудачу, потому что мы всегда возвращаем пустой вектор. Чтобы это исправить и реализовать search, нашей программе нужно выполнить следующие шаги:

  1. Перебрать каждую строку содержимого.
  2. Проверить, содержит ли строка нашу строку запроса.
  3. Если содержит, добавить её в список возвращаемых значений.
  4. Если не содержит, ничего не делать.
  5. Вернуть список совпавших результатов.

Давайте проработаем каждый шаг, начиная с перебора строк.

Перебор строк с помощью метода lines

В Rust есть полезный метод для построчного перебора строк, удобно названный lines, который работает, как показано в листинге 12-17. Обратите внимание, что этот код пока не скомпилируется.

Имя файла: src/lib.rs
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    for line in contents.lines() {
        // делаем что-то со строкой
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn one_result() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";

        assert_eq!(vec!["safe, fast, productive."], search(query, contents));
    }
}
Листинг 12-17: Перебор каждой строки в contents

Метод lines возвращает итератор. Мы подробно рассмотрим итераторы в главе 13. Но вспомните, что вы видели этот способ использования итератора в листинге 3-5, где мы использовали цикл for с итератором для выполнения кода для каждого элемента коллекции.

Поиск запроса в каждой строке

Далее мы проверим, содержит ли текущая строка нашу строку запроса. К счастью, у строк есть полезный метод с именем contains, который делает это за нас! Добавьте вызов метода contains в функцию search, как показано в листинге 12-18. Обратите внимание, что этот код по-прежнему не скомпилируется.

Имя файла: src/lib.rs
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    for line in contents.lines() {
        if line.contains(query) {
            // делаем что-то со строкой
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn one_result() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";

        assert_eq!(vec!["safe, fast, productive."], search(query, contents));
    }
}
Листинг 12-18: Добавление функциональности для проверки того, содержит ли строка строку в query

На данный момент мы наращиваем функциональность. Чтобы код скомпилировался, нам нужно вернуть значение из тела, как мы указали в сигнатуре функции.

Сохранение совпавших строк

Чтобы завершить эту функцию, нам нужен способ сохранить совпавшие строки, которые мы хотим вернуть. Для этого мы можем создать изменяемый вектор перед циклом for и вызвать метод push, чтобы сохранить line в векторе. После цикла for мы возвращаем вектор, как показано в листинге 12-19.

Имя файла: src/lib.rs
pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let mut results = Vec::new();

    for line in contents.lines() {
        if line.contains(query) {
            results.push(line);
        }
    }

    results
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn one_result() {
        let query = "duct";
        let contents = "\
Rust:
safe, fast, productive.
Pick three.";

        assert_eq!(vec!["safe, fast, productive."], search(query, contents));
    }
}
Листинг 12-19: Сохранение совпавших строк, чтобы мы могли их вернуть

Теперь функция search должна возвращать только строки, содержащие query, и наш тест должен пройти. Давайте запустим тест:

$ cargo test
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
    Finished `test` profile [unoptimized + debuginfo] target(s) in 1.22s
     Running unittests src/lib.rs (target/debug/deps/minigrep-9cd200e5fac0fc94)

running 1 test
test tests::one_result ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

     Running unittests src/main.rs (target/debug/deps/minigrep-9cd200e5fac0fc94)

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

   Doc-tests minigrep

running 0 tests

test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

Наш тест прошёл, поэтому мы знаем, что он работает!

На этом этапе мы могли бы рассмотреть возможности рефакторинга реализации функции поиска, сохраняя тесты проходящими, чтобы поддерживать ту же функциональность. Код в функции поиска не так уж плох, но он не использует некоторые полезные возможности итераторов. Мы вернёмся к этому примеру в главе 13, где подробно рассмотрим итераторы и посмотрим, как его улучшить.

Теперь вся программа должна работать! Давайте попробуем её, сначала со словом, которое должно вернуть ровно одну строку из стихотворения Эмили Дикинсон: frog.

$ cargo run -- frog poem.txt
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.38s
     Running `target/debug/minigrep frog poem.txt`
How public, like a frog

Отлично! Теперь давайте попробуем слово, которое совпадёт с несколькими строками, например body:

$ cargo run -- body poem.txt
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
     Running `target/debug/minigrep body poem.txt`
I'm nobody! Who are you?
Are you nobody, too?
How dreary to be somebody!

И, наконец, давайте убедимся, что мы не получаем никаких строк, когда ищем слово, которого нет в стихотворении, например monomorphization:

$ cargo run -- monomorphization poem.txt
   Compiling minigrep v0.1.0 (file:///projects/minigrep)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.0s
     Running `target/debug/minigrep monomorphization poem.txt`

Отлично! Мы создали свою мини-версию классического инструмента и узнали много нового о том, как структурировать приложения. Мы также узнали немного о файловом вводе и выводе, временах жизни, тестировании и разборе командной строки.

Чтобы завершить этот проект, мы кратко продемонстрируем, как работать с переменными окружения и как печатать в стандартный поток ошибок, что полезно при написании программ командной строки.