async Task Add()
{
SetTestPath();
var repo = mockup.Get <IGitRepoRepository>();
var result = await repo.Add(GitRepoTests.CreateInput("TestRepo"));
Assert.NotNull(result);
}
async Task List()
{
var totalItems = 3;
var controller = mockup.Get <LotsaValuesController>();
for (var i = 0; i < totalItems; ++i)
{
Assert.NotNull(await controller.Add(ValueTests.CreateInput()));
}
var query = new ValueQuery();
var result = await controller.List(query);
Assert.Equal(query.Limit, result.Limit);
Assert.Equal(query.Offset, result.Offset);
Assert.Equal(3, result.Total);
Assert.NotEmpty(result.Items);
}
async Task List()
{
SetTestPath();
var totalItems = 3;
var controller = mockup.Get <GitReposController>();
for (var i = 0; i < totalItems; ++i)
{
Assert.NotNull(await controller.Add(GitRepoTests.CreateInput($"Repo{i}")));
}
var query = new GitRepoQuery();
var result = await controller.List(query);
Assert.Equal(query.Limit, result.Limit);
Assert.Equal(query.Offset, result.Offset);
Assert.Equal(3, result.Total);
Assert.NotEmpty(result.Items);
}
private void TestConfig(BuildTaskDefinition taskDefinition, string fileName)
{
var args = mockup.Get <BuildEventArgs>();
var createConfig = new CreateIISWebConfig(taskDefinition);
createConfig.Execute(args);
var configText = outputStream.Contents;
FileUtils.WriteTestFile(typeof(CreateIISWebConfigTests), fileName, configText);
var expected = FileUtils.ReadTestFile(typeof(CreateIISWebConfigTests), fileName);
Assert.Equal(expected, configText);
}
protected virtual async Task CreateAsyncMocks()
{
mockup.Add <IValidSchemaTypeManager>(s =>
{
var mock = new Mock <IValidSchemaTypeManager>();
mock.Setup(i => i.IsValid(It.IsAny <Type>())).Returns(true);
return(mock.Object);
});
mockup.Add <JsonSchemaGenerator>(s => new JsonSchemaGenerator(HalcyonConvention.DefaultJsonSchemaGeneratorSettings));
mockup.Add <ISchemaBuilder>(s => new SchemaBuilder(s.Get <JsonSchemaGenerator>(), s.Get <IValidSchemaTypeManager>()));
//This is setup outside the mock callbacks, so we can do async properly
//The get must be after the registrations
EndpointClientDefinition endpoint = null;
mockup.TryAdd <IClientGenerator>(s =>
{
if (endpoint == null)
{
throw new InvalidOperationException("This should not happen. EndpointClientDefinition not yet resolved and is null.");
}
var mock = new Mock <IClientGenerator>();
IEnumerable <EndpointClientDefinition> mockEndpoints = new List <EndpointClientDefinition>()
{
endpoint
};
mock.Setup(i => i.GetEndpointDefinitions()).Returns(Task.FromResult(mockEndpoints));
return(mock.Object);
});
var schemaBuilder = mockup.Get <ISchemaBuilder>();
endpoint = await CreateEndpointDefinition(schemaBuilder);
}
public void ManualMock()
{
var mockup = new Mockup();
mockup.Add <ITestInterface>(s =>
{
var mock = new Mock <ITestInterface>();
mock.Setup(i => i.DoSomething())
.Returns(true);
return(mock.Object);
});
var testInterface = mockup.Get <ITestInterface>();
Assert.True(testInterface.DoSomething());
}
public void MockOverride()
{
//This test just uses exception classes due to easy inheritance
//not because it actually is exception based
var mockup = new Mockup();
mockup.Add <Exception>(s =>
{
return(new InvalidCastException());
});
mockup.Add <Exception>(s =>
{
return(new InvalidOperationException());
});
var test = mockup.Get <Exception>();
Assert.IsType <InvalidOperationException>(test);
}
public async Task EmptySchema()
{
var binder = mockup.Get <SchemaConfigurationBinder>();
var json = await binder.CreateSchema();
if (WriteTestFiles)
{
FileUtils.WriteTestFile(this.GetType(), "EmptySchema.json", json);
}
Assert.Equal(FileUtils.ReadTestFile(this.GetType(), "EmptySchema.json"), json);
}
public void Valid()
{
mockup.Get <MapperConfiguration>().AssertConfigurationIsValid();
}
public void Test()
{
ReflectedServiceSetup.ConfigureReflectedServices(mockup.Get <IServiceCollection>(), this.GetType().Assembly);
Assert.True(ReflectedServiceSetupTests.CalledConfigureServices, $"Did not call configure services, could not find {nameof(ServiceSetup)}");
}
public ServicePrincipalManagerTests(ITestOutputHelper output)
{
mockup.AddCommonMockups(output);
config = mockup.Get <Config>();
}
public void SetSubscription()
{
var accountManager = mockup.Get <IAccountManager>();
accountManager.SetSubscription("Visual Studio Professional");
}
public KeyVaultManagerTests(ITestOutputHelper output)
{
mockup.AddCommonMockups(output);
config = mockup.Get <Config>();
}
public async Task CreateAcr()
{
var manager = new AcrManager(mockup.Get <IShellRunner>());
await manager.Create(TestAcr, TestRg, TestRegion, "Basic");
}
public SubscriptionManagerTests(ITestOutputHelper output)
{
mockup.AddCommonMockups(output);
config = mockup.Get <Config>();
}
public ArmTemplateManagerTests(ITestOutputHelper output)
{
mockup.AddCommonMockups(output);
config = mockup.Get <Config>();
}
public void Echo()
{
var processRunner = new LoggingProcessRunner <LoggingProcessRunnerTests>(new ProcessRunner(), mockup.Get <ILogger <LoggingProcessRunnerTests> >());
var startInfo = new ProcessStartInfo("pwsh", "-c 'hi'");
var result = processRunner.Run(startInfo);
Assert.Equal(0, result);
}
public async Task RunProcessCommandsVoidSecurityCheck()
{
var runner = mockup.Get <IShellRunner>();
var builder = runner.CreateCommandBuilder();
var evil = "exit 44;";
builder.AddCommand($"'Before'");
builder.AddResultCommand($"{evil}");
builder.AddCommand($"'After'");
await runner.RunProcessVoidAsync(builder);
}
public void GetCurrentMaster()
{
using (var dir = new SelfDeletingDirectory(Path.GetFullPath(Path.Combine(basePath, nameof(this.GetCurrentMaster)))))
{
Repository.Init(dir.Path, false);
using (var repo = new Repository(dir.Path))
{
var testFilePath = Path.Combine(dir.Path, "test.txt");
File.WriteAllText(testFilePath, "Some test data.");
Commands.Stage(repo, testFilePath);
var signature = new Signature("Test Bot", "*****@*****.**", DateTime.Now);
repo.Commit("Added test data", signature, signature);
var branchRepo = new BranchRepository(repo, mockup.Get <ICommitRepository>());
var current = branchRepo.GetCurrent();
Assert.Equal("master", current.FriendlyName);
Assert.Equal("refs/heads/master", current.CanonicalName);
}
}
}
