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);
}
}
