Besides the information available on the Octopress website, here are the steps I had to take:

1. Install Octopress.
2. Download Exitwp and install its dependencies.
3. Upgrade Wordpress install to version later than 3.1 to be compatible with Exitwp.
4. Enable Disqus on Wordpress and export comments. Also, disqus was configured in the Octopress configuration.
5. In Wordpress, under Tools->Export, generate an xml file for the website. Run Exitwp on this file to generate the posts in Markdown.
6. The comments are turned off in these posts. I ran the following script (found in comments here) in terminal to turn comments on:

    for I in *.markdown; do sed -i '' -e ':a' -e 'N' -e '$!ba' -e 's/\n---\n/\
    comments: true\
    ---\
    /' "$I"; 
   

7. Generate aliases for posts/pages if you want to maintain your old urls by adding the Jekyll Alias Generator plugin.
8. Deploy to heroku.
9. Point domain to heroku.

You spend almost than half your waking hours at your job. Your job satisfaction will have a big impact over your happiness, and you owe it to yourself to work at a job that love. Before we discuss how you can improve yourself as a developer, make sure that you are in this for the right reasons. Quoting Jeff Atwood:

Be realistic: are you programming to collect a paycheck, or are you programming because you are driven to? I know this sounds harsh, but it’s an economic reality– in an environment of global offshoring, the world simply can’t support any more highly paid mediocre coders. There are a hundred thousand well educated Indian developers who will do what you do at a fraction of the price, and thousands more coming of age in other third world countries. Blame the Internet if you want, but just being “good with computers” is no longer a free ticket to a high paying tech job.

Your college education will teach you to be competent (at the best) when you graduate. That might not be enough to get you the job you want. At his talk at Business of Software 2010, Seth Godin emphasized his preference for brilliant vs competent programmers

If there’s any job that could be written down, it gets done by freelancer. Because if we can write down exactly what we want, why on earth we need a brilliant person to do it? We get a competent person to do it. There are no competent people that work at our company.

Here are 10 things that can help you on your journey to improve as a developer:

1. Empty your cup
As you learn new technologies and ways of doing things, don’t let what you know right now interfere with the learning process.

2. Read more books Get in the habit of reading books (technical or otherwise) regularly. I recommend that you start with the following 3
The Pragmatic Programmer

Joel On Software

Getting Things Done

Ask the people you admire for books that significantly influenced them. Check out Jeff Atwood’s and Scott Hanselman’s recommendations.

3. Read Code
Try to read more code from other programmers. You will pick up useful gems from seeing how they work. Check out the Weekly Source Code posts by Scott Hanselman if you are looking for a place to start.

4. Meet other passionate developers

Try and attend as many user groups, conferences, coding dojos and nerd dinners as you can. You can find local events at www.communitymegaphone.com.
You are the average of five people you spend the most time with. Education is in a way soaking up knowledge from people smarter than you. College is one place to do that, where you learn from your professors, but it might nor be the most  efficient way. Try and find a mentor, but be respectful of his/her time. You should not be asking them for answers that a simple Google Search can provide you.

(Your goal is not to exploit your friends, but remember that most job positions are filled by recommendations/references from other employees rather than through job boards.)

5. Social Media
Use Google Reader, or a RSS feed aggregator of your choice and keep up with blogs of other developers. A few to get started are Scott Hanselman’s blog, CodeBetter, CodingHorror, The Morning Brew, DZone and Rands In Repose.

Podcasts are another excellent way to learn about the latest and the greatest going on in the tech world. My favorites are .Net Rocks, Hanselminutes, The Startup Success Podcast and Herding Code.

You can pick up a lot on Twitter, depending on whom you are following. I also learn a lot by monitoring sites such as Hacker News.

6. Help Others

An excellent way to learn is to help other people with their problems. You can try contributing to open source projects, answering questions on Stack Overflow or even building an application that satisfies somebody’s needs.
7. Certifications
This is kind of a mixed bag. Just having a certification may or may not help your personal brand, but preparing for a certification is a great way to pick up the basics in a new technology and timeboxing it at the same time.

8. Don’t restrict yourself to one platform

Technologies, frameworks will come and go many times during your career. Try to be a well rounded developer and pick up the good parts from multiple technologies rather than invest all your time in one particular one.
9. Write (more) code
Try to work on a side project to play around with technologies you don’t get to use at your day job. Also, code katas are an excellent way to hone your craft.

10. Share what you learn

If you try to teach something to your friends, you’ll end up mastering the topic yourself in the process. Try and host technical brownbags, or volunteer to present at a user group meeting. The fear of public embarrassment due to not knowing your subject well is a great motivator to understand something inside out.
A few more general tips before finishing this:

1. Work Out: Take care your body, or you will pay the price later. When Richard Branson was asked on how one can became more productive, his answer was to work out. He said that it gave him an additional four hours of productive time everyday.

2. Take Breaks: Take regular breaks from your computer. It’s very easy to get burnt out by working too hard.

3. Use the 80/20 principle: Use the Pareto’s principle to your advantage. It’ll take you 20% time to learn 80% of the programming language or framework you are trying to learn and vice versa. You do not need to know 100% of a language before starting to work in it, so plan accordingly.

4. Invest in the best hardware and software you can afford: You are going to spend a lot of time on your computer. Even though I am a big fan of frugality as well as minimalism, this is one place I do not recommend that you try to save money. Use what makes you the most effective.

5. Stay hungry, Stay foolish: Steve Jobs ended his Stanford commencement speech with these words. I try to remind myself about those words regularly, and I honestly can’t think of anything better to tell you.

1. AutoUpdate: You can enable autoupdate of installed extensions now, instead of manually having to install updates to all your extensions. Previously, you had to do this manually.

2. Logging: The ExtensionSync activity can now be logged to a file.

3. ExtensionSync now watches for file change and updates extensions on settings file change rather than on Visual Studio startup. This feature was added after I found that some of the users use ExtensionSync to share extensions with other devs, and that the settings file can be updated while a Visual Studio instance is still open.

All the settings can be configured in Tools->Options->ExtensionSync.

The code is available on github. If you face any problems with the extension, please open a bug there.

1. Launch Git Bash. If you access TFS from a different account than what you are logged in as, you can launch it under the TFS account by entering the following at Start->Run
   runas /netonly /user:your_domain\your_user_name “cmd /c sh –login -i”

(sh.exe resides at “C:\Program Files (x86)\Git\bin” on my computer which is added to the PATH variable.)

1. Navigate to the directory you want to work in and clone the TFS repository using “git tfs clone repository_url source_path”. You can use the “quick-clone” option if you want just the snapshot of the latest code rather than the complete history. I setup a test project on Codeplex to play with git-tfs, and I had to issue the following command to get the complete repository:
   git tfs clone https://tfs.codeplex.com/tfs/tfs24 $/gittfstest

2. Now you can work offline. Add gitignore file to ignore bin directories, temporary files etc, and open your project and make your changes. Visual Studio will warn you on opening the project that TFS is unavailable, since you do not have the code in TFS mapped to this directory. Just choose the “Temporarily work uncontrolled” option.

1. You can commit to your local git repository at any time you want. Whenever you are ready to commit back to TFS, you have 3 options:
   1. git tfs checkin: Allows you to check in code directly into TFS. Can associate the change with commit message, work items etc.
   2. git tfs checkintool: Allows you to review your changes in the TFS check in tool before checking them in.

3. git tfs shelve: Creates a shelveset that you can review and check in. 

1. Whenever you are ready to pull the latest code changes from TFS, use
   git tfs pull

You can download the extension from the Gallery, or by searching for ExtensionSync in the Visual Studio Extension Manager. Once the extension has been installed, configure the directory you want to use for storing your settings by going to Tools->Options->ExtensionSync. Visual Studio will save your settings in this directory every time it closes, and it’ll also read the settings file and update extension every time it starts (It also does this when you configure a new Settings directory, but this should be a one time thing). I recorded a screencast to explain the workflow. This is my first screencast, hopefully the quality improves as I practice more .

I think Microsoft would probably roll out something like this as a part of Visual Studio sometime down the line. It would be nice to use the cloud and have Visual Studio remember all my settings for me (Maybe the user’s settings could be associated with his Windows Live ID). Till then, I hope my extension can be of some use to you.

Update: I got back feedback from a user that Visual Studio was crashing for him while syncing with Windows Live Mesh. I have not been able to replicate the issue, but if you face any problems, deleting the settings file should let you get back to normal. You can also file an issue on Github, if you find any. I would love to get some feedback (good or bad). Update2: The issue should hopefully be fixed with version 0.1.2. This extension can only synchronize VSIX extensions and not those installed by MSIs. Hat Tip to Graeme Foster and @efvincent for helping me replicate the issue.

I have had a Visual Studio macro for a long time that kills all the instances of the local Asp.Net Development Server, but in the interest of sharing it more easily with my peers, and to play around with Visual Studio 2010 extensibility, I have written a Visual Studio extension that allows you to do the same. You can get the extension here. If you want to play around with the code or change something, you can access the code on GitHub. Once you download the extension and install it, it’ll show up under your Tools Menu in Visual Studio.

You can change your keybinding by going under Tools->Options->Keyboard and searching for KillCassini.

And that’s it. You can invoke the extension by using the Tools Menu or your keyboard shortcut. If you are interested in what the extension is doing, it writes down some information in the Debug Output Window every time you run it.

One of the problems I used to face with my Visual Studio Macro for doing the same was that the orphaned icon for the killed server process used to stay around till you hovered your mouse over it. This is not a problem for most people (unless your OCD runs as deep as me). In this extension, I have made an attempt to rectify that problem by refreshing the Taskbar System tray. This seems to work on my system at least (64 bit Windows 7).

It has been fun playing with the Visual Studio extensibility and I hope to work on some more extensions in the near future.

using System;

using System.Runtime.InteropServices;

using Microsoft.VisualStudio.OLE.Interop;

internal class TaskBarUtil
{
    public static void RefreshNotificationArea()
    {
        var notificationAreaHandle = GetNotificationAreaHandle();  
        if (notificationAreaHandle == IntPtr.Zero)
            return;  
        RefreshWindow(notificationAreaHandle);
    }  
    private static void RefreshWindow(IntPtr windowHandle)
    {
        const uint wmMousemove = 0x0200;
        RECT rect;
        GetClientRect(windowHandle, out rect);  
        for (var x = 0; x < rect.right; x += 5)
            for (var y = 0; y < rect.bottom; y += 5)
                SendMessage(
                    windowHandle,
                    wmMousemove,
                    0,
                    (y << 16) + x);
    }  
    private static IntPtr GetNotificationAreaHandle()
    {
        const string notificationAreaTitle = "Notification Area";
        const string notificationAreaTitleInWindows7 = "User Promoted Notification Area";  
        var systemTrayContainerHandle = FindWindowEx(IntPtr.Zero, IntPtr.Zero,
                                                    "Shell_TrayWnd", string.Empty);
        var systemTrayHandle = FindWindowEx(systemTrayContainerHandle, IntPtr.Zero,
                                                    "TrayNotifyWnd", string.Empty);
        var sysPagerHandle = FindWindowEx(systemTrayHandle, IntPtr.Zero, "SysPager", 
                                                    string.Empty);
        var notificationAreaHandle = FindWindowEx(sysPagerHandle, IntPtr.Zero, 
                                                    "ToolbarWindow32", 
                                                    notificationAreaTitle);  
        if (notificationAreaHandle == IntPtr.Zero)
            notificationAreaHandle = FindWindowEx(sysPagerHandle, IntPtr.Zero, 
                                                    "ToolbarWindow32",
                                                    notificationAreaTitleInWindows7);
        return notificationAreaHandle;
    }  
    [DllImport("user32.dll", SetLastError = true)]
    static extern IntPtr FindWindowEx(IntPtr parentHandle, IntPtr childAfter, 
                                                    string className, 
                                                    string windowTitle);  
    [DllImport("user32.dll")]
    static extern bool GetClientRect(IntPtr handle, out RECT rect);  
    [DllImport("user32.dll", CharSet = CharSet.Auto)]
    static extern IntPtr SendMessage(IntPtr handle, UInt32 message, Int32 wParam, 
                                                    Int32 lParam);
}

The book breaks down the technique into 5 stages:

1. Planning: Extract the most important things from your overall task list into your daily to-do list. This is done once at the beginning of the day.
2. Tracking: Track metrics per pomodoro, like interruptions, completed vs abandoned pomodoro, etc.
3. Recording: File your observations at the end of the day.
4. Processing: Analyze your recorded raw data and turn it into information you can act on.
5. Visualizing: Organize the information to improve your process.

A couple of other things from the book that I need to remember:

• Work on the most important thing on your daily to-do list.
• If you can’t help but interrupt your pomodoro, void it, take a break and start a new one rather than pausing and resuming the current one.
• We procrastinate because it gives us temporary relief from the stress of doing the task.
• Estimation is just guessing based on empirical knowledge. A good way to estimate the number of pomodori you will finish today is to look at how many you did yesterday.
• If an activity estimate is bigger than 7 pomodori, break it down into smaller activities.
• Make sure you do not try to get things done like responding to email in your rest period between different pomodori.
• Working overtime is not sustainable.

I give the book a rating of 5/5 and recommend it to my friends. I have used the Pomodoro Technique before, but reading this has book makes me feel much more prepared to utilize it fully. Another lesson I have learned is that I do not have to use the Pomodoro Technique all the time. I find it ideal to use when I am procrastinating a lot, or having a hard time focusing.

So AutoTest goes on my list of things to play with over the weekend, you know because I could use some giddiness in my life right now. I haven’t been regular with my Ruby hacking, so I decided to check out AutoTest.Net, the .Net counterpart for the same framework. AutoTest.Net was created all the way back in Nov 2007 by James Avery (I live on the bleeding edge, don’t I). Lately, it is being maintained and worked on by Svein Arne Ackenhausen on GitHub.

To get started, download the latest code from GitHub and build it. I initially tried downloading just the binaries and making it work, but kept on getting errors. I think the binaries at this time are out of sync with the latest source code so I would recommend compiling the code yourself. Update the AutoTest.config with the correct location for your build executable as well as your test runners. Now if you launch AutoTest.WinForms.exe, it’ll look something like this:

Choose your code directory and click on “Ok”, and it should be up and running.

If I make a change to a source file now, AutoTest.Net runs all the unit tests for me.

Pretty neat, huh! Now, if you do not have a dual monitor setup, it might be kind of a pain to navigate to the status window every time you make a change to ensure that everything is green. The icing on the cake is that AutoTest.Net integrates with Growl for Windows. After turning on growl, I get:

And, if I add a failing test, I get

So I can continue coding without having to move focus to another application and get continuous feedback at the same time. Brett was right, this setup does make me feel pretty excited. I am definitely going to use this in my side projects, where I have been following a TDD workflow lately. For all you cross-platform folks, AutoTest.Net works with Mono as well. And based on the commit history, it looks like that Svein is checking in updates and fixes very regularly, kudos to him for that.

A couple of things to remember:

• If your tests start running in an infinite loop, that’s because AutoTest.Net is being triggered by updates in your TestResults. Use the “IgnoreFile” element in the config to specify an ignore file (similar to .gitignore), and AutoTest.Net wil ignore those changes.
• If you run into any issues, set the “Debugging” element to “true” in the AutoTest.Config file, and monitor the Debug.log file in your AutoTest.Net directory. That is how I found the previous issue.

I split my tasks into 2 categories

• Time sensitive and/or Recurring Events: This incudes meetings, appointments, birthday/anniversary reminders. I use Microsoft Outlook in the office, and GMail Calendar for personal stuff. My Gmail calendar is synced with my IPhone. Using the Google Calendar Sync utility, I keep the Outlook and GMail Calendar in sync, so all my commitments are available to me in Outlook as well as on my IPhone all the time.
• One Time tasks: This can vary from anything like picking up the drycleaning to buying stationary, or perhaps checking out a new technology framework in spare time. I use Google Tasks to store my tasks under different lists. I have lists for the items to do for my blog, things to do for the Dallas C# SIG, project ideas that I might want to pursue later, groceries to pick up and so on. The tasks can also be accessed from my IPhone using gmail.com/tasks.

And that’s it. Between Google calendar and Google Tasks, I am able to keep track of all my tasks.

I want to mention two other online tools that help me organize my online information significantly. Both of these are available in the form of JavaScript bookmarklets and always live in the bookmarks bar on my browser.

• Evernote: This is permanent catalog for information that I want to access later. I organize information using appropriate tags. Evernote also has native Windows, Mac, Blackberry, Palm, Windows Mobile and IPhone apps.
• Instapaper: I use this as a temporary store for links that I want to go through when I have more time on my hands.

I have been hacking on some personal projects in the little time I have found over the last 3 months, mostly on flights . I also spent some time learning and understanding GIT, something that has been on my TODO list for a while. I am fascinated by the DVCS model and am excited by the improvements it offers over a centralized source control repository. I have started to use GIT on my side projects for now and plan to evaluate Mercurial somewhere down the line.

        private IDictionary<string, int> _ages;




 




        [TestInitialize]




        public void Setup()




        {




            var mockDictionary = new Mock<IDictionary<string, int>>();




            mockDictionary.SetupSet(m => m["Sara"] = It.IsAny<int>())




                .Callback((string name, int value) => mockDictionary




                                            .SetupGet(m => m["Sara"])




                                            .Returns(value));




            _ages = mockDictionary.Object;




        }




 




        [TestMethod]




        public void Test_Indexed_Property_Using_MOQ()




        {




            _ages["Sara"] = 15;




            IncrementAge(_ages,"Sara");




            Assert.AreEqual(16,_ages["Sara"]);




        }




 




        static void IncrementAge(IDictionary<string,int> ages,string personName)




        {




            ages[personName] = ages[personName] + 1;




        }

Update: Looks like Bertrand Le Roy had already blogged about a similar solution.

• Visual Studio Tips & Tricks by Zain Naboulsi::) Zain covered some useful Visual Studio tips and tricks that he has been outlining on twitter and his blog lately. Of course, the most remarkable shortcut he showed (and nobody in the audience knew about) was that pressing F7 in a command prompt gives a dropdown of all previously executed commands :).
• Delightful forms plug-in for Ruby On Rails: The speaker outlined his inspiration behind this forms plug-in, and the output looked very clean and user friendly.
• The CAP theorem by Michael Perry::) Michael gave an overview of the CAP theorem (only 2 out of 3 features from the list of Consistency, Availability and Partition Tolerance can be achieved at one time for a distributed computer system).
• NoSQL/MongoDb 101.
• FolderTrack application overview.
• Less CSS::) allows use of variables, mixins and nested rules in CSS.
• Windows Phone 7 overview by Chris Koenig.
• SEO optimization and hacks: This was my favorite session for the day and the presenter showed very impressive hacks and examples for manipulating SEO.
• Targeting Mobile CSS media.
• Overview of DallasMakerSpace community::) Another cool presentation about the hackerspace community in Dallas.
• My BDD talk.

A big thanks to the organizers for putting this up and I look forward to attending this next year.

1. Anti-Reflective Screen Protector: I bought the glossy screen MBP, and that turned out to be a big mistake since I  frequently hack at coffee shop/restaurant patios and the glossy screen made the code unreadable. This Moshi iVisor screen protector fixed that and gave the screen a matte finish. It was also very easy to apply without any air bubble issues.
2. Keyboard Cover: I bought the keyboard cover after it showed up in my Amazon recommended products list (probably because the screen protector is from the same company), and I have been pleasantly surprised with it. It is quite thin and does not take much time to get used to. It has also already saved me from serious trouble once when I spilled Diet Coke on the keyboard.
3. Spare Apple MagSafe Power Adapter::) I haven’t been able to find a good docking solution for the MBP, but carrying a spare power adapter saves me the trouble of crawling under the desk every day to plug/unplug it.
4. Apple MagSafe Airline Adapter: I have already flown to India (>20 hour flying time) twice this year, and the airline adapter is a lifesaver for such long flights. Just make sure you get a seat with a power port (I use www.seatguru.com to choose good seats), and you are good to go.
5. mStand Laptop Stand: I use this at home, and find it to be quite elegant looking. It also has a gap at the front for easy access to the laptop lid for opening/closing.

I have been meaning to check out the HyperMac external battery, looks like a great product if you go to conferences frequently, or are a road warrior. If any of you have tried it out, please do leave a comment about your experience with it.

However, when I add reference for the Workflow service in the NT Service, no new activities are available in a workflow inside the NT Service project. It looks like Visual Studio parses the service reference differently based on the type of client project. I ended up comparing the csproj files manually for my console workflow client and NT service workflow client. By copying the following entry to the NT service project file, I was able to get it to behave consistently:

{32f31d43-81cc-4c15-9de6-3fc5453562b6};{FAE04EC0-301F-11D3 -BF4B-00C04F79EFBC}

It seems that the first guid represents a workflow project type and the second one stands for a Windows C# project.

1. Created Local backup of my dasBlog site.

2. Used this tool to create BlogML file from dasBlog.

3. Installed WordPress on a test directory on my host (GoDaddy), since it provided a 1-click install.

4. Configured the permalink structure in WordPress.

5. Used BlogML to WordPress Import Module mentioned here to import all my old data.

6. Installed Redirection plug-in for WordPress. Under Redirection->Options->Import, I used the CSV file containing the mapped URLS to set up URL redirection so that all the old links remained intact.

7. Renamed the test directory to my desired blog directory name in the host.

In case you are subscribed to the old RSS feed URL, please be sure to update it to the new one.

1. You cannot use ‘localhost’ from inside the emulator to refer to your local PC. You have to use either the computer name or the IP address. However, even after I use the computer name, I get this when trying to access a local resource.
   

2. The Windows firewall blocks the emulator from accessing anything on port 80 by default. I had to pull up the Windows Firewall settings and create a new Inbound Rule (I am using 64-bit Windows 7 here). The screenshots below should be self-explanatory.
   

And Voila! The emulator is now able to access local resources.

The code that we developed during the talk can be downloaded here.

This is the second part of the 2 post series on Mocking. In the last post, we discussed the basics of Mocking and how Adam (the intern) used Manual Mocking to unit test the simple Shopping Cart application he’s building. In this post, we’ll see how using a Mocking library can make the process of mocking out dependencies simpler.

Why use a mocking library?
The projects you work on are usually nowhere as simple/small as the Shopping Cart example Adam is working on (If they are, is there room for one more on the team?). If you have to build a new mock class for each of your classes, the amount of new code you have to write increases significantly. Also, you might want to reuse your test infrastructure across different classes, or just want the mock object to act dumb.

It’s also harder to do interaction based testing using Manual Mocks. In the manual mock for Logger, we had to add a new field to track how many times it is called. As the behavior to test becomes complicated, so does your mock class. Using a mocking library can take care of all these mundane things.

 Why MOQ?

MOQ is a simple and easy to learn mocking library for .NET that takes advantage of .NET 3.5 (i.e. Linq expression trees) and C# 3.0 features (i.e. lambda expressions). There are other mocking libraries like RhinoMocks and TypeMock Isolator, and MOQ is relatively new to the scene. The main reason I recommend using MOQ is because it has a really low learning curve and is intuitive to use. Unlike other libraries, it does not force you to distinguish between a mock and a stub, which makes it easier for developers new to mocking to work with.

MOQ Basics
To create a mock of type T, you will use the Mock class. Any interface type can be used for mocking, but for classes, only abstract and virtual members can be mocked. Let’s walk through a few common scenarios and the corresponding MOQ usage.

Creating Mock objects

 Mock<IProduct> _mockProduct = new Mock<IProduct>();




 Mock<ILogger> _mockLogger = new Mock<ILogger>();

Mocking a method implementation and returning fake data

 _mockProduct.Setup(m => m.GetProductCategory()).Returns("Test Category");

Mocking a property and returning fake data

_mockProduct.SetupGet(m => m.Name)




            .Returns("Product 1");

Throw exception

 _mockLogger.Setup(m => m.Log(It.Is<string>(p => p == null)))




            .Throws(new ArgumentNullException());

Validate Parameters

 _mockLogger.Setup(m => m.Log(It.IsRegex("[1-9]+")))




            .Callback(() => Console.WriteLine("Numbers passed"));

Verify Interactions

 _mockLogger.Object.Log("test");




 _mockLogger.Verify(m => m.Log(It.Is<string>(s=>s=="test")),Times.Once());

Invoke Callback

 int counter = 0;




 _mockLogger.Setup(m => m.Log(It.IsAny<String>())).Callback(() => counter++);

Even if you are new to MOQ, you’ll find the API very intuitive and easy to pick up.

Back to the Shopping Cart

So Adam sees how easy it is easy to work with MOQ and how much code/effort it saves him, and he updates his unit tests for the Shopping Cart accordingly. Note that these unit tests are independent of the manual mock classes as well as from external resources like the filesystem/database.

   1:  [TestMethod]




   2:  public void AddProduct_AddingProductWithPrice10_ShouldMakeTotal10()




   3:  {




   4:      var mock = new Mock<IProduct>();




   5:      mock.SetupGet(m => m.Price).Returns(10.00M);




   6:      var cart = new ShoppingCart(null);




   7:      cart.AddProduct(mock.Object);




   8:      Assert.AreEqual(10.00M, cart.Total);




   9:   




  10:  }




  11:   




  12:  [TestMethod]




  13:  public void AddProduct_AddingProduct_ShouldCallLogger()




  14:  {




  15:      var mockProduct = new Mock<IProduct>();




  16:      var mockLogger = new Mock<ILogger>();




  17:      mockLogger.Setup(m => m.Log(It.IsAny<string>())).Verifiable("Log should have been called");




  18:      var cart = new ShoppingCart(mockLogger.Object);




  19:      cart.AddProduct(mockProduct.Object);




  20:      mockLogger.Verify();




  21:  }

Later….

You are satisfied with the ShoppingCart project and the corresponding tests that Adam built. When you run into him in the evening, you commend him on the nice work and invite him to have a couple of beers with you. As you are sitting at the bar, you glance at the mirror and you see something that makes the hair at the back of your neck stand up. Instead of Adam and you at the bar, it’s just you sitting there with 2 beers in your hand talking to yourself. You then realize that Adam was a figment of your imagination and you might have suffered from some sort of a dual personality disorder (Kind of like Fight Club)). Your brain created Adam so that you could face your fears and misconceptions about Unit Testing and Mocking. On the bright side, you realize that you have finished your project and are sitting in a bar with 2 beers. Cheers!

Download Code