Saturday, June 22, 2013

Why I Re-activated my Facebook Account

Last week I had had enough of Facebook. The most recent issue I've had with it is how spammers are now using your social network graph to make spam look more like legitimate emails by adding from names and cc'ing real people. 

So I left Facebook.

Well actually I am a coward so I only deactivated my account. And for the last week I haven't missed it one bit. 

Then last night I had a vivid dream about my dad, who lost his battle with cancer last August. When I awoke I remembered the dream so vividly and I was overcome with the feeling that if I ever decided to come back to Facebook, my dad would not be there to accept my friend request.

There are a few other friends I have lost in the last couple of years and I find myself occasionally visiting their walls to read the words from others who share the sadness from them missing in our lives. 

So today I re-activated my account. To bring me comfort that there's a virtual space for me to reflect on the loved ones who can no longer accept my friend requests. 

Tuesday, March 5, 2013

Nooks & Crannies

Today I used two features in NUnit that I have never used before and I thought I would share for those who have yet to discover these great features as well.

TestFixture Parameters

Did you know that the TestFixtureAttribute can take parameters?

   1:  [TestFixture("My Name")]

Did you know that you can place more than one on your class?

   1:  [TestFixture("My Name")]
   2:  [TestFixture("Your Name")]
   3:  public class SimpleTests
   4:  {
   5:  }

I have recently been writing normal NUnit tests in a BDD influenced style. I know there are frameworks like SpecFlow and machine.specifications that are better then what I am doing, but at work I am trying to reduce the number of frameworks I introduce in a week, and those two are pretty invasive in that they both require VS2102 integrations for their maximum benefit.

For my BDD-ish test I have taken to making test fixtures that look like this

   1:  [TestFixture]
   2:  public class SimpleGreeterTests
   3:  {
   4:      [SetUp]
   5:      public void SetUp()
   6:      {
   7:          EstablishContext();
   8:          given_I_have_a_name();
   9:          when_the_greeter_greets();
  10:      }
  12:      [Test]
  13:      public void then_the_greeting_should_say_hello()
  14:      {
  15:          Assert.That(Result, Is.EqualTo(string.Format("Hello {0}", Name)));
  16:      }
  18:      protected string Name { get; set; }
  19:      protected IGreeter Subject { get; set; }
  20:      protected string Result { get; set; }
  22:      protected void EstablishContext()
  23:      {
  24:          Subject = new Greeter();
  25:      }
  27:      protected void given_I_have_a_name()
  28:      {
  29:          Name = RandomDataHelper.Get<string>();
  30:      }
  32:      protected void when_the_greeter_greets()
  33:      {
  34:          Result = Subject.Greet(Name);
  35:      }
  36:  }

This pattern is something I am really enjoying and not the real topic here.

Today I created a test very similar in nature to this. I my case I need to code to return something different based on specific values of name. I thought I would have to write multiple suites. I knew I could execute a test multiple times with the TestCase attribute, but with this BDD structure to my tests, I needed the data to vary within the scope of the SetUp method.

Luckily NUnit introduced TestFixture parameters in 2.5. Which allowed me to make a test like this

   1:  [TestFixture("Jimmy", "Hello Mr. Bosse")]
   2:  [TestFixture("Lisa", "Hello Mrs. Bosse")]
   3:  public class SimpleGreeterTests
   4:  {
   5:      [SetUp]
   6:      public void SetUp()
   7:      {
   8:          EstablishContext();
   9:          given_my_name_is(_name);
  10:          when_the_greeter_greets();
  11:      }
  13:      [Test]
  14:      public void then_the_greeting_should_say_hello()
  15:      {
  16:          Assert.That(Result, Is.EqualTo(_greeting));
  17:      }
  19:      protected string Name { get; set; }
  20:      protected IGreeter Subject { get; set; }
  21:      protected string Result { get; set; }
  23:      public SimpleGreeterTests(string name, string greeting)
  24:      {
  25:          _name = name;
  26:          _greeting = greeting;
  27:      }
  29:      protected void EstablishContext()
  30:      {
  31:          Subject = new Greeter();
  32:      }
  34:      protected void given_I_have_a_name(string name)
  35:      {
  36:          Name = name;
  37:      }
  39:      protected void when_the_greeter_greets()
  40:      {
  41:          Result = Subject.Greet(Name);
  42:      }
  43:  }


The next little gem I discovered was the more robust asserts NUnit lets you do against collections. For years I have been testing that my arrays contain the same elements

Assert.That(thisArray, Is.EquivalentTo(thatArray));

but today I needed to make sure my array was in the correct order. Through the magic of intellisense I was able to find this little nugget

Assert.That(thisArray, Is.Ordered.By("LastName"));

Lesson Learned

While my approach to new frameworks is often to find out just enough to get me going on the thing I  am building right now, I think I will try harder to fight TL;DR; and spend more time in the nooks and crannies.

Follow me on