public async Task CourseSearchServiceFailureTestAsync()
        {
            //Arrange
            var serviceHelperFake           = A.Fake <IServiceHelper>();
            var manageCoursesFake           = A.Fake <ICourseOpportunityBuilder>(ops => ops.Strict());
            var courseSearchAuditRepository = A.Fake <IAuditRepository>(ops => ops.Strict());
            var loggerFake         = A.Fake <IApplicationLogger>();
            var fakePolicy         = A.Fake <ITolerancePolicy>();
            var fakeMessageBuilder = A.Fake <IBuildTribalMessage>();

            //Setup Calls ANY exception will do as we are catching all of them for this call
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseListOutput> > > ._, Constants.CourseSearchEndpointConfigName)).Throws(new HttpException("failed cause I want to"));

            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListInput> ._)).DoesNothing();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <Exception> ._)).DoesNothing();
            A.CallTo(() => loggerFake.ErrorJustLogIt(A <string> ._, A <Exception> ._)).DoesNothing();

            var courseSearchService = new CourseSearchService(manageCoursesFake, serviceHelperFake, courseSearchAuditRepository, loggerFake, fakePolicy, fakeMessageBuilder);

            //Act
            var results = await courseSearchService.GetCoursesAsync("CourseKeyWords");

            //Assert
            results.Should().BeEmpty();
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseListOutput> > > ._, Constants.CourseSearchEndpointConfigName)).MustHaveHappened();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListInput> ._)).MustHaveHappened();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <Exception> ._)).MustHaveHappened();
            A.CallTo(() => loggerFake.ErrorJustLogIt(A <string> ._, A <Exception> ._)).MustHaveHappened();
        }
        public async Task SearchCoursesAsyncTests(string keywords, bool coursesAvailable)
        {
            //Arrange
            var serviceHelperFake           = A.Fake <IServiceHelper>();
            var manageCoursesFake           = A.Fake <ICourseOpportunityBuilder>(ops => ops.Strict());
            var courseSearchAuditRepository = A.Fake <IAuditRepository>(ops => ops.Strict());
            var loggerFake         = A.Fake <IApplicationLogger>();
            var fakePolicy         = A.Fake <ITolerancePolicy>();
            var fakeMessageBuilder = A.Fake <IBuildTribalMessage>(ops => ops.Strict());

            //Setup Calls and Dummies
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseListOutput> > > ._, Constants.CourseSearchEndpointConfigName))
            .Returns(coursesAvailable ? GetDummyCourseOutput() : new CourseListOutput());
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListInput> ._)).DoesNothing();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListOutput> ._)).DoesNothing();
            A.CallTo(() => fakeMessageBuilder.GetCourseSearchInput(A <string> ._, A <CourseSearchProperties> ._))
            .Returns(new CourseListInput());
            var courseSearchService = new CourseSearchService(manageCoursesFake, serviceHelperFake, courseSearchAuditRepository, loggerFake, fakePolicy, fakeMessageBuilder);

            //Act
            await courseSearchService.SearchCoursesAsync(keywords, new CourseSearchProperties());

            //Assert
            A.CallTo(() => fakeMessageBuilder.GetCourseSearchInput(A <string> ._, A <CourseSearchProperties> ._))
            .MustHaveHappened(1, Times.Exactly);
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseListOutput> > > ._, Constants.CourseSearchEndpointConfigName)).MustHaveHappened();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListInput> ._)).MustHaveHappened();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListOutput> ._)).MustHaveHappened();
        }
Beispiel #3
0
        public async Task CourseSearchServiceTestAsync(string keywords, bool coursesAvailable)
        {
            //Arrange
            var serviceHelperFake           = A.Fake <IServiceHelper>();
            var manageCoursesFake           = A.Fake <ICourseOpportunityBuilder>(ops => ops.Strict());
            var courseSearchAuditRepository = A.Fake <IAuditRepository>(ops => ops.Strict());
            var loggerFake = A.Fake <IApplicationLogger>();
            var fakePolicy = A.Fake <ITolerancePolicy>();

            //Setup Calls and Dummies
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseListOutput> > > ._, Constants.CourseSearchEndpointConfigName)).Returns(coursesAvailable ? GetDummyCourseOutput() : new CourseListOutput());
            A.CallTo(() => manageCoursesFake.SelectCoursesForJobProfile(A <IEnumerable <Course> > ._))
            .Returns(GenerateDummyCourses());
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListInput> ._)).DoesNothing();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListOutput> ._)).DoesNothing();

            var courseSearchService = new CourseSearchService(manageCoursesFake, serviceHelperFake, courseSearchAuditRepository, loggerFake, fakePolicy);

            //Act
            await courseSearchService.GetCoursesAsync(keywords);

            //Assert
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseListOutput> > > ._, Constants.CourseSearchEndpointConfigName)).MustHaveHappened();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListInput> ._)).MustHaveHappened();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseListOutput> ._)).MustHaveHappened();
            if (coursesAvailable)
            {
                A.CallTo(() => manageCoursesFake.SelectCoursesForJobProfile(A <IEnumerable <Course> > .That.Matches(m => m.Any()))).MustHaveHappened();
            }
            else
            {
                A.CallTo(() => manageCoursesFake.SelectCoursesForJobProfile(A <IEnumerable <Course> > .That.IsEmpty())).MustHaveHappened();
            }
        }
Beispiel #4
0
        private async Task DateFormComplete(IDialogContext context, IAwaitable <StartDateForm> result)
        {
            var tenantId = 1;

            StartDateForm form = null;

            try
            {
                form = await result;
            }
            catch (OperationCanceledException)
            {
            }

            if (form == null)
            {
                await context.PostAsync("You cancelled the form.");
            }
            else
            {
                var month               = form.Month;
                var startDate           = month + form.Year;
                var courseSearchService = new CourseSearchService();
                var courses             = courseSearchService.SearchByStartDate(startDate, tenantId,
                                                                                form.BeforeDuringAfter.ToString());

                var reply = context.MakeMessage();
                reply.Attachments      = new List <Attachment>();
                reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;

                var datesButtons = new CardAction()
                {
                    Type  = "openUrl",
                    Title = "View Details",
                    Value = "https://www.cityvarsityonline.com/course-schedule"
                };

                var pictureUrl = "https://www.cityvarsityonline.com/wp-content/uploads/2016/12/Creative-Writing.png";

                foreach (var course in courses)
                {
                    var thumbnail = new ThumbnailCard()
                    {
                        Title    = course.Name,
                        Subtitle = $"StartDate: {course.Semester}",
                        Buttons  = new List <CardAction>()
                    };
                    thumbnail.Buttons.Add(datesButtons);
                    thumbnail.Images.Add(new CardImage(pictureUrl));
                    reply.Attachments.Add(thumbnail.ToAttachment());
                }

                await context.PostAsync("Please select course from below:");

                await context.PostAsync(reply);
            }
        }
Beispiel #5
0
        public async Task GetServiceStatusAsyn(bool coursesAvailable, ServiceState expectedServiceStatus)
        {
            //Arrange
            var serviceHelperFake           = A.Fake <IServiceHelper>();
            var courseSearchAuditRepository = A.Fake <IAuditRepository>(ops => ops.Strict());
            var loggerFake        = A.Fake <IApplicationLogger>(ops => ops.Strict());
            var manageCoursesFake = A.Fake <ICourseOpportunityBuilder>(ops => ops.Strict());
            var fakePolicy        = A.Fake <ITolerancePolicy>();

            //Setup Calls and Dummies
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseListOutput> > > ._, Constants.CourseSearchEndpointConfigName)).Returns(coursesAvailable ? GetDummyCourseOutput() : new CourseListOutput());
            A.CallTo(() => loggerFake.LogExceptionWithActivityId(A <string> ._, A <Exception> ._)).Returns("Exception acctivity id");

            var courseSearchService = new CourseSearchService(manageCoursesFake, serviceHelperFake, courseSearchAuditRepository, loggerFake, fakePolicy);

            //Act
            var serviceStatus = await courseSearchService.GetCurrentStatusAsync();

            //Asserts
            serviceStatus.Status.Should().Be(expectedServiceStatus);
        }
        public async Task GetCourseDetailsAsyncTests(string courseId, bool coursesAvailable)
        {
            //Arrange
            var serviceHelperFake           = A.Fake <IServiceHelper>();
            var manageCoursesFake           = A.Fake <ICourseOpportunityBuilder>(ops => ops.Strict());
            var courseSearchAuditRepository = A.Fake <IAuditRepository>(ops => ops.Strict());
            var loggerFake         = A.Fake <IApplicationLogger>();
            var fakePolicy         = A.Fake <ITolerancePolicy>();
            var fakeMessageBuilder = A.Fake <IBuildTribalMessage>(ops => ops.Strict());

            //Setup Calls and Dummies
            A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseDetailOutput> > > ._, Constants.CourseSearchEndpointConfigName)).Returns(coursesAvailable ? new CourseDetailOutput() : null);

            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseDetailInput> ._)).DoesNothing();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseDetailOutput> ._)).DoesNothing();
            A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <Exception> ._)).DoesNothing();
            A.CallTo(() => fakeMessageBuilder.GetCourseDetailInput(A <string> ._)).Returns(new CourseDetailInput());
            var courseSearchService = new CourseSearchService(manageCoursesFake, serviceHelperFake, courseSearchAuditRepository, loggerFake, fakePolicy, fakeMessageBuilder);

            //Act
            await courseSearchService.GetCourseDetailsAsync(courseId);

            //Assert
            if (!string.IsNullOrWhiteSpace(courseId))
            {
                A.CallTo(() => fakeMessageBuilder.GetCourseDetailInput(A <string> ._)).MustHaveHappened();
                A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseDetailOutput> > > ._, Constants.CourseSearchEndpointConfigName)).MustHaveHappened();
                A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseDetailInput> ._)).MustHaveHappened();
                A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseDetailOutput> ._)).MustHaveHappened();
            }
            else
            {
                A.CallTo(() => fakeMessageBuilder.GetCourseDetailInput(A <string> ._)).MustNotHaveHappened();
                A.CallTo(() => serviceHelperFake.UseAsync(A <Func <ServiceInterface, Task <CourseDetailOutput> > > ._, Constants.CourseSearchEndpointConfigName)).MustNotHaveHappened();
                A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseDetailInput> ._)).MustNotHaveHappened();
                A.CallTo(() => courseSearchAuditRepository.CreateAudit(A <CourseDetailOutput> ._)).MustNotHaveHappened();
            }
        }
Beispiel #7
0
        public async Task GetServiceStatusExceptionAsync()
        {
            //Arrange
            var serviceHelperFake           = A.Fake <IServiceHelper>();
            var courseSearchAuditRepository = A.Fake <IAuditRepository>(ops => ops.Strict());
            var loggerFake        = A.Fake <IApplicationLogger>(ops => ops.Strict());
            var manageCoursesFake = A.Fake <ICourseOpportunityBuilder>(ops => ops.Strict());
            var fakePolicy        = A.Fake <ITolerancePolicy>();

            //Setup Calls and Dummies
            A.CallTo(() => serviceHelperFake.Use(A <Func <ServiceInterface, CourseListOutput> > ._, "Bad EndPoint")).Returns(GetDummyCourseOutput());
            A.CallTo(() => loggerFake.LogExceptionWithActivityId(A <string> ._, A <Exception> ._)).Returns("Exception logged");

            var courseSearchService = new CourseSearchService(manageCoursesFake, serviceHelperFake, courseSearchAuditRepository, loggerFake, fakePolicy);

            //Act
            var serviceStatus = await courseSearchService.GetCurrentStatusAsync();

            //Asserts
            serviceStatus.Status.Should().NotBe(ServiceState.Green);
            serviceStatus.Notes.Should().Contain("Exception");
            A.CallTo(() => loggerFake.LogExceptionWithActivityId(A <string> ._, A <Exception> ._)).MustHaveHappened();
        }
Beispiel #8
0
        private async Task ProcessSearchOption(IDialogContext context, IAwaitable <object> result)
        {
            var repo                = new EducorDbRepo(null);
            var chosenOption        = await result;
            var tenantId            = 1;
            var courseSearchService = new CourseSearchService();
            var reply               = context.MakeMessage();
            var pictureUrl          = "";


            switch (chosenOption.ToString())
            {
            case "Search by Course Category":

                reply.Attachments      = new List <Attachment>();
                reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;
                var courses          = new List <Data.Models.Course>();
                var courseCategories = CourseCategory.CreateList();

                var categoryButtons = new CardAction()
                {
                    Type  = "openUrl",
                    Title = "View Details",
                    Value = "https://www.cityvarsityonline.com/courses/"
                };

                foreach (var courseCategory in courseCategories)
                {
                    var thumbnail = new ThumbnailCard()
                    {
                        Title    = courseCategory.Title,
                        Subtitle = courseCategory.SubTitle,
                        Buttons  = new List <CardAction>()
                    };
                    thumbnail.Buttons.Add(categoryButtons);
                    thumbnail.Images.Add(new CardImage(courseCategory.PictureUrl));
                    reply.Attachments.Add(thumbnail.ToAttachment());
                }
                await context.PostAsync("Please Select the course category:");

                await context.PostAsync("Each link will take you to the website courses");

                await context.PostAsync(reply);

                break;

            case "Search by Course Start Date":

                var form = new FormDialog <StartDateForm>(
                    new StartDateForm(),
                    StartDateForm.BuildForm
                    );

                context.Call <StartDateForm>(form, DateFormComplete);

                break;

            case "Search by Course Name":

                await context.PostAsync("Please name the course you are looking for:");

                var courseName = await result;

                courses = repo.CourseQueries.GetAllForTenant(tenantId)
                          .Where(x => x.IsVisible && x.Name.Contains(courseName.ToString())).ToList();

                reply                  = context.MakeMessage();
                reply.Attachments      = new List <Attachment>();
                reply.AttachmentLayout = AttachmentLayoutTypes.Carousel;

                var namesButtons = new CardAction()
                {
                    Type  = "openUrl",
                    Title = "View Details",
                    Value = "https://www.cityvarsityonline.com/course-schedule"
                };

                pictureUrl = "https://www.cityvarsityonline.com/wp-content/uploads/2016/12/Creative-Writing.png";

                foreach (var course in courses)
                {
                    var thumbnail = new ThumbnailCard()
                    {
                        Title    = course.Name,
                        Subtitle = $"Start Date: {course.Semester.Substring(0, 8)}\n" +
                                   $"End Date: {course.Semester.Substring(12, 20)}",
                        Buttons = new List <CardAction>()
                    };
                    thumbnail.Buttons.Add(namesButtons);
                    thumbnail.Images.Add(new CardImage(pictureUrl));
                    reply.Attachments.Add(thumbnail.ToAttachment());
                }

                await context.PostAsync("Here are courses with similar or related names:");

                await context.PostAsync(reply);

                break;

            default:
            // ReSharper disable once RedundantCaseLabel
            case "Show All Courses on Offer":

                //PromptDialog.Confirm(context, ViewListOfAllCourses, "Please confirm that want to view all courses?",
                //    "Please click an option below or type 'yes' or 'no'", 2, PromptStyle.Auto, new string[] { "YES", "NO" });


                tenantId = 1;

                repo    = new EducorDbRepo(null);
                courses = repo.CourseQueries.GetAllForTenant(tenantId).Where(x => x.IsVisible).ToList();

                var response = context.MakeMessage();
                response.Attachments      = new List <Attachment>();
                response.AttachmentLayout = AttachmentLayoutTypes.Carousel;

                var datesButtons = new CardAction()
                {
                    Type  = "openUrl",
                    Title = "View Details",
                    Value = "https://www.cityvarsityonline.com/course-schedule"
                };

                pictureUrl = "https://www.cityvarsityonline.com/wp-content/uploads/2016/12/Creative-Writing.png";

                foreach (var course in courses)
                {
                    var thumbnail = new ThumbnailCard()
                    {
                        Title    = course.Name,
                        Subtitle = $"Price: R{ course.OriginalCost}\n" +
                                   $"College: City Varsity Online\n" +
                                   $"Start Date: {course.Semester}\n \n",
                        Buttons = new List <CardAction>()
                    };
                    thumbnail.Buttons.Add(datesButtons);
                    thumbnail.Images.Add(new CardImage(pictureUrl));
                    response.Attachments.Add(thumbnail.ToAttachment());
                }

                await context.PostAsync("Please select course from our list below:");

                await context.PostAsync(response);

                context.Wait(MessageReceived);
                break;
            }
        }