public void TestSetJobLabel()
{
var request = JobRequestObject.CreateExportJob("test.nt");
request.Label = "My Export";
Assert.That(request, Has.Property("Label").EqualTo("My Export"));
}
public void TestCreateConsolidateJob()
{
var request = JobRequestObject.CreateConsolidateJob();
Assert.That(request, Has.Property("JobType").EqualTo("Consolidate"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string>()));
}
public void TestCreateExportJob()
{
var request = JobRequestObject.CreateExportJob("exportFile.nt");
Assert.That(request, Has.Property("JobType").EqualTo("Export"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string> {
{ "FileName", "exportFile.nt" }, { "GraphUri", null }, { "Format", RdfFormat.NQuads.MediaTypes[0] }
}));
request = JobRequestObject.CreateExportJob("exportFile.rdf", "http://some/graph/uri");
Assert.That(request, Has.Property("JobType").EqualTo("Export"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string> {
{ "FileName", "exportFile.rdf" }, { "GraphUri", "http://some/graph/uri" }, { "Format", RdfFormat.NQuads.MediaTypes[0] }
}));
request = JobRequestObject.CreateExportJob("exportFile.rdf", "http://some/graph/uri", RdfFormat.NTriples);
Assert.That(request, Has.Property("JobType").EqualTo("Export"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string> {
{ "FileName", "exportFile.rdf" }, { "GraphUri", "http://some/graph/uri" }, { "Format", RdfFormat.NTriples.MediaTypes[0] }
}));
Assert.That(() => JobRequestObject.CreateExportJob(null), Throws.TypeOf <ArgumentNullException>().With.Property("ParamName").EqualTo("exportFileName"));
Assert.That(() => JobRequestObject.CreateExportJob(""), Throws.TypeOf <ArgumentException>().With.Property("ParamName").EqualTo("exportFileName"));
Assert.That(() => JobRequestObject.CreateExportJob("foo", ""), Throws.TypeOf <ArgumentException>().With.Property("ParamName").EqualTo("graphUri"));
}
public void TestPostTransactionGraphJob()
{
// Setup
var brightstar = new Mock <IBrightstarService>();
var mockJobInfo = new Mock <IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("5678");
brightstar.Setup(
s =>
s.ExecuteTransaction("foo", "preconditions string", "delete patterns string", "insert triples string",
"http://update/graph/uri", false))
.Returns(mockJobInfo.Object)
.Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
var requestObject = JobRequestObject.CreateTransactionJob("preconditions string", "delete patterns string",
"insert triples string", "http://update/graph/uri");
// Execute
var response = app.Post("/foo/jobs", with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/5678"));
brightstar.Verify();
}
public void TestCreateUpdateStatisticsJob()
{
var request = JobRequestObject.CreateUpdateStatsJob();
Assert.That(request, Has.Property("JobType").EqualTo("UpdateStats"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string>()));
}
public void TestPostSnapshotJobWithDefaultCommitPoint()
{
TestValidPost("/foo/jobs", JobRequestObject.CreateSnapshotJob("bar", "Rewrite"),
(b, m) => b.Setup(s => s.CreateSnapshot("foo", "bar", PersistenceType.Rewrite, null))
.Returns(m.Object)
.Verifiable());
}
public ActionResult EditJobRequest(JobRequestObject model, string Save, string Close)
{
if (GlobalClass.SystemSession)
{
if (ModelState.IsValid)
{
DataReturn data = manage.UpdateMainData(model);
ViewBag.mess = data.mess;
if (data.flag == 1)
{
if (!string.IsNullOrEmpty(Save))
{
model = manage.GetJobrequestDetails(model.RequestKey);
}
else
{
return(RedirectToAction("Index", "Home"));
}
}
}
ViewBag.JobPriorityKey = new SelectList(db.JobType.Where(m => m.IsDelete == false).OrderBy(m => m.TName), "ID", "TName", model.JobPriorityKey);
ViewBag.TradeKey = new SelectList(db.Trade.Where(m => m.IsDelete == false).OrderBy(m => m.TName), "ID", "TName", model.TradeKey);
return(View(model));
}
else
{
Exception e = new Exception("Sorry, your Session has Expired");
return(View("Error", new HandleErrorInfo(e, "Home", "Logout")));
}
}
internal DataReturn UpdateMainData(JobRequestObject obj)
{
DataReturn model = new DataReturn();
try
{
JobRequest _job = db.JobRequest.Find(obj.RequestKey);
_job.LocationKey = obj.LocationKey;
_job.CustomerKey = GlobalClass.LoginUser.CustomerKey;
_job.CContactKey = obj.CContactKey;
_job.TradeKey = obj.TradeKey;
_job.JobPriorityKey = obj.JobPriorityKey;
_job.ServiceNeeded = obj.ServiceNeeded;
_job.ServiceNeededByOrOn = obj.ServiceNeededByOrOn;
_job.DNEamount = obj.DNEamount;
_job.SpecialNote = obj.SpecialNote;
_job.ServiceDate = obj.ServiceDate;
_job.ServiceByTime = obj.ServiceByTime;
_job.SVCLocationContact = obj.SVCLocationContact;
_job.SvcLocationContactPhone = obj.SvcLocationContactPhone;
_job.EntryDatetime = DateTime.Now;
_job.IsRequest = true;
db.SaveChanges();
model.flag = 1;
model.key = _job.RequestKey;
model.mess = "Data has been Update successfully.";
}
catch (Exception ex)
{
model.flag = 0;
model.mess = ex.Message.ToString();
}
return(model);
}
public void TestPostTransactionRequiresTransactionalUpdatePermission()
{
AssertPermissionRequired(
JobRequestObject.CreateTransactionJob(new UpdateTransactionData
{
ExistencePreconditions = "pre",
NonexistencePreconditions = "nexist",
DeletePatterns = "del",
InsertData = "ins",
DefaultGraphUri = null
}, null), StorePermissions.TransactionUpdate);
}
public void TestPostSnapshotJob()
{
TestValidPost("/foo/jobs", JobRequestObject.CreateSnapshotJob("bar", "AppendOnly", 123),
(b, m) =>
{
var mockCommitPoint = new Mock <ICommitPointInfo>();
b.Setup(s => s.GetCommitPoint("foo", 123)).Returns(mockCommitPoint.Object);
b.Setup(s => s.CreateSnapshot("foo", "bar", PersistenceType.AppendOnly, It.IsAny <ICommitPointInfo>()))
.Returns(m.Object)
.Verifiable();
});
}
public void TestCreateSparqlUpdateJob()
{
var request = JobRequestObject.CreateSparqlUpdateJob("expression");
Assert.That(request, Has.Property("JobType").EqualTo("SparqlUpdate"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string> {
{ "UpdateExpression", "expression" }
}));
Assert.That(() => JobRequestObject.CreateSparqlUpdateJob(null), Throws.TypeOf <ArgumentNullException>().With.Property("ParamName").EqualTo("updateExpression"));
Assert.That(() => JobRequestObject.CreateSparqlUpdateJob(""), Throws.TypeOf <ArgumentException>().With.Property("ParamName").EqualTo("updateExpression"));
Assert.That(() => JobRequestObject.CreateSparqlUpdateJob(" "), Throws.TypeOf <ArgumentException>().With.Property("ParamName").EqualTo("updateExpression"));
}
public void TestPostRepeatTransactionJob()
{
TestValidPost("/foo/jobs", JobRequestObject.CreateRepeatTransactionJob(Guid.NewGuid()),
(b, m) =>
{
var mockTransaction = new Mock <ITransactionInfo>();
b.Setup(s => s.GetTransaction("foo", It.IsAny <Guid>()))
.Returns(mockTransaction.Object)
.Verifiable();
b.Setup(s => s.ReExecuteTransaction("foo", mockTransaction.Object))
.Returns(m.Object)
.Verifiable();
});
}
public void TestCreateTransactionJob()
{
var request = JobRequestObject.CreateTransactionJob("preconditions", "deletes", "inserts");
Assert.That(request, Has.Property("JobType").EqualTo("Transaction"));
Assert.That(request,
Has.Property("JobParameters")
.EqualTo(new Dictionary <string, string>
{
{ "Preconditions", "preconditions" },
{ "Deletes", "deletes" },
{ "Inserts", "inserts" },
{ "DefaultGraphUri", null }
}));
}
public ActionResult EditJobRequest(Guid id)
{
if (GlobalClass.SystemSession)
{
JobRequestObject model = new JobRequestObject();
model = manage.GetJobrequestDetails(id);
ViewBag.JobPriorityKey = new SelectList(db.JobType.Where(m => m.IsDelete == false).OrderBy(m => m.TName), "ID", "TName", model.JobPriorityKey);
ViewBag.TradeKey = new SelectList(db.Trade.Where(m => m.IsDelete == false).OrderBy(m => m.TName), "ID", "TName", model.TradeKey);
return(View(model));
}
else
{
Exception e = new Exception("Sorry, your Session has Expired");
return(View("Error", new HandleErrorInfo(e, "Home", "Logout")));
}
}
public void TestPostTransactionJob()
{
// Setup
var brightstar = new Mock <IBrightstarService>();
var mockJobInfo = new Mock <IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("5678");
brightstar.Setup(
s =>
s.ExecuteTransaction("foo", It.Is <UpdateTransactionData>(txn =>
txn.ExistencePreconditions ==
"preconditions string" &&
txn.NonexistencePreconditions ==
"nonexistence preconditions string" &&
txn.DeletePatterns == "delete patterns string" &&
txn.InsertData == "insert triples string" &&
txn.DefaultGraphUri == null), false,
"TransactionJob"))
.Returns(mockJobInfo.Object)
.Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
var requestObject = JobRequestObject.CreateTransactionJob(
new UpdateTransactionData
{
ExistencePreconditions = "preconditions string",
NonexistencePreconditions = "nonexistence preconditions string",
DeletePatterns = "delete patterns string",
InsertData = "insert triples string",
DefaultGraphUri = null
}, "TransactionJob");
// Execute
var response = app.Post("/foo/jobs", with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/5678"));
brightstar.Verify();
}
internal JobRequestObject GetJobrequestDetails(Guid requestKey)
{
JobRequest j = db.JobRequest.Find(requestKey);
JobRequestObject model = new JobRequestObject();
model.RequestKey = j.RequestKey;
if (j.ServiceNeededByOrOn == null)
{
model.ServiceNeededByOrOn = "Service Needed by";
}
else
{
model.ServiceNeededByOrOn = j.ServiceNeededByOrOn;
}
model.LocationKey = j.LocationKey;
model.LocationName = j.Location.Lname;
model.CustomerKey = j.CustomerKey;
model.CustomerName = j.Customer.Cname;
model.CContactKey = j.CContactKey;
model.ContactName = j.CustomerContact.Cname;
model.LocationContactAddress = j.Location.Address;
model.LocationContactCityName = j.Location.CityList.CityName;
model.LocationContactStateName = j.Location.StateList.StateName;
model.LocationContactZipCode = j.Location.ZIPcode;
model.TradeKey = j.TradeKey;
model.TradeName = j.Trade.TName;
model.JobPriorityKey = j.JobPriorityKey;
model.JobPriority = j.JobType.TName;
model.ServiceNeeded = j.ServiceNeeded;
model.DNEamount = j.DNEamount;
model.SpecialNote = j.SpecialNote;
model.ServiceDate = j.ServiceDate;
model.ServiceByTime = j.ServiceByTime;
model.SVCLocationContact = j.SVCLocationContact;
model.SvcLocationContactPhone = j.SvcLocationContactPhone;
model.EntryDatetime = j.EntryDatetime;
model.JobRequestAttachmentsObjectList = new List <JobRequestAttachmentsObject>();
model.JobRequestAttachmentsObjectList = GetJobRequestAttachmentList(requestKey);
return(model);
}
public void TestCreateJobWithLabelInConstructor()
{
// Consolidate
var consolidateRequest = JobRequestObject.CreateConsolidateJob(label: "ConsolidationJob");
Assert.That(consolidateRequest, Has.Property("Label").EqualTo("ConsolidationJob"));
// export
var exportRequest = JobRequestObject.CreateExportJob("export.nt", label: "ExportJob");
Assert.That(exportRequest, Has.Property("Label").EqualTo("ExportJob"));
// import
var importRequest = JobRequestObject.CreateImportJob("import.nt", label: "ImportJob");
Assert.That(importRequest, Has.Property("Label").EqualTo("ImportJob"));
// repeat transaction
var repeatRequest = JobRequestObject.CreateRepeatTransactionJob(Guid.Empty, label: "RepeatJob");
Assert.That(repeatRequest, Has.Property("Label").EqualTo("RepeatJob"));
// Snapshot
var snapshotRequest = JobRequestObject.CreateSnapshotJob("storeToSnapshot", PersistenceType.AppendOnly, label: "SnapshotJob");
Assert.That(snapshotRequest, Has.Property("Label").EqualTo("SnapshotJob"));
// Sparql Update
var sparqlUpdateRequest = JobRequestObject.CreateSparqlUpdateJob("update expression", label: "SparqlUpdateJob");
Assert.That(sparqlUpdateRequest, Has.Property("Label").EqualTo("SparqlUpdateJob"));
// Transaction
var transactionJob = JobRequestObject.CreateTransactionJob(
new UpdateTransactionData
{
ExistencePreconditions = "precon",
NonexistencePreconditions = "nexist",
DeletePatterns = "delete",
InsertData = "insert",
DefaultGraphUri = null,
}, "TransactionJob");
Assert.That(transactionJob, Has.Property("Label").EqualTo("TransactionJob"));
// Update Statistics
var updateStatsRequest = JobRequestObject.CreateUpdateStatsJob(label: "UpdateStats");
Assert.That(updateStatsRequest, Has.Property("Label").EqualTo("UpdateStats"));
}
public void TestCreateImportJob()
{
var request = JobRequestObject.CreateImportJob("importFile.nt");
Assert.That(request, Has.Property("JobType").EqualTo("Import"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string> {
{ "FileName", "importFile.nt" }, { "DefaultGraphUri", null }
}));
request = JobRequestObject.CreateImportJob("importFile.rdf", "http://some/graph/uri");
Assert.That(request, Has.Property("JobType").EqualTo("Import"));
Assert.That(request, Has.Property("JobParameters").EqualTo(new Dictionary <string, string> {
{ "FileName", "importFile.rdf" }, { "DefaultGraphUri", "http://some/graph/uri" }
}));
Assert.That(() => JobRequestObject.CreateImportJob(null), Throws.TypeOf(typeof(ArgumentNullException)).With.Property("ParamName").EqualTo("importFileName"));
Assert.That(() => JobRequestObject.CreateImportJob(""), Throws.TypeOf(typeof(ArgumentException)).With.Property("ParamName").EqualTo("importFileName"));
Assert.That(() => JobRequestObject.CreateImportJob("foo", ""), Throws.TypeOf(typeof(ArgumentException)).With.Property("ParamName").EqualTo("defaultGraphUri"));
}
private void AssertPermissionRequired(JobRequestObject jobRequest, StorePermissions witheldPermission)
{
var brightstar = new Mock <IBrightstarService>();
var permissionsService = new Mock <AbstractStorePermissionsProvider>();
permissionsService.Setup(s => s.GetStorePermissions(null, "foo"))
.Returns(StorePermissions.All ^ witheldPermission)
.Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object, permissionsService.Object));
// Execute
var response = app.Post("/foo/jobs", with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(jobRequest);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
permissionsService.Verify();
}
public void TestPostExportGraphJob()
{
var brightstar = new Mock <IBrightstarService>();
var mockJobInfo = new Mock <IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("2345");
brightstar.Setup(s => s.StartExport("foo", "export.nt", "http://some/graph/uri")).Returns(mockJobInfo.Object).Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
var requestObject = JobRequestObject.CreateExportJob("export.nt", "http://some/graph/uri");
// Execute
var response = app.Post("foo/jobs", with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/2345"));
brightstar.Verify();
}
private static void TestValidPost(string toUrl, JobRequestObject requestObject, Action <Mock <IBrightstarService>, Mock <IJobInfo> > brightstarSetup)
{
var mockJobInfo = new Mock <IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("ABCD");
var brightstar = new Mock <IBrightstarService>();
brightstarSetup(brightstar, mockJobInfo);
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
// Execute
var response = app.Post(toUrl, with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/ABCD"));
brightstar.Verify();
}
public void TestPostImportJob()
{
var brightstar = new Mock <IBrightstarService>();
var mockJobInfo = new Mock <IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("3456");
brightstar.Setup(s => s.StartImport("foo", "import.nt", null, "ImportJob")).Returns(mockJobInfo.Object).Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
var requestObject = JobRequestObject.CreateImportJob("import.nt", label: "ImportJob");
// Execute
var response = app.Post("/foo/jobs", with =>
{
with.Accept(new MediaRange("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/3456"));
brightstar.Verify();
}
public void TestPostExportJob()
{
var brightstar = new Mock <IBrightstarService>();
var mockJobInfo = new Mock <IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("2345");
brightstar.Setup(s => s.StartExport("foo", "export.nt", null, It.Is <RdfFormat>(r => r.DefaultExtension.Equals(RdfFormat.NQuads.DefaultExtension)), "ExportJob")).Returns(mockJobInfo.Object).Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
var requestObject = JobRequestObject.CreateExportJob("export.nt", label: "ExportJob");
// Execute
var response = app.Post("foo/jobs", with =>
{
with.Accept(new MediaRange("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/2345"));
brightstar.Verify();
}
public void TestPostSparqlUpdateJob()
{
// Setup
var brightstar = new Mock <IBrightstarService>();
var mockJobInfo = new Mock <IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("4567");
brightstar.Setup(s => s.ExecuteUpdate("foo", "update expression", false)).Returns(mockJobInfo.Object).Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
var requestObject = JobRequestObject.CreateSparqlUpdateJob("update expression");
// Execute
var response = app.Post("/foo/jobs", with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/4567"));
brightstar.Verify();
}
public void TestCreateTransactionJob()
{
var request = JobRequestObject.CreateTransactionJob(new UpdateTransactionData
{
ExistencePreconditions = "preconditions",
NonexistencePreconditions = "nonexistencePreconditions",
DeletePatterns = "deletes",
InsertData = "inserts",
DefaultGraphUri = null
}, null);
Assert.That(request, Has.Property("JobType").EqualTo("Transaction"));
Assert.That(request,
Has.Property("JobParameters")
.EqualTo(new Dictionary <string, string>
{
{ "Preconditions", "preconditions" },
{ "NonexistencePreconditions", "nonexistencePreconditions" },
{ "Deletes", "deletes" },
{ "Inserts", "inserts" },
{ "DefaultGraphUri", null }
}));
}
public void TestPostConsolidateJobRequiresAdminPermissions()
{
AssertPermissionRequired(JobRequestObject.CreateConsolidateJob(), StorePermissions.Admin);
}
public void TestPostSnapshotJobRequiresAdminPermissions()
{
AssertPermissionRequired(JobRequestObject.CreateSnapshotJob("bar", "AppendOnly", 123), StorePermissions.Admin);
AssertPermissionRequired(JobRequestObject.CreateSnapshotJob("bletch", "Rewrite"), StorePermissions.Admin);
}
public void TestPostRepeatTransactionJobRequiresAdminPermissions()
{
AssertPermissionRequired(JobRequestObject.CreateRepeatTransactionJob(Guid.Empty), StorePermissions.Admin);
}
private void AssertPermissionRequired(JobRequestObject jobRequest, StorePermissions witheldPermission)
{
var brightstar = new Mock<IBrightstarService>();
var permissionsService = new Mock<AbstractStorePermissionsProvider>();
permissionsService.Setup(s => s.GetStorePermissions(null, "foo"))
.Returns(StorePermissions.All ^ witheldPermission)
.Verifiable();
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object, permissionsService.Object));
// Execute
var response = app.Post("/foo/jobs", with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(jobRequest);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Unauthorized));
permissionsService.Verify();
}
public void TestPostUpdateStatsJobRequiresAdminPermissions()
{
AssertPermissionRequired(JobRequestObject.CreateUpdateStatsJob(), StorePermissions.Admin);
}
public void TestPostUpdateStatsJob()
{
TestValidPost("/foo/jobs", JobRequestObject.CreateUpdateStatsJob(),
(b, m) => b.Setup(s => s.UpdateStatistics("foo")).Returns(m.Object).Verifiable());
}
private static void TestValidPost(string toUrl, JobRequestObject requestObject, Action<Mock<IBrightstarService>, Mock<IJobInfo>> brightstarSetup)
{
var mockJobInfo = new Mock<IJobInfo>();
mockJobInfo.Setup(s => s.JobId).Returns("ABCD");
var brightstar = new Mock<IBrightstarService>();
brightstarSetup(brightstar, mockJobInfo);
var app = new Browser(new FakeNancyBootstrapper(brightstar.Object));
// Execute
var response = app.Post(toUrl, with =>
{
with.Accept(MediaRange.FromString("application/json"));
with.JsonBody(requestObject);
});
// Assert
Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.Created));
Assert.That(response.Headers["Location"], Is.EqualTo("foo/jobs/ABCD"));
brightstar.Verify();
}
