public async Task RemoveDomaine_RemovesDomainInStorage()
        {
            DecisionModel currentPrototype = this.Prototype;
            Domaine       firstDomain      = currentPrototype.Domaines.Single();
            Domaine       secondDomain     = TestingDomaineGenerator.DifferentByName().Take(1).Single();

            // Bloc 1 : création initiale de la décision
            {
                DecisionModel decision = currentPrototype;
                decision.Domaines.Add(secondDomain);

                Assert.AreEqual(2, decision.Domaines.Count);
                await this.Persister.StoreDecisionAsync(decision);
            }

            // Bloc 2 : Enlever un domaine à la décision
            {
                DecisionModel decision = (await this.Persister.FetchAllAsync()).Single();
                decision.Domaines.Remove(secondDomain);
                await this.Persister.StoreDecisionAsync(decision);
            }

            // Bloc final : vérification que la décision ne contient qu'un seul domaine
            {
                DecisionModel decision = (await this.Persister.FetchAllAsync()).Single();
                Assert.IsTrue(decision.Domaines.Contains(firstDomain));
                Assert.IsFalse(decision.Domaines.Contains(secondDomain));
            }
        }
        public async Task DeleteDecision_WithMoreThanOneDomain_ThenFetch_DoesNotFail()
        {
            DecisionModel currentPrototype = this.Prototype;
            Domaine       firstDomain      = currentPrototype.Domaines.Single();
            Domaine       secondDomain     = TestingDomaineGenerator.DifferentByName().Take(1).Single();

            // Création initiale de la décision avec un domaine
            {
                DecisionModel decision = currentPrototype;
                Assert.AreEqual(1, decision.Domaines.Count);
                await this.Persister.StoreDecisionAsync(decision);
            }

            // Bloc 2 : Ajout d'un second domaine
            {
                DecisionModel decision = (await this.Persister.FetchAllAsync()).Single();
                decision.Domaines.Add(secondDomain);
                await this.Persister.StoreDecisionAsync(decision);
            }

            // Bloc 3 : Suppresion de la décision
            {
                DecisionModel decision = (await this.Persister.FetchAllAsync()).Single();
                decision.EstSupprimée = true;
                await this.Persister.StoreDecisionAsync(decision);
            }

            // Bloc final : vérification que la décision est bien supprimée et dans deux domaines
            {
                DecisionModel decision = (await this.Persister.FetchAllAsync()).Single();

                Assert.IsTrue(decision.EstSupprimée);
                Assert.IsTrue(decision.Domaines.Contains(firstDomain));
                Assert.IsTrue(decision.Domaines.Contains(secondDomain));
            }
        }
 private static DecisionModel PrototypeDecision()
 {
     return(new DecisionModel(string.Empty, string.Empty, DateTime.Now, MockUri, TestingDomaineGenerator.DifferentByName().Take(1).ToArray()));
 }