public SingleResponse<UserFeed> LookupUserFeed(UserFeed userFeed)
{
if (userFeed.Feed == null || string.IsNullOrEmpty(userFeed.Feed.Url))
{
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.None, "");
}
var factory = new HttpFeedFactory();
try
{
var rssFeed = factory.CreateFeed(new Uri(userFeed.Feed.Url));
return ResponseBuilder.BuildSingleResponse(new UserFeed
{
Name = rssFeed.Title,
Feed = userFeed.Feed
}, ErrorLevel.None);
}
catch (NotSupportedException)
{
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.Error, "URL type is not supported");
}
catch (InvalidFeedXmlException ex)
{
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.Critical,
string.Format("Failed to retrieve feed at URL: {0}", userFeed.Feed.Url), ex);
}
}
public void AddUserFeed()
{
//Arrange
IFeedManager feedManager = new FeedManager(_database);
//Act
const string url = "http://test.url.fake";
var userFeed = new UserFeed
{
Feed = new Feed
{
Url = url
}
};
var response = feedManager.AddUserFeed(userFeed);
//Assert
Assert.AreEqual(ErrorLevel.None, response.Status.ErrorLevel, response.Status.ErrorMessage);
Assert.IsNotNull(response.Data);
Assert.IsNotNullOrEmpty(response.Data.Id);
Assert.IsNotNull(response.Data.Feed);
Assert.IsNotNullOrEmpty(response.Data.Feed.Id);
var getFeedResponse = feedManager.GetUserFeedsByUrl(url);
Assert.AreEqual(ErrorLevel.None, getFeedResponse.Status.ErrorLevel, getFeedResponse.Status.ErrorMessage);
Assert.IsNotNull(getFeedResponse.Data);
Assert.IsNotEmpty(getFeedResponse.Data);
var feedResponse = getFeedResponse.Data.First();
Assert.IsNotNull(feedResponse);
Assert.AreEqual(url, feedResponse.Feed.Url);
}
public void LookupUserFeed_CatchUriException()
{
//Arrange
IRssManager rssManager = new RssManager();
//Act
var userFeed = new UserFeed
{
Feed = new Feed
{
Url = ""
}
};
var response = rssManager.LookupUserFeed(userFeed);
//Assert
Assert.AreEqual(ErrorLevel.None, response.Status.ErrorLevel, response.Status.ErrorMessage);
}
public void LookupUserFeed()
{
//Arrange
IRssManager rssManager = new RssManager();
//Act
const string url = "http://ericlippert.com/feed/";
var userFeed = new UserFeed
{
Feed = new Feed
{
Url = url
}
};
SingleResponse<UserFeed> response = rssManager.LookupUserFeed(userFeed);
//Assert
Assert.AreEqual(ErrorLevel.None, response.Status.ErrorLevel, response.Status.ErrorMessage);
Assert.IsNotNullOrEmpty(response.Data.Name);
}
public SingleResponse<UserFeed> AddUserFeed(UserFeed userFeed)
{
try
{
if (userFeed == null)
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.Error, "userFeed is required");
if (userFeed.Feed == null)
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.Error, "userFeed.Feed is required");
var existingFeed = _database.Query<RavenFeed>()
.FirstOrDefault(f => f.Url == userFeed.Feed.Url);
string existingFeedId;
if (existingFeed == null)
{
var ravenFeed = Mapper.Map<RavenFeed>(userFeed.Feed);
existingFeedId = _database.Store(ravenFeed);
}
else
{
existingFeedId = existingFeed.Id;
}
var ravenUserFeed = Mapper.Map<RavenUserFeed>(userFeed);
ravenUserFeed.RavenFeedId = existingFeedId;
userFeed.Id = _database.Store(ravenUserFeed);
userFeed.Feed.Id = existingFeedId;
return new SingleResponse<UserFeed>
{
Data = userFeed,
Status = new Status
{
ErrorLevel = ErrorLevel.None
}
};
}
catch (Exception ex)
{
return ResponseBuilder.BuildSingleResponse(userFeed, ErrorLevel.Critical,
string.Format("Fatal error adding feed: {0}", ex), ex);
}
}
public void GetUserFeedUnreadCount_FeedRequired()
{
//Arrange
var feedManager = TestRegistry.GetKernel().Get<IFeedManager>();
//Act
var userFeed = new UserFeed
{
Id = "UserFeeds/1"
};
var response = feedManager.GetUserFeedUnreadCount(userFeed);
//Assert
Assert.IsNotNull(response);
Assert.AreEqual(ErrorLevel.Error, response.Status.ErrorLevel);
Assert.IsTrue(response.Status.ErrorMessage.Contains("Feed cannot be null"),
"Error message should contain \"Feed cannot be null\": " + response.Status.ErrorMessage);
}
public void GetUserFeedUnreadCount()
{
//Arrange
var feedManager = TestRegistry.GetKernel().Get<IFeedManager>();
//Act
var userFeed = new UserFeed
{
Id = "UserFeeds/1",
RavenUserId = "ravenuser/1",
Feed = new Feed
{
Id = "ravenfeed/1"
}
};
var response = feedManager.GetUserFeedUnreadCount(userFeed);
//Assert
Assert.IsNotNull(response);
Assert.AreEqual(ErrorLevel.None, response.Status.ErrorLevel, response.Status.ErrorMessage);
Assert.Greater(response.Data, 0);
}
public void GetUserFeeds_AfterAdd()
{
//Arrange
IFeedManager feedManager = new FeedManager(_database);
//Act
const string url = "http://new.feed.url";
var userFeed = new UserFeed
{
Feed = new Feed
{
Url = url
},
RavenUserId = "ravenuser/2"
};
var response = feedManager.AddUserFeed(userFeed);
//Assert
Assert.AreEqual(ErrorLevel.None, response.Status.ErrorLevel, response.Status.ErrorMessage);
//TODO there has to be a better way to deal with eventual consistency here
Thread.Sleep(500);
var getFeedsResponse = feedManager.GetUserFeeds(new User
{
Id = "ravenuser/2"
});
Assert.AreEqual(ErrorLevel.None, getFeedsResponse.Status.ErrorLevel, getFeedsResponse.Status.ErrorMessage);
Assert.IsNotNull(getFeedsResponse.Data);
Assert.IsNotEmpty(getFeedsResponse.Data);
var newFeed = getFeedsResponse.Data.FirstOrDefault(f => f.Feed.Url == url);
Assert.IsNotNull(newFeed);
Assert.AreEqual(newFeed.Feed.Url, url);
Assert.AreEqual("ravenuser/2", newFeed.RavenUserId);
}
public void GetUserFeedItems_UserIdRequired()
{
//Arrange
//TODO use servicelocator for this
IFeedManager feedManager = new FeedManager(_database);
//Act
var userFeed = new UserFeed();
var response = feedManager.GetUserFeedItems(userFeed);
//Assert
Assert.IsNotNull(response);
Assert.IsNotNull(response.Status);
Assert.AreEqual(ErrorLevel.Error, response.Status.ErrorLevel, "User Id should be required");
}
public void GetUserFeedItems()
{
//Arrange
//TODO use servicelocator for this
IFeedManager feedManager = new FeedManager(_database);
//Act
var userFeed = new UserFeed
{
RavenUserId = "ravenuser/1",
Feed = new Feed
{
Id = "ravenfeed/1"
}
};
var response = feedManager.GetUserFeedItems(userFeed);
//Assert
Assert.IsNotNull(response);
Assert.IsNotNull(response.Status);
Assert.AreEqual(ErrorLevel.None, response.Status.ErrorLevel, response.Status.ErrorMessage);
Assert.IsNotNull(response.Data);
Assert.Greater(response.Data.Count(), 0);
Assert.IsNotNull(response.Data.First().Id);
}
public void AddUserFeed_FeedIsRequired()
{
//Arrange
IFeedManager feedManager = new FeedManager(_database);
//Act
var userFeed = new UserFeed();
var response = feedManager.AddUserFeed(userFeed);
//Assert
Assert.AreEqual(ErrorLevel.Error, response.Status.ErrorLevel);
Assert.AreEqual("userFeed.Feed is required", response.Status.ErrorMessage);
}
public SingleResponse<int> GetUserFeedUnreadCount(UserFeed userFeed)
{
try
{
if (userFeed == null)
{
return ResponseBuilder.BuildSingleResponse<int>(ErrorLevel.Error, "User feed is required");
}
if (userFeed.Feed == null)
{
return ResponseBuilder.BuildSingleResponse<int>(ErrorLevel.Error, "userFeed.Feed cannot be null");
}
var feedId = userFeed.Feed.Id;
var count = _database.Query<UserFeedItem>()
.Count(uf => uf.FeedId == feedId &&
uf.RavenUserId == userFeed.RavenUserId &&
uf.IsUnread);
return ResponseBuilder.BuildSingleResponse(count, ErrorLevel.None);
}
catch (Exception ex)
{
return ResponseBuilder.BuildSingleResponse<int>(ErrorLevel.Critical,
string.Format("Fatal error getting user feed unread count: {0}", ex), ex);
}
}
public void UpdateFeedUnreadCount(string username, UserFeed userFeed)
{
Clients.Group(username).UpdateFeedUnreadCount(userFeed);
}
public void LookupUserFeed_NotSupportedUrl()
{
//Arrange
IRssManager rssManager = new RssManager();
//Act
var userFeed = new UserFeed
{
Feed = new Feed
{
Url = "magnet:?xt=urn:btih:d784a1cdfe1f3b75de71f59be0a75bf68a00806c&dn=%5BMetal%5"
}
};
var response = rssManager.LookupUserFeed(userFeed);
//Assert
Assert.AreEqual(ErrorLevel.Error, response.Status.ErrorLevel, "Should have gotten an error: " + response.Status.ErrorMessage);
}
public SingleResponse<UserFeed> UpdateUserFeed(UserFeed userFeed)
{
try
{
if (userFeed == null)
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.Error, "userFeed is required");
if (userFeed.Feed == null)
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.Error, "userFeed.Feed is required");
if (userFeed.Feed.Id == null)
return ResponseBuilder.BuildSingleResponse<UserFeed>(ErrorLevel.Error, "userFeed.Feed.Id is required");
var existingFeed = _database.Load<RavenFeed>(userFeed.Feed.Id);
if (existingFeed == null)
{
return ResponseBuilder.BuildSingleResponse(userFeed, ErrorLevel.Error, string.Format("Feed not found with id {0}", userFeed.Feed.Id));
}
var updateFeedResponse = UpdateFeed(userFeed.Feed);
if (updateFeedResponse.Status.ErrorLevel > ErrorLevel.None)
{
return ResponseBuilder.BuildSingleResponse(userFeed, updateFeedResponse.Status.ErrorLevel, updateFeedResponse.Status.ErrorMessage);
}
var ravenUserFeed = Mapper.Map<RavenUserFeed>(userFeed);
ravenUserFeed.RavenFeedId = existingFeed.Id;
_database.Store(ravenUserFeed);
return ResponseBuilder.BuildSingleResponse(userFeed, ErrorLevel.None);
}
catch (Exception ex)
{
return ResponseBuilder.BuildSingleResponse(userFeed, ErrorLevel.Critical,
string.Format("Fatal error updating user feed: {0}", ex), ex);
}
}
public void UpdateUserFeedTest()
{
//Arrange
IFeedManager feedManager = new FeedManager(_database);
//Act
var unreadCount = new Random().Next(1000);
const string url = "http://test.url.fake";
var userFeed = new UserFeed
{
Id = "ravenuserfeed/1",
Category = "updated category",
Name = "updated name",
UnreadCount = unreadCount,
Feed = new Feed
{
Id = "ravenfeed/1",
Url = url
},
RavenUserId = "ravenuser/1"
};
var response = feedManager.UpdateUserFeed(userFeed);
//Assert
Assert.AreEqual(ErrorLevel.None, response.Status.ErrorLevel, response.Status.ErrorMessage);
var getFeedResponse = feedManager.GetUserFeedByUserIdAndUrl(new User {Id = "ravenuser/1"}, url);
Assert.IsNotNull(getFeedResponse);
Assert.AreEqual(ErrorLevel.None, getFeedResponse.Status.ErrorLevel, getFeedResponse.Status.ErrorMessage);
Assert.IsNotNull(getFeedResponse.Data);
Assert.IsNotNull(getFeedResponse.Data.Feed);
Assert.AreEqual(url, getFeedResponse.Data.Feed.Url);
Assert.AreEqual(unreadCount, getFeedResponse.Data.UnreadCount);
Assert.AreEqual("updated category", getFeedResponse.Data.Category);
Assert.AreEqual("updated name", getFeedResponse.Data.Name);
}
public CollectionResponse<FeedItem> GetFeedItems(UserFeed userFeed)
{
if (string.IsNullOrEmpty(Context.User.Identity.Name))
{
return ResponseBuilder.BuildCollectionResponse<FeedItem>(ErrorLevel.Error, "Please log in to view feed items");
}
//TODO use client connection for this
Groups.Add(Context.ConnectionId, Context.User.Identity.Name);
var userQuery = new User
{
Username = Context.User.Identity.Name
};
var userResponse = _authentication.GetUserByUsername(userQuery);
if (userResponse.Status.ErrorLevel > ErrorLevel.Warning || userResponse.Data == null)
{
return ResponseBuilder.BuildCollectionResponse<FeedItem>(userResponse.Status.ErrorLevel,
string.Format("Unable to retrieve feed items for user \"{0}\": {1}", userQuery.Username, userResponse.Status.ErrorMessage));
}
var user = userResponse.Data;
if (user.Id != userFeed.RavenUserId)
{
return ResponseBuilder.BuildCollectionResponse<FeedItem>(ErrorLevel.Error, "Please log in to view feed items");
}
return _feedManager.GetUserFeedItems(userFeed);
}
public CollectionResponse<FeedItem> GetUserFeedItems(UserFeed userFeed)
{
try
{
if (userFeed == null)
{
return ResponseBuilder.BuildCollectionResponse<FeedItem>(ErrorLevel.Error, "User feed is required");
}
if (string.IsNullOrEmpty(userFeed.RavenUserId))
{
return ResponseBuilder.BuildCollectionResponse<FeedItem>(ErrorLevel.Error, "User Id is required");
}
if (userFeed.Feed == null || string.IsNullOrEmpty(userFeed.Feed.Id))
{
return ResponseBuilder.BuildCollectionResponse<FeedItem>(ErrorLevel.Error, "Feed is required");
}
var feedId = userFeed.Feed.Id;
//TODO need to find another way to query this
Expression<Func<UserFeedItem, bool>> expression = ufi => ufi.RavenUserId == userFeed.RavenUserId && ufi.FeedId == feedId;
var userFeedItems = _database.Query<UserFeedItem>()
.Where(expression)
.ToList();
var feedItems = new List<FeedItem>();
foreach (var userFeedItem in userFeedItems)
{
FeedItem feedItem = _database.Load<FeedItem>(userFeedItem.FeedItemId);
if (feedItem != null)
{
feedItems.Add(feedItem);
}
}
return ResponseBuilder.BuildCollectionResponse(feedItems, ErrorLevel.None);
}
catch (Exception ex)
{
return ResponseBuilder.BuildCollectionResponse<FeedItem>(ErrorLevel.Critical,
string.Format("Fatal error getting feed items: {0}", ex), ex);
}
}
