---
title: "Test Cases, String Asserts and more"
url: "https://courses.osherove.com/courses/tdd-in-net-in-hebrew/test-cases-string-asserts-and-more.md"
canonical: "https://courses.osherove.com/courses/tdd-in-net-in-hebrew/test-cases-string-asserts-and-more/"
tags: []
author: "Roy Osherove"
description: "Lesson 4 of 22 in TDD in .NET in Hebrew (Day1 - Unit Testing and TDD 101), 34:49. Free video by Roy Osherove."
usage: "Licensed under CC BY 4.0 — reuse, quote and adapt with attribution (Roy Osherove, link to the original page)."
license: "https://creativecommons.org/licenses/by/4.0/"
---

# Test Cases, String Asserts and more

1. [Courses](https://courses.osherove.com/#courses)
2. [TDD in .NET in Hebrew](https://courses.osherove.com/courses/tdd-in-net-in-hebrew/)
3. Day1 - Unit Testing and TDD 101

Lesson 4 of 22

Duration: 34:49 [Watch on YouTube](https://www.youtube.com/watch?v=_BrBkzT-25U) Spoken in Hebrew

## In this lesson

Roy Osherove merges similar tests with [NUnit](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-2#ch02lev1sec3 "First steps with NUnit (The Art of Unit Testing, 2nd ed., ch. 2)")'s [TestCase attribute](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-2#ch02lev1sec5 "Refactoring to parameterized tests (The Art of Unit Testing, 2nd ed., ch. 2)") and compares ways to test an exception: try/catch with Assert.Fail, the [ExpectedException attribute](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-2 "Checking for expected thrown errors (The Art of Unit Testing, 3rd ed., ch. 2)"), which can pass when another line throws, and Assert.Throws with a lambda. He treats a [TearDown](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-9#sigil_toc_id_171 "Setting up and tearing down (The Art of Unit Testing, 3rd ed., ch. 9)") as a sign of an [integration test](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_25 "Integration tests (The Art of Unit Testing, 3rd ed., ch. 1)"), to be kept in a separate project, and names the continuous test tools AutoTest.NET, NCrunch and Mighty Moose. He then introduces the three [TDD](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_27 "Test-driven development (The Art of Unit Testing, 3rd ed., ch. 1)") steps and starts a calculator memory feature test first.

## Transcript

4,694 words

[\[00:03\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=3s) ופה אנחנו נכנסים לאפצ'ר שכרגע חסר ב-MSTest שזה הנושא של parametr test אני יכול לקחת את הדבר הזה ולהגיד עכשיו יש לי פה פרמטר לפונקציה עדיין אף אחד לא שולח אותו כי הוא עדיין לא מספיק חכם תכף אני אראה לכם איך אני אשתמש בו זה y שתי פרמטרים

[\[00:34\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=34s) ו אני בשניהם אני מצפה אפילו לאותו אר נכון אז אני יכול להגיד עכשיו במקום test אני משנה את זה לtest casס אני אומר הטestק casס הראשון אני שולח מינוס2 כל מה זה המינוס3 ו2 או 1 ואני מצפה חזרה למינוס1 אחד נכון אני אין לי פרמטר על זה אני תמיד מצפה לר כביכול יש לי עכשיו את אותו test

[\[01:06\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=66s) עשיתי רפקטורing הטest הזה רץ בדיוק אותו דבר מה שיפה בטסט זה שאני יכול לשים מטפל test cas אותה מתודה וכל אחד מהם הופך לטסט בנפרד אז אני יכול לעשות ככה אני יכול להגיד אוקיי עכשיו נעשה אחד זה מינוס 3 הטסט הזה עדיין אמור לעבור מינו עזר עכשיו יש לי תשימו לב returns error value עם 1 ומינוס 3 נכשל אוקיי

[\[01:37\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=97s) ועכשיו אני יכול ללכת ולתקן את הפיצ'ר הזה >> יש פה משהו שאני מכיר צריך שדבר על ההתרדה >> ההתרדות זה משהו שאני נכון y נתן מאפס עד הכל אמור לעבור עכשיו שלושה פסט עכשיו בוא נדבר על מה מתי לך אם אתה חובר חזרה עוד לפני שעשית את התיקון הזה של אור y קטן מאפס כן >> ובטעות עשית את הטestט כמו שאמרנו קודם >> מינוס אח >> לא אחד במינוס שבעצם היה מחזיר התוצאה והטסט היה עובר כן >> אז בעצם אנחנו נתקנים כאן באותה באותו מצב שוניט testing היה אמור לפתור לנו שאנחנו יכולים לסמוך על הקוד ב-100% שבעצם פאקטור גדול שאנחנו עושים אנחנו מריצים את היוקסטים

[\[02:24\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=144s) ויודעים שהסנריוס שאנחנו מצפים יעבו >> אתה אתה אתה אומר שעריפת כלום שעשיתי לשבור את הטסט זהו לא אני אומר מה שכונ שהכתיבה של הטestטים צריכה לעשות איזה רו מטורף כאילו כדי שאפשר לסמוך על זה ב-100% כדי שאתה לעבור על כל הסנך איזשהו >> טוב צריך לזכור שאנחנו עדיין לא עושים את [TDD](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-1#ch01lev1sec6 "Test-driven development (The Art of Unit Testing, 2nd ed., ch. 1)") בטDD ההרגשה לגבי הטest משתנה כי בTD אתה מתחיל מטestט שאמור להיקשל ואז הוא אמור לעבור ואם אתה ואתה תגלה בד מאוד מהר כי אחד מהם לא יקרה >> שמנו מלא ואז אתה סומך על הט >> נגיד שהיית משנה עכשיו היית עושה רפאקטור והיית משנה את ה לא היית עושה את הטפס והיית משנה שם את הור למינוס שת זה היה פקטור אז הטest היה עובר ועדיין לא הייתה מודע לזה שאתה לא בודק אם הyשלילי ש >> נכון אם הייתי מחזיר מינוס שת אבל הייתי מודע לזה שאני מחזיר מינוס ש עשך

[\[03:16\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=196s) נגיע לנושא של אבל טD הרבה פעמים אתה מחזיר כדי לרום לכל לעבור אבל אתה מוכיח בטest נוסף שמשהו לא בסדר שם >> זאת אומרת הטestטים מג מגבים אחד את השני אבל הם מראים לך עבודה אינטרמנטלית המטרה היא תספור לא רק להוכיח נכונות המטרה היא להוסיף פונקציונליות אבל בצורה אינטרמנטלית עכשיו במקרה הזה בוא נניח שאני עכשיו אני עכשיו יכול להחזיר פה מינוס שת לשמ את הקס את האר ואם היית אם היית מסיר את קטן נפס זה עדיין היה >> אם הייתי עושה פה מינוס שת זה היה עוד פקט >> כן אבל הוא y את הנפס עדיין ק >> אני מסכים איתך שאתה יכול לכתוב [unit testing](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_17 "Defining unit testing, step by step (The Art of Unit Testing, 3rd ed., ch. 1)") ושעדיין יהיה לך בוא

[\[03:53\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=233s) >> זה לא משהו זה הולך להמשיך לקרות מה ש אבל ההבדל הוא בתרבות התרבות הארגונית אומרת שכשאני מגלה את הבאגים האלה אחר כך ואף אחד לא אומר שאתם לא תגלו באגים אחר כך להפך אתם תגלו באגים פשוט תדעו מה לעשות איתם אחר כך הרבה יותר בקלות זה שאתם תוסיפו את הטestטים לפני שאתם פותרים את הבאגים ואז הבאגים האלה אם הם יחזירו אתם תגלו אותם ודרך אגב בד של טttנושא של מתי להפסיד לכתוב טestטים אין איזשהוא משהו מוצג שעובר את זה היום מתי אתם חושבים שהקוד שלכם עובד מתי אתם מגישים את הקוד לסורס קונטרול או לד

[\[04:29\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=269s) היום בצ'קין אנחנו שמים ש >> אנחנו עושים טס >> מה גורם לך לחשוב שאתה יכול לעשות צ'קין לכל >> אנחנו עושים טסים פה יש לך פשוט יותר סיבות לחשוב שיש לך סיבות לשים שקטו זה ההבדל זה קור אותך לרמת ודאות יותר גבוהה אבל זה לא ודאי >> זה לא תהליך מדעי זה לא תליך מדעי זה תהליך אנושי >> בגלזה אומר שזה עדיין מסוכן כי אתה יכול לסמוך על זה הרבה יותר נגיד אם אתה עושה זה בסדר זה לא זה מסוכן בהתחלה כי הרשת ביטחון שלך מאוד קטנה אבל יכול שאתה תגלה את הדברים אתה גם אתה פשוט מאבא את הרשת כל הזמן >> ותזכור המטרה שלך היא לא רק לבדוק שזה עובד אלא להוסיף את הפונקציונליות

[\[05:06\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=306s) אז גם אם לא הכל עובד וחלק לא עובד באמת יש לך עדיין משהו הרבה בצורה הרבה יותר מהירה ממה שהיה בך קודם >> אבל אתה יכול לרשות לעצמך לעשות שינויים גדולים יותר >> ככל שאתה תרגיש יותר בנוח בהתחלה אתה לא תרגיש בנוח לעשות שינויים גדולים כי הקover שלך יהיה מאוד מאוד זה גם מאוד עוד לא מסתכל על התהליך בוא בוא אני רק >> אנחנו עדיין לא עושים את התגיד שבאמת הטסטים עוברים ביו הרבה יותר מסי >> אבל זה לא התהליך שהיינו עושים אנחנו היו נוגעים לתוצאות אחרות לגמרי בגלל שמה שאני אומר עכשיו זה את הPI אני לא מלמד את התהליך הדה

[\[05:38\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=338s) הוא התמודד עם החשש שלך כי כרגע החשש לא מחובר לתהליך עוד אין דלי >> כן סב קיצור אתה צודק פועל >> לא הוא לא פועל אני מעודן את התהליך ברגע הוא אז נוכל להיות אה הוא צודק בקטע הזה שהטestטים הם אף פעם לא ארובה לזה שהפוד עובד אבל הם הם עוזרים לך בביטחון שהפוד עובד אבל אם לא עושים TDTd אז יש הרבה יותר סיכוי שהטestטים ישרים מסכים יש דרך לצאת שמות

[\[06:08\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=368s) ש לתת שמותס מסובך אם הוא מסובך אני אני מאמין שהדבר שהכי קשה יש שני דברים מאוד קשים בטestטים למצוא שמות טובים ולמצוא פרמטרים טובים אוקיי כל השאר הוא היה יחסית קל כבר רגע שאתה יודע איך לבדוק את המערכת שלך זאת אומרת הדבר השלישי הכי קשה זה להסתכל על קוד שאתה אף פעם לא בדקת ולנסות לכתוב את הטestט הראשון שלו ואז זה להבין את הפאטרן איפה לשלוח מה לצפות איפה הנדרי resultלט שלי וכולי וזה יכול לקחת גם שעה שעתיים אה אבל בטestט הבא זה ברקח שתי דקות בטסט הבא זה 30 שניות

[\[06:45\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=405s) >> אבל שם טוב לטestטest casס >> לטest casס שים לבest casס מה שאני הייתי עושה הייתי עושה לזה עודפקטורing הייתי משתמש פה בקונסטנט כי זה לא קר מבחינתי מינוס של זה לא אומר לי שום דבר אוקיי אז הייתי עושה מפה קונסט שם פוזיטיב שם נגטיב אז הייתי אומר וואלה אני רואה פוזיטיב פה ופוסיטיב פה ונגטיב פה ונגטיב פה וזה ואז מבחינתי זה הרבה יותר טוב אבל צריך לזכור שבטest casיס באטריביוטים אתה יכול לשלוח רק דברים שהם compiled אתה לא יכול לשלוח כבר לזינרים אתה לא לא יכול לשלוח delגatס או דברים כאלה

[\[07:18\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=438s) עוד שאלות אם שם פה קונס אתה תראה בס תראה בכונס או את הערך שלו כן ש אתה תראה את הערך שלו אבל אני לא בטוח אפילו לא שמתי לב כי בדרך כלל איך שאוני מגיע לדברים פה עם לא יודע בדרך כלל לא מגיע לערכים כאלה לא יודע למה רק בדמוים הסתם כי בדרך כלל הטestטים הם קצת יותר קריאים כי הם קצת יותר אמיתיים אני רוצה להראות עוד פיצ'ר חדש אלה כן יש עוד שרט

[\[07:49\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=469s) לא פיצר חדש ב-NUnit פיצר חדש מבחינת הקורס מה קורה אם יש לי קוד כזה if x גדול מ1000 אז throw new exception I can't do that אוקיי מי שמכיר טוב מי שלא מכיר את קודיסה בחלל

[\[08:39\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=519s) אוקיי אבל איך אני בודק פיצ'ר כזה אז ופה חשוב לזכור שבפריים יש היום כמה דרכים לבדוק דברים כאלה קודם כל איך אני אכתוב את הטest הזה ‏test addig number first over מה שמזכיר לי שלא שנינו את השם הזה פהפוד עוזר לפוסות האלה מהבי זה קצת

[\[09:16\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=556s) אמ ש מבחינתי אני אריץ את זה אלפי פעמים ביום את האלטר הזה כן זה אמור להיות מהיר אמור להיות לזה firstold זורק exception אז אני עושה varable ‏C C מה זה מה וחצי

[\[09:46\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=586s) השאלה >> 1000 מה >> max ועוד אחד >> מקס ול ועוד אחד הבעיה היא מקס ולח שהפלוס הזה מרגיש לי כמו לוגיקה אני לא רוצה אני לא רוצה שיהיה לי דינמי אם אני יודע שבד אחד זה הראשון אז אני אשנה את זה אבל אם אני רואה שמץ אני מתחלף כל הזמן אני אשנה ס בדרך כלל זאת לא כזאת בעיה אה לפעמים אני מסכים איתך שמשתמשים בקונס פלוס אח אצלנו זאת עדיין לבית

[\[10:16\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=616s) 1001 ו >> סביב 100 ו2 אני רואה 100 ו2 אבל זה כבר את העניין של טמפ אצלכם יכול להיות שכבר הייתם עושים פה אני צריך לקבל את הול כי אני מקבל פה אפtion אז איך אני בודק את האספtion אז ככה פעם אני אספר לכם שתבינו את ההיסטוריות פעם בג'אבה היו עושים את כל הדבר הזה בטריy catch אחד גדול alt ry catch exception e ואם הגעתי לc

[\[10:52\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=652s) בטח com successס הוא לא היה צריך comנ כי כתוב לי בשם של test אבל אם הגעתי לפה אני עושה assert עבודה fail dude where אוקיי עד R אפס עכשיו זה בעיה נכון זה בעיה טestטים שאחרי שאתה שאתה כותב אותם אחרי הקוד יופי אז זהפס איך אני יודע שהטest הזה באמת בודק את הדבר הנכון אז מה שאני הולך לעשות עכשיו זה אני אשים פה promטר ס

[\[11:27\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=687s) אני רואה את הטest שלי נכשל ואז אני יודע שהטest הזה באמת בודק את הדבר הנכון אה alt אוקיי אז לקחת לי עוד חמש שניות מהחיים שלי אבל אני יודע שהטest הזה הוא נכון אמ אוקיי אז הטest הזה הוא באמת מבחינת מבחינה טכנית הוא נכון אבל מבחינת אדabity הוא די די די לא משהו אז ב-NUnit פטרו את זה בצורה מאוד נחמדה במקום בנוסף לטest שמים [expected exception](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-2#ch02lev1sec6 "More NUnit attributes (The Art of Unit Testing, 2nd ed., ch. 2)")

[\[12:01\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=721s) ואת ה-typeפ של הceptפtion שאתה מצפה לו כי במקרה שלנו זה אספtion במקרה שלכם זה יהיה של אקספtion אמיתי שהמערכת זורקת ואז צריך עכשיו להוריד את כל הטריק catch כי מה שאטed exception עושה זה תחשבו על זה הוא הוטף את כל הטest בטריק אחד גדול ברמת הרע עושה alt וואלה rפס אבל יש לי בעיה אם זה נכון אני לא יודע מה קורה alt הופ אופס זה לא מה שהתכוונתי זה גם לא מה שהתכוונתי

[\[12:32\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=752s) רוצה ‏one failed system exception was expected אוקיי לבדוק את ההג >> מה >> אפשר גם להוסיף את ההודעה את ההודעה של המage של הceptפtion כן אתה יכול גם להרגיד מה תהיה מה יהיה המage אבל שם יש בעיה נוספת שאם אתה מחליט בדיוק מה הסטרינג ומחר הסטרינג הזה משתנה נגיד יש לו עודספיס בסוף אתה לא יכול לעשות קונטינס או דברים כאלה אלה אתה לא יכול לעשות דברים דינמיים

[\[13:05\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=785s) אז נדבר על איך כותבים את זה אוקיי אז הסט הוא באמת נראה שהוא נורא מפשט את התהליך אבל יש איתו בעיה יש אתו בעיה גדולה מאוד של טסט מי ש יכול להבין מה יודע שזה הקספ של הנכון יודע שזה בא מהשורה הנכון >> איך אני יודע שזה בא מהשורה הנכול זה הדבר הבעייתי פה מה אם היצירה של מייקל יותר זורק לי את אותו טיים של אקספ של מחר אז הטest שלי עובר למרות שהקוד בכך עובד אז מה שאני רוצה זה לבדוק שמשהו

[\[13:39\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=819s) ששורה מסוימת זורקת אספtion אז גם אם יש את הפtion אל תשתמשו בו אז כי זה API שלךשן הנה API קצת יותר חדש עושים assert throws ty של exception ופה נותנים delegate זה עוד דרך אגב contrול shift space נותן לך אפשרויות מה איך למלא את הפרמטר רואים ואז נורא נורא קל לעשות דברים אומר תשמע אתה יכול לשלוח פה פונקציה או ליצור פונקציה חדשה או לשלוח del דלגate או לשלוח למדה

[\[14:12\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=852s) למי כבר יצא לעבוד עםטס למי יצא לעבוד עם לדה expressions אוקיי לנדש ה זה דלגט קצת יותר פשוטים מבחינתי מה שאני עושה זה c add 1001 ו2 אני מוחק את השורה הזאת שבת ככה לפעים אם אני עושה את זה אולי קצת יותר קרי ככה אוקיי אז בעצם מה שאני אומר ש יש לי פה דלגט שלא מקבל פרמטרים והבודי שלו זה אחרי החץ השורה הזאת בלבד אמורה לזרוק את האקספtion

[\[14:47\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=887s) אז אם מחר השורה הזאת זרוק אקספtion הסט שלי יקשה אבל כל זמן שהשורה הזאת זורקת אפtion הס שלי ימשיך לעבור זה גם פיצ'ר שחסר בnsms test אין עשר למרות ש לא >> מה >> יש בערך >> יש בערך את הספר שזה >> אבל זה לא במסט test ב >> אבל ב-MSTest זה לא בלתי אתה צריך להוריד שמשתמש בו >> כן אבל flוא assur הוא לא בלתי בתוך MSTest fl זה dl שאתה מוריד >> הוא לא ממייקרוסופט

[\[15:22\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=922s) הוא לא חלק מmstס אז הוא לא פיצר של mssס זה משהו שאתה מוסיף >> עכשיו אתה גם יכול לכתוב את זה בעצמך לוקח שש שורות של קוד לכתוב משלכם בסופו של דבר זה ממש ממש פשוט מה שלא מסביר את הסיבה למה למייקרוסופט גבר אחרי שלושה רליסים של פשו סטודיות לא הוסיפו את זה אבל זה מסביר על רמת המחויבות שלהם בעולם היו מטestטים על כמה אכפת להם מבחינת ההתקדמות שם זאת אחת הסיבות שמבחינת MSTest היום ממערכת שהיא זה כמוס זה כאילו הE ש של הtest frameס אוקיי יש לו בדיוק מספיק כדי לראות דברים בסיסיים אבל אין לו test cases אין לו pr יש לו עדיין באגים בחלק בחלק מהמקרים הוא הרבה יותר

[\[16:03\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=963s) מבחינת הפיצ'רים הבסיסיים של tdd הטestטים שאתם תכתבו עם ms testים יהיו פחות maable פחות readable אל כן תצטרכו להוסיף דברים כמו fltion וכולי שזה dlים וכל מיני הלפרים אבל בלתי בתוך הכלי אין שום דבר מספיק טוב אוקיי שזה מעניין בגלל שהבן אדם שכתב את אין יוני במקור הוא עובד במייקרוסופט עכשיו זאת אומרת מייקרוסופט קנ את הבן אדם ככה שמה אותו שם הוא לא עובד על סטודיו אבל הוא לא עובד על הניטestי גם בVטודיו

[\[16:33\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=993s) בהפסנאות שם >> הוא עבד מה באפסנאות אמרת >> שאלה אם אם יש לי בפונקציה add יותר מאקספtion אחד אותו אספש ואיך אני אדע ש >> אם יש לך בפונקציה יותר מטyפ אחד של הפונקציה יכולה לזרוק כמה פעמים >> אה אז יש את multפile resultלs אז כל אחד מהם סניפה נכון כל אחד מהם היא זורקת במקרה אחר >> לא לא >> לא יכול להיות בקספש הנכון מזרק בדיוק >> שהטייפ הנכון של האקספtion או שהמג הנכון אותה זה בערך המרך המ אם יש לך מסage >> אז אז בוא אני אסביר א' אתה אם זה לפי טייפ אז אתה משנה את הטy >> לא ברור אבל אם אותו >> אבל אם הוא אותו טייפ אז אתה יכול לקבל את האפtion ישר כי זה פונקציה אתה יכול לקבל את האפtionקט

[\[17:18\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1038s) ואז אתה יכול לעשות עליו x נפל מג יש לך את כל המידע אתה מקבל את obק עצמו כאילו אתה יכול לעשות אסרט אני לא משתמש בסרט הרquול כמעט עלסטרינגים מה שהייתי עושה הייתי עושה אשרט או תראו בדיוק הייתי משתמש באובייקט אחר בני שנקרא string string ואז הייתי נותן לו את expectected נגיד message needle

[\[17:50\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1070s) ואת הxנ message והסיבה היא שאם אני משתמש עשר על סטרינגים סטרינגים תחשבו על זה זה סוג של UI יכול להיות להם פתאום את הטיים בהתחלה יכול להיות להם new lינס בסוף לא אכפת לי מהדברים האלה שמשתנים כל הזמן אכפת לי מהcore mage אז הטestט הזה יחזיק הרבה יותר זמן מאשר טestטים שם מודדים שהסטרינג נראה בדיוק ככה מחר אני רוצה להוסיף גם עוד משהו בסטרינגים שלי אבל המסג עדיין צריך להיות אותו דבר אז הטestט הזה ימשיך לעבוד

[\[18:22\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1102s) כן זה מתחשב בקייסינג הונט הקט הזה הוא מתחשב בקי >> כלומר >> אז אתה גם יכול להשתמש בגular exp >> אוקיי אז במצב אבל הלוכחים זה היה casing שונה אז זה לא היה עובד >> אם אני לא רואה יש פה את ה את האפשרות לשנות גם את הקיסים אה יש לו זה יש לו strרנ יש פה אני לא זוכר בדיוק אני בדרך כלל משתמש בקייסים וזה לא משנה

[\[18:56\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1136s) דווקא קיסינג זה משהו שכן חשוב שמתחיל באותיות גדולות פול זה לא זה לא משהו שפגע בי בעבר אז לא הייתי צריך לגלות את זה אבל זאת לא אמורה להיות בעיה עוד שאלות בכלל כל פעם שאתם רואים אותכם עושים אסרטול עלסטרים תחליףו את זה לסרטס הטestטים שלכם יחזיקו הרבה יותר זמן אוקיי אז זה מבחינת rows יש עוד כמה פיצרים של [NUnit](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-2#ch02lev1sec3 "First steps with NUnit (The Art of Unit Testing, 2nd ed., ch. 2)") שאנחנו צריכים להכיר ולדעת

[\[19:27\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1167s) לדוגמה יש עוד אפג שנקרא את הטestים שלנו אתם רואים שיש after אחרי כל test אוקיי עכשיו מה שמעניין זה שהטest הזה נחשב בגלל שהמג' באמת לא מכיל את ה זהו הוא חיל I can't do thatדא

[\[20:01\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1201s) הוא קורה אחרי כל test למה לדעתכם אפשר להשתמש בו לנקות את ה משהו חוק רצים רול בפידת >> זה בעצם ההפך של סטאפ ההפך של setטאפ אבל זה יש משהו מאוד מעניין בטרדאון מבחינת הפטר של השימושטרדון אתה משלם כדי לנקות אחריך אם יש לך מה לנקות וזה לא בזיכרון רוב הזיכרון שמה שיש לך זה לא unit test אלא inרation test זה מאוד חשוב צריך לנקות דבס זה לא unit test כבר אתה משתמש בו משתמש בפסיסטם

[\[20:40\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1240s) בנתנו un test >> זה הפנט test מכסה רץ בזיכרון הוא קנסטי הוא לא נוגע בdeפendes של fסם database וכולי לכן אני קורא לכל הדברים אחרים [integration test](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-1#ch01lev1sec3 "Integration tests (The Art of Unit Testing, 2nd ed., ch. 1)") עוד פעם זה חשוב שוב לי לדעת שאני אם אני רואה טרדון אני אומר וואלה 95% מהזמן זה test יש מקרי קצה מסוימים שבהם יש לך סינגלטון statטיק שאתה רוצה לנפות כל מיני הלפרים שאתה רוצה לעשות להם reset שהם בזיכרון זה המקרים היחידים שבהם טד make sense וזה unit test כשזה חשוב כי כשאנחנו נתחיל לעשות testw אחד לשני ונראה את הקוד אחד של השני אז הטרדון האלה מאוד חשובים כי הרבה פעמים זה סימן שמה שיש לך זה אינטגרש test הוא צריך להיות בפרויקט אחר שנקרא mypegration

[\[21:25\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1285s) Test אני מפריד ביניהם בגלל שגration tests אני בדרך כלל רוצה להריץ בבילד נפרדים מאשר unit tests הם הרבה יותר איתיים וגם אם אני אם יש לי מיקס ביניהם אז הרבה פעמים integraation tests הם אתה עושה get lest verion של הקוד שלך integraation test בדfaultט הרבה פעמים צריכים קונפיגורציה אז אז הם נופלים אבל מה שאני רוצה זה שיהיה את את האקספרerס הבא מוסגת מריץ את את כל הפרויקט של הטestטים וכולם ירוקים, כולם עוברים.

[\[21:59\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1319s) אוקיי? אבל אם פתאום אחד נכשל ואני שואל את ה את ה מי שכתב את הטest למה הטסט הזה נחשב? ואז הוא אומר לי אה זה בסדר, זה פשוט חסר לך פה הקונפיגורציה אז אני מתחיל לא להאמין לטסט שלי, נכון? אני רוצה שכשיש לי הכל ירוק ואחד לכשיו אני רוצה להיות מודעג, אני לא רוצה להגיד אז זה בסדר. לכן אני מפריד ביניהם כי אני יודע שבנגר test שם זה בסדר להגיד זה בסדר חסר לי קונפיגורציה אבל בני test זה אף פעם לא בסדר בIT test get verion תמיד עובר אין דבר כזה שאני עושה getion ויש לי testים שנכשלים בIT testing testים שנכשלים לפעמים כי חסר לי דטפיס כי זהסטרד כי זה רנדומים נשים אותם באנטגרש test ושם אני יודע אני מצפה לזה שלא בכלל כולם יעברו ביולט אבל לפחות יש לי איזה פרויקט אחד או כמה במערכת שהם the save green זור ששם כולם אמורים לעבור ואז יש לי איזשהיא מידה של ביטחון שהמערכת עובדת

[\[22:53\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1373s) אוקיי שיר >> מה >> הם אלה שירוץ >> הם גם אלה שירוץ בטוס integration אבל זה גם קשור למהירות יכול להיות לפעמים שאני אריץ test בinusation אם אני יכול כי יכול להיות שיש לי integration test שהם מהירים יחסית אז אז אני מחלק דברים לcration daily build לפי מהירות של הטestי אבל מבחינת החלוקה לפרויקטים זה קשור לא למהירות זה קשור לקונסיסטנטיות שלי אוקיי וזה קשור לעובדה שאם יש לי שליטה או אין לי שליטה בדרך כלל אין לי שליטה על דברים אחרים עלפילסם יש לי בטestטים שבהם כתבתי את הפרויקט שלי יש לי כונן z אבל באינטגרשט test הוא מצפה על כונן אבל בביל סרבר שכחתי עדיין לשים את הכונן הזה וכולי

[\[23:41\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1421s) אוקיי עוד דברים שאלות לפני שאתם מתחילים לכתוב סרטון >> חוץ מאלת את הדברים האלה רצים גם מקומפילציה >> לא הבנתי >> חוץ מריץ אותם כאילו ידנית רצים גם >> אוצרקפג משהו האלטר r הרצה של testר הוא עושהס וגם מריץ קומפילציה לפני זה לא צריך לעשות שום דבר אני לא צריך לעשות בילד לא >> אתה רוצה שזה יקרה אוטומטית בקומפילציה טז רבן לא עושה את זה בשביל זה יש כלי אחר שהוא חינמי שנקרא AutoTest.NET

[\[24:12\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1452s) זה דף הבא שבכלתי להראות שזה יפה רואים פה את המני הזה לצערי זה לא קיים בנוגד כי זה לא פק זה לא dependency אבל זה פרקט open source יכולים להוריד את הטלר שלו מה שאתם עושים אתם אומרים וואלה resום engine בפרויקט הנוכחי שלכם ואז אני יכול לראות את ה את הפבק וויידו שלי עכשיו כל פעם שאני עושהסיב נגיד אני עושה פה רווח וסיve contrול s משהו שהוא עושה

[\[24:44\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1484s) שפה הוא היה אמור לזהות את זה test. Net צריך צריך סטא נראה מה קורה מעניין לא מריץ את זה לפעמים זה מריץ לפעמים זה לא מריץ אנחנו נעבור יש בעיקרון שלושה continוס test frameworks שלושתם חינמים כרגע יש את ה-AutoTest.NET שאני בגדול התחלתי לנסות אותו רק לפני כמה ימים

[\[25:14\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1514s) יש את ה-NCrunch אch הוא הוא החזק מביניהם הוא גם יודע לחלק להריז את הטestטים ברקע עםפle thדadס יודע לעשות אגנור לחלק מהטestטים יש לך הרבה טestטים בלגסי אבל הוא הולך להיות מוצר לא חינמי בעתיד אבל כרגע הוא חינמי והוא לא open source ויש את Mighty Moose Mighty Moose הוא הוא גם continuous tests החוזק שלו הוא עלה הכסף ועכשיו הוא חינמי אבל הוא לאסוף החוזק שלו הוא מבוסס על AutoTest.NET אבל החוזק שלו האמיתי זה שהוא גם משתמש ביוריסטיקות

[\[25:48\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1548s) כדי להבין איזה טestטים צריך להריץ לקות ששיניתם אז הוא לא מורץ את כל הטestטים אוטומטית יש לך 100 טestטים אבל רק ארבע צריכים לרוץ אז הוא ירץ רק את הארבע האלה הוא משתמש בהמון סוגים של קoverage ופיילינג כדי לעשות את העבודה שלו בגלל זה הוא גם יחסית איתי מאחרים אבל כשיש לכם פרויקטים הרבה legגy test והרבה אנטגרש test הוא ממש ממש מולץ אז גם זה וגם אקרא' מאוד חזקים אני אני בכוונה רציתי לנסות להראות לכם את האוטוטest אבל משום מה זה כמובן בדמוים תמיד הפעם הראשונה שברים עסיקים לעבוד

[\[26:21\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1581s) אז יש פתרונות כאלה ואתם יכולים לנסות להתקן אצלכם כל אחד מהדברים האלה כנראה אין קנץ זה את ה קנץ בינתיים אני הכי אהבתי כי הוא יחסית מהיר ואפילו לא צריך לעשות סיף אתה כותב אות והוא כבר מנסה להרץ ברקע מאוד חמוד עוד שאלות אוקיי אמ לא הנה הפרט window של הtestam דרך אגב

[\[26:52\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1612s) מעניין אני לא רואה פה את הטestטים אבל לא משנה בסדר מה שנעשה עכשיו ניכנס קצת לTDD ואז אנחנו נלך להוספסת הצהריים ואז נחתוך קצת יש פה איזה משהו ששכחתי אוקיי TTD מורכב משלושה חלקים אם עכשיו כתבנו מטestים עכשיו אנחנו נכנס לtest first בtd יש שלושה חלקים בדרך כלל כל אחד מהם מרגיש יותר מבוחך מהשני כשאתה עושה את זה בפעם הראשונה אבל צריך לזכרו שבתהליך הלמידה הרבה פעמים צריך לעשות משהו בזמן מסוים כדי להבין את הוול שלו

[\[27:35\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1655s) אז אם יש משהו אחד שאני מבקש ממכם בשלושה ימים של הקורס הזה לעשות זה להש להישאר עם ראש פתוח ולנסות דברים גם אם אתם מרגישים שהם תקשיים גם אם אתם מרגישים שאתם שאתם חושבים שאתם שזה לא רעיון טוב מבקש ממכם בכל מקרה לעשות את זה להישאר עם ראש פתוח אחד הדברים המעניינים זה שככל שאנחנו עושים את הדבר הזה יותר בדקות בהתחלה כשאנחנו מגיעים לקוד האמיתי לקוד המסובך הצדים האלה שומרים עלינו הרבה יותר זומרת התהליך פה הוא הרבה יותר לעבודה אינקרמנטלית סימפליסיטי

[\[28:06\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1686s) כמשהו שקשה לעשות שאם אתה יודע לעשות אותו בדברים הקלים, בדברים המסובכים הוא מאוד עוזר לך. אז בדברים הקלים הוא נראה מכוח. בדברים המסובכים פתאום הוא נראה מאוד מאוד עוזר. אה אז אז אז הדבר הראשון זה make it fail. בtd הפרק מבחינתי הוא read only. אני לא נוגע בשורת קודק בלי test שנחשב. אוקיי? אני יכול לעשות פקטורים אבל אני לא משנה פונקציונליות. אז מה זה מה ההבדל? מה זה פקטורים? מישהו יודע את ההגדרה?

[\[28:40\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1720s) רפקטורים זה שינוי קוד בלי שינוי פונקציונליות אוקיי עשיתם רני לפונקציה זה נקראפקטורים לקחתם פונקציה ארוכה וחילקתם אותה לחמש פונקציות קטנות זהרפקטור כל זמן שלא שיניתם מה שהיא עושה אז פקטור זה בדרך כלל שינוי המטבילטי של משהו אז אין לי בעיה לשנות קוד ולעשות פקטורing אבל אני לא הוסיף לו פיצ'רים הוא אשנה פיצ'רים קיימים אני מקסימום אשנה את המבנה של הקוד אז אני מתחיל מטest שנכשל אני גורם לטסט לעבור בלי לגעת בטestט. הרבה פעמים אנשים אומרים הטestט נכשל ואז אני משנה את הטestט ואז הוא עובר.

[\[29:13\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1753s) אבל המטרה היא לשנות את הטest כי הטest הוא ההגדרה שלך למה זה ההצלחה. Define success. אז successס זה שאני יכול לעשות ככה וככה. עכשיו לגרום לט לעבור זה to achieve success. לגרום לproductiontion c לעבוד כדי שהטest יעבור. אבל הקט האמיתי הוא שהproduודקש קוד עובד נגרום לו לעבוד בצורה הפשוטה ביותר. הפשטות זה החלק הכי מסובך בדרך כלל בקורס הזה כי המוח שלנו הוא מכוון לעבודה מאוד מאוד גנרית לעבודה מאוד

[\[29:46\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1786s) שעם המון שמורידה את כל הספש שלנו לגבי הקודמה אנחנו נכתוב קוד שיודע לקבל את כל הסוגי האבוד אבל פה אנחנו נוריד את זה אנחנו נדע את זה סוגי אינבות וזה מה שמוביל בין השר לעבודה אינקרמנטלית הרבה פעמים אנחנו מנסים להתחיל לעשות פיצ'ר ואז לוקח לנו שבוע מהפיצ'ר לעבוד אבל היום אנחנו יכולים לעשות פיצ'ר בחלקים קטנים שכל אחד מהם עושה הרבה הנחות יסוד ואז לאט לאט מורידים הנחת יסוד אחת אחרי השנייה דוגמה כמות האינפוטים סוגי האינפוטים אז valing valid val כל אחד מהם הוא פיצר בפני עצמו ואז כל הזמן יש לי משהו שעובד אבל הוא עובד קצת יותר ג'נריק קצת יותר ג'נריק אבל אני מתחיל ממשהו מאוד לא ג'נרי מאוד גנרי

[\[30:29\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1829s) אז כשיש לי את הטest עובר אז אני עושה ריפקטור זאת אומרת אני משנה את הפונקציונליות גם בטestטים וגם בפרדtion. אם אני רק משנה prodctiontion ולא משנה testים אז הטestטים שלי יהיו unreable וmainable. תזכירו גם בטestטים את הרפקטורing אני עושה רק אחרי שהטestטים עוברים בגלל שהמטרה שלי לגרום לפונקציונליות תקיים. אוקיי אז make it better זהctטורing אם אני לא עושה את השלב של הריפקטורing אז הרבה פעמים הסימפליסityי מוביל לקוד מאוד מכוער

[\[31:00\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1860s) ואם אני אשאר עם הקוד המכואר הזה אני לא אהיה מרוצה מהתוצאה למרות שהיא עובדת אבל החלק היפה הוא שכשיש לך טestטים ואתה רואה קוד מכוער אתה יכול לשנות אותו יך לעשות אורי פקטורים כשאין לך טestטים ואתה רואה קוד מכוער אתה עושה קופי פיסט ומוסיף את הפיצ'ר בקוד החדש אחרי זה הקודם גם נראה אוקיי, אז תכף נדבר על simplity. א, בואו עכשיו נוסיף פיצ'רים לקלטור. א, אבל הפיצ'רים שאני אכניס הם

[\[31:33\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1893s) כן, בואו נתחיל. יש לכם איזה רעיון להכניס לפיצר לקלט שלנו? >> מה? >> זה מתמטי. אני רוצה משהו עם לוגיקה משהו שחנו להוסיף לוגיקה לא ייתן לנו לחלק באפסנו לחלק value זה גם ככה המערכתומכת בזה אסור value מה זה לשמור לשמור ערך כדי להשתמש בו מחר כחול פה >> לשמור אה זאת אומרת שיהיה לו ממורי כן >> אוקיי

[\[32:06\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1926s) אז אם אנחנו רוצים להוסיף את הפיצ'ר הזה הדבר האחרון שאנחנו נעשה עושה זה ללכת לפקש פה אני לא מוסיף את הפיצ'ר קודם כל אני כותב טest לדבר הזה אז עכשיו אני רוצה לכתוב את הפיצ'ר אז בואו נתחיל מאיזשהו טestט חדש קודם כל אני מתחיל בטest אז מה המרשפ של הפיצ'רמור >> mורי סצנריו מה מה הסנריו יכול להיות שיש לי הרבה סנר לקלות פה מה הסנריו הכי פשוט לעשות ממור

[\[32:44\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1964s) סט וג אני אם יש set וגט אז מה הכי פשוט ביניהם? >> לאג יש לו דפלט נכון מסכימים איתי? לכל דבר שאתה יכול לעשות עושה יש לו גט ולכן תמיד הגט הוא הראשון ככ כי הטestט הכי פשוט זה טסט שעוד לא עשית גט נכוןס שעוד לא עושים את הסט אוקיי בסדר mורy אז אם אנחנו עושים get set אז אנחנו יכולים פשוט לעשות אפט default defaultט

[\[33:14\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=1994s) מה הדיפולט שלו >> מה כפת אתם defult mורy >> לכתוב mורy by default אבל מה בוא בואו נחשוב מה הב מה הבי של ממורי אז זה הפיצר שלך מה אתה הפרודקט אומר שלך >> אפשר לו לשים לו תוצאה כלשהי >> תוצאה כלשהי אבל הוא לא עשים לו תוצאה זה הטסט הכי פשוט שהוא הוא מחזיר ל מה שיש לו איזשהו אם ש אין לו אפס אחלה returnsים

[\[33:46\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=2026s) להגיד שזה returns default value במקרה שלנו אני בכוונה נפשט את זה ואני אגיד return zero כי במemורy default של מרטג תמיד 0 אוקיי make אטריזל שווה c איך נקרא לה פונקציה get mורy או סתם mורy propפרery זה לא משנה אבל זה כן משנה איך היית רוצה מה ה היה מושלם

[\[34:18\]](https://www.youtube.com/watch?v=_BrBkzT-25U&t=2058s) מה >> getג value get sl >> לא צח אבל get כא כיס value ומה הסרט שלנו יהיה אקול אפס ורס נכון מקובל עליכם הטestט הזה אחלה עכשיו תשימו לב אני קודם כל מסיים את ‏test

## Related

- [Refactoring to parameterized tests](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-2#ch02lev1sec5) · The Art of Unit Testing, 2nd ed., ch. 2

    Refactoring to parameterized tests in NUnit, the same merging of similar tests the lesson does with TestCase.

- [Checking for expected thrown errors](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-2) · The Art of Unit Testing, 3rd ed., ch. 2

    Book section on checking for expected thrown errors, the exception-testing options the lesson compares.

- [More NUnit attributes](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-2#ch02lev1sec6) · The Art of Unit Testing, 2nd ed., ch. 2

    Covers more NUnit attributes, a natural follow-up to the attribute-based setup, teardown and exception tests shown here.

- [Another Entlib example: Separate integration tests from unit tests (and learn to know the difference)](https://osherove.com/blog/2005/4/11/another-entlib-example-separate-integration-tests-from-unit.html) · osherove.com

    Argues for separating integration tests from unit tests, as the lesson does when a TearDown signals an integration test.

### Also linked in this lesson

#### The Art of Unit Testing, 3rd ed.

- [Setting up and tearing down](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-9#sigil_toc_id_171), ch. 9
- [Integration tests](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_25), ch. 1
- [Test-driven development](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_27), ch. 1
- [Defining unit testing, step by step](https://livebook.manning.com/book/the-art-of-unit-testing-third-edition/chapter-1#sigil_toc_id_17), ch. 1

#### The Art of Unit Testing, 2nd ed.

- [First steps with NUnit](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-2#ch02lev1sec3), ch. 2
- [Test-driven development](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-1#ch01lev1sec6), ch. 1
- [Integration tests](https://livebook.manning.com/book/the-art-of-unit-testing-second-edition/chapter-1#ch01lev1sec3), ch. 1

[Previous lesson Test Demo](https://courses.osherove.com/courses/tdd-in-net-in-hebrew/test-demo/) [Next lesson TDD Demo](https://courses.osherove.com/courses/tdd-in-net-in-hebrew/tdd-demo/)


---

## About the author

**Roy Osherove**: Senior Solutions Architect at AWS working on AI for production and AI-driven development; author of The Art of Unit Testing and Elastic Leadership, with about 20 years of consulting and training on unit testing, TDD, team leadership and continuous delivery.

### Sites

- [RobotPaper](https://robotpaper.ai/): This blog: AI patterns and anti-patterns, AI and coding agents, and engineering leadership.
- [osherove.com](https://osherove.com): Roy's personal site. Author of The Art of Unit Testing and Elastic Leadership; consulting and training on unit testing, TDD, team leadership and continuous delivery, plus about 20 years of blog posts.
- [The Art of Unit Testing](https://www.artofunittesting.com): The Art of Unit Testing, 3rd Edition (Manning): readable, maintainable, trustworthy unit tests, plus TDD workshops in C#, JavaScript, Java and Kotlin.
- [5whys.com](https://www.5whys.com): Roy's writing on software team leadership: self-organizing teams, surviving chaos, learning mode and the Elastic Leadership model.
- [Pipeline Driven](https://pipelinedriven.org): Continuous delivery and DevOps practices: build patterns, pipeline-friendly testing, DevOps metrics and enterprise DevOps.
- [Elastic Leadership](https://www.elasticleadership.com): Elastic Leadership, Roy's framework for software team leaders (survival, learning and self-organizing modes).

### Social

- X: https://x.com/royosherove
- LinkedIn: https://www.linkedin.com/in/osherove/

### Contact

- Contact form: https://forms.gle/jQSx5KoXvrVA1JCK7

### License

Licensed under CC BY 4.0 — reuse, quote and adapt with attribution (Roy Osherove, link to the original page). License: https://creativecommons.org/licenses/by/4.0/