public async Task ReturnToUserOnInvalidQuery()
        {
            itemsMocker.Setup(i => i.Add(It.Is <DbDiagram>(item => CompareSample(item, SampleDiagram))));
            contextMocker.Setup(c => c.Diagrams).Returns(itemsMocker.Object);
            testerMocker.Setup(c => c.TestTableSetup(
                                   It.Is <string>(query => SampleQuery.Equals(query))))
            .ReturnsAsync("ERROR");
            sut = new DiagramController(contextMocker.Object, testerMocker.Object);

            await sut.Create();

            await sut.Create(SampleDiagram, null);
        }
        public async Task AddDiagramOnValidQuery()
        {
            itemsMocker.Setup(i => i.Add(It.Is <DbDiagram>(item => CompareSample(item, SampleDiagram))));

            contextMocker.Setup(c => c.Diagrams).Returns(itemsMocker.Object);
            testerMocker.Setup(c => c.TestTableSetup(
                                   It.Is <string>(query => SampleQuery.Equals(query))))
            .ReturnsAsync("OK");
            contextMocker.Setup(c => c.SaveAsync()).Returns(Task.Run(() => 1)).Verifiable();
            sut = new DiagramController(contextMocker.Object, testerMocker.Object);

            await sut.Create();

            await sut.Create(SampleDiagram, null);

            contextMocker.Verify(c => c.SaveAsync(), () => Times.Once());
        }
Esempio n. 3
0
        public async Task CreateDiagramSeedsAndExercise()
        {
            db.Mock.Setup(d => d.SaveAsync()).ReturnsAsync(1);
            {
                DiagramController diagramController = new DiagramController(db, tester);
                var diagrams = (await diagramController.Index()).Model as List <DbDiagram>;

                Assert.Empty(diagrams);

                const string q1 = "CREATE TABLE tab_1(id int PRIMARY KEY, name VARCHAR(30));";

                await diagramController.Create(new DbDiagram
                {
                    Name          = "Diagram1",
                    CreationQuery = q1,
                    Diagram       = new byte[] { 1, 2, 3 }
                }, null);

                diagrams = (await diagramController.Index()).Model as List <DbDiagram>;

                Assert.Single(diagrams, d => d.Name == "Diagram1" && d.CreationQuery == q1);
            }
            {
                SeedController seedController = new SeedController(db, tester);
                var            diagram        = db.Diagrams.Single();
                var            seeds          = (await seedController.Index()).Model as IEnumerable <IGrouping <int, Seed> >;

                Assert.Empty(seeds);

                var model1 = seedController.Create(diagram.DbDiagramId).Result.Model as SeedCreateViewModel;
                Assert.Equal(model1.DiagramId, diagram.DbDiagramId);

                const string seedQuery = "INSERT INTO tab_1 (id, name) VALUES (1, 'aaa'), (2, 'bbb'), (3, 'ccc');";

                await seedController.Create(new SeedCreateViewModel
                {
                    DiagramId = diagram.DbDiagramId,
                    SeedQuery = seedQuery
                });

                Assert.Single(db.Seeds, s => s.Diagram == diagram && s.SeedQuery == seedQuery);
            }
            {
                ExerciseController exerciseController = new ExerciseController(db, exerciser, tester);
                var          diagram = db.Diagrams.Single();
                var          seed    = db.Seeds.Single();
                const string query   = "SELECT id FROM tab_1 WHERE name LIKE 'aaa';";

                var testQ = await exerciseController.TestQuery(query, diagram.DbDiagramId);

                await exerciseController.Create(new CreateExercise
                {
                    Diagram       = diagram.DbDiagramId,
                    Description   = "Exercising",
                    Title         = "Exercise_1",
                    SolutionQuery = query,
                    Difficulty    = 30
                });

                var exercise = db.Exercises.Single();
                var result   = await exerciseController.Solve(exercise.ExerciseId, "SELECT id FROM tab_1 WHERE name NOT LIKE 'bbb' AND name NOT LIKE 'ccc'");

                Assert.Single(db.Statuses, s => s.Accepted);

                result = await exerciseController.Solve(exercise.ExerciseId, "SELECT name FROM tab_1 WHERE name LIKE 'aaa'");

                Assert.All(db.Statuses, s => Assert.False(s.Resolution != null && s.Resolution.Contains("Error")));
                Assert.Single(db.Statuses, s => !s.Accepted);

                result = await exerciseController.Solve(exercise.ExerciseId, "SELECT sad");

                Assert.Single(db.Statuses, s => s.Resolution != null && s.Resolution.Contains("Error") && !s.Accepted);
            }
        }