The idea of having a portable environment is really neat, it’s even better when you don’t have to pay through your nose to have it and use it with privacy.

If you don’t have a 32GB flash drive, DropBox is a good way to go.

I wanted to do the following:

1. Install Ubuntu via VirtualBox (VMWare).
2. Setup the envoirnment with the necessary software.
3. Sync it to dropbox.
4. Add files from within the image to dropbox. (without redownloading the virtual machine image in the virtual machine)
5. Sync it across multiple computers.

I made the unfortunate mistake of syncing Ubuntu after it installed, and then again after 3gb of software installs. Don’t let it sync until everything is done!

How I did it:

With the 50gb dropbox, create a folder called: “Operating Systems”, “OS” whatever you want.

1. Download the latest ubuntu install.
2. Download the latest image of VirtualBox. For me it was: “VirtualBox-3.2.8-64453-Win.exe”
3. Install it and sync it in your “Operating Systems” folder.
4. In VirtualBox, click new, give your OS Image a name and select Ubuntu.
5. Allocate at least 1024mb of memory, Create a new hard disk in your dropbox folder, select dynamically expanding storage, with at least 8gb of space.
6. Click start select your ubuntu iso, set it up.
7. After you have installed Ubuntu, mount the VirtualBox additions, and install them.
8. After that is done, go ahead and install all your packages and software.
9. In your regular OS go to C:\Users\..\.VirtualBox replace .. with your username.
10. Yank out all the files in there and sync them to your “Operating Systems” folder.
11. Shutdown ubuntu, close down VirtualBox. Let Dropbox sync your finished product.
12. On another computer, let dropbox sync everything.
13. Install Virtualbox, copy the necessary files to C:\Users\..\.VirtualBox with .. being your username.
14. Start VirtualBox your OS should be listed, make sure your paths are all correct in your images prefrences, start it up and you should be good to go.

Adding files to dropbox is simple with VirtualBox shared network, all you have to do is navigate to your dropbox folder. In ubuntu Places > Network. Locate your dropbox folder and add items there. I even went as far as creating a simple alias to the location and added a dropbox icon to the alias.

To wrap it up, some of the drawbacks:

• If you change the image to much it has to re sync the entire image.
• Indexing large files takes forever.
• The initial sync takes a while.

For those of you who are going to ask, syncing minor changes to the image are quick after the indexing is complete.

Another positive note, in Dropbox’s votebox there are already a lot of requests to manually sync files.

Good Luck!

At the end of this tutorial I have a link to a PHP version I wrote for personal use, feel free to download, edit, destroy, and share it.

Lets dive in.

If you are using Notepad++, “Zen Coding.js” is located here:

..\Notepad++\plugins\NppScripting\includes\Zen Coding.js

You will need to edit this file to add your own custom snippets/abbreviations.

Locate the following code (contents have been replaced with “//there is code here”):

	'html': {
		'filters': 'html',
		'snippets': {
			//there is code here
		},
		'abbreviations': {
			//there is code here
		},
		'element_types': {
		}
	},
	'xsl': {
		'extends': 'html',
		'filters': 'html, xsl',
		'abbreviations': {
			//there is code here
		}
	},

These are all of the existing html and xsl abbreviations and snippets provided with Zen Coding.

For the sake of time, we are going to add a PHP section right before this line:

	'xsl': {

This will look like this:

	'html': {
		'filters': 'html',
		'snippets': {
			//there is code here
		},
		'abbreviations': {
			//there is code here
		},
		'element_types': {
		}
	},
	'php': {
		'filters': 'php, html',
		'snippets': {
			//we will write snippets here
		}
	},
	'xsl': {
		'extends': 'html',
		'filters': 'html, xsl',
		'abbreviations': {
			//there is code here
		}
	},

Make sure your curly braces, comas, etc. are correct otherwise you will get an error loading the file.

Now locate:

	var know_syntaxes = {
		'html': 1,
		//there is more code here

	};

Add ‘php’: 1 to this code, like this:

	var know_syntaxes = {
		'html': 1,
		'php': 1,
		//there is more code here
	};

Finally, lets add a snippet, I am going to create one for an inline function as my blog won’t let me write out actual php code without rendering it, if you would like to wrap your code in a php tag go right ahead.

So lets try something like this:

	'php': {
		'filters': 'php, html',
		'snippets': {
			//we will write snippets here
			'php:func':	'function |() {\n\t\n}',
		}
	},

| is the position of your mouse cursor.

\n is new line

\t is tab

See simple.

Save your “Zen Coding.js” file, restart your application in our case Notepad++.

Now if you were to type in php:func then click Ctrl+E, this would expand to:

function () {

}

tada, and now as promised:

My attempt at PHP snippets!

Download/Preview the PHP section, via copy paste from here: Preview/Download.

Or

Download the entire Zen Coding.js file, by right click save as.

—

As you can see there is so much room for editing and customizing your own abbreviations and snippets. I haven’t even touched the tip of the iceberg. So go explore and good luck, just make sure to make a backup file.

Throughout this year, I will be adding great website designs right here, so make sure to tune in. Click continue reading, to see the rest.

Hold on to your 56k modems, this could get slow.

The Darling Starling

31Three

The Pixel Blog

Foxie

Morphix

Cult Foo

Kulturbanause

More to come!

Over time it will slowly make your hardware less functional and will make you want to crawl under your desk, or go after your computer with a baseball bat.

The current fix is to not run Unit Tests, or if you really have to, you can use ReSharper:

ReSharper -> Unit Tests -> Run All Tests from Solution.

Yes, this is a joke, well the virus part anyway!

In this tutorial I will step you through a framework called Moq for (.NET) released under the New BSD License. I will not be discussing what Mocking is here as that’s outside the scope of this tutorial. What is mocking/mock object?

Before we jump in to the code, here are some important links:

Get Moq.

Get Moq Contrib

Moq API.

So lets dive in, assuming you already added a reference to the Moq DLL and Moq.Contrib DLL in your project. Let’s start out by creating a new Abstract class to your project. During this session I am going to call this class: UnitBaseAbstractClass for readability.

Creating A Base Test Class

UnitBaseAbstractClass: This class is in charge of setting up a Moq based environment for each of your TestClass’.

1. First let’s add the Moq and Moq.Contrib namespaces to this UnitBaseAbstractClass class.

using Moq;
using Moq.Contrib;

That was simple!

2. Now lets add the [TestClass] attribute to the top of this class, for anything extending it will now need to be a test.

using Moq;
using Moq.Contrib;

namespace MyUnitTests
{
    [TestClass]
    public abstract class UnitBaseAbstractClass
    {
    }
}

3. This maybe a bit confusing but bare with me; we are now going to add two public members to our UnitBaseAbstractClass class these are of type MockFactory and AutoMockContainer. See the next example:

MockFactory: A utility factory used to manage a mocks lifecycle.

AutoMockContainer: A container used to automatically inject mocks into desired objects.

using Moq;
using Moq.Contrib;

namespace MyUnitTests
{
    [TestClass]
    public abstract class UnitBaseAbstractClass
    {

            public MockFactory _factory;
            public AutoMockContainer _container;

    }
}

tada…

4. We will now need to create a method called “Setup” which will take in a MockBehavior enum. In this tutorial we will only use: MockBehavior.Default.

MockBehavior: Tells the MockFactory how to behave. The Strict behavior throws an exception if a mock isn’t setup exactly like its mocked object. Loose will never throw an exception and Default is setup to use the Loose behavior.

(If you don’t understand what this means it’s alright to move on, as it will not affect you yet.)

5. We are going to use Setup to instantiate both MockFactory and AutoMockContainer the factory will need the behavior passed into Setup and the AutoMockContainer will need the MockFactory.

Like this:

using Moq;
using Moq.Contrib;

namespace MyUnitTests
{
    [TestClass]
    public abstract class UnitBaseAbstractClass
    {

    public MockFactory _factory;
    public AutoMockContainer _container;

        public void Setup(MockBehavior behavior)
        {
            _factory = new MockFactory(behavior);
            _container = new AutoMockContainer(_factory);
        }

    }
}

6. Last but not least we want to implement our [TestCleanup]. We will call this method VerifyAll, all it will do is verify that all of our mocks were used and that they were used correctly. Making the final code look something like this:

using Moq;
using Moq.Contrib;

namespace MyUnitTests
{
    [TestClass]
    public abstract class UnitBaseAbstractClass
    {

    public MockFactory _factory;
    public AutoMockContainer _container;

        public void Setup(MockBehavior behavior)
        {
            _factory = new MockFactory(behavior);
            _container = new AutoMockContainer(_factory);
        }

        [TestCleanup]
        public void VerifyAll()
        {
            _factory.VerifyAll();
        }

    }
}

Nice, small, and powerful.

A Test Class using our Base Class

The fun part!

1. Let’s start by writing some tests against this pseudo PersonService class:

namespace MyRear
{

    public class PersonService
    {
        private readonly IRepository _repository;

        public PersonService(IRepository repository)
        {
              _repository = repository;
        }
        public bool SavePerson(Person person)
        {
        		try{
        		   return _repository.Save(person);
        		}
	        	catch (Exception ex){
	        	   throw new CustomException(ex);
	        	}
        }
    }
}

2. Lets create our test class using UnitBaseAbstractClass. Our [TestInitialize] will be using the base Setup method we created in UnitBaseAbstractClass and we will use the AutoMockContainer to create a new instance of our PersonService class. We will also create a new person.

That was a mouthful, like this:

namespace MyRearTests
{
    [TestClass]
    public class PersonServiceTests : UnitBaseAbstractClass
    {
        private readonly PersonService _service;
	     private Person _person;

        [TestInitialize]
        public void SetupPerson()
        {
            Setup(MockBehavior.Default);
            _service = _container.Create<PersonService>();
	         _person = new Person();
	    }

    }
}

3. Time to write the tests! Before that though, I want to show you how to mock _repository.Save the code that calls the Database. Which in this case we do not want to access in our testing environment.

This code:

return _repository.Save(person);

4. First we want to get a mock object for IRepository because this is how we are going to call Save.

We do this with this line of code:

 _container.GetMock<IRepository>()

6. We then want to make sure that we can mock Save. We accomplish this via some Linq we call the Expect method.

In it we call Save and pass our _person object.

 _container.GetMock<IRepository>()
	    .Expect(s => s.Save(_person))

7. We then need to tell the object what to return (in this case I return a bool, lets say true). After calling the Returns method make sure to verify that this mock was even needed via Verifiable method.

 _container.GetMock<IRepository>()
	    .Expect(s => s.Save(_person))
	    .Returns(true)
	    .Verifiable();

8. Lets make it a test now!

namespace MyRearTests
{
    [TestClass]
    public class PersonServiceTests : UnitBaseAbstractClass
    {
        private readonly PersonService _service;
	    private Person _person;

        [TestInitialize]
        public void PersonServiceSetup()
        {
            Setup(MockBehavior.Default);
            _service = _container.Create<PersonService>();
	        _person = new Person();
	    }

        [TestMethod]
        public void SavePersonSuccess()
        {
 	        var result =
        	        _container.GetMock<IRepository>()
		            .Expect(s => s.Save(_person))
	            	    .Returns(true)
		            .Verifiable();

            Assert.IsTrue(result, "Person should have saved.");
        }

    }
}

9. Lets add another test that returns false, a failed save.

namespace MyRearTests
{
    [TestClass]
    public class PersonServiceTests : UnitBaseAbstractClass
    {
        private readonly PersonService _service;
	    private Person _person;

        [TestInitialize]
        public void PersonServiceSetup()
        {
            Setup(MockBehavior.Default);
            _service = _container.Create<PersonService>();
	        _person = new Person();
	    }

        [TestMethod]
        public void SavePersonSuccess()
        {
 	        var result =
        	    _container.GetMock<IRepository>()
		            .Expect(s => s.Save(_person))
		            .Returns(true)
		            .Verifiable();

            Assert.IsTrue(result, "Person should save.");
        }

        [TestMethod]
        public void SavePersonFail()
        {
 	        var result =
        	        _container.GetMock<IRepository>()
		            .Expect(s => s.Save(_person))
		            .Returns(false)
		            .Verifiable();

            Assert.IsFalse(result, "Person should not save.");
        }

    }
}

10. The last test is a bit tricky its why we wrapped Save in PersonService with a try catch and threw a custom exception.

First lets write something like this:

 _container.GetMock<IRepository>()
	    .Expect(s => s.Save(_person))

11. Handling exceptions is different then normal asserts throwing them is different too.

In order to throw an exception we need to call the Throws method instead of returns.

 _container.GetMock<IRepository>()
	    .Expect(s => s.Save(_person))
	    .Throws(new Exception("Save Threw Up"))
	    .Verifiable();

12. Lets make sure we handle the code. We do this with the [ExpectedException] attribute on our test methods.

Like so:

        [TestMethod]
        [ExpectedException(typeof(CustomException))]
        public void SavePersonException()
        {
		        _container.GetMock<IRepository>()
		        .Expect(s => s.Save(_person))
		        .Throws(new Exception("Save Threw Up"))
		        .Verifiable();
	        }

13. The Final Test looks like this:

namespace MyRearTests
{
    [TestClass]
    public class PersonServiceTests : UnitBaseAbstractClass
    {
        private readonly PersonService _service;
	    private Person _person;

        [TestInitialize]
        public void PersonServiceSetup()
        {
            Setup(MockBehavior.Default);
            _service = _container.Create<PersonService>();
	        _person = new Person();
	    }

        [TestMethod]
        public void SavePersonSuccess()
        {
 	        var result =
        	    _container.GetMock<IRepository>()
		    .Expect(s => s.Save(_person))
		    .Returns(true)
		    .Verifiable();

            Assert.IsTrue(result, "Person should save.");
        }

        [TestMethod]
        public void SavePersonFail()
        {
 	        var result =
        	    _container.GetMock<IRepository>()
		    .Expect(s => s.Save(_person))
		    .Returns(true)
		    .Verifiable();

            Assert.IsFalse(result, "Person should not save.");
        }

        [TestMethod]
        [ExpectedException(typeof(CustomException))]
        public void SavePersonException()
        {
		    _container.GetMock<IRepository>()
		     .Expect(s => s.Save(_person))
		     .Throws(new Exception("Save Threw Up"))
		     .Verifiable();
	    }
    }
}

I hope this helped you out a bit more in understanding the Moq Framework. Good Luck, let me know if I need to change anything in the tutorial or make anything clearer!

Here is an example to get you started. I wrote it in two parts:

A Class that Consumes a Feed (FeedReader)
An Object representing a Feed Item (FeedViewModel).

And so we begin:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Xml.Linq;

namespace FeedExample
{

	public class FeedReader
	{
		public static IList<FeedViewModel> GetBlogFeed(string feedUrl, int feedCount)
		{
			//Load feed via a feedUrl.
			var doc = XDocument.Load(feedUrl); 

			//Get all the "items" in the feed.
			var feeds = doc.Descendants("item").Select(x =>
					new FeedViewModel
					{
					     //Get title, pubished date, and link elements.
						Title = x.Element("title").Value, //3
						PublishedDate = DateTime.Parse(x.Element("pubDate").Value),
						Url = x.Element("link").Value
					} //  Put them into an object (FeedViewModel)
					)
					// Order them by the pubDate (FeedViewModel.PublishedDate).
					.OrderByDescending(x=> x.PublishedDate)
					//Only get the amount specified, the top (1, 2, 3, etc.) via feedCount.
					.Take(feedCount);

 			//Convert the feeds to a List and return them.
			return feeds.ToList();
		}
	}

	public class FeedViewModel
	{
		public string Title { get; set; }
		public string Url { get; set; }
		public DateTime PublishedDate { get; set; }
	}

}

You can get some more items from the feed like: title, link, comments, pubDate, dc:creator, category, guid, description, content:encoded, etc…

To prevent your website from slowing down you can cache your feed like this:

//Check if feed exists
if (HttpRuntime.Cache["Feed"] == null)
				{
					//If it is, insert it into the cache, cache for 10 minutes
					HttpRuntime.Cache.Insert("Feed",
						FeedReader.GetBlogFeed("url", 5), null, SystemTime.Now().AddMinutes(10), Cache.NoSlidingExpiration);
				}

//retrieve cached feeds
var cachedFeeds = (List<FeedItemViewModel>) HttpRuntime.Cache["Feed"]

HttpRuntime.Cache is part of the System.Web namespace.

        var oldContext = HttpContext.Current;
        HttpContext.Current = new HttpContext(HttpContext.Current.Request,
        fakeResponse);

        var html = new HtmlHelper(new ViewContext(fakeControllerContext,
        new FakeView(), fakeViewDataDictionary, new TempDataDictionary()),
        new ViewPage());

        html.RenderPartial(viewName, viewData, viewDataDictionary);
        HttpContext.Current = oldContext; //yay 

Though, because you’re reading this you’re like me and you never give up! So how, how do you get around all of this? The answer is Spark. Eeek, another DLL? Yes, Spark is its own View Engine which is an entire different framework. Yes, you have to go to their website download the DLLS, put it in your Lib folder and reference it in your code. Let me tell you now, it is well worth it. Let’s dive in!

Let’s write the code to render our email using the Spark. We want our code to take in the template name, something like: “ForgotUsernameEmail.spark” and we also want it to reuse our current ViewData Object which is of type ViewDataDictionary and contains Person data, we will need to add this into our own implementation of AbstractSparkView. See samples bellow:

Render Email Method:

public string RenderEmail(string sparkViewName, ViewDataDictionary
viewData)
{
     var email = new StringWriter();
     var view = (EmailTemplateBase) _engine.CreateInstance(new
     SparkViewDescriptor().AddTemplate(sparkViewName));
     view.ViewData = viewData;

     try
     {
         view.RenderView(email);
     }
     finally
     {
         _engine.ReleaseInstance(view);
     }
     return email.ToString();
}

Oops thanks Arnis, forgot to mention EmailTemplateBase is just an extended version of AbstractSparkView that includes the ASP.NET MVC ViewDataDictionary.

Custom Spark AbstractSparkView with ViewData implementation:

    public abstract class EmailTemplateBase : AbstractSparkView
    {
        public ViewDataDictionary ViewData { get; set; }

        public object Eval(string expression)
        {
            return ViewData.Eval(expression);
        }

        public string Eval(string expression, string format)
        {
            return ViewData.Eval(expression, format);
        }

    }

So that’s done, let’s make the template… In my MVC Web Project I am going to add into my Views folder or maybe even Views/Email a file called “ForgotUsernameEmail.spark”.

Dear ${#name}:


Your username is ${#userName}.


Thank You.

I also put in a use tag to pull down a Signature file, since this is the same in everyone of my emails. Now let’s actually write the code to call it:

string email = RenderEmail("ForgotUsernameEmail.spark",ViewData);

And that’s all you need to do, well besides read up on spark syntax: http://www.sparkviewengine.com/documentation/configuring

I have recently been introduced to a company by the name of ArtOfTest a Microsoft Gold Certified Partner and for a good reason. The company has two products: “Automation Design Canvas” and the “WebAii” Framework, both incredibly useful tools.

The one I am going to write and sample today is the WebAii Framework, available as a free download from: ArtOfTest WebAii.

Overview:
This light weight testing framework is perfect for writing tests in NUnit or Visual Studio Team Test because it seamlessly integrates with your current project and really doesn’t take any setup due to the provided Visual Studio Templates that come with the installer. All you need to do is write the tests.

So let’s dive into some quick code snippets from the website:

Ajax JavaScript Automation Testing:

[TestMethod] //Define your test method (VS Test)
public void AjaxJsAutomation()
{
      // Wait for a specific element with id 'containing' foo to exist
      Element e = new Element(new FindParam("id=~foo"), ActiveBrowser);
      e.Wait.ForExists();

      // Convert the generic element to an HtmlDiv
      HtmlDiv myDiv = e.As<HtmlDiv>(); 

      // Now invoke a javascript function on my page directly.
      Actions.InvokeScript("myJsFunction('param')");

      // Wait for a color "computed" style to become red
      myDiv.Wait.ForStyles(true, "color=red");

      // Invoke OnFocus event
      myDiv.InvokeEvent(ScriptEventType.OnFocus);

      // Wait for the div to be invisible.
      myDiv.Wait.ForVisibleNot();

      // Move the mouse over the div
      myDiv.MouseHover();

      //Write assertion code here.
}

This is probably one of the cooler features of WebAii. What this code is doing is pulling an element with an id of “~foo” as soon as it exists. Then after the item exists this code is invoking a javascript function and actually waiting for the javascript to change data on your page.

Asp.NET Testing:

[TestMethod] //Define your test method (VS Test)
public void AspNetTesting()
{
      // Set the local server to be Asp.Net local server (aka cassini)
      Manager.Settings.LocalWebServer = LocalWebServerType.AspNetDevelopmentServer;
      Manager.Settings.WebAppPhysicalPath = @"C:\myAspNetApp\Test";

      // Launch a new browser
      Manager.LaunchNewBrowser();

      // Navigate to a page in your app.
      ActiveBrowser.NavigateTo("/main.aspx");

      // Get the grid using partial id.
      Element grid = Find.ById("~dataGrid1");

      //Write assertion code here.
}

As you can see testing asp.NET applications is as easy as setting up the local web server and web application physical path. The rest as usual, launch the web browser via the Manager, get/set your elements and then run your assertions.

So I should probably get back to writing my tests at work but there is a lot more goodness in WebAii and I encourage you to take a look at it when you get a chance and the best place to start is the documentation: Web Aii Docs