protected override void EstablishContext()
        {
            //Prepare supplied data collections
            suppliedListOfSchoolMetricModel = GetListOfSchoolMetricModel();

            //Set up the mocks
            schoolMetricTableService = mocks.StrictMock<IService<SchoolMetricTableRequest, SchoolMetricTableModel>>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();

            //Set expectations
            Expect.Call(schoolMetricTableService.Get(null))
                .Constraints(
                    new ActionConstraint<SchoolMetricTableRequest>(x =>
                    {
                        Assert.That(x.LocalEducationAgencyId == suppliedLocalEducationAgencyId);
                        Assert.That(x.MetricVariantId == suppliedMetricVariantId);
                    })
                ).Return(new SchoolMetricTableModel { SchoolMetrics = suppliedListOfSchoolMetricModel, ListMetadata = new List<MetadataColumnGroup>() });

            Expect.Call(metadataListIdResolver.GetListId(ListType.SchoolMetricTable, SchoolCategory.None)).Return(
                MetadataListIdResolver.SchoolMetricTableListId);

            Expect.Call(listMetadataProvider.GetListMetadata(MetadataListIdResolver.SchoolMetricTableListId)).Return(getSuppliedMetadataColumnGroups());
        }
Пример #2
0
        protected override void EstablishContext()
        {
            base.BeforeExecuteTest();
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            metadataProvider = mocks.StrictMock<IListMetadataProvider>();

            Expect.Call(schoolCategoryProvider.GetSchoolCategoryType(expectedSchoolId))
                  .Return(expectedSchoolCategory);
            Expect.Call(metadataListIdResolver.GetListId(expectedListType, expectedSchoolCategory))
                  .Return(expectedMetadataListId);
            Expect.Call(metadataProvider.GetListMetadata(expectedMetadataListId))
                  .Return(expectedColumnGroups);
        }
        protected override void EstablishContext()
        {
            studentSchoolLinks = new StudentSchoolAreaLinksFake();
            studentInformationRepository = mocks.StrictMock<IRepository<StudentInformation>>();
            studentSchoolInformationRepository = mocks.StrictMock<IRepository<StudentSchoolInformation>>();
            studentListRepository = mocks.StrictMock<IRepository<StudentList>>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            classroomMetricsProvider = mocks.StrictMock<IClassroomMetricsProvider>();
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            studentListPagingProvider = mocks.StrictMock<IStudentGradeListPagingProvider>();
            accommodationProvider = mocks.StrictMock<IAccommodationProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();


            Expect.Call(schoolCategoryProvider.GetSchoolCategoryType(suppliedSchoolId1)).Repeat.Any().Return(SchoolCategory.Ungraded);
            Expect.Call(studentInformationRepository.GetAll()).Repeat.Any().Return(GetStudentInformation());
            Expect.Call(studentSchoolInformationRepository.GetAll()).Repeat.Any().Return(GetStudentSchoolInformation());
            Expect.Call(metadataListIdResolver.GetListId(ListType.StudentGrade, SchoolCategory.HighSchool)).Repeat.Twice().Return(suppliedMetadataListId);
            Expect.Call(listMetadataProvider.GetListMetadata(suppliedMetadataListId)).Repeat.Twice().Return(suppliedMetadataColumnGroupList);
            Expect.Call(accommodationProvider.GetAccommodations(null, suppliedSchoolId1)).IgnoreArguments().Return(null);

            var studentList = GetStudentList();
            Expect.Call(studentListRepository.GetAll()).Repeat.Any().Return(studentList);
            Expect.Call(classroomMetricsProvider.GetAdditionalMetrics(studentList.Single(x => x.StudentUSI == expectedStudentUSI), suppliedMetadataColumnGroupList)).IgnoreArguments().Repeat.Any().Return(suppliedAdditionalMetrics);

            Expect.Call(studentListPagingProvider
                .GetEntityList(StudentGradeListPageRequest.Create(suppliedLocalEducationAgencyId,
                                                                                          suppliedSchoolId1,
                                                                                          suppliedGrade,
                                                                                          suppliedMetadataColumnGroupList,
                                                                                          suppliedSortColumn,
                                                                                          suppliedSortDirection)))
                .Repeat.Any().IgnoreArguments().Return(GetStudentListGradePageData().Select(x => new StudentSchoolIdentifier { StudentUSI = x.StudentUSI, SchoolId = x.SchoolId }));

            Expect.Call(studentListPagingProvider
                .GetPageData(StudentGradeListPageRequest.Create(suppliedLocalEducationAgencyId,
                                                                                            null,
                                                                                            suppliedGrade,
                                                                                            string.Empty,
                                                                                            suppliedMetadataColumnGroupList,
                                                                                            suppliedSortColumn,
                                                                                            suppliedSortDirection,
                                                                                            suppliedVisibleColumns)))
                .Repeat.Any().IgnoreArguments().Return(GetStudentListGradePageData());

            base.EstablishContext();
        }
Пример #4
0
        protected override void EstablishContext()
        {
            studentSchoolLinks = new StudentSchoolAreaLinksFake();
            staffCohortRepository = mocks.StrictMock<IRepository<StaffCohort>>();
            staffCustomStudentListStudentRepository = mocks.StrictMock<IRepository<StaffCustomStudentListStudent>>();
            staffCustomStudentListRepository = mocks.StrictMock<IRepository<StaffCustomStudentList>>();
            uniqueListProvider = mocks.StrictMock<IUniqueListIdProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            classroomMetricsProvider = mocks.StrictMock<IClassroomMetricsProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();
            studentListWithMetricsProvider = mocks.StrictMock<IStudentMetricsProvider>();

            Expect.Call(uniqueListProvider.GetUniqueId()).Return("StudentList" + suppliedStaffUSI);
            Expect.Call(staffCohortRepository.GetAll()).Repeat.Any().Return(GetStaffCohorts());
            Expect.Call(staffCustomStudentListRepository.GetAll()).Repeat.Any().Return(GetStaffCustomStudentLists());
            Expect.Call(staffCustomStudentListStudentRepository.GetAll()).Repeat.Any().Return(GetStaffCustomStudentListStudents());

            Expect.Call(metadataListIdResolver.GetListId(ListType.StudentDemographic, SchoolCategory.HighSchool)).Return(suppliedMetadataListId);
            Expect.Call(listMetadataProvider.GetListMetadata(suppliedMetadataListId)).Return(suppliedMetadataColumnGroupList);

            Expect.Call(studentListWithMetricsProvider.GetOrderedStudentList(null))
                  .Repeat.Any()
                  .IgnoreArguments()
                  .Return(GetStudentList());

            Expect.Call(studentListWithMetricsProvider.GetStudentsWithMetrics(null))
                  .Repeat.Any()
                  .IgnoreArguments()
                  .Return(new List<StudentMetric>().AsQueryable());

            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForSorting("1")).IgnoreArguments().Repeat.Any().Return(1);
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForDisplay("1")).IgnoreArguments().Repeat.Any().Return("1");

            Expect.Call(classroomMetricsProvider.GetAdditionalMetrics(null, null)).IgnoreArguments().Repeat.Any().Return(suppliedAdditionalMetrics);

            base.EstablishContext();
        }
        protected override void EstablishContext()
        {
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            metricCorrelationService = mocks.StrictMock<IMetricCorrelationProvider>();
            footnoteRepository = mocks.StrictMock<IRepository<MetricInstanceFootnote>>();
            classroomMetricsProvider = mocks.StrictMock<IClassroomMetricsProvider>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            metricNodeResolver = mocks.StrictMock<IMetricNodeResolver>();
            StudentMetricProvider = mocks.StrictMock<IStudentMetricsProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();
            schoolMetricStudentListRepository = mocks.StrictMock<IRepository<SchoolMetricStudentList>>();

            Expect.Call(StudentMetricProvider.GetOrderedStudentList(null, null, null)).Repeat.Any().IgnoreArguments().Return(GetSuppliedStudentList());
            Expect.Call(StudentMetricProvider.GetStudentsWithMetrics(null)).Repeat.Any().IgnoreArguments().Return(GetStudentListPageData());
            Expect.Call(metricCorrelationService.GetRenderingParentMetricVariantIdForStudent(suppliedMetricVariantId, suppliedSchoolId)).Repeat.Any().Return(new MetricCorrelationProvider.MetricRenderingContext { MetricVariantId = suppliedRenderingMetricVariantId, ContextMetricVariantId = suppliedContextMetricVariantId });
            Expect.Call(metricNodeResolver.GetMetricNodeForSchoolFromMetricVariantId(suppliedSchoolId, suppliedMetricVariantId)).Repeat.AtLeastOnce().Return(GetSuppliedMetricMetadataNode());
            Expect.Call(footnoteRepository.GetAll()).Repeat.Any().Return(GetSuppliedMetricFootnotes());
            Expect.Call(metadataListIdResolver.GetListId(ListType.ClassroomGeneralOverview, SchoolCategory.HighSchool)).IgnoreArguments().Repeat.Any().Return(1);
            Expect.Call(schoolMetricStudentListRepository.GetAll()).Return(GetSchoolMetricStudentList());

            suppliedMetadataColumnGroupList = GetSuppliedListMetadata();
            Expect.Call(listMetadataProvider.GetListMetadata(1)).IgnoreArguments().Repeat.Any().Return(suppliedMetadataColumnGroupList);

            Expect.Call(classroomMetricsProvider.GetAdditionalMetrics(null, null))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(new List<StudentWithMetrics.Metric>());

            expectedStudentIds.Clear();
            expectedStudentIds.Add(suppliedStudentId1);
            expectedStudentIds.Add(suppliedStudentId2);
            expectedStudentIds.Add(suppliedStudentId3);
            expectedStudentIds.Add(suppliedStudentId4);

            expectedSchoolCategory = SchoolCategory.HighSchool;

            base.EstablishContext();
        }
        protected override void EstablishContext()
        {
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            uniqueListProvider = mocks.StrictMock<IUniqueListIdProvider>();
            metricCorrelationService = mocks.StrictMock<IMetricCorrelationProvider>();
            classroomMetricsProvider = mocks.StrictMock<IPriorYearClassroomMetricsProvider>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            metricNodeResolver = mocks.StrictMock<IMetricNodeResolver>();
            warehouseAvailabilityProvider = mocks.StrictMock<IWarehouseAvailabilityProvider>();
            maxPriorYearProvider = mocks.StrictMock<IMaxPriorYearProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();
            priorYearStudentMetricsProvider = mocks.StrictMock<IPriorYearStudentMetricsProvider>();
            studentMetricsProvider = mocks.StrictMock<IStudentMetricsProvider>();

            Expect.Call(maxPriorYearProvider.Get(suppliedLocalEducationAgencyId)).Repeat.Any().Return(2011);
            Expect.Call(metricNodeResolver.GetMetricNodeForSchoolFromMetricVariantId(suppliedSchoolId,
                suppliedMetricVariantId)).Repeat.Any().Return(GetSuppliedMetricMetadataNode());
            Expect.Call(metricCorrelationService.GetRenderingParentMetricVariantIdForStudent(suppliedMetricVariantId,
                suppliedSchoolId)).Repeat.Any()
                .Return(new MetricCorrelationProvider.MetricRenderingContext
                {
                    MetricVariantId = suppliedRenderingMetricVariantId,
                    ContextMetricVariantId = suppliedContextMetricVariantId
                });
            Expect.Call(uniqueListProvider.GetUniqueId(suppliedMetricVariantId)).Repeat.Any().Return(suppliedUniqueListId);
            Expect.Call(metadataListIdResolver.GetListId(ListType.ClassroomGeneralOverview, SchoolCategory.HighSchool))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(1);
            Expect.Call(listMetadataProvider.GetListMetadata(1))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(GetSuppliedListMetadata());
            Expect.Call(priorYearStudentMetricsProvider.GetStudentList(GetPriorYearStudentListWithMetricsQueryOptions()))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(GetExpectedPriorYearStudentList());
            Expect.Call(studentMetricsProvider.GetOrderedStudentList(GetStudentListWithMetricsQueryOptions()))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(
                    GetStudentSectionEntityListData()
                        .Where(x => expectedStudentIds.Contains(x.StudentUSI) && x.SchoolId == suppliedSchoolId)
                        .AsQueryable());
            Expect.Call(
                priorYearStudentMetricsProvider.GetStudentsWithMetrics(GetPriorYearStudentListWithMetricsQueryOptions()))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(
                    GetSuppliedPriorYearSchoolMetricStudentList()
                        .Where(x => expectedStudentIds.Contains(x.StudentUSI) && x.SchoolId == suppliedSchoolId));
            Expect.Call(studentMetricsProvider.GetStudentsWithMetrics(GetStudentListWithMetricsQueryOptions()))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(
                    GetStudentListSectionPageData()
                        .Where(x => expectedStudentIds.Contains(x.StudentUSI) && x.SchoolId == suppliedSchoolId)
                        .AsQueryable());
            Expect.Call(classroomMetricsProvider.GetAdditionalMetrics(null, null, null))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(new List<StudentWithMetrics.Metric>());

            base.EstablishContext();
        }
        protected override void EstablishContext()
        {
            enhancedStudentInformationRepository = mocks.StrictMock<IRepository<EnhancedStudentInformation>>();
            teacherStudentSectionRepository = mocks.StrictMock<IRepository<TeacherStudentSection>>();
            teacherSectionRepository = mocks.StrictMock<IRepository<TeacherSection>>();
            staffStudentCohortRepository = mocks.StrictMock<IRepository<StaffStudentCohort>>();
            staffCohortRepository = mocks.StrictMock<IRepository<StaffCohort>>();
            staffCustomStudentListStudentRepository = mocks.StrictMock<IRepository<StaffCustomStudentListStudent>>();
            staffCustomStudentListRepository = mocks.StrictMock<IRepository<StaffCustomStudentList>>();

            accommodationProvider = mocks.StrictMock<IAccommodationProvider>();
            uniqueListIdProvider = mocks.StrictMock<IUniqueListIdProvider>();
            trendRenderingDispositionProvider = mocks.StrictMock<ITrendRenderingDispositionProvider>();
            rootMetricNodeResolver = mocks.StrictMock<IRootMetricNodeResolver>();
            metricStateProvider = mocks.StrictMock<IMetricStateProvider>();
            studentMetricObjectiveRepository = mocks.StrictMock<IRepository<StudentMetricObjective>>();

            assessmentDetailsProvider = mocks.StrictMock<IAssessmentDetailsProvider>();
            assessmentBenchmarkDetailsProvider = mocks.StrictMock<IAssessmentBenchmarkDetailsProvider>();
            studentMetricsProvider = mocks.StrictMock<IStudentMetricsProvider>();
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            classroomMetricsProvider = mocks.StrictMock<IClassroomMetricsProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();

            Expect.Call(studentMetricObjectiveRepository.GetAll()).Return(GetSuppliedStudentMetricObjective());
            Expect.Call(teacherStudentSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherStudentSection());
            Expect.Call(teacherSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherSection());
            Expect.Call(staffStudentCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffStudentCohort());
            Expect.Call(staffCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCohort());

            Expect.Call(staffCustomStudentListRepository.GetAll()).Repeat.Any().Return(new List<StaffCustomStudentList>().AsQueryable() );
            Expect.Call(staffCustomStudentListStudentRepository.GetAll()).Repeat.Any().Return(new List<StaffCustomStudentListStudent>().AsQueryable());

            Expect.Call(studentMetricsProvider.GetOrderedStudentList(null, null, null)).IgnoreArguments().Return(SuppliedStudentList.AsQueryable().Where(x => x.SchoolId == suppliedSchoolId && expectedStudentIds.Contains(x.StudentUSI)));
            Expect.Call(studentMetricsProvider.GetStudentsWithMetrics(null)).IgnoreArguments().Return(SuppliedStudentMetrics.AsQueryable());
            Expect.Call(schoolCategoryProvider.GetSchoolCategoryType(suppliedSchoolId)).Return(SchoolCategory.HighSchool);
            Expect.Call(uniqueListIdProvider.GetUniqueId()).Return(suppliedUniqueListId);
            Expect.Call(metadataListIdResolver.GetListId(ListType.ClassroomGeneralOverview, SchoolCategory.HighSchool)).Return(0);
            Expect.Call(rootMetricNodeResolver.GetRootMetricNodeForStudent(suppliedSchoolId)).Repeat.Any().Return(GetStudentRootOverviewNode());
            Expect.Call(listMetadataProvider.GetListMetadata(0)).Return(new List<MetadataColumnGroup>());
            Expect.Call(assessmentDetailsProvider.GetStudentsFixedRowTitle(suppliedAssessmentSubType, suppliedSubjectArea)).Return(string.Empty);
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForSorting(null)).IgnoreArguments().Return(23).Repeat.Times(expectedStudentIds.Count);
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForDisplay(null)).IgnoreArguments().Return("Formatted").Repeat.Times(expectedStudentIds.Count);
            
            Expect.Call(classroomMetricsProvider.GetAdditionalMetrics(null, null)).IgnoreArguments()
                .Do(new Func<IEnumerable<StudentMetric>, List<MetadataColumnGroup>, List<StudentWithMetrics.Metric>>((arg1, arg2) => new List<StudentWithMetrics.Metric>()))
                .Repeat.Times(expectedStudentIds.Count);

            Expect.Call(assessmentBenchmarkDetailsProvider.GetObjectiveColumnWidth()).Return(string.Empty).Repeat.Times(expectedObjectiveTitleCount);
            Expect.Call(assessmentBenchmarkDetailsProvider.GetMetricIdsForObjectives(suppliedSubjectArea)).Return(new[] { requestedMetricId }).Repeat.Times(1);
            Expect.Call(assessmentBenchmarkDetailsProvider.OnStudentAssessmentInitialized(null, null, StaffModel.SubjectArea.None)).IgnoreArguments()
                .Return(new StudentWithMetrics.IndicatorMetric
                {
                    MetricVariantId = requestedMetricId,
                    MetricIndicator = 1,
                    StudentUSI = 1,
                    UniqueIdentifier = 1,
                    DisplayValue = "some value",
                    State = MetricStateType.Good,
                    Value = "some other value",
                })
                .Repeat.Times(expectedStudentIds.Count);

            base.EstablishContext();
        }
Пример #8
0
        protected override void EstablishContext()
        {
            base.EstablishContext();

            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            studentListWithMetricsProvider = mocks.StrictMock<IStudentMetricsProvider>();

            teacherStudentSectionRepository = mocks.StrictMock<IRepository<TeacherStudentSection>>();
            teacherSectionRepository = mocks.StrictMock<IRepository<TeacherSection>>();
            staffStudentCohortRepository = mocks.StrictMock<IRepository<StaffStudentCohort>>();
            staffCohortRepository = mocks.StrictMock<IRepository<StaffCohort>>();
            staffCustomStudentListRepository = mocks.StrictMock<IRepository<StaffCustomStudentList>>();
            staffCustomStudentListStudentRepository = mocks.StrictMock<IRepository<StaffCustomStudentListStudent>>();
            watchListManager = mocks.StrictMock<IStudentWatchListManager>();

            Expect.Call(teacherStudentSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherStudentSection());
            Expect.Call(teacherSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherSection());
            Expect.Call(staffStudentCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffStudentCohort());
            Expect.Call(staffCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCohort());
            Expect.Call(staffCustomStudentListRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCustomStudentList());
            Expect.Call(staffCustomStudentListStudentRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCustomStudentListStudent());
            Expect.Call(schoolCategoryProvider.GetSchoolCategoryType(suppliedSchoolId)).Repeat.Any().IgnoreArguments().Return(SchoolCategory.HighSchool);
            Expect.Call(metadataListIdResolver.GetListId(ListType.ClassroomGeneralOverview, SchoolCategory.HighSchool)).IgnoreArguments().Repeat.Any().Return(1);
            Expect.Call(listMetadataProvider.GetListMetadata(1)).IgnoreArguments().Repeat.Any().Return(GetSuppliedListMetadata());
            Expect.Call(studentListWithMetricsProvider.GetOrderedStudentList(GetStudentListWithMetricsQueryOptions())).IgnoreArguments().Repeat.Any().Return(new List<EnhancedStudentInformation>().AsQueryable());
            Expect.Call(studentListWithMetricsProvider.GetStudentsWithMetrics(GetStudentListWithMetricsQueryOptions())).IgnoreArguments().Repeat.Any().Return(new List<StudentMetric>().AsQueryable());
            Expect.Call(watchListManager.CreateStudentMetricsProviderQueryOptions(null, null, 0, 0, 0, null, 0, StudentListType.All)).IgnoreArguments().Repeat.Any().Return(new StudentMetricsProviderQueryOptions());
        }
Пример #9
0
        protected override void EstablishContext()
        {
            studentListWithMetricsRepository = mocks.StrictMock<IRepository<StudentMetric>>();
            teacherStudentSectionRepository = mocks.StrictMock<IRepository<TeacherStudentSection>>();
            teacherSectionRepository = mocks.StrictMock<IRepository<TeacherSection>>();
            staffStudentCohortRepository = mocks.StrictMock<IRepository<StaffStudentCohort>>();
            staffCohortRepository = mocks.StrictMock<IRepository<StaffCohort>>();
            staffCustomStudentListRepository = mocks.StrictMock<IRepository<StaffCustomStudentList>>();
            staffCustomStudentListStudentRepository = mocks.StrictMock<IRepository<StaffCustomStudentListStudent>>();
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            accommodationProvider = mocks.StrictMock<IAccommodationProvider>();
            uniqueListProvider = mocks.StrictMock<IUniqueListIdProvider>();
            trendRenderingDispositionProvider = mocks.StrictMock<ITrendRenderingDispositionProvider>();
            rootMetricNodeResolver = mocks.StrictMock<IRootMetricNodeResolver>();
            metricStateProvider = mocks.StrictMock<IMetricStateProvider>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            priorYearClassroomMetricsProvider = mocks.StrictMock<IPriorYearClassroomMetricsProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            warehouseAvailabilityProvider = mocks.StrictMock<IWarehouseAvailabilityProvider>();
            maxPriorYearProvider = mocks.StrictMock<IMaxPriorYearProvider>();
            studentMetricsProvider = mocks.StrictMock<IStudentMetricsProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();
            priorYearStudentMetricsProvider = mocks.StrictMock<IPriorYearStudentMetricsProvider>();

            Expect.Call(studentListWithMetricsRepository.GetAll()).Repeat.Any().Return(GetSuppliedStudentMetrics());
            Expect.Call(teacherStudentSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherStudentSection());
            Expect.Call(teacherSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherSection());
            Expect.Call(staffStudentCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffStudentCohort());
            Expect.Call(staffCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCohort());
            Expect.Call(staffCustomStudentListRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCustomStudentList());
            Expect.Call(staffCustomStudentListStudentRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCustomStudentListStudent());

            Expect.Call(uniqueListProvider.GetUniqueId()).Return(suppliedUniqueListId);

            Expect.Call(trendRenderingDispositionProvider.GetTrendRenderingDisposition(TrendDirection.Decreasing, TrendInterpretation.Standard)).IgnoreArguments().Repeat.Any().Return(TrendEvaluation.DownBad);
            Expect.Call(accommodationProvider.GetAccommodations(expectedStudentIds.ToArray(), suppliedSchoolId)).Return(GetSuppliedAccommodations());

            Expect.Call(rootMetricNodeResolver.GetRootMetricNodeForStudent(suppliedSchoolId)).Repeat.Any().Return(GetStudentRootOverviewNode());

            Expect.Call(metricStateProvider.GetState(41, 1)).Repeat.Any().Return(new State { StateText = suppliedFourByFourText, DisplayStateText = suppliedFourByFourDisplayText });

            //Tested Elsewhere.
            Expect.Call(metadataListIdResolver.GetListId(ListType.ClassroomGeneralOverview, SchoolCategory.HighSchool)).IgnoreArguments().Repeat.Any().Return(1);
            Expect.Call(listMetadataProvider.GetListMetadata(1)).IgnoreArguments().Repeat.Any().Return(GetSuppliedListMetadata());
            Expect.Call(priorYearStudentMetricsProvider.GetStudentsWithMetrics(GetPriorYearStudentListWithMetricsQueryOptions()))
                .IgnoreArguments()
                .Repeat.Any()
                .Return(GetPriorYearStudentMetrics(suppliedLocalEducationAgencyId).AsQueryable());

            Expect.Call(warehouseAvailabilityProvider.Get()).Return(true);
            Expect.Call(maxPriorYearProvider.Get(suppliedLocalEducationAgencyId)).Return(2011);
            Expect.Call(studentMetricsProvider.GetOrderedStudentList(GetStudentListWithMetricsQueryOptions())).IgnoreArguments().Repeat.Any().Return(GetStudentSectionEntityListData(suppliedStudentListType).ToList().AsQueryable());
            Expect.Call(studentMetricsProvider.GetStudentsWithMetrics(GetStudentListWithMetricsQueryOptions())).IgnoreArguments().Repeat.Any().Return(GetStudentListSectionPageData(suppliedStudentListType).AsQueryable());
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForDisplay("1")).IgnoreArguments().Repeat.AtLeastOnce().Return("");
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForSorting("1")).IgnoreArguments().Repeat.AtLeastOnce().Return(1);

            base.EstablishContext();
        }
        protected override void EstablishContext()
        {
            //studentListWithMetricsRepository = mocks.StrictMock<IRepository<StudentList>>();
            //teacherStudentSectionRepository = mocks.StrictMock<IRepository<TeacherStudentSection>>();
            //teacherSectionRepository = mocks.StrictMock<IRepository<TeacherSection>>();
            //staffStudentCohortRepository = mocks.StrictMock<IRepository<StaffStudentCohort>>();
            //staffCohortRepository = mocks.StrictMock<IRepository<StaffCohort>>();
            staffCustomStudentListRepository = mocks.StrictMock<IRepository<StaffCustomStudentList>>();
            staffCustomStudentListStudentRepository = mocks.StrictMock<IRepository<StaffCustomStudentListStudent>>();
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            accommodationProvider = mocks.StrictMock<IAccommodationProvider>();
            trendRenderingDispositionProvider = mocks.StrictMock<ITrendRenderingDispositionProvider>();
            rootMetricNodeResolver = mocks.StrictMock<IRootMetricNodeResolver>();
            metricStateProvider = mocks.StrictMock<IMetricStateProvider>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            classroomMetricsProvider = mocks.StrictMock<IClassroomMetricsProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            studentListWithMetricsProvider = mocks.StrictMock<IStudentMetricsProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();
            watchListManager = mocks.StrictMock<IStudentWatchListManager>();

            //Expect.Call(studentListWithMetricsRepository.GetAll()).Return(GetSuppliedStudentListWithMetrics());
            //Expect.Call(teacherStudentSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherStudentSection());
            //Expect.Call(teacherSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherSection());
            //Expect.Call(staffStudentCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffStudentCohort());
            //Expect.Call(staffCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCohort());
            Expect.Call(staffCustomStudentListRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCustomStudentList());
            Expect.Call(staffCustomStudentListStudentRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCustomStudentListStudent());

            Expect.Call(trendRenderingDispositionProvider.GetTrendRenderingDisposition(TrendDirection.Decreasing, TrendInterpretation.Standard)).IgnoreArguments().Repeat.Any().Return(TrendEvaluation.DownBad);
            Expect.Call(accommodationProvider.GetAccommodations(expectedStudentIds.ToArray(), suppliedSchoolId)).Return(GetSuppliedAccommodations());

            Expect.Call(rootMetricNodeResolver.GetRootMetricNodeForStudent(suppliedSchoolId)).Repeat.Any().Return(GetStudentRootOverviewNode());

            Expect.Call(metricStateProvider.GetState(41, 1)).Repeat.Any().Return(new State { StateText = suppliedFourByFourText, DisplayStateText = suppliedFourByFourDisplayText });

            //Tested Elsewhere.
            Expect.Call(metadataListIdResolver.GetListId(ListType.ClassroomGeneralOverview, SchoolCategory.HighSchool)).IgnoreArguments().Repeat.Any().Return(1);
            Expect.Call(listMetadataProvider.GetListMetadata(1)).IgnoreArguments().Repeat.Any().Return(GetSuppliedListMetadata());
            Expect.Call(studentListWithMetricsProvider.GetOrderedStudentList(GetStudentListWithMetricsQueryOptions(suppliedStudentListType))).IgnoreArguments().Repeat.Any().Return(GetStudentSectionEntityListData(suppliedStudentListType));
            Expect.Call(studentListWithMetricsProvider.GetStudentsWithMetrics(GetStudentListWithMetricsQueryOptions(suppliedStudentListType))).IgnoreArguments().Repeat.Any().Return(GetStudentListSectionPageDataData(suppliedStudentListType));
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForDisplay("1")).IgnoreArguments().Repeat.AtLeastOnce().Return("");
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForSorting("1")).IgnoreArguments().Repeat.AtLeastOnce().Return(1);
            Expect.Call(watchListManager.CreateStudentMetricsProviderQueryOptions(null, null, 3, 3, null, null, null, StudentListType.All))
                .IgnoreArguments().Repeat.Any().Return(new StudentMetricsProviderQueryOptions());

            base.EstablishContext();
        }
        protected override void EstablishContext()
        {
            SetSuppliedGoal();

            localEducationAgencyMetricSchoolListRepository = mocks.StrictMock<IRepository<LocalEducationAgencyMetricSchoolList>>();
            staffInformationRepository = mocks.StrictMock<IRepository<StaffInformation>>();
            schoolInformationRepository = mocks.StrictMock<IRepository<SchoolInformation>>();
            uniqueListIdProvider = mocks.StrictMock<IUniqueListIdProvider>();
            metricCorrelationService = mocks.StrictMock<IMetricCorrelationProvider>();
            metricInstanceSetKeyResolver = mocks.StrictMock<IMetricInstanceSetKeyResolver<LocalEducationAgencyMetricInstanceSetRequest>>();
            metricGoalProvider = mocks.StrictMock<IMetricGoalProvider>();
            metricNodeResolver = mocks.StrictMock<IMetricNodeResolver>();
            domainSpecificMetricNodeResolver = mocks.StrictMock<IDomainSpecificMetricNodeResolver>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();


            suppliedLocalEducationAgencyMetricSchoolList = GetSuppliedLocalEducationAgencyMetricSchoolList();
            suppliedStaffInformationList = GetSuppliedStaffInformationRepository();
            suppliedSchoolInformationList = GetSuppliedSchoolInformationRepository();

            Expect.Call(metricNodeResolver.GetMetricNodeForLocalEducationAgencyMetricVariantId(suppliedMetricVariantId)).Return(GetSuppliedMetricMetadataNode());
            Expect.Call(localEducationAgencyMetricSchoolListRepository.GetAll()).Repeat.Any().Return(suppliedLocalEducationAgencyMetricSchoolList);
            Expect.Call(staffInformationRepository.GetAll()).Repeat.Any().Return(suppliedStaffInformationList);
            Expect.Call(schoolInformationRepository.GetAll()).Return(suppliedSchoolInformationList);
            Expect.Call(uniqueListIdProvider.GetUniqueId(suppliedMetricVariantId)).Return(suppliedListContext);
            Expect.Call(domainSpecificMetricNodeResolver.GetOperationalDashboardMetricNode()).Return(GetSuppliedOperationalDashboardMetricNode());
            Expect.Call(metricInstanceSetKeyResolver.GetMetricInstanceSetKey(null)).Constraints(
                    new ActionConstraint<LocalEducationAgencyMetricInstanceSetRequest>(x =>
                                                                                        {
                                                                                            Assert.That(x.MetricVariantId == suppliedMetricVariantId);
                                                                                            Assert.That(x.LocalEducationAgencyId == suppliedLocalEducationAgencyId);
                                                                                        })).Return(suppliedMetricInstanceSetKey);
            Expect.Call(metricGoalProvider.GetMetricGoal(suppliedMetricInstanceSetKey, suppliedMetricId)).Return(suppliedGoal);

            Expect.Call(metricCorrelationService.GetRenderingParentMetricVariantIdForSchool(suppliedMetricVariantId, 1)).Constraints(
                     Rhino.Mocks.Constraints.Is.Equal(suppliedMetricVariantId), Rhino.Mocks.Constraints.Is.Anything()).Repeat.Any().Return(new MetricCorrelationProvider.MetricRenderingContext { ContextMetricVariantId = suppliedContextMetricVariantId, MetricVariantId = suppliedCorrelationMetricVariantId });
            Expect.Call(metadataListIdResolver.GetListId(ListType.SchoolMetricTable, SchoolCategory.None)).Return(
                MetadataListIdResolver.SchoolMetricTableListId);
            Expect.Call(listMetadataProvider.GetListMetadata(MetadataListIdResolver.SchoolMetricTableListId)).Return(
                new List<MetadataColumnGroup>());
        }
        protected override void EstablishContext()
        {
            studentListWithMetricsRepository = mocks.StrictMock<IRepository<StudentMetric>>();
            teacherStudentSectionRepository = mocks.StrictMock<IRepository<TeacherStudentSection>>();
            teacherSectionRepository = mocks.StrictMock<IRepository<TeacherSection>>();
            staffStudentCohortRepository = mocks.StrictMock<IRepository<StaffStudentCohort>>();
            staffCohortRepository = mocks.StrictMock<IRepository<StaffCohort>>();
            metricComponentRepository = mocks.StrictMock<IRepository<MetricComponent>>();
            studentSchoolMetricInstanceSetRepository = mocks.StrictMock<IRepository<StudentSchoolMetricInstanceSet>>();
            studentRecordCurrentCourseRepository = mocks.StrictMock<IRepository<StudentRecordCurrentCourse>>();
            metricRepository = mocks.StrictMock<IRepository<Dashboards.Metric.Data.Entities.Metric>>();
            schoolCategoryProvider = mocks.StrictMock<ISchoolCategoryProvider>();
            accommodationProvider = mocks.StrictMock<IAccommodationProvider>();
            uniqueListProvider = mocks.StrictMock<IUniqueListIdProvider>();
            trendRenderingDispositionProvider = mocks.StrictMock<ITrendRenderingDispositionProvider>();
            gradeStateProvider = mocks.StrictMock<IGradeStateProvider>();
            rootMetricNodeResolver = mocks.StrictMock<IRootMetricNodeResolver>();
            metricStateProvider = mocks.StrictMock<IMetricStateProvider>();
            classroomMetricsProvider = mocks.StrictMock<IClassroomMetricsProvider>();
            studentListUtilitiesProvider = mocks.StrictMock<IStudentListUtilitiesProvider>();
            metadataListIdResolver = mocks.StrictMock<IMetadataListIdResolver>();
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            subjectSpecificOverviewMetricComponentProvider = mocks.StrictMock<ISubjectSpecificOverviewMetricComponentProvider>();
            studentListWithMetricsProvider = mocks.StrictMock<IStudentMetricsProvider>();
            gradeLevelUtilitiesProvider = mocks.StrictMock<IGradeLevelUtilitiesProvider>();

            Expect.Call(studentListWithMetricsRepository.GetAll()).Repeat.Any().Return(GetSuppliedStudentMetrics());
            Expect.Call(teacherStudentSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherStudentSection());
            Expect.Call(teacherSectionRepository.GetAll()).Repeat.Any().Return(GetSuppliedTeacherSection());
            Expect.Call(staffStudentCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffStudentCohort());
            Expect.Call(staffCohortRepository.GetAll()).Repeat.Any().Return(GetSuppliedStaffCohort());
            Expect.Call(metricComponentRepository.GetAll()).Repeat.Any().Return(GetSuppliedMetricComponent());
            Expect.Call(studentSchoolMetricInstanceSetRepository.GetAll()).Repeat.Any().Return(GetSuppliedStudentSchoolMetricInstanceSet());
            Expect.Call(studentRecordCurrentCourseRepository.GetAll()).Repeat.Any().Return(GetSuppliedStudentRecordCurrentCourse());
            Expect.Call(metricRepository.GetAll()).Repeat.Any().Return(GetMetric());

            Expect.Call(uniqueListProvider.GetUniqueId()).Repeat.Twice().Return(suppliedUniqueListId);
            Expect.Call(gradeStateProvider.Get(0)).IgnoreArguments().Repeat.Any().Return(MetricStateType.Acceptable);
            Expect.Call(gradeStateProvider.Get("A")).IgnoreArguments().Repeat.Any().Return(MetricStateType.Acceptable);

            Expect.Call(metricStateProvider.GetState(0, String.Empty, String.Empty)).IgnoreArguments().Repeat.Any().Return(new State(MetricStateType.Good, "Good"));

            Expect.Call(trendRenderingDispositionProvider.GetTrendRenderingDisposition(TrendDirection.Increasing, TrendInterpretation.Standard)).Repeat.Any().Return(TrendEvaluation.UpGood);
            Expect.Call(trendRenderingDispositionProvider.GetTrendRenderingDisposition(TrendDirection.Decreasing, TrendInterpretation.Standard)).Repeat.Any().Return(TrendEvaluation.DownBad);

            Expect.Call(rootMetricNodeResolver.GetRootMetricNodeForStudent(suppliedSchoolId)).Repeat.Any().Return(GetStudentRootOverviewNode());

            foreach (var studentId in expectedStudentIds)
                Expect.Call(classroomMetricsProvider.GetAdditionalMetrics(null, null)).IgnoreArguments().Constraints(Property.Value("StudentUSI", studentId), Rhino.Mocks.Constraints.Is.Anything()).Repeat.Any().Return(GetSuppliedMetrics());

            //Tested Elsewhere.
            Expect.Call(metadataListIdResolver.GetListId(ListType.ClassroomSubjectSpecific, SchoolCategory.HighSchool, "subjectArea")).IgnoreArguments().Repeat.Any().Return(1);
            Expect.Call(listMetadataProvider.GetListMetadata(1, "subjectArea")).IgnoreArguments().Repeat.Any().Return(GetSuppliedListMetadata());
            
            Expect.Call(studentListUtilitiesProvider.PrepareMetric(1, 1, 1, "1", 1, "1", "1")).IgnoreArguments().Repeat.Any().Return(FakeMetric());
            Expect.Call(studentListUtilitiesProvider.PrepareTrendMetric(1, 1, 1, "1", 1, "1", "1", 1, 1, null)).IgnoreArguments().Repeat.Any().Return(FakeTrendMetric());

            Expect.Call(subjectSpecificOverviewMetricComponentProvider.GetMetricIdsForComponents()).Return(new int[] { (int)StudentMetricEnum.AbsenceLevelCurrentPeriod, (int)StudentMetricEnum.ClassGradeGradesFalling10PercentOrMore });
            Expect.Call(studentListWithMetricsProvider.GetOrderedStudentList(GetStudentListWithMetricsQueryOptions())).IgnoreArguments().Repeat.Any().Return(GetStudentListData(suppliedStudentListType));
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForSorting("1")).IgnoreArguments().Repeat.AtLeastOnce().Return(1);
            Expect.Call(studentListWithMetricsProvider.GetStudentsWithMetrics(GetStudentListWithMetricsQueryOptions())).IgnoreArguments().Repeat.Any().Return(GetStudentListWithMetricsData(suppliedStudentListType));
            Expect.Call(gradeLevelUtilitiesProvider.FormatGradeLevelForDisplay(null)).Repeat.Any().Return(string.Empty);

            base.EstablishContext();
        }