public void Creating_a_Model_should_return_the_object_with_expected_metatype_info_embedded(string metaTypeName, string displayName) {
using (var server = TestServer.Create<TestStartup>()) {
// arrange
var metaType = new MetaType { Name = metaTypeName, DisplayName = displayName, };
using (var session = Storage.GetAsyncSession()) {
session.StoreAsync(metaType).Wait();
session.SaveChangesAsync().Wait();
}
var model = new Model { };
var json = JsonConvert.SerializeObject(model, this.JsonConverter);
// act
var response =
server.CreateRequest("api/models/{0}".FormatString(metaTypeName))
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
// verify
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var result = response.Content.ReadAsStringAsync().Result;
var returnedModel = JsonConvert.DeserializeObject<Model>(result, this.JsonConverter);
Assert.Equal(metaType.Id, returnedModel._shurikenMeta.MetaTypeId);
Assert.Equal(metaType.Name, returnedModel._shurikenMeta.MetaTypeName);
Assert.Equal(metaType.DisplayName, returnedModel._shurikenMeta.MetaTypeDisplayName);
}
}
public void Enumerable_fields_should_not_contain_null_values() {
using (var server = TestServer.Create<TestStartup>()) {
// arrange
var schema = new MetaType { Name = "simple_schema" };
schema.Fields.Add(new EnumerableField { Name = "listOfStrings", EnumerableOf = new TextField() });
using (var session = Storage.GetAsyncSession()) {
session.StoreAsync(schema).Wait();
session.SaveChangesAsync().Wait();
}
// act
var model = new Model { };
model["listOfStrings"] = new object[] { null };
var json = JsonConvert.SerializeObject(model, this.JsonConverter);
var response =
server.CreateRequest("api/models/{0}".FormatString(schema.Name))
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
// verify
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var content = response.Content.ReadAsStringAsync().Result;
var result = JsonConvert.DeserializeObject<ApiError>(content);
Assert.Equal(ApiErrorCode.SchemaMismatch, result.ErrorCode);
}
}
protected virtual Model[] CreateModels(MetaType metaType, int max) {
var fixture = AutofixtureHelpers.CreateFixture();
var models =
fixture.Build<Model>()
.Without(m => m.Id)
.With
(model => model._shurikenMeta,
new Model.MetaData
{
MetaTypeId = metaType.Id,
MetaTypeName = metaType.Name,
MetaTypeDisplayName = metaType.DisplayName,
CreatedOn = DateTime.UtcNow,
LastModified = DateTime.UtcNow
})
.CreateMany(max)
.ToArray();
using (var session = Storage.GetAsyncSession()) {
foreach (var model in models) {
model.SaveAsync(model._shurikenMeta.MetaTypeName, session).Wait();
}
session.SaveChangesAsync().Wait();
}
return models;
}
public void Should_not_be_able_update_Models_with_fields_not_specified_on_the_MetaType(
string fieldName,
string fieldNameNotInSchema) {
using (var server = TestServer.Create<TestStartup>()) {
// arrange
var schema = new MetaType { Name = "simple_schema" };
var model = new Model { };
model[fieldName] = "Some Text";
schema.Fields.Add(new TextField { Name = fieldName });
using (var session = Storage.GetAsyncSession()) {
session.StoreAsync(schema).Wait();
model.SaveAsync(schema.Name, session).Wait();
session.SaveChangesAsync().Wait();
}
// act
model[fieldNameNotInSchema] = "Some Text";
var json = JsonConvert.SerializeObject(model, this.JsonConverter);
var response =
server.CreateRequest("api/models/{0}".FormatString(schema.Name))
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.SendAsync("PUT")
.Result;
// verify
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var content = response.Content.ReadAsStringAsync().Result;
var result = JsonConvert.DeserializeObject<ApiError>(content);
Assert.Equal(ApiErrorCode.SchemaMismatch, result.ErrorCode);
}
}
public void Should_not_be_able_create_a_model_without_all_fields_defined_on_MetaType(string[] fieldNames) {
using (var server = TestServer.Create<TestStartup>()) {
// arrange
var schema = new MetaType { Name = "simple_schema" };
foreach (var fieldName in fieldNames) {
schema.Fields.Add(new TextField { Name = fieldName });
}
using (var session = Storage.GetAsyncSession()) {
session.StoreAsync(schema).Wait();
session.SaveChangesAsync().Wait();
}
// act
var someFields = fieldNames.Take(3);
var model = new Model { };
foreach (var fieldName in someFields) {
model[fieldName] = "Some Text";
}
var json = JsonConvert.SerializeObject(model, this.JsonConverter);
var response =
server.CreateRequest("api/models/{0}".FormatString(schema.Name))
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
// verify
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var content = response.Content.ReadAsStringAsync().Result;
var result = JsonConvert.DeserializeObject<ApiError>(content);
Assert.Equal(ApiErrorCode.SchemaMismatch, result.ErrorCode);
}
}
public void MetaType_json_posted_should_be_the_same_as_document_stored_in_the_database() {
var metaTypeCreatedFromUI = new MetaType { Name = "some_meta_type", DisplayName = "Some Meta Type" };
metaTypeCreatedFromUI.Fields.Add(new BooleanField { Name = "SomeBoolField", DisplayName = "Some Boolean Field" });
var json = JsonConvert.SerializeObject(metaTypeCreatedFromUI, this.JsonSerializerSettings);
using (var server = TestServer.Create<TestStartup>()) {
var response =
server.CreateRequest("api/metatypes")
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var createdMetaType = JsonConvert.DeserializeObject<MetaType>
(response.Content.ReadAsStringAsync().Result, this.JsonSerializerSettings);
using (var session = Storage.GetAsyncSession()) {
var metaType = session.LoadAsync<MetaType>(createdMetaType.Id).Result;
Assert.Equal(metaTypeCreatedFromUI.Name, metaType.Name);
Assert.Equal(metaTypeCreatedFromUI.DisplayName, metaType.DisplayName);
Assert.Equal(metaTypeCreatedFromUI.Fields.First().Name, metaType.Fields.First().Name);
Assert.Equal(metaTypeCreatedFromUI.Fields.First().DisplayName, metaType.Fields.First().DisplayName);
Assert.Equal(metaTypeCreatedFromUI.Fields.First().GetType(), metaType.Fields.First().GetType());
}
}
}
public static IEnumerable<object[]> Data() {
var metaType = new MetaType { Name = "some_meta_type" };
metaType.Fields.Add(new BooleanField { Name = "Field1" });
metaType.Fields.Add(new BooleanField { Name = "field1" });
yield return new object[] { metaType };
metaType = new MetaType { Name = "some_meta_type" };
var obj = new ArbitraryObjectField { Name = "obj1" };
obj.Fields.Add(new BooleanField { Name = "Field1" });
obj.Fields.Add(new BooleanField { Name = "field1" });
metaType.Fields.Add(obj);
yield return new object[] { metaType };
metaType = new MetaType { Name = "some_meta_type" };
var obj1 = new ArbitraryObjectField { Name = "obj1" };
var obj2 = new ArbitraryObjectField { Name = "obj2" };
obj2.Fields.Add(new BooleanField { Name = "Field1" });
obj2.Fields.Add(new BooleanField { Name = "field1" });
obj1.Fields.Add(obj2);
metaType.Fields.Add(obj1);
yield return new object[] { metaType };
}
protected virtual MetaType CreateMetaType(string name) {
var metaType = new MetaType { Name = name };
using (var session = Storage.GetAsyncSession()) {
session.StoreAsync(metaType).Wait();
session.SaveChangesAsync().Wait();
metaType.CreateDefaultModelByMetaTypeIndexAsync().Wait();
}
return metaType;
}
public void Should_not_be_able_create_duplicate_field_names_on_any_object(MetaType metaType) {
var json = JsonConvert.SerializeObject(metaType, this.JsonSerializerSettings);
using (var server = TestServer.Create<TestStartup>()) {
var response =
server.CreateRequest("api/metatypes")
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
var result = JsonConvert.DeserializeObject<ApiError>(response.Content.ReadAsStringAsync().Result);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Equal(ApiErrorCode.DuplicateFieldName, result.ErrorCode);
}
}
public async Task<IHttpActionResult> UpdateMetaType(MetaType model) {
using (var session = Storage.GetAsyncSession()) {
var existing = await session.LoadAsync<MetaType>(model.Id);
if (existing.Name != model.Name) {
return this.ApiErrorResult(ApiErrorCode.CannotRenameMetaType);
}
session.Advanced.Evict(existing);
var fieldErrorCode = this.ValidateMetaTypeFieldNames(model.Fields);
if (fieldErrorCode.HasValue) return this.ApiErrorResult(fieldErrorCode.Value);
await session.StoreAsync(model);
await session.SaveChangesAsync();
}
return this.StatusCode(HttpStatusCode.NoContent);
}
public void Field_Names_should_be_alphanumeric_strings_with_no_spaces_and_less_than_151_characters(string fieldName) {
var metaType = new MetaType { Name = "some_meta_type" };
metaType.Fields.Add(new BooleanField { Name = fieldName });
var json = JsonConvert.SerializeObject(metaType, this.JsonSerializerSettings);
using (var server = TestServer.Create<TestStartup>()) {
var response =
server.CreateRequest("api/metatypes")
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
var result = JsonConvert.DeserializeObject<ApiError>(response.Content.ReadAsStringAsync().Result);
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
Assert.Equal(ApiErrorCode.InvalidFieldName, result.ErrorCode);
}
}
public void Creating_a_MetaType_should_return_the_object_with_an_Id_of_the_expected_convention() {
var metaType = new MetaType { Name = "some_meta_type" };
using (var server = TestServer.Create<TestStartup>()) {
var response =
server.CreateRequest("api/metatypes")
.And
(message =>
message.Content = new StringContent(JsonConvert.SerializeObject(metaType), Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var result = response.Content.ReadAsStringAsync().Result;
var createdMetaType = JsonConvert.DeserializeObject<MetaType>(result, this.JsonSerializerSettings);
Assert.Equal(string.Format(@"metatypes${0}", metaType.Name.ToLower()), createdMetaType.Id);
}
}
public void Should_not_be_able_to_create_models_with_ArbitraryObject_fields_N_levels_deep_with_an_empty_object_value(int n) {
using (var server = TestServer.Create<TestStartup>()) {
// arrange
var schema = new MetaType { Name = "simple_schema" };
var i = 0;
var fields = schema.Fields;
while (i < n) {
var obj = new ArbitraryObjectField { Name = "obj{0}".FormatString(i) };
fields.Add(obj);
fields = obj.Fields;
i++;
}
using (var session = Storage.GetAsyncSession()) {
session.StoreAsync(schema).Wait();
session.SaveChangesAsync().Wait();
}
// act
i = 0;
var model = new Model { };
var o = model as Dough;
while (i < n) {
var fieldName = "obj{0}".FormatString(i);
o[fieldName] = new Dough { };
o = o[fieldName] as Dough;
i++;
}
var json = JsonConvert.SerializeObject(model, this.JsonConverter);
var response =
server.CreateRequest("api/models/{0}".FormatString(schema.Name))
.And(message => message.Content = new StringContent(json, Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
// verify
Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
var content = response.Content.ReadAsStringAsync().Result;
var result = JsonConvert.DeserializeObject<ApiError>(content);
Assert.Equal(ApiErrorCode.SchemaMismatch, result.ErrorCode);
}
}
public void Creating_a_MetaType_should_create_an_Index_for_Models_of_the_MetaType_indexed_by_MetaTypeName(string metaTypeName) {
// arrange
using (var server = TestServer.Create<TestStartup>()) {
Storage.DocumentStore.Conventions.DefaultQueryingConsistency = ConsistencyOptions.AlwaysWaitForNonStaleResultsAsOfLastWrite;
var metaType = new MetaType { Name = metaTypeName };
// act
var response =
server.CreateRequest("api/metatypes")
.And
(message =>
message.Content = new StringContent(JsonConvert.SerializeObject(metaType), Encoding.UTF8, "application/json"))
.PostAsync()
.Result;
// verify
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var expectedIndexName = Storage.DefaultByMetaTypeNameIndexNameConvention.FormatString(metaTypeName);
var index = Storage.DocumentStore.DatabaseCommands.GetIndex(expectedIndexName);
Assert.NotNull(index);
}
}
public async Task<IHttpActionResult> CreateMetaType(MetaType model) {
try {
if (!this.ValidateAlphanumericString(model.Name, 1000, true)) return this.ApiErrorResult(ApiErrorCode.InvalidMetaTypeName);
var fieldErrorCode = this.ValidateMetaTypeFieldNames(model.Fields);
if (fieldErrorCode.HasValue) return this.ApiErrorResult(fieldErrorCode.Value);
using (var session = Storage.GetAsyncSession()) {
await session.StoreAsync(model);
await session.SaveChangesAsync();
await model.CreateDefaultModelByMetaTypeIndexAsync();
return this.Created(string.Empty, model);
}
}
//todo: implement a better way to enforce unique names for meta types
catch (ConcurrencyException e) {
if (e.Message.ToLowerInvariant()
== string.Format("put attempted on document 'metatypes${0}' using a non current etag", model.Name.ToLowerInvariant())) {
return this.ApiErrorResult
(ApiErrorCode.DuplicateMetaTypeName, "A MetaType with the name: {0} already exists", model.Name);
}
throw;
}
}
