public async Task IsDisplayable_ManyDependencies()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppWithDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new ());
var fargateRecommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_ASPNET_CORE_FARGATE_RECIPE_ID);
var isDefaultOptionSetting = fargateRecommendation.GetOptionSetting("Vpc.IsDefault");
var createNewOptionSetting = fargateRecommendation.GetOptionSetting("Vpc.CreateNew");
var vpcIdOptionSetting = fargateRecommendation.GetOptionSetting("Vpc.VpcId");
// Before dependency aren't satisfied
Assert.False(fargateRecommendation.IsOptionSettingDisplayable(vpcIdOptionSetting));
// Satisfy dependencies
isDefaultOptionSetting.SetValueOverride(false);
Assert.False(fargateRecommendation.GetOptionSettingValue <bool>(isDefaultOptionSetting));
// Default value for Vpc.CreateNew already false, this is to show explicitly setting an override that satisfies Vpc Id option setting
createNewOptionSetting.SetValueOverride(false);
Assert.False(fargateRecommendation.GetOptionSettingValue <bool>(createNewOptionSetting));
// Verify
Assert.True(fargateRecommendation.IsOptionSettingDisplayable(vpcIdOptionSetting));
}
public async Task GetSortedProductsQuery_SortByRecommended()
{
//arrange
var sampleProducts = GetSampleProducts();
_mockProductsService.Setup(i => i.GetProducts()).ReturnsAsync(sampleProducts);
var sampleHistory = GetSampleHistory();
_mockProductsService.Setup(i => i.GetShopperHistory()).ReturnsAsync(sampleHistory);
var service = _mockProductsService.Object;
var engine = new RecommendationEngine(service);
var handler = new GetSortedProductsQueryHandler(service, engine);
var query = new GetSortedProductsQuery(SortOrder.Recommended);
//act
var results = await handler.Handle(query, default(CancellationToken));
//assert
_mockProductsService.Verify(i => i.GetProducts(), Times.Once, "Get Products Method should be invoked in produts service");
_mockProductsService.Verify(i => i.GetShopperHistory(), Times.Once, "Get history method should be invoked in products service");
//Assert that first item name is "Product 3" with most quantity
Assert.AreEqual(results.First().Name, "Product 3", "Product with name Product 3 should be the first product");
Assert.AreEqual(results.Last().Name, "Product 1", "Product with name Product 1 should be the last product");
}
public OrderService(EmailSender emailSender, ReceiptPrinter receiptPrinter, OrderDao orderDao, ReceiptDao receiptDao, RecommendationEngine recommendationEngine)
{
_emailSender = emailSender;
_receiptPrinter = receiptPrinter;
_orderDao = orderDao;
_receiptDao = receiptDao;
_recommendationEngine = recommendationEngine;
}
public SetOptionSettingTests()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = engine.ComputeRecommendations(projectPath, new Dictionary <string, string>()).GetAwaiter().GetResult();
_recommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
_optionSetting = _recommendation.Recipe.OptionSettings.First(x => x.Id.Equals("EnvironmentType"));
}
public async Task ValueMappingWithDefaultValue()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
var beanstalkRecommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
var environmentTypeOptionSetting = beanstalkRecommendation.Recipe.OptionSettings.First(optionSetting => optionSetting.Id.Equals("EnvironmentType"));
Assert.Equal("SingleInstance", beanstalkRecommendation.GetOptionSettingValue(environmentTypeOptionSetting, false));
}
public async Task GetOptionSettingTests_OptionSettingDoesNotExist(string jsonPath)
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
var beanstalkRecommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
var optionSetting = beanstalkRecommendation.GetOptionSetting(jsonPath);
Assert.Null(optionSetting);
}
public async Task BlazorWasmTest(string projectName)
{
var projectPath = SystemIOUtilities.ResolvePath(projectName);
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
var blazorRecommendation = recommendations.FirstOrDefault(r => r.Recipe.Id == Constants.BLAZOR_WASM);
Assert.NotNull(blazorRecommendation);
Assert.NotNull(blazorRecommendation.Recipe.DeploymentConfirmation.DefaultMessage);
}
public async Task ObjectMappingWithDefaultValue()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
var beanstalkRecommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
var applicationIAMRoleOptionSetting = beanstalkRecommendation.Recipe.OptionSettings.First(optionSetting => optionSetting.Id.Equals("ApplicationIAMRole"));
var iamRoleTypeHintResponse = beanstalkRecommendation.GetOptionSettingValue <IAMRoleTypeHintResponse>(applicationIAMRoleOptionSetting, false);
Assert.Null(iamRoleTypeHintResponse.RoleArn);
Assert.True(iamRoleTypeHintResponse.CreateNew);
}
public async Task ApplyApplicationIAMRolePreviousSettings(bool createNew, string roleArn)
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
var beanstalkRecommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
var roleArnValue = roleArn == null ? "null" : $"\"{roleArn}\"";
var serializedSettings = @$ "
{{
" "ApplicationIAMRole" ": {{
" "RoleArn" ": {roleArnValue},
public void GetRecommendations_Pivoted_PearsonSimilarity()
{
var data = TransformData(PCI_Data);
var engine = new RecommendationEngine();
var pivoted = engine.Pivot(data);
var target = pivoted.Single(x => x.Owner == "Just My Luck");
var result = engine.GetRecommendations(target, pivoted, PearsonCorrelation.Calculate);
Assert.That(result[0].Key, Is.EqualTo("Michael Phillips"));
Assert.That(result[0].Score, Is.EqualTo(4.0));
Assert.That(result[1].Key, Is.EqualTo("Jack Matthews"));
Assert.That(result[1].Score, Is.EqualTo(3.0));
}
public void ShouldIncludeTests(RuleEffect effect, bool testPass, bool expectedResult)
{
var awsCredentials = new Mock <AWSCredentials>();
var session = new OrchestratorSession(
null,
awsCredentials.Object,
"us-west-2",
"123456789012")
{
AWSProfileName = "default"
};
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, session);
Assert.Equal(expectedResult, engine.ShouldInclude(effect, testPass));
}
public async Task WebAppWithDockerFileTest()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppWithDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
recommendations
.Any(r => r.Recipe.Id == Constants.ASPNET_CORE_ASPNET_CORE_FARGATE_RECIPE_ID)
.ShouldBeTrue("Failed to receive Recommendation: " + Constants.ASPNET_CORE_ASPNET_CORE_FARGATE_RECIPE_ID);
recommendations
.Any(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID)
.ShouldBeTrue("Failed to receive Recommendation: " + Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
}
public async Task ApplyProjectNameToSettings()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
var beanstalkRecommendation = recommendations.FirstOrDefault(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
var beanstalEnvNameSetting = beanstalkRecommendation.Recipe.OptionSettings.FirstOrDefault(x => string.Equals("EnvironmentName", x.Id));
Assert.Equal("WebAppNoDockerFile-dev", beanstalkRecommendation.GetOptionSettingValue <string>(beanstalEnvNameSetting));
beanstalkRecommendation.OverrideProjectName("CustomName");
Assert.Equal("CustomName-dev", beanstalkRecommendation.GetOptionSettingValue <string>(beanstalEnvNameSetting));
}
public async Task MessageProcessingAppTest()
{
var projectPath = SystemIOUtilities.ResolvePath("MessageProcessingApp");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
recommendations
.Any(r => r.Recipe.Id == Constants.CONSOLE_APP_FARGATE_SERVICE_RECIPE_ID)
.ShouldBeTrue("Failed to receive Recommendation: " + Constants.CONSOLE_APP_FARGATE_SERVICE_RECIPE_ID);
recommendations
.Any(r => r.Recipe.Id == Constants.CONSOLE_APP_FARGATE_SCHEDULE_TASK_RECIPE_ID)
.ShouldBeTrue("Failed to receive Recommendation: " + Constants.CONSOLE_APP_FARGATE_SCHEDULE_TASK_RECIPE_ID);
}
public async Task DockerExecutionDirectory_DockerfileLevel()
{
var projectPath = SystemIOUtilities.ResolvePath("docker\\WebAppNoSolution");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, _session);
var recommendations = await engine.ComputeRecommendations(projectPath, new());
var recommendation = recommendations.FirstOrDefault(x => x.Recipe.DeploymentBundle.Equals(DeploymentBundleTypes.Container));
var cloudApplication = new CloudApplication {
Name = "WebAppNoSolution"
};
var result = await _deploymentBundleHandler.BuildDockerImage(cloudApplication, recommendation);
Assert.Equal(Path.GetFullPath(projectPath), recommendation.DeploymentBundle.DockerExecutionDirectory);
}
public async Task <ActionResult> RecommendGifts(string friendId, FacebookContext context)
{
if (!String.IsNullOrEmpty(friendId))
{
var friend = await context.Client.GetFacebookObjectAsync <MyAppUserFriend>(friendId);
if (friend != null)
{
var products = await RecommendationEngine.RecommendProductAsync(friend);
ViewBag.FriendName = friend.Name;
return(View(products));
}
}
return(View("Error"));
}
public void GetRecommendations_EuclideanDistance()
{
var transformedData = TransformData(PCI_Data);
var toby = TransformUser(PCI_Data, "Toby");
var engine = new RecommendationEngine();
var recommendations = engine.GetRecommendations(toby, transformedData, EuclideanDistanceTests.CalculateBroken);
Assert.That(recommendations[0].Key, Is.EqualTo("The Night Listener"));
Assert.That(recommendations[0].Score, Is.EqualTo(3.5002478401415877).Within(Delta), "Score for 'The Night Listener'");
Assert.That(recommendations[1].Key, Is.EqualTo("Lady in the Water"));
Assert.That(recommendations[1].Score, Is.EqualTo(2.7561242939959363).Within(Delta), "Score for 'Lady in the Water'");
Assert.That(recommendations[2].Key, Is.EqualTo("Just My Luck"));
Assert.That(recommendations[2].Score, Is.EqualTo(2.4619884860743739).Within(Delta), "Score for 'Just My Luck'");
}
public void GetRecommendations_PearsonSimilarity()
{
var transformedData = TransformData(PCI_Data);
var toby = TransformUser(PCI_Data, "Toby");
var engine = new RecommendationEngine();
var recommendations = engine.GetRecommendations(toby, transformedData, PearsonCorrelation.Calculate);
DebugPrint(recommendations);
Assert.That(recommendations[0].Key, Is.EqualTo("The Night Listener"));
Assert.That(recommendations[0].Score, Is.EqualTo(3.3477895267131013).Within(Delta), "Score for 'The Night Listener'");
Assert.That(recommendations[1].Key, Is.EqualTo("Lady in the Water"));
Assert.That(recommendations[1].Score, Is.EqualTo(2.8325499182641614).Within(Delta), "Score for 'Lady in the Water'");
Assert.That(recommendations[2].Key, Is.EqualTo("Just My Luck"));
Assert.That(recommendations[2].Score, Is.EqualTo(2.5309807037655645).Within(Delta), "Score for 'Just My Luck'");
}
public SetOptionSettingTests()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var parser = new ProjectDefinitionParser(new FileManager(), new DirectoryManager());
var awsCredentials = new Mock <AWSCredentials>();
var session = new OrchestratorSession(
parser.Parse(projectPath).Result,
awsCredentials.Object,
"us-west-2",
"123456789012")
{
AWSProfileName = "default"
};
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, session);
var recommendations = engine.ComputeRecommendations().GetAwaiter().GetResult();
_recommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
_optionSetting = _recommendation.Recipe.OptionSettings.First(x => x.Id.Equals("EnvironmentType"));
}
public async Task IsDisplayable_OneDependency()
{
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new());
var beanstalkRecommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_BEANSTALK_RECIPE_ID);
var environmentTypeOptionSetting = beanstalkRecommendation.Recipe.OptionSettings.First(optionSetting => optionSetting.Id.Equals("EnvironmentType"));
var loadBalancerTypeOptionSetting = beanstalkRecommendation.Recipe.OptionSettings.First(optionSetting => optionSetting.Id.Equals("LoadBalancerType"));
Assert.Equal("SingleInstance", beanstalkRecommendation.GetOptionSettingValue(environmentTypeOptionSetting));
// Before dependency isn't satisfied
Assert.False(beanstalkRecommendation.IsOptionSettingDisplayable(loadBalancerTypeOptionSetting));
// Satisfy dependency
environmentTypeOptionSetting.SetValueOverride("LoadBalanced");
Assert.Equal("LoadBalanced", beanstalkRecommendation.GetOptionSettingValue(environmentTypeOptionSetting));
// Verify
Assert.True(beanstalkRecommendation.IsOptionSettingDisplayable(loadBalancerTypeOptionSetting));
}
static void Main(string[] args)
{
Stopwatch w = new Stopwatch();
w.Start();
//IDataLoader loader = new CSVDataLoader();
//BookDetail bd = loader.Load();
string isbn = "0195153448";
RecommendationEngine engine = new RecommendationEngine();
IList <Book> books = engine.Recommend(new Preference {
ISBN = isbn, Age = 18, State = " california"
}, 10);
Console.WriteLine($"You Bought:\n {books[0].BookTitle} By {books[0].BookAuthor} ({books[0].Year})");
Console.WriteLine("------------------------------------------------------------------------------------------------");
books.Remove(books[0]);
Console.WriteLine("Recommended For You");
Console.WriteLine("------------------------------------------------------------------------------------------------");
foreach (Book b in books)
{
Console.WriteLine($"{b.BookTitle} by {b.BookAuthor} ({b.Year})\n");
}
Console.WriteLine("Obtained in: " + w.ElapsedMilliseconds + "ms");
}
public async Task ClearOptionSettingValue_String()
{
var interactiveServices = new TestToolInteractiveServiceImpl(new List <string>
{
"<reset>"
});
var consoleUtilities = new ConsoleUtilities(interactiveServices);
var projectPath = SystemIOUtilities.ResolvePath("WebAppNoDockerFile");
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
var recommendations = await engine.ComputeRecommendations(projectPath, new Dictionary <string, string>());
var fargateRecommendation = recommendations.First(r => r.Recipe.Id == Constants.ASPNET_CORE_ASPNET_CORE_FARGATE_RECIPE_ID);
var ecsServiceNameOptionSetting = fargateRecommendation.Recipe.OptionSettings.First(optionSetting => optionSetting.Id.Equals("ECSServiceName"));
var originalDefaultValue = fargateRecommendation.GetOptionSettingDefaultValue <string>(ecsServiceNameOptionSetting);
ecsServiceNameOptionSetting.SetValueOverride("TestService");
Assert.Equal("TestService", fargateRecommendation.GetOptionSettingValue <string>(ecsServiceNameOptionSetting));
ecsServiceNameOptionSetting.SetValueOverride(consoleUtilities.AskUserForValue("Title", "TestService", true, originalDefaultValue));
Assert.Equal(originalDefaultValue, fargateRecommendation.GetOptionSettingValue <string>(ecsServiceNameOptionSetting));
}
public void GetSimilar_PearsonSimilarity()
{
var transformedData = TransformData(PCI_Data);
var toby = TransformUser(PCI_Data, "Toby");
var engine = new RecommendationEngine();
var similarUsers = engine.GetSimilar(toby, transformedData, PearsonCorrelation.Calculate);
DebugPrint(similarUsers);
Assert.That(similarUsers[0].Key, Is.EqualTo("Lisa Rose"));
Assert.That(similarUsers[0].Score, Is.EqualTo(0.99124070716192991).Within(Delta), "Score for 'Lisa Rose'");
Assert.That(similarUsers[1].Key, Is.EqualTo("Mick LaSalle"));
Assert.That(similarUsers[1].Score, Is.EqualTo(0.92447345164190486).Within(Delta), "Score for 'Mick LaSelle'");
Assert.That(similarUsers[2].Key, Is.EqualTo("Claudia Puig"));
Assert.That(similarUsers[2].Score, Is.EqualTo(0.89340514744156476).Within(Delta), "Score for 'Claudia Puig'");
}
public void Pivot()
{
var data = TransformData(PCI_Data);
var engine = new RecommendationEngine();
var result = engine.Pivot(data);
var item = result.Single(x => x.Owner == "Snakes on a Plane");
// Original: Toby => Snakes on a Plane => 4.5
// New: Snakes on a Plane => Toby => 4.5
Assert.IsTrue(item.Ratings.Any(x => x.Key == "Toby" && x.Score == 4.5), "Missing score for 'Toby' under 'Snakes on a Plane'");
}
public void GetSimilar_Pivoted_PearsonSimilarity()
{
var data = TransformData(PCI_Data);
var engine = new RecommendationEngine();
var pivoted = engine.Pivot(data);
var target = pivoted.Single(x => x.Owner == "Superman Returns");
var result = engine.GetSimilar(target, pivoted, PearsonCorrelation.Calculate);
Assert.That(result[0].Key, Is.EqualTo("You, Me and Dupree"));
Assert.That(result[0].Score, Is.EqualTo(0.657).Within(0.001));
Assert.That(result[1].Key, Is.EqualTo("Lady in the Water"));
Assert.That(result[1].Score, Is.EqualTo(0.487).Within(0.001));
Assert.That(result[2].Key, Is.EqualTo("Snakes on a Plane"));
Assert.That(result[2].Score, Is.EqualTo(0.111).Within(0.001));
Assert.That(result[3].Key, Is.EqualTo("The Night Listener"));
Assert.That(result[3].Score, Is.EqualTo(-0.179).Within(0.001));
Assert.That(result[4].Key, Is.EqualTo("Just My Luck"));
Assert.That(result[4].Score, Is.EqualTo(-0.422).Within(0.001));
}
public void GetSimilar_EuclideanDistance()
{
var transformedData = TransformData(PCI_Data);
var toby = TransformUser(PCI_Data, "Lisa Rose");
var engine = new RecommendationEngine();
var similarUsers = engine.GetSimilar(toby, transformedData, EuclideanDistanceTests.CalculateBroken);
Assert.That(similarUsers[0].Key, Is.EqualTo("Michael Phillips"));
Assert.That(similarUsers[0].Score, Is.EqualTo(0.4444444444444444).Within(Delta), "Score for 'Michael Phillips'");
Assert.That(similarUsers[1].Key, Is.EqualTo("Mick LaSalle"));
Assert.That(similarUsers[1].Score, Is.EqualTo(0.3333333333333333).Within(Delta), "Score for 'Mick LaSelle'");
Assert.That(similarUsers[2].Key, Is.EqualTo("Claudia Puig"));
Assert.That(similarUsers[2].Score, Is.EqualTo(0.2857142857142857).Within(Delta), "Score for 'Claudia Puig'");
Assert.That(similarUsers[3].Key, Is.EqualTo("Toby"));
Assert.That(similarUsers[3].Score, Is.EqualTo(0.2222222222222222).Within(Delta), "Score for 'Toby'");
Assert.That(similarUsers[4].Key, Is.EqualTo("Jack Matthews"));
Assert.That(similarUsers[4].Score, Is.EqualTo(0.21052631578947367).Within(Delta), "Score for 'Jack Matthews'");
Assert.That(similarUsers[5].Key, Is.EqualTo("Gene Seymour"));
Assert.That(similarUsers[5].Score, Is.EqualTo(0.14814814814814814).Within(Delta), "Score for 'Gene Seymour'");
}
public void ShouldIncludeTests(RuleEffect effect, bool testPass, bool expectedResult)
{
var engine = new RecommendationEngine(new[] { RecipeLocator.FindRecipeDefinitionsPath() }, new Orchestrator.OrchestratorSession());
Assert.Equal(expectedResult, engine.ShouldInclude(effect, testPass));
}
