public async Task AllConfirmedAsync_ShouldReturnsCorrectCountOfConfirmedSubscribers()
{
await this.dbContext.Subscribers.AddRangeAsync(new List <Subscriber>
{
new Subscriber {
IsConfirmed = true
},
new Subscriber {
IsConfirmed = false
},
new Subscriber {
IsConfirmed = true
},
new Subscriber {
IsConfirmed = true
},
new Subscriber {
IsConfirmed = false
},
});
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
var result = await subscriberService.AllConfirmedAsync <FakeSubscriber>();
var expectedCount = 3;
var actualCount = result.Count();
Assert.Equal(expectedCount, actualCount);
}
public void TestUnsubscribe()
{
const string email = "*****@*****.**";
var token = SubscriberService.CalculateToken(email);
Assert.IsTrue(SubscriberService.VerifyToken(email, token));
}
public async Task HandleMemberSubscriptionAsync_UnsubscribedSubscriber_ShouldBeResubscribedWithStatusPending()
{
//arrange
var nullLogger = new NullLogger <SubscriberService>();
var fakeRepository = new FakeMailchimpRepository();
var subscriberService = new SubscriberService(nullLogger, fakeRepository);
var unsubscribedSubscriber = new NewSubscriberDto()
{
Email = "*****@*****.**",
Name = "Unsubscribed",
Source = "UnitTest"
};
//assume
var assumedMember = await fakeRepository.GetMemberAsync(unsubscribedSubscriber.Email);
Assume.That(
assumedMember?.Status ==
"unsubscribed", "Missing unsubscribed member in the collection");
//act
await subscriberService.HandleMemberSubscriptionAsync(unsubscribedSubscriber);
MemberDto receivedMember = await fakeRepository.GetMemberAsync(unsubscribedSubscriber.Email);
//assert
Assert.Equal(unsubscribedSubscriber.Email, receivedMember.EmailAddress);
Assert.Equal("pending", receivedMember.Status);
}
public void GetByUserTest()
{
var id = new Guid();
var list = new List <Subscriber>()
{
new Subscriber()
{
Id = new Guid(),
UserProfileId = id
},
new Subscriber()
{
Id = new Guid(),
UserProfileId = new Guid()
}
};
var unit = new MockUnitOfWork();
unit.MockRepository();
unit.MockGetAllForRep(list);
var service = new SubscriberService(unit.Object);
var res = service.GetByUser(id).GetAwaiter().GetResult();
Assert.NotNull(res);
Assert.NotEmpty(res);
Assert.Equal(id, res.First().UserProfileId);
Assert.IsAssignableFrom <IEnumerable <Subscriber> >(res);
}
public async Task GetAsync_Projection_ShouldGetCorrectSubscriber_WhenCategoryExists()
{
var wantedSubscriberId = Guid.NewGuid().ToString();
var wantedSubscriberConfirmationCode = Guid.NewGuid().ToString();
await this.dbContext.Subscribers.AddRangeAsync(new List <Subscriber>()
{
new Subscriber {
Id = "1", ConfirmationCode = "1"
},
new Subscriber {
Id = wantedSubscriberId, ConfirmationCode = wantedSubscriberConfirmationCode
},
new Subscriber {
Id = "3", ConfirmationCode = "3"
},
});
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
var expectedSubscriberId = wantedSubscriberId;
var subscriber = await subscriberService.GetAsync <FakeSubscriber>(wantedSubscriberId, wantedSubscriberConfirmationCode);
Assert.Equal(expectedSubscriberId, subscriber.Id);
}
public async Task GetAsync_ShouldGetCorrectSubscriber_WhenEmailExists()
{
var wantedSubscriberId = Guid.NewGuid().ToString();
var wantedSubscriberEmail = Guid.NewGuid().ToString();
await this.dbContext.Subscribers.AddRangeAsync(new List <Subscriber>()
{
new Subscriber {
Id = "1", Email = "*****@*****.**"
},
new Subscriber {
Id = wantedSubscriberId, Email = wantedSubscriberEmail
},
new Subscriber {
Id = "3", Email = "*****@*****.**"
},
});
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
var expectedSubscriberId = wantedSubscriberId;
var subscriber = await subscriberService.GetAsync(wantedSubscriberEmail);
Assert.Equal(expectedSubscriberId, subscriber.Id);
}
public async Task GetAsync_Projection_ShouldThrowInvalidSubscriberException_WhenSubscriberNotExists()
{
var correctConfirmationCode = Guid.NewGuid().ToString();
await this.dbContext.Subscribers.AddRangeAsync(new List <Subscriber>()
{
new Subscriber {
Id = "1", ConfirmationCode = "1"
},
new Subscriber {
Id = "2", ConfirmationCode = correctConfirmationCode
},
new Subscriber {
Id = "3", ConfirmationCode = "3"
},
});
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
var incorrectId = Guid.NewGuid().ToString();
Assert.Throws <InvalidSubscriberException>(() =>
subscriberService.GetAsync <FakeSubscriber>(incorrectId, correctConfirmationCode).GetAwaiter().GetResult());
}
public async Task ExistsAsync_ShouldReturnsTrue_WhenSubscriberEmailExists()
{
var existingEmail = "*****@*****.**";
await this.dbContext.Subscribers.AddRangeAsync(new List <Subscriber>
{
new Subscriber {
Email = "*****@*****.**"
},
new Subscriber {
Email = "*****@*****.**"
},
new Subscriber {
Email = existingEmail
},
new Subscriber {
Email = "*****@*****.**"
},
new Subscriber {
Email = "*****@*****.**"
},
});
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
var result = await subscriberService.ExistsAsync(existingEmail);
Assert.True(result);
}
public async Task ExistsAsync_ShouldReturnsFalse_WhenSubscriberEmailNotExists()
{
await this.dbContext.Subscribers.AddRangeAsync(new List <Subscriber>
{
new Subscriber {
Email = "*****@*****.**"
},
new Subscriber {
Email = "*****@*****.**"
},
new Subscriber {
Email = "*****@*****.**"
},
new Subscriber {
Email = "*****@*****.**"
},
new Subscriber {
Email = "*****@*****.**"
},
});
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
var notExistingEmail = "*****@*****.**";
var result = await subscriberService.ExistsAsync(notExistingEmail);
Assert.False(result);
}
public async Task HandleMemberSubscriptionAsync_AlreadySubscribed_ShouldBeNotChanged()
{
//arrange
var nullLogger = new NullLogger <SubscriberService>();
var fakeRepository = new FakeMailchimpRepository();
var subscriberService = new SubscriberService(nullLogger, fakeRepository);
var subscribedSubscriber = new NewSubscriberDto()
{
Email = "*****@*****.**",
Name = "Subscribed",
Source = "UnitTest"
};
//assume
var assumedMember = await fakeRepository.GetMemberAsync(subscribedSubscriber.Email);
Assume.That(
assumedMember?.Status ==
"subscribed", "Missing subscribed member in the collection");
//act
await subscriberService.HandleMemberSubscriptionAsync(subscribedSubscriber);
MemberDto receivedMember = await fakeRepository.GetMemberAsync(subscribedSubscriber.Email);
var memberChanges = fakeRepository.Members["*****@*****.**"];
//assert
Assert.Single(memberChanges);
Assert.Equal(subscribedSubscriber.Email, receivedMember.EmailAddress);
Assert.Equal("subscribed", receivedMember.Status);
}
public async Task HandleMemberSubscriptionAsync_Pending_ShouldBeChangedByEmailsServiceToUnsubscribedThanPending()
{
//arrange
var nullLogger = new NullLogger <SubscriberService>();
var fakeRepository = new FakeMailchimpRepository();
var subscriberService = new SubscriberService(nullLogger, fakeRepository);
var newSubscriber = new NewSubscriberDto()
{
Email = "*****@*****.**",
Name = "Marek",
Source = "UnitTest"
};
//act
await subscriberService.HandleMemberSubscriptionAsync(newSubscriber);
MemberDto receivedMember = await fakeRepository.GetMemberAsync(newSubscriber.Email);
var memberHistory = fakeRepository.Members["*****@*****.**"];
//assert
Assert.Equal(3, memberHistory.Count);
Assert.Equal(newSubscriber.Email, receivedMember.EmailAddress);
Assert.Equal("unsubscribed", memberHistory.ElementAt(1).Status);
Assert.Equal("pending", receivedMember.Status);
}
/// <summary>
/// This method Send Message
/// </summary>
public void SendMessage(bool isPrivate = false, SubscriberCallback subscriber = null)
{
// Create a new instance of a 'SubscriberMessage' object.
SubscriberMessage message = null;
// Create a new instance of a 'SubscriberMessage' object.
message = new SubscriberMessage();
message.Text = MessageText;
message.FromId = Id;
message.FromName = SubscriberName;
message.SentTime = DateTime.Now;
// Set the Time
message.Sent = DateTime.Now;
// Set the
message.BubbleColor = (BubbleColorEnum)Shuffler.PullNextItem();
try
{
// If the MessageText string exists
if (TextHelper.Exists(MessageText))
{
// if this is a private message
if ((isPrivate) && (NullHelper.Exists(subscriber)) && (subscriber.HasCallback))
{
// Set the ToName
message.ToName = subscriber.Name;
message.ToId = subscriber.Id;
// This is a private message
message.IsPrivate = true;
// Send this message to all clients
SubscriberService.SendPrivateMessage(subscriber, message);
}
else
{
// Set the ToName
message.ToName = "Room";
message.ToId = Guid.Empty;
// Send this message to all clients
SubscriberService.BroadcastMessage(message);
}
// Erase the Text
MessageText = "";
// Deliver the message to this client, without being Broadcast
Listen(message);
}
}
catch (Exception error)
{
// for debugging only
DebugHelper.WriteDebugError("BroadCastMessage", "Chat.razor.cs", error);
}
}
public override List <Subscriber> Subscribers(SubscriberService subscriberService)
{
return(new List <Subscriber> {
new Subscriber {
Name = _email
}
});
}
public void AddAsync_WithEmailAlreadyExist_ThrowException()
{
SubscriberModel subscriberModel = new SubscriberModel();
var mockUoW = new Mock <IUnitOfWork>();
SubscriberService subscriberService = new SubscriberService(mockUoW.Object);
subscriberService.AddAsync
}
public WcfHost()
{
instance = new SubscriberService();
host = new ServiceHost(instance, new Uri("net.tcp://localhost:8600"));
Binding binding = new NetTcpBinding(SecurityMode.Transport);
host.AddServiceEndpoint(typeof(ISubscriberService).FullName, binding, "net.tcp://localhost:8600/Test");
host.Open();
}
public async void GetCardId_CardExists_returnSuscriberWithThisCardId()
{
var subscriberService = new SubscriberService(
new SubscriberRepository(
new WeightWatchersContext()));
CardModel result = await subscriberService.GetByIdAsync(1);
Assert.Equals(1, result.id);
}
public WcfHost()
{
instance = new SubscriberService();
host = new ServiceHost(instance, new Uri("net.tcp://localhost:8600"));
Binding binding = new NetTcpBinding(SecurityMode.Transport);
host.AddServiceEndpoint(typeof(ISubscriberService).FullName, binding, "net.tcp://localhost:8600/Test");
host.Open();
}
/// <summary>
/// This method Dispose
/// </summary>
public void Dispose()
{
// If the SubscriberService object exists
if (NullHelper.Exists(SubscriberService))
{
// Unsubscribe from the service
SubscriberService.Unsubscribe(Id);
}
}
public async Task CreateAsync_ShouldAddNewSubscriber_WithNotConfirmedEmail()
{
var subscriberService = new SubscriberService(this.dbContext);
var newSubscriberEmail = "*****@*****.**";
var newSubscriber = await subscriberService.CreateAsync(newSubscriberEmail);
var newSubscriberFromDb = await this.dbContext.Subscribers.FindAsync(newSubscriber.Id);
Assert.False(newSubscriberFromDb.IsConfirmed);
}
public async Task CreateAsync_ShouldGenerateConfirmationCodeToNewSubscriber()
{
var subscriberService = new SubscriberService(this.dbContext);
var newSubscriberEmail = "*****@*****.**";
var newSubscriber = await subscriberService.CreateAsync(newSubscriberEmail);
var newSubscriberFromDb = await this.dbContext.Subscribers.FindAsync(newSubscriber.Id);
Assert.NotNull(newSubscriberFromDb.ConfirmationCode);
}
public async Task CreateAsync_ShouldAddNewSubscriberToDb()
{
var subscriberService = new SubscriberService(this.dbContext);
var newSubscriberEmail = "*****@*****.**";
await subscriberService.CreateAsync(newSubscriberEmail);
const int expected = 1;
var actual = this.dbContext.Subscribers.Count();
Assert.Equal(expected, actual);
}
/// <summary>
/// This method is used to send a Private message to a user
/// </summary>
/// <param name="args"></param>
/// <param name="toId"></param>
private void SendPrivateMessageClicked(EventArgs args, Guid toId)
{
// Attempt to find the subscriber
SubscriberCallback subscriber = SubscriberService.FindSubscriber(toId);
// If the subscriber object exists
if (NullHelper.Exists(subscriber))
{
// Send a message
SendMessage(true, subscriber);
}
}
public void Initialize()
{
_gateFactory = A.Fake <IGateFactory>();
_fallbackService = A.Fake <IFallbackService>();
_httpClientFactory = A.Fake <IHttpClientFactory>();
var logger = A.Fake <ILogger <SubscriberService> >();
_toTest = new SubscriberService(_gateFactory, new List <IFallbackService>
{
_fallbackService
}, _httpClientFactory, logger);
}
public void Add_Subscriber_To_Db()
{
var mockDbSet = new Mock <DbSet <Subscriber> >();
var mockContext = new Mock <RentalContext>();
mockContext.Setup(r => r.Subscribers).Returns(mockDbSet.Object);
var service = new SubscriberService(mockContext.Object);
service.Add(new Subscriber());
mockContext.Verify(a => a.Add(It.IsAny <Subscriber>()), Times.Once);
mockContext.Verify(s => s.SaveChanges(), Times.Once);
}
public async void LoginAsync_EmailExist_GotMinus1()
{
var optionsBuilder = new DbContextOptionsBuilder <WeightWatchersContext>()
.UseSqlServer("Server = C1; Database = WeightWatchersDB ;Trusted_Connection=True; ").Options;
WeightWatchersContext weightWatchersContext = new WeightWatchersContext(optionsBuilder);
var subscriberService = new SubscriberService(new SubscriberRepository(weightWatchersContext, mapper), mapper);
//Act - Call the method being tested
var isEmailExist = await subscriberService.LoginAsync("*****@*****.**", "4545");
//Assert
Assert.Equal(isEmailExist, -1);
}
public void GetCardId_CardExists_returnSuscriberWithThisCardId()
{
var mock = new Mock <ISubscriberRepository>();
var card = new CardModel()
{
id = 1, weight = 200
};
mock.Setup(p => p.GetById(1)).Returns(card);
SubscriberService subscriberService = new SubscriberService(mock.Object);
var result = subscriberService.GetByIdAsync(1);
Assert.AreEqual(card, result);
}
public async System.Threading.Tasks.Task GetCardIdAsync_CardExists_returnSuscriberWithThisCardIdAsync()
{
var mock = new Mock <ISubscriberRepository>();
var card = new CardModel()
{
id = 1, weight = 200
};
mock.Setup(p => p.GetByIdAsync(1).Result).Returns(card);
SubscriberService subscriberService = new SubscriberService(mock.Object);
CardModel result = subscriberService.GetByIdAsync(1).Result;
Assert.Equal(card, result);
}
/// <summary>
/// This event registers with the chat server
/// </summary>
public void RegisterWithServer()
{
SubscriberCallback callback = new SubscriberCallback(SubscriberName);
callback.Callback = Listen;
callback.Name = SubscriberName;
// Get a message back
SubscriberMessage message = SubscriberService.Subscribe(callback);
// if message.Text exists and equals Subscribed
if ((NullHelper.Exists(message)) && (message.HasText) && (TextHelper.IsEqual(message.Text, "Subscribed")))
{
// Set to true
Connected = true;
// Set the Id the Server assigned
this.Id = message.ToId;
}
// Convert the Subscribers to Names
this.Names = SubscriberService.GetSubscriberNames();
// get the count
int count = NumericHelper.ParseInteger(message.Data.ToString(), 0, -1);
// if there are two people online or more
if (count > 1)
{
// send a message to everyone else this user has joined
SubscriberMessage newMessage = new SubscriberMessage();
// set the text
newMessage.FromId = Id;
newMessage.FromName = SubscriberName;
newMessage.Text = SubscriberName + " has joined the conversation.";
newMessage.ToId = Guid.Empty;
newMessage.ToName = "Room";
newMessage.IsSystemMessage = true;
// Send the message
SubscriberService.BroadcastMessage(newMessage);
// 6.5.2020: Get the Messages as you connect now
this.Messages = SubscriberService.GetBroadcastMessages(this.Id, DisplayMessagesCount);
}
// Update
Refresh();
}
public async void GetCardAsync_CardExist_GotCardModel()
{
var optionsBuilder = new DbContextOptionsBuilder <WeightWatchersContext>()
.UseSqlServer("Server = C1; Database = WeightWatchersDB ;Trusted_Connection=True; ").Options;
WeightWatchersContext weightWatchersContext = new WeightWatchersContext(optionsBuilder);
var subscriberService = new SubscriberService(new SubscriberRepository(weightWatchersContext, mapper), mapper);
//Act - Call the method being tested
var card = await subscriberService.GetCardAsync(1);
//Assert
Assert.IsType <CardModel>(card);
}
public async Task SubscribeAsync_ShouldSubscribe_WhenSubscriberExistsAndConfirmationCodeIsCorrect()
{
var subscriberId = Guid.NewGuid().ToString();
var subscriberConfirmationCode = Guid.NewGuid().ToString();
await this.dbContext.Subscribers.AddAsync(new Subscriber { Id = subscriberId, ConfirmationCode = subscriberConfirmationCode });
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
await subscriberService.SubscribeAsync(subscriberId, subscriberConfirmationCode);
var subscriber = await this.dbContext.Subscribers.FindAsync(subscriberId);
Assert.True(subscriber.IsConfirmed);
}
public async Task UnsubscribeAsync_ShouldThrowInvalidSubscriberException_WhenSubscriberNotExists()
{
var subscriberId = Guid.NewGuid().ToString();
var subscriberConfirmationCode = Guid.NewGuid().ToString();
await this.dbContext.Subscribers.AddAsync(new Subscriber { Id = subscriberId, ConfirmationCode = subscriberConfirmationCode });
await this.dbContext.SaveChangesAsync();
var subscriberService = new SubscriberService(this.dbContext);
var incorrectId = Guid.NewGuid().ToString();
Assert.Throws <InvalidSubscriberException>(() =>
subscriberService.UnsubscribeAsync(incorrectId, subscriberConfirmationCode).GetAwaiter().GetResult());
}
public void ProvisionedServicesDictionary_Public_Property_does_not_throw_an_exception_when_billed_services_name_is_null()
{
// Arrange
const string expectedClassName = "VOICE - VOIP";
const string expectedDescription = "CALLER ID ON TV";
const string expectedName = "CVCTV";
var expectedCompositeNameAndDescription = string.Format("({0}) {1}", expectedName, expectedDescription);
const string expectedElementClass = "childItem";
const bool expectedExcludedFromSyncedServices = false;
const string expectedImageUrl = "../../../../Images/warning.png";
const bool expectedIsSynced = false;
var provisionedService = new SubscriberService()
{
Action = null,
ClassName = expectedClassName,
Description = expectedDescription,
Name = expectedName,
Type = DAL.DataTransfer.Common.ServiceClassTypeDto.None
};
CVoipPhoneServicesViewModelForTests.ProvisionedServicesList.Add(provisionedService);
var billedService = new SubscriberService()
{
Action = null,
ClassName = null,
Description = null,
Name = null,
Type = DAL.DataTransfer.Common.ServiceClassTypeDto.None
};
CVoipPhoneServicesViewModelForTests.BilledServicesList.Add(billedService);
var actual = new SortedDictionary<string, List<SubscriberService>>();
// Act and Assert - the test passes if there isn't any exception thrown
try
{
actual = CVoipPhoneServicesViewModelForTests.ProvisionedServicesDictionary;
}
catch(Exception ex)
{
Assert.Fail("The following exception was thrown{0}{0}{1}", Environment.NewLine, ex);
}
Assert.IsNotNull(actual, "The ProvisionedServicesDictionary public property returned null");
Assert.AreEqual(1, actual.Count, "The ProvisionedServicesDictionary count did not match the expected value");
Assert.IsTrue(actual.ContainsKey(expectedClassName), "The result doesn't contain the Key of {0}", expectedClassName);
List<SubscriberService> subscriberServices;
actual.TryGetValue(expectedClassName, out subscriberServices);
Assert.IsNotNull(subscriberServices, "The list of services inside ProvisionedServicesDictionary public property returned null");
Assert.AreEqual(1, subscriberServices.Count, "The subscriber services count did not match the expected value");
Assert.AreEqual(expectedCompositeNameAndDescription, subscriberServices[0].CompositeNameAndDescription, "The subscriber services CompositeNameAndDescription did not match the expected value");
Assert.AreEqual(expectedElementClass, subscriberServices[0].ElementClass, "The subscriber services ElementClass did not match the expected value");
Assert.AreEqual(expectedExcludedFromSyncedServices, subscriberServices[0].ExcludedFromSyncedServices, "The subscriber services ExcludedFromSyncedServices did not match the expected value");
Assert.AreEqual(expectedImageUrl, subscriberServices[0].ImageUrl, "The subscriber services ImageUrl did not match the expected value");
Assert.AreEqual(expectedIsSynced, subscriberServices[0].IsSynced, "The subscriber services IsSynced did not match the expected value");
}
public SubscribersController(IUnitOfWork unitOfWork)
: base(unitOfWork)
{
SubscriberService = new SubscriberService(UnitOfWork);
GroupService = new GroupService(UnitOfWork);
}
public SubscriberController()
{
SubscriberService = new SubscriberService(UnitOfWork);
}
