Loading ...
Sorry, an error occurred while loading the content.

TDD/unit testing in a team without unit testing

Expand Messages
  • Lukasz Szyrmer
    Hi all, Just wondering if anyone might have some experience with or know of some good resources on doing TDD within a team that doesn t feel strongly about
    Message 1 of 10 , Jan 11, 2012
    • 0 Attachment
      Hi all,

      Just wondering if anyone might have some experience with or know of some good resources on doing TDD within a team that doesn't feel strongly about automated testing. Ron Jeffries mentions such a concept in passing in his book Extreme Programming Adventures in C#.

      Generally speaking, I can see the benefits of unit testing. We do some interface level-behavioural testing, particularly where it's easy, but I'm not sure if we're really getting the benefit from our efforts.

      We already have a CI environment which builds on every check-in, and this is quite useful. On some of our programs, tests are somewhat hard to write, as most of our desktop programs are traditional desktop (Borland) C++ apps with windows UIs, so there isn't a separation of concerns like with MVVM in WPF for example.

      In particular, is there a good way of writing tests against one class without being too disruptive for the project? Are there any intermediate steps possible? For example, are there any easy ways to unit test a specific fragile class? Is this just an issue of figuring out how to apply dependency injection in this context? Does it make sense to pull the class out context?

      I realize it would be good to get everyone on board with TDD on one hand, and lower-level unit testing on the other, but it's hard to sell if I have little experience with it.

      Luke


      Linedata Limited
      Registered Office: 85 Gracechurch St., London, EC3V 0AA
      Registered in England and Wales No 3475006 VAT Reg No 710 3140 03





      [Non-text portions of this message have been removed]
    • Daniel Wildt
      What we have done in our company was to create a coding dojo ( http://codingdojo.org/) space every week. The team started to play with TDD more and more and
      Message 2 of 10 , Jan 11, 2012
      • 0 Attachment
        What we have done in our company was to create a coding dojo (
        http://codingdojo.org/) space every week. The team started to play with TDD
        more and more and few weeks after, they were building unit tests using a
        test first approach.

        Coding Dojos create confidence and they create a more "humble" space for
        learning.

        Regards,
        Daniel Wildt
        http://danielwildt.com


        On Wed, Jan 11, 2012 at 8:45 AM, Lukasz Szyrmer <
        lukasz.szyrmer@...> wrote:

        > Hi all,
        >
        > Just wondering if anyone might have some experience with or know of some
        > good resources on doing TDD within a team that doesn't feel strongly about
        > automated testing. Ron Jeffries mentions such a concept in passing in his
        > book Extreme Programming Adventures in C#.
        >
        > Generally speaking, I can see the benefits of unit testing. We do some
        > interface level-behavioural testing, particularly where it's easy, but I'm
        > not sure if we're really getting the benefit from our efforts.
        >
        > We already have a CI environment which builds on every check-in, and this
        > is quite useful. On some of our programs, tests are somewhat hard to write,
        > as most of our desktop programs are traditional desktop (Borland) C++ apps
        > with windows UIs, so there isn't a separation of concerns like with MVVM in
        > WPF for example.
        >
        > In particular, is there a good way of writing tests against one class
        > without being too disruptive for the project? Are there any intermediate
        > steps possible? For example, are there any easy ways to unit test a
        > specific fragile class? Is this just an issue of figuring out how to apply
        > dependency injection in this context? Does it make sense to pull the class
        > out context?
        >
        > I realize it would be good to get everyone on board with TDD on one hand,
        > and lower-level unit testing on the other, but it's hard to sell if I have
        > little experience with it.
        >
        > Luke
        >
        >
        > Linedata Limited
        > Registered Office: 85 Gracechurch St., London, EC3V 0AA
        > Registered in England and Wales No 3475006 VAT Reg No 710 3140 03
        >
        >
        >
        >
        >
        > [Non-text portions of this message have been removed]
        >
        >
        >
        > ------------------------------------
        >
        > To Post a message, send it to: extremeprogramming@...
        >
        > To Unsubscribe, send a blank message to:
        > extremeprogramming-unsubscribe@...
        >
        > ad-free courtesy of objectmentor.comYahoo! Groups Links
        >
        >
        >
        >


        [Non-text portions of this message have been removed]
      • Wouter Lagerweij
        Hi Lukasz, Getting people enthused about TDD can be hard, the best way is probably to show them. Daniel s suggestion of a coding dojo is a good one. Expect a
        Message 3 of 10 , Jan 11, 2012
        • 0 Attachment
          Hi Lukasz,

          Getting people enthused about TDD can be hard, the best way is probably to
          show them. Daniel's suggestion of a coding dojo is a good one. Expect a
          difficult start if no-one has done TDD before, though. Watch some of Jim
          Shore's (http://jamesshore.com/Blog/) or Kent Beck;s (
          http://pragprog.com/screencasts/v-kbtdd/test-driven-development) videos
          together, for instance, to get an idea of how to begin.

          As you've been noticing code not written test-first can be hard to test.
          This is usually because it's more tightly coupled (with either other
          project code, or with frameworks used) than it really should be.
          Initially you will need to write some higher level tests around such a
          fragile class you're talking about, which will probably test not just that
          class, but some of the surroundings (possibly mocking/faking some
          dependencies). When you're sure you are safe, you can start refactoring the
          class to make things more testable. All of this can be done while leaving
          the rest of the system as-is. And this is a great way to get started.
          Usually, you'll find some bugs in the process, which can help getting
          others involved.

          hth,

          Wouter

          On Wed, Jan 11, 2012 at 11:45 AM, Lukasz Szyrmer <
          lukasz.szyrmer@...> wrote:

          > **
          >
          >
          > Hi all,
          >
          > Just wondering if anyone might have some experience with or know of some
          > good resources on doing TDD within a team that doesn't feel strongly about
          > automated testing. Ron Jeffries mentions such a concept in passing in his
          > book Extreme Programming Adventures in C#.
          >
          > Generally speaking, I can see the benefits of unit testing. We do some
          > interface level-behavioural testing, particularly where it's easy, but I'm
          > not sure if we're really getting the benefit from our efforts.
          >
          > We already have a CI environment which builds on every check-in, and this
          > is quite useful. On some of our programs, tests are somewhat hard to write,
          > as most of our desktop programs are traditional desktop (Borland) C++ apps
          > with windows UIs, so there isn't a separation of concerns like with MVVM in
          > WPF for example.
          >
          > In particular, is there a good way of writing tests against one class
          > without being too disruptive for the project? Are there any intermediate
          > steps possible? For example, are there any easy ways to unit test a
          > specific fragile class? Is this just an issue of figuring out how to apply
          > dependency injection in this context? Does it make sense to pull the class
          > out context?
          >
          > I realize it would be good to get everyone on board with TDD on one hand,
          > and lower-level unit testing on the other, but it's hard to sell if I have
          > little experience with it.
          >
          > Luke
          >
          > Linedata Limited
          > Registered Office: 85 Gracechurch St., London, EC3V 0AA
          > Registered in England and Wales No 3475006 VAT Reg No 710 3140 03
          >
          > [Non-text portions of this message have been removed]
          >
          >
          >



          --
          Wouter Lagerweij | wouter@...
          http://www.lagerweij.com | @wouterla <http://twitter.com/#!/wouterla>


          [Non-text portions of this message have been removed]
        • Chris Hulan
          Don t know if it will help sell your team on unit tests, but Michael Feathers _Working Effectively with Legacy Code_ is the bible for how to add tests to
          Message 4 of 10 , Jan 11, 2012
          • 0 Attachment
            Don't know if it will help sell your team on unit tests,
            but Michael Feathers' _Working Effectively with Legacy Code_ is the bible for
            how to add tests to existing code with minimum disruption.

            cheers
          • Steven Solomon
            It is hard. right now i am working on a web team. we had CI but no unit tests or acceptance tests. my strategy is adding those as I change things but keep them
            Message 5 of 10 , Jan 11, 2012
            • 0 Attachment
              It is hard. right now i am working on a web team. we had CI but no unit
              tests or acceptance tests. my strategy is adding those as I change things
              but keep them out of the
              CI script (they don't run on the build, because Im not forcing TDD on my
              coworkers) so while adding tests I occasionally pull them over for a second
              and let them know what I am doing.
              Hopefully combining non breaking code and a non aggressive tdd evangelism
              will get results but we will see

              On Wed, Jan 11, 2012 at 9:28 AM, Chris Hulan <chris.hulan@...> wrote:

              > **
              >
              >
              > Don't know if it will help sell your team on unit tests,
              > but Michael Feathers' _Working Effectively with Legacy Code_ is the bible
              > for
              > how to add tests to existing code with minimum disruption.
              >
              > cheers
              >
              >


              [Non-text portions of this message have been removed]
            • George Dinwiddie
              Lukasz, ... I second Chris recommendation of WELC and suggest you pair it with the Mikado Method (http://mikadomethod.wordpress.com/book/) - George -- ... *
              Message 6 of 10 , Jan 11, 2012
              • 0 Attachment
                Lukasz,

                On 1/11/12 9:28 AM, Chris Hulan wrote:
                > Don't know if it will help sell your team on unit tests,
                > but Michael Feathers' _Working Effectively with Legacy Code_ is the bible for
                > how to add tests to existing code with minimum disruption.

                I second Chris' recommendation of WELC and suggest you pair it with the
                Mikado Method (http://mikadomethod.wordpress.com/book/)

                - George

                --
                ----------------------------------------------------------------------
                * George Dinwiddie * http://blog.gdinwiddie.com
                Software Development http://www.idiacomputing.com
                Consultant and Coach http://www.agilemaryland.org
                ----------------------------------------------------------------------
              • Charlie Poole
                Hi George, I hadn t come across that before myself but it looks interesting. Thanks! Charlie On Wed, Jan 11, 2012 at 11:11 AM, George Dinwiddie ... [Non-text
                Message 7 of 10 , Jan 11, 2012
                • 0 Attachment
                  Hi George,

                  I hadn't come across that before myself but it looks interesting. Thanks!

                  Charlie

                  On Wed, Jan 11, 2012 at 11:11 AM, George Dinwiddie
                  <lists@...>wrote:

                  > **
                  >
                  >
                  > Lukasz,
                  >
                  > On 1/11/12 9:28 AM, Chris Hulan wrote:
                  > > Don't know if it will help sell your team on unit tests,
                  > > but Michael Feathers' _Working Effectively with Legacy Code_ is the
                  > bible for
                  > > how to add tests to existing code with minimum disruption.
                  >
                  > I second Chris' recommendation of WELC and suggest you pair it with the
                  > Mikado Method (http://mikadomethod.wordpress.com/book/)
                  >
                  > - George
                  >
                  > --
                  > ----------------------------------------------------------
                  > * George Dinwiddie * http://blog.gdinwiddie.com
                  > Software Development http://www.idiacomputing.com
                  > Consultant and Coach http://www.agilemaryland.org
                  > ----------------------------------------------------------
                  >
                  >
                  >


                  [Non-text portions of this message have been removed]
                • james@renaissancesoftware.net
                  Hello Luke I just wrote a blogpost about why manual test is unsustainable. It is not a article about TDD though it might give some insight into the need for
                  Message 8 of 10 , Jan 11, 2012
                  • 0 Attachment
                    Hello Luke

                    I just wrote a blogpost about why manual test is unsustainable. It is not a article about TDD though it might give some insight into the need for automated tests. The other recomendations people made on the list are good ones.

                    http://www.renaissancesoftware.net/blog/archives/206

                    There are lot's of good reasons to do TDD. The most compelling one for new people in my opinion is defect prevention. Here's an article about that

                    http://www.renaissancesoftware.net/blog/archives/16

                    I've got some other articles onTDD that might help make a case to get some people to try TDD.

                    thanks, James

                    --------------------------------------------------------------------------------------------
                    James Grenning Author of TDD for Embedded C
                    www.renaissancesoftware.net http://pragprog.com/titles/jgade/
                    www.renaissancesoftware.net/blog
                    www.twitter.com/jwgrenning

                    On Jan 11, 2012, at 4:45 AM, Lukasz Szyrmer wrote:

                    > Hi all,
                    >
                    > Just wondering if anyone might have some experience with or know of some good resources on doing TDD within a team that doesn't feel strongly about automated testing. Ron Jeffries mentions such a concept in passing in his book Extreme Programming Adventures in C#.
                    >
                    > Generally speaking, I can see the benefits of unit testing. We do some interface level-behavioural testing, particularly where it's easy, but I'm not sure if we're really getting the benefit from our efforts.
                    >
                    > We already have a CI environment which builds on every check-in, and this is quite useful. On some of our programs, tests are somewhat hard to write, as most of our desktop programs are traditional desktop (Borland) C++ apps with windows UIs, so there isn't a separation of concerns like with MVVM in WPF for example.
                    >
                    > In particular, is there a good way of writing tests against one class without being too disruptive for the project? Are there any intermediate steps possible? For example, are there any easy ways to unit test a specific fragile class? Is this just an issue of figuring out how to apply dependency injection in this context? Does it make sense to pull the class out context?
                    >
                    > I realize it would be good to get everyone on board with TDD on one hand, and lower-level unit testing on the other, but it's hard to sell if I have little experience with it.
                    >
                    > Luke
                    >
                    > Linedata Limited
                    > Registered Office: 85 Gracechurch St., London, EC3V 0AA
                    > Registered in England and Wales No 3475006 VAT Reg No 710 3140 03
                    >
                    > [Non-text portions of this message have been removed]
                    >
                    >



                    [Non-text portions of this message have been removed]
                  • Lukasz Szyrmer
                    George, Thanks for the Mikado method reference, as I wasn t aware of that one. Looks fantastic, because it seems to address the business payoff of using TDD
                    Message 9 of 10 , Jan 12, 2012
                    • 0 Attachment
                      George,

                      Thanks for the Mikado method reference, as I wasn't aware of that one. Looks fantastic, because it seems to address the business payoff of using TDD while refactoring (i.e. not adding new features). I'm concerned about spending a lot of time (more importantly convincing others to spend lots of their time) on something that ends up proving largely what I already know, so hopefully that will clear things up a bit.

                      Luke



                      Linedata Limited
                      Registered Office: 85 Gracechurch St., London, EC3V 0AA
                      Registered in England and Wales No 3475006 VAT Reg No 710 3140 03



                      From: extremeprogramming@yahoogroups.com [mailto:extremeprogramming@yahoogroups.com] On Behalf Of George Dinwiddie
                      Sent: 11 January 2012 19:12
                      To: extremeprogramming@yahoogroups.com
                      Subject: Re: [XP] TDD/unit testing in a team without unit testing
                      Importance: High



                      Lukasz,

                      On 1/11/12 9:28 AM, Chris Hulan wrote:
                      > Don't know if it will help sell your team on unit tests,
                      > but Michael Feathers' _Working Effectively with Legacy Code_ is the bible for
                      > how to add tests to existing code with minimum disruption.

                      I second Chris' recommendation of WELC and suggest you pair it with the
                      Mikado Method (http://mikadomethod.wordpress.com/book/)

                      - George

                      --
                      ----------------------------------------------------------
                      * George Dinwiddie * http://blog.gdinwiddie.com
                      Software Development http://www.idiacomputing.com
                      Consultant and Coach http://www.agilemaryland.org
                      ----------------------------------------------------------



                      [Non-text portions of this message have been removed]
                    • Steve Freeman
                      It looks like you re in London. You should consider bringing a laptop to the eXtreme Tuesday Club and asking for help.
                      Message 10 of 10 , Jan 14, 2012
                      • 0 Attachment
                        It looks like you're in London. You should consider bringing a laptop to the eXtreme Tuesday Club and asking for help.

                        http://xpday-london.editme.com/MeetingsSchedule2009

                        S.

                        On 11 Jan 2012, at 10:45, Lukasz Szyrmer wrote:
                        > Just wondering if anyone might have some experience with or know of some good resources on doing TDD within a team that doesn't feel strongly about automated testing. Ron Jeffries mentions such a concept in passing in his book Extreme Programming Adventures in C#.
                        >
                        > Generally speaking, I can see the benefits of unit testing. We do some interface level-behavioural testing, particularly where it's easy, but I'm not sure if we're really getting the benefit from our efforts.
                        >
                        > We already have a CI environment which builds on every check-in, and this is quite useful. On some of our programs, tests are somewhat hard to write, as most of our desktop programs are traditional desktop (Borland) C++ apps with windows UIs, so there isn't a separation of concerns like with MVVM in WPF for example.
                        >
                        > In particular, is there a good way of writing tests against one class without being too disruptive for the project? Are there any intermediate steps possible? For example, are there any easy ways to unit test a specific fragile class? Is this just an issue of figuring out how to apply dependency injection in this context? Does it make sense to pull the class out context?
                        >
                        > I realize it would be good to get everyone on board with TDD on one hand, and lower-level unit testing on the other, but it's hard to sell if I have little experience with it.
                        >
                        > Luke
                        >
                        >
                        > Linedata Limited
                        > Registered Office: 85 Gracechurch St., London, EC3V 0AA
                        > Registered in England and Wales No 3475006 VAT Reg No 710 3140 03
                        >
                        >
                        >
                        >
                        >
                        > [Non-text portions of this message have been removed]
                        >

                        Steve Freeman
                        http://www.mockobjects.com
                        http://www.growing-object-oriented-software.com

                        Winner of the Agile Alliance Gordon Pask award 2006




                        Steve Freeman

                        Winner of the Agile Alliance Gordon Pask award 2006
                        Book: http://www.growing-object-oriented-software.com

                        +44 797 179 4105
                        Twitter: @sf105
                        Higher Order Logic Limited
                        Registered office. 2 Church Street, Burnham, Bucks, SL1 7HZ.
                        Company registered in England & Wales. Number 7522677
                      Your message has been successfully submitted and would be delivered to recipients shortly.