public IHttpActionResult UploadResource()
{
//throw new Exception("forced error");
HttpResponseMessage response = new HttpResponseMessage();
var httpRequest = HttpContext.Current.Request;
DigitalResource myResource = null;
//DigitalResource resource = null;
//if (albumID != null)
{
System.Web.HttpFileCollection files = System.Web.HttpContext.Current.Request.Files;
Repository.ResourceRepository repository = new Repository.ResourceRepository();
ReferenceRepository refRepository = new ReferenceRepository();
UserRepository ur = new UserRepository();
string currentUser = User.Identity.Name;
User user = ur.Get(currentUser);
//Album album = repository.GetAlbums(x => x.Name == albumID).FirstOrDefault();
//for (int i = 0; i < files.Count; i++)
{
HttpPostedFile file = files[0];
string name = file.FileName;
using (Stream fileStream = file.InputStream)
{
myResource = repository.SaveOrGet(refRepository, user, fileStream, name);
}
}
}
return(Ok(myResource));
}
public static async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "get", "post", Route = null)] HttpRequest req, TraceWriter log)
{
log.Info("Add Sport");
var requestBody = new StreamReader(req.Body).ReadToEnd();
var sport = JsonConvert.DeserializeObject <SportLocationView>(requestBody);
var connectionString = Environment.GetEnvironmentVariable("SQLAZURECONNSTR_Nova2018CodeCampContext");
try
{
var options = new DbContextOptionsBuilder <Nova2018CodeCampContext>()
.UseSqlServer(connectionString)
.Options;
var context = new Nova2018CodeCampContext(options);
IReferenceRepository repository = new ReferenceRepository(context);
var worker = new ReferenceWorker(repository);
var actual = await worker.AddSport(sport);
return(new OkObjectResult(actual.ToString()));
}
catch (Exception e)
{
log.Error(e.ToString());
return(new BadRequestObjectResult(e.Message));
}
}
public void Setup()
{
if (_referenceRepository is null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_file = Substitute.For <FileBase>();
_file.ReadAllText(_commitMessagePath, _encoding).Returns(_commitMessage);
_file.ReadAllText(_mergeMessagePath, _encoding).Returns(_mergeMessage);
_directory = Substitute.For <DirectoryBase>();
var path = Substitute.For <PathBase>();
path.Combine(Arg.Any <string>(), Arg.Any <string>()).Returns(x => Path.Combine((string)x[0], (string)x[1]));
_fileSystem = Substitute.For <IFileSystem>();
_fileSystem.File.Returns(_file);
_fileSystem.Directory.Returns(_directory);
_fileSystem.Path.Returns(path);
_manager = new CommitMessageManager(_workingDirGitDir, _encoding, _fileSystem, overriddenCommitMessage: null);
}
public void SetUp()
{
if (_referenceRepository == null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_commands = new GitUICommands(_referenceRepository.Module);
// mock git executable
_gitExecutable = new MockExecutable();
typeof(GitModule).GetField("_gitExecutable", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(_commands.Module, _gitExecutable);
var cmdRunner = new GitCommandRunner(_gitExecutable, () => GitModule.SystemEncoding);
typeof(GitModule).GetField("_gitCommandRunner", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(_commands.Module, cmdRunner);
var uiCommandsSource = Substitute.For <IGitUICommandsSource>();
uiCommandsSource.UICommands.Returns(x => _commands);
_commitInfo = new GitUI.CommitInfo.CommitInfo
{
UICommandsSource = uiCommandsSource
};
}
public void SetUp()
{
if (_referenceRepository == null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_commands = new GitUICommands(_referenceRepository.Module);
// mock git executable
_gitExecutable = new MockExecutable();
typeof(GitModule).GetField("_gitExecutable", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(_commands.Module, _gitExecutable);
var cmdRunner = new GitCommandRunner(_gitExecutable, () => GitModule.SystemEncoding);
typeof(GitModule).GetField("_gitCommandRunner", BindingFlags.Instance | BindingFlags.NonPublic)
.SetValue(_commands.Module, cmdRunner);
var uiCommandsSource = Substitute.For <IGitUICommandsSource>();
uiCommandsSource.UICommands.Returns(x => _commands);
// the following assignment of _commitInfo.UICommandsSource will already call this command
_gitExecutable.StageOutput("for-each-ref --sort=-taggerdate --format=\"%(refname)\" refs/tags/", "");
_commitInfo = new GitUI.CommitInfo.CommitInfo
{
UICommandsSource = uiCommandsSource
};
}
public void SetUp()
{
_remoteReferenceRepository ??= new ReferenceRepository();
// we will be modifying .git/config and need to completely reset each time
_referenceRepository = new ReferenceRepository();
_referenceRepository.Module.AddRemote(RemoteName, _remoteReferenceRepository.Module.WorkingDir);
_referenceRepository.Fetch(RemoteName);
_commands = new GitUICommands(_referenceRepository.Module);
_referenceRepository.CreateCommit("Commit1", "Commit1");
_referenceRepository.CreateBranch("Branch1", _referenceRepository.CommitHash);
_referenceRepository.CreateTag("Branch1", _referenceRepository.CommitHash);
_referenceRepository.CreateCommit("Commit2", "Commit2");
_referenceRepository.CreateBranch("Branch2", _referenceRepository.CommitHash);
_referenceRepository.CreateCommit("head commit");
var composition = TestComposition.Empty
.AddParts(typeof(MockWindowsJumpListManager))
.AddParts(typeof(MockRepositoryDescriptionProvider))
.AddParts(typeof(MockAppTitleGenerator));
ExportProvider mefExportProvider = composition.ExportProviderFactory.CreateExportProvider();
ManagedExtensibility.SetTestExportProvider(mefExportProvider);
}
public void Setup()
{
if (_referenceRepository is null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_uiCommands = new GitUICommands(_referenceRepository.Module);
_module = Substitute.For <IGitModule>();
_module.GetCurrentRemote().ReturnsForAnyArgs("origin");
_module.GetCurrentCheckout().ReturnsForAnyArgs(ObjectId.WorkTreeId);
_exampleScript = ScriptManager.GetScript(_keyOfExampleScript);
_exampleScript.AskConfirmation = false; // avoid any dialogs popping up
_exampleScript.RunInBackground = true; // avoid any dialogs popping up
if (_miRunScript is null)
{
throw new InvalidOperationException();
}
}
internal DataErrorRoutingEngine(DataErrorService service)
{
dataErrorService = service;
referenceRepository = new ReferenceRepository();
referenceService = new ReferenceService();
correctiveActionService = new CorrectiveActionService();
dataErrorRepository = service.repository;
}
public void SetUp()
{
_referenceRepository = new ReferenceRepository();
_initialCommit = _referenceRepository.CommitHash;
_referenceRepository.CreateCommit("head commit");
_headCommit = _referenceRepository.CommitHash;
_commands = new GitUICommands(_referenceRepository.Module);
}
public AboutController(IPageDataContextRetriever dataRetriever,
IPageAttachmentUrlRetriever pageAttachmentUrlRetriever,
AboutUsRepository aboutUsRepository,
ReferenceRepository referenceRepository)
{
this.dataRetriever = dataRetriever;
this.pageAttachmentUrlRetriever = pageAttachmentUrlRetriever;
this.aboutUsRepository = aboutUsRepository;
this.referenceRepository = referenceRepository;
}
public void GetTimeByTimeId_When_executed_return_Programs_for_id(int timeId, string timeData)
{
// Insert seed data into the database using one instance of the context
InitializeSports();
LoadSports();
var repository = new ReferenceRepository(_context);
var actual = repository.GetTimeByTimeId(timeId);
Assert.Equal(timeData, actual.Result.TimeHour);
}
public void GetTeamByTeamId_When_executed_return_Teams_for_id(int teamId, string teamName)
{
// Insert seed data into the database using one instance of the context
InitializeSports();
LoadSports();
var repository = new ReferenceRepository(_context);
var actual = repository.GetTeamByTeamId(teamId);
Assert.Equal(teamName, actual.Result.Name);
}
public HomeController(IPageDataContextRetriever pageDataContextRetriever,
IPageUrlRetriever pageUrlRetriever,
IPageAttachmentUrlRetriever attachmentUrlRetriever,
HomeRepository homeSectionRepository,
ReferenceRepository referenceRepository)
{
this.pageDataContextRetriever = pageDataContextRetriever;
this.homeSectionRepository = homeSectionRepository;
this.referenceRepository = referenceRepository;
this.pageUrlRetriever = pageUrlRetriever;
this.attachmentUrlRetriever = attachmentUrlRetriever;
}
public void GetTeamBySport_When_executed_create_list_of_Teams_bySport(int sportId, int expected)
{
// Insert seed data into the database using one instance of the context
InitializeSports();
LoadSports();
var repository = new ReferenceRepository(_context);
var actual = repository.GetTeamBySport(sportId);
Assert.Equal(expected, actual.Result.Count);
}
public override async ValueTask ReadAsync()
{
if (_reference is null)
{
if (GitRepository.TryReadRefFile(Path.Combine(ReferenceRepository.GitDir, Name), "ref: ", out var val))
{
_reference = val;
return;
}
_reference = await ReferenceRepository.ResolveAsync(this).ConfigureAwait(false);
}
}
public void GetLocationByLocationId_When_executed_return_Programs_for_id(int locationId, string locationName, string address)
{
// Insert seed data into the database using one instance of the context
InitializeSports();
LoadSports();
var repository = new ReferenceRepository(_context);
var actual = repository.GetLocationByLocationId(locationId);
Assert.Equal(locationName, actual.Result.Name);
Assert.Equal(address, actual.Result.Street);
}
public void SetUp()
{
// we will be modifying .git/config and need to completely reset each time
_referenceRepository = new ReferenceRepository();
foreach (var name in RemoteNames)
{
_referenceRepository.Module.AddRemote(name, $"http://localhost/remotes/{name}.git");
}
_commands = new GitUICommands(_referenceRepository.Module);
_remotesManager = new ConfigFileRemoteSettingsManager(() => _referenceRepository.Module);
}
public void GetSports_When_executed_create_list_of_Sport_with_Children()
{
// Insert seed data into the database using one instance of the context
InitializeSports();
LoadSports();
var repository = new ReferenceRepository(_context);
var actual = repository.GetSports();
Assert.Equal(3, actual.Result.Count);
Assert.Equal(2, actual.Result[0].Programs.Count);
}
public void SetUp()
{
if (_referenceRepository == null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_commands = new GitUICommands(_referenceRepository.Module);
}
public void SetUp()
{
if (_referenceRepository is null)
{
_referenceRepository = new ReferenceRepository();
AppSettings.LoadSettings();
}
else
{
_referenceRepository.Reset();
}
_commands = new GitUICommands(_referenceRepository.Module);
}
public void SetUp()
{
if (_referenceRepository is null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
ExportProvider mefExportProvider = TestComposition.Empty.ExportProviderFactory.CreateExportProvider();
ManagedExtensibility.SetTestExportProvider(mefExportProvider);
}
public void SetUp()
{
_originalDefaultPullAction = AppSettings.DefaultPullAction;
if (_referenceRepository == null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_commands = new GitUICommands(_referenceRepository.Module);
}
public void SetUp()
{
_referenceRepository = new ReferenceRepository();
_initialCommit = _referenceRepository.CommitHash;
_referenceRepository.CreateCommit("Commit1", "Commit1");
_branch1Commit = _referenceRepository.CommitHash;
_referenceRepository.CreateBranch("Branch1", _branch1Commit);
_referenceRepository.CreateCommit("Commit2", "Commit2");
_referenceRepository.CreateBranch("Branch2", _referenceRepository.CommitHash);
_referenceRepository.CreateCommit("head commit");
_headCommit = _referenceRepository.CommitHash;
_commands = new GitUICommands(_referenceRepository.Module);
}
public void SetUp()
{
if (_referenceRepository is null)
{
_referenceRepository = new ReferenceRepository();
}
else
{
_referenceRepository.Reset();
}
_commands = new GitUICommands(_referenceRepository.Module);
ExportProvider mefExportProvider = _composition.ExportProviderFactory.CreateExportProvider();
ManagedExtensibility.SetTestExportProvider(mefExportProvider);
}
public async Task <string> CompletePartialAndSaveResource(PartialUpload partialUploadDetails)
{
ReferenceRepository refRepository = new ReferenceRepository();
UserRepository ur = new UserRepository();
string currentUser = User.Identity.Name;
User user = ur.Get(currentUser);
Repository.ResourceRepository repository = new Repository.ResourceRepository();
string resourceTagID = repository.CompletePartialAndSaveResource(refRepository,
user,
partialUploadDetails.uploadID, partialUploadDetails.originalName,
partialUploadDetails.md5OfResource,
partialUploadDetails.partTags,
partialUploadDetails.totalSize);
return(resourceTagID);
}
public void GetSectors()
{
//Arrange
var logger = new Mock <ILogService>();
var repository = new ReferenceRepository(_connection, _mapper, logger.Object);
//Act
var sectors = repository.GetSectors();
//Assert
sectors.Should().NotBeNullOrEmpty();
sectors.Any(std => std.Id == 0 ||
string.IsNullOrWhiteSpace(std.Name) ||
!std.Standards.Any() ||
std.Standards.Any(x => x.ApprenticeshipSectorId != std.Id))
.Should().BeFalse();
}
public void AddSport_When_executed_add_sport()
{
var sport = new Sport()
{
Name = "Basketball"
};
var repository = new ReferenceRepository(_context);
var id = repository.AddSport(sport);
var sports = _context.Sport.ToListAsync();
Assert.Single(sports.Result);
Assert.True(sports.Result[0].Id > 0);
Assert.Equal(sport.Name, sports.Result[0].Name);
}
public ReferenceRepositoryTest()
{
_contractRepository = new Mock <IGenericRepository <ItContract> >();
_systemRepository = new Mock <IGenericRepository <ItSystem> >();
_systemUsageRepository = new Mock <IGenericRepository <ItSystemUsage> >();
_projectRepository = new Mock <IGenericRepository <ItProject> >();
_dpaRepository = new Mock <IGenericRepository <DataProcessingRegistration> >();
_sut = new ReferenceRepository
(
new Mock <IGenericRepository <ExternalReference> >().Object,
_contractRepository.Object,
_systemRepository.Object,
_systemUsageRepository.Object,
_projectRepository.Object,
_dpaRepository.Object
);
}
public void GetFrameworks()
{
//Arrange
var logger = new Mock <ILogService>();
var repository = new ReferenceRepository(_connection, _mapper, logger.Object);
//Act
var frameworks = repository.GetFrameworks();
//Assert
frameworks.Should().NotBeNullOrEmpty();
frameworks.Any(std => std.Id == 0 ||
string.IsNullOrWhiteSpace(std.CodeName) ||
string.IsNullOrWhiteSpace(std.FullName) ||
string.IsNullOrWhiteSpace(std.ShortName))
.Should().BeFalse();
}
public void AddLocation_When_executed_add_location()
{
var location = new Location()
{
Name = "Woodbridge",
SportId = 1
};
var repository = new ReferenceRepository(_context);
var id = repository.AddLocation(location);
var locations = _context.Location.ToListAsync();
Assert.Single(locations.Result);
Assert.True(locations.Result[0].Id > 0);
Assert.Equal(location.Name, locations.Result[0].Name);
}
public void Setup()
{
const string Code = @"namespace Test
{
using System;
public class TestClass
{
private object _number = new object();
public object GetNumber()
{
return _number;
}
}
}";
_solution = CreateSolution(Code);
_sut = new ReferenceRepository(_solution);
}
public void InitTest()
{
base.InitDbContext();
_repository = new UserRepository(this.DbFactory);
_referenceRepository = new ReferenceRepository(this.DbFactory);
}
