21 October 2013

Kreatives Schweißen in Eppelheim

0 comments
Am Wochenende habe ich endlich meinen lang ersehnten Schweißkurs in Eppelheim wahrgenommen.

Es war super entspannend und vor allem sehr lehrreich.
Die Werkstatt in Eppelheim ist wirklich toll mit allen erdenklichen Werkzeugen ausgestattet gewesen die auch zur freien Verwendung bereitgestellt wurden.

Zum Ablauf:
Begonnen hat der Kurs am Samstag morgen um 09:30 Uhr mit einem leckeren Frühstück. Danach wurden uns die Grundlagen des Schweißens theoretisch beigebracht. Nach dieser kurzen Einführung ging es auch schon direkt los mit den ersten Übungen. Nach ein Paar Stunden konnte man auch die ersten brauchbaren Schweißnähte ziehen. Im Anschluss wurden wir durch ein leckeres Mittagessen gestärkt.


Am Flexen ;)
Nach dem Essen konnte jeder anfangen seine Ideen zu verwirklichen.

So endete auch der Erste Tag: Mit vielen Eindrücken und Ideen.


Am "Stolz wie Harry gucken"
Der zweite Tag begann auch wieder mit einem Frühstück ;)
Die Theorie wurde noch einmal vertieft.
Jeder durfte frei "werkeln" und konnte sich jederzeit vertrauensvoll an unsere beiden "Ausbilder" wenden.

Das Ende des Sonntags wurde mit einer "Vernissage" abgeschlossen und alle Objekte besprochen.

Ein Paar Ergebnisse

Für das nächste Mal werde ich eine Menge Schrott sammeln und habe bestimmt auch ein Paar mehr Ideen die man verwirklichen kann.
Ich kann es absolut empfehlen! Es erweitert den Horizont!

Vielen Dank noch einmal an Heinz und Brigitte unsere Ausbilder.

25 June 2013

Read XML File with PowerShell against SharePoint Client Object Model

4 comments
I was discussing with Oliver Wirkus how to use the SharePoint Client Side Object Model (CSOM) via PowerShell. We also wanted to read some configuration values from an XML file.

As CP pointed out, it is possible to get rid of the dynamic c#, which definetly Looks more elegant:
function GetWeb([string]$url)
{
    $clientContext = New-Object Microsoft.SharePoint.Client.ClientContext($url);
    [Microsoft.SharePoint.Client.Web]$web = $clientContext.Web;
    $clientContext.Load($web);
    $clientContext.ExecuteQuery();
    return $web;
}

# Used to Load the SharePoint Client DLLs from the current directory
Add-Type -Path Microsoft.SharePoint.Client.dll
Add-Type -Path Microsoft.SharePoint.Client.Runtime.dll

#Read XML File and iterate all <User> Nodes
[xml]$ConfigFile = Get-Content CSOMConfig.xml 
foreach( $user in $ConfigFile.Users.User) 
{ 
    # use XML Node "Name"
    $WebUrl="http://SOMEURL/" + $user.Name;
    # call GetWeb-method defined in CSOM code from above
    [Microsoft.SharePoint.Client.Web]$web = GetWeb($WebUrl);
} 
the corresponding CSOMConfig.xml file:
 
   
    SomeName 
   
   
    AnotherName 
   

Just for completeness. All files are located on Folder:
You can also implement this solution with dynamic c# in PowerShell:
PowerShell:
$Assem = ( 
    "Microsoft.SharePoint.Client, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c", 
    "Microsoft.SharePoint.Client.Runtime, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c",
    "System.Core, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")
$cSharp = @"
    using System;
    using System.Collections.Generic;
    using Microsoft.SharePoint.Client;
    
    namespace Enterprisebugs
    {
        public class SharePointList
        {
            public static Web GetWeb(string url)
            {
                var clientContext = new ClientContext(url);

                Web web = clientContext.Web;
                clientContext.Load(web);
                clientContext.ExecuteQuery();

                return web;
            }
        }
    }
"@

# Used to Load the SharePoint Client DLLs from the current directory
Add-Type -Path Microsoft.SharePoint.Client.dll
Add-Type -Path Microsoft.SharePoint.Client.Runtime.dll

# The CSOM code from above
Add-Type -ReferencedAssemblies $Assem -TypeDefinition $cSharp -Language CSharp;

#Read XML File and iterate all <user> Nodes
[xml]$ConfigFile = Get-Content CSOMConfig.xml 
foreach( $user in $ConfigFile.Users.User) 
{ 
    # use XML Node "Name"
    $WebUrl="http://SOMEURL/" + $user.Name;
    # call GetWeb-method defined in CSOM code from above
    [Microsoft.SharePoint.Client.Web]$web = [Enterprisebugs.SharePointList]::GetWeb($WebUrl);
} 

Cool solution to use the CSOM via PowerShell! Thanks to Oliver as well ;)

03 March 2013

Habe gerade den Frühling fotografiert

0 comments
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!

19 February 2013

Testbericht Nokia Lumia 610 :-)

2 comments
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 ;)

12 February 2013

Getting control over the time with Typemock Isolator

0 comments
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

Working sample data driven RowTest with MSTest

0 comments
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



Fake a webservice by creating a stub

0 comments
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

Enjoy!