public async Task TestGetById_CheckProperties()
{
var facebook = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Facebook.Id,
SocialMediaTypeName = SocialMediaType.Facebook.Value
};
var socialMedia = new SocialMedia
{
SocialMediaId = 1,
SocialMediaType = facebook,
SocialMediaTypeId = facebook.SocialMediaTypeId,
SocialMediaValue = "value"
};
context.SocialMediaTypes.Add(facebook);
context.SocialMedias.Add(socialMedia);
Action <SocialMediaDTO> tester = (dto) =>
{
Assert.AreEqual(facebook.SocialMediaTypeId, dto.SocialMediaTypeId);
Assert.AreEqual(facebook.SocialMediaTypeName, dto.SocialMediaType);
Assert.AreEqual(socialMedia.SocialMediaId, dto.Id);
Assert.AreEqual(socialMedia.SocialMediaValue, dto.Value);
};
var result = service.GetById(socialMedia.SocialMediaId);
var resultAsync = await service.GetByIdAsync(socialMedia.SocialMediaId);
tester(result);
tester(resultAsync);
}
public async Task TestCreate_SocialableEntityDoesNotExist()
{
using (ShimsContext.Create())
{
System.Data.Entity.Fakes.ShimDbContext.AllInstances.SetOf1 <Organization>((c) =>
{
return(context.Organizations);
});
var socialMediaType = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Facebook.Id,
SocialMediaTypeName = SocialMediaType.Facebook.Value
};
var userId = 1;
var id = 10;
var user = new User(userId);
var value = "value";
var socialMediaTypeId = socialMediaType.SocialMediaTypeId;
var socialMediaPresense = new OrganizationSocialMediaPresence(user, socialMediaTypeId, value, id);
context.SocialMediaTypes.Add(socialMediaType);
Func <Task> f = () =>
{
return(service.CreateAsync <Organization>(socialMediaPresense));
};
service.Invoking(x => x.Create <Organization>(socialMediaPresense)).ShouldThrow <ModelNotFoundException>()
.WithMessage(String.Format("The sociable entity with id [{0}] was not found.", id));
f.ShouldThrow <ModelNotFoundException>()
.WithMessage(String.Format("The sociable entity with id [{0}] was not found.", id));
}
}
/// <summary>
/// Check that a social media url is valid
/// </summary>
/// <param name="url">Url to check is valid</param>
/// <param name="type">Social media type to validate against. By default will check that url is valid for any social media type.</param>
/// <returns>Returns true when valid otherwise false</returns>
public static bool IsValidUrl(string url, SocialMediaType type = SocialMediaType.Unknown)
{
if (String.IsNullOrEmpty(url))
{
return(false);
}
if (type == SocialMediaType.Unknown)
{
return(CategorizeUrl(url) != SocialMediaType.Unknown);
}
switch (type)
{
case SocialMediaType.YouTubeVideo: return(IsValidYouTubeUrl(url));
case SocialMediaType.VimeoVideo: return(IsValidVimeoUrl(url));
case SocialMediaType.TwitterProfile: return(IsValidTwitterUrl(url));
case SocialMediaType.LinkedInProfile: return(IsValidLinkedInUrl(url));
case SocialMediaType.FacebookProfile: return(IsValidFacebookUrl(url));
}
throw new NotSupportedException($"Social media type {type} not supported");
}
public async Task TestGet_CheckProperties()
{
var facebook = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Facebook.Id,
SocialMediaTypeName = SocialMediaType.Facebook.Value,
Url = "url"
};
context.SocialMediaTypes.Add(facebook);
Action <PagedQueryResults <SocialMediaTypeDTO> > tester = (results) =>
{
Assert.AreEqual(1, results.Total);
Assert.AreEqual(1, results.Results.Count);
var firstResult = results.Results.First();
Assert.AreEqual(facebook.SocialMediaTypeId, firstResult.Id);
Assert.AreEqual(facebook.SocialMediaTypeName, firstResult.Name);
Assert.AreEqual(facebook.Url, firstResult.Url);
};
var defaultSorter = new ExpressionSorter <SocialMediaTypeDTO>(x => x.Id, SortDirection.Ascending);
var queryOperator = new QueryableOperator <SocialMediaTypeDTO>(0, 10, defaultSorter);
var serviceResults = service.Get(queryOperator);
var serviceResultsAsync = await service.GetAsync(queryOperator);
tester(serviceResults);
tester(serviceResultsAsync);
}
public async Task TestUpdate_CheckProperties()
{
var creator = 1;
var facebookType = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Facebook.Id,
SocialMediaTypeName = SocialMediaType.Facebook.Value
};
var twitter = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Twitter.Id,
SocialMediaTypeName = SocialMediaType.Twitter.Value
};
var oldSocialMediaTypeId = facebookType.SocialMediaTypeId;
var oldValue = "oldValue";
var yesterday = DateTimeOffset.Now.AddDays(-1.0);
var socialMedia = new SocialMedia
{
SocialMediaId = 1
};
context.SetupActions.Add(() =>
{
context.SocialMedias.Add(socialMedia);
context.SocialMediaTypes.Add(facebookType);
context.SocialMediaTypes.Add(twitter);
socialMedia.History.CreatedBy = creator;
socialMedia.History.CreatedOn = yesterday;
socialMedia.History.RevisedBy = creator;
socialMedia.History.RevisedOn = yesterday;
socialMedia.SocialMediaTypeId = facebookType.SocialMediaTypeId;
socialMedia.SocialMediaType = facebookType;
socialMedia.SocialMediaValue = oldValue;
});
var updatorId = 2;
var updator = new User(updatorId);
var updatedInstance = new UpdatedSocialMediaPresence(updator, socialMedia.SocialMediaId, "newValue", twitter.SocialMediaTypeId);
Action tester = () =>
{
Assert.AreEqual(1, context.SocialMedias.Count());
Assert.AreEqual(2, context.SocialMediaTypes.Count());
Assert.AreEqual(updatedInstance.Value, socialMedia.SocialMediaValue);
Assert.AreEqual(updatedInstance.SocialMediaTypeId, socialMedia.SocialMediaTypeId);
Assert.AreEqual(creator, socialMedia.History.CreatedBy);
Assert.AreEqual(yesterday, socialMedia.History.CreatedOn);
DateTimeOffset.Now.Should().BeCloseTo(socialMedia.History.RevisedOn, 2000);
Assert.AreEqual(updatorId, socialMedia.History.RevisedBy);
};
context.Revert();
service.Update(updatedInstance);
tester();
context.Revert();
await service.UpdateAsync(updatedInstance);
tester();
}
public ActionResult DeleteConfirmed(int id)
{
SocialMediaType socialMediaType = db.SocialMediaTypes.Find(id);
db.SocialMediaTypes.Remove(socialMediaType);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "Id,Name")] SocialMediaType socialMediaType)
{
if (ModelState.IsValid)
{
db.Entry(socialMediaType).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(socialMediaType));
}
/// <summary>
/// Creates a new social media presence with the user, type of social media, and value.
/// </summary>
/// <param name="user">The user creating the social media presence.</param>
/// <param name="socialMediaTypeId">The social media type by id.</param>
/// <param name="value">The value.</param>
public SocialMediaPresence(User user, int socialMediaTypeId, string value)
{
Contract.Requires(user != null, "The user must not be null.");
if (SocialMediaType.GetStaticLookup(socialMediaTypeId) == null)
{
throw new UnknownStaticLookupException(string.Format("The social media type with id [{0}] is not known.", socialMediaTypeId));
}
this.SocialMediaTypeId = socialMediaTypeId;
this.Value = value;
this.Create = new Create(user);
}
public ActionResult Create([Bind(Include = "Id,Name")] SocialMediaType socialMediaType)
{
if (ModelState.IsValid)
{
db.SocialMediaTypes.Add(socialMediaType);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(socialMediaType));
}
// GET: SocialMediaTypes/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SocialMediaType socialMediaType = db.SocialMediaTypes.Find(id);
if (socialMediaType == null)
{
return(HttpNotFound());
}
return(View(socialMediaType));
}
private SocialMediaType AddandGetTestSocialMediaType()
{
var socialMediaTypeType = new SocialMediaType
{
Description = "TestType"
};
using (var socialMediaTypeRepo = new SocialMediaTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
socialMediaTypeRepo.Add(socialMediaTypeType);
socialMediaTypeRepo.SaveChanges();
}
return(socialMediaTypeType);
}
public void GetById_CorrectDataGot_ActualEqualsExpectedData()
{
var expectedSocialMediaType = new SocialMediaType
{
ID = 1,
Description = "Youtube"
};
SocialMediaType actualSocialMediaType;
using (var socialMediaTypeRepo = new SocialMediaTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
actualSocialMediaType = socialMediaTypeRepo.GetById(expectedSocialMediaType.ID);
}
AssertSocialMediaTypesEqual(expectedSocialMediaType, actualSocialMediaType);
}
public void Add_WasSocialMediaTypeAdded_ActualEqualsExpectedData()
{
var expectedSocialMediaType = new SocialMediaType
{
Description = "NewType"
};
SocialMediaType actualSocialMediaType;
using (var socialMediaTypeRepo = new SocialMediaTypeRepository(new brothershipEntities(ConnectionStrings.TEST_CONNECTION_STRING_NAME)))
{
socialMediaTypeRepo.Add(expectedSocialMediaType);
socialMediaTypeRepo.SaveChanges();
actualSocialMediaType = socialMediaTypeRepo.GetById(expectedSocialMediaType.ID);
}
AssertSocialMediaTypesEqual(expectedSocialMediaType, actualSocialMediaType);
}
/// <summary>
/// Returns social media id from url
/// </summary>
/// <param name="url">Url to parse for id</param>
/// <param name="type">Social media type to target</param>
/// <returns>If found returns social media id otherwise returns empty string</returns>
public static string GetId(string url, SocialMediaType type)
{
if (String.IsNullOrEmpty(url))
{
return(String.Empty);
}
switch (type)
{
case SocialMediaType.YouTubeVideo: return(IsValidYouTubeUrl(url) ? GetYouTubeId(url) : String.Empty);
case SocialMediaType.VimeoVideo: return(IsValidVimeoUrl(url) ? GetVimeoId(url) : String.Empty);
case SocialMediaType.TwitterProfile: return(IsValidTwitterUrl(url) ? GetTwitterId(url) : String.Empty);
case SocialMediaType.FacebookProfile: return(IsValidFacebookUrl(url) ? GetFacebookId(url) : String.Empty);
}
throw new NotSupportedException($"Social media type {type} not supported");
}
internal static async Task <IEnumerable <SubscriptionModel> > GetAllCommunitiesAsync(this RealmSettings realmSettings, SocialMediaType socialMediaType)
{
var user = await realmSettings.GetUser();
var realmUrl = new Uri($"realms://{realmSettings.RealmServerUrl}/{realmSettings.RealmName}");
var realm = await user.GetRealm(realmUrl);
return(SubscriptionsHelper.GetDefaultCommunitySubscriptionsByRealm(realm)
.Where(x => x.Type == socialMediaType));
}
public DataSourceTypeAttribute(SocialMediaType mediaType)
{
MediaType = mediaType;
}
private void AssertSocialMediaTypesEqual(SocialMediaType expected, SocialMediaType actual)
{
Assert.AreEqual(expected.ID, actual.ID);
Assert.AreEqual(expected.Description, actual.Description);
}
public void Add(SocialMediaType entity)
{
entity.ID = GenerateSocialMediaTypeId();
_fakeSocialMediaTypes.Add(entity);
}
public void Delete(SocialMediaType entity)
{
var socialMediaType = _fakeSocialMediaTypes.Single(p => p.ID == entity.ID);
_fakeSocialMediaTypes.Remove(socialMediaType);
}
public async Task TestCreate_CheckProperties()
{
using (ShimsContext.Create())
{
System.Data.Entity.Fakes.ShimDbContext.AllInstances.SetOf1 <Organization>((c) =>
{
return(context.Organizations);
});
var organization = new Organization
{
OrganizationId = 1
};
var socialMediaType = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Facebook.Id,
SocialMediaTypeName = SocialMediaType.Facebook.Value
};
var userId = 1;
var user = new User(userId);
var value = "value";
var socialMediaTypeId = socialMediaType.SocialMediaTypeId;
var socialMediaPresense = new OrganizationSocialMediaPresence(user, socialMediaTypeId, value, organization.GetId());
context.SetupActions.Add(() =>
{
organization.SocialMedias.Clear();
context.SocialMediaTypes.Add(socialMediaType);
context.Organizations.Add(organization);
});
Action beforeServiceTester = () =>
{
Assert.AreEqual(0, context.SocialMedias.Count());
Assert.AreEqual(0, context.Organizations.First().SocialMedias.Count);
};
Action <SocialMedia> tester = (serviceResult) =>
{
Assert.IsNotNull(serviceResult);
Assert.AreEqual(1, organization.SocialMedias.Count);
var firstSocialMedia = context.Organizations.First().SocialMedias.First();
Assert.IsTrue(Object.ReferenceEquals(serviceResult, firstSocialMedia));
Assert.AreEqual(socialMediaType.SocialMediaTypeId, serviceResult.SocialMediaTypeId);
Assert.AreEqual(value, serviceResult.SocialMediaValue);
Assert.AreEqual(userId, serviceResult.History.CreatedBy);
Assert.AreEqual(userId, serviceResult.History.RevisedBy);
DateTimeOffset.Now.Should().BeCloseTo(serviceResult.History.CreatedOn, 2000);
DateTimeOffset.Now.Should().BeCloseTo(serviceResult.History.RevisedOn, 2000);
};
context.Revert();
beforeServiceTester();
var socialMedia = service.Create <Organization>(socialMediaPresense);
tester(socialMedia);
context.Revert();
beforeServiceTester();
socialMedia = await service.CreateAsync <Organization>(socialMediaPresense);
tester(socialMedia);
}
}
public async Task TestUpdate_SocialMedia_SevisNotLocked()
{
var personId = 1;
var participantId = 1;
var creator = 1;
var updatorId = 2;
var updator = new User(updatorId);
var facebookType = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Facebook.Id,
SocialMediaTypeName = SocialMediaType.Facebook.Value
};
var twitter = new SocialMediaType
{
SocialMediaTypeId = SocialMediaType.Twitter.Id,
SocialMediaTypeName = SocialMediaType.Twitter.Value
};
var oldSocialMediaTypeId = facebookType.SocialMediaTypeId;
var oldValue = "oldValue";
var yesterday = DateTimeOffset.Now.AddDays(-1.0);
Person person = new Person
{
PersonId = personId
};
var socialMedia = new SocialMedia
{
SocialMediaId = 1,
Person = person,
PersonId = person.PersonId
};
var participant = new Participant
{
ParticipantId = participantId,
PersonId = person.PersonId,
ParticipantStatusId = ParticipantStatus.Active.Id
};
List <Participant> participants = new List <Participant>();
participants.Add(participant);
person.Participations = participants;
var participantPerson = new ParticipantPerson
{
Participant = participant,
ParticipantId = participant.ParticipantId,
};
participant.ParticipantPerson = participantPerson;
var queuedToSubmitStatus = new SevisCommStatus
{
SevisCommStatusId = SevisCommStatus.InformationRequired.Id,
SevisCommStatusName = SevisCommStatus.InformationRequired.Value
};
var commStatus = new ParticipantPersonSevisCommStatus
{
AddedOn = DateTimeOffset.UtcNow,
BatchId = "batch id",
Id = 501,
ParticipantId = participant.ParticipantId,
ParticipantPerson = participantPerson,
SevisCommStatus = queuedToSubmitStatus,
SevisCommStatusId = queuedToSubmitStatus.SevisCommStatusId,
};
participantPerson.ParticipantPersonSevisCommStatuses.Add(commStatus);
person.SocialMedias.Add(socialMedia);
context.SetupActions.Add(() =>
{
context.SocialMedias.Add(socialMedia);
context.SocialMediaTypes.Add(facebookType);
context.SocialMediaTypes.Add(twitter);
context.Participants.Add(participant);
context.ParticipantPersons.Add(participantPerson);
context.ParticipantPersonSevisCommStatuses.Add(commStatus);
socialMedia.History.CreatedBy = creator;
socialMedia.History.CreatedOn = yesterday;
socialMedia.History.RevisedBy = creator;
socialMedia.History.RevisedOn = yesterday;
socialMedia.SocialMediaTypeId = facebookType.SocialMediaTypeId;
socialMedia.SocialMediaType = facebookType;
socialMedia.SocialMediaValue = oldValue;
});
context.Revert();
var updatedSocialMedia = new UpdatedSocialMediaPresence(updator, socialMedia.SocialMediaId, "newValue", twitter.SocialMediaTypeId);
var message = String.Format("An update was attempted on participant with id [{0}] but should have failed validation.",
participant.ParticipantId);
Action a = () => service.Update(updatedSocialMedia);
Func <Task> f = () => service.UpdateAsync(updatedSocialMedia);
a.ShouldNotThrow <EcaBusinessException>();
f.ShouldNotThrow <EcaBusinessException>();
}
public void Update(SocialMediaType entity)
{
var entityIndex = _fakeSocialMediaTypes.IndexOf(entity);
_fakeSocialMediaTypes[entityIndex] = entity;
}
