public void GivenExistingTabThatShouldBeUpdated_UpdateTabDefinitions_UpdatesTab()
        {
            MockRepository       fakes = new MockRepository();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.PartialMock(fakes);
            List <Tab>           tabs = new List <Tab>();
            Tab existingTab           = new TestTab();

            tabs.Add(existingTab);
            tabDefinitionUpdater.Stub(updater => updater.UpdateTabDefinition(Arg <TabDefinition> .Is.Anything, Arg <Tab> .Is.Anything));
            TabDefinitionRepository fakeTabDefinitionRepository = fakes.Stub <TabDefinitionRepository>();

            tabDefinitionUpdater.TabDefinitionRepository = fakeTabDefinitionRepository;
            TabDefinition existingTabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(existingTab);

            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.GetTabDefinition(existingTab.Name)).Return(existingTabDefinition);
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.SaveTabDefinition(Arg <TabDefinition> .Is.Anything));
            tabDefinitionUpdater.TabDefinitionRepository.Replay();
            tabDefinitionUpdater.Stub(updater => updater.TabDefinitionShouldBeUpdated(existingTabDefinition, existingTab)).Return(true);
            tabDefinitionUpdater.Replay();

            tabDefinitionUpdater.UpdateTabDefinitions(tabs);

            tabDefinitionUpdater.AssertWasCalled(updater => updater.UpdateTabDefinition(existingTabDefinition, existingTab));
            tabDefinitionUpdater.TabDefinitionRepository.AssertWasCalled(factory => factory.SaveTabDefinition(existingTabDefinition));
        }
        public void GivenTabDefinitionWithAllValuesEqualToTab_TabDefinitionShouldBeUpdated_ReturnsFalse()
        {
            Tab tab = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            bool shouldBeUpdated = tabDefinitionUpdater.TabDefinitionShouldBeUpdated(tabDefinition, tab);

            Assert.False(shouldBeUpdated);
        }
        public void GivenTabDefinitionWithAllValuesEqualToTab_TabDefinitionShouldBeUpdated_ReturnsFalse()
        {
            Tab                  tab                  = new TestTab();
            TabDefinition        tabDefinition        = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            bool shouldBeUpdated = tabDefinitionUpdater.TabDefinitionShouldBeUpdated(tabDefinition, tab);

            Assert.False(shouldBeUpdated);
        }
        public void GivenTabDefinitionWithDifferentSortIndex_TabDefinitionShouldBeUpdated_ReturnsTrue()
        {
            Tab tab = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);
            tabDefinition.SortIndex++;
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            bool shouldBeUpdated = tabDefinitionUpdater.TabDefinitionShouldBeUpdated(tabDefinition, tab);

            Assert.True(shouldBeUpdated);
        }
        public void GivenTab_UpdateTabDefinition_UpdatesTabDefinitionsSortIndex()
        {
            Tab tab = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);
            tabDefinition.SortIndex = tab.SortIndex + 1;
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            tabDefinitionUpdater.UpdateTabDefinition(tabDefinition, tab);

            Assert.Equal<int>(tab.SortIndex, tabDefinition.SortIndex);
        }
        public void GivenTab_UpdateTabDefinition_UpdatesTabDefinitionsName()
        {
            Tab tab = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);
            tabDefinition.Name = TestValueUtility.CreateRandomString();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            tabDefinitionUpdater.UpdateTabDefinition(tabDefinition, tab);

            Assert.Equal<string>(tab.Name, tabDefinition.Name);
        }
        // GET api/GetData/5
        public TestTab GetTestTab(string id)
        {
            TestTab testtab = db.TestTab.Find(id);

            if (testtab == null)
            {
                throw new HttpResponseException(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            return(testtab);
        }
        public void GivenTab_UpdateTabDefinition_UpdatesTabDefinitionsRequiredAccess()
        {
            Tab tab = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);
            tabDefinition.RequiredAccess = tab.RequiredAccess + 1;
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            tabDefinitionUpdater.UpdateTabDefinition(tabDefinition, tab);

            Assert.Equal<AccessLevel>(tab.RequiredAccess, tabDefinition.RequiredAccess);
        }
        public void GivenTabDefinitionWithDifferentName_TabDefinitionShouldBeUpdated_ReturnsTrue()
        {
            Tab tab = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);
            tabDefinition.Name = TestValueUtility.CreateRandomString();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            bool shouldBeUpdated = tabDefinitionUpdater.TabDefinitionShouldBeUpdated(tabDefinition, tab);

            Assert.True(shouldBeUpdated);
        }
        public void GivenTabDefinitionWithDifferentName_TabDefinitionShouldBeUpdated_ReturnsTrue()
        {
            Tab           tab           = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);

            tabDefinition.Name = TestValueUtility.CreateRandomString();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            bool shouldBeUpdated = tabDefinitionUpdater.TabDefinitionShouldBeUpdated(tabDefinition, tab);

            Assert.True(shouldBeUpdated);
        }
        public void GivenTabDefinitionWithDifferentSortIndex_TabDefinitionShouldBeUpdated_ReturnsTrue()
        {
            Tab           tab           = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);

            tabDefinition.SortIndex++;
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            bool shouldBeUpdated = tabDefinitionUpdater.TabDefinitionShouldBeUpdated(tabDefinition, tab);

            Assert.True(shouldBeUpdated);
        }
        public void GivenTab_UpdateTabDefinition_UpdatesTabDefinitionsSortIndex()
        {
            Tab           tab           = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);

            tabDefinition.SortIndex = tab.SortIndex + 1;
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            tabDefinitionUpdater.UpdateTabDefinition(tabDefinition, tab);

            Assert.Equal <int>(tab.SortIndex, tabDefinition.SortIndex);
        }
        public void GivenTab_UpdateTabDefinition_UpdatesTabDefinitionsRequiredAccess()
        {
            Tab           tab           = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);

            tabDefinition.RequiredAccess = tab.RequiredAccess + 1;
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            tabDefinitionUpdater.UpdateTabDefinition(tabDefinition, tab);

            Assert.Equal <AccessLevel>(tab.RequiredAccess, tabDefinition.RequiredAccess);
        }
        public void GivenTab_UpdateTabDefinition_UpdatesTabDefinitionsName()
        {
            Tab           tab           = new TestTab();
            TabDefinition tabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(tab);

            tabDefinition.Name = TestValueUtility.CreateRandomString();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();

            tabDefinitionUpdater.UpdateTabDefinition(tabDefinition, tab);

            Assert.Equal <string>(tab.Name, tabDefinition.Name);
        }
        // POST api/GetData
        public HttpResponseMessage PostTestTab(TestTab testtab)
        {
            if (ModelState.IsValid)
            {
                db.TestTab.Add(testtab);
                db.SaveChanges();

                HttpResponseMessage response = Request.CreateResponse(HttpStatusCode.Created, testtab);
                response.Headers.Location = new Uri(Url.Link("DefaultApi", new { id = testtab.id }));
                return(response);
            }
            else
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }
        }
        public void GivenExistingTab_UpdateTabDefinitions_DoesNotSaveTab()
        {
            MockRepository fakes = new MockRepository();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();
            List<Tab> tabs = new List<Tab>();
            Tab existingTab = new TestTab();
            tabs.Add(existingTab);
            TabDefinitionRepository fakeTabDefinitionRepository = fakes.Stub<TabDefinitionRepository>();
            tabDefinitionUpdater.TabDefinitionRepository = fakeTabDefinitionRepository;
            TabDefinition existingTabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(existingTab);
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.GetTabDefinition(existingTab.Name)).Return(existingTabDefinition);
            tabDefinitionUpdater.TabDefinitionRepository.Replay();

            tabDefinitionUpdater.UpdateTabDefinitions(tabs);

            tabDefinitionUpdater.TabDefinitionRepository.AssertWasNotCalled(factory => factory.SaveTabDefinition(Arg<TabDefinition>.Is.Anything));
        }
        public void GivenNewTab_UpdateTabDefinitions_SavesNewTabDefinition()
        {
            MockRepository fakes = new MockRepository();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.PartialMock(fakes);
            List<Tab> tabs = new List<Tab>();
            Tab newTab = new TestTab();
            tabs.Add(newTab);
            tabDefinitionUpdater.Stub(updater => updater.UpdateTabDefinition(Arg<TabDefinition>.Is.Anything, Arg<Tab>.Is.Anything));
            tabDefinitionUpdater.Replay();
            TabDefinitionRepository fakeTabDefinitionRepository = fakes.Stub<TabDefinitionRepository>();
            tabDefinitionUpdater.TabDefinitionRepository = fakeTabDefinitionRepository;
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.GetTabDefinition(newTab.Name)).Return(null);
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.SaveTabDefinition(Arg<TabDefinition>.Is.Anything));
            tabDefinitionUpdater.TabDefinitionRepository.Replay();

            tabDefinitionUpdater.UpdateTabDefinitions(tabs);

            tabDefinitionUpdater.AssertWasCalled(updater => updater.UpdateTabDefinition(Arg<TabDefinition>.Is.NotNull, Arg<Tab>.Matches(tab => tab == newTab)));
            tabDefinitionUpdater.TabDefinitionRepository.AssertWasCalled(factory => factory.SaveTabDefinition(Arg<TabDefinition>.Is.NotNull));
        }
        public void GivenExistingTab_UpdateTabDefinitions_DoesNotSaveTab()
        {
            MockRepository       fakes = new MockRepository();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.Create();
            List <Tab>           tabs = new List <Tab>();
            Tab existingTab           = new TestTab();

            tabs.Add(existingTab);
            TabDefinitionRepository fakeTabDefinitionRepository = fakes.Stub <TabDefinitionRepository>();

            tabDefinitionUpdater.TabDefinitionRepository = fakeTabDefinitionRepository;
            TabDefinition existingTabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(existingTab);

            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.GetTabDefinition(existingTab.Name)).Return(existingTabDefinition);
            tabDefinitionUpdater.TabDefinitionRepository.Replay();

            tabDefinitionUpdater.UpdateTabDefinitions(tabs);

            tabDefinitionUpdater.TabDefinitionRepository.AssertWasNotCalled(factory => factory.SaveTabDefinition(Arg <TabDefinition> .Is.Anything));
        }
        // DELETE api/GetData/5
        public HttpResponseMessage DeleteTestTab(string id)
        {
            TestTab testtab = db.TestTab.Find(id);

            if (testtab == null)
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            db.TestTab.Remove(testtab);

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                return(Request.CreateResponse(HttpStatusCode.NotFound));
            }

            return(Request.CreateResponse(HttpStatusCode.OK, testtab));
        }
        public void GivenNewTab_UpdateTabDefinitions_SavesNewTabDefinition()
        {
            MockRepository       fakes = new MockRepository();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.PartialMock(fakes);
            List <Tab>           tabs = new List <Tab>();
            Tab newTab = new TestTab();

            tabs.Add(newTab);
            tabDefinitionUpdater.Stub(updater => updater.UpdateTabDefinition(Arg <TabDefinition> .Is.Anything, Arg <Tab> .Is.Anything));
            tabDefinitionUpdater.Replay();
            TabDefinitionRepository fakeTabDefinitionRepository = fakes.Stub <TabDefinitionRepository>();

            tabDefinitionUpdater.TabDefinitionRepository = fakeTabDefinitionRepository;
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.GetTabDefinition(newTab.Name)).Return(null);
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.SaveTabDefinition(Arg <TabDefinition> .Is.Anything));
            tabDefinitionUpdater.TabDefinitionRepository.Replay();

            tabDefinitionUpdater.UpdateTabDefinitions(tabs);

            tabDefinitionUpdater.AssertWasCalled(updater => updater.UpdateTabDefinition(Arg <TabDefinition> .Is.NotNull, Arg <Tab> .Matches(tab => tab == newTab)));
            tabDefinitionUpdater.TabDefinitionRepository.AssertWasCalled(factory => factory.SaveTabDefinition(Arg <TabDefinition> .Is.NotNull));
        }
        // PUT api/GetData/5
        public HttpResponseMessage PutTestTab(string id, TestTab testtab)
        {
            if (ModelState.IsValid && id == testtab.id)
            {
                db.Entry(testtab).State = EntityState.Modified;

                try
                {
                    db.SaveChanges();
                }
                catch (DbUpdateConcurrencyException)
                {
                    return(Request.CreateResponse(HttpStatusCode.NotFound));
                }

                return(Request.CreateResponse(HttpStatusCode.OK));
            }
            else
            {
                return(Request.CreateResponse(HttpStatusCode.BadRequest));
            }
        }
        public void GivenExistingTabThatShouldBeUpdated_UpdateTabDefinitions_UpdatesTab()
        {
            MockRepository fakes = new MockRepository();
            TabDefinitionUpdater tabDefinitionUpdater = TabDefinitionUpdaterFactory.PartialMock(fakes);
            List<Tab> tabs = new List<Tab>();
            Tab existingTab = new TestTab();
            tabs.Add(existingTab);
            tabDefinitionUpdater.Stub(updater => updater.UpdateTabDefinition(Arg<TabDefinition>.Is.Anything, Arg<Tab>.Is.Anything));
            TabDefinitionRepository fakeTabDefinitionRepository = fakes.Stub<TabDefinitionRepository>();
            tabDefinitionUpdater.TabDefinitionRepository = fakeTabDefinitionRepository;
            TabDefinition existingTabDefinition = TabDefinitionUpdaterTestsUtility.CreateTabDefinition(existingTab);
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.GetTabDefinition(existingTab.Name)).Return(existingTabDefinition);
            tabDefinitionUpdater.TabDefinitionRepository.Stub(factory => factory.SaveTabDefinition(Arg<TabDefinition>.Is.Anything));
            tabDefinitionUpdater.TabDefinitionRepository.Replay();
            tabDefinitionUpdater.Stub(updater => updater.TabDefinitionShouldBeUpdated(existingTabDefinition, existingTab)).Return(true);
            tabDefinitionUpdater.Replay();

            tabDefinitionUpdater.UpdateTabDefinitions(tabs);

            tabDefinitionUpdater.AssertWasCalled(updater => updater.UpdateTabDefinition(existingTabDefinition, existingTab));
            tabDefinitionUpdater.TabDefinitionRepository.AssertWasCalled(factory => factory.SaveTabDefinition(existingTabDefinition));
        }
示例#23
0
        private void InitializeComponent()
        {
            SuspendLayout();
            ClientSize = new Size(GUILayout.MainFormSizeWidth, GUILayout.MainFormSizeHeight);

            _githubButton = new WebBrowserButton
            {
                Size = new Size(25, 25),
                Url  = ProgramLocalization.ProjectGitHubPage,
                BackgroundImageLayout = ImageLayout.Stretch,
                BackgroundImage       = Images.Flat.GitHub,
            };

            _githubButton.SetPosition(this, PointOffset.UpRight, 0);

            _localizationComboBox = new LocalizationComboBox();

            _localizationComboBox.SetPosition(_githubButton, PointOffset.Left, 0);

            _subjectComboBox = new FixedComboBox
            {
                DropDownStyle = ComboBoxStyle.DropDownList,
            };

            _subjectComboBox.SetSize(180, ControlSizeType.Width);

            foreach (SubjectType subject in EnumUtils.GetValuesWithoutDefault <SubjectType>())
            {
                _subjectComboBox.Items.Add(Globals.Localization.Subjects[subject]);
            }

            _subjectComboBox.SelectedIndex = 0;

            _startTestButton = new FixedButton();
            _startTestButton.SetSize(125, ControlSizeType.Width);
            _startTestButton.SetPosition(_subjectComboBox, PointOffset.Right, 0);
            _startTestButton.Click += StartTestButtonOnClick;

            _testTab = new TestTab
            {
                Appearance = TabAppearance.FlatButtons,
                BackColor  = Color.Black
            };
            _testTab.SetPosition(_subjectComboBox, PointOffset.Down, 0);
            _testTab.SetSize(ClientSize.Width, ClientSize.Height - _testTab.Location.Y - 20);
            _testTab.Completed += StopTest;

            _timerLabel = new FixedLabel
            {
                AutoSize  = false,
                ForeColor = Color.Red
            };
            _timerLabel.SetSize(20, ControlSizeType.Height);
            _timerLabel.SetPosition(0, _testTab.Location.Y + _testTab.Size.Height);

            _stopTestButton = new FixedButton
            {
                Visible = false,
                Enabled = false
            };
            _stopTestButton.SetSize(120, 20);
            _stopTestButton.SetPosition(ClientSize.Width - _stopTestButton.Size.Width, _testTab.Location.Y + _testTab.Size.Height);
            _stopTestButton.Click += StopTestButtonOnClick;

            _lastGradeLabel = new FixedLabel
            {
                AutoSize  = false,
                TextAlign = ContentAlignment.MiddleCenter,
                ForeColor = Color.Red,
                Text      = @"-",
                Visible   = false
            };
            _lastGradeLabel.SetSize(30, _stopTestButton.Size.Height);
            _lastGradeLabel.SetPosition(_stopTestButton, PointOffset.Left, 0);

            _lastGradeTextLabel = new FixedLabel
            {
                AutoSize  = false,
                TextAlign = ContentAlignment.MiddleRight,
                ForeColor = Color.Red,
                Visible   = false
            };
            _lastGradeTextLabel.SetSize(120, _lastGradeLabel.Size.Height);
            _lastGradeTextLabel.SetPosition(_lastGradeLabel, PointOffset.Left, 0);

            FormBorderStyle = FormBorderStyle.FixedSingle;
            MaximizeBox     = false;
            Icon            = Resources.Resources.icon;
            Controls.Add(_githubButton);
            Controls.Add(_localizationComboBox);
            Controls.Add(_subjectComboBox);
            Controls.Add(_startTestButton);
            Controls.Add(_testTab);
            Controls.Add(_timerLabel);
            Controls.Add(_stopTestButton);
            Controls.Add(_lastGradeLabel);
            Controls.Add(_lastGradeTextLabel);
            ResumeLayout();
        }