Inheritance: System.Entity
        public void CanEnsureVirtualGroupCreationIsValid()
        {
            Group virtualGroupFromForm = new Group();
            ViewResult result = controller.Create(virtualGroupFromForm).AssertViewRendered();

            result.ViewData.Model.ShouldNotBeNull();
            result.ViewData.Model.ShouldBeOfType(typeof(GroupFormViewModel));
        }
        public void CanCompareVirtualGroups()
        {
            Group instance = new Group();
            instance.Name = "VAN";

            Group instanceToCompareTo = new Group();
            instanceToCompareTo.Name = "VAN";

            instance.ShouldEqual(instanceToCompareTo);
        }
 public SyndicationFeed GetFeed(Group group)
 {
     using (XmlReader reader = XmlReader.Create(group.Rss))
     {
         try
         {
             return SyndicationFeed.Load(reader);
         }
         catch (Exception)
         {
             throw;
         }
     }
 }
        public ActionResult Create(Group group)
        {
            if (ViewData.ModelState.IsValid)
            {
                ActionConfirmation saveOrUpdateConfirmation = groupManagementService.SaveOrUpdate(group);

                if (saveOrUpdateConfirmation.WasSuccessful)
                {
                    TempData[ControllerEnums.GlobalViewDataProperty.PageMessage.ToString()] = saveOrUpdateConfirmation.Message;
                    return RedirectToAction("Index");
                }
            }

            GroupFormViewModel viewModel = groupManagementService.CreateFormViewModelFor(group);
            return View(viewModel);
        }
        public void Will_aggregate_posts_from_multiple_blogs()
        {
            var blogs = new Group[]
                            {
                                GetGroup(1), GetGroup(3),
                            };
            var blogRepo = MockRepository.GenerateStub<IGroupManagementService>();
            blogRepo.Stub(x => x.GetAll()).Return(blogs);
            var postRepo = MockRepository.GenerateStub<ISyndicationFeedRepository>();

            var blog0Items = new SyndicationItem[] {new SyndicationItem(),};
            postRepo.Stub(x => x.GetFeed(blogs[0])).Return(new SyndicationFeed(blog0Items)) ;
            var blog1Items = new SyndicationItem[] { new SyndicationItem(), new SyndicationItem(), };
            postRepo.Stub(x => x.GetFeed(blogs[1])).Return(new SyndicationFeed(blog1Items));

            var posts = new BlogspotNewsProvider(blogRepo, postRepo).GetItems();
            Assert.AreEqual(3, posts.Count());
            //blog0Items.ForEach(x => Assert.That(posts.Contains(x)));
            //blog1Items.ForEach(x => Assert.That(posts.Contains(x)));
        }
 public Group GetGroup(int id)
 {
     var b = new Group();
     SharpArch.Testing.EntityIdSetter.SetIdOf(b, id);
     return b;
 }
 public GroupFormViewModel CreateFormViewModelFor(Group group)
 {
     GroupFormViewModel viewModel = CreateFormViewModel();
     viewModel.Group = group;
     return viewModel;
 }
 private void TransferFormValuesTo(Group groupToUpdate, Group groupFromForm)
 {
     groupToUpdate.Name = groupFromForm.Name;
     groupToUpdate.ShortName = groupFromForm.ShortName;
     groupToUpdate.Blog = groupFromForm.Blog;
     groupToUpdate.Rss = groupFromForm.Rss;
     groupToUpdate.Manager = groupFromForm.Manager;
     groupToUpdate.Description = groupFromForm.Description;
     groupToUpdate.StartTime = groupFromForm.StartTime;
     groupToUpdate.EndTime = groupFromForm.EndTime;
     groupToUpdate.TimeZone = groupFromForm.TimeZone;
 }
        public ActionConfirmation UpdateWith(Group groupFromForm)
        {
            Group groupToUpdate = groupRepository.Get(groupFromForm.Id);
            TransferFormValuesTo(groupToUpdate, groupFromForm);

            if (groupToUpdate.IsValid())
            {
                ActionConfirmation updateConfirmation = ActionConfirmation.CreateSuccessConfirmation(
                    "The group was successfully updated.");
                updateConfirmation.Value = groupToUpdate;

                return updateConfirmation;
            }
            else
            {
                groupRepository.DbContext.RollbackTransaction();

                return ActionConfirmation.CreateFailureConfirmation(
                    "The group could not be saved due to missing or invalid information.");
            }
        }
        public ActionConfirmation SaveOrUpdate(Group group)
        {
            if (group.IsValid())
            {
                groupRepository.SaveOrUpdate(group);

                ActionConfirmation saveOrUpdateConfirmation = ActionConfirmation.CreateSuccessConfirmation(
                    "The group was successfully saved.");
                saveOrUpdateConfirmation.Value = group;

                return saveOrUpdateConfirmation;
            }
            else
            {
                groupRepository.DbContext.RollbackTransaction();

                return ActionConfirmation.CreateFailureConfirmation(
                    "The group could not be saved due to missing or invalid information.");
            }
        }
        /// <summary>
        /// Creates a valid, transient VirtualGroup; typical of something retrieved back from a form submission
        /// </summary>
        private Group CreateTransientVirtualGroup()
        {
            Group virtualGroup = new Group() {
                Name = "VAN",
                Blog = "http://wwww.virtualaltnet.com",
                Manager = null
            };

            return virtualGroup;
        }