Let’s play tennis, with TDD

TDD & Code Kata’s

Now I’m working since more than four months as a software engineer at bbv Software Services in Switzerland. Every new employee at bbv needs to attend several courses (bbv Academy) to improve and extend his skills towards a good software developer. After my Scrum Master course, the next one on my schedule was Test Driven Development.

In addition to the theory why TDD, clean code and pair programming is highly desirable the course was accompanied with hands-on code kata’s. For those who don’t know what a code kata is, here is a citation from Wikipedia:

A code kata is an exercise in programming which helps a programmer hone their skills through practice and repetition.

One kata of the course was the Tennis Scorer. The goal was to implement a mechanism, which prints the score of a single game (therefore there are no sets).

Our Referee

The rules given were the following:

  1. A game is won by the first player to have won at least four points in total and at least two points more than the opponent.
  2. The running score of each game is described in a manner peculiar to tennis: scores from zero to three points are described as “love”, “fifteen”, “thirty”, and “forty” respectively.
  3. If at least three points have been scored by each player, and the scores are equal, the score is “deuce”.
  4. If at least three points have been scored by each side and a player has one more point than his opponent, the score of the game is “advantage” for the player in the lead.

Our implementation should be based on the ITennisScorer interface, which of yourse was changed during the exercise.

</span>
<pre>namespace Tennis
{
    public interface ITennisScorer
    {
        void AchievesScore(Player player);

        string GameScore { get; }
    }

    public enum Player
    {
        PlayerA,
        PlayerB
    }
}

Because it was a TDD course, we needed to build up a TODO list of appropriate unit tests first (e.g. Game just started, no one scored so far, expected score “love”).

Then we implented the unit tests one by one. Each of them had to fail first. Then came the actual implementation, test should pass afterwards. Code Refactoring -> All tests should pass.

Our Players

My initial implementation was blotched with many if statements, handling all the special cases for the game score (deuce, advantage, …). I also had code duplication, because I needed to track and update the score of player A and B separately.

But here comes the ultimate advantage of TDD. You’re not afraid anymore to refactor your code to a better architecture and solution. Because you know you can (and should) always run your unit tests and see if everything is still behaving as desired. You can sleep comfortably without to fear the next morning from an upcoming design change. Ok, I know. Some can still sleep during the nights without TDD, but they will be haunted by bad dreams 😉

So I refactored my code and eliminated the code duplication. Instead of using an enum to track the actual player score, I simply use a two-dimensional array, which holds all the possible scores of a game.

namespace Tennis
{
    public class TennisScorer : ITennisScorer
    {
        private int scoreA;
        private int scoreB;

        private const string GameA = "gameA";
        private const string GameB = "gameB";
        private const string AdvantageA = "advantageA";
        private const string AdvantageB = "advantageB";

        private static readonly string[][] PlayerScores = new[]
            {
                new[] {"love",  "15:0",     "30:0",     "40:0",     GameA},
                new[] {"0:15",  "15:15",    "30:15",    "40:15",    GameA},
                new[] {"0:30",  "15:30",    "30:30",    "40:30",    GameA},
                new[] {"0:40",  "15:40",    "30:40",    "deuce",    AdvantageA},
                new[] { GameB,   GameB,     GameB,      AdvantageB}
            };

        public void AchievesScore(Player player)
        {
            switch (player)
            {
                case Player.PlayerA:
                    UpdateGameScore(ref scoreA, ref scoreB);
                    break;
                case Player.PlayerB:
                    UpdateGameScore(ref scoreB, ref scoreA);
                    break;
            }
        }

        public string GameScore
        {
            get { return PlayerScores[scoreB][scoreA]; }
        }

        private void UpdateGameScore(ref int playerToAddScore, ref int opponentScore)
        {
            if (GameScore == AdvantageA || GameScore == AdvantageB)
            {
                opponentScore--;
            }
            else if (GameScore != GameA && GameScore != GameB)
            {
                playerToAddScore++;
            }
        }
    }
}

The Regulating Authority

I also refactored my unit tests. There were many tests, testing all the possible game processes. But my course instructor gave me the hint to use Nunit’s RowTest. Instead of writing many, almost identical tests for each case, I wrote just one parametrized unit test and the many case were provided as a parameter.

namespace Tennis.Test
{
    using NUnit.Framework;
    using FluentAssertions;

    [TestFixture]
    public class TennisScorerTest
    {
        private TennisScorer testee;

        [SetUp]
        public void SetUp()
        {
            testee = new TennisScorer();
        }

        [TestCase("", "love")]
        [TestCase("A", "15:0")]
        [TestCase("AAB", "30:15")]
        [TestCase("AAAB", "40:15")]
        [TestCase("BBB", "0:40")]
        [TestCase("BBB", "0:40")]
        [TestCase("ABABAB", "deuce")]
        [TestCase("AAABBB", "deuce")]
        [TestCase("AABBAB", "deuce")]
        [TestCase("AAABBBA", "advantageA")]
        [TestCase("AAABBBB", "advantageB")]
        [TestCase("AAAA", "gameA")]
        [TestCase("AAAAA", "gameA")]
        [TestCase("AAAABBBBBB", "gameA")]
        [TestCase("AAABBBBB", "gameB")]
        [TestCase("ABABABABABABABABABABABAA", "gameA")]
        public void PlayerScores(string game, string expectedScores)
        {
            foreach (var currentScore in game)
            {
                switch (currentScore)
                {
                    case 'A':
                        testee.AchievesScore(Player.PlayerA);
                        break;
                    case 'B':
                        testee.AchievesScore(Player.PlayerB);
                        break;
                }
            }
            testee.GameScore.Should().Be(expectedScores);
        }
    }
}

References & Coaches

If you want to practice your programming skills, I can encourage you to do some code kata’s, or similar challenges, to stay fresh in your head.

Here is a list of some useful sites with some brain-teasers and, if given, their solutions:

My Tennis Scorer implementation is available on GitHub.

2013-03-10 | Posted in: C#, Coding | Comments Closed

Debug- und Testcode haben nichts im Release zu suchen

Jaja, da hab ich mir doch die Sunrise Mein Konto App von Google Play runtergeladen. Mit der App kann man unter sein eigenes Sunrise Konto zugreifen und dabei laufende Kosten, Inklusivleistungen und Rechnungen der eigenen Produkte einsehen. Es ist wirklich eine gute App, teilweise umständlich zu navigieren aber ansonsten ist alles ersichtlich was man an Kontoinformationen braucht.

Und Windows Phone 7?

Da dachte ich mir doch: Hey, eine solche App muss ich auf dem Windows Phone 7 auch haben. Aber leider Fehlanzeige. Für WP7 gibts von Sunrise noch keine App.
Ja gut, dann schreib ich doch selber eine Sunrise Mein Konto App fürs WP7.

Doch so einfach ist das nicht: Die Verbindung zwischen App und Server ist mit SSL gesichert. Ich habe keine Ahnung welche Services (REST, SOAP?) an welchen Endpunkten aufgerufen werden. Was für Daten und in welcher Form (JSON, XML?) diese übertragen werden. Wie läuft der Login Vorgang, HTTP Authentication, GET/POST Variablen, selbstgemachtes Gemüse? Hier wurden die Hausaufgaben gut gemacht, der Datenverkehr ist verschlüsselt.

Aber ich möchte dennoch herausfinden was so vor sich geht. Machen wir doch eine Man in the Middle Attacke mit dem Emulator. Dafür werde ich meine persönlichen Login Daten opfern müssen.
Das Übliche halt:

  • Meinen PC als Proxy dazwischenschalten, am Besten mit Charles Web Debugging Proxy
  • Lokales Zertifikat erstellen wo www1.sunrise.ch als Common Name eingetragen ist
  • Das “Sunrise” in den Zertifikatsspeicher des Emulators oder eines echten Android Gerätes (Root Zugriff erforderlich) installieren
  • Applikation auf Emulator oder Android Gerät laufen lassen und mit LogCat zugleich noch den Output der App aufzeigen

Aber ich bin gerade auf Wohnungssuche, habe also keine Zeit und brauche eine schnellere Lösung 😉

Hey App, lass mich rein, ich bin Entwickler

Meine Faulheit muss ja bekanntlich belohnt werden. Und das wurde ich auch. 😀
Ich wollte sehen ob die App irgendwelchen Debug Output an LogCat sendet und habe die offizielle App von Google Play runtergeladen. Der Output war jedoch minimal. Einige Standardmeldungen wie “Login successful” kamen heraus aber nichts Auffschlussreiches über die Internals der App.

Also habe ich mich etwas am APK File zu schaffen gemacht. Mit dem APK MultiTool die App dekompiliert, und anschliessend das AppManifest.xml in Klartext geöffnet.
Folgendes ist mir aufgefallen:

  1. android:debuggable=”true” ist nicht gesetzt. Ist auch gut so, ist ja schliesslich ein Release und keine Debug Version.
  2. Eine Activity mit Namen Administration ist registriert. Lässt vermuten, dass es irgendwo in der ofiziellen App einen ServiceDialog o.ä. gibt.
Also schön das Debug Flag setzen und die XML Datei speichern. Mit dem APK MultiTool die “modifizierte” Applikation wieder in ein APK File builden und anschliessend noch erneut signieren.

Oh, ich bin ja schon drin

Und wer hätte das gedacht: Die Debug Statements wurden alle schön brav mit in die ofizielle App kompiliert. LogCat spuckte fröhlich alle möglichen Statements raus. JSON Objekte und Inhalt, Hostnamen und Pfade der jeweiligen Services, Login Infos uvm.

LogCat Output

Debug Infos im LogCat Output

Nun gut, aber was ist mit der registrierten Administration Activity? War nicht schwer herauszufinden. Sobald man im Login Screen ist, einfach mal den “Search” Button drücken (F5 im Emulator) und schon kommt man ins Service Menü, oder sollte ich besser sagen in den Test Dialog? Das neue APK File auf mein Android Gerät installiert. Übrigens: Die App lässt sich auch installieren, wenn “Installation von Nicht-Market Anwendungen zulassen” deaktiviert ist.

Fazit

Service Dialog

Service Dialog

Es ist nichts sensitives ans Tageslicht gerückt. Ich habe weder Zugriff auf vertrauliche Kundendaten erhalten oder sonstige Hinweise auf sicherheitskritische Bereiche. Da haben die Entwickler der App gute Arbeit geleistet.

Aber dennoch sollte man darum bemüht sein Debug Informationen, Testdaten, Testabläufe und sonstige interne Informationen nicht in den offiziellen Release zu veröffentlichen. Solche Daten verschwenden nicht nur zusätzlichen Speicher auf dem Phone, sondern sie können sicherheitskritische Informationen an jedermann preisgeben.

Testabläufe sollten auch möglichst mithilfe von Tools und Unit Tests vorgenommen werden und nicht mit echten Testern, welche auf Test Screens mit den Fingern herumdrücken. Solche Tests sind nicht immer einfach. Dies resultiert auch oft daraus, dass eine Entkopplung vom User Interface und der Business Logic nicht einfach zu bewerkstelligen ist. Ein guter Ansatz um eine gute Entkopplung zu erzielen und somit die Applikation “testbarer” zu machen wäre das Model View ViewModel (MVVM) Pattern.

Ich persönlich freue mich sehr über die ganze Sache. Dadurch habe ich genug Einblicke bekommen um meine Windows Phone App zu entwickeln. Die Authentisierung läuft über HTTP POST. Die Session wird mittels eines Login Keys, welcher vom Server zugewiesen wird, identifiziert und die Daten werden im JSON Format vom Server zurückgesandt.

Android: Trusting SSL certificates

Two weeks ago I got the task to establish TLS secured connections via certificates to a service endpoint.
I thought it’s not a big deal, because the endpoint already uses an EV certificate from a trusted CA (SwissSign) in Switzerland. Therefore I shouldn’t have to worry that the certificate would be considered as untrusted so I don’t have to import it to the trusted certs in the  Java  key store etc.
FAIL! I’ve got a security exception, cert is not trusted. Same problem when I visit the website with the browser. Ok, that’s bad, SwissSign is not such a big player like thawte, so, it needs some time till it will be added to the android trusted CA list. But, when I visit thawte.com, their cert is also not trusted by android. WTF?
Windows Phone and iPhone trust my SwissSign CA and don’t complain.

So, let’s ask google, stackoverflow and the blogosphere. Found a lot of solutions how to disable certificate checking entirely.
Yeah, great, this will solve my problem, my connection will be “secure” and everyone will be able to intercept my connection and inject his own certificate. But I finally found the solution with help from other sites and some testing and debugging.

The Solution

The following main steps are required to achieve a secured connection from trusted Certification Authorities.

  1. Grab all required certificates (root and any intermediate CA’s)
  2. Create a keystore with keytool and the BouncyCastle provider and import the certs
  3. Load the keystore in your android app and use it for the secured connections
    • Don’t use the standard java.net.ssl.HttpsURLConnection for the secure connection. Use the Apache HttpClient (Version 4 atm) library, which is already built-in in android. It’s built on top of the java connection libraries and is, in my opinion, faster, better modularized and easier to understand.

Step 1: Grab the certs

You have to obtain all certificates that build a chain from the endpoint certificate the whole way up to the Root CA. This means, any (if present) Intermediate CA certs and also the Root CA cert. You don’t need to obtain the endpoint certificate.
You can obtain those certs from the chain (if provided) included in the endpoint certificate or from the official site of the issuer (in my case SwissSign).

Ensure that you save the obtained certificates in the Base64 encoded X.509 format. The content should look similar to this:

-----BEGIN CERTIFICATE-----
MIIGqTC.....
-----END CERTIFICATE-----

Step 2: Create the keystore

Download the BouncyCastle Provider and store it to a known location.
Also ensure that you can invoke the keytool command (usually located under the bin folder of your JRE installation).

Now import the obtained certs (don’t import the endpoint cert) into a BouncyCastle formatted keystore.
I didn’t tested it, but I think the order of importing the certificates is important. This means, import the lowermost Intermediate CA certificate first and then all the way up to the Root CA certificate.

With the following command a new keystore (if not already present) with the password mysecret will be created and the Intermediate CA certificate will be imported. I also defined the BouncyCastle provider, where it can be found on my file system and the keystore format. Execute this command for each certificate in the chain.

keytool -importcert -v -trustcacerts -file &quot;path_to_cert/interm_ca.cer&quot; -alias IntermediateCA -keystore &quot;res/raw/myKeystore.bks&quot; -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath &quot;path_to_bouncycastle/bcprov-jdk16-145.jar&quot; -storetype BKS -storepass mysecret

Verify if the certificates were imported correctly into the keystore:

keytool -list -keystore &quot;res/raw/myKeystore.bks&quot; -provider org.bouncycastle.jce.provider.BouncyCastleProvider -providerpath &quot;path_to_bouncycastle/bcprov-jdk16-145.jar&quot; -storetype BKS -storepass mysecret

Should output the whole chain:

RootCA, 22.10.2010, trustedCertEntry, Thumbprint (MD5): 24:77:D9:A8:91:D1:3B:FA:88:2D:C2:FF:F8:CD:33:93
IntermediateCA, 22.10.2010, trustedCertEntry, Thumbprint (MD5): 98:0F:C3:F8:39:F7:D8:05:07:02:0D:E3:14:5B:29:43

Now you can copy the keystore as a raw resource in your android app under res/raw/

Step 3: Use the keystore in your app

First of all we have to create a custom Apache HttpClient that uses our keystore for HTTPS connections:

public class MyHttpClient extends DefaultHttpClient {

	final Context context;

	public MyHttpClient(Context context) {
		this.context = context;
	}

	@Override
	protected ClientConnectionManager createClientConnectionManager() {
		SchemeRegistry registry = new SchemeRegistry();
		registry.register(new Scheme(&quot;http&quot;, PlainSocketFactory.getSocketFactory(), 80));
		// Register for port 443 our SSLSocketFactory with our keystore
		// to the ConnectionManager
		registry.register(new Scheme(&quot;https&quot;, newSslSocketFactory(), 443));
		return new SingleClientConnManager(getParams(), registry);
	}

	private SSLSocketFactory newSslSocketFactory() {
		try {
			// Get an instance of the Bouncy Castle KeyStore format
			KeyStore trusted = KeyStore.getInstance(&quot;BKS&quot;);
			// Get the raw resource, which contains the keystore with
			// your trusted certificates (root and any intermediate certs)
			InputStream in = context.getResources().openRawResource(R.raw.mykeystore);
			try {
				// Initialize the keystore with the provided trusted certificates
				// Also provide the password of the keystore
				trusted.load(in, &quot;mysecret&quot;.toCharArray());
			} finally {
				in.close();
			}
			// Pass the keystore to the SSLSocketFactory. The factory is responsible
			// for the verification of the server certificate.
			SSLSocketFactory sf = new SSLSocketFactory(trusted);
			// Hostname verification from certificate
			// http://hc.apache.org/httpcomponents-client-ga/tutorial/html/connmgmt.html#d4e506
			sf.setHostnameVerifier(SSLSocketFactory.STRICT_HOSTNAME_VERIFIER);
			return sf;
		} catch (Exception e) {
			throw new AssertionError(e);
		}
	}
}

We have created our custom HttpClient, now we can just use it for secure connections. For example when we make a GET call to a REST resource.

// Instantiate the custom HttpClient
DefaultHttpClient client = new MyHttpClient(getApplicationContext());
HttpGet get = new HttpGet(&quot;https://www.mydomain.ch/rest/contacts/23&quot;);
// Execute the GET call and obtain the response
HttpResponse getResponse = client.execute(get);
HttpEntity responseEntity = getResponse.getEntity();

That’s it. Took me long to figure it out, hope this helps and saves you that time.

I really hope that the android platform will implement a better mechanism in future releases for defining which Certification Authorities should be trusted or not or just expand their own trusted CA list. If they don’t, I can’t believe they will get good acceptance from the business sector. Ok, you can control which certificates you want to trust in your app, but you still can’t add thawte as a trusted CA in the android keystore and your browser will always complain about an untrusted CA. The only way I know to eliminate this problem is to root your phone (very user friendly) and add your CA manually to the android keystore.

Feel free to comment.

Programming Life and the Zen of Computers

Ich bin kürzlich über den Blog von Scott Hanselman gestossen und war beeindruckt.

Viele State of the Art Einträge über Microsoft Produkte (auch CTPs), Codebeispiele, Guidelines und Tools, die kein Entwickler missen will.

Um stets auf dem aktuellen Stand zu bleiben bietet sich neben dem RSS Feed auch ein Weekly Podcast an.

Ein kürzlich von ihm gehaltene Präsentation Web Deployment Made Awesome: If You’re Using XCopy, You’re Doing It Wrong zeigt sehr ausdrücklich die neuen Deployment-Möglichkeiten (vorallem für ASP.NET) von Visual Studio 2010. Deployment ist an sich keine interessante Arbeit und ich bin sehr froh, dass künftig dem Entwickler dabei viel mühselige Arbeit abgenommen wird.

Besonderes Highlight: Eine ASP.NET Webaaplikation kann im Package auch die IIS Einstellungen enthalten, welche beim Deployment automatisch in den IIS geladen werden. Es können auch eigene Parameter für die Einstellungen definiert werden (siehe Präsentation @30:50). Während der Installation erstellt MSDeploy automatisch ein grafisches Eingabeformular, worin der Benutzer die Parameter bequem eingeben kann (z.B. Datenbankpassword, Webservice URL, ACL’s, …) und diese beim Einspielen in den IIS übernommen werden.

2010-03-29 | Posted in: Coding | Comments Closed