2017-07 on Funky Si's Test

Creating NuGet packages with VSTS

funkysi1701@gmail.com (funkysi1701) — Mon, 31 Jul 2017 20:00:45 +0000

For a while I have found myself writing the same bits of code for different web projects. This annoys me as it goes against the DRY principle (don’t repeat yourself).

One possible solution is to write your own nuget packages. You can then add this piece of code to any project you work on.

nuget.org is the public nuget feed where any developer can download nuget packages. You could publish your nuget package here, but your might want to restrict access so better to create a private nuget feed.

Lets look at how we create a nuget feed in Visual Studio. First thing you need to do is install the Package Management extension to Visual Studio Team Services (its free for less than 5 users), this will add a packages section under the build menu.

Before you can start using this new feature you need to add a Package Management License in the users hub.

Once that is done you can create a feed. You need to give your feed a name, decide if only members of the current project or everyone in your account should have access to read and contribute to.

Now you have a feed you could use the nuget package command to create a nupkg file and then nuget push command to add it to your feed. A better way is to get Visual Studio Team Services to do all the hard work.

Create a new project in Visual Studio Team Service to house your nuget package. In the build section add an empty build definition. Choose a build agent, I am using the Hosted VS2017. Then add the following steps nuget restore, Visual Studio Build, nuget pack and nuget push.

nuget restore – this step is only needed if your code depends on other packages. If it depends on other packages that are only in your feed you must specify your feed in the feeds and authentication section.
Visual Studio Build – this builds your code like you would in Visual Studio. The only config I made to this step was to specify Release in configuration.
nuget pack – this creates the nupkg file from your built project. In configuration to package specify the same as you specified in the previous step (in my case Release)
nuget push – this publishes to your feed, so of course you need to specify your feed.

One last thing to configure is to enable the continuous integration option in triggers. This means whenever you push code all these steps will run and you have a new version of your nuget package.

In Visual Studio you need to create a *.nuspec file, this contains all the meta data about your nuget package. Let look at an example.

<?xml version="1.0"?>
<package >
 <metadata>
 <id>$id$</id>
 <version>1.0.2</version>
 <title>Nuget</title>
 <authors>Simon Foster</authors>
 <owners>Simon Foster</owners>
 <requireLicenseAcceptance>false</requireLicenseAcceptance>
 <description>An example of a nuget package.</description>
 <releaseNotes>Release Notes</releaseNotes>
 <copyright>Copyright 2017</copyright>
 <projectUrl>https://[yourVSaccount].visualstudio.com/nuget/</projectUrl>
 </metadata>
</package>

One last thing to mention is version numbers. You can either change the version number in your *.nuspec file everytime you push changes. This will create stable packages like 1.0, 1.1, 1.2 etc

However you can use the automatic version number setting in the nuget pack build step. However I have found this only ever creates pre-release packages and I haven’t found a way to upgrade a package from pre-release to stable.

This is a really neat way to reuse your code in multiple projects. I have only been looking at this for a few days and I have already extracted code to do with emails, creating excel downloads and database related methods. I suspect that doing this will also have a side benefit of forcing me to create code with fewer dependencies so more code can be turned into a nuget package.

Async and Await

funkysi1701@gmail.com (funkysi1701) — Mon, 24 Jul 2017 20:00:45 +0000

For a while the Async and Await commands in c# have confused me.

Like most things the best way to learn about something is to use it in a real world example. I am currently adding an email alert feature to a website. This is an ideal example of something that would benefit from Asynchronous programming. There is no need for the webpage to wait to send 1000s of emails, lets just send a call to get started and allow the browser to carry on as normal.

This is my first try at using async and await so feel free to suggest best practises in the comments.

Lets start with a Send method in my EmailController.

public ActionResult Send(int id, int pageId, int userID)
{
 if (!Authorize.checkPageIsAuthorised(userID, (Authorize.PageIds)pageId))
 {
 return Redirect("/login");
 }
 else
 {
 Task<string> t = SendNotifications(id,userID);
 return Redirect(Request.UrlReferrer.ToString());
 }
}

This simply checks to see if you have permission to the page. If not redirects to the login page otherwise it makes a method call and redirects back to the page it came from.

Lets have a look at that method call in more detail.

Task t = SendNotification(id, userid);

SendNotification doesn’t return a normal string it returns a Task, so lets look at how we are creating this.

public async Task<string> SendNotifications(int id,string type,int userid)
{
 //logic ommitted
 await ef.SendEmail(model, emailHtmlBody);
 return "OK";
}

The return type is set to Task but it has the aysnc keyword appended to it. It also makes a call with the await keyword.

public async Task SendEmail(EmailModel model,string emailHtmlBody)
{
 //logic removed
 await smtp.SendMailAsync(message);
}

So that is it. My first bit of code that uses Async and Await. My controller calls a method asynchronously which then calls another method asynchronously which sends emails asynchronously.

Async – This enables the Await keyword to be used in the method

Await – This is where things get asynchronous. The await keyword allows the code to wait asynchronously for the long running code to complete.

How good is your SSL?

funkysi1701@gmail.com (funkysi1701) — Mon, 17 Jul 2017 20:00:45 +0000

I recently watched Troy Hunt’s What Every Developer Must Know about HTTPS course on Pluralsight. Its very good and really make you think about SSL certificates and how to correctly implement them.

One thing in particular Troy mentions is the website SSL Labs . This website allows you to test a websites implementation of SSL. A grade of A to F is assigned with A being the best and F being the worst.

Troy Hunt has a blog post where he discusses how Australian Banks score. Lets look at a few UK banks.

Bank	SSL Certificate	Grade	Home Page Under SSL
HSBC	www.hsbc.co.uk	B	Y
Nationwide	onlinebanking.nationwide.co.uk	C	N
NatWest	www.nwolb.com	C	N
Barclaycard	www.barclaycard.co.uk	A-	Y
Barclays	bank.barclays.co.uk	A-	N
Lloyds Bank	www.lloydsbank.com	A	N
Royal Bank of Scotland	www.rbsdigital.com	C	N
Standard Chartered	www.sc.com	C	Y
Virgin Money	uk.virginmoney.com	A+	Y
Santander	retail.santander.co.uk	A-	N

On the whole the ratings are all quite good with all being in the range A-C. However I have also indicated if they have SSL on the home page. Only 4 out 10 website listed above have the home page load under SSL.

Why does this matter as long as the login is under SSL? Any page that loads over http is potentially at risk from a man in the middle attack. A fake malicious home page could contain links to any page and trick users into entering personal information.

If you want to test a bank or other website not listed here. Go to https://www.ssllabs.com/ssltest/index.html and type the address that is on the SSL certificate in to the search. The good news is that this site scores a A.

Troy mentions that there is rapid growth in the adoption of SSL, there is also rapid growth in improving ratings. One of these banks went from a C to an A during the course of writing this blog.

Writing your first test

funkysi1701@gmail.com (funkysi1701) — Mon, 10 Jul 2017 20:00:45 +0000

Whenever I write a new test I have to think how best to do it. Hopefully I can summarise a few tips here to help get started.

Arrange Act Assert

The first thing I think about when writing a test is Arrange, Act, Assert. Arrange, Act, Assert is a pattern for writing the tests.

Arrange – This gets things in order ready to execute the test.

Act – This executes the method you want to test.

Assert – This compares the value produced in the Act step with a known value typically with a method similar to the following

Assert.AreEqual(expected value, actual value)

Say for example you wanted to test a method called ReturnsTrue() which does nothing but returns a value of true. This method is in a class called ReturnsTrueClass

The Arrange step in this example would be.

ReturnsTrueClass t = new ReturnsTrueClass();

The Act step in this example would be.

var result = t.ReturnTrue();

The Assert step in this example would be.

Assert.AreEqual(true, result);

This is a stupidly simple example but hopefully you get the idea of how you can build all your tests with these three steps.

Recently I saw a tweet complaining that someone has mixed up expected and actual in the Assert statement.

There is a minor but special hell reserved for those who mix up the expected and actual parameters in Assert.Equals
— Keith Williams (@zogface) July 5, 2017

At first glance this probably isn’t the worst mistake to make as if your tests are all passing actual and expected are the same.

However tests will fail, that is the whole point of them, you can then fix bits of code. If you have mixed up actual and expected it adds extra time to debugging and figuring out what values are produced from your code and what you are expecting it to produce. It may be your test uses a mocking framework and somewhere in there, there is an issue, with mixed up expected/actual you may assume a problem in your code rather than the test.

Also, how do you make such an error? When I type Assert.AreEquals() in Visual Studio, Visual Studio tells me what each parameter does, it takes a matter of seconds to do this, just by hovering over the code.

One last tip to say about tests. Write your tests to test the behaviour of your application.

Uploading Files to AWS

funkysi1701@gmail.com (funkysi1701) — Mon, 03 Jul 2017 20:00:45 +0000

I am a fan of Azure but today I have been looking at AWS. Specifically how to upload and download files.

AWS S3 stores files in Buckets. I already had an AWS S3 account setup with a Bucket. I am going to assume you have got a bucket setup and concentrate on the code to get files in and out.

First step is to use nuget to install the AWS packages. In nuget the packages you want are called AWSSDK.Core and AWSSDK.S3.

The using statements you want to use are called Amazon.S3 and Amazon.S3.Transfer, not sure why this doesn’t match nuget, this difference caught me out a couple of times.

Now to the code that uploads files

AmazonS3Client AWSclient = new AmazonS3Client(accessKeyID, secretAccessKeyID, Amazon.RegionEndpoint.EUWest1);
TransferUtility fileTransferUtility = new TransferUtility(AWSclient);
using (FileStream streamWriter = new FileStream(path, FileMode.Open))
{
 TransferUtilityUploadRequest fileTransferUtilityRequest = new TransferUtilityUploadRequest
 {
 BucketName = "flawlessimages",
 InputStream = streamWriter,
 Key = fileName
 };
 fileTransferUtility.Upload(fileTransferUtilityRequest);
}

Lets break it down and look at what it does.

AmazonS3Client AWSclient = new AmazonS3Client(accessKeyID, secretAccessKeyID, Amazon.RegionEndpoint.EUWest1);

This creates an instance of AmazonS3Client, we are passing the Access Key and Secret Access Key both of which can be found from your Amazon S3 account My Security Credentials section. Amazon.RegionEndpoint.EUWest1 specifies the amazon data centres that your bucket is located in.

TransferUtility fileTransferUtility = new TransferUtility(AWSclient);

This creates an instance of TransfterUtility using the AmazonS3Client instance we created in the previous step.

using (FileStream streamWriter = new FileStream(path, FileMode.Open))
{

This opens up a filestream from a files path and specifies that the file should be opened.

TransferUtilityUploadRequest fileTransferUtilityRequest = new TransferUtilityUploadRequest
{
 BucketName = "flawlessimages",
 InputStream = streamWriter,
 Key = fileName
};
fileTransferUtility.Upload(fileTransferUtilityRequest);

This last step specifies which bucket to upload to, what input stream to upload and the Key to use. Key is just AWS way of referring to files, more commonly referred to as the filename.

This is all you need to do to upload a file to your Bucket. The file will be located at https://s3-eu-west-1.amazonaws.com/[bucketname]/[filename] , however by default it will not be downloadable until you set Read permission to everyone, once you do that anyone who has the link will be able to download your file.

This is the same permission level as any file you have on your webserver, however AWS has a better way.

using (s3Client = new AmazonS3Client(accessKeyID, secretAccessKeyID, Amazon.RegionEndpoint.USEast1))
{
 GetPreSignedUrlRequest request1 = new GetPreSignedUrlRequest
 {
 BucketName = bucketName,
 Key = filename,
 Expires = DateTime.Now.AddMinutes(5)
 };
 urlString = s3Client.GetPreSignedURL(request1);
}

Here we are generating a url to download the file, but we are specifying that it is only valid for 5 minutes. This means that if you share the url it will only work for 5 minutes, after that AWS will give an access denied message.

This is much better security than you have on a typical web server, and easy to implement, every time a user clicks on a download link you generate a new presigned url and send the download to the browser, as long as this process doesn’t take longer than 5 minutes the user will never know.