Demo – WPF TDD with xUNIT

This demo is about using WPF Test driven development with xUnit framework. xUnit.net is a free, open source, community-focused unit testing tool for the .NET Framework.

xUnit.net has two different types of unit tests: facts and theories.

  • Facts are tests which are always true. They test invariant conditions.
  • Theories are tests which are only true for a particular set of data.

In the below demo, We write few failing tests, make them pass, then repeat the process. I have installed and configured below tools and packages.

  • Visual Studio 2017 Community,
  • WPF
  • TDD with xUNIT Framework
  • Autofac for dependency injection

Our solution would look like this, 4 layers


  • WPFTDDxUNIT.Model — This contains the domain entity which is being used in the project. It is a good practice to keep domain changes to a separate project so that this is not changed accidentally by other team members.
  • WPFTDDxUNIT.DataAccess — In this demo project, Data access is carrying an in-memory collection of records. All the friend’s list is loaded from this project. You can use any relational database like SQL Server or MySQL or any other to save this data.
  • WPFTDDxUNIT.UI.WPF — WPF User Interface is carrying our front end. We want to focus on separation of concerns, so we have not crammed data access and domain into this project.
  • WPFTDDxUNIT.UITests — This is what this blog post is about. We will use this project in the solution to unit tests our view models and other classes to ensure our actual code is backed by units tests. We will use xUnit TDD framework for this task.

The weird interface would look like this, :p

Before we proceed for units test, need to confirm if the below package is installed from nuget:-


Install-Package xunit.runner.visualstudio -Version 2.4.1

If you have Visual Studio Community (or Pro or Enterprise), you can run your xUnit.net tests within Visual Studio’s built-in test runner (i.e Test Explorer).

If not installed the nuget package, please Right click on the project in Solution Explorer and choose Manage NuGet Packages. Search for (and install) a package named xunit.runner.visualstudio:

Now We go to our Unit tests projects, and they can be seen at Test Explorer. Luckily all the unit tests are green.

In the below unit test, we will violate single responsibility principle and cram multiple things to be checked. Here, we use the [Fact] attribute to denote a parameterless unit test.

We can also do the assert check for .net property change events. In the below code, we see the fact is simply going to check if the RaisePropertyChangedEvent is triggered for the friend.

In order to run single test, we can use Ctrl+R, T or Click the Run All link in the Test Explorer window, to see the results update in the Test Explorer window as the tests are run:

Advertisements

Using Unity DI with Angular + WebAPI

Unity is a Dependency Injection container. Our objective usage of Unity framework is to inject the dependencies to the dependent object. 

The Dependency Injection pattern is an implementation of Inversion of Control. IoC means that objects do not create other objects on which they rely to do their work. Instead, they get the objects that they need from an outside source.

The advantages of using Dependency Injection pattern and Inversion of Control are the following:

  • Reduces class coupling
  • Increases code reusing
  • Improves code maintainability
  • Improves application testing

Unity has an excellent documentation and support for Unity WebAPI. Unity DI is open sourced, more info here at https://github.com/unitycontainer/unity

For this demo, we have a multilayered project, whose solution looks like below

Our first step is to add Unity.WebApi to TrackerFrontEnd is via the NuGet package. You can search for unity.webapi using the GUI or type the following into the package manager console.

Install-Package Unity
install-package Unity.WebApi

Once we have installed Unity on our main project, our reference would have added required Unity packages.

Second step is to go to, web application startup.cs file and register components using unity.

Hooking them up.
Once installed the NuGet package, we need to hook it up in order to get the framework to start resolving components via Unity. The old school way, involved calling Bootstrapper.Initialise(). For the new packages, we just change this line to UnityConfig.RegisterComponents(). Once UnityConfig has registered components, it is easy for us to start registering our interfaces types with actual implementations.

Now, post hooking up Unity DI, we can inject dependencies into any controller. I prefer using constructor injection.

Call FitBit API using C#

FitBit integration is pretty easy since FitBit documentation is very detailed one and easy to pick up. In order to call FitBit apis, you need to register yourself on their development platform and do a handshake with token-based authentication. FitBit uses token-based authentication for the webbased application. So I am using asp.net MVC application as the web client.

First register yourself and get Client ID and Client secret key

https://dev.fitbit.com

Once you have registered yourself and created the application on fitbit dev environment, you will see your application below :-

As a developer, we need client ID, Client secret and callback url. We will save this information in config files. We prepare the user to redirect to Fitbit.com to prompt them to authorize this app, on successful authentication we will call the required apis from FitBit and get the data.

More info on webapi calls with request and response on FitBit website — https://dev.fitbit.com/build/reference/web-api/basics/

Once we run out webapp, we need to go to its login page. This login page is going to FitBit api, does a handshake.

We are passing same clientid and client secret for authentication.

On successful handshake, we will see our profile data from fitbit. FitBit also gives, user activity like daily steps, weekly steps, heart rate data. But that will be there for another post.

5 considerations to save your sql database from bottleneck

We all write sql queries and fetch the data from the database. Many a times, an inefficient query may pose a bottleneck on the production database’s resources, and cause slow performance for other users if the query contains errors. Most time, we write blind queries and get all the possible data, which is not even required or to be shown to the end user on the form or GRID. In most scenarios, there are few tweaks you can do to your sql queries to optimize for better good.

  1. Indexes

Database novices often find indexes mysterious or difficult. They either index nothing or they try to index everything.

2. Less is more, so select * [STAR] carefully

A common way of retrieving the desired columns is to use the * symbol even though not all the columns are really needed. If you only need a limited number of rows you should use the LIMIT clause (or your database’s equivalent). Take a look at the following code:

SELECT name, price FROM products;

SELECT name, price FROM products LIMIT 10;

3. Say no to correlated subqueries

A correlated subquery is a subquery which depends on the outer query. It uses the data obtained from the outer query in its WHERE clause. Suppose you want to list all users who have made a donation. You could retrieve the data with the following code:

SELECT user_id, last_name FROM users WHERE EXISTS (SELECT * FROM donationuser WHERE donationuser.user_id = users.user_id);

SELECT DISTINCT users.user_id FROM users INNER JOIN donationuser ON users.user_id = donationuser.user_id;

4. Avoid Wildcards

In SQL, wildcard is provided for us with ‘%’ symbol. We should be considerate for using wildcard, which will definitely slow down your query especially for table that are really huge. We can optimize our query with wildcard by doing a postfix wildcard instead of pre or full wildcard. Below are few examples.

#Full wildcard
SELECT * FROM TABLE WHERE COLUMN LIKE ‘%hello%’;
#Postfix wildcard
SELECT * FROM TABLE WHERE COLUMN LIKE ‘hello%’;
#Prefix wildcard
SELECT * FROM TABLE WHERE COLUMN LIKE ‘%hello’;
5. COUNT VS EXIST, you decide

Some of us might use COUNT operator to determine whether a particular data exist. There are many instances where we can make use of Exists. Example below:-

SELECT COLUMN FROM TABLE WHERE COUNT(COLUMN) > 0

This is a very bad query since count will search for all record exist on the table to determine the numeric value of field ‘COLUMN’.