Manipuler une collection de sous-objets dans une vue ASP.Net MVC

icon Tags de l'article : , , ,

Aout 13, 2018
Hello les devs !

Aujourd'hui on va parler d'une problématique assez commune : envoyer des sous-objets au serveur depuis une vue CSHTML.

En effet, quand on développe un site avec ASP.Net MVC, il peut arriver qu'on ait besoin, dans notre vue, de manipuler des objets qui sont en fait... une collection d'objets liés à notre objet principal.

Exemple : ma classe Guerrier qui a une propriété "Inventaire" contenant une collection d'"Objet".

Dans ma vue, j'aimerais donc pouvoir voir les objets dans l'inventaire, et si besoin... en ajouter/supprimer.

Comment faire ça ?

Et bien en fait c'est ultra simple : le moteur d'ASP.Net MVC sait tout à fait mapper des sous-objets à partir de nommages façon "tableau".

Exemple : <input type="text" name="Guerrier.Inventaire[0].Nom" value="Epée des mille vérités" />

Grâce à la syntaxe "Inventaire[0].Nom", le moteur d'ASP.Net va comprendre de lui-même qu'il s'agit du premier objet dans la liste "Inventaire" et va essayer de le créer et mapper ses propriétés.

Quelques choses à noter tout de même :
  • Attention à la numérotation, si vous avez juste un sous-objet numéroté [1], il ne sera pas mappé et récupéré.
  • Côté serveur vous ne récupérerez que ce qui a été envoyé par le client. S'il s'agit de données à sauvegarder, vous devrez faire une comparaison entre ce que vous avez en base et ce que l'utilisateur a envoyé.
  • Si vous n'avez pas de valeurs, vous n'aurez pas d'objets.
  • Si vous n'avez pas d'objets, vous ne récupérerez pas une collection vide, mais null.
  • Si jamais les champs sont disabled, ils ne seront ni récupérés, ni mappés (pratique pour activer/désactiver un objet en javascript).

Voilà,

Bonne semaine et bon dev à tous/toutes !

Bug avec bootstrap-datepicker dans sa version v4.17.45

icon Tags de l'article : , , ,

Aout 10, 2018
Hello,

Juste un micro article pour vous prévenir d'un bug dans la version 4.17.45 du bootstrap-datepicker...

Si vous êtes comme moi et que vous passez par des packages nugets, méfiez-vous : la dernière version en Nuget est la 4.17.45 qui contient des bugs.

(Dont un très chiant : si vous faites une sélection particulière en fonction du format, par exemple une sélection par mois uniquement, au 2eme clic le mode de sélection aura disparu).

Les bugs sont corrigés sur la dernière version en ligne : la 4.17.47.

N'hésitez pas à mettre à jour manuellement votre code, étant donné que le package Nuget est à la masse :(

Bon dev à tous/toutes.

Ecrire des tests unitaires pour une méthode de contrôleur d'API qui attend un fichier (ou comment mocker HttpContext)

icon Tags de l'article : , ,

Juillet 02, 2018
Hello tout le monde,

Aujourd'hui un cas de dev très spécifique : comment tester unitairement une méthode de contrôleur MVC / d'API qui attend un fichier ?

Exemple de méthode :

[HttpPost]
[Route("fromDocument")]
public IHttpActionResult CreateFromDocument()
{
	if (!Request.Content.IsMimeMultipartContent())
	{
		return InternalServerError(Resource.Error_RequestNotMimeMultipartContent);
	}

	if (HttpContext.Current.Request.Files.Count != 1)
	{
		return BadRequest(Resource.Error_FileContentIncorrect);
	}

	// We will only consider the first file
	HttpPostedFile uploadedFile = HttpContext.Current.Request.Files[0];

	if (uploadedFile.ContentLength > ConstantApplicationSettings.UploadFileSizeLimitInBytes)
	{
		return BadRequest();
	}

	uploadedFile.InputStream.Position = 0;

	string originFileName = uploadedFile.FileName.Replace("\"", string.Empty);
	_itemBusinessLogic.CreateDocument(item.Id, originFileName, uploadedFile.InputStream, CurrentUserId);

	return Ok();
}

Comment tester cette méthode ? En effet, de l'extérieur le HttpContext n'est pas accessible. Du coup comment faire croire au contrôleur qu'il recoit bien un fichier alors que ce n'est pas le cas ?

Pour ça, il faut passer par plusieurs étapes.

Déjà, la première chose importante à assimiler : il ne faut PAS mocker HttpContext.
La classe est vraiment énorme et embarque énormément de choses. La mocker ou la stubber c'est prendre le risque d'avoir du code qui casse en production sans qu'on s'en rende compte, malgré des tests unitaires parfaits.

Non, la vraie bonne pratique c'est d'interfacer nos besoins d'objets liés à HttpContext. Nous allons donc créer une interface IHttpContextAdapter :

public interface IHttpContextAdapter
{
	HttpFileCollectionBase GetFiles();
}

Comme vous le voyez, nous allons renvoyer un HttpFileCollectionBase. Pas un HttpFileCollection car il s'agit d'une classe sealed, et donc impossible à mock sans passer par de l'interception.

Du coup, implémentons cette interface dans la classe qui nous servira dans nos contrôleurs d'API :

public class HttpContextAdapter : IHttpContextAdapter
{
    public HttpFileCollectionBase GetFiles()
    {
        return new HttpFileCollectionWrapper(HttpContext.Current.Request.Files);
    }
}

Voilà. Comme vous l'avez compris, le HttpFileCollectionWrapper va permettre de transformer le HttpFileCollection en HttpFileCollectionBase, classe qu'on peut mocker / stubber car non sealed.

Du coup, injectons maintenant dans notre constructeur cette interface, et utilisons la :

public class ItemService : ApiControllerBase, IItemService
{
	public readonly IItemBusinessLogic _itemBusinessLogic;
	public readonly IHttpContextAdapter _httpContextAdapter;

    public ItemService(IItemBusinessLogic itemBusinessLogic, IHttpContextAdapter httpContextAdapter)
    {
		_itemBusinessLogic = itemBusinessLogic;
        _httpContextAdapter = httpContextAdapter;
    }
	
	[...]
}

Voilà. Et du coup, au lieu d'appeler HttpContext.Current, nous allons appeler notre _httpContextAdapter :

// avant modification
if (HttpContext.Current.Request.Files.Count != 1)
[...]
HttpPostedFile uploadedFile = HttpContext.Current.Request.Files[0];

// après modification
if (_httpContextAdapter.GetFiles().Count != 1)
[...]
HttpPostedFileBase uploadedFile = _httpContextAdapter.GetFiles().Get(0);

Ca avance, ça avance.

Mais on a toujours un problème : lorsque le contrôleur va vérifier le fichier censé être en entrée... il va faire un Request.Content.IsMimeMultipartContent()...
Or... le mock de notre HttpContext ne suffira pas à faire passer cette méthode.

Heureusement, j'ai trouvé une méthode d'extension qui permet de faire ça !
Elle va tout simplement réinitialiser le ControllerContext de notre ApiController en ajoutant un "faux" fichier de 100 bytes, avec les bons headers :

public static void InitializeMimeMultipartContent(this ApiController controller, string fileName = "filename.txt")
{
	var user = controller.User;
	Uri uri = controller.Request.RequestUri;

	var configuration = new HttpConfiguration();
	var request = new HttpRequestMessage(HttpMethod.Post, string.Empty);
	var content = new MultipartFormDataContent();

	var fileContent = new ByteArrayContent(new byte[100]);
	fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment")
	{
		FileName = fileName
	};
	content.Add(fileContent);
	request.Content = content;
	request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;

	controller.ControllerContext = new HttpControllerContext(new HttpConfiguration(), new HttpRouteData(new HttpRoute(string.Empty)), request);

	controller.User = user;
	controller.Request.RequestUri = uri;
}

La seule chose à noter est que, comme on va réinitialiser le ControllerContext, on perdra des données qui sont probablement actuellement utilisées (l'utilisateur courant, l'url courante, etc.), d'où le fait qu'on mette de côté l'utilisateur et l'url avant la réinitialisation, pour les remettre dans le contrôleur ensuite.

Et voilà, nous avons tous les outils pour pouvoir tester efficacement notre méthode !

Voici donc un test unitaire commenté utilisant tout ce qu'on vient de coder (avec RhinoMocks, mais vous devriez pouvoir adapter ce code à votre moteur de mocking) :

[Test]
public void ItemController_CreateFromDocument_WithValidData_Ok()
{
	string fileName = "file.png";
	
	// on va d'abord initialiser le contrôleur pour faire croire qu'il s'agit d'un MimeMultipartContent
	_itemController.InitializeMimeMultipartContent(fileName);

	// ensuite on va mocker les appels à GetFile() de IHttpContextAdapter
	HttpFileCollectionBase files = MockRepository.GenerateStub<HttpFileCollectionBase>();
    HttpPostedFileBase file = MockRepository.GenerateStub<HttpPostedFileBase>();
	_httpContextAdapter.Stub(p => p.GetFiles()).Return(files);
	files.Stub(p => p.Get(0)).Return(file);

	// ici on mocke le "nombre" de fichiers envoyés
	files.Stub(p => p.Count).Return(1);
	
	// maintenant, on mocke le fichier "envoyé", avec les propriétés checkées par notre contrôleur
	file.Stub(p => p.FileName).Return(fileName);
	file.Stub(p => p.ContentLength).Return(50000);
	
	// on pense aussi à renvoyer un stub pour le stream (pour éviter que les appels au stream ne plantent)
	file.Stub(p => p.InputStream).Return(MockRepository.GenerateStub<Stream>());

	// Une fois le test prêt, on appelle notre méthode de contrôleur
	HttpResponseMessage httpResponseMessage = _itemController.CreateFromDocument().GetResponse();

	// Et on n'a plus qu'à vérifier que la réponse est bien celle attendue, et que la couche métier a été appelé
	ApiControllerAssert.IsOk(httpResponseMessage);
	_itemBusinessLogic.AssertWasCalled(p => p.CreateDocument(
		Arg<string>.Is.Equal(fileName),
		Arg<Stream>.Is.NotNull,
		Arg<int>.Is.Equal(CurrentUserId)));
}

En espérant que ce soit utile à quelqu'un :)

Bon dev tout le monde !

Quelques outils que tout bon développeur .Net devrait utiliser sur ses projets

icon Tags de l'article : , , , ,

Mai 15, 2018
J'ai entendu dire, il y a longtemps, que Bill Gates avait dit :



Et c'est vrai. Quelqu'un qui n'aime pas travailler inutilement trouvera toujours des voies pour travailler plus efficacement et supprimer les tâches chiantes inutiles.

Au fil des années, je me suis rendu compte que trop peu de développeurs se posaient une question pourtant évidente : quelle tâche quotidienne et contraignante pourrais-je simplifier dans mon process de développement/test ?

La réponse est souvent : ben merde y'en a plein en fait !!!

Qu'il s'agisse de purger la base de données, de créer un compte utilisateur, de remplir la BDD avec de fausses données... il y a souvent énormément de tâches qu'un développeur pourrait automatiser pour vite gagner un maximum de temps. Et si en plus ce développement est mutualisé entre les développeurs... ben c'est un gain énorme pour toute l'équipe.

Pour ça, je voulais partager avec vous les outils que tout bon développeur .Net devrait utiliser pour ça.

1) Une extension Visual Studio

Coder sa propre extension Visual Studio n'est pas forcément évident... mais ça peut vous permettre de gagner un maximum de temps en ajoutant directement dans VS les choses chiantes que vous devez faire régulièrement.

Quelques exemples (dont certains tirés de l'extension VS de mon poste actuel) :
  • purger la base de données
  • créer un compte utilisateur de test
  • démarrer le noeud Selenium
  • tuer tous les process Chrome Selenium qui restent
  • changer la configuration de la BDD (local / tests de perfs / preprod)
  • etc.

Avoir ces options directement dans votre Visual Studio peut vous faire gagner un temps précieux. Car même juste 2 minutes par jour, sur une année ça représente une journée entière de travail...

2) Le #if DEBUG

En local, on a parfois besoin d'avoir des fonctionnements différents du fonctionnement en production. Que ce soit à cause du cache, de la quantité de données, ou même de l'initialisation de la base de données... on a parfois envie d'avoir un fonctionnement différent, pour se simplifier la vie.

Voici quelques exemples d'actions que j'ai pu automatiser par le passé, grâce au #if DEBUG :
  • au lieu d'aller chercher le catalogue complet de données en BDD (ce qui prenait 2 minutes à chaque lancement de l'application), on le stocke sérialisé sur le disque dur et on l'utilise comme tel (bim, 10 secondes de chargement au lieu de 2 minutes)
  • création automatique d'un compte par défaut si aucun compte n'existe déjà
  • connexion automatique au compte par défaut
  • extraction, anonymisation et stockage sérialisé dans des fichiers de données venant de la production, afin de pouvoir faire des calculs statistiques sans avoir à requêter directement la BDD de prod
  • forcer la connexion à la BDD locale

3) Un dossier de ressources

Là on est dans l'évidence, mais parfois ça ne fait pas de mal de rappeler les évidences : prenez des notes.

Vous galérez à trouver une procédure spécifique ? Notez là quand vous avez enfin trouvé.
Un collègue vous montre une procédure compliquée pour faire quelque chose ? Notez là.
Vous découvrez gadget super cool que vous pourriez avoir à utiliser plus tard ? Mettez le de côté.

Quand on développe, il faut aussi savoir prendre des notes. Personnellement, j'ai toujours un dossier de ressources (personnelles) chiffré.

Qu'est ce qu'on trouve dans le mien ? Enormément de choses :
  • Les logins/mdp pour chaque compte partagé lié à notre application
  • Des scripts windows/powershell pour certaines actions (backup d'une base de données, restauration, création d'un certificat)
  • Comment faire certaines actions simples/complexes dans la solution
  • Des scripts SQL pour certaines actions BDD (purge et réindex Azure, identifier la fragmentation des index, batch de suppression des anciens logs, etc.)
  • Des rappels sur certains concepts qui ont du mal à rentrer (oui, même après plus de 15 ans de dev, ça doit être le grand âge)

Ca peut sembler idiot, car souvent en 2/3 minutes sur stackoverflow on peut retrouver la solution... mais :
1) Ca permet d'avoir du spécifique pour notre situation
2) Si nos fichiers sont bien triés et nommés, on gagne du temps même par rapport à stackoverflow
3) Ca peut vous sauver la vie si vous devez refaire une opération compliquée (prévue à l'origine comme un one-shot, vous savez, le célèbre "ne t'en fais pas, c'est juste pour cette fois" d'il y a 6 mois)

4) Les tests unitaires

Bon, je ne vais pas insister sur l'importance des tests unitaires dans un projet, mais sachez ceci : vous pouvez très bien utiliser des tests unitaires pour automatiser certaines actions de dev/debug.

Quelques exemples :
  • Tester la connectionstring du projet
  • Vérifier que toutes les procédures stockées appelées sont bien présentes dans la BDD
  • Tester une procédure stockée
  • Vérifier qu'une convention de codage est bien respectée sur le projet (quand on a des règles spécifiques)

Ou même encore : créer des données en dur en base. Après tout pourquoi pas ?

4) Un logiciel d'automatisation dans le navigateur

Lorsqu'on fait du dev web, on a souvent besoin de remplir des formulaires pour tester certaines choses. Et remplir 10 fois d'affilée les même 10 champs... ben ça fatigue très vite.

Or... il existe une solution simple : les extensions Chrome/Firefox d'automatisation. Par exemple iMacros.

Ces extensions permettent d'enregistrer un enchainement d'actions faites dans le navigateur pour les reproduire ensuite. Grâce à ça, vous pourrez créer un compte, vous logger, remplir en formulaire, etc... en un seul clic.

5) Les tests Selenium

Même si les tests Selenium sont, à la base, conçus pour tester votre application, vous pouvez les utiliser pour de nombreuses choses pas forcément évidentes à première vue :
  • Tester une API
  • Tester l'interconnexion entre 2 applications
  • Aller vérifier l'état d'un autre service en ligne
  • Créer une surcouche de monitoring (quand vous n'avez qu'un board figé de monitoring et pas d'API)
  • ...

6) Les macros de Notepad++

Si vous ne les avez jamais utilisé, sachez que Notepad++ permet d'enregistrer toutes les actions produites sur une ligne, pour ensuite les reproduire sur toutes les lignes d'un fichier.

Vous avez un fichier où le format ne va pas du tout, vous devez passer un bloc à gauche, supprimer quelques caractères et rajouter un morceau à la fin ? Record => modifications => Fin => Jouer en boucle jusqu'à la fin => terminé.

Voilà, je pense que ça fait déjà pas mal,

Je vous ai épargné les grands classiques, comme les environnements d'intégration continue, car si vous n'en avez pas déjà, il y a de fortes chances que ce soit indépendant de votre volonté (je voulais concentrer cet article sur ce que les développeurs peuvent faire eux-même, sur leur poste).

J'espère que cet article vous a plu, bonne journée et bon dev à tous et toutes !

S'authentifier en POST avec un WebClient

icon Tags de l'article : ,

Aout 09, 2016
Hello,

Lorsqu'on est comme moi, on a tendance à aimer faire des tools qui vont scraper des pages web à l'aide d'un WebClient C#.

Sauf que voilà, il faut parfois pouvoir s'authentifier pour accéder à des pages qu'on aimerait parser... Et pour ça. Il y a une solution ! :)

Déjà, il va vous falloir une classe dérivée de WebClient qui gère les cookies et l'authentification :

// source : http://stackoverflow.com/questions/11118712/webclient-accessing-page-with-credentials
public class CookieAwareWebClient : WebClient
{
    public CookieAwareWebClient()
    {
        CookieContainer = new CookieContainer();
    }
    public CookieContainer CookieContainer { get; private set; }

    protected override WebRequest GetWebRequest(Uri address)
    {
        var request = (HttpWebRequest)base.GetWebRequest(address);
        request.CookieContainer = CookieContainer;
        return request;
    }
}

Maintenant, vous n'avez plus qu'à utiliser cette classe pour vous authentifier avec un UploadValues (en lui passant vos paramètres POST) :

using (var client = new CookieAwareWebClient())
{                
    // on spécifie que c'est du POST
    client.Headers.Add("Content-Type", "application/x-www-form-urlencoded");

    // cette ligne est ajoutée car parfois les authentifications vérifient le referer
    client.Headers.Add("Referer", "https://referer/if/needed");

    // on crée notre table clef / valeur
    var values = new NameValueCollection
    {
        { "username", "us3rn4me" },
        { "password", "p4ssw0rd" }
    };

    // on s'authentifie
    client.UploadValues("https://url/de/la/page/d/authentification", values);

    // et voilà, on n'a plus qu'à appeler les pages qui nous intéressent, accessibles désormais vu qu'on s'est authentifiés avec le UploadValues !
    var pageContent = client.DownloadString(url);
}

Et le tour est joué !

Bon dev à tous !

Modifier ses AppSettings et ConnectionStrings via les fichiers de config en .Net

icon Tags de l'article : , , ,

Juin 24, 2016
Hello,

Petit article, ça faisait longtemps :)

Aujourd'hui on va parler .Net, AppSettings et ConnectionStrings.

Lorsqu'on développe, la bonne pratique est d'utiliser les fichiers de configuration pour stocker nos paramètres d'application et nos chaines de connexion. Ce fichier de configuration s'appelle, pour ceux qui ne le savent pas, Web.Config ou App.Config. Exemple :

<appSettings>
     <add key="MyValue" value="42"/>
     <add key="MyIPAddress" value="::1"/>
</appSettings>
<connectionStrings>
     <add name="MyConnectionString" connectionString="Data Source=.\;Initial Catalog=MyDB;Persist Security Info=True;User ID=MyLogin;Password=MyPassword;MultipleActiveResultSets=True" />
</connectionStrings>

Classique vous me direz. Maintenant, savez vous comment faire pour que les valeurs de vos AppSettings et ConnectionStrings changent lorsque vous publiez en mode Release ?

Et oui, il faut modifier le fichier Web.Release.Config (ou App.Release.Config).

Dans ce fichier, vous pouvez ajouter de nouveaux AppSettings ou ConnectionStrings, mais vous pouvez aussi modifier les valeurs par défaut (du Web.config ou App.config)

Voici un exemple qui va :
  • Supprimer l'AppSettings MyValue
  • Modifier la valeur de l'AppSettings MyIPAddress
  • Modifier la valeur de la ConnectionString MyConnectionString

<appSettings>
     <add key="MyValue" xdt:Transform="Remove" xdt:Locator="Match(key)"/>
     <add key="MyIPAddress" value="1.2.3.4" xdt:Transform="SetAttributes" xdt:Locator="Match(key)" />
</appSettings>
<connectionStrings>
     <add name="MyConnectionString" connectionString="Server=tcp:myserver.database.windows.net,1433;Database=mydb;User ID=mylogin@mydb;Password=mypassword;Trusted_Connection=False;Encrypt=True;Connection Timeout=30;" xdt:Transform="SetAttributes" xdt:Locator="Match(name)"/>
</connectionStrings>

Simple non ?

En résumé, lors de la publication dans une config sélectionnée (debug, release ou autre) :
  • Supprimer une ligne: xdt:Transform="Remove" xdt:Locator="Match(key)"
  • Modifier la valeur d'une ligne : xdt:Transform="SetAttributes" xdt:Locator="Match(key)"
  • Ajouter une ligne : il suffit de l'ajouter dans le fichier concerné

Une dernière chose, non négligeable : ces modifications / suppressions n'impacteront pas votre application lorsque vous la lancez en local, même dans la configuration sélectionnée ! Pour ça, il faut faire les modifications à la main dans le web.config ou app.config.

Bon dev à tous !

Le célèbre bug du cookie ASP.Net qui disparait

icon Tags de l'article : , ,

Septembre 18, 2015
Tout le monde se fait avoir, et ça vient de m'arriver.

Alors que je développais tranquillement ma solution, je me suis rendu compte que ma connexion à l'application cassait juste après que je me sois connecté.

Après vérification, il s'avérait que mon cookie disparaissait sans raison dès que je faisais la moindre action après ma connexion.

J'ai tout vérifié, mon code de création de cookie était bon :

Response.Cookies["UserSettings"]["IdUser"] = user.Id.ToString();
Response.Cookies["UserSettings"]["Token"] = user.Token;
Response.Cookies["UserSettings"]["Name"] = user.FirstName + " " + user.LastName;

Response.Cookies["UserSettings"].Expires = DateTime.UtcNow.AddDays(WebAppConstants.COOKIE_LIFETIME);

D'où ça vient ? C'est très simple : je devais probablement faire un Response.Cookies à un endroit au lieu d'un Request.Cookies pour lire le contenu de mon cookie.

Et effectivement c'était le cas, à un endroit où j'essayais de lire mon cookie :
if(Response.Cookies["UserSettings"] != null && Response.Cookies["UserSettings"]["Name"] != null) 
{
     //...
}

En effet, en ASP.Net, dès qu'on essaie de lire un cookie avec Response.Cookies, un cookie qui sera automatiquement renvoyé au navigateur est créé.

Or comme on ne spécifie pas la date d'expiration du cookie... il s'agit du 01/01/0001. Et du coup, quand le navigateur recevra ce cookie, il se dira que son cookie existant est obsolète... et le supprimera.

Donc rappelez-vous en : dès qu'un cookie disparait sans raison après avoir été créé, il y a de fortes chances que vous ayez essayé d'y accéder en passant par Response.Cookies au lieu de Request.Cookies !