public void Leere_ToDo_Liste() {
     var toDoListe = new contracts.datamodel.ToDoListe {
         ToDos = new List<contracts.datamodel.ToDo>()
     };
     sut.Process(toDoListe);
     Assert.That(sharedState.ToDos, Is.Empty);
 }
 public void Gefilterte_und_gelöschte_ToDos_werden_ignoriert() {
     var toDoListe = new contracts.datamodel.ToDoListe {
         ToDos = new List<contracts.datamodel.ToDo> {
             new contracts.datamodel.ToDo {Filtered = true,  Deleted = true},
             new contracts.datamodel.ToDo {Filtered = true,  Deleted = false},
             new contracts.datamodel.ToDo {Filtered = false, Deleted = true},
         }
     };
     sut.Process(toDoListe);
     Assert.That(sharedState.ToDos, Is.Empty);
 }
        public void Nicht_leere_ToDo_Liste() {
            var toDoListe = new contracts.datamodel.ToDoListe {
                ToDos = new List<contracts.datamodel.ToDo> {
                    new contracts.datamodel.ToDo(),
                    new contracts.datamodel.ToDo(),
                    new contracts.datamodel.ToDo()
                }
            };
            sut.Process(toDoListe);

            var toDos = sharedState.ToDos;
            Assert.That(toDos.Count, Is.EqualTo(3));
        }
Example #4
0
 public void Setup() {
     toDoListe = new contracts.datamodel.ToDoListe();
     sut = new ToDos_filtern();
     sut.Inject(toDoListe);
     sut.Result += x => { };
 }
Example #5
0
 public void Inject(contracts.datamodel.ToDoListe independent) {
     datamodel = independent;
 }
Example #6
0
        public static void Run() {
            var viewmodel = new ToDoListe();
            var datamodel = new contracts.datamodel.ToDoListe();

            var toDo_ergänzen = new ToDo_ergänzen();
            var toDo_löschen = new ToDo_löschen();
            var toDo_Bearbeitung_beenden = new ToDo_Bearbeitung_beenden();
            var toDo_Bearbeitung_beginnen = new ToDo_Bearbeitung_beginnen();
            var main = new Main();

            var lokale_ToDo_Liste_speichern = new Lokale_ToDo_Liste_speichern();
            var lokale_ToDo_Liste_laden = new Lokale_ToDo_Liste_laden();
            var toDo_Liste_speichern = new ToDo_Liste_speichern(
                new Throttle<contracts.datamodel.ToDoListe>(500),
                lokale_ToDo_Liste_speichern, new Synchronizer<string>());

            var toDo_Liste_in_ViewModel_übersetzen = new ToDo_Liste_in_ViewModel_uebersetzen();
            var selektierte_Ids_ermitteln = new Selektierte_Ids_ermitteln();
            var selektiertes_ToDo_ermitteln = new Selektiertes_ToDo_ermitteln();
            var geöffnetes_ToDo_ermitteln = new Geöffnetes_ToDo_ermitteln();
            var toDo_Erledigt = new ToDo_erledigt();
            var toDos_filtern = new ToDos_filtern();

            var simpleDb = new SimpleDb();
            var toDo_Listen_Synchronisieren = new ToDo_Listen_synchronisieren();

            var toDo_Liste_Synchronisieren = new ToDo_Liste_synchronisieren(
                new Asynchronizer(), 
                new Remote_ToDo_Liste_laden(simpleDb),
                toDo_Listen_Synchronisieren,
                new Synchronizer<contracts.datamodel.ToDoListe>(),
                new Remote_ToDo_Liste_speichern(simpleDb),
                toDo_Liste_speichern, 
                toDo_Liste_in_ViewModel_übersetzen);

            var toDo_Liste_laden = new ToDo_Liste_laden(lokale_ToDo_Liste_laden, toDo_Liste_in_ViewModel_übersetzen);
            var neues_ToDo_anlegen = new Neues_ToDo_anlegen(toDo_ergänzen, toDo_Liste_in_ViewModel_übersetzen, toDo_Liste_speichern);
            var selektierte_ToDos_löschen = new Selektierte_ToDos_löschen(selektierte_Ids_ermitteln, toDo_löschen, toDo_Liste_in_ViewModel_übersetzen, toDo_Liste_speichern);
            var geöffnetes_ToDo_schließen = new Geöffnetes_ToDo_schließen(geöffnetes_ToDo_ermitteln, toDo_Bearbeitung_beenden, toDo_Liste_in_ViewModel_übersetzen, toDo_Liste_speichern);
            var selektiertes_ToDo_öffnen = new Selektiertes_ToDo_öffnen(selektiertes_ToDo_ermitteln, toDo_Bearbeitung_beginnen, toDo_Liste_in_ViewModel_übersetzen, toDo_Liste_speichern);
            var geändertes_ToDo_speichern = new Selektiertes_ToDo_erledigt(toDo_Erledigt, toDo_Liste_in_ViewModel_übersetzen, toDo_Liste_speichern);
            var toDo_Liste_filtern = new ToDo_Liste_filtern(toDos_filtern, toDo_Liste_in_ViewModel_übersetzen);
            var theEntryPoint = new TheEntryPoint();

            var mainboard = new Mainboard(
                theEntryPoint,
                viewmodel,
                toDo_Liste_speichern,
                toDo_Liste_laden,
                neues_ToDo_anlegen, 
                selektierte_ToDos_löschen, 
                geöffnetes_ToDo_schließen,
                selektiertes_ToDo_öffnen,
                geändertes_ToDo_speichern,
                toDo_Liste_filtern,
                toDo_Liste_Synchronisieren,
                main);

            main.Inject(viewmodel);
            toDo_Liste_in_ViewModel_übersetzen.Inject(viewmodel);
            selektierte_Ids_ermitteln.Inject(viewmodel);
            selektiertes_ToDo_ermitteln.Inject(viewmodel);
            geöffnetes_ToDo_ermitteln.Inject(viewmodel);

            toDo_ergänzen.Inject(datamodel);
            toDo_löschen.Inject(datamodel);
            toDo_Bearbeitung_beenden.Inject(datamodel);
            toDo_Bearbeitung_beginnen.Inject(datamodel);
            toDo_Erledigt.Inject(datamodel);
            lokale_ToDo_Liste_laden.Inject(datamodel);
            toDo_Listen_Synchronisieren.Inject(datamodel);
            toDos_filtern.Inject(datamodel);

            theEntryPoint.Run();
            main.ShowDialog();
        }
        public void Eigenschaften_eines_ToDos_werden_übernommen() {
            var toDoListe = new contracts.datamodel.ToDoListe {
                ToDos = new List<contracts.datamodel.ToDo> {
                    new contracts.datamodel.ToDo {
                        Changes = true,
                        Deleted = false,
                        Erledigt = true,
                        InBearbeitung = true,
                        IsSelected = true,
                        Text = "x",
                        Tags = "z",
                        Version = 1
                    },
                }
            };
            sut.Process(toDoListe);

            var toDos = sharedState.ToDos;
            Assert.That(toDos.ElementAt(0).Changes, Is.True);
            Assert.That(toDos.ElementAt(0).Erledigt, Is.True);
            Assert.That(toDos.ElementAt(0).InBearbeitung, Is.True);
            Assert.That(toDos.ElementAt(0).IsSelected, Is.True);
            Assert.That(toDos.ElementAt(0).Text, Is.EqualTo("x"));
            Assert.That(toDos.ElementAt(0).Tags, Is.EqualTo("z"));
            Assert.That(toDos.ElementAt(0).Version, Is.EqualTo(1));
        }
 public void Default_ToDo_Liste() {
     var toDoListe = new contracts.datamodel.ToDoListe();
     sut.Process(toDoListe);
     Assert.That(sharedState.ToDos, Is.Empty);
 }
        public void Von_gelöschten_ToDos_werden_keine_Tags_gebildet() {
            var toDoListe = new contracts.datamodel.ToDoListe {
                ToDos = new List<contracts.datamodel.ToDo> {
                    new contracts.datamodel.ToDo {
                        Tags = "x",
                        Deleted = true
                    }
                }
            };
            sut.Process(toDoListe);

            Assert.That(sharedState.Tags.ElementAt(0).Tag, Is.EqualTo(ToDo_Liste_in_ViewModel_uebersetzen.Alle_ToDos));
            Assert.That(sharedState.Tags.ElementAt(0).FilterBy, Is.EqualTo(FilterBy.Nothing));
            Assert.That(sharedState.Tags.ElementAt(1).Tag, Is.EqualTo(ToDo_Liste_in_ViewModel_uebersetzen.Leeres_Tag));
            Assert.That(sharedState.Tags.ElementAt(1).FilterBy, Is.EqualTo(FilterBy.EmptyTag));
            Assert.That(sharedState.Tags.Count, Is.EqualTo(2));
        }
        public void Leere_Tags_werden_speziell_behandelt() {
            var toDoListe = new contracts.datamodel.ToDoListe {
                ToDos = new List<contracts.datamodel.ToDo> {
                    new contracts.datamodel.ToDo {
                        Tags = "   "
                    },
                    new contracts.datamodel.ToDo {
                        Tags = ""
                    }
                }
            };
            sut.Process(toDoListe);

            Assert.That(sharedState.Tags.ElementAt(0).Tag, Is.EqualTo(ToDo_Liste_in_ViewModel_uebersetzen.Alle_ToDos));
            Assert.That(sharedState.Tags.ElementAt(0).FilterBy, Is.EqualTo(FilterBy.Nothing));
            Assert.That(sharedState.Tags.ElementAt(1).Tag, Is.EqualTo(ToDo_Liste_in_ViewModel_uebersetzen.Leeres_Tag));
            Assert.That(sharedState.Tags.ElementAt(1).FilterBy, Is.EqualTo(FilterBy.EmptyTag));
            Assert.That(sharedState.Tags.Count, Is.EqualTo(2));
        }
        public void Tags_werden_aus_den_ToDos_ermittelt() {
            var toDoListe = new contracts.datamodel.ToDoListe {
                ToDos = new List<contracts.datamodel.ToDo> {
                    new contracts.datamodel.ToDo {
                        Tags = "x, y, z"
                    },
                    new contracts.datamodel.ToDo {
                        Tags = "x, a, z"
                    },
                    new contracts.datamodel.ToDo {
                        Tags = "a, b, y"
                    }
                }
            };
            sut.Process(toDoListe);

            Assert.That(sharedState.Tags.ElementAt(0).Tag, Is.EqualTo(ToDo_Liste_in_ViewModel_uebersetzen.Alle_ToDos));
            Assert.That(sharedState.Tags.ElementAt(0).FilterBy, Is.EqualTo(FilterBy.Nothing));
            Assert.That(sharedState.Tags.ElementAt(1).Tag, Is.EqualTo(ToDo_Liste_in_ViewModel_uebersetzen.Leeres_Tag));
            Assert.That(sharedState.Tags.ElementAt(1).FilterBy, Is.EqualTo(FilterBy.EmptyTag));
            Assert.That(sharedState.Tags.ElementAt(2).Tag, Is.EqualTo("x"));
            Assert.That(sharedState.Tags.ElementAt(2).FilterBy, Is.EqualTo(FilterBy.Tag));
            Assert.That(sharedState.Tags.ElementAt(3).Tag, Is.EqualTo("y"));
            Assert.That(sharedState.Tags.ElementAt(3).FilterBy, Is.EqualTo(FilterBy.Tag));
            Assert.That(sharedState.Tags.ElementAt(4).Tag, Is.EqualTo("z"));
            Assert.That(sharedState.Tags.ElementAt(4).FilterBy, Is.EqualTo(FilterBy.Tag));
            Assert.That(sharedState.Tags.ElementAt(5).Tag, Is.EqualTo("a"));
            Assert.That(sharedState.Tags.ElementAt(5).FilterBy, Is.EqualTo(FilterBy.Tag));
            Assert.That(sharedState.Tags.ElementAt(6).Tag, Is.EqualTo("b"));
            Assert.That(sharedState.Tags.ElementAt(6).FilterBy, Is.EqualTo(FilterBy.Tag));
            Assert.That(sharedState.Tags.Count, Is.EqualTo(7));
        }