Kodebot

What is SOLID principles?

Wed, 18 Sep 2019 00:00:00 +0000

SOLID is mnemonic acronym where each letter represents one principle.

Result verification

Fri, 22 Feb 2019 10:25:49 +0000

We use result verification technique when the test receives the result by running SUT.

Consider an example of testing a function that adds two numbers and returns the result

function add(a, b):
    return a+b

we verify the correctness of this function by simply checking the result returned by add function

function test_add():
    // arrange
    a = 10
    b = 15

    // act
    result = add(a, b)

    // assert
    areEqual(25, result) // 25 is expected

Simple test data

Fri, 22 Feb 2019 10:25:49 +0000

When we need data, we just create variables with the data and use them in the other places within the unit test.

consider an example of testing a function that adds two numbers

function add(a, b):
    return a+b

to test this function, we need two input data. We can simply create two variables with the data in our test function and use them as arguments for add() function.

function test_add():
    // arrange
    a = 10
    b = 15

    // act
    add(a, b)

Structure

Fri, 22 Feb 2019 10:25:49 +0000

Any unit test will have two or more of the following steps

Setup
Run SUT
Verification
Cleanup

Setup

One of the first step in writing unit test is Setup. In this step, we prepare test data, dependencies and/or the context for the test.

For example, we will replace any real dependencies with fake ones and define set of good test data as part of this step.

However, this step is not necessary for all the tests.

Test driven development

Fri, 22 Feb 2019 10:25:49 +0000

Test driven development (TDD) is a popular approach for writing unit tests.

With this approach, we write a test first, see it fail, then write production code to make the test pass.

Typically, we repeat the steps below in that order

take a small requirement
write failing test for the requirement
write production code to make test pass
refactor

It is claimed that TDD helps to write code that simple, flexible and just enough to satisfy the requirement.

What is automated unit testing?

Fri, 22 Feb 2019 10:25:49 +0000

Let’s first understand what we call as Unit. The term unit is very subjective, so it means different things to different people. In the context of testing, I like to think of unit as one or more lines of code that does something small but tangible to move towards achieving the end goal of the program.

What do I mean by this? Well, lets look at an example of a very simple calculator program. In order to build a calculator, we need to build individual operations that are supported by the calculator. Each simple operations like addition, subtraction, multiplication and division are implemented using few lines of code and these operations are units as these are small but tangible steps needed to build a calculator.

Single Responsibility Principle

Wed, 18 Sep 2019 00:00:00 +0000

Watch video

Single Responsibility Principle (SRP) is about how we separate or modularise code in object oriented design. This principle says that

Data driven test

Fri, 22 Feb 2019 10:25:49 +0000

When we want to test SUT, we usually want to test with different set of data. It is not ideal to create one test function for one set of input data. This is where data driven tests are helpful.

Consider the same example function that adds two numbers

function add(a, b):
    return a+b

To be thorough, we need to test this function with few different set of data including but not limited to negative numbers, positive numbers and zeros.

State verification

Fri, 22 Feb 2019 10:25:49 +0000

State verification is similar to result verification but rather than checking the result of SUT, we check the state of an object or something similar.

Consider an example of testing a function that closes the database connection

module databaseManager

isOpen

function close():
    isOpen = false

When we call this function, it is not going to return anything, instead it is going to change the state of isOpen field

So we need to verify the state of isOpen field to ensure the correctness of close function

Test oriented development

Fri, 22 Feb 2019 10:25:49 +0000

Test oriented development is another approach where it is not important to write tests first but it is important to write test while writing production code.

Typically, we repeat the steps below in that order

take a small requirement
write production code
write unit tests
refactor

Why are we writing unit tests?

Fri, 22 Feb 2019 10:25:49 +0000

We can find many reasons for writing unit tests, there are three reasons that stands out in my opinion

Verify the correctness of the code
Provide safety-net when we want to change the code (feedback mechanism)
Serve as a documentation of the code

Verify the correctness of the code

I don’t think any good developer will just write code and say the work is done. They will test it, either via manual steps or by writing automated unit tests, to verify whether the implementation is correct or not.

Open-Closed Principle

Wed, 18 Sep 2019 00:00:00 +0000

Watch video

Open-Closed Principle(OCP) says software must be open for extension but closed for modification. When we first hear this, it might sound like oxymoron but it is not when we understand this principle correctly.

Fake test dependency

Fri, 22 Feb 2019 10:25:49 +0000

It is very common that the SUT depends on something else. The dependency could be anything like another function, object or external system and we may not be able to control their behavior all the time. A good unit test should not be affected by the changes in the dependencies of SUT.

So, a common technique is to replace the dependencies with fake versions that we can control.

For example, consider a function that takes age of the passenger and prints whether he/she is eligible for senior citizen discount when promotion is available.

Interaction verification

Fri, 22 Feb 2019 10:25:49 +0000

Interaction verification is completely different from result and state verification. With this technique, we will be checking whether an interaction under a specific condition has happened or not.

Consider the example below, the databaseManager module offers a function to close database, but it neither returns any result nor changes the state. All this function does is that it calls a function in database module.

module databaseManager

function close():
    database.close()

So, the only thing we can do to verify the correctness of this function is to check whether it calls close() function in database module or not

What is good unit test?

Fri, 22 Feb 2019 10:25:49 +0000

When writing tests for any block of code, it must be comprehensive and cover all the scenarios. If we write tests for most obvious scenarios and don’t cover the less common scenarios then we don’t know how it is going to behave on those untested scenarios.

Each test we write should have the following qualities

Quick to run
Repeatable
Focused
Isolated
Self validating

Quick to run

When running unit test, we don’t want to wait long. Because each of the tests we write target only few lines of the code, we could easily end up with hundreds, if not thousands, of tests even for a small program/application. Our tests must be extremely fast to get the feedback quickly. So we should try to avoid anything that will slow down our tests. When this is not possible, we should at least be able to keep the slow running tests separate and run them independently without affecting fast running tests.

Liskov Substitution Principle

Wed, 18 Sep 2019 00:00:00 +0000

Watch video

Liskov Substitution Principle(LSP) is about substitution of one object for another without affecting the program that uses those objects.

Mock dependency

Fri, 22 Feb 2019 10:25:49 +0000

While fake dependencies are really useful for unit testing, they lack in features like tracking function calls, intercepting arguments, etc.. that makes unit testing easier. Mock dependency is a dependency which offers all the benefits of fake dependencies and more features to make unit testing easier.

It is not going to be easy to create and maintain mock dependencies; this is why we generally use mocking libraries to create mock dependencies.

Other types of automated testing

Fri, 22 Feb 2019 10:25:49 +0000

While unit test targets small piece of code, we have other types of test that generally focus at higher level than unit tests. Two examples of such types of test we have are

Integration tests
End to end tests

Generally, unit tests focus on small piece of code without considering the behavior of dependencies they have (usually with the help of fake dependencies). This means we will be able to verify whether the target code works on it own or not, but we will not know whether it is going to work correctly as a part of bigger program. While this is the correct approach for unit tests, it doesn’t cover verifying the behavior with real dependencies. Integration and End to end tests falls under this category where SUT will be tested with real dependencies.

Interface Segregation Principle

Wed, 18 Sep 2019 00:00:00 +0000

Watch video

Interface Segregation Principle(ISP) was introduced by Robert C. Martin. He says

Dependency Inversion Principle

Wed, 18 Sep 2019 00:00:00 +0000

Watch video

Dependency Inversion Principle(DIP) is introduced by Robert C. Martin and his definition is

System Under Test (SUT)

Fri, 22 Feb 2019 10:25:49 +0000

The implementation of System Under Test (SUT) that are the target of our unit test can be one of the following

direct implementation
indirect implementation
combination of the above

Direct implementation

If a function or piece of code is direct implementation, then it will take zero or more inputs and provide some results or cause state change with very little or no dependencies.

Examples of direct implementation

Functions that implement individual operations of a calculator program like addition, subtraction, etc…
Function that creates new student object
Function that validates bank account number

Indirect implementation

Normally a function or piece of code falls under this type when it gets something done via one or more of its dependencies rather than doing it on its own.

Join and GroupJoin in C#

Wed, 03 Feb 2021 13:55:27 +0000

Introduction

Join and GroupJoin are two different methods that we can use in our LINQ query to join two different collections. At first glance, they might look similar but they produce different results. Lets look at how they work with an example.

Example setup

For our example, we are going to use the following Student and Enrolment class.

class Student
{
    public string Id { get; set; }
    public string Name { get; set; }
}

class Enrolment
{
    public string Id { get; set; }
    public string StudentId { get; set; }
}

And we assume, we have the following data

tmux One Minute Guide

Thu, 28 Jan 2021 10:19:39 +0000

What is tmux?

tmux is terminal multiplexer that allows your terminal to be split into different sessions, windows and panes. One of the great thing about tmux is that, you can detach from and reattach to, tmux sessions without terminating the programs running in those sessions.

Session - is a wrapper for your windows and panes that you can create, detach from and reattach to without terminating the programs running in the sessions

NodeJs: Loops, Closure and Async Invocation

Sun, 04 Oct 2015 00:00:00 +0000

Closure

Closure is something that is very familiar to all C# developers who know lambda expressions/functions but they just may not know that it is called Closure in JavaScript.
Lets look at what is closure in JavaScript without further ado with an example:

function outer(){
	var inOuter = "outer";
	inner();
	
	function inner(){
		console.log(inOuter); // prints 'outer'
	}
}

In this example, the variable inOuter is defined in the function outer but it is used in the function inner. This is possible because, the a function in JavaScript can access all the variables in the scope where the function is defined and this is called Closure.

Exception Handling in NodeJS

Sun, 27 Sep 2015 00:00:00 +0000

Introduction

Exception handling in Node might look completely different for developers coming from C# background like myself. It is mainly because of the way Node works. Node uses single thread based event loop to enable concurrency, this results in higher throughput with relatively low overhead. When it comes to exception handling, having some understanding of the event loop will help you to do the right thing.

Event Loop

Node has the following three main components to achieve concurrent, non-blocking execution
1. Event Demultiplexer
2. Event Loop
3. Event Queue

Unit Testing Entity Framework async Queries

Thu, 13 Aug 2015 00:00:00 +0000

Introduction

In my last article, we have seen how to unit test Entity Framework queries. Now, let’s look at how to unit test async queries. When using async tasks, if we don’t use it all the way then we are not using async tasks properly. For example, if you have async action method in your controller which queries database synchronously to send some data to the requester, then we are NOT using async properly as the thread is blocked during database operation. So, to take full advantage of async tasks, we have to use async tasks all the way wherever it is applicable. Fortunately, we get async query support starting from Entity Framework 6.

Unit Testing Entity Framework Queries

Mon, 10 Aug 2015 00:00:00 +0000

Introduction

When writing unit tests, we should test only one thing at once and isolate the system under test(SUT) from all the dependencies. We should follow the same approach for any LINQ queries you write to retrieve data from the underlying Database. But, I have seen many developers excluding the whole data access layer from unit testing. This is not right approach to follow IMHO. Many developers don’t bother unit testing data access layer because of the perceived effort and complexity involved in isolating the data access layer from underlying Database and ORM tools like Entity Framework. The truth is, it is very easy to test your queries without touching Entity Framework or Database.

VS-TAC - Cordova version

Fri, 17 Jul 2015 00:00:00 +0000

Visual Studio – Tools for Apache Cordova is a great addition to Visual Studio. It allows us to develop Apache Cordova applications while taking all the advantages of Visual Studio. I started using it with VS 2015 RC for one of the application I am developing using Ionic.

Most of the work is done by visual studio using a new npm package called vs-tac, this package takes care of building and deploying your application using collection of cordova tools.

ASP.NET MVC 5 - JsonResult with Http Status Code 400

Fri, 19 Jun 2015 00:00:00 +0000

ASP.NET Web API 2 introduced several helper methods like Ok, NotFound, BadRequest, etc… . This allows us to write code which makes its intentions clear.

In recent times, I have been working in semi-single page application which uses ASP.NET MVC 5 and AngularJS. The application is designed in a way that, there is only one view per feature and each view is SPA. So, each ASP.NET MVC controller have only one GET action that returns the view and rest of the communication is using actions that returns JsonResult that can be used by client in AJAX style just like consuming Web API. With this design, I have to send JsonResult for everything, but, the Http Status Code has to be set appropriately so that the client can use them for any processing that it needs to do based on the Status Code.

AngularJS 1.x - Validation on File Input type

Tue, 16 Jun 2015 00:00:00 +0000

Introduction

You might already known that AngularJS 1.x doesn’t support model binding for File Input type at the moment. This means, implementing any validation on File Input type is not straight forward as validation entirely depends on model binding.

I have come across a requirement where, I need to create a form with ‘required’ validation on File Input type and I also need to display bootstrap form feedback. There are number of great solutions out there to make file upload with angular easier but none of them provide easier way to enforce validation.

Angular 1.x - Unit Testing a function that returns Promise

Mon, 08 Jun 2015 00:00:00 +0000

I wrote this post few months back which show how we can mock a function that returns Promise. In this post, we will see how to test a function that returns Promise.

We will use the following simple controller as our SUT

var app = angular.module("app");

app.controller("studentController", function($q, studentDataService){
    var vm = this;    
    vm.students = undefined;
    
    activate();
    
    function activate (){
        vm.students = getAllStudents();
    }
    
    function getAllStudents(){
        return studentDataService
        .getAll();
    }
});

This simple controller has getAllStudents() which returns a promise. The activate method calls getAllStudents() and assigns the returned promise to vm.students. In angular, you can directly bind promise, so, this is perfectly valid.

TypeScript - Accessing object with null key

Wed, 03 Jun 2015 00:00:00 +0000

Objects in JavaScript is just a key value pair and key is usually string and value can be anything. The following is an example of JavaScript object literal

var car = {
    wheels : 3,
    colour: 'red',
    drive: function(){
    ...
    }
}

The key in the object can be null. The default route in AngularJS is associated with null key, for example.

We can access the value associated with the null key in JavaScript quite easily like this:

ASP.NET MVC 5 Hosting for Integration / E2E Testing

Sat, 30 May 2015 00:00:00 +0000

Introduction

When we want to do proper Integration or End to End testing of Web API, we can choose any process as host for Web API 2 or higher. This is possible because Web API supports Owin/Katana, which means, it doesn’t have any direct dependency on IIS. On the other hand MVC 5 doesn’t have support for Owin/Katana due to the fact that ASP.NET pipeline is depending on IIS. So this leaves us with only one option to host MVC 5, which is IIS, even for integration/e2e testing.

How to isolate AutoMapper in Unit Tests?

Wed, 20 May 2015 00:00:00 +0000

Introduction

When it comes to Unit testing, the rule is to isolate all the dependencies and focus only on the unit of code you are testing. I have been silently ignoring this for AutoMapper until I found a proper way to isolate and replace the behavior of mapping.

When I was looking for a proper way to do this, I come across many posts but none of them were having full working example without any additional layer between the function/class that wants to use AutoMapper and AutoMapper itself.

ASP.NET 5 - Tag Helpers, the HTML way

Thu, 14 May 2015 00:00:00 +0000

Introduction

Tag Helper is not a new concept in ASP.NET but they way we use Tag Helpers in razor view is different. In the previous versions of ASP.NET, if we want to use HTML tag helper, we will be switching from HTML's native declarative style to imperative style of C#.

We loose the tooling support we get when editing HTML document for the most part. For example, the following code creates a label

ASP.NET 5 - Environment specific pipeline configuration

Fri, 08 May 2015 00:00:00 +0000

Introduction

In ASP.NET 5, we configure and add middlewares (aka pipelines) using Startup class. The convention is similar to Owin/Katana but not the same.

The Configuration method in Owin/Katana Startup class is replaced by Configure method and the parameter type is IApplicationBuilder rather than IAppBuilder and how we create and add middleware is also different to some extend.

ASP.NET 5 Startup class allows us to add and configure services using ConfigureService method, this is not available in Owin/Katana Startup class. The services we add using this method is added to the DependencyInjection container which comes with ASP.NET 5 out of the box.

Owin - Katana core middleware patterns

Wed, 29 Apr 2015 00:00:00 +0000

Introduction

Katana supports 4 different convention based patterns for adding middlewares in its lowest level. They are,

Delegate Pattern
Instance Pattern
Generator/Nested Delegate Pattern
Constructor Type or Type Pattern

All the other formats/patterns supported through IAppBuilder's extension methods are implemented using one of these 4 patterns under the hood.

I couldn't find any examples in the web which show how to use these patterns, so I am creating it for my future reference.

TypeScript - 'this' reference in AngularJS event handler

Mon, 27 Apr 2015 00:00:00 +0000

Let's have a look at how AngularJS 1.x controller is usually created in TypeScript before we go into details of how AngularJS event handler and how 'this' works in the AngularJS event handler context.

TypeScript encourages to type anything and everything to take full advantages of the type system and tool supports we get when working with any strongly typed language.

So, when using TypeScript with AngularJS 1.x, class is usually created to represent the implementation of the controllers. Here is an example of how this would look like

TypeScript build automation in ASP.NET 5 (MVC6) using Gulp

Sat, 18 Apr 2015 00:00:00 +0000

Introduction

ASP.NET 5 introduces some major changes in terms of how we develop applications like no need for project and file association, wwwroot folder, first class support for JSON config files, .NET framework choice, separation of client side and server side package management and more. You can read more on this here.

Above all of these, it supports JavaScript build automation by providing support for the nodejs platform.

Visual Studio 2015 has in-built task runner to run grunt or gulp tasks, this is great because we don't have to leave Visual Studio to run these tasks.

MVC 6 Camel Case JSON

Mon, 13 Apr 2015 00:00:00 +0000

I am excited with all the new features that are coming with MVC 6. One of the main differences between MVC 6 and previous versions is that it doesn't have two different libraries and controllers for MVC and Web API.

The previous versions of Asp.Net MVC uses JavaScriptSerializer for MVC controllers and JSON.NET for Web API controllers.

This means, if you have an application which uses both MVC controllers and Web API controllers then you need to apply any custom JSON serialization configurations twice or you should replace JavaScriptSerializer with JSON.NET.

TPL Task and Windows Identity Impersonation - The beauty of Closure

Thu, 09 Apr 2015 00:00:00 +0000

I have created a web application with Windows Authentication and impersonation is enabled as I need the application connect to SQL Server database using Windows Authentication.

I wanted to run a TPL task in the impersonated context, so, I added the following code naively in a action method of one of my controllers

// naive task code

Task.Run(() =>
{
      // Task code here
});

Though, this answer suggests that tasks will run under the same context under which it was created, it wasn't working that way in my case.

Selenium and Page Objects

Mon, 06 Apr 2015 00:00:00 +0000

I use Selenium or Protractor for E2E tests that require browser automation. I prefer to use Selenium when I want to write my tests in C# and Protractor for AngularJS applications.

It doesn't matter what tool/framework you use, if you want to bring in structure and make your test code reusable when dealing with any UI automation then Page Object is your friend.

I have been creating my Page Objects incorrectly with two major flaws until I read this great article from Martin Fowler. The flaws in my Page Objects were

ECMAScript 6 - Sublime Text editor build system

Fri, 27 Mar 2015 00:00:00 +0000

The specification for ECMAScript 6 (aka ES6, ECMAScript harmony) is expected to be released in June 2015 and many tools, frameworks and browsers have started implementing the features of ES6. For example, Angular 2.0 and Aurelia allows us to write code in ES6 now. There are transpilers as well out there, which allows us to write code in ES6 and transpile them into ES5. I have come across two major transpilers traceur and babel, they are equally good.

Six stars of AngularJS - Part 3

Wed, 25 Mar 2015 00:00:00 +0000

In part 1 and 2 of this series, we have seen five different ways to create a service in angular.

The last one we are going to look at in this series is 'decorate' function of $provide service.

Decorator

The decorate function is NOT used to create a service, instead, this is used to decorate or replace an existing service. Let's look at this function with an example

// sample 1
app.factory('movieService', movieService);

    function movieService() {
        return {
            getAllMovies: getAllMovies
        }

        function getAllMovies() {
            return ['engMovie1', 'engMovie2', 'engMovie3'];
        }
    }

In this example, we have movieService which exposes a function to get all the movies. Now, Let's create a decorator for this service to change the behavior of getAllMovies to return only the first 2 items.

Six stars of AngularJS - Part 2

Tue, 24 Mar 2015 00:00:00 +0000

In part 1 of this series, we have briefly seen how $provide and $injector work and we also took a deep dive on how we create a service using provider function of $provide service.

Lets continue our journey and look at how and when we can use other functions of $provide service to create services.

The following are the four functions we are going to look at now

factory
service
value
constant

Factory

The factory is one of the functions exposed by $provide service to create services. Here is an example of service created using factory function of $provide service

Six stars of AngularJS - Part 1

Mon, 23 Mar 2015 00:00:00 +0000

Introduction

Services are one of the core buiding blocks of AngularJS. It helps us to create reusable code that can be shared accross the application(s).

AngularJS gives us five different options to create services. We will look at what are those five options and how and when they can be used. But, before that lets take a brief look at couple of built-in angular services and how they works in the context of dependency injection.

NSequenceComparer to compare two sequences

Sat, 21 Mar 2015 00:00:00 +0000

I had a requirement to compare two sequences to find the differences in .NET platform. To compare large sequences, I needed an algorithm that does not use recursion. I could not find anything in the internet that I can use out of the box, so, I created this nuget package

This package is very simple to use, you can read usage instructions here

Feel free to use and contribute.

Mocking function that returns promise

Mon, 16 Mar 2015 00:00:00 +0000

Promises are very useful to develope non-blocking web applications and it also helps to avoid pyramid of doom.

AngularJS supports Q based promises, this means, we can create functions in AngularJS application that uses promises. When it comes to unit testing functions that returns promises, it is just like unit testing normal functions only if you remember simulate scope's life cycle using $apply() or $digest()

Let's see this with an example. The following controller loads restaurants using promise

Strucuring unit tests

Mon, 16 Mar 2015 00:00:00 +0000

I have been following the same unit test structure that Phil Haack described here. But, I use slightly different version when my tests need too many repeated test setups and cleanups.

I like jasmine mainly because it allows to keep the tests DRY using nested structure. Ofcourse it is possible in jasmine because method nesting is allowed in JavaScript. I like to structure my C# test files the same way using nested classes without using any additional libraries

Decorator over Inheritance hierarchy

Sun, 15 Mar 2015 00:00:00 +0000

I have used inheritance to solve a problem in many situations - some of them are correct and some of them are not when thinking about it now.

When you are in a situation where you think you need multi-level inheritance, 9 out of 10 times you can solve the same problem using decorators.

One of the problems I have seen recently which fits in this pattern is the implementation of ICommand interface. See the implementation below

Organize AngularJS Tests within a test file

Sun, 15 Mar 2015 00:00:00 +0000

I like to have one test file per components of AngularJS application. So, for example, homeController will have its own test file named homeSpec or homeControllerSpec.

First, create a suite to describe a component at a high level and for each scenario create nested suits. This allows us to define any test setup that are common for all the tests in one place.

For example, loading module, overriding and injecting any dependencies are done in the beforeEach method of outter test suite. The setup is applicable for all the tests defined in the outter and nested test suits, so, if you don't want any setup for all the tests then do not include them here.

Setup Chutzpah to Run Javascript Tests in VisualStudio

Sat, 14 Mar 2015 00:00:00 +0000

First thing first, install Chutzpah Test Runner and Test Adaptor for the Test Explorer.

Next, setup your projects in Visual Studio. I personally like to keep my test code in a separate project for JavaScript as well so my project and folder structure looks like this:

This allows you to restrict testing frameworks and libraries like Jasmine only to the test project. I use JavaScript libraries directly from the main project when it is needed in test projects as well rather then adding them again in the test project (some people have different view on this but it works for me).