public void UnSubscribeUserOnChannel() { SubscriptionBL bl = new SubscriptionBL(); SubscriptionController subscriptioncontroller = new SubscriptionController(); Input <Models.Inputs.Subscription.UnSubscribeUserChannel> usucs = new Input <Models.Inputs.Subscription.UnSubscribeUserChannel>(); Models.Inputs.Subscription.UnSubscribeUserChannel usuc = new Models.Inputs.Subscription.UnSubscribeUserChannel(); usuc.userID = "1"; usuc.serviceID = "1"; usuc.operatorID = "1"; usuc.channelID = "1"; usuc.countryID = "1"; usucs.input = usuc; Models.CommonInputParams param = new CommonInputParams(); param.company = "iSYS"; param.deviceid = "123123123"; param.password = "******"; param.username = "******"; usucs.param = param; var result = subscriptioncontroller.UnSubscribeUserOnChannel(usucs); Assert.IsNotNull(result); Assert.AreEqual("0", result.status.statuscode); }
public void InteractiveServiceUserMessage() { SubscriptionBL bl = new SubscriptionBL(); SubscriptionController subscriptioncontroller = new SubscriptionController(); Input <Models.Inputs.Subscription.Interactiveserviceusermsg> usucs = new Input <Models.Inputs.Subscription.Interactiveserviceusermsg>(); Models.Inputs.Subscription.Interactiveserviceusermsg usuc = new Models.Inputs.Subscription.Interactiveserviceusermsg(); usuc.userid = "56454561"; usuc.interactiveserviceid = "1"; usuc.usermessage = "hello"; usuc.operatorid = "1"; usucs.input = usuc; Models.CommonInputParams param = new CommonInputParams(); param.company = "iSYS"; param.deviceid = "123123123"; param.password = "******"; param.username = "******"; usucs.param = param; var result = subscriptioncontroller.InteractiveServiceUserMessage(usucs); Assert.IsNotNull(result); Assert.AreEqual("0", result.status.statuscode); }
public override void Given() { Mediator = new Mock <IMediator>(); TriggerName = "test"; CancellationToken = new CancellationTokenSource().Token; Controller = new SubscriptionController(Mediator.Object); }
public CancelTests() { TestAccount.PaddleSubscriptionId = 12345; // Setup GetSubscriptionUser() _mockPaddleClient .Setup(c => c.GetSubscriptionUser(It.IsAny <long>())) .Returns((long subscriptionId) => { return(Task.FromResult(new SubscriptionUser { UpdateUrl = ReturnedUpdateUrl, NextPayment = new SubscriptionUser.PaymentInfo { Date = ReturnedNextPaymentDate } })); }); // Setup CancelSubscription() _mockPaddleClient.Setup(c => c.CancelSubscription(It.IsAny <long>())) .Returns((long subscriptionId) => { _capturedCancelledSubscriptionId = subscriptionId; return(Task.CompletedTask); }); _controller = new SubscriptionController(Db, UserEventsService, TimeService, _mockPaddleClient.Object); SetUpLoggedInUser(_controller); }
/// <summary> /// Subscribes the <paramref name="subscriberInstance" /> to any event matching <typeparamref name="T" /> as event data type /// </summary> /// <typeparam name="T">The type to subscribe to</typeparam> /// <param name="subscriberInstance">The instance of a subscriber to be subscribed to the event</param> /// <param name="newDataCallback">A callback method acceptiong <typeparamref name="T" /> as argument, which will be called when new data from publishers is available</param> /// <param name="policy">The data modify policy, default is <see cref="DataModifyPolicy.NoModify" /></param> /// <param name="evaluateTemplateObject">Pass a Func to subscribe using template objects. If no Func is given, <paramref name="subscriberInstance" /> will be subscribed to every event with matching <typeparamref name="T" />.<br /> /// As an alternative, a <paramref name="evaluateTemplateObject" /> can be provided to request templates for the data to be published from every single publisher.</param> /// <param name="forbidRemote">if set to <c>true</c> no remote publishers will be considered.</param> /// <param name="subscriptionCallback">A callback method used to notify the subscriber of a new subscription. It passes a <seealso cref="SubscriptionHandle"/> instance used to identify the 1:1 relation between one publisher event and one subscriber</param> /// <exception cref="System.ArgumentException">subscriberInstance must be a valid subscriber</exception> public static void To <T>(object subscriberInstance, Action <T, SubscriptionHandle> newDataCallback, DataModifyPolicy policy = DataModifyPolicy.NoModify, Func <T, bool> evaluateTemplateObject = null, bool forbidRemote = false, Action <Type, SubscriptionHandle> subscriptionCallback = null) { _log.DebugFormat("Subscribing {0} to type {1} {2}", subscriberInstance, typeof(T), (evaluateTemplateObject != null ? "with template object" : string.Empty)); EllaModel.Instance.AddActiveSubscriber(subscriberInstance); if (!forbidRemote) { if (Networking.IsRunning) { Func <T, bool> eval = evaluateTemplateObject; Action <RemoteSubscriptionHandle> callback = handle => SubscriptionController.SubscribeToRemotePublisher(handle, subscriberInstance, newDataCallback, policy, eval, subscriptionCallback); Networking.SubscribeToRemoteHost <T>(callback); } } if (evaluateTemplateObject == null) { evaluateTemplateObject = (o => true); } SubscriptionRequest sr = new SubscriptionRequest() { SubscriberInstance = subscriberInstance, RequestedType = typeof(T) }; sr.SubscriptionCall = () => SubscriptionController.DoLocalSubscription <T>(subscriberInstance, newDataCallback, evaluateTemplateObject, subscriptionCallback, policy); EllaModel.Instance.AddSubscriptionRequest(sr); SubscriptionController.DoLocalSubscription(subscriberInstance, newDataCallback, evaluateTemplateObject, subscriptionCallback, policy); }
public void ChangeSubscriptionShouldRemoveSubscriptionFromRepositoryAndSendConfirmationIfAllTopicsAreRemovedAndReturn204() { const string testMail = "*****@*****.**"; var testTopicA = new Topic { Abbreviation = "TA", Description = "Test Topic A" }; var testTopicB = new Topic { Abbreviation = "TB", Description = "Test Topic A" }; var testSubscription = new Subscription { Mail = testMail, Topics = new List <Topic> { testTopicA, testTopicB } }; var repositoryMock = new Mock <ISubscriptionRepository>(); repositoryMock .Setup(repository => repository.GetSubscription(testMail)) .Returns(testSubscription); var sendContentMock = new Mock <ISendContent>(); var controller = new SubscriptionController(repositoryMock.Object, sendContentMock.Object); IActionResult result = controller.ChangeSubscription(testMail, Enumerable.Empty <string>().ToArray()); var objectResult = result as NoContentResult; Assert.NotNull(objectResult); repositoryMock.Verify(repository => repository.RemoveSubscription(It.IsAny <Subscription>()), Times.Once); sendContentMock.Verify(sendContent => sendContent.Send(testMail, It.IsAny <Content>()), Times.Once); }
public async void Patch_No_Errors() { SubscriptionControllerMockFacade mock = new SubscriptionControllerMockFacade(); var mockResult = new Mock <UpdateResponse <ApiSubscriptionResponseModel> >(); mockResult.SetupGet(x => x.Success).Returns(true); mock.ServiceMock.Setup(x => x.Update(It.IsAny <string>(), It.IsAny <ApiSubscriptionRequestModel>())) .Callback <string, ApiSubscriptionRequestModel>( (id, model) => model.IsDisabled.Should().Be(true) ) .Returns(Task.FromResult <UpdateResponse <ApiSubscriptionResponseModel> >(mockResult.Object)); mock.ServiceMock.Setup(x => x.Get(It.IsAny <string>())).Returns(Task.FromResult <ApiSubscriptionResponseModel>(new ApiSubscriptionResponseModel())); SubscriptionController controller = new SubscriptionController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, new ApiSubscriptionModelMapper()); controller.ControllerContext = new ControllerContext(); controller.ControllerContext.HttpContext = new DefaultHttpContext(); var patch = new JsonPatchDocument <ApiSubscriptionRequestModel>(); patch.Replace(x => x.IsDisabled, true); IActionResult response = await controller.Patch(default(string), patch); response.Should().BeOfType <OkObjectResult>(); (response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK); mock.ServiceMock.Verify(x => x.Update(It.IsAny <string>(), It.IsAny <ApiSubscriptionRequestModel>())); }
public void GetShouldReturnSubscriptionFromRepositoryIfMailIsInRepository() { const string testMail = "*****@*****.**"; var testTopic = new Topic { Abbreviation = "TT", Description = "Test Topic" }; var testSubscription = new Subscription { Mail = testMail, Topics = new List <Topic> { testTopic } }; var repositoryMock = new Mock <ISubscriptionRepository>(); repositoryMock .Setup(repository => repository.GetSubscription(testMail)) .Returns(testSubscription); var sendContentMock = new Mock <ISendContent>(); var controller = new SubscriptionController(repositoryMock.Object, sendContentMock.Object); Subscription subscription = controller.GetSubscription(testMail); Assert.Equal(testMail, subscription.Mail); Assert.Equal(testTopic, subscription.Topics.Single()); }
public async void BulkInsert_No_Errors() { SubscriptionControllerMockFacade mock = new SubscriptionControllerMockFacade(); var mockResponse = new CreateResponse <ApiSubscriptionResponseModel>(new FluentValidation.Results.ValidationResult()); mockResponse.SetRecord(new ApiSubscriptionResponseModel()); mock.ServiceMock.Setup(x => x.Create(It.IsAny <ApiSubscriptionRequestModel>())).Returns(Task.FromResult <CreateResponse <ApiSubscriptionResponseModel> >(mockResponse)); SubscriptionController controller = new SubscriptionController(mock.ApiSettingsMoc.Object, mock.LoggerMock.Object, mock.TransactionCoordinatorMock.Object, mock.ServiceMock.Object, mock.ModelMapperMock.Object); controller.ControllerContext = new ControllerContext(); controller.ControllerContext.HttpContext = new DefaultHttpContext(); var records = new List <ApiSubscriptionRequestModel>(); records.Add(new ApiSubscriptionRequestModel()); IActionResult response = await controller.BulkInsert(records); response.Should().BeOfType <OkObjectResult>(); (response as OkObjectResult).StatusCode.Should().Be((int)HttpStatusCode.OK); var result = (response as OkObjectResult).Value as List <ApiSubscriptionResponseModel>; result.Should().NotBeEmpty(); mock.ServiceMock.Verify(x => x.Create(It.IsAny <ApiSubscriptionRequestModel>())); }
public SubscriptionControllerTest() { DB = new InMemoryDB(); context = DB.GetInMemoryDB(true); SeederInMemoryDB.Seed(context); c = new SubscriptionController(context); }
private string SubscribeTopic() { if (UserId <= 0) { return(BuildOutput(string.Empty, OutputCodes.AuthenticationFailed, true)); } int iStatus = 0; SubscriptionController sc = new SubscriptionController(); int forumId = -1; int topicId = -1; if (Params.ContainsKey("forumid") && SimulateIsNumeric.IsNumeric(Params["forumid"])) { forumId = int.Parse(Params["forumid"].ToString()); } if (Params.ContainsKey("topicid") && SimulateIsNumeric.IsNumeric(Params["topicid"])) { topicId = int.Parse(Params["topicid"].ToString()); } iStatus = sc.Subscription_Update(PortalId, ModuleId, forumId, topicId, 1, this.UserId, ForumUser.UserRoles); if (iStatus == 1) { return(BuildOutput("{\"subscribed\":true,\"text\":\"" + Utilities.JSON.EscapeJsonString(Utilities.GetSharedResource("[RESX:TopicSubscribe:TRUE]")) + "\"}", OutputCodes.Success, true, true)); } else { return(BuildOutput("{\"subscribed\":false,\"text\":\"" + Utilities.JSON.EscapeJsonString(Utilities.GetSharedResource("[RESX:TopicSubscribe:FALSE]")) + "\"}", OutputCodes.Success, true, true)); } }
public void UpdateSubscripitionTest() { Subscription subscriptionsample = context.subscription.Where(x => x.ClientId == demoClientId).FirstOrDefault(); subscriptionDTOTest subscription = new subscriptionDTOTest(); subscription.subscriptionid = subscriptionsample.SubscriptionId; subscription.clientid = demoClientId; subscription.fromdate = DateTime.Now; subscription.todate = DateTime.Now.AddMonths(3); // subscriptionMkt.MarketBaseId = mktbase.MarketBaseId; JObject request = (JObject)JToken.FromObject(subscription); var subscriptionController = new SubscriptionController { Request = new System.Net.Http.HttpRequestMessage(), Configuration = new HttpConfiguration() }; var response = subscriptionController.updateSubscription(request); Subscription subscriptionupdated = context.subscription.Where(x => x.SubscriptionId == subscription.subscriptionid).FirstOrDefault(); Assert.IsNotNull(response); Assert.IsTrue(response.IsSuccessStatusCode); Assert.IsNotNull(subscriptionupdated); Assert.AreEqual(response.StatusCode, HttpStatusCode.Created); }
public void AddMarketBaseToSubscriptionTest() { Subscription subscriptionsample = context.subscription.Where(x => x.ClientId == demoClientId).FirstOrDefault(); ClientMarketBases mktbase = context.ClientMarketBases.Where(x => x.ClientId == demoClientId).FirstOrDefault(); subscriptionMktDTOTest subscriptionMkt = new subscriptionMktDTOTest(); subscriptionMkt.subscriptionid = subscriptionsample.SubscriptionId; subscriptionMkt.mktbaseid = new List <int>(); subscriptionMkt.mktbaseid.Add(mktbase.MarketBaseId); subscriptionMkt.clientid = demoClientId; JObject request = (JObject)JToken.FromObject(subscriptionMkt); var subscriptionController = new SubscriptionController { Request = new System.Net.Http.HttpRequestMessage(), Configuration = new HttpConfiguration() }; var response = subscriptionController.addMarketBase(request); int mktbaseID = subscriptionMkt.mktbaseid[0]; var subscriptionMkts = context.subscriptionMarket.Where(x => x.SubscriptionId == subscriptionMkt.subscriptionid && x.MarketBaseId == mktbaseID).ToList(); Assert.IsNotNull(response); Assert.IsTrue(response.IsSuccessStatusCode); Assert.IsTrue(subscriptionMkts.Count() > 0); }
public void Setup() { var dependencies = new SetupDependencies(); _customerController = dependencies.GetCustomerControllerInstance(); _productController = dependencies.GetProductControllerInstance(); _subscriptionController = dependencies.GetSubscriptionControllerInstance(); }
public void GetActiveSubscription_ReturnsNOK() { var controller = new SubscriptionController(ism); // Act var result = controller.GetActiveSubscription(2); // Assert Assert.Null(result); }
public void GetActiveSubscription_ReturnsOK() { var controller = new SubscriptionController(ism); // Act var result = controller.GetActiveSubscription(1); // Assert Assert.IsType <SubscriptionDto>(result); }
public void GetSubscription_ReturnsNOK() { var controller = new SubscriptionController(ism); // Act var result = controller.GetSubscription(1); // Assert Assert.IsType <BadRequestObjectResult>(result); }
public void GetAllSubscriptions_ReturnsOK() { var controller = new SubscriptionController(ism); // Act var result = controller.GetAllSubscriptions(); // Assert Assert.NotEmpty(result); }
public void GetBonusDays_ReturnsNOK() { var controller = new SubscriptionController(ism); // Act var result = controller.GetBonusDays(245, 2); // Assert Assert.IsType <Int32>(result); Assert.Equal(0, result); }
public void Put_ReturnsNOK() { var controller = new SubscriptionController(ism); // Act SubscriptionDto sub = new SubscriptionDto(); var result = controller.Put(sub); // Assert Assert.IsType <BadRequestResult>(result); }
public void GetAllSubscriptions_ReturnsNOK() { var mockSub = new Mock <ISubscriptionManipulation>(); var controller = new SubscriptionController(mockSub.Object); // Act var result = controller.GetAllSubscriptions(); // Assert Assert.Empty(result); }
public void AddSubscription_Valid_SubscriptionStatus() { Mock <ISubscriptionRepository> acr = new Mock <ISubscriptionRepository>(); acr.Setup(p => p.AddSubscription(db, "Token")).Returns("Your Subscription Added Successfully!"); SubscriptionController contr = new SubscriptionController(acr.Object); var data = contr.Add_Subscription(db) as OkObjectResult; Assert.AreEqual(200, data.StatusCode); }
public void ViewDetailsBySubscriptionID() { Mock <ISubscriptionRepository> mock = new Mock <ISubscriptionRepository>(); mock.Setup(p => p.ViewDetailsByID(2)).Returns(db); SubscriptionController con = new SubscriptionController(mock.Object); var data = con.ViewDetails_BySubID(2) as OkObjectResult; Assert.AreEqual(200, data.StatusCode); }
public void RemoveSubscription_Valid_SubscriptionStatus() { string str = "Unsubscription Done. Thank You!"; Mock <ISubscriptionRepository> acr = new Mock <ISubscriptionRepository>(); acr.Setup(p => p.RemoveSubscription(db, "Token")).Returns(str); SubscriptionController contr = new SubscriptionController(acr.Object); var data = contr.Remove_Subscription(db) as OkObjectResult; Assert.AreEqual(200, data.StatusCode); }
public void AddSubscription_InValid_SubscriptionStatus() { Mock <ISubscriptionRepository> mock = new Mock <ISubscriptionRepository>(); mock.Setup(p => p.AddSubscription(sub, "Token")).Returns("Sorry! Subscription Not Possible Due To Unavailable drug."); SubscriptionController obj = new SubscriptionController(mock.Object); var res = obj.Add_Subscription(sub) as OkObjectResult; Assert.AreEqual(200, res.StatusCode); }
/// <summary> /// Unsubscribes the <paramref name="subscriberInstance"/> from all events /// </summary> /// <param name="subscriberInstance">The subscriber instance.</param> public static void From(object subscriberInstance) { _log.DebugFormat("Unsubscribing {0} from all events", EllaModel.Instance.GetSubscriberId(subscriberInstance)); if (!Is.Subscriber(subscriberInstance.GetType())) { _log.ErrorFormat("Cannot unsubscribe. {0} is not a valid subscriber", subscriberInstance.GetType().ToString()); throw new ArgumentException("subscriberInstance must be a valid subscriber"); } SubscriptionController.PerformUnsubscribe(s => s.Subscriber == subscriberInstance); }
public void WhenAUserUnSubscribes(string lastName, string firstName, string email) { var controller = new SubscriptionController(this.dataStorageMock.Object, this.reportingMock.Object) { ControllerContext = MvcMockHelpers.GetControllerContextMock("POST") }; var actionResult = controller.Delete(email, new FormCollection()); ScenarioContext.Current["Controller"] = controller; ScenarioContext.Current["ActionResult"] = actionResult; }
public void SetUp() { // Setup Mocks and Stub mockDataService = new Mock <IDataService>(); mockCacheProvider = MockComponentProvider.CreateDataCacheProvider(); subscriptionSecurityController = new Mock <ISubscriptionSecurityController>(); DataService.SetTestableInstance(mockDataService.Object); SubscriptionSecurityController.SetTestableInstance(subscriptionSecurityController.Object); // Setup SUT subscriptionController = new SubscriptionController(); }
public void TestConstructor_PassEverythingCorrectly_ShouldInitializeCorrectly() { // Arrange var mockedService = new Mock <ISubscriptionService>(); var mockedProvider = new Mock <IAuthenticationProvider>(); var mockedFactory = new Mock <IViewModelFactory>(); // Act var controller = new SubscriptionController(mockedService.Object, mockedProvider.Object, mockedFactory.Object); // Assert Assert.IsNotNull(controller); }
/// <summary> /// Unsubscribes the <paramref name="subscriberInstance" /> from type <typeparamref name="T" /> /// </summary> /// <typeparam name="T">The type to unsubscribe from</typeparam> /// <exception cref="System.ArgumentException">subscriberInstance must be a valid subscriber</exception> public static void From <T>(object subscriberInstance) { _log.DebugFormat("Unsubscribing {0} from type {1}", EllaModel.Instance.GetSubscriberId(subscriberInstance), typeof(T)); if (!Is.Subscriber(subscriberInstance.GetType())) { _log.ErrorFormat("Cannot unsubscribe. {0} is not a valid subscriber", subscriberInstance.GetType().ToString()); throw new ArgumentException("subscriberInstance must be a valid subscriber"); } SubscriptionController.PerformUnsubscribe(s => s.Subscriber == subscriberInstance && s.Event.EventDetail.DataType == typeof(T)); }
public void SetUp() { // Setup Mocks and Stub mockDataService = new Mock<IDataService>(); mockCacheProvider = MockComponentProvider.CreateDataCacheProvider(); subscriptionSecurityController = new Mock<ISubscriptionSecurityController>(); DataService.SetTestableInstance(mockDataService.Object); SubscriptionSecurityController.SetTestableInstance(subscriptionSecurityController.Object); // Setup SUT subscriptionController = new SubscriptionController(); }
private string SubscribeTopic() { if (UserId <= 0) { return BuildOutput(string.Empty, OutputCodes.AuthenticationFailed, true); } int iStatus = 0; SubscriptionController sc = new SubscriptionController(); int forumId = -1; int topicId = -1; if (Params.ContainsKey("forumid") && SimulateIsNumeric.IsNumeric(Params["forumid"])) { forumId = int.Parse(Params["forumid"].ToString()); } if (Params.ContainsKey("topicid") && SimulateIsNumeric.IsNumeric(Params["topicid"])) { topicId = int.Parse(Params["topicid"].ToString()); } iStatus = sc.Subscription_Update(PortalId, ModuleId, forumId, topicId, 1, this.UserId, ForumUser.UserRoles); if (iStatus == 1) { return BuildOutput("{\"subscribed\":true,\"text\":\"" + Utilities.JSON.EscapeJsonString(Utilities.GetSharedResource("[RESX:TopicSubscribe:TRUE]")) + "\"}", OutputCodes.Success, true, true); } else { return BuildOutput("{\"subscribed\":false,\"text\":\"" + Utilities.JSON.EscapeJsonString(Utilities.GetSharedResource("[RESX:TopicSubscribe:FALSE]")) + "\"}", OutputCodes.Success, true, true); } }