public Controller()
{
mockup.Add <IRepoFolderProvider>(s => new RepoFolderProvider(testFolder));
mockup.Add <GitReposController>(m => new GitReposController(m.Get <IGitRepoRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public SaverTests()
{
mockup.Add <TestTypeFinder>(s => new TestTypeFinder());
mockup.Add <Saver>(s => new Saver(s.Get <TestTypeFinder>()));
data = new SaveTest <int>()
{
TheProp = 6
};
}
public SchemaConfigurationBinderTests()
{
var builder = new ConfigurationBuilder();
mockup.Add <IConfiguration>(s =>
{
var mock = new Mock <IConfiguration>();
mock.Setup(i => i.GetSection(It.IsAny <String>())).Returns(s.Get <IConfigurationSection>());
mock.Setup(i => i[It.IsAny <String>()]).Returns("Hi");
return(mock.Object);
});
mockup.Add <SchemaConfigurationBinder>(s => new SchemaConfigurationBinder(s.Get <IConfiguration>()));
}
public JsonTestBase(T value)
{
mockup.Add <TestTypeFinder>(s => new TestTypeFinder());
mockup.Add <JsonSaver>(s => new JsonSaver(s.Get <TestTypeFinder>()));
filePath = $"../../../JsonSaverTests/Examples/{this.GetType().Name}.json";
writeFile = Directory.Exists(Path.GetDirectoryName(filePath));
data = new SaveTest <T>()
{
TheProp = value
};
}
public Controller()
{
mockup.Add <LeftsController>(m => new LeftsController(m.Get <ILeftRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public Controller()
{
mockup.Add <EntriesController>(m => new EntriesController(m.Get <IEntryRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public Controller()
{
mockup.Add <StoresController>(m => new StoresController(m.Get <IStoreRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public Controller()
{
mockup.Add <AuthorizedKeysController>(m => new AuthorizedKeysController(m.Get <IAuthorizedKeyRepository>(), m.Get <IAuthorizedKeysWriter>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public Controller()
{
mockup.Add <CategoriesController>(m => new CategoriesController(m.Get <ICategoryRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public Controller()
{
mockup.Add <ItemsController>(m => new ItemsController(m.Get <IItemRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public Controller()
{
mockup.Add <LotsaValuesController>(m => new LotsaValuesController(m.Get <IValueRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public Controller()
{
mockup.Add <RightsController>(m => new RightsController(m.Get <IRightRepository>())
{
ControllerContext = m.Get <ControllerContext>()
});
}
public BranchRepositoryTests()
{
mockup.Add <ICommitRepository>(s =>
{
var mock = new Mock <ICommitRepository>();
mock.Setup(i => i.HasUncommittedChanges()).Returns(false);
return(mock.Object);
});
mockup.MockServiceCollection.AddThreaxProcessHelper(o =>
{
o.IncludeLogOutput = false;
o.DecorateProcessRunner = r => new SpyProcessRunner(r)
{
Events = new ProcessEvents()
{
ErrorDataReceived = (o, e) => { if (e.DataReceivedEventArgs.Data != null)
{
Console.WriteLine(e.DataReceivedEventArgs.Data);
}
},
OutputDataReceived = (o, e) => { if (e.DataReceivedEventArgs.Data != null)
{
Console.WriteLine(e.DataReceivedEventArgs.Data);
}
},
}
};
});
basePath = this.GetType().Name;
}
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);
}
/// <summary>
/// Setup global shared mockups that can be used across may tests.
/// </summary>
/// <param name="mockup">The mockup class to configure.</param>
/// <returns>The passed in mockup test.</returns>
public static Mockup SetupGlobal(this Mockup mockup)
{
mockup.Add <IValidSchemaTypeManager>(s =>
{
var mock = new Mock <IValidSchemaTypeManager>();
mock.Setup(i => i.IsValid(It.IsAny <Type>())).Returns(true);
return(mock.Object);
});
mockup.Add <EndpointDocJsonSchemaGenerator>(s => new EndpointDocJsonSchemaGenerator(HalcyonConvention.DefaultJsonSchemaGeneratorSettings, s.Get <IValueProviderResolver>(), s.Get <ISchemaCustomizerResolver>(), s.Get <IAutoTitleGenerator>()));
mockup.Add <ISchemaBuilder>(s => new SchemaBuilder(s.Get <EndpointDocJsonSchemaGenerator>(), s.Get <IValidSchemaTypeManager>()));
mockup.Add <SchemaJsonConverter>(m => new SchemaJsonConverter());
mockup.Add <JsonSerializerSettings>(s =>
{
var settings = HalcyonConvention.DefaultJsonSerializerSettings;
settings.Formatting = Formatting.Indented; //Use indented for tests, makes test files easier to read
return(settings);
});
mockup.Add <JsonSerializer>(s => JsonSerializer.Create(s.Get <JsonSerializerSettings>()));
return(mockup);
}
/// <summary>
/// Setup global shared mockups that can be used across may tests.
/// </summary>
/// <param name="mockup">The mockup class to configure.</param>
/// <returns>The passed in mockup test.</returns>
public static Mockup SetupGlobal(this Mockup mockup)
{
mockup.MockServiceCollection.AddTimeTracking();
mockup.MockServiceCollection.AddAppMapper(includeAutomapperConfig: true);
mockup.Add <AppDbContext>(m => new AppDbContext(new DbContextOptionsBuilder <AppDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options));
mockup.Add <IIdentity>(m => CreateIdentity(Roles.DatabaseRoles()));
mockup.Add <ClaimsPrincipal>(m => new ClaimsPrincipal(m.Get <IIdentity>()));
mockup.Add <HttpContext>(m => new DefaultHttpContext()
{
User = m.Get <ClaimsPrincipal>()
});
mockup.Add <IHttpContextAccessor>(m => new HttpContextAccessor()
{
HttpContext = m.Get <HttpContext>()
});
mockup.Add <ControllerContext>(m => new ControllerContext()
{
HttpContext = m.Get <HttpContext>()
});
return(mockup);
}
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 JsonConfigIncluderTests()
{
mockup.Add <IConfigurationBuilder>(s =>
{
var mock = new Mock <IConfigurationBuilder>();
mock.Setup(i => i.Add(It.IsAny <IConfigurationSource>())).Callback <IConfigurationSource>((cs) =>
{
var jsonCs = cs as JsonConfigurationSource;
if (jsonCs != null)
{
sources.Add(jsonCs);
}
}).Returns(() => mock.Object);
return(mock.Object);
});
}
/// <summary>
/// Setup a IWebHost in the mocks. This will use the configuration files from the test project.
/// </summary>
/// <param name="mockup">The mockup class to configure.</param>
/// <returns>The passed in mockup test.</returns>
public static Mockup SetupWebHost(this Mockup mockup)
{
mockup.Add <IWebHost>(m =>
{
var hostBuilder = new WebHostBuilder()
.UseEnvironment("development")
.UseKestrel()
.UseStartup <Startup>()
.ConfigureAppConfiguration(configuration =>
{
configuration.Sources.Clear();
configuration.AddJsonFile("appsettings.json");
configuration.AddJsonFile("appsettings.Development.json");
});
return(hostBuilder.Build());
});
return(mockup);
}
public CreateIISWebConfigTests()
{
mockup.Add <BuildEventArgs>(s => new BuildEventArgs(s.Get <IBuildStatusTracker>(), s.Get <ISiteBuilder>(), s.Get <BuilderUserInfo>()));
}
private static Mockup SetupModel(this Mockup mockup)
{
mockup.Add <IGitRepoRepository>(m => new GitRepoRepository(m.Get <IRepoFolderProvider>(), m.Get <IClonePathBuilder>(), m.Get <IProcessRunner>()));
return(mockup);
}
private static Mockup SetupModel(this Mockup mockup)
{
mockup.Add <IValueRepository>(m => new ValueRepository(m.Get <AppDbContext>(), m.Get <AppMapper>()));
return(mockup);
}
public Repository()
{
mockup.Add <IRepoFolderProvider>(s => new RepoFolderProvider(testFolder));
}
public ReflectedServiceSetupTests()
{
mockup.Add <IServiceCollection>(s => new Mock <IServiceCollection>().Object);
}
