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; } }