public void CreateNewOrganization_Returns_Ok(OrganizationTypeKeys organizationType, bool expectRolesAssigned)
{
//Arrange
var newOrg = new Organization
{
Name = A <string>(),
TypeId = (int)organizationType
};
_userRepository.Setup(x => x.GetByKey(_user.Id)).Returns(_user);
ExpectAllowCreateReturns <Organization>(true);
_authorizationContext.Setup(x => x.HasPermission(It.IsAny <DefineOrganizationTypePermission>()))
.Returns(true);
var transaction = new Mock <IDatabaseTransaction>();
_transactionManager.Setup(x => x.Begin(IsolationLevel.Serializable)).Returns(transaction.Object);
_organizationRepository.Setup(x => x.Insert(newOrg)).Returns(newOrg);
//Act
var result = _sut.CreateNewOrganization(newOrg);
//Assert
Assert.True(result.Ok);
Assert.Same(newOrg, result.Value);
transaction.Verify(x => x.Commit(), Times.Once);
Assert.Equal(1, newOrg.OrgUnits.Count);
Assert.Equal(newOrg.Name, newOrg.OrgUnits.First().Name);
Assert.NotNull(newOrg.Config);
_organizationRepository.Verify(x => x.Save(), Times.Once);
_roleService.Verify(x => x.MakeLocalAdmin(_user, newOrg), Times.Exactly(expectRolesAssigned ? 1 : 0));
_roleService.Verify(x => x.MakeUser(_user, newOrg), Times.Exactly(expectRolesAssigned ? 1 : 0));
}
public bool CanChangeOrganizationType(Organization organization, OrganizationTypeKeys organizationType)
{
if (organization == null)
{
throw new ArgumentNullException(nameof(organization));
}
return
(_authorizationContext.AllowModify(organization) &&
_authorizationContext.HasPermission(new DefineOrganizationTypePermission(organizationType, organization.Id)));
}
public void AllowChangeOrganizationType_Returns(OrganizationTypeKeys organizationType, bool globalAdmin, bool localAdmin, bool expectedResult)
{
//Arrange
var organizationId = A <int>();
ExpectUserIsGlobalAdmin(globalAdmin);
ExpectHasRoleReturns(organizationId, OrganizationRole.LocalAdmin, localAdmin);
//Act
var result = _sut.HasPermission(new DefineOrganizationTypePermission(organizationType, organizationId));
//Assert
Assert.Equal(expectedResult, result);
}
public void HasPermission_With_DefineOrganizationTypePermission_Returns(OrganizationTypeKeys organizationType, OrganizationRole userRole, bool expectedResult)
{
//Arrange
var organizationId = A <int>();
ExpectUserHasRoles(organizationId, userRole);
ExpectUserIsGlobalAdmin(userRole == OrganizationRole.GlobalAdmin);
//Act
var actual = _sut.HasPermission(new DefineOrganizationTypePermission(organizationType, organizationId));
//Assert
Assert.Equal(expectedResult, actual);
}
public async Task Cannot_Create_Organization_Of_Type(OrganizationRole role, OrganizationTypeKeys organizationType)
{
//Arrange
var login = await HttpApi.GetCookieAsync(role);
var name = A <string>();
var cvr = (A <int>() % 9999999999).ToString("D10");
const AccessModifier accessModifier = AccessModifier.Public;
//Act - perform the action with the actual role
using (var result = await OrganizationHelper.SendCreateOrganizationRequestAsync(TestEnvironment.DefaultOrganizationId, name, cvr, organizationType, accessModifier, login))
{
//Assert
Assert.Equal(HttpStatusCode.Forbidden, result.StatusCode);
}
}
public async Task Can_Create_Organization_Of_Type(OrganizationRole role, OrganizationTypeKeys organizationType)
{
//Arrange
var login = await HttpApi.GetCookieAsync(role);
var name = A <string>();
var cvr = (A <int>() % 9999999999).ToString("D10");
const AccessModifier accessModifier = AccessModifier.Public;
//Act - perform the action with the actual role
var result = await OrganizationHelper.CreateOrganizationAsync(TestEnvironment.DefaultOrganizationId, name, cvr, organizationType, accessModifier, login);
//Assert
Assert.Equal(accessModifier, result.AccessModifier);
Assert.Equal(name, (string)result.Name);
Assert.Equal(cvr, (string)result.Cvr);
}
public DefineOrganizationTypePermission(OrganizationTypeKeys targetOrganizationType, int parentOrganizationId)
{
TargetOrganizationType = targetOrganizationType;
ParentOrganizationId = parentOrganizationId;
}
public static async Task <HttpResponseMessage> SendCreateOrganizationRequestAsync(int owningOrganizationId, string name, string cvr, OrganizationTypeKeys type, AccessModifier accessModifier, Cookie optionalLogin = null)
{
var cookie = optionalLogin ?? await HttpApi.GetCookieAsync(OrganizationRole.GlobalAdmin);
var url = TestEnvironment.CreateUrl("odata/Organizations");
var body = new
{
AccessModifier = ((int)accessModifier).ToString("D"),
Cvr = cvr,
Id = owningOrganizationId, //This looks odd, but is checked in BaseEntityController. Id is changed once created
Name = name,
TypeId = (int)type
};
return(await HttpApi.PostWithCookieAsync(url, cookie, body));
}
public static async Task <Organization> CreateOrganizationAsync(int owningOrganizationId, string name, string cvr, OrganizationTypeKeys type, AccessModifier accessModifier, Cookie optionalLogin = null)
{
using var createdResponse = await SendCreateOrganizationRequestAsync(owningOrganizationId, name, cvr, type, accessModifier, optionalLogin);
Assert.Equal(HttpStatusCode.Created, createdResponse.StatusCode);
return(await createdResponse.ReadResponseBodyAsAsync <Organization>());
}
