public void EditPostAction_ValidPlayerViewModelWithValidationException_PlayerViewModelIsReturned()
{
// Arrange
var testData = MakeTestPlayerViewModel();
SetupEditThrowsValidationException();
var sut = BuildSUT();
// Act
var result = TestExtensions.GetModel <PlayerViewModel>(sut.Edit(testData));
// Assert
VerifyEdit(Times.Once());
Assert.IsNotNull(result, ASSERT_FAIL_VIEW_MODEL_MESSAGE);
}
public void WhenValueIsNull_MaximumLengthValidator_ExpectJsConverterValidatorMessageAreNullAndEqual()
{
var seedData = new SeedData
{
//RuleFor(rf => rf.MaximumLengthValidatorProp).MaximumLength(6);
MaximumLengthValidatorProp = null
};
var validationRules = new SeedDataValidator();
var actual = TestExtensions.GetActualErrors(seedData, validationRules).FirstOrDefault();
var expected = TestExtensions.GetExpectErrorMessages(seedData, validationRules).FirstOrDefault();
Assert.Equal(expected, actual);
}
public void TournamentResults_TournamentResultsRequested_TournamentResultsReturned()
{
// Arrange
var testTournamentResults = new GameServiceTestFixture().TestGameResults().Build();
var expected = new TournamentResultsViewModelBuilder().Build();
SetupGameResultsGetTournamentResults(TOURNAMENT_ID, testTournamentResults);
var sut = BuildSUT();
// Act
var actual = TestExtensions.GetModel <TournamentResultsViewModel>(sut.TournamentResults(TOURNAMENT_ID, TOURNAMENT_NAME));
// Assert
TestHelper.AreEqual(expected, actual, new TournamentResultsViewModelComparer());
}
public void Index_GetAllContributors_AllContributorsAreReturned()
{
// Arrange
var testData = MakeTestContributorTeams();
var expected = MakeTestContributorTeamViewModels(testData);
SetupGetAll(testData);
var sut = BuildSUT();
// Act
var actual = TestExtensions.GetModel <IEnumerable <ContributorsTeamViewModel> >(sut.Index()).ToList();
// Assert
CollectionAssert.AreEqual(expected, actual, new ContributorTeamViewModelComparer());
}
public void UserDetails_ExistingUser_UserViewModelIsReturned()
{
// Arrange
var user = CreateUser();
MockUserServiceGetUserDetails(USER_ID, user);
var sut = BuildSUT();
var expected = CreateUserViewModel();
// Act
var actual = TestExtensions.GetModel <UserViewModel>(sut.UserDetails(USER_ID));
// Assert
TestHelper.AreEqual <UserViewModel>(expected, actual, new Comparers.UserViewModelComparer());
}
public void BinaryExpressionTest(object left, object right, object result)
{
var leftExpression = new ExpressionMock(() => left);
var rightExpr = new ExpressionMock(() => right);
var @operator = new OperatorMock(() => result);
var expression = new Core.Cells.Expressions.BinaryExpression(leftExpression, @operator, rightExpr);
var processor = TestExtensions.CreateProcessor();
Assert.AreEqual(result, expression.Evaluate(processor));
Assert.AreEqual(processor, leftExpression.Processor, "Left expression");
Assert.AreEqual(processor, rightExpr.Processor, "Right expression");
Assert.AreEqual(left, @operator.Left, "Left value");
Assert.AreEqual(right, @operator.Right, "Right value");
}
public void EditGetAction_ExistingPlayer_PlayerViewModelIsReturned()
{
// Arrange
var testData = MakeTestPlayer(TEST_PLAYER_ID);
var expected = MakeTestPlayerViewModel(TEST_PLAYER_ID);
SetupGet(TEST_PLAYER_ID, testData);
var sut = BuildSUT();
// Act
var actual = TestExtensions.GetModel <PlayerViewModel>(sut.Edit(TEST_PLAYER_ID));
// Assert
TestHelper.AreEqual(expected, actual, new PlayerViewModelComparer());
}
public void WhenValueIsNull_NotEmptyValidatorMessage_ExpectJsConverterValidatorMessageAreEqual()
{
var seedData = new SeedData
{
//RuleFor(rf => rf.NotNullValidatorProp).NotNull();
NotEmptyValidatorProp = null
};
var validationRules = new SeedDataValidator();
var actual = TestExtensions.GetActualErrors(seedData, validationRules).FirstOrDefault();
var expected = TestExtensions.GetExpectErrorMessages(seedData, validationRules).FirstOrDefault();
Assert.Equal(expected, actual);
}
public async Task ProblemJson_400_ModelValidation_Test()
{
//Arrange
var concert = new User
{
UserId = Guid.NewGuid()
};
var request = TestExtensions.GetJsonRequest(concert, "POST", "/core/v1/users");
//Act
var response = await fixture._httpClient.SendAsync(request);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
response.Content.Headers.ContentLength.Should().BeGreaterThan(0);
response.ShouldBeProblemJson();
}
internal StorageConnectionString GetConnectionString(
SharedAccessSignatureCredentials credentials = default,
bool includeEndpoint = true,
bool includeTable = false)
{
credentials ??= GetAccountSasCredentials();
if (!includeEndpoint)
{
return(TestExtensions.CreateStorageConnectionString(
credentials,
TestConfigDefault.AccountName));
}
(Uri, Uri)blobUri = StorageConnectionString.ConstructBlobEndpoint(
Constants.Https,
TestConfigDefault.AccountName,
public void WhenCreditCardNumberIsCorrect_CreditCardValidator_ExpectJsConverterValidatorMessageIsNullAndMessagesAreEqual()
{
var seedData = new SeedData
{
//RuleFor(rf => rf.CreditCardValidatorProp).CreditCard();
CreditCardValidatorProp = "5105105105105100"
};
var validators = new SeedDataValidator();
var actual = TestExtensions.GetActualErrors(seedData, validators).FirstOrDefault();
var expected = TestExtensions.GetExpectErrorMessages(seedData, validators).FirstOrDefault();
Assert.Null(actual);
Assert.Equal(expected, actual);
}
public void CloseCreatedProject_NewProjectWillExistInClosedProjectsAndUnexistsInOpenProjects_TrueReturned()
{
var generatedProjectName = TestExtensions.GetRandomString(length: 6);
var projectForm = new ProjectFormInfo()
{
Name = generatedProjectName,
Description = "this project needs to be moved to closed projects",
Visibility = Visibility.Public,
};
ProjectsSteps.CreateNewProject(projectForm);
ProjectsSteps.CloseProject(generatedProjectName);
var actual = ProjectsSteps.ContainsClosedProject(generatedProjectName) && !ProjectsSteps.ContainsOpenProject(generatedProjectName);
Assert.True(actual);
}
public void UserDetails_ExistingUser_UserViewModelIsReturned()
{
// Arrange
var user = CreateUser();
SetupGetUserDetails(EXISTING_ID, user);
var sut = BuildSUT();
var expected = CreateUserViewModel();
// Act
var actual = TestExtensions.GetModel <UserViewModel>(sut.UserDetails(EXISTING_ID));
// Assert
Assert.Equal <UserViewModel>(expected, actual, new UserViewModelComparer());
}
public void Details_ExistingPlayer_PlayerViewModelIsReturned()
{
// Arrange
var testData = MakeTestPlayer(TEST_PLAYER_ID);
var expected = MakeTestPlayerViewModel(TEST_PLAYER_ID);
SetupGet(TEST_PLAYER_ID, testData);
var sut = BuildSUT();
// Act
var actual = TestExtensions.GetModel <PlayerRefererViewModel>(sut.Details(TEST_PLAYER_ID));
// Assert
Assert.Equal <PlayerViewModel>(expected, actual.Model, new PlayerViewModelComparer());
VerifyGetAllowedOperation(_allowedOperationDetails, Times.Once());
}
public void Scripting_Distribute_With_Spacing()
{
var client = this.GetScriptingClient();
var pagesize = new VA.Geometry.Size(4, 4);
client.Document.NewDocument();
client.Page.NewPage(pagesize, false);
var size1 = new VA.Geometry.Size(0.5, 0.5);
var size2 = new VA.Geometry.Size(1.0, 1.0);
var size3 = new VA.Geometry.Size(1.5, 1.5);
var r1 = new VA.Geometry.Rectangle(new VA.Geometry.Point(1, 1), size1);
var r2 = new VA.Geometry.Rectangle(new VA.Geometry.Point(2, 2), size2);
var r3 = new VA.Geometry.Rectangle(new VA.Geometry.Point(4, 4), size3);
var s1 = client.Draw.DrawRectangle(r1);
var s2 = client.Draw.DrawRectangle(r2);
var s3 = client.Draw.DrawRectangle(r3);
client.Selection.SelectNone();
client.Selection.SelectShapesById(s1);
client.Selection.SelectShapesById(s2);
client.Selection.SelectShapesById(s3);
var targetshapes = new VisioScripting.TargetShapes();
client.Distribute.DistributeSelectionOnAxis(targetshapes, VisioScripting.Models.Axis.XAxis, 0.25);
client.Distribute.DistributeSelectionOnAxis(targetshapes, VisioScripting.Models.Axis.YAxis, 1.0);
var shapes = new[] { s1, s2, s3 };
var shapeids = shapes.Select(s => (int)s.ID16).ToList();
var out_xfrms = VisioAutomation.Shapes.ShapeXFormCells.GetCells(client.Page.GetActivePage(), shapeids, VA.ShapeSheet.CellValueType.Result);
var out_positions = out_xfrms.Select(xfrm => TestExtensions.ToPoint(xfrm.PinX.Value, xfrm.PinY.Value)).ToArray();
Assert.AreEqual(1.25, out_positions[0].X);
Assert.AreEqual(1.25, out_positions[0].Y);
Assert.AreEqual(2.25, out_positions[1].X);
Assert.AreEqual(3.00, out_positions[1].Y);
Assert.AreEqual(3.75, out_positions[2].X);
Assert.AreEqual(5.25, out_positions[2].Y);
var targetdoc = new VisioScripting.TargetDocument();
client.Document.CloseDocument(targetdoc, true);
}
public void WhenValueLengthGreaterThan6_MaximumLengthValidator_ExpectJsConverterValidatorMessageEqual()
{
var seedData = new SeedData
{
//RuleFor(rf => rf.MaximumLengthValidatorProp).MaximumLength(6);
MaximumLengthValidatorProp = "sample_sample"
};
var validationRules = new SeedDataValidator();
var actual = TestExtensions.GetActualErrors(seedData, validationRules).FirstOrDefault();
var expected = TestExtensions.GetExpectErrorMessages(seedData, validationRules).FirstOrDefault();
Assert.NotNull(actual);
Assert.Equal(expected, actual);
}
public async Task ProblemJson_405_MethodNotAllowed_Test()
{
//Arrange
var concert = new Concert
{
ConcertId = Guid.NewGuid(),
Name = "Best Kept Secret Festival 2019"
};
var request = TestExtensions.GetJsonRequest(concert, "PUT", "/core/v1/concerts");
//Act
var response = await fixture._httpClient.SendAsync(request);
//Assert
response.StatusCode.Should().Be(HttpStatusCode.MethodNotAllowed);
response.Content.Headers.ContentLength.Should().BeGreaterThan(0);
response.ShouldBeProblemJson();
}
public async Task SignRequest_WithValidRequest_WillSignProperly(string method)
{
// Arrange
var testData = await TestData.For(method);
var expectedMAuthHeader = $"MWS {TestExtensions.ClientUuid.ToHyphenString()}:{testData.Payload}";
// Act
var actual = await testData.Request.Sign(TestExtensions.ClientOptions(testData.SignedTime));
// Assert
Assert.Equal(expectedMAuthHeader, actual.Headers.GetFirstValueOrDefault <string>(Constants.MAuthHeaderKey));
Assert.Equal(
testData.SignedTime.ToUnixTimeSeconds(),
actual.Headers.GetFirstValueOrDefault <long>(Constants.MAuthTimeHeaderKey)
);
}
public async Task CheckSuccessfulCreatingNewRepository_NewRepositoryShouldBeCreated_TrueReturned()
{
var newRepository = new RepositoryRequestBody()
{
Name = TestExtensions.GetRandomString(5),
Description = "that repository was created with rest api service",
AutoInit = true,
IsPrivate = false,
GitIgnoreTemplate = "VisualStudio",
};
var repository = await RepositoryController.AddRepositoryAsync(newRepository);
var repositories = (await RepositoryController.GetRepositoriesAsync()).ToList();
Assert.Contains(repository, repositories);
}
public static async Task SignRequest_WithValidRequest_WillSignProperly(string method)
{
// Arrange
var testData = await method.FromResource();
var expectedMAuthHeader = testData.MAuthHeader;
// Act
var actual = await testData.ToHttpRequestMessage().Sign(TestExtensions.ClientOptions(testData.SignedTime));
// Assert
Assert.Equal(expectedMAuthHeader, actual.Headers.GetFirstValueOrDefault <string>(Constants.MAuthHeaderKey));
Assert.Equal(
testData.SignedTime.ToUnixTimeSeconds(),
actual.Headers.GetFirstValueOrDefault <long>(Constants.MAuthTimeHeaderKey)
);
}
public void EditPostAction_InvalidGameResultViewModel_GameResultViewModelIsReturned()
{
// Arrange
var testData = CreateResultViewModel();
var expectedResult = CreateExpectedResult();
var sut = BuildSUT();
sut.ModelState.AddModelError(string.Empty, string.Empty);
// Act
var result = TestExtensions.GetModel <GameResultViewModel>(sut.Edit(testData));
// Assert
VerifyEditGameResult(expectedResult, Times.Never());
Assert.IsNotNull(result, ASSERT_FAIL_VIEW_MODEL_MESSAGE);
}
public void CreateGetAction_GameResultViewModelRequested_GameResultViewModelIsReturned()
{
// Arrange
_teamServiceMock.Setup(ts => ts.Get()).Returns(new List <Team>());
var expected = new GameResultViewModel
{
TournamentId = TOURNAMENT_ID
};
var controller = BuildSUT();
// Act
var actual = TestExtensions.GetModel <GameResultViewModel>(controller.Create(TOURNAMENT_ID));
// Assert
TestHelper.AreEqual <GameResultViewModel>(expected, actual, new GameResultViewModelComparer());
}
public async Task SendAsync_WithValidRequest_WillSignProperly(string method)
{
// Arrange
var testData = await TestData.For(method);
var actual = new AssertSigningHandler();
var signingHandler = new MAuthSigningHandler(TestExtensions.ClientOptions(testData.SignedTime), actual);
// Act
using (var client = new HttpClient(signingHandler))
{
await client.SendAsync(testData.Request);
}
// Assert
Assert.Equal(testData.MAuthHeader, actual.MAuthHeader);
Assert.Equal(testData.SignedTime, actual.MAuthTimeHeader.FromUnixTimeSeconds());
}
public void EditPost_MissingEntityException_RedirectToGameResultViewModel()
{
// Arrange
var gameResultViewModel = CreateResultViewModel();
var expectedResult = CreateExpectedResult();
_gameServiceMock.Setup(grs => grs.EditGameResult(It.IsAny <Game>()))
.Throws(new MissingEntityException());
var sut = BuildSUT();
// Act
var result = TestExtensions.GetModel <GameResultViewModel>(sut.Edit(gameResultViewModel));
// Assert
VerifyEditGameResult(expectedResult, Times.Once());
Assert.IsNotNull(result, ASSERT_FAIL_VIEW_MODEL_MESSAGE);
}
public async Task Can_join_channel()
{
////Arrange
var client = ElasticClientFactory.Create();
var user = TestExtensions.RandomUser();
await new UserService().EnsureUser(user);
////Act
await new ChannelService().Join(user, "global");
////Assert
await client.Indices.RefreshAsync(Indices.Index <UserAccount>());
var userAccount = await new UserService().FindById(user.UserId());
Assert.IsTrue(userAccount.Channels.Contains("global"));
}
public void CheckCreatingNewRepositories_RepositoryPageWillExistNewRepository_TrueReturned()
{
var generatedRepositoryName = TestExtensions.GetRandomString(length: 8);
var repositoryForm = new RepositoryFormInfo()
{
Name = generatedRepositoryName,
Description = "test creating repository",
NeedToAddReadmi = true,
Visibility = Visibility.Private,
NeedToAddGitIgnore = true,
GitIgnoreTemplate = "VisualStudio",
};
RepositoriesSteps.CreateNewRepository(repositoryForm);
var actual = RepositoriesSteps.ContainsRepository(generatedRepositoryName);
Assert.True(actual);
}
public void Index_FeedbacksExist_AllFeedbacksReturned()
{
// Arrange
var feedbacks = GetFeedbacks();
var expected = GetRequestsViewModels();
_feedbacksServiceMock.Setup(r => r.Get()).Returns(feedbacks);
var sut = BuildSut();
// Act
var actionResult = sut.Index();
// Assert
var actual = TestExtensions.GetModel <List <RequestsViewModel> >(actionResult);
CollectionAssert.AreEqual(expected, actual, new RequestsViewModelComparer());
}
void when_post_processing()
{
xit["manual test"] = () => {
var p = new UpdateCSProjPostProcessor();
p.Configure(new Properties(
"Entitas.CodeGeneration.Plugins.ProjectPath = " + TestExtensions.GetProjectRoot() + "/../Match-One/Assembly-CSharp.csproj" + "\n" +
"Entitas.CodeGeneration.Plugins.TargetDirectory = Assets/Sources"
));
var files = new [] {
new CodeGenFile("My/Generated/Folder/File1.cs", "Hello, world!", "Test"),
new CodeGenFile("My/Generated/Folder/File2.cs", "Hello, world!", "Test")
};
p.PostProcess(files);
};
}
void when_resolving()
{
xcontext["when no dependencies"] = () => {
string dllPath = null;
Type[] types = null;
before = () => {
dllPath = TestExtensions.GetProjectRoot() + "/Tests/Tests.Fixtures/TestDependenyBase/bin/Release/TestDependenyBase.dll";
var resolver = new AssemblyResolver(AppDomain.CurrentDomain, new string[0]);
resolver.Load(dllPath);
types = resolver.GetTypes();
};
it["loads dll"] = () => {
types.Length.should_be(1);
types[0].FullName.should_be("TestDependenyBase.Point");
};
it["instantiates type"] = () => {
Activator.CreateInstance(types[0]);
};
};
xcontext["when dependencies"] = () => {
string dllPath = null;
Type[] types = null;
before = () => {
dllPath = TestExtensions.GetProjectRoot() + "/Tests/Tests.Fixtures/TestDependency/bin/Release/TestDependency.dll";
var resolver = new AssemblyResolver(AppDomain.CurrentDomain, new string[0]);
resolver.Load(dllPath);
types = resolver.GetTypes();
};
it["loads dll with all dependencies"] = () => {
types.Length.should_be(1);
types[0].FullName.should_be("TestDependency.PositionComponent");
};
it["instantiates type"] = () => {
Activator.CreateInstance(types[0]);
};
};
}
void when_checking_namespaces()
{
var projectRoot = TestExtensions.GetProjectRoot();
var sourceFiles = TestExtensions.GetSourceFiles(projectRoot);
it["processes roughly the correct number of files"] = () => {
sourceFiles.Count.should_be_greater_than(200);
sourceFiles.Count.should_be_less_than(300);
};
System.Console.WriteLine("sourceFiles: " + sourceFiles.Count);
const string namespacePattern = @"(?:^namespace)\s.*\b";
string expectedNamespacePattern = string.Format(@"[^\{0}]*", Path.DirectorySeparatorChar);
var addonsDir = dir("Addons");
var each = new Each <string, string, string>();
foreach (var file in sourceFiles)
{
var fileName = file.Key
.Replace(dir(projectRoot), string.Empty)
.Replace(addonsDir, string.Empty);
string expectedNamespace;
expectedNamespace = Regex.Match(fileName, expectedNamespacePattern)
.ToString()
.Replace("namespace ", string.Empty)
.Trim();
var foundNamespace = Regex.Match(file.Value, namespacePattern, RegexOptions.Multiline)
.ToString()
.Replace("namespace ", string.Empty)
.Trim();
each.Add(new NSpecTuple <string, string, string>(fileName, foundNamespace, expectedNamespace));
}
each.Do((fileName, given, expected) =>
it["{0} namespace should be {2}".With(fileName, given, expected)] = () => given.should_be(expected)
);
}
