public void AllowReturnsBadReuqestForFailingLifecycleManagerOperation()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
LIFE_CYCLE_ALLOW_PERMISSION
},
Username = CURRENT_USER_ID
})
.MustBeCalled();
Mock.Arrange(() => _coreService.Jobs)
.IgnoreInstance()
.ReturnsCollection(new List <Job>(new List <CumulusCoreService.Job> {
CreateSampleJob()
}))
.MustBeCalled();
var mockedLifeCycleManager = Mock.Create <LifeCycleManager>();
Mock.Arrange(() => mockedLifeCycleManager.OnAllowCallback(Arg.IsAny <Job>()))
.IgnoreInstance()
.Throws <InvalidOperationException>()
.MustBeCalled();
var actionResult = _lifeCyclesController.Allow(SAMPLE_TOKEN, null)
.Result;
Assert.IsTrue(actionResult.GetType() == typeof(BadRequestErrorMessageResult));
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(mockedLifeCycleManager);
Mock.Assert(_coreService);
}
public void DeleteStateChangeLockForAuthorizedUserWithDeletePermissionDeletesStateChangeLock()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
STATE_CHANGE_LOCK_DELETE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <StateChangeLock>()))
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.StateChangeLocks.Find(1))
.IgnoreInstance()
.Returns(CreateSampleStateChangeLockDbSet()[0])
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.StateChangeLocks.Remove(Arg.IsAny <StateChangeLock>()))
.IgnoreInstance()
.MustBeCalled();
var actionResult = _stateChangeLocksController.Delete(1).Result;
AssertStatusCodeResult(actionResult, HttpStatusCode.NoContent);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <StateChangeLock>()));
Mock.Assert(_lifeCycleContext);
}
public void CancelWithValidKeyCreatesLifecycleManagerAndExecutesCancelMethod()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
LIFE_CYCLE_CANCEL_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
var mockedEntityController = Mock.Create <EntityController>();
Mock.Arrange(() => mockedEntityController.LoadEntity(Arg.IsAny <Uri>()))
.IgnoreInstance()
.Returns(ENTITY)
.MustBeCalled();
var mockedLifeCycleManager = Mock.Create <LifeCycleManager>();
Mock.Arrange(() => mockedLifeCycleManager.Cancel(new Uri(ENTITY_ID), ENTITY, TENANT_ID))
.IgnoreInstance()
.MustBeCalled();
var actionResult = _lifeCyclesController.Cancel(ENTITY_ID, null)
.Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkResult));
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(mockedEntityController);
Mock.Assert(mockedLifeCycleManager);
}
public void AllowWithValidTokenCreatesLifecycleManagerAndExecutesOnAllowCallbackMethod()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
LIFE_CYCLE_ALLOW_PERMISSION
},
Username = CURRENT_USER_ID
})
.MustBeCalled();
Mock.Arrange(() => _coreService.Jobs)
.IgnoreInstance()
.ReturnsCollection(new List <Job>(new List <CumulusCoreService.Job> {
CreateSampleJob()
}))
.MustBeCalled();
var mockedLifeCycleManager = Mock.Create <LifeCycleManager>();
Mock.Arrange(() => mockedLifeCycleManager.OnAllowCallback(Arg.IsAny <Job>()))
.IgnoreInstance()
.MustBeCalled();
var actionResult = _lifeCyclesController.Allow(SAMPLE_TOKEN, null)
.Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkResult));
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(mockedLifeCycleManager);
Mock.Assert(_coreService);
}
public void PatchReturnsBadRequestIfEntityCouldNotBeLoaded()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
LIFE_CYCLE_UPDATE_PERMISSION
},
Username = CURRENT_USER_ID
})
.MustBeCalled();
var mockedEntityController = Mock.Create <EntityController>();
Mock.Arrange(() => mockedEntityController.LoadEntity(Arg.IsAny <Uri>()))
.IgnoreInstance()
.Throws <HttpRequestException>();
var delta = new Delta <LifeCycle>(typeof(LifeCycle));
delta.TrySetPropertyValue("Condition", CONTINUE_CONDITION);
var actionResult = _lifeCyclesController.Patch(ENTITY_ID, delta)
.Result;
Assert.IsTrue(actionResult.GetType() == typeof(BadRequestErrorMessageResult));
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
}
public void CancelReturnsBadRequestIfEntityCouldNotBeLoaded()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
LIFE_CYCLE_CANCEL_PERMISSION
},
Username = CURRENT_USER_ID
})
.MustBeCalled();
var mockedEntityController = Mock.Create <EntityController>();
Mock.Arrange(() => mockedEntityController.LoadEntity(Arg.IsAny <Uri>()))
.IgnoreInstance()
.Throws <HttpRequestException>();
var actionResult = _lifeCyclesController.Cancel(ENTITY_ID, null)
.Result;
Assert.IsTrue(actionResult.GetType() == typeof(BadRequestErrorMessageResult));
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
}
public void GetCalloutDefinitionByIdForNonExistingCalloutDefinitionIdReturnsNotFound()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
CALLOUT_DEFINITION_READ_PERMISSION
},
Username = CURRENT_USER_ID
})
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Find(1))
.IgnoreInstance()
.Returns((CalloutDefinition)null)
.MustBeCalled();
var actionResult = _calloutDefinitionsController.GetCalloutDefinition(1,
CreateODataQueryOptions("http://localhost/api/Core.svc/CalloutDefinitions(1)"))
.Result;
AssertStatusCodeResult(actionResult, HttpStatusCode.NotFound);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void RunForUnauthorizedUserReturnsForbidden()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
JOB_RUN_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <Job>()))
.Returns(false)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Jobs.Find(1))
.IgnoreInstance()
.Returns(CreateSampleJobDbSet()[0])
.MustBeCalled();
var actionResult = _jobsController.Run(1, null).Result;
AssertStatusCodeResult(actionResult, HttpStatusCode.Forbidden);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <Job>()));
Mock.Assert(_lifeCycleContext);
}
public void PutCalloutDefinitionForNonExistingCalloutDefinitionIdReturnsNotFound()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
CALLOUT_DEFINITION_UPDATE_PERMISSION
},
Username = CURRENT_USER_ID
})
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Find(1))
.IgnoreInstance()
.Returns((CalloutDefinition)null)
.MustBeCalled();
var actionResult = _calloutDefinitionsController.Put(1,
new CalloutDefinition
{
Id = 1,
EntityType = SAMPLE_ENTITY_TYPE,
EntityId = ENTITY_ID_1,
TenantId = TENANT_ID,
Parameters = "testparameters",
}).Result;
AssertStatusCodeResult(actionResult, HttpStatusCode.NotFound);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void PutJobForNonExistingJobIdReturnsNotFound()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
JOB_UPDATE_PERMISSION
},
Username = CURRENT_USER_ID
})
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Jobs.Find(1))
.IgnoreInstance()
.Returns((Job)null)
.MustBeCalled();
var actionResult = _jobsController.Put(1,
new Job
{
Id = 1,
Type = "Test",
State = JobStateEnum.Canceled.ToString(),
Parameters = SAMPLE_PARAMETERS,
}).Result;
AssertStatusCodeResult(actionResult, HttpStatusCode.NotFound);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void GetCalloutDefinitionsForUserWithReadPermissionReturnsCalloutDefinitionsTheUserIsAuthorizedFor()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
CALLOUT_DEFINITION_READ_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.GetEntitiesForUser(Arg.IsAny <DbSet <CalloutDefinition> >(), CURRENT_USER_ID, TENANT_ID))
.ReturnsCollection(CreateSampleCalloutDefinitionDbSet().ToList())
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions)
.IgnoreInstance()
.ReturnsCollection(CreateSampleCalloutDefinitionDbSet())
.MustBeCalled();
var actionResult = _calloutDefinitionsController.GetCalloutDefinitions(
CreateODataQueryOptions("http://localhost/api/Core.svc/CalloutDefinitions"))
.Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkNegotiatedContentResult <IEnumerable <CalloutDefinition> >));
var response = actionResult as OkNegotiatedContentResult <IEnumerable <CalloutDefinition> >;
Assert.IsNotNull(response);
Assert.AreEqual(2, response.Content.Count());
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.GetEntitiesForUser(Arg.IsAny <DbSet <CalloutDefinition> >(), CURRENT_USER_ID, TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void GetStateChangeLocksForUserWithoutStateChangeLocksReturnsEmptyList()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
STATE_CHANGE_LOCK_READ_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.GetEntitiesForUser(Arg.IsAny <DbSet <StateChangeLock> >(), CURRENT_USER_ID, TENANT_ID))
.ReturnsCollection(new List <StateChangeLock>())
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.StateChangeLocks)
.IgnoreInstance()
.ReturnsCollection(CreateSampleStateChangeLockDbSet())
.MustBeCalled();
var actionResult = _stateChangeLocksController.GetStateChangeLocks(
CreateODataQueryOptions("http://localhost/api/Core.svc/StateChangeLocks"))
.Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkNegotiatedContentResult <IEnumerable <StateChangeLock> >));
var response = actionResult as OkNegotiatedContentResult <IEnumerable <StateChangeLock> >;
Assert.IsNotNull(response);
Assert.AreEqual(0, response.Content.Count());
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.GetEntitiesForUser(Arg.IsAny <DbSet <StateChangeLock> >(), CURRENT_USER_ID, TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void DeleteCalloutDefinitionForUnauthorizedUserReturnsForbidden()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
CALLOUT_DEFINITION_DELETE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <CalloutDefinition>()))
.Returns(false)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Find(1))
.IgnoreInstance()
.Returns(CreateSampleCalloutDefinitionDbSet()[0])
.MustBeCalled();
var actionResult = _calloutDefinitionsController.Delete(1).Result;
AssertStatusCodeResult(actionResult, HttpStatusCode.Forbidden);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <CalloutDefinition>()));
Mock.Assert(_lifeCycleContext);
}
public void IsEntityOfUserForMatchingTidAndCreatedByReturnsTrue()
{
Assert.IsTrue(CurrentUserDataProvider.IsEntityOfUser(USERNAME, TENANT_ID, new BaseEntity
{
CreatedBy = USERNAME,
Tid = TENANT_ID
}));
}
public void PostJobForUserWithCreatePermissionCreatesJobAndReturnsCreated()
{
Job createdJob = null;
Mock.Arrange(() => ODataControllerHelper.ResponseCreated(
Arg.IsAny <ODataController>(), Arg.IsAny <Job>(),
Arg.IsAny <String>())).Returns(new HttpResponseMessage(HttpStatusCode.Created));
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
JOB_CREATE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Jobs.Add(Arg.IsAny <Job>()))
.IgnoreInstance()
.DoInstead((Job j) => createdJob = j)
.Returns((Job j) => j)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.SaveChanges())
.IgnoreInstance()
.MustBeCalled();
var actionResult = _jobsController.Post(
new Job
{
Id = 1,
CreatedBy = ANOTHER_USER_ID,
Modified = DateTimeOffset.Now,
ModifiedBy = CURRENT_USER_ID,
Tid = TENANT_ID,
Type = "Test",
State = JobStateEnum.Running.ToString(),
Parameters = SAMPLE_PARAMETERS,
Token = SAMPLE_TOKEN,
TenantId = ANOTHER_TENANT_ID
}).Result;
Assert.AreEqual(CURRENT_USER_ID, createdJob.CreatedBy);
Assert.AreEqual(DateTimeOffset.Now.Date, createdJob.Created.Date);
Assert.IsNull(createdJob.ModifiedBy);
Assert.AreEqual(TENANT_ID, createdJob.Tid);
Assert.AreEqual(JobStateEnum.Running.ToString(), createdJob.State);
Assert.AreEqual("Test", createdJob.Type);
Assert.AreEqual(SAMPLE_PARAMETERS, createdJob.Parameters);
Assert.AreEqual(ANOTHER_TENANT_ID, createdJob.TenantId);
Assert.IsTrue(actionResult.GetType() == typeof(ResponseMessageResult));
var response = actionResult as ResponseMessageResult;
Assert.AreEqual(HttpStatusCode.Created, response.Response.StatusCode);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void PatchCalloutDefinitionForAuthorizedUserWithUpdatePermissionUpdatesDeliveredFields()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
CALLOUT_DEFINITION_UPDATE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <CalloutDefinition>()))
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Find(1))
.IgnoreInstance()
.Returns(CreateSampleCalloutDefinitionDbSet()[0])
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Attach(Arg.IsAny <CalloutDefinition>()))
.IgnoreInstance()
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Entry(Arg.IsAny <CalloutDefinition>()))
.IgnoreInstance()
.Returns(Mock.Create <DbEntityEntry <CalloutDefinition> >())
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.SaveChanges())
.IgnoreInstance()
.MustBeCalled();
var delta = new Delta <CalloutDefinition>(typeof(CalloutDefinition));
delta.TrySetPropertyValue("Id", "3");
delta.TrySetPropertyValue("CreatedBy", ANOTHER_USER_ID);
delta.TrySetPropertyValue("ModifiedBy", ANOTHER_USER_ID);
delta.TrySetPropertyValue("Tid", ANOTHER_TENANT_ID);
delta.TrySetPropertyValue("Parameters", "testparameters");
delta.TrySetPropertyValue("EntityType", SAMPLE_ENTITY_TYPE);
var actionResult = _calloutDefinitionsController.Patch(1, delta).Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkNegotiatedContentResult <CalloutDefinition>));
var response = actionResult as OkNegotiatedContentResult <CalloutDefinition>;
var calloutDefinition = response.Content;
Assert.AreEqual(1, calloutDefinition.Id);
Assert.AreEqual(DateTimeOffset.Now.Date, calloutDefinition.Modified.Date);
Assert.AreEqual(CURRENT_USER_ID, calloutDefinition.CreatedBy);
Assert.AreEqual(CURRENT_USER_ID, calloutDefinition.ModifiedBy);
Assert.AreEqual(TENANT_ID, calloutDefinition.Tid);
Assert.AreEqual("testparameters", calloutDefinition.Parameters);
Assert.AreEqual(SAMPLE_ENTITY_TYPE, calloutDefinition.EntityType);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <CalloutDefinition>()));
Mock.Assert(_lifeCycleContext);
}
public void PostCalloutDefinitionForUserWithCreatePermissionCreatesCalloutDefinitionAndReturnsCreated()
{
CalloutDefinition createdCalloutDefinition = null;
Mock.Arrange(() => ODataControllerHelper.ResponseCreated(
Arg.IsAny <ODataController>(), Arg.IsAny <CalloutDefinition>(),
Arg.IsAny <String>())).Returns(new HttpResponseMessage(HttpStatusCode.Created));
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
CALLOUT_DEFINITION_CREATE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Add(Arg.IsAny <CalloutDefinition>()))
.IgnoreInstance()
.DoInstead((CalloutDefinition j) => createdCalloutDefinition = j)
.Returns((CalloutDefinition j) => j)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.SaveChanges())
.IgnoreInstance()
.MustBeCalled();
var actionResult = _calloutDefinitionsController.Post(
new CalloutDefinition
{
Id = 1,
CreatedBy = ANOTHER_USER_ID,
Modified = DateTimeOffset.Now,
Tid = ANOTHER_TENANT_ID,
ModifiedBy = CURRENT_USER_ID,
EntityType = SAMPLE_ENTITY_TYPE,
EntityId = ENTITY_ID_1,
TenantId = TENANT_ID,
Parameters = "testparameters"
}).Result;
Assert.AreEqual(CURRENT_USER_ID, createdCalloutDefinition.CreatedBy);
Assert.AreEqual(DateTimeOffset.Now.Date, createdCalloutDefinition.Created.Date);
Assert.IsNull(createdCalloutDefinition.ModifiedBy);
Assert.AreEqual(TENANT_ID, createdCalloutDefinition.Tid);
Assert.AreEqual(SAMPLE_ENTITY_TYPE, createdCalloutDefinition.EntityType);
Assert.AreEqual(ENTITY_ID_1, createdCalloutDefinition.EntityId);
Assert.AreEqual(TENANT_ID, createdCalloutDefinition.TenantId);
Assert.AreEqual("testparameters", createdCalloutDefinition.Parameters);
Assert.IsTrue(actionResult.GetType() == typeof(ResponseMessageResult));
var response = actionResult as ResponseMessageResult;
Assert.AreEqual(HttpStatusCode.Created, response.Response.StatusCode);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void PutCalloutDefinitionForAuthorizedUserSetsUpdatedDate()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
CALLOUT_DEFINITION_UPDATE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <CalloutDefinition>()))
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Find(1))
.IgnoreInstance()
.Returns(CreateSampleCalloutDefinitionDbSet()[0])
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.CalloutDefinitions.Attach(Arg.IsAny <CalloutDefinition>()))
.IgnoreInstance()
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Entry(Arg.IsAny <CalloutDefinition>()))
.IgnoreInstance()
.Returns(Mock.Create <DbEntityEntry <CalloutDefinition> >())
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.SaveChanges())
.IgnoreInstance()
.MustBeCalled();
var actionResult = _calloutDefinitionsController.Put(1,
new CalloutDefinition
{
Id = 1,
EntityType = SAMPLE_ENTITY_TYPE,
EntityId = ENTITY_ID_1,
TenantId = TENANT_ID,
Parameters = "testparameters",
}).Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkNegotiatedContentResult <CalloutDefinition>));
var response = actionResult as OkNegotiatedContentResult <CalloutDefinition>;
var calloutDefinition = response.Content;
Assert.AreEqual(1, calloutDefinition.Id);
Assert.AreEqual(CURRENT_USER_ID, calloutDefinition.CreatedBy);
Assert.AreEqual(DateTimeOffset.Now.Date, calloutDefinition.Modified.Date);
Assert.AreEqual(CURRENT_USER_ID, calloutDefinition.ModifiedBy);
Assert.AreEqual(SAMPLE_ENTITY_TYPE, calloutDefinition.EntityType);
Assert.AreEqual(ENTITY_ID_1, calloutDefinition.EntityId);
Assert.AreEqual(TENANT_ID, calloutDefinition.TenantId);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <CalloutDefinition>()));
Mock.Assert(_lifeCycleContext);
}
public async Task <IHttpActionResult> Patch([FromODataUri] int key, Delta <Job> delta)
{
var declaringType = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
var fn = String.Format("{0}:{1}",
declaringType.Namespace,
declaringType.Name);
if (!ModelState.IsValid)
{
Debug.WriteLine("Job to be created has invalid ModelState.");
return(BadRequest(ModelState));
}
try
{
Debug.WriteLine(fn);
var identity = CurrentUserDataProvider.GetIdentity(TenantId);
var permissionId = CreatePermissionId("CanUpdate");
if (!identity.Permissions.Contains(permissionId))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
var job = db.Jobs.Find(key);
if (null == job)
{
return(StatusCode(HttpStatusCode.NotFound));
}
if (!CurrentUserDataProvider.IsEntityOfUser(identity.Username, identity.Tid, job))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
Debug.WriteLine("Patching Job with id '{0}'", key);
var id = job.Id;
var created = job.Created;
var createdBy = job.CreatedBy;
var tId = job.Tid;
delta.Patch(job);
job.Id = id;
job.Created = created;
job.CreatedBy = createdBy;
job.Modified = DateTimeOffset.Now;
job.ModifiedBy = identity.Username;
job.Tid = tId;
db.Jobs.Attach(job);
db.Entry(job).State = EntityState.Modified;
db.SaveChanges();
Debug.WriteLine("Job with id '{0}' patched", key);
return(Ok <Job>(job));
}
catch (Exception e)
{
Debug.WriteLine(String.Format("{0}: {1}\r\n{2}", e.Source, e.Message, e.StackTrace));
throw;
}
}
public void GetCurrentUsernameGetsUsernameFromHttpContext()
{
Mock.Arrange(() => HttpContext.Current.User.Identity.Name)
.Returns(USERNAME)
.OccursOnce();
CurrentUserDataProvider.GetCurrentUsername();
Mock.Assert(() => HttpContext.Current.User.Identity.Name);
}
// PUT: api/Core.svc/CalloutDefinitions(5)
public async Task <IHttpActionResult> Put([FromODataUri] int key, CalloutDefinition calloutDefinition)
{
var declaringType = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
var fn = String.Format("{0}:{1}",
declaringType.Namespace,
declaringType.Name);
if (!ModelState.IsValid)
{
Debug.WriteLine("CalloutDefinition to be updated with id '{0}' has invalid ModelState.", key);
return(BadRequest(ModelState));
}
if (key != calloutDefinition.Id)
{
return(BadRequest());
}
try
{
Debug.WriteLine(fn);
var identity = CurrentUserDataProvider.GetIdentity(TenantId);
var permissionId = CreatePermissionId("CanUpdate");
if (!identity.Permissions.Contains(permissionId))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
var original = db.CalloutDefinitions.Find(calloutDefinition.Id);
if (null == original)
{
return(StatusCode(HttpStatusCode.NotFound));
}
if (!CurrentUserDataProvider.IsEntityOfUser(identity.Username, identity.Tid, calloutDefinition))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
calloutDefinition.Created = original.Created;
calloutDefinition.CreatedBy = original.CreatedBy;
calloutDefinition.Modified = DateTimeOffset.Now;
calloutDefinition.ModifiedBy = identity.Username;
calloutDefinition.Tid = original.Tid;
db.CalloutDefinitions.Attach(calloutDefinition);
db.Entry(calloutDefinition).State = EntityState.Modified;
db.SaveChanges();
Debug.WriteLine("CalloutDefinition with id '{0}' updated", key);
return(Ok <CalloutDefinition>(calloutDefinition));
}
catch (Exception e)
{
Debug.WriteLine(String.Format("{0}: {1}\r\n{2}", e.Source, e.Message, e.StackTrace));
throw;
}
}
public void PutJobForAuthorizedUserSetsUpdatedDate()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
JOB_UPDATE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <Job>()))
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Jobs.Find(1))
.IgnoreInstance()
.Returns(CreateSampleJobDbSet()[0])
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Jobs.Attach(Arg.IsAny <Job>()))
.IgnoreInstance()
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Entry(Arg.IsAny <Job>()))
.IgnoreInstance()
.Returns(Mock.Create <DbEntityEntry <Job> >())
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.SaveChanges())
.IgnoreInstance()
.MustBeCalled();
var actionResult = _jobsController.Put(1,
new Job
{
Id = 1,
Type = "Test",
State = JobStateEnum.Canceled.ToString(),
Parameters = SAMPLE_PARAMETERS,
}).Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkNegotiatedContentResult <Job>));
var response = actionResult as OkNegotiatedContentResult <Job>;
var job = response.Content;
Assert.AreEqual(1, job.Id);
Assert.AreEqual(CURRENT_USER_ID, job.CreatedBy);
Assert.AreEqual(DateTimeOffset.Now.Date, job.Modified.Date);
Assert.AreEqual(CURRENT_USER_ID, job.ModifiedBy);
Assert.AreEqual(JobStateEnum.Canceled.ToString(), job.State);
Assert.AreEqual("Test", job.Type);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <Job>()));
Mock.Assert(_lifeCycleContext);
}
// PUT: api/Utilities.svc/LifeCycles(5)
public async Task <IHttpActionResult> Put([FromODataUri] String key, LifeCycle lifeCycle)
{
var declaringType = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
var fn = String.Format("{0}:{1}",
declaringType.Namespace,
declaringType.Name);
if (!ModelState.IsValid)
{
Debug.WriteLine("Entity to be changed by LifeCycleManager with id '{0}' has invalid ModelState.", key);
return(BadRequest(ModelState));
}
if (key != lifeCycle.Id)
{
return(BadRequest());
}
try
{
Debug.WriteLine(fn);
var identity = CurrentUserDataProvider.GetIdentity(TenantId);
var permissionId = CreatePermissionId("CanUpdate");
if (!identity.Permissions.Contains(permissionId))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
var entityUri = new Uri(key);
var entity = LoadEntity(new DefaultAuthenticationProvider(), entityUri);
var lifeCycleManager = new LifeCycleManager(new DefaultAuthenticationProvider(), ExtractTypeFromUriString(key));
lifeCycleManager.RequestStateChange(entityUri, entity, lifeCycle.Condition, identity.Tid);
return(Ok());
}
catch (UriFormatException e)
{
return(BadRequest("Invalid Id - Id has to be a valid URI"));
}
catch (HttpRequestException e)
{
return(BadRequest("Loading entity from passed Uri failed (Either not found or not authorized)"));
}
catch (InvalidOperationException e)
{
return(BadRequest(String.Format("Changing state with provided condition: '{0}' not possible", lifeCycle.Condition)));
}
catch (Exception e)
{
Debug.WriteLine(String.Format("{0}: {1}\r\n{2}", e.Source, e.Message, e.StackTrace));
throw;
}
}
public void PatchJobForAuthorizedUserWithUpdatePermissionUpdatesDeliveredFields2()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
JOB_UPDATE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <Job>()))
.Returns(true)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Jobs.Find(1))
.IgnoreInstance()
.Returns(CreateSampleJobDbSet()[0])
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Jobs.Attach(Arg.IsAny <Job>()))
.IgnoreInstance()
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.Entry(Arg.IsAny <Job>()))
.IgnoreInstance()
.Returns(Mock.Create <DbEntityEntry <Job> >())
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.SaveChanges())
.IgnoreInstance()
.MustBeCalled();
var delta = new Delta <Job>(typeof(Job));
delta.TrySetPropertyValue("Id", "3");
delta.TrySetPropertyValue("CreatedBy", ANOTHER_USER_ID);
delta.TrySetPropertyValue("ModifiedBy", ANOTHER_USER_ID);
delta.TrySetPropertyValue("Parameters", SAMPLE_PARAMETERS);
var actionResult = _jobsController.Patch(1, delta).Result;
Assert.IsTrue(actionResult.GetType() == typeof(OkNegotiatedContentResult <Job>));
var response = actionResult as OkNegotiatedContentResult <Job>;
var job = response.Content;
Assert.AreEqual(1, job.Id);
Assert.AreEqual(DateTimeOffset.Now.Date, job.Modified.Date);
Assert.AreEqual(CURRENT_USER_ID, job.CreatedBy);
Assert.AreEqual(CURRENT_USER_ID, job.ModifiedBy);
Assert.AreEqual(SAMPLE_PARAMETERS, job.Parameters);
Assert.AreEqual(JobStateEnum.Running.ToString(), job.State);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => CurrentUserDataProvider.IsEntityOfUser(CURRENT_USER_ID, TENANT_ID, Arg.IsAny <Job>()));
Mock.Assert(_lifeCycleContext);
}
// POST: api/Core.svc/Jobs
public async Task <IHttpActionResult> Post(Job job)
{
var declaringType = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
var fn = String.Format("{0}:{1}",
declaringType.Namespace,
declaringType.Name);
if (!ModelState.IsValid)
{
Debug.WriteLine("Job to be created has invalid ModelState.");
return(BadRequest(ModelState));
}
try
{
Debug.WriteLine(fn);
var identity = CurrentUserDataProvider.GetIdentity(TenantId);
var permissionId = CreatePermissionId("CanCreate");
if (!identity.Permissions.Contains(permissionId))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
if (null == job)
{
var errorMsg = "Job to be created contains invalid data.";
Debug.WriteLine(errorMsg);
return(BadRequest(errorMsg));
}
Debug.WriteLine("Saving new job...");
var jobEntity = new Job()
{
Created = DateTimeOffset.Now,
CreatedBy = identity.Username,
Tid = identity.Tid,
Type = null == job.Type ? "Default" : job.Type,
State = job.State,
Parameters = job.Parameters,
ReferencedItemId = job.ReferencedItemId,
Token = job.Token,
TenantId = job.TenantId
};
jobEntity = db.Jobs.Add(jobEntity);
db.SaveChanges();
Debug.WriteLine("Saved job with id '{0}'", jobEntity.Id);
return(ResponseMessage(ODataControllerHelper.ResponseCreated(this, jobEntity)));
}
catch (Exception e)
{
Debug.WriteLine(String.Format("{0}: {1}\r\n{2}", e.Source, e.Message, e.StackTrace));
throw;
}
}
// POST: api/Core.svc/CalloutDefinitions
public async Task <IHttpActionResult> Post(CalloutDefinition calloutDefinition)
{
var declaringType = System.Reflection.MethodBase.GetCurrentMethod().DeclaringType;
var fn = String.Format("{0}:{1}",
declaringType.Namespace,
declaringType.Name);
if (!ModelState.IsValid)
{
Debug.WriteLine("CalloutDefinition to be created has invalid ModelState.");
return(BadRequest(ModelState));
}
try
{
Debug.WriteLine(fn);
var identity = CurrentUserDataProvider.GetIdentity(TenantId);
var permissionId = CreatePermissionId("CanCreate");
if (!identity.Permissions.Contains(permissionId))
{
return(StatusCode(HttpStatusCode.Forbidden));
}
if (null == calloutDefinition)
{
var errorMsg = "CalloutDefinition to be created contains invalid data.";
Debug.WriteLine(errorMsg);
return(BadRequest(errorMsg));
}
Debug.WriteLine("Saving new CalloutDefinition...");
var calloutDefinitionEntity = new CalloutDefinition()
{
Created = DateTimeOffset.Now,
CreatedBy = identity.Username,
CalloutType = calloutDefinition.CalloutType,
Tid = identity.Tid,
TenantId = calloutDefinition.TenantId,
EntityType = calloutDefinition.EntityType,
EntityId = calloutDefinition.EntityId,
Condition = calloutDefinition.Condition,
Parameters = calloutDefinition.Parameters
};
calloutDefinitionEntity = db.CalloutDefinitions.Add(calloutDefinitionEntity);
db.SaveChanges();
Debug.WriteLine("Saved CalloutDefinition with id '{0}'", calloutDefinitionEntity.Id);
return(ResponseMessage(ODataControllerHelper.ResponseCreated(this, calloutDefinitionEntity)));
}
catch (Exception e)
{
Debug.WriteLine(String.Format("{0}: {1}\r\n{2}", e.Source, e.Message, e.StackTrace));
throw;
}
}
public void PostStateChangeLockForUserWithCreatePermissionCreatesEntityAndReturnsCreated()
{
StateChangeLock createdEntity = null;
Mock.Arrange(() => ODataControllerHelper.ResponseCreated(
Arg.IsAny <ODataController>(), Arg.IsAny <StateChangeLock>(),
Arg.IsAny <String>())).Returns(new HttpResponseMessage(HttpStatusCode.Created));
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String> {
STATE_CHANGE_LOCK_CREATE_PERMISSION
},
Username = CURRENT_USER_ID,
Tid = TENANT_ID
})
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.StateChangeLocks.Add(Arg.IsAny <StateChangeLock>()))
.IgnoreInstance()
.DoInstead((StateChangeLock j) => createdEntity = j)
.Returns((j) => j)
.MustBeCalled();
Mock.Arrange(() => _lifeCycleContext.SaveChanges())
.IgnoreInstance()
.MustBeCalled();
var actionResult = _stateChangeLocksController.Post(
new StateChangeLock
{
Id = 1,
CreatedBy = ANOTHER_USER_ID,
Modified = DateTimeOffset.Now,
ModifiedBy = CURRENT_USER_ID,
Tid = ANOTHER_TENANT_ID,
EntityId = ENTITY_ID
}).Result;
Assert.AreEqual(CURRENT_USER_ID, createdEntity.CreatedBy);
Assert.AreEqual(DateTimeOffset.Now.Date, createdEntity.Created.Date);
Assert.IsNull(createdEntity.ModifiedBy);
Assert.AreEqual(TENANT_ID, createdEntity.Tid);
Assert.AreEqual(ENTITY_ID, createdEntity.EntityId);
Assert.AreNotEqual(1, createdEntity.Id);
Assert.IsTrue(actionResult.GetType() == typeof(ResponseMessageResult));
var response = actionResult as ResponseMessageResult;
Assert.AreEqual(HttpStatusCode.Created, response.Response.StatusCode);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(_lifeCycleContext);
}
public void GetIdentityThrowsArgumentNullExceptionIfApplicationNameNotDefined()
{
Mock.Arrange(() => HttpContext.Current.User.Identity.Name)
.Returns(USERNAME)
.OccursOnce();
Mock.Arrange(() => ConfigurationManager.AppSettings)
.Returns(new NameValueCollection())
.OccursOnce();
ThrowsAssert.Throws <ArgumentNullException>(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
Mock.Assert(() => HttpContext.Current.User.Identity.Name);
Mock.Assert(() => ConfigurationManager.AppSettings);
}
public void DeleteCalloutDefinitionForUserWithoutDeletePermissionReturnsForbidden()
{
Mock.Arrange(() => CurrentUserDataProvider.GetIdentity(TENANT_ID))
.Returns(new Identity
{
Permissions = new List <String>(),
Username = CURRENT_USER_ID
})
.MustBeCalled();
var actionResult = _calloutDefinitionsController.Delete(1).Result;
AssertStatusCodeResult(actionResult, HttpStatusCode.Forbidden);
Mock.Assert(() => CurrentUserDataProvider.GetIdentity(TENANT_ID));
}
public void IsEntityOfUserForNonMatchingTidAndCreatedByReturnsFalse()
{
Assert.IsFalse(CurrentUserDataProvider.IsEntityOfUser(USERNAME, TENANT_ID,
new BaseEntity
{
CreatedBy = "Another",
Tid = TENANT_ID
}));
Assert.IsFalse(CurrentUserDataProvider.IsEntityOfUser(USERNAME, TENANT_ID,
new BaseEntity
{
CreatedBy = USERNAME,
Tid = Guid.NewGuid().ToString()
}));
}
