Habe gerade den Frühling fotografiert

Jetzt geht's (hoffentlich) endlich mit dem Frühling los. Die Knospen fangen an zu sprießen ;) Passend dazu ein Bild.

Der Frühling kommt!

Wurde aber aber auch langsam Zeit.

die Knospen sprießen!

Testbericht Nokia Lumia 610 :-)

Ich hatte jetzt ausführlich Gelegenheit mein "Nokia Lumia 610" zu testen. Hier ist der ausführliche Bericht:


Turn up the fun: Das mach ich jetzt :)

Nokia sagt selbst über dieses Telefon dass es das "Best Value Smartphone" ist. Da stelle ich mir zwingend die Frage was "Best Value" hier bedeuten soll? Meint Nokia damit vielleicht die nachfolgenden Punkte:

• Superschwacher Prozessor: Egal was man tut es hakelt und läuft nicht flüssig.
• Bahnticket als PDF öffnen dauert ewig. Im Zug hat der Schaffner schon angefangen das "Knöllchen" auszustellen. Konnte dann doch noch das Ticket vorzeigen, hat eben etwas gedauert.
• Navigation: Gerne fährt man seinem GPS Signal davon. Das Telefon scheint die Karte nicht schnell genug aktualisieren zu können.
• Bei den meisten Anwendungen kommt keine wirkliche Freude auf, da die Ladezeit mich an die guten alten C64 zurück erinnert.
• Das Telefon bootet gerne selbst. Grund ist mir hierfür leider nicht bekannt. Wahrscheinlich denkt sich das Gerät: "Was ein Windows PC kann, mach ich auch!".
• Sprachqualität ist in den meisten Fällen doch schon sehr mangelhaft. Evtl. liegt das auch zum Teil am Netzbetreiber aber ich kann mir nicht vorstellen dass ich in ganz Deutschlang schlechten Empfang habe :)
• Gerne wird im Telefon auch angezeigt, dass es keinen Empfang hat. Das bekommt man aber erst dann mit wenn der Arbeitstag rum ist und man sich denkt: "Heute war es aber ruhig". Ein Neustart behebt das Problem.
• Manche Anwendungen, die z.B. einen Kompass brauchen laufen gar nicht.
• Die Kamera hat in meiner Hosentasche einmal ein ganz gutes Bild gemacht. Da war es nämlich stockduster und das hat die Kamera auch sehr schön aufgezeichnet. Aber sobald man versucht ein Motiv zu fotografieren ist das Gerät eher Essig.
• Ok, mit Windows 7.5 ist man nicht mehr am Puls der Zeit aber das Betriebssystem an sich ist schon das was ich mir vorstelle.

Man muss allerdings fairerweise sagen dass nicht alles schlecht an diesem Telefon ist. Ich habe sogar ein Feature herausgefunden was Nokia in seiner Produktbeschreibung nicht erwähnt hat. Das Nokia Lumia 610 eignet sich besonders gut als:

• Bierdeckel

Neues Feature im Nokia Lumia 610: Die "Bierdeckel" Funktion!

Bisher habe ich keinen Ausfall beobachten können und während des Testzeitraums ist das Bier auch nicht von der Oberfläche gerutscht. Hier wurde ein 0,5 Liter "Dunkles" getestet.

So jetzt fühle ich mich besser, ich hoffe ihr auch ;)

Getting control over the time with Typemock Isolator

Let's assume we have a class like the DateTimeHelper class shown below, that has a dependency to the DateTime object and we want to write a test for it. It's untestable. All you can do is run your test every hour. But i think this is actually not a best practice. By the way it is not reproduceable and we are not able to run a test like this on a continuous integration Server. We Need to get control over the time!
See the DateTimeHelper class:

public static class DateTimeHelper
{
    /// 

    /// Returns an text according to the current time
    /// 
    /// 
    /// 
    /// Uhrzeiten die unterschieden werden sollen:
    /// 
    /// 23-6: night
    /// 7-10: morning
    /// 11-13: noon
    /// 14-22: evening
    /// 
    /// 
    public static string GetTextForCurrentDate()
    { 
        // Dependency to the DateTime Object
        // Will always return the current time
        DateTime currentTime = DateTime.Now;

        if (currentTime.Hour >= 23 || currentTime.Hour <= 6)
        {
            return "night";
        }
        if (currentTime.Hour >= 7 && currentTime.Hour <= 10)
        {
            return "morning";
        }
        if (currentTime.Hour >= 11 && currentTime.Hour <= 13)
        {
            return "noon";
        }
        if (currentTime.Hour >= 14 && currentTime.Hour <= 22)
        {
            return "evening";
        }

        throw new NotImplementedException("This sould never happen");
    }
}

But wait! There is Typemock Isolator a tool that let's you fake / mock any dependency! With Typemock we are also able to take control over the DateTime object!

In an earlier article (working sample data driven RowTest with MSTest) i explained how to do a RowTest.
The magic happens in Line 31: When DateTime.Now is called, it should return a date we have defined. Now we have the possibility to walk through all our code paths! Amazing!
The full DateTimeHelperTest class

[TestClass, Isolated(DesignMode.Pragmatic)]
public class DateTimeHelperTest
{
    private TestContext testContextInstance;
    public TestContext TestContext
    {
        get { return testContextInstance; }
        set { testContextInstance = value; }
    }

    /// 

    /// A test for GetImageForCurrentTime
    ///
    [TestMethod()]
    [DeploymentItem("BusinessLogic.Test\\TestData\\GetImageForCurrentTime_TestBoundaries.xml")]
    [DataSource("Microsoft.VisualStudio.TestTools.DataSource.XML", "|DataDirectory|\\GetImageForCurrentTime_TestBoundaries.xml", "Row", DataAccessMethod.Sequential)]
    public void GetTextForCurrentDateTest()
    {
        int hourToTest = Int32.Parse((string)TestContext.DataRow["HourToTest"]);
        string assertValue = (string)TestContext.DataRow["AssertValue"];

        Execute_GetTextForCurrentDateTest(hourToTest, assertValue);
    }

    private void Execute_GetTextForCurrentDateTest(int hourToTest, string assertValue)
    {
        string expected = assertValue;
        // If DateTime.Now is called, our DateTime wil be returned
        DateTime controlledDate = new DateTime(2013, 1, 1, hourToTest, 0, 0);
        // This is very the Typemock magic happens!
        Isolate.WhenCalled(() => DateTime.Now).WillReturn(controlledDate);

        string actual = DateTimeHelper.GetTextForCurrentDate();

        Assert.AreEqual(expected, actual);
    }
}

This is the XML File with all the neccessary test data. In my opinion it is the easiest way to simply test any hour that can occur.

<?xml version="1.0" encoding="utf-8" ?>
<Rows>
  <Row>
    <HourToTest>0</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
  <Row>
    <HourToTest>1</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
  <Row>
    <HourToTest>2</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
  <Row>
    <HourToTest>3</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
  <Row>
    <HourToTest>4</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
  <Row>
    <HourToTest>5</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
  <Row>
    <HourToTest>6</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
  <Row>
    <HourToTest>7</HourToTest>
    <AssertValue>morning</AssertValue>
  </Row>
  <Row>
    <HourToTest>8</HourToTest>
    <AssertValue>morning</AssertValue>
  </Row>
  <Row>
    <HourToTest>9</HourToTest>
    <AssertValue>morning</AssertValue>
  </Row>
  <Row>
    <HourToTest>10</HourToTest>
    <AssertValue>morning</AssertValue>
  </Row>
  <Row>
    <HourToTest>11</HourToTest>
    <AssertValue>noon</AssertValue>
  </Row>
  <Row>
    <HourToTest>12</HourToTest>
    <AssertValue>noon</AssertValue>
  </Row>
  <Row>
    <HourToTest>13</HourToTest>
    <AssertValue>noon</AssertValue>
  </Row>
  <Row>
    <HourToTest>14</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>15</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>16</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>17</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>18</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>19</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>20</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>21</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>22</HourToTest>
    <AssertValue>evening</AssertValue>
  </Row>
  <Row>
    <HourToTest>23</HourToTest>
    <AssertValue>night</AssertValue>
  </Row>
</Rows>

Related Resources

• Project files on github
• Typemocks Homepage

Working sample data driven RowTest with MSTest

it's quite frustrating getting a data-driven test running with Visual Studio 2012 and MSTest.

Here is a working sample using a XML-File as datasource for the data-driven test.

Now i'm feeling better :)

Sample of the working unit-test

XML-File:

<?xml version="1.0" encoding="utf-8" ?>
<Rows>
  <Row>
    <Country></Country>
    <Image>unknown.gif</Image>
  </Row>
  <Row>
    <Country>germany</Country>
    <Image>germany.gif</Image>
  </Row>
  <Row>
    <Country>usa</Country>
    <Image>usa.gif</Image>
  </Row>
  <Row>
    <Country>some country</Country>
    <Image>unknown.gif</Image>
  </Row>
</Rows>

Unit Test:

[TestClass]
public class CountryHandlerTest
{
    private TestContext testContextInstance;
    public TestContext TestContext
    {
        get { return testContextInstance; }
        set { testContextInstance = value; }
    }


    [TestMethod]
    [DeploymentItem("BusinessLogic.Test\\TestData\\GetImageForCountry.xml")]
    [DataSource("Microsoft.VisualStudio.TestTools.DataSource.XML", "|DataDirectory|\\GetImageForCountry.xml", "Row", DataAccessMethod.Sequential)]
    public void GetImageForCountry_SeveralTests()
    {
        // Get data out of the XML File
        string country = testContextInstance.DataRow["Country"].ToString();
        string image = testContextInstance.DataRow["Image"].ToString();

        Execute_GetImageForCountry_SeveralTests(country, image);
    }

    /// 

    /// Helper Method that executes the test
    /// 
    /// 
    /// 
    private void Execute_GetImageForCountry_SeveralTests(string country, string image)
    {
        #region Arrange

        string expected = image;
        CountryHandler target = new CountryHandler();

        #endregion

        #region Act

        string actual = target.GetImageForCountry(country);

        #endregion

        #region Assert

        Assert.AreEqual(expected, actual);

        #endregion
    }
}

Method that will be tested:

public class CountryHandler
{
    /// 

    /// Get the Image for a given country
    /// 
    /// 
    /// The following requirements must be fulfilled:
    /// 
    /// "germany" return "germany.gif"
    /// "usa" return "usa.gif"
    /// all other countries return "unknown.gif"
    /// 
    /// 
    /// 
    /// 
    public string GetImageForCountry(string country)
    {
        if (country == "germany")
        {
            return "germany.gif";
        }
        if (country == "usa")
        {
            return "usa.gif";
        }

        return "unknown.gif";
    }
}

Runnning the test gives me a nice code coverage ;)

Related Resources

• Project files on github

Fake a webservice by creating a stub

In a previous blog post i explained how to consume a webservice.
If you are developing against a webservice you will be faced with those challanges:

• the webservice is not availiable
• the webservice doesn't exist in this moment
• the webservice is kind of slow when retrieving data

Scenario:

I will use the CountryInformationService webservice located at: http://www.ezzylearning.com/services/CountryInformationService.asmx in order to retrieve the country population of a given country. I'm going to create a fake webservice returning dummy values to develop against.

Steps to be done:

• create webservice proxy class
• fake the webservice
• start a instance of the fake webservice
• run the project against the fake webservice

Files for this sample are on github

if you don't like to code by yourself. Have a look at the source for this article on github.

Detailed steps:

1. create webservice proxy class
Locate the wsdl.exe and navigate to this directory. In my case the file resides in: C:\Program Files (x86)\Microsoft SDKs\Windows\v7.0A\Bin
Use the wsdl.exe to generate the webservice interface like this:

wsdl.exe /language:CS /namespace:EnterpriseBugs.FakeWebservice.FakeService /protocol:SOAP /out:C:\projects\enterprisebugs.com-samples\FakeWebservice\FakeService\CountryInformationServiceInterfaces.cs /serverinterface http://www.ezzylearning.com/services/CountryInformationService.asmx

Browse to the file you just created: CountryInformationService.cs. Include this file into you project.

2. fake the webservice
With the just generated interface we have the ability to create a fake webservice with the same signature than the original webservice.
Add a new item to the FakeService Project: "CountryInformationService.asmx"

Now we need to replace the inheritance in class CountryInformationService.asmx.cs from System.Web.Services.WebService to ICountryInformationServiceSoap and implement the interface.

All the method bodies are implemented with a NotImplemented-exception. Nice!
Now we can start faking the behavior of the generated methods. In this example i'm not going to implement all the methods but the GetCountries()-method.

Create a private method that will return our DataSet like this:

private static DataSet PopulateDataSet()
{
    DataSet ds = new DataSet();

    #region Countries

    DataTable dtCountries = new DataTable("Countries");
    dtCountries.Columns.Add(new DataColumn("ISO2", typeof(string)));
    dtCountries.Columns.Add(new DataColumn("ISO3", typeof(string)));
    dtCountries.Columns.Add(new DataColumn("Country", typeof(string)));

    DataRow drCountries = dtCountries.NewRow();
    drCountries["ISO2"] = "AX";
    drCountries["ISO3"] = "ALA";
    drCountries["Country"] = "Aland Islands";
    dtCountries.Rows.Add(drCountries);

    drCountries = dtCountries.NewRow();
    drCountries["ISO2"] = "CN";
    drCountries["ISO3"] = "CHN";
    drCountries["Country"] = "China";
    dtCountries.Rows.Add(drCountries);

    drCountries = dtCountries.NewRow();
    drCountries["ISO2"] = "DE";
    drCountries["ISO3"] = "DEU";
    drCountries["Country"] = "Germany";
    dtCountries.Rows.Add(drCountries);

    drCountries = dtCountries.NewRow();
    drCountries["ISO2"] = "FR";
    drCountries["ISO3"] = "FRA";
    drCountries["Country"] = "France";
    dtCountries.Rows.Add(drCountries);

    ds.Tables.Add(dtCountries);

    #endregion

    return ds;
}

And then call PopulateDataSet() inside the GetCountries()-method:

public System.Data.DataSet GetCountries()
{
    return PopulateDataSet();
}

We are done with the coding issues. Let's start the webservice

3. start a instance of the fake webservice

The webservice is now running.

4. run the project against the fake webservice
Now follow the steps described in Consuming a webservice. Be sure to change the webservice URL to the just startet local webservice. This should be something similar like: http://localhost:59826/CountryInformationService.asmx. Have a look at the FakeService properties and get the Project Url:

Finally start your project by hitting "F5"!

If you want to run your code against the "real" webservice, just change the webservice URL in the project.

Related Resources

• Project files on github

Enjoy!

Consuming a webservice

Consuming a webservice is quite easy. All you need to do is getting a reference to the webservice and let Visual Studio do all the work for you ;)

Scenario:

I will use the CountryInformationService webservice located at: http://www.ezzylearning.com/services/CountryInformationService.asmx in order to retrieve the country population of a given country.

Steps in a short:

1. Create a webservice reference
2. Use the webservice ;)

Files for this sample are on github

if you don't like to code by yourself. Have a look at the source for this article on github.

Detailed steps:

1. Create a webservice reference
In my case i created a console application. Then:

Add a service reference:


Add web reference:


Insert the URL: http://www.ezzylearning.com/services/CountryInformationService.asmx. You will notice that all the availiable web service methods are listed.


Have a look at your project now. The web reference is created.

2. Use the webservice
Using the service i pretty simple. Just get an instance of the webservice and use the method.

static void Main(string[] args)
{
    // get a instance of the webservice
    CountryInformationService service = new CountryInformationService();
    // call the method
    string result = service.GetPopulationByCountry("Germany");
            
    Console.WriteLine("Germany has a population of: " + result);
    Console.ReadLine();
}

This should result in an output like this:

Related Resources

• Project files on github

SharePoint Custom Feature Activation Dependency - Ordering

Scenario: You have added multiple Features in your SharePoint project. You  have added activation dependencies to the features, but they are not activated in the order you put the activation dependencies.

Feature Name	Depends On
Feature1 (da5198d4-b81e-4098-9799-d23641c558c2)	none
Feature2 depends on Feature1 (42f35cbc-e46d-4cdd-88d3-a3e7f83ee31a)	Feature1
Feature3 depends on Feature2 (eb1d232d-8e05-4563-85ac-c0c8ff2919e8)	Feature2 depends on Feature1

Have a look at the package Explorer you will see something like this:

 

Douh! The feature order depends on how the features are ordered in the package and not like in the solution explorer.
Now the solution is simple: Just click on the feature in the package explorer and change the ordering of the features as shown:

The activation should occur as expected.