public async Task <OperatingStatus> CreateAsync(Category category)
{
if (category == null)
{
return(OperatingStatus.InvalidArgument);
}
else if (category.CheckEmptyFields())
{
return(OperatingStatus.EmptyArgument);
}
return(await _repo.CreateAsync(category).ConfigureAwait(false));
}
public async void CreateAsync_GivenSaveThrowsException_ReturnsDbUpdateException()
{
var contextMock = new Mock <ICrowdSparkContext>();
contextMock.Setup(c => c.Categories.Add(It.IsAny <Category>()));
contextMock.Setup(c => c.SaveChangesAsync(default(CancellationToken))).ThrowsAsync(new System.Data.DataException("Error", default(Exception)));
using (var repo = new CategoryRepository(contextMock.Object))
{
await Assert.ThrowsAsync <DbUpdateException>(() => repo.CreateAsync(new CategoryCreateDTO()
{
}));
}
}
public async void CreateAsync_CheckIfCategoryExists()
{
var cat = new CategoryCreateDTO
{
Name = "Programming"
};
using (var repository = new CategoryRepository(context))
{
var id = await repository.CreateAsync(cat);
Assert.NotNull(await context.Categories.FindAsync(id));
}
}
public async void DeleteAsync_FalseIfNotExists()
{
var cat = new CategoryCreateDTO
{
Name = "Programming"
};
using (var repository = new CategoryRepository(context))
{
var id = await repository.CreateAsync(cat);
Assert.False(await repository.DeleteAsync(id + 1));
}
}
public async void FindAsync_Trueifcaseincorrect()
{
var cat = new CategoryCreateDTO
{
Name = "Programming"
};
using (var repository = new CategoryRepository(context))
{
var id = await repository.CreateAsync(cat);
Assert.NotNull(await repository.FindAsync("programming"));
}
}
public async Task OneTimeSetup()
{
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
categoryRepository = new CategoryRepository(ConnectionFactorySetup.ConnectionFactory);
category = await categoryRepository.CreateAsync(new Category { HourId = hour.Id, CategoryType = CategoryType.InfrastructurePerformance });
category = await categoryRepository.ReadAsync(category.Id);
category.CategoryType = CategoryType.Uptime;
await categoryRepository.UpdateAsync(category);
}
public async void DeleteAsync_TrueifExists_ActuallyDeletes()
{
var cat = new CategoryCreateDTO
{
Name = "Programming"
};
using (var repository = new CategoryRepository(context))
{
var id = await repository.CreateAsync(cat);
Assert.True(await repository.DeleteAsync(id));
Assert.Equal(0, await context.Categories.CountAsync());
}
}
public async Task MetricData_ReadByCategoryScoreAsync_Success()
{
//Arrange
var repo = new MetricDataRepository(ConnectionFactorySetup.ConnectionFactory);
var categoryScoreRepo = new CategoryScoreRepository(ConnectionFactorySetup.ConnectionFactory);
var categoryRepo = new CategoryRepository(ConnectionFactorySetup.ConnectionFactory);
var category = await categoryRepo.CreateAsync(new Category { HourId = hour.Id, CategoryType = CategoryType.Uptime });
var categoryScore = await categoryScoreRepo.CreateAsync(new CategoryScore { CategoryId = category.Id, Category = category });
//Act
var result = await repo.ReadByCategoryScoreAsync(categoryScore);
//Assert
Assert.That(result.Any(r => r.Id == metricData.Id), Is.True);
}
public async void CreateManyCategories_GetThemBackSorted()
{
var list = new List <CategoryCreateDTO>();
list.Add(new CategoryCreateDTO {
Name = "Programming"
});
list.Add(new CategoryCreateDTO {
Name = "Mechanical"
});
list.Add(new CategoryCreateDTO
{
Name = "Sport"
});
list.Add(new CategoryCreateDTO
{
Name = "Outlife"
});
using (var repository = new CategoryRepository(context))
{
var id_list = new HashSet <int>();
for (int i = 0; i < list.Count; i++)
{
id_list.Add(await repository.CreateAsync(list[i]));
}
Assert.Equal(id_list.Count, list.Count);
// Check to see if we get categories sorted.
var sorted_list = await repository.ReadAsync();
var listToCheck = new List <CategoryDTO>(sorted_list);
Assert.Equal(list.Count, sorted_list.Count);
list.Sort((CategoryCreateDTO x, CategoryCreateDTO y) => x.Name.CompareTo(y.Name));
for (int i = 0; i < list.Count; i++)
{
Assert.Equal(list[i].Name, listToCheck[i].Name);
}
}
}
public async void FindWildcardAsync_EmptyCollection()
{
var list = new List <CategoryCreateDTO>();
list.Add(new CategoryCreateDTO
{
Name = "Programming"
});
list.Add(new CategoryCreateDTO
{
Name = "Mechanical"
});
list.Add(new CategoryCreateDTO
{
Name = "Sport"
});
list.Add(new CategoryCreateDTO
{
Name = "Outlife"
});
using (var repository = new CategoryRepository(context))
{
var id_list = new HashSet <int>();
for (int i = 0; i < list.Count; i++)
{
id_list.Add(await repository.CreateAsync(list[i]));
}
Assert.Equal(id_list.Count, list.Count);
var sorted_list = await repository.FindWildcardAsync("Arduino");
var listToCheck = new List <CategoryDTO>(sorted_list);
Assert.Equal(0, listToCheck.Count);
sorted_list = await repository.FindWildcardAsync("e");
listToCheck = new List <CategoryDTO>(sorted_list);
Assert.True(listToCheck.Count > 0);
}
}
public async Task OneTimeSetup()
{
var hourRepo = new HourRepository(ConnectionFactorySetup.ConnectionFactory);
var categoryRepo = new CategoryRepository(ConnectionFactorySetup.ConnectionFactory);
hour = await hourRepo.CreateAsync(new Hour { HourTimeStamp = DateTime.Now });
category = await categoryRepo.CreateAsync(new Category { HourId = hour.Id, CategoryType = CategoryType.Uptime });
categoryScoreRepository = new CategoryScoreRepository(ConnectionFactorySetup.ConnectionFactory);
categoryScore = await categoryScoreRepository.CreateAsync(new CategoryScore { CategoryId = category.Id, Score = 100.0m });
categoryScore.Score = 75.0m;
await categoryScoreRepository.UpdateAsync(categoryScore);
categoryScore = await categoryScoreRepository.ReadAsync(categoryScore.Id);
}
public async void UpdateAsync_GivenCorrectId_ReturnsFalse()
{
var cat = new CategoryCreateDTO
{
Name = "Programming"
};
var catup = new CategoryDTO
{
Id = 2,
Name = "Sports"
};
using (var repository = new CategoryRepository(context))
{
var id = await repository.CreateAsync(cat);
Assert.False(await repository.UpdateAsync(catup));
}
}
public async Task CreateCategory()
{
//Arrange
var newCategory = new Category()
{
Id = 99,
Code = "099",
Name = "Lenovo Thinkpad"
};
//Act
await _sut.CreateAsync(newCategory);
//Assert
var category = await _context.Categories.FirstOrDefaultAsync(x => x.Id == newCategory.Id);
category.Should().BeAssignableTo <Category>();
category.Should().NotBeNull();
category.Id.Should().Be(newCategory.Id);
}
// POST: api/Categories
public async Task <int> Post([FromBody] string task)
{
int records;
try
{
records = await repository.CreateAsync(JsonConvert.DeserializeObject <Category>(task));
}
catch (SqlException ex)
{
throw ex;
}
catch (Exception ex)
{
throw ex;
}
return(records);
}
public async Task CreateCategory()
{
_createdCategory = await _categoryRepository.CreateAsync(new Category { Name = "test-category" });
Assert.IsNotNull(_createdCategory);
}
public async Task CanCreateAsync()
{
await _repository.CreateAsync(_category);
Assert.Single(Collection);
}
