private static void VerifyDiscrepancyResolution(IDiscrepanciesService service)
{
// Assort
var account = new Account
{
EmailAddress = "*****@*****.**",
FirstName = "Amaury",
LastName = "Rodriguez",
ProviderId = (int)Domain.Engagement.Providers.ProviderType.Yahoo
};
var subscriber = default(Subscriber);
var notExistingSeedDiscrepancy = SeedDiscrepancy.FromEngager(account, subscriber);
// Act
var result = service.Resolve(notExistingSeedDiscrepancy).Result;
// Assert
Assert.IsTrue(result.Succeeded);
Assert.AreEqual(SeedDiscrepancy.ResolvedMessage, result.Messages);
Assert.AreEqual(notExistingSeedDiscrepancy, result.Source);
using (var ctx = new SubscribersContext())
{
var provider = WD40.Domain.Engagement.Providers.Registry.Instance[notExistingSeedDiscrepancy.Account.Value.ProviderId];
var metadata = service.GetMetadataForProviderAsync(provider.SubscriberId).Result;
subscriber = ctx.FromStore(metadata.DatabaseName, metadata.TableName).GetSubscribers(s => s.email.Trim() == notExistingSeedDiscrepancy.EmailAddress).Result.SingleOrDefault();
Assert.IsNotNull(subscriber);
Assert.AreEqual(subscriber.send, 1);
}
// TODO: Update subscriber set Mailable = false
subscriber.SetMailable(false);
var notMailableSeedDiscrepancy = SeedDiscrepancy.FromEngager(account, subscriber);
// Act
result = service.Resolve(notMailableSeedDiscrepancy).Result;
// Assert
Assert.IsTrue(result.Succeeded);
Assert.AreEqual(SeedDiscrepancy.ResolvedMessage, result.Messages);
Assert.AreEqual(notMailableSeedDiscrepancy, result.Source);
using (var ctx = new SubscribersContext())
{
var provider = WD40.Domain.Engagement.Providers.Registry.Instance[notExistingSeedDiscrepancy.Account.Value.ProviderId];
var metadata = service.GetMetadataForProviderAsync(provider.SubscriberId).Result;
subscriber = ctx.FromStore(metadata.DatabaseName, metadata.TableName).GetSubscribers(s => s.email.Trim() == notExistingSeedDiscrepancy.EmailAddress).Result.SingleOrDefault();
Assert.IsNotNull(subscriber);
Assert.AreEqual(subscriber.send, 1);
// Clean Up
var wasDeleted = ctx.Delete(subscriber).Result;
Assert.IsTrue(wasDeleted);
subscriber = ctx.GetSubscribers(s => s.email.Trim() == notExistingSeedDiscrepancy.EmailAddress).Result.SingleOrDefault();
Assert.IsNull(subscriber);
}
}
private static Mock<IDiscrepanciesService> CreateFakeService()
{
var service = new Mock<IDiscrepanciesService>();
service
.Setup(x => x.GetMetadataForProviderAsync(It.IsAny<int>()))
.Returns<int>(async subscriberId =>
{
using (var ctx = new OenContext())
{
var linkData = await ctx.Lists.FirstOrDefaultAsync(x => x.enabled && (x.clientKey_id == subscriberId) && (x.emailCount > 0));
return new WD40.Domain.Engagement.Providers.Metadata
{
DatabaseName = linkData.dataBaseName,
TableName = linkData.tableName
};
}
});
service
.Setup(x => x.GetNotMailableEngagedItemsAsync(It.IsAny<ProviderType>(), It.IsAny<int>(), It.IsAny<int>()))
.Returns<ProviderType, int, int>(async (pId, sId, days) =>
{
var result = (new SeedDiscrepancy[] { }).AsEnumerable();
using (var ctx = new EngagerContext())
{
var oldestDateCreated = DateTime.Today.AddDays(-days);
var accounts = await (from x in ctx.Accounts
where x.IsActive && (x.ProviderId == (int)pId) && (x.DateAccountCreated >= oldestDateCreated)
select x).ToArrayAsync();
if (accounts.Any())
{
var metadata = await service.Object.GetMetadataForProviderAsync(sId);
using (var subscribersCtx = new SubscribersContext())
{
subscribersCtx.Database.Connection.ConnectionString += string.Format(";initial catalog={0};", metadata.DatabaseName);
var subscribers = subscribersCtx.FromStore(metadata.DatabaseName, metadata.TableName).GetSubscribers(subscribersCtx.AllSubscribersSpecification).Result;
if (subscribers.Any())
{
result = from x in accounts
join y in subscribers on x.EmailAddress equals y.email.Trim() into all
from r in all.DefaultIfEmpty()
where (r == null) || (r.send == 0)
select SeedDiscrepancy.FromEngager(x, r);
}
}
}
return result.AsQueryable();
}
});
service
.Setup(x => x.GetNotEngagedMailableItemsAsync(It.IsAny<ProviderType>(), It.IsAny<int>(), It.IsAny<int>()))
.Returns<ProviderType, int, int>(async (pId, sId, days) =>
{
var result = (new SeedDiscrepancy[] { }).AsEnumerable();
var metadata = await service.Object.GetMetadataForProviderAsync(sId);
using (var subscribersCtx = new SubscribersContext())
{
var subscribers = await subscribersCtx.FromStore(metadata.DatabaseName, metadata.TableName).GetSubscribers(subscribersCtx.MailableSubscribersSpecification);
if (subscribers.Any())
{
var oldestDateCreated = DateTime.Today.AddDays(-days);
using (var ctx = new EngagerContext())
{
var accounts = await (from x in ctx.Accounts
where (x.ProviderId == (int)pId) && (x.DateAccountCreated >= oldestDateCreated)
select x).ToArrayAsync();
result = from x in subscribers
join y in accounts on x.email.Trim() equals y.EmailAddress into all
from r in all.DefaultIfEmpty()
where (r == null) || !r.IsActive
select SeedDiscrepancy.FromWhiteDelivery(r, x);
}
}
return result.AsQueryable();
}
});
service
.Setup(x => x.Resolve(It.IsAny<SeedDiscrepancy>()))
.Returns<SeedDiscrepancy>(async sd =>
{
if (!sd.IsValid)
{
return SeedDiscrepancyResolution.Failed(sd).WithMessage(SeedDiscrepancy.InvalidDiscrepancyMessage);
}
var result = SeedDiscrepancyResolution.Failed(sd).WithMessage(SeedDiscrepancy.NotImplementedFeatureMessage);
if (sd.IsEngagerDiscrepancy)
{
using (var subscribersCtx = new SubscribersContext())
{
var provider = WD40.Domain.Engagement.Providers.Registry.Instance[sd.Account.Value.ProviderId];
var metadata = await service.Object.GetMetadataForProviderAsync(provider.SubscriberId);
if (!sd.Subscriber.HasValue)
{
try
{
result.Succeeded = await subscribersCtx.FromStore(metadata.DatabaseName, metadata.TableName).AddSubscriber(sd);
result.WithMessage(SeedDiscrepancy.ResolvedMessage);
}
catch (Exception e)
{
result.WithMessage(e.Message);
}
}
else
{
try
{
result.Succeeded = await subscribersCtx.FromStore(metadata.DatabaseName, metadata.TableName).EnableSubscriber(sd);
result.WithMessage(SeedDiscrepancy.ResolvedMessage);
}
catch (Exception e)
{
result.WithMessage(e.Message);
}
}
}
}
else
{
if (!sd.Account.HasValue)
{
// TODO: Add subscriber to Engager
throw new NotImplementedException(result.Messages);
}
else
{
// TODO: Update account in Engager with active = true
throw new NotImplementedException(result.Messages);
}
}
return result;
});
return service;
}
private static void VerifyEngagerDiscrepancies(IDiscrepanciesService service, Mapping provider, int daysCreated)
{
var result = service.GetNotMailableEngagedItemsAsync(provider.ProviderId, provider.SubscriberId, daysCreated).Result;
// Assert
if (result.Any())
{
result.Take(MaxAccountsToVerify).ToList().ForEach(x =>
{
if (x.Subscriber.HasValue)
{
using (var ctx = new SubscribersContext())
{
var metadata = service.GetMetadataForProviderAsync(provider.SubscriberId).Result;
var subscriber = ctx.FromStore(metadata.DatabaseName, metadata.TableName).GetSubscribers(s => s.subscriber_id == x.Subscriber.Value.SubscriberId).Result.SingleOrDefault();
Assert.IsNotNull(subscriber);
Assert.AreEqual(subscriber.send, 0);
}
Assert.AreEqual(x.Description, SeedDiscrepancy.NotMailableSeedMessage);
}
else
{
using (var ctx = new SubscribersContext())
{
var metadata = service.GetMetadataForProviderAsync(provider.SubscriberId).Result;
var subscriber = ctx.FromStore(metadata.DatabaseName, metadata.TableName).GetSubscribers(s => s.email == x.EmailAddress).Result.SingleOrDefault();
Assert.IsNull(subscriber);
}
Assert.AreEqual(x.Description, string.Format(SeedDiscrepancy.MissingSeedMessage, "WD"));
}
});
}
}
public async Task<SeedDiscrepancyResolution> Resolve(SeedDiscrepancy discrepancy)
{
if (!discrepancy.IsValid)
{
return SeedDiscrepancyResolution.Failed(discrepancy).WithMessage(SeedDiscrepancy.InvalidDiscrepancyMessage);
}
var result = SeedDiscrepancyResolution.Failed(discrepancy).WithMessage(SeedDiscrepancy.NotImplementedFeatureMessage);
if (discrepancy.IsEngagerDiscrepancy)
{
using (var subscribersCtx = new SubscribersContext())
{
var provider = WD40.Domain.Engagement.Providers.Registry.Instance[discrepancy.Account.Value.ProviderId];
var metadata = await GetMetadataForProviderAsync(provider.SubscriberId);
if (!discrepancy.Subscriber.HasValue)
{
try
{
result.Succeeded = await subscribersCtx.FromStore(metadata.DatabaseName, metadata.TableName).AddSubscriber(discrepancy);
result.WithMessage(SeedDiscrepancy.ResolvedMessage);
}
catch (Exception e)
{
result.WithMessage(e.Message);
}
}
else
{
try
{
result.Succeeded = await subscribersCtx.FromStore(metadata.DatabaseName, metadata.TableName).EnableSubscriber(discrepancy);
result.WithMessage(SeedDiscrepancy.ResolvedMessage);
}
catch (Exception e)
{
result.WithMessage(e.Message);
}
}
}
}
else
{
if (!discrepancy.Account.HasValue)
{
// TODO: Add subscriber to Engager
throw new NotImplementedException(result.Messages);
}
else
{
// TODO: Update account in Engager with active = true
throw new NotImplementedException(result.Messages);
}
}
return result;
}
