protected override void EstablishContext()
        {
            //Prepare supplied data collections
            suppliedListMetadata = GetSuppliedListMetadata();
            suppliedStudentRow = GetSuppliedStudentRow();
            suppliedPriorYearStudentRow = GetSuppliedPriorYearStudentList();
            suppliedMetricVariants = GetSuppliedMetricVariants();

            //Set up the mocks
            listMetadataProvider = mocks.StrictMock<IListMetadataProvider>();
            studentListUtilitiesProvider = mocks.StrictMock<IStudentListUtilitiesProvider>();
            trendRenderingDispositionProvider = mocks.StrictMock<ITrendRenderingDispositionProvider>();
            metricStateProvider = mocks.StrictMock<IMetricStateProvider>();
            metricVariantRepository = mocks.StrictMock<IRepository<MetricVariant>>();

            windsorContainer = new WindsorContainer();
            windsorContainer.Kernel.Resolver.AddSubResolver(new ArrayResolver(windsorContainer.Kernel));
            RegisterProviders(windsorContainer);
            IoC.Initialize(windsorContainer);

            additionalPriorYearMetricProvider = IoC.Resolve<IAdditionalPriorYearMetricProvider>();

            Expect.Call(metricVariantRepository.GetAll())
                .Return(suppliedMetricVariants.AsQueryable()).Repeat.AtLeastOnce();
        }
        public static StudentWithMetrics.Metric ToListCellTypedMetric(this StudentMetric metricData,
                                                                      MetadataColumn cell,
                                                                      IStudentListUtilitiesProvider utilitiesProvider,
                                                                      ITrendRenderingDispositionProvider trendRenderingDispositionProvider)
        {
            switch (cell.MetricListCellType)
            {
                case MetricListCellType.TrendMetric:
                    return utilitiesProvider.PrepareTrendMetric(metricData.StudentUSI, metricData.SchoolId,
                                                                cell.UniqueIdentifier, metricData.MetricVariantId,
                                                                metricData.Value, metricData.MetricStateTypeId,
                                                                metricData.ValueTypeName, metricData.TrendDirection,
                                                                trendRenderingDispositionProvider);
                case MetricListCellType.AssessmentMetric:
                    return utilitiesProvider.PrepareIndicatorMetric(metricData.StudentUSI, metricData.SchoolId,
                                                                    cell.UniqueIdentifier, metricData.MetricVariantId,
                                                                    metricData.Value, metricData.MetricStateTypeId,
                                                                    metricData.ValueTypeName);
            }

            return utilitiesProvider.PrepareMetric(metricData.StudentUSI, metricData.SchoolId, cell.UniqueIdentifier,
                                                   metricData.MetricVariantId, metricData.Value,
                                                   metricData.MetricStateTypeId, metricData.ValueTypeName);
        }
 protected override void ExecuteTest()
 {
     studentListUtilitiesProvider = new StudentListUtilitiesProvider(metricStateProvider, metricNodeResolver);
     actualModel = studentListUtilitiesProvider.PrepareTrendMetric(suppliedStudentUSI, suppliedUniqueIdentifier, suppliedMetricVariantId, suppliedMetricValue.ToString(), suppliedStateType, suppliedValueType, suppliedDisplayFormat, suppliedTrendInterpretation, null, null);
 }
 protected override void ExecuteTest()
 {
     studentListUtilitiesProvider = new StudentListUtilitiesProvider(metricStateProvider, metricNodeResolver);
     actualModel = studentListUtilitiesProvider.PrepareMetric(suppliedStudentUSI, suppliedSchoolId, suppliedUniqueIdentifier, suppliedMetricVariantId, suppliedMetricValue.ToString(), suppliedStateType, suppliedValueType);
 }
 protected override void ExecuteTest()
 {
     studentListUtilitiesProvider = new StudentListUtilitiesProvider(metricStateProvider, metricNodeResolver);
     actualModel = studentListUtilitiesProvider.PrepareIndicatorMetric(suppliedStudentUSI, suppliedUniqueIdentifier, null, null, null, null, null);
 }
 protected override void EstablishContext()
 {
     _utilitiesProvider = mocks.StrictMock<IStudentListUtilitiesProvider>();
     Expect.Call(_utilitiesProvider.PrepareTrendMetric(0,0,0,0,"",0,"",0,_trendDispositionProvider)).IgnoreArguments().Return(new StudentWithMetrics.TrendMetric());
     _trendDispositionProvider = mocks.StrictMock<ITrendRenderingDispositionProvider>();
 }
        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();
        }